zgsm-ai
diff --git a/‎packages/types/src/experiment.ts‎
Lines changed: 4 additions & 6 deletions b/‎packages/types/src/experiment.ts‎
Lines changed: 4 additions & 6 deletions
diff --git a/‎src/core/assistant-message/presentAssistantMessage.ts‎
Lines changed: 2 additions & 14 deletions b/‎src/core/assistant-message/presentAssistantMessage.ts‎
Lines changed: 2 additions & 14 deletions
diff --git a/‎src/core/task/Task.ts‎
Lines changed: 11 additions & 65 deletions b/‎src/core/task/Task.ts‎
Lines changed: 11 additions & 65 deletions
diff --git a/‎src/core/tools/MultiApplyDiffTool.ts‎
Lines changed: 3 additions & 8 deletions b/‎src/core/tools/MultiApplyDiffTool.ts‎
Lines changed: 3 additions & 8 deletions
diff --git a/‎src/core/tools/ReadFileTool.ts‎
Lines changed: 1 addition & 7 deletions b/‎src/core/tools/ReadFileTool.ts‎
Lines changed: 1 addition & 7 deletions
diff --git a/‎src/core/tools/__tests__/applyDiffTool.experiment.spec.ts‎
Lines changed: 5 additions & 5 deletions b/‎src/core/tools/__tests__/applyDiffTool.experiment.spec.ts‎
Lines changed: 5 additions & 5 deletions
diff --git a/‎src/core/webview/generateSystemPrompt.ts‎
Lines changed: 1 addition & 1 deletion b/‎src/core/webview/generateSystemPrompt.ts‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎src/core/webview/webviewMessageHandler.ts‎
Lines changed: 2 additions & 2 deletions b/‎src/core/webview/webviewMessageHandler.ts‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎src/shared/__tests__/experiments.spec.ts‎
Lines changed: 5 additions & 26 deletions b/‎src/shared/__tests__/experiments.spec.ts‎
Lines changed: 5 additions & 26 deletions
@@ -7,14 +7,13 @@ import type { Keys, Equals, AssertEqual } from "./type-fu.js"
  */
 
 export const experimentIds = [
+	"chatSearch",
+	"alwaysIncludeFileDetails",
 	"powerSteering",
 	"multiFileApplyDiff",
 	"preventFocusDisruption",
 	"imageGeneration",
 	"runSlashCommand",
-	"chatSearch",
-	"alwaysIncludeFileDetails",
-	"nativeToolCalling",
 ] as const
 
 export const experimentIdsSchema = z.enum(experimentIds)
@@ -26,14 +25,13 @@ export type ExperimentId = z.infer<typeof experimentIdsSchema>
  */
 
 export const experimentsSchema = z.object({
+	chatSearch: z.boolean().optional(),
+	alwaysIncludeFileDetails: z.boolean().optional(),
 	powerSteering: z.boolean().optional(),
 	multiFileApplyDiff: z.boolean().optional(),
 	preventFocusDisruption: z.boolean().optional(),
 	imageGeneration: z.boolean().optional(),
 	runSlashCommand: z.boolean().optional(),
-	chatSearch: z.boolean().optional(),
-	alwaysIncludeFileDetails: z.boolean().optional(),
-	nativeToolCalling: z.boolean().optional(),
 })
 
 export type Experiments = z.infer<typeof experimentsSchema>
 
