test(browser): add compatibility helper and tests; include new files in build

Author: hannesrudolph

src/core/webview/__tests__/generateSystemPrompt.browser-capability.spec.ts

@@ -0,0 +1,85 @@
+import { describe, test, expect, vi } from "vitest"
+
+// Module under test
+import { generateSystemPrompt } from "../generateSystemPrompt"
+
+// Mock SYSTEM_PROMPT to capture its third argument (browser capability flag)
+vi.mock("../../prompts/system", () => ({
+	SYSTEM_PROMPT: vi.fn(async (_ctx, _cwd, canUseBrowserTool: boolean) => {
+		// return a simple string to satisfy return type
+		return `SYSTEM_PROMPT:${canUseBrowserTool}`
+	}),
+}))
+
+// Mock API handler so we control model.info flags
+vi.mock("../../api", () => ({
+	buildApiHandler: vi.fn((_config) => ({
+		getModel: () => ({
+			id: "mock-model",
+			info: {
+				// New world: supportsImages controls browser capability
+				supportsImages: true,
+				// Legacy flag explicitly false to validate backward-compat behavior
+				supportsComputerUse: false,
+				contextWindow: 200_000,
+				maxTokens: 8192,
+				supportsPromptCache: false,
+			},
+		}),
+	})),
+}))
+
+// Minimal mode utilities: provide a custom mode that includes the "browser" group
+const mockCustomModes = [
+	{
+		slug: "test-mode",
+		label: "Test Mode",
+		description: "",
+		groups: [{ id: "browser" }], // critical: include browser group
+	},
+]
+
+// Minimal ClineProvider stub
+function makeProviderStub() {
+	return {
+		cwd: "/tmp",
+		context: {} as any,
+		customModesManager: {
+			getCustomModes: async () => mockCustomModes,
+		},
+		getCurrentTask: () => ({
+			rooIgnoreController: { getInstructions: () => undefined },
+		}),
+		getMcpHub: () => undefined,
+		// State must enable browser tool and provide apiConfiguration
+		getState: async () => ({
+			apiConfiguration: {
+				apiProvider: "openrouter", // not used by the test beyond handler creation
+			},
+			customModePrompts: undefined,
+			customInstructions: undefined,
+			browserViewportSize: "900x600",
+			diffEnabled: false,
+			mcpEnabled: false,
+			fuzzyMatchThreshold: 1.0,
+			experiments: {},
+			enableMcpServerCreation: false,
+			browserToolEnabled: true, // critical: enabled in settings
+			language: "en",
+			maxReadFileLine: -1,
+			maxConcurrentFileReads: 5,
+		}),
+	} as any
+}
+
+describe("generateSystemPrompt browser capability (supportsImages=true, supportsComputerUse=false)", () => {
+	test("passes canUseBrowserTool=true when mode has browser group and setting enabled", async () => {
+		const provider = makeProviderStub()
+		const message = { mode: "test-mode" } as any
+
+		const result = await generateSystemPrompt(provider, message)
+
+		// SYSTEM_PROMPT mock encodes the boolean into the returned string
+		expect(result).toBe("SYSTEM_PROMPT:true")
+	})
+})

src/shared/__tests__/browserCapability.spec.ts

@@ -0,0 +1,18 @@
+import { describe, test, expect } from "vitest"
+import { modelSupportsBrowserCapability } from "../browserCapability"
+
+describe("modelSupportsBrowserCapability", () => {
+	test("enables when supportsImages=true and supportsComputerUse=false/absent", () => {
+		expect(modelSupportsBrowserCapability({ supportsImages: true } as any)).toBe(true)
+		expect(modelSupportsBrowserCapability({ supportsImages: true, supportsComputerUse: false } as any)).toBe(true)
+	})
+
+	test("enables when supportsComputerUse=true even if supportsImages=false", () => {
+		expect(modelSupportsBrowserCapability({ supportsImages: false, supportsComputerUse: true } as any)).toBe(true)
+	})
+
+	test("disabled when both flags are false or missing", () => {
+		expect(modelSupportsBrowserCapability({ supportsImages: false } as any)).toBe(false)
+		expect(modelSupportsBrowserCapability({} as any)).toBe(false)
+	})
+})

src/shared/browserCapability.ts

@@ -0,0 +1,18 @@
+import type { ModelInfo } from "@roo-code/types"
+import type { ProviderSettings } from "@roo-code/types"
+
+/**
+ * Temporary compatibility helper for determining whether the browser tool
+ * should be considered supported by a model.
+ *
+ * During the transition away from supportsComputerUse, we treat models as
+ * browser-capable if either:
+ * - supportsImages === true (new behavior), OR
+ * - supportsComputerUse === true (legacy behavior present in some providers)
+ */
+export function modelSupportsBrowserCapability(model: ModelInfo, _settings?: ProviderSettings): boolean {
+	const supportsImages = (model as any)?.supportsImages === true
+	// Legacy flag may still exist in some model tables or be read from older code paths
+	const legacyComputerUse = (model as any)?.supportsComputerUse === true
+	return supportsImages || legacyComputerUse
+}