Add Temperature Override feature with validation and tests

Author: d-oit

package.json

@@ -270,7 +270,12 @@
 		"configuration": {
 			"title": "Roo Code",
 			"properties": {
-				"roo-cline.allowedCommands": {
+				"roo-code.enableTemperatureOverride": {
+					"type": "boolean",
+					"default": true,
+					"description": "Enable temperature override using @customTemperature syntax"
+				},
+				"roo-code.allowedCommands": {
 					"type": "array",
 					"items": {
 						"type": "string"

src/core/Cline.ts

@@ -12,6 +12,7 @@ import getFolderSize from "get-folder-size"
 import { serializeError } from "serialize-error"
 import * as vscode from "vscode"
 
+import { TemperatureOverrideService } from "./services/TemperatureOverrideService"
 import { TokenUsage } from "../schemas"
 import { ApiHandler, buildApiHandler } from "../api"
 import { ApiStream } from "../api/transform/stream"
@@ -31,7 +32,7 @@ import { TerminalRegistry } from "../integrations/terminal/TerminalRegistry"
 import { UrlContentFetcher } from "../services/browser/UrlContentFetcher"
 import { listFiles } from "../services/glob/list-files"
 import { CheckpointStorage } from "../shared/checkpoints"
-import { ApiConfiguration } from "../shared/api"
+import { ApiConfiguration, ApiHandlerOptions } from "../shared/api"
 import { findLastIndex } from "../shared/array"
 import { combineApiRequests } from "../shared/combineApiRequests"
 import { combineCommandSequences } from "../shared/combineCommandSequences"
@@ -119,6 +120,9 @@ export class Cline extends EventEmitter<ClineEvents> {
 	readonly taskId: string
 	readonly instanceId: string
 
+	private tempOverrideService: TemperatureOverrideService
+	private originalTemp?: number
+
 	readonly rootTask: Cline | undefined = undefined
 	readonly parentTask: Cline | undefined = undefined
 	readonly taskNumber: number
@@ -197,6 +201,8 @@ export class Cline extends EventEmitter<ClineEvents> {
 			throw new Error("Either historyItem or task/images must be provided")
 		}
 
+		this.tempOverrideService = new TemperatureOverrideService()
+
 		this.rooIgnoreController = new RooIgnoreController(this.cwd)
 		this.rooIgnoreController.initialize().catch((error) => {
 			console.error("Failed to initialize RooIgnoreController:", error)
@@ -861,6 +867,42 @@ export class Cline extends EventEmitter<ClineEvents> {
 	}
 
 	private async initiateTaskLoop(userContent: UserContent): Promise<void> {
+		// Handle temperature override if present
+		try {
+			const firstBlock = userContent[0]
+			if (firstBlock.type === "text") {
+				const tempOverride = this.tempOverrideService.parseAndApplyOverride(
+					firstBlock.text || "",
+					this.apiConfiguration.modelTemperature || 0,
+				)
+
+				if (tempOverride) {
+					// Store original temp for restoration
+					this.originalTemp = tempOverride.originalTemp
+
+					// Apply override to apiConfiguration
+					this.apiConfiguration.modelTemperature = tempOverride.temperature
+
+					// For providers using direct options access (like MistralHandler)
+					// we need to update both the configuration and the provider's copy of options
+					if (this.api && "options" in this.api) {
+						// Use type assertion since we know these providers have options
+						const provider = this.api as { options: ApiHandlerOptions }
+						// Update the provider's copy of options
+						provider.options.modelTemperature = tempOverride.temperature
+					}
+
+					firstBlock.text = tempOverride.cleanedInput
+				}
+			}
+		} catch (error) {
+			await this.say(
+				"error",
+				`Temperature override error: ${error instanceof Error ? error.message : String(error)}`,
+			)
+			return
+		}
+
 		// Kicks off the checkpoints initialization process in the background.
 		this.getCheckpointService()
 
@@ -893,6 +935,20 @@ export class Cline extends EventEmitter<ClineEvents> {
 				this.consecutiveMistakeCount++
 			}
 		}
+
+		// Restore original temperature if override was applied
+		if (this.originalTemp !== undefined) {
+			// Restore both apiConfiguration and provider options
+			this.apiConfiguration.modelTemperature = this.originalTemp
+
+			// Also restore provider's copy if it exists
+			if (this.api && "options" in this.api) {
+				const provider = this.api as { options: ApiHandlerOptions }
+				provider.options.modelTemperature = this.originalTemp
+			}
+
+			this.originalTemp = undefined
+		}
 	}
 
 	async abortTask(isAbandoned = false) {

src/core/__mocks__/telemetry/TelemetryService.ts

@@ -0,0 +1,6 @@
+export const telemetryService = {
+	captureTaskCreated: jest.fn(),
+	captureTaskRestarted: jest.fn(),
+	captureTaskCompleted: jest.fn(),
+	captureError: jest.fn(),
+}

src/core/__tests__/TempOverrideIntegration.test.ts

@@ -0,0 +1,231 @@
+import { Cline } from "../Cline"
+import { ClineProvider } from "../webview/ClineProvider"
+import { TemperatureOverrideService } from "../services/TemperatureOverrideService"
+import * as vscode from "vscode"
+
+// Mock dependencies
+jest.mock("../webview/ClineProvider")
+jest.mock("../services/TemperatureOverrideService")
+jest.mock("../ignore/RooIgnoreController")
+
+// Mock storagePathManager to avoid file system errors
+jest.mock("../../shared/storagePathManager", () => ({
+	getStorageBasePath: jest.fn().mockReturnValue("/mock/storage/path"),
+	getTaskDirectoryPath: jest.fn().mockReturnValue("/mock/task/path"),
+	ensureDirectoryExists: jest.fn().mockResolvedValue(true),
+}))
+
+// More complete vscode mock
+jest.mock("vscode", () => ({
+	workspace: {
+		getConfiguration: jest.fn().mockReturnValue({
+			get: jest.fn().mockReturnValue(true),
+		}),
+		createFileSystemWatcher: jest.fn().mockReturnValue({
+			onDidChange: jest.fn(),
+			onDidCreate: jest.fn(),
+			onDidDelete: jest.fn(),
+			dispose: jest.fn(),
+		}),
+	},
+	window: {
+		createTextEditorDecorationType: jest.fn().mockReturnValue({
+			dispose: jest.fn(),
+		}),
+		showErrorMessage: jest.fn(),
+		tabGroups: {
+			all: [],
+		},
+	},
+	env: {
+		language: "en",
+	},
+	RelativePattern: jest.fn().mockImplementation(() => ({})),
+}))
+
+describe("Temperature Override Integration", () => {
+	let cline: Cline
+	let mockProvider: jest.Mocked<ClineProvider>
+	let mockGetConfig: jest.Mock
+	let mockTempOverrideService: jest.Mocked<TemperatureOverrideService>
+	let mockApi: any
+	const defaultTemp = 0
+	beforeEach(() => {
+		// Reset mocks
+		jest.clearAllMocks()
+
+		mockProvider = {
+			context: {
+				globalStorageUri: { fsPath: "/test/storage" },
+			},
+			postStateToWebview: jest.fn(),
+			postMessageToWebview: jest.fn(),
+			log: jest.fn(),
+			getState: jest.fn().mockReturnValue({
+				terminalOutputLineLimit: 100,
+				maxWorkspaceFiles: 50,
+			}),
+		} as any
+
+		mockGetConfig = jest.fn().mockReturnValue(true)
+		;(vscode.workspace.getConfiguration as jest.Mock).mockImplementation(() => ({
+			get: mockGetConfig,
+		}))
+
+		// Mock the TemperatureOverrideService
+		mockTempOverrideService = {
+			parseAndApplyOverride: jest.fn().mockImplementation((input, currentTemp) => {
+				// Check configuration like the real service does
+				const config = vscode.workspace.getConfiguration("roo-cline")
+				if (!config.get<boolean>("enableTemperatureOverride", true)) {
+					return null
+				}
+
+				if (input.startsWith("@customTemperature:")) {
+					const match = input.match(/^@customTemperature:([^ ]*)/)
+					if (match && match[1] === "0.9") {
+						// Preserve leading whitespace after command like real service
+						return {
+							temperature: 0.9,
+							originalTemp: currentTemp,
+							cleanedInput: input.substring(match[0].length),
+						}
+					}
+				}
+				return null
+			}),
+		} as any
+
+		// Set up the mock behavior for the disabled test
+		;(TemperatureOverrideService as jest.Mock).mockImplementation(() => mockTempOverrideService)
+
+		// Mock console.error to reduce test noise
+		jest.spyOn(console, "error").mockImplementation(() => {})
+
+		// Create mock API with options property
+		mockApi = {
+			options: {
+				modelTemperature: defaultTemp,
+			},
+		}
+
+		cline = new Cline({
+			provider: mockProvider,
+			apiConfiguration: {
+				modelTemperature: defaultTemp,
+			},
+			task: "test task",
+		})
+
+		// Mock the API handler
+		Object.defineProperty(cline, "api", {
+			get: () => mockApi,
+		})
+
+		// Mock providerRef.deref() to return our mockProvider with getState
+		Object.defineProperty(cline, "providerRef", {
+			get: () => ({
+				deref: () => mockProvider,
+			}),
+		})
+	})
+
+	afterEach(() => {
+		jest.restoreAllMocks()
+	})
+
+	describe("initiateTaskLoop", () => {
+		it("should not process temperature override when disabled", async () => {
+			// Setup the mock to return null for this specific test
+			jest.spyOn(mockTempOverrideService, "parseAndApplyOverride").mockReturnValue(null)
+
+			const userContent = [
+				{
+					type: "text" as const,
+					text: "@customTemperature:0.9 Do something",
+				},
+			]
+
+			// @ts-ignore - accessing private method for testing
+			await cline.initiateTaskLoop(userContent)
+
+			expect(cline.apiConfiguration.modelTemperature).toBe(defaultTemp)
+			expect(userContent[0].text).toBe("@customTemperature:0.9 Do something")
+		})
+
+		it("should apply temperature override when enabled", async () => {
+			const userContent = [
+				{
+					type: "text" as const,
+					text: "@customTemperature:0.9 Do something",
+				},
+			]
+
+			// @ts-ignore - accessing private method for testing
+			await cline.initiateTaskLoop(userContent)
+
+			expect(cline.apiConfiguration.modelTemperature).toBe(0.9) // Should be set to the override value
+			expect(userContent[0].text).toBe(" Do something") // Should preserve leading space like real service
+			expect(mockGetConfig).toHaveBeenCalledWith("enableTemperatureOverride", true)
+		})
+
+		it("should handle invalid temperature override gracefully", async () => {
+			const userContent = [
+				{
+					type: "text" as const,
+					text: "@customTemperature:3.0 Do something",
+				},
+			]
+
+			// @ts-ignore - accessing private method for testing
+			await cline.initiateTaskLoop(userContent)
+
+			// Should not modify temperature when invalid
+			expect(cline.apiConfiguration.modelTemperature).toBe(defaultTemp)
+			expect(userContent[0].text).toBe("@customTemperature:3.0 Do something")
+		})
+
+		it("should handle image blocks without error", async () => {
+			const userContent = [
+				{
+					type: "image" as const,
+					source: "data:image/png;base64,...",
+				},
+			]
+
+			// @ts-ignore - accessing private method for testing
+			await cline.initiateTaskLoop(userContent)
+
+			expect(cline.apiConfiguration.modelTemperature).toBe(defaultTemp)
+		})
+
+		// Additional test for provider with direct options access
+		it("should update and restore provider options for handlers with direct access", async () => {
+			const userContent = [
+				{
+					type: "text" as const,
+					text: "@customTemperature:0.9 Do something",
+				},
+			]
+
+			// @ts-ignore - accessing private method for testing
+			await cline.initiateTaskLoop(userContent)
+
+			// Check both apiConfiguration and provider options are updated
+			expect(cline.apiConfiguration.modelTemperature).toBe(0.9)
+			expect(mockApi.options.modelTemperature).toBe(0.9)
+
+			// @ts-ignore - accessing private property for testing
+			expect(cline.originalTemp).toBe(defaultTemp)
+
+			// Call abortTask which restores temperature
+			await cline.abortTask()
+
+			// Check both are restored
+			expect(cline.apiConfiguration.modelTemperature).toBe(defaultTemp)
+			expect(mockApi.options.modelTemperature).toBe(defaultTemp)
+			// @ts-ignore - accessing private property for testing
+			expect(cline.originalTemp).toBeUndefined()
+		})
+	})
+})