@@ -282,13 +282,7 @@ export async function presentAssistantMessage(cline: Task) {
 			let hasToolResult = false
 
 			// Check if we're using native tool protocol (do this once before defining pushToolResult)
-			const state = await cline.providerRef.deref()?.getState()
-			const toolProtocol = resolveToolProtocol(
-				cline.apiConfiguration,
-				cline.api.getModel().info,
-				cline.apiConfiguration.apiProvider,
-				state?.experiments,
-			)
+			const toolProtocol = resolveToolProtocol(cline.apiConfiguration, cline.api.getModel().info)
 			const isNative = isNativeProtocol(toolProtocol)
 			const toolCallId = (block as any).id
 
@@ -531,13 +525,7 @@ export async function presentAssistantMessage(cline: Task) {
 					await checkpointSaveAndMark(cline)
 
 					// Check if native protocol is enabled - if so, always use single-file class-based tool
-					const state = await cline.providerRef.deref()?.getState()
-					const applyDiffToolProtocol = resolveToolProtocol(
-						cline.apiConfiguration,
-						cline.api.getModel().info,
-						cline.apiConfiguration.apiProvider,
-						state?.experiments,
-					)
+					const applyDiffToolProtocol = resolveToolProtocol(cline.apiConfiguration, cline.api.getModel().info)
 					if (isNativeProtocol(applyDiffToolProtocol)) {
 						await applyDiffToolClass.handle(cline, block as ToolUse<"apply_diff">, {
 							askApproval,
 
@@ -428,12 +428,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		// Initialize the assistant message parser only for XML protocol.
 		// For native protocol, tool calls come as tool_call chunks, not XML.
 		// experiments is always provided via TaskOptions (defaults to experimentDefault in provider)
-		const toolProtocol = resolveToolProtocol(
-			this.apiConfiguration,
-			this.api.getModel().info,
-			this.apiConfiguration.apiProvider,
-			experimentsConfig,
-		)
+		const toolProtocol = resolveToolProtocol(this.apiConfiguration, this.api.getModel().info)
 		this.assistantMessageParser = toolProtocol === "xml" ? new AssistantMessageParser() : undefined
 
 		this.messageQueueService = new MessageQueueService()
@@ -1347,12 +1342,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		)
 		const modelInfo = this.api.getModel().info
 		const state = await this.providerRef.deref()?.getState()
-		const toolProtocol = resolveToolProtocol(
-			this.apiConfiguration,
-			modelInfo,
-			this.apiConfiguration.apiProvider,
-			state?.experiments,
-		)
+		const toolProtocol = resolveToolProtocol(this.apiConfiguration, modelInfo)
 		return formatResponse.toolError(formatResponse.missingToolParameterError(paramName, toolProtocol))
 	}
 
@@ -1496,12 +1486,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		// conversations with tool uses and no tool schema.
 		// For native protocol, we preserve tool_use and tool_result blocks as they're expected by the API.
 		const state = await this.providerRef.deref()?.getState()
-		const protocol = resolveToolProtocol(
-			this.apiConfiguration,
-			this.api.getModel().info,
-			this.apiConfiguration.apiProvider,
-			state?.experiments,
-		)
+		const protocol = resolveToolProtocol(this.apiConfiguration, this.api.getModel().info)
 		const useNative = isNativeProtocol(protocol)
 
 		// Only convert tool blocks to text for XML protocol
@@ -1859,12 +1844,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 			} else {
 				const modelInfo = this.api.getModel().info
 				const state = await this.providerRef.deref()?.getState()
-				const toolProtocol = resolveToolProtocol(
-					this.apiConfiguration,
-					modelInfo,
-					this.apiConfiguration.apiProvider,
-					state?.experiments,
-				)
+				const toolProtocol = resolveToolProtocol(this.apiConfiguration, modelInfo)
 				nextUserContent = [{ type: "text", text: formatResponse.noToolsUsed(toolProtocol) }]
 				this.consecutiveMistakeCount++
 			}
@@ -2549,12 +2529,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 					// Check if we're using native protocol
 					const state = await this.providerRef.deref()?.getState()
 					const isNative = isNativeProtocol(
-						resolveToolProtocol(
-							this.apiConfiguration,
-							this.api.getModel().info,
-							this.apiConfiguration.apiProvider,
-							state?.experiments,
-						),
+						resolveToolProtocol(this.apiConfiguration, this.api.getModel().info),
 					)
 
 					if (isNative) {
@@ -2695,12 +2670,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 					if (!didToolUse) {
 						const modelInfo = this.api.getModel().info
 						const state = await this.providerRef.deref()?.getState()
-						const toolProtocol = resolveToolProtocol(
-							this.apiConfiguration,
-							modelInfo,
-							this.apiConfiguration.apiProvider,
-							state?.experiments,
-						)
+						const toolProtocol = resolveToolProtocol(this.apiConfiguration, modelInfo)
 						this.userMessageContent.push({ type: "text", text: formatResponse.noToolsUsed(toolProtocol) })
 						this.consecutiveMistakeCount++
 					}
@@ -2731,14 +2701,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 					// user messages (which would cause tool_result validation errors).
 					let state = await this.providerRef.deref()?.getState()
 					if (
-						isNativeProtocol(
-							resolveToolProtocol(
-								this.apiConfiguration,
-								this.api.getModel().info,
-								this.apiConfiguration.apiProvider,
-								state?.experiments,
-							),
-						) &&
+						isNativeProtocol(resolveToolProtocol(this.apiConfiguration, this.api.getModel().info)) &&
 						this.apiConversationHistory.length > 0
 					) {
 						const lastMessage = this.apiConversationHistory[this.apiConversationHistory.length - 1]
@@ -2805,14 +2768,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 							// For native protocol, re-add the user message we removed
 							// Reuse the state variable from above
 							if (
-								isNativeProtocol(
-									resolveToolProtocol(
-										this.apiConfiguration,
-										this.api.getModel().info,
-										this.apiConfiguration.apiProvider,
-										state?.experiments,
-									),
-								)
+								isNativeProtocol(resolveToolProtocol(this.apiConfiguration, this.api.getModel().info))
 							) {
 								await this.addToApiConversationHistory({
 									role: "user",
@@ -2909,12 +2865,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 			const canUseBrowserTool = modelSupportsBrowser && modeSupportsBrowser && (browserToolEnabled ?? true)
 
 			// Resolve the tool protocol based on profile, model, and provider settings
-			const toolProtocol = resolveToolProtocol(
-				apiConfiguration ?? this.apiConfiguration,
-				modelInfo,
-				(apiConfiguration ?? this.apiConfiguration)?.apiProvider,
-				experiments,
-			)
+			const toolProtocol = resolveToolProtocol(apiConfiguration ?? this.apiConfiguration, modelInfo)
 
 			return SYSTEM_PROMPT(
 				provider.context,
@@ -3025,7 +2976,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 			apiConfiguration,
 			autoApprovalEnabled,
 			alwaysApproveResubmit,
-			requestDelaySeconds,
+			// requestDelaySeconds,
 			mode,
 			zgsmCodeMode,
 			autoCondenseContext = true,
@@ -3156,12 +3107,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 		// 1. Tool protocol is set to NATIVE
 		// 2. Model supports native tools
 		const modelInfo = this.api.getModel().info
-		const toolProtocol = resolveToolProtocol(
-			this.apiConfiguration,
-			modelInfo,
-			this.apiConfiguration.apiProvider,
-			state?.experiments,
-		)
+		const toolProtocol = resolveToolProtocol(this.apiConfiguration, modelInfo)
 		const shouldIncludeTools = toolProtocol === TOOL_PROTOCOL.NATIVE && (modelInfo.supportsNativeTools ?? false)
 
 		// Build complete tools array: native tools + dynamic MCP tools, filtered by mode restrictions
 
@@ -63,14 +63,7 @@ export async function applyDiffTool(
 	removeClosingTag: RemoveClosingTag,
 ) {
 	// Check if native protocol is enabled - if so, always use single-file class-based tool
-	const provider = cline.providerRef.deref()
-	const state = await provider?.getState()
-	const toolProtocol = resolveToolProtocol(
-		cline.apiConfiguration,
-		cline.api.getModel().info,
-		cline.apiConfiguration.apiProvider,
-		state?.experiments,
-	)
+	const toolProtocol = resolveToolProtocol(cline.apiConfiguration, cline.api.getModel().info)
 	if (isNativeProtocol(toolProtocol)) {
 		return applyDiffToolClass.handle(cline, block as ToolUse<"apply_diff">, {
 			askApproval,
@@ -81,6 +74,8 @@ export async function applyDiffTool(
 	}
 
 	// Check if MULTI_FILE_APPLY_DIFF experiment is enabled
+	const provider = cline.providerRef.deref()
+	const state = await provider?.getState()
 	if (provider && state) {
 		const isMultiFileApplyDiffEnabled = experiments.isEnabled(
 			state.experiments ?? {},
 
@@ -109,13 +109,7 @@ export class ReadFileTool extends BaseTool<"read_file"> {
 		const { handleError, pushToolResult } = callbacks
 		const fileEntries = params.files
 		const modelInfo = task.api.getModel().info
-		const state = await task.providerRef.deref()?.getState()
-		const protocol = resolveToolProtocol(
-			task.apiConfiguration,
-			modelInfo,
-			task.apiConfiguration.apiProvider,
-			state?.experiments,
-		)
+		const protocol = resolveToolProtocol(task.apiConfiguration, modelInfo)
 		const useNative = isNativeProtocol(protocol)
 
 		if (!fileEntries || fileEntries.length === 0) {
 
@@ -181,22 +181,22 @@ describe("applyDiffTool experiment routing", () => {
 		expect(applyDiffToolClass.handle).not.toHaveBeenCalled()
 	})
 
-	it("should use class-based tool when native protocol is enabled regardless of experiment", async () => {
-		// Update model to support native tools
+	it("should use class-based tool when model defaults to native protocol", async () => {
+		// Update model to support native tools and default to native protocol
 		mockCline.api.getModel = vi.fn().mockReturnValue({
 			id: "test-model",
 			info: {
 				maxTokens: 4096,
 				contextWindow: 128000,
 				supportsPromptCache: false,
-				supportsNativeTools: true, // Enable native tools support
+				supportsNativeTools: true, // Model supports native tools
+				defaultToolProtocol: "native", // Model defaults to native protocol
 			},
 		})
 
 		mockProvider.getState.mockResolvedValue({
 			experiments: {
 				[EXPERIMENT_IDS.MULTI_FILE_APPLY_DIFF]: true,
-				[EXPERIMENT_IDS.NATIVE_TOOL_CALLING]: true, // Enable native tool calling experiment
 			},
 		})
 		;(applyDiffToolClass.handle as any).mockResolvedValue(undefined)
@@ -210,7 +210,7 @@ describe("applyDiffTool experiment routing", () => {
 			mockRemoveClosingTag,
 		)
 
-		// When native protocol is enabled, should always use class-based tool
+		// When native protocol is used, should always use class-based tool
 		expect(applyDiffToolClass.handle).toHaveBeenCalledWith(mockCline, mockBlock, {
 			askApproval: mockAskApproval,
 			handleError: mockHandleError,
 
@@ -71,7 +71,7 @@ export const generateSystemPrompt = async (provider: ClineProvider, message: Web
 	const canUseBrowserTool = modelSupportsBrowser && modeSupportsBrowser && (browserToolEnabled ?? true)
 
 	// Resolve tool protocol for system prompt generation
-	const toolProtocol = resolveToolProtocol(apiConfiguration, modelInfo, apiConfiguration.apiProvider, experiments)
+	const toolProtocol = resolveToolProtocol(apiConfiguration, modelInfo)
 
 	const systemPrompt = await SYSTEM_PROMPT(
 		provider.context,
 
@@ -3192,7 +3192,7 @@ export const webviewMessageHandler = async (
 			break
 		}
 		case "copyError": {
-			const { message: errorMessage } = message.values ?? {}
+			const { message: errorMessage, originModelId, selectedLLM } = message.values ?? {}
 			const { apiConfiguration } = await provider.getState()
 			const httpProxy = process.env.http_proxy || process.env.HTTP_PROXY
 			const httpsProxy = process.env.https_proxy || process.env.HTTPS_PROXY
@@ -3226,7 +3226,7 @@ export const webviewMessageHandler = async (
 				await vscode.env.clipboard.writeText(dedent`
 					message: ${errorMessage}
 					provider: ${apiConfiguration.apiProvider}
-					Model: ${apiConfiguration.apiProvider === "zgsm" ? apiConfiguration.zgsmModelId : apiConfiguration.apiModelId}
+					Model: ${apiConfiguration.apiProvider === "zgsm" ? selectedLLM || originModelId || apiConfiguration.zgsmModelId : apiConfiguration.apiModelId}
 					${apiConfiguration.apiProvider === "zgsm" ? `BaseUrl: ${apiConfiguration.zgsmBaseUrl || ZgsmAuthConfig.getInstance().getDefaultApiBaseUrl()}` : ""}
 					vscodeVersion: ${vscode.version}
 					pluginVersion: ${Package.version}
 
@@ -23,35 +23,16 @@ describe("experiments", () => {
 		})
 	})
 
-	describe("CHAT_SEARCH", () => {
-		it("is configured correctly", () => {
-			expect(EXPERIMENT_IDS.CHAT_SEARCH).toBe("chatSearch")
-			expect(experimentConfigsMap.CHAT_SEARCH).toMatchObject({
-				enabled: false,
-			})
-		})
-	})
-
-	describe("NATIVE_TOOL_CALLING", () => {
-		it("is configured correctly", () => {
-			expect(EXPERIMENT_IDS.NATIVE_TOOL_CALLING).toBe("nativeToolCalling")
-			expect(experimentConfigsMap.NATIVE_TOOL_CALLING).toMatchObject({
-				enabled: false,
-			})
-		})
-	})
-
 	describe("isEnabled", () => {
 		it("returns false when POWER_STEERING experiment is not enabled", () => {
 			const experiments: Record<ExperimentId, boolean> = {
 				powerSteering: false,
 				multiFileApplyDiff: false,
 				preventFocusDisruption: false,
 				imageGeneration: false,
-				runSlashCommand: false,
 				chatSearch: false,
 				alwaysIncludeFileDetails: false,
-				nativeToolCalling: false,
+				runSlashCommand: false,
 			}
 			expect(Experiments.isEnabled(experiments, EXPERIMENT_IDS.POWER_STEERING)).toBe(false)
 		})
@@ -60,12 +41,11 @@ describe("experiments", () => {
 			const experiments: Record<ExperimentId, boolean> = {
 				powerSteering: true,
 				multiFileApplyDiff: false,
+				chatSearch: false,
+				alwaysIncludeFileDetails: false,
 				preventFocusDisruption: false,
 				imageGeneration: false,
 				runSlashCommand: false,
-				chatSearch: false,
-				alwaysIncludeFileDetails: false,
-				nativeToolCalling: false,
 			}
 			expect(Experiments.isEnabled(experiments, EXPERIMENT_IDS.POWER_STEERING)).toBe(true)
 		})
@@ -74,12 +54,11 @@ describe("experiments", () => {
 			const experiments: Record<ExperimentId, boolean> = {
 				powerSteering: false,
 				multiFileApplyDiff: false,
+				chatSearch: false,
+				alwaysIncludeFileDetails: false,
 				preventFocusDisruption: false,
 				imageGeneration: false,
 				runSlashCommand: false,
-				chatSearch: false,
-				alwaysIncludeFileDetails: false,
-				nativeToolCalling: false,
 			}
 			expect(Experiments.isEnabled(experiments, EXPERIMENT_IDS.POWER_STEERING)).toBe(false)
 		})