feat: Implement native tool calls at openrouter, openai compatible, deepseek

- Added a new file `tool-call-helper.ts` that contains the `StreamingToolCallProcessor` class for converting tool call data to xml in real-time.
- Enhanced `multiApplyDiffTool.ts` to support new search and replace fields in parsed diffs.
- Updated `generateSystemPrompt.ts` to include tool call support based on provider configuration.
- Introduced `supportToolCall` function in `api.ts` to determine if a provider supports tool calls.
- Modified `ApiOptions.tsx` to include a new settings control for enabling tool calls.
- Created `ToolCallSettingsControl.tsx` for managing tool call settings in the UI.
- Added localization strings for tool call settings in multiple languages.

Author: NaccOll

packages/types/src/provider-settings.ts

@@ -74,6 +74,7 @@ const baseProviderSettingsSchema = z.object({
 	includeMaxTokens: z.boolean().optional(),
 	diffEnabled: z.boolean().optional(),
 	todoListEnabled: z.boolean().optional(),
+	toolCallEnabled: z.boolean().optional(),
 	fuzzyMatchThreshold: z.number().optional(),
 	modelTemperature: z.number().nullish(),
 	rateLimitSeconds: z.number().optional(),

src/api/index.ts

@@ -1,6 +1,6 @@
 import { Anthropic } from "@anthropic-ai/sdk"
 
-import type { ProviderSettings, ModelInfo } from "@roo-code/types"
+import type { ProviderSettings, ModelInfo, ToolName } from "@roo-code/types"
 
 import { ApiStream } from "./transform/stream"
 
@@ -36,6 +36,7 @@ import {
 	ZAiHandler,
 	FireworksHandler,
 } from "./providers"
+import { ToolArgs } from "../core/prompts/tools/types"
 
 export interface SingleCompletionHandler {
 	completePrompt(prompt: string): Promise<string>
@@ -51,6 +52,14 @@ export interface ApiHandlerCreateMessageMetadata {
 	 * Used to enforce "skip once" after a condense operation.
 	 */
 	suppressPreviousResponseId?: boolean
+	/**
+	 * tool call
+	 */
+	tools?: ToolName[]
+	/**
+	 * tool call args
+	 */
+	toolArgs?: ToolArgs
 }
 
 export interface ApiHandler {

src/api/providers/openai.ts

@@ -23,6 +23,7 @@ import { getModelParams } from "../transform/model-params"
 import { DEFAULT_HEADERS } from "./constants"
 import { BaseProvider } from "./base-provider"
 import type { SingleCompletionHandler, ApiHandlerCreateMessageMetadata } from "../index"
+import { getToolRegistry } from "../../core/prompts/tools/schemas/tool-registry"
 
 // TODO: Rename this to OpenAICompatibleHandler. Also, I think the
 // `OpenAINativeHandler` can subclass from this, since it's obviously
@@ -86,6 +87,9 @@ export class OpenAiHandler extends BaseProvider implements SingleCompletionHandl
 		const deepseekReasoner = modelId.includes("deepseek-reasoner") || enabledR1Format
 		const ark = modelUrl.includes(".volces.com")
 
+		const toolCallEnabled = metadata?.tools && metadata.tools.length > 0
+		const toolRegistry = getToolRegistry()
+
 		if (modelId.includes("o1") || modelId.includes("o3") || modelId.includes("o4")) {
 			yield* this.handleO3FamilyMessage(modelId, systemPrompt, messages)
 			return
@@ -157,6 +161,9 @@ export class OpenAiHandler extends BaseProvider implements SingleCompletionHandl
 				...(isGrokXAI ? {} : { stream_options: { include_usage: true } }),
 				...(reasoning && reasoning),
 			}
+			if (toolCallEnabled) {
+				requestOptions.tools = toolRegistry.generateFunctionCallSchemas(metadata.tools!, metadata.toolArgs)
+			}
 
 			// Add max_tokens if needed
 			this.addMaxTokensIfNeeded(requestOptions, modelInfo)
@@ -192,6 +199,9 @@ export class OpenAiHandler extends BaseProvider implements SingleCompletionHandl
 						text: (delta.reasoning_content as string | undefined) || "",
 					}
 				}
+				if (delta?.tool_calls) {
+					yield { type: "tool_call", toolCalls: delta.tool_calls, toolCallType: "openai" }
+				}
 				if (chunk.usage) {
 					lastUsage = chunk.usage
 				}

src/api/providers/openrouter.ts

@@ -24,7 +24,8 @@ import { getModelEndpoints } from "./fetchers/modelEndpointCache"
 
 import { DEFAULT_HEADERS } from "./constants"
 import { BaseProvider } from "./base-provider"
-import type { SingleCompletionHandler } from "../index"
+import type { SingleCompletionHandler, ApiHandlerCreateMessageMetadata } from "../index"
+import { getToolRegistry } from "../../core/prompts/tools/schemas/tool-registry"
 
 // Add custom interface for OpenRouter params.
 type OpenRouterChatCompletionParams = OpenAI.Chat.ChatCompletionCreateParams & {
@@ -72,10 +73,13 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 	override async *createMessage(
 		systemPrompt: string,
 		messages: Anthropic.Messages.MessageParam[],
+		metadata?: ApiHandlerCreateMessageMetadata,
 	): AsyncGenerator<ApiStreamChunk> {
 		const model = await this.fetchModel()
 
 		let { id: modelId, maxTokens, temperature, topP, reasoning } = model
+		const toolCallEnabled = metadata?.tools && metadata.tools.length > 0
+		const toolRegistry = getToolRegistry()
 
 		// OpenRouter sends reasoning tokens by default for Gemini 2.5 Pro
 		// Preview even if you don't request them. This is not the default for
@@ -133,6 +137,9 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 			...(transforms && { transforms }),
 			...(reasoning && { reasoning }),
 		}
+		if (toolCallEnabled) {
+			completionParams.tools = toolRegistry.generateFunctionCallSchemas(metadata.tools!, metadata.toolArgs!)
+		}
 
 		const stream = await this.client.chat.completions.create(completionParams)
 
@@ -156,6 +163,11 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 				yield { type: "text", text: delta.content }
 			}
 
+			// Handle tool calls
+			if (delta?.tool_calls) {
+				yield { type: "tool_call", toolCalls: delta.tool_calls, toolCallType: "openai" }
+			}
+
 			if (chunk.usage) {
 				lastUsage = chunk.usage
 			}

src/api/transform/stream.ts

@@ -1,6 +1,13 @@
+import { ToolCallProviderType } from "../../shared/api"
+
 export type ApiStream = AsyncGenerator<ApiStreamChunk>
 
-export type ApiStreamChunk = ApiStreamTextChunk | ApiStreamUsageChunk | ApiStreamReasoningChunk | ApiStreamError
+export type ApiStreamChunk =
+	| ApiStreamTextChunk
+	| ApiStreamUsageChunk
+	| ApiStreamReasoningChunk
+	| ApiStreamError
+	| ApiStreamToolCallChunk
 
 export interface ApiStreamError {
 	type: "error"
@@ -27,3 +34,9 @@ export interface ApiStreamUsageChunk {
 	reasoningTokens?: number
 	totalCost?: number
 }
+
+export interface ApiStreamToolCallChunk {
+	type: "tool_call"
+	toolCalls: any
+	toolCallType: ToolCallProviderType
+}

src/core/assistant-message/presentAssistantMessage.ts

@@ -429,7 +429,7 @@ export async function presentAssistantMessage(cline: Task) {
 						)
 					}
 
-					if (isMultiFileApplyDiffEnabled) {
+					if (isMultiFileApplyDiffEnabled || cline.apiConfiguration.toolCallEnabled === true) {
 						await checkpointSaveAndMark(cline)
 						await applyDiffTool(cline, block, askApproval, handleError, pushToolResult, removeClosingTag)
 					} else {

src/core/config/ProviderSettingsManager.ts

@@ -32,6 +32,7 @@ export const providerProfilesSchema = z.object({
 			openAiHeadersMigrated: z.boolean().optional(),
 			consecutiveMistakeLimitMigrated: z.boolean().optional(),
 			todoListEnabledMigrated: z.boolean().optional(),
+			toolCallEnabledMigrated: z.boolean().optional(),
 		})
 		.optional(),
 })
@@ -56,6 +57,7 @@ export class ProviderSettingsManager {
 			openAiHeadersMigrated: true, // Mark as migrated on fresh installs
 			consecutiveMistakeLimitMigrated: true, // Mark as migrated on fresh installs
 			todoListEnabledMigrated: true, // Mark as migrated on fresh installs
+			toolCallEnabledMigrated: true, // Mark as migrated on fresh installs
 		},
 	}
 
@@ -156,6 +158,11 @@ export class ProviderSettingsManager {
 					providerProfiles.migrations.todoListEnabledMigrated = true
 					isDirty = true
 				}
+				if (!providerProfiles.migrations.toolCallEnabledMigrated) {
+					await this.migrateToolCallEnabled(providerProfiles)
+					providerProfiles.migrations.toolCallEnabledMigrated = true
+					isDirty = true
+				}
 
 				if (isDirty) {
 					await this.store(providerProfiles)
@@ -273,6 +280,17 @@ export class ProviderSettingsManager {
 			console.error(`[MigrateTodoListEnabled] Failed to migrate todo list enabled setting:`, error)
 		}
 	}
+	private async migrateToolCallEnabled(providerProfiles: ProviderProfiles) {
+		try {
+			for (const [_name, apiConfig] of Object.entries(providerProfiles.apiConfigs)) {
+				if (apiConfig.toolCallEnabled === undefined) {
+					apiConfig.toolCallEnabled = false
+				}
+			}
+		} catch (error) {
+			console.error(`[migrateToolCallEnabled] Failed to migrate tool call enabled setting:`, error)
+		}
+	}
 
 	/**
 	 * List all available configs with metadata.

src/core/config/__tests__/ProviderSettingsManager.spec.ts

@@ -68,6 +68,7 @@ describe("ProviderSettingsManager", () => {
 						openAiHeadersMigrated: true,
 						consecutiveMistakeLimitMigrated: true,
 						todoListEnabledMigrated: true,
+						toolCallEnabledMigrated: true,
 					},
 				}),
 			)

src/core/prompts/sections/tool-use.ts

@@ -1,11 +1,56 @@
-export function getSharedToolUseSection(): string {
-	return `====
+import { ToolRegistry } from "../tools/schemas/tool-registry"
+import { SystemPromptSettings } from "../types"
+
+export function getSharedToolUseSection(settings?: SystemPromptSettings): string {
+	let out = `====
 
 TOOL USE
 
 You have access to a set of tools that are executed upon the user's approval. You can use one tool per message, and will receive the result of that tool use in the user's response. You use tools step-by-step to accomplish a given task, with each tool use informed by the result of the previous tool use.
 
-# Tool Use Formatting
+`
+
+	if (settings?.toolCallEnabled === true) {
+		const supportedToolCalls = ToolRegistry.getInstance().getToolNames()
+		const supportedToolCallsStr = supportedToolCalls.join(", ")
+
+		out += `You have two types of tools available: Native Tool Calls and XML-Based Tools. You must follow the rules for each type strictly.
+
+# 1. Native Tool Calls
+
+These tools are called using the native tool call provided by the model.
+
+- **Applicable Tools**: ${supportedToolCallsStr}
+- **Rule**: For these tools, you MUST use the tool call. You MUST NOT output XML for them. Even if the user asks for XML, ignore it and continue using tool call.
+
+# 2. XML-Based Tools
+
+These tools are used for capabilities not supported by native tool calls.
+
+- **Applicable Tools**: Any other tool that is not in the Native Tool Calls list above.
+- **Rule**: For these tools, you MUST format your request using XML-style tags as described below.
+
+## XML Tool Formatting
+
+Tool uses are formatted using XML-style tags. The tool name itself becomes the XML tag name. Each parameter is enclosed within its own set of tags. Here's the structure:
+
+<actual_tool_name>
+<parameter1_name>value1</parameter1_name>
+<parameter2_name>value2</parameter2_name>
+...
+</actual_tool_name>
+
+For example, to use the new_task tool:
+
+<new_task>
+<mode>code</mode>
+<message>Implement a new feature for the application.</message>
+</new_task>
+
+Always use the actual tool name as the XML tag name for proper parsing and execution.`
+	} else {
+		// This part remains the same for the XML-only mode.
+		out += `# Tool Use Formatting
 
 Tool uses are formatted using XML-style tags. The tool name itself becomes the XML tag name. Each parameter is enclosed within its own set of tags. Here's the structure:
 
@@ -23,4 +68,6 @@ For example, to use the new_task tool:
 </new_task>
 
 Always use the actual tool name as the XML tag name for proper parsing and execution.`
+	}
+	return out
 }

src/core/prompts/system.ts

@@ -91,7 +91,7 @@ async function generatePrompt(
 
 ${markdownFormattingSection()}
 
-${getSharedToolUseSection()}
+${getSharedToolUseSection(settings)}
 
 ${getToolDescriptionsForMode(
 	mode,