Merge branch 'main' into issue/368

Author: navedmerchant

packages/types/src/providers/friendli.ts

@@ -20,6 +20,8 @@ export const friendliModels = {
 		outputPrice: 4.4,
 		cacheWritesPrice: 0,
 		cacheReadsPrice: 0.26,
+		supportsReasoningEffort: ["minimal", "low", "medium", "high", "xhigh", "max"],
+		reasoningEffort: "high",
 		description:
 			"GLM-5.2 is Zhipu's flagship model with a 1M context window and 128k max output, served via Friendli Model APIs. It delivers top-tier long-context reasoning, coding, and agentic performance for extended engineering sessions.",
 	},
@@ -33,6 +35,8 @@ export const friendliModels = {
 		outputPrice: 4.4,
 		cacheWritesPrice: 0,
 		cacheReadsPrice: 0.26,
+		supportsReasoningEffort: ["minimal", "low", "medium", "high", "xhigh", "max"],
+		reasoningEffort: "high",
 		description:
 			"GLM-5.1 is Zhipu's most capable model with a 200k context window and 128k max output, served via Friendli Model APIs. It delivers top-tier reasoning, coding, and agentic performance.",
 	},

src/activate/__tests__/registerCommands.spec.ts

@@ -2,7 +2,7 @@ import type { Mock } from "vitest"
 import * as vscode from "vscode"
 import { ClineProvider } from "../../core/webview/ClineProvider"
 
-import { getVisibleProviderOrLog, registerCommands, setPanel } from "../registerCommands"
+import { getVisibleProviderOrLog, openClineInNewTab, registerCommands, setPanel } from "../registerCommands"
 
 vi.mock("execa", () => ({
 	execa: vi.fn(),
@@ -13,8 +13,16 @@ vi.mock("vscode", () => ({
 		QuickFix: { value: "quickfix" },
 		RefactorRewrite: { value: "refactor.rewrite" },
 	},
+	Uri: {
+		joinPath: vi.fn((_base: unknown, ..._pathSegments: string[]) => ({ path: _pathSegments.join("/") })),
+	},
+	ViewColumn: {
+		Two: 2,
+	},
 	window: {
 		createTextEditorDecorationType: vi.fn().mockReturnValue({ dispose: vi.fn() }),
+		createWebviewPanel: vi.fn(),
+		visibleTextEditors: [],
 	},
 	workspace: {
 		workspaceFolders: [
@@ -367,3 +375,53 @@ describe("registerCommands handlers", () => {
 		await handlers["zoo-code.plusButtonClicked"]()
 	})
 })
+
+describe("openClineInNewTab", () => {
+	let mockOutputChannel: vscode.OutputChannel
+	let mockContext: vscode.ExtensionContext
+
+	beforeEach(() => {
+		vi.clearAllMocks()
+
+		mockOutputChannel = {
+			appendLine: vi.fn(),
+			append: vi.fn(),
+			clear: vi.fn(),
+			hide: vi.fn(),
+			name: "mock",
+			replace: vi.fn(),
+			show: vi.fn(),
+			dispose: vi.fn(),
+		}
+
+		mockContext = {
+			subscriptions: [],
+			extensionUri: { path: "/mock/ext" },
+		} as unknown as vscode.ExtensionContext
+
+		const mockPanel = {
+			webview: { postMessage: vi.fn() },
+			onDidChangeViewState: vi.fn(),
+			onDidDispose: vi.fn(),
+		}
+		;(vscode.window.createWebviewPanel as Mock).mockReturnValue(mockPanel)
+
+		// Reset module-level panel state.
+		setPanel(undefined, "sidebar")
+		setPanel(undefined, "tab")
+	})
+
+	it("creates a webview panel with title 'Zoo Code'", async () => {
+		await openClineInNewTab({ context: mockContext, outputChannel: mockOutputChannel })
+
+		expect(vscode.window.createWebviewPanel).toHaveBeenCalledWith(
+			"zoo-code.TabPanelProvider",
+			"Zoo Code",
+			expect.any(Number),
+			expect.objectContaining({
+				enableScripts: true,
+				retainContextWhenHidden: true,
+			}),
+		)
+	})
+})

src/activate/registerCommands.ts

@@ -251,7 +251,7 @@ export const openClineInNewTab = async ({ context, outputChannel }: Omit<Registe
 
 	const targetCol = hasVisibleEditors ? Math.max(lastCol + 1, 1) : vscode.ViewColumn.Two
 
-	const newPanel = vscode.window.createWebviewPanel(ClineProvider.tabPanelId, "Roo Code", targetCol, {
+	const newPanel = vscode.window.createWebviewPanel(ClineProvider.tabPanelId, "Zoo Code", targetCol, {
 		enableScripts: true,
 		retainContextWhenHidden: true,
 		localResourceRoots: [context.extensionUri],

src/api/providers/__tests__/friendli.spec.ts

@@ -142,7 +142,16 @@ describe("FriendliHandler", () => {
 		},
 	])(
 		"should expose newly added model $modelId",
-		({ modelId, contextWindow, maxTokens, supportsMaxTokens, inputPrice, outputPrice, cacheWritesPrice, cacheReadsPrice }) => {
+		({
+			modelId,
+			contextWindow,
+			maxTokens,
+			supportsMaxTokens,
+			inputPrice,
+			outputPrice,
+			cacheWritesPrice,
+			cacheReadsPrice,
+		}) => {
 			expect(friendliModels[modelId]).toBeDefined()
 			const info = friendliModels[modelId] as import("@roo-code/types").ModelInfo
 			expect(info.maxTokens).toBe(maxTokens)
@@ -394,3 +403,217 @@ describe("Friendli model max output tokens (clamping behavior)", () => {
 		expect(result).toBe(80_000)
 	})
 })
+
+describe("FriendliHandler — Friendli-specific reasoning params", () => {
+	beforeEach(() => {
+		vi.clearAllMocks()
+	})
+
+	it("should include reasoning_effort, chat_template_kwargs, parse_reasoning for GLM-5.2 with reasoning enabled", async () => {
+		const handler = new FriendliHandler({
+			apiModelId: "zai-org/GLM-5.2",
+			friendliApiKey: "test-key",
+			enableReasoningEffort: true,
+			reasoningEffort: "high",
+		})
+
+		mockCreate.mockImplementationOnce(() => ({
+			[Symbol.asyncIterator]: () => ({
+				async next() {
+					return { done: true }
+				},
+			}),
+		}))
+
+		await handler.createMessage("system", []).next()
+
+		expect(mockCreate).toHaveBeenCalledWith(
+			expect.objectContaining({
+				model: "zai-org/GLM-5.2",
+				reasoning_effort: "high",
+				chat_template_kwargs: { enable_thinking: true },
+				parse_reasoning: true,
+				include_reasoning: true,
+			}),
+			undefined,
+		)
+	})
+
+	it("should send enable_thinking: false when enableReasoningEffort is false on controllable model", async () => {
+		const handler = new FriendliHandler({
+			apiModelId: "zai-org/GLM-5.2",
+			friendliApiKey: "test-...ey",
+			enableReasoningEffort: false,
+		})
+
+		mockCreate.mockImplementationOnce(() => ({
+			[Symbol.asyncIterator]: () => ({
+				async next() {
+					return { done: true }
+				},
+			}),
+		}))
+
+		await handler.createMessage("system", []).next()
+
+		const callArgs = mockCreate.mock.calls[0][0] as Record<string, unknown>
+		expect(callArgs.reasoning_effort).toBeUndefined()
+		expect(callArgs.chat_template_kwargs).toEqual({ enable_thinking: false })
+		expect(callArgs.parse_reasoning).toBeUndefined()
+		expect(callArgs.include_reasoning).toBeUndefined()
+	})
+
+	it("should send enable_thinking: false when reasoningEffort is none on controllable model", async () => {
+		const handler = new FriendliHandler({
+			apiModelId: "zai-org/GLM-5.2",
+			friendliApiKey: "test-...ey",
+			enableReasoningEffort: true,
+			reasoningEffort: "none",
+		})
+
+		mockCreate.mockImplementationOnce(() => ({
+			[Symbol.asyncIterator]: () => ({
+				async next() {
+					return { done: true }
+				},
+			}),
+		}))
+
+		await handler.createMessage("system", []).next()
+
+		const callArgs = mockCreate.mock.calls[0][0] as Record<string, unknown>
+		expect(callArgs.reasoning_effort).toBeUndefined()
+		expect(callArgs.chat_template_kwargs).toEqual({ enable_thinking: false })
+		expect(callArgs.parse_reasoning).toBeUndefined()
+		expect(callArgs.include_reasoning).toBeUndefined()
+	})
+
+	it("should send enable_thinking: false when reasoningEffort is disable on controllable model", async () => {
+		const handler = new FriendliHandler({
+			apiModelId: "zai-org/GLM-5.2",
+			friendliApiKey: "test-...ey",
+			enableReasoningEffort: true,
+			reasoningEffort: "disable",
+		})
+
+		mockCreate.mockImplementationOnce(() => ({
+			[Symbol.asyncIterator]: () => ({
+				async next() {
+					return { done: true }
+				},
+			}),
+		}))
+
+		await handler.createMessage("system", []).next()
+
+		const callArgs = mockCreate.mock.calls[0][0] as Record<string, unknown>
+		expect(callArgs.reasoning_effort).toBeUndefined()
+		expect(callArgs.chat_template_kwargs).toEqual({ enable_thinking: false })
+		expect(callArgs.parse_reasoning).toBeUndefined()
+		expect(callArgs.include_reasoning).toBeUndefined()
+	})
+
+	it("should use model default reasoningEffort when no explicit settings are provided", async () => {
+		const handler = new FriendliHandler({
+			apiModelId: "zai-org/GLM-5.2",
+			friendliApiKey: "test-...ey",
+			// No enableReasoningEffort or reasoningEffort — model default "high" kicks in
+		})
+
+		mockCreate.mockImplementationOnce(() => ({
+			[Symbol.asyncIterator]: () => ({
+				async next() {
+					return { done: true }
+				},
+			}),
+		}))
+
+		await handler.createMessage("system", []).next()
+
+		const callArgs = mockCreate.mock.calls[0][0] as Record<string, unknown>
+		expect(callArgs.reasoning_effort).toBe("high")
+		expect(callArgs.chat_template_kwargs).toEqual({ enable_thinking: true })
+		expect(callArgs.parse_reasoning).toBe(true)
+		expect(callArgs.include_reasoning).toBe(true)
+	})
+
+	it("should not include any reasoning params for non-reasoning DeepSeek-V3.2", async () => {
+		const handler = new FriendliHandler({
+			apiModelId: "deepseek-ai/DeepSeek-V3.2",
+			friendliApiKey: "test-key",
+			enableReasoningEffort: true,
+			reasoningEffort: "high",
+		})
+
+		mockCreate.mockImplementationOnce(() => ({
+			[Symbol.asyncIterator]: () => ({
+				async next() {
+					return { done: true }
+				},
+			}),
+		}))
+
+		await handler.createMessage("system", []).next()
+
+		const callArgs = mockCreate.mock.calls[0][0] as Record<string, unknown>
+		expect(callArgs.reasoning_effort).toBeUndefined()
+		expect(callArgs.chat_template_kwargs).toBeUndefined()
+		expect(callArgs.parse_reasoning).toBeUndefined()
+	})
+
+	it("should handle delta.reasoning_content from parse_reasoning=true stream", async () => {
+		const handler = new FriendliHandler({
+			apiModelId: "zai-org/GLM-5.2",
+			friendliApiKey: "test-key",
+			enableReasoningEffort: true,
+			reasoningEffort: "high",
+		})
+
+		mockCreate.mockImplementationOnce(async () => ({
+			[Symbol.asyncIterator]: async function* () {
+				yield {
+					choices: [{ delta: { reasoning_content: "Let me think..." } }],
+					usage: null,
+				}
+				yield {
+					choices: [{ delta: { content: "The answer is 42" } }],
+					usage: null,
+				}
+				yield {
+					choices: [{ delta: {} }],
+					usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+				}
+			},
+		}))
+
+		const stream = handler.createMessage("system", [])
+		const chunks = []
+		for await (const chunk of stream) {
+			chunks.push(chunk)
+		}
+
+		expect(chunks).toContainEqual({ type: "reasoning", text: "Let me think..." })
+		expect(chunks).toContainEqual({ type: "text", text: "The answer is 42" })
+	})
+
+	it("completePrompt should include reasoning params when enabled", async () => {
+		const handler = new FriendliHandler({
+			apiModelId: "zai-org/GLM-5.2",
+			friendliApiKey: "test-key",
+			enableReasoningEffort: true,
+			reasoningEffort: "medium",
+		})
+
+		mockCreate.mockResolvedValueOnce({
+			choices: [{ message: { content: "test result" } }],
+		})
+
+		await handler.completePrompt("test")
+
+		const callArgs = mockCreate.mock.calls[0][0] as Record<string, unknown>
+		expect(callArgs.reasoning_effort).toBe("medium")
+		expect(callArgs.chat_template_kwargs).toEqual({ enable_thinking: true })
+		expect(callArgs.parse_reasoning).toBe(true)
+		expect(callArgs.include_reasoning).toBe(true)
+	})
+})

src/api/providers/__tests__/lmstudio.spec.ts

@@ -125,7 +125,9 @@ describe("LmStudioHandler", () => {
 				for await (const _chunk of stream) {
 					// Should not reach here
 				}
-			}).rejects.toThrow("Please check the LM Studio developer logs to debug what went wrong")
+			}).rejects.toThrow(
+				"Please check the LM Studio developer logs to debug what went wrong. You may need to load the model with a larger context length to work with Zoo Code's prompts.",
+			)
 		})
 	})
 
@@ -144,7 +146,7 @@ describe("LmStudioHandler", () => {
 		it("should handle API errors", async () => {
 			mockCreate.mockRejectedValueOnce(new Error("API Error"))
 			await expect(handler.completePrompt("Test prompt")).rejects.toThrow(
-				"Please check the LM Studio developer logs to debug what went wrong",
+				"Please check the LM Studio developer logs to debug what went wrong. You may need to load the model with a larger context length to work with Zoo Code's prompts.",
 			)
 		})