feat: add tool call functionality

- Introduced a new ToolCallSettingsControl component for enabling/disabling tool calls in the settings UI.
- Updated API options to include tool call settings and integrated it into the existing settings view.
- Enhanced localization files to support new tool call settings in multiple languages.
- Added logic to handle tool call enabled state across different components and tools.

Author: NaccOll

packages/types/src/provider-settings.ts

@@ -95,6 +95,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"
 
@@ -39,6 +39,7 @@ import {
 	FeatherlessHandler,
 } from "./providers"
 import { NativeOllamaHandler } from "./providers/native-ollama"
+import { ToolArgs } from "../core/prompts/tools/types"
 
 export interface SingleCompletionHandler {
 	completePrompt(prompt: string): Promise<string>
@@ -54,6 +55,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/base-openai-compatible-provider.ts

@@ -10,6 +10,7 @@ import { convertToOpenAiMessages } from "../transform/openai-format"
 import type { SingleCompletionHandler, ApiHandlerCreateMessageMetadata } from "../index"
 import { DEFAULT_HEADERS } from "./constants"
 import { BaseProvider } from "./base-provider"
+import { ToolRegistry } from "../../core/prompts/tools/schemas/tool-registry"
 
 type BaseOpenAiCompatibleProviderOptions<ModelName extends string> = ApiHandlerOptions & {
 	providerName: string
@@ -81,6 +82,11 @@ export abstract class BaseOpenAiCompatibleProvider<ModelName extends string>
 			stream_options: { include_usage: true },
 		}
 
+		if (metadata?.tools && metadata.tools.length > 0) {
+			params.tools = ToolRegistry.getInstance().generateFunctionCallSchemas(metadata.tools, metadata.toolArgs)
+			params.tool_choice = "auto"
+		}
+
 		// Only include temperature if explicitly set
 		if (this.options.modelTemperature !== undefined) {
 			params.temperature = this.options.modelTemperature

src/api/providers/base-provider.ts

@@ -32,4 +32,34 @@ export abstract class BaseProvider implements ApiHandler {
 
 		return countTokens(content, { useWorker: true })
 	}
+
+	/**
+	 * Convert tool schemas to text format for token counting
+	 */
+	protected convertToolSchemasToText(toolSchemas: Anthropic.ToolUnion[]): string {
+		if (toolSchemas.length === 0) {
+			return ""
+		}
+
+		const toolsDescription = toolSchemas
+			.map((tool) => {
+				// Handle different tool types by accessing properties safely
+				const toolName = tool.name
+				let toolText = `Tool: ${toolName}\n`
+
+				// Try to access description and input_schema properties
+				if ("description" in tool) {
+					toolText += `Description: ${tool.description}\n`
+				}
+
+				if ("input_schema" in tool && tool.input_schema && typeof tool.input_schema === "object") {
+					toolText += `Parameters:\n${JSON.stringify(tool.input_schema, null, 2)}\n`
+				}
+
+				return toolText
+			})
+			.join("\n---\n")
+
+		return `Available Tools:\n${toolsDescription}`
+	}
 }

src/api/providers/featherless.ts

@@ -1,4 +1,9 @@
-import { DEEP_SEEK_DEFAULT_TEMPERATURE, type FeatherlessModelId, featherlessDefaultModelId, featherlessModels } from "@roo-code/types"
+import {
+	DEEP_SEEK_DEFAULT_TEMPERATURE,
+	type FeatherlessModelId,
+	featherlessDefaultModelId,
+	featherlessModels,
+} from "@roo-code/types"
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
 

src/api/providers/lm-studio.ts

@@ -15,6 +15,7 @@ import { BaseProvider } from "./base-provider"
 import type { SingleCompletionHandler, ApiHandlerCreateMessageMetadata } from "../index"
 import { getModels, getModelsFromCache } from "./fetchers/modelCache"
 import { getApiRequestTimeout } from "./utils/timeout-config"
+import { getToolRegistry } from "../../core/prompts/tools/schemas/tool-registry"
 
 export class LmStudioHandler extends BaseProvider implements SingleCompletionHandler {
 	protected options: ApiHandlerOptions
@@ -40,6 +41,8 @@ export class LmStudioHandler extends BaseProvider implements SingleCompletionHan
 			{ role: "system", content: systemPrompt },
 			...convertToOpenAiMessages(messages),
 		]
+		const toolCallEnabled = metadata?.tools && metadata.tools.length > 0
+		const toolRegistry = getToolRegistry()
 
 		// -------------------------
 		// Track token usage
@@ -68,7 +71,17 @@ export class LmStudioHandler extends BaseProvider implements SingleCompletionHan
 
 		let inputTokens = 0
 		try {
-			inputTokens = await this.countTokens([{ type: "text", text: systemPrompt }, ...toContentBlocks(messages)])
+			const inputMessages: Anthropic.Messages.ContentBlockParam[] = [{ type: "text", text: systemPrompt }]
+			if (toolCallEnabled) {
+				const toolSchemas: Anthropic.ToolUnion[] = toolRegistry.generateAnthropicToolSchemas(
+					metadata.tools!,
+					metadata.toolArgs,
+				)
+				const toolsText = this.convertToolSchemasToText(toolSchemas)
+				inputMessages.push({ type: "text", text: toolsText })
+			}
+			inputMessages.push(...toContentBlocks(messages))
+			inputTokens = await this.countTokens(inputMessages)
 		} catch (err) {
 			console.error("[LmStudio] Failed to count input tokens:", err)
 			inputTokens = 0
@@ -83,6 +96,10 @@ export class LmStudioHandler extends BaseProvider implements SingleCompletionHan
 				temperature: this.options.modelTemperature ?? LMSTUDIO_DEFAULT_TEMPERATURE,
 				stream: true,
 			}
+			if (toolCallEnabled) {
+				params.tools = toolRegistry.generateFunctionCallSchemas(metadata.tools!, metadata.toolArgs)
+				params.tool_choice = "auto"
+			}
 
 			if (this.options.lmStudioSpeculativeDecodingEnabled && this.options.lmStudioDraftModelId) {
 				params.draft_model = this.options.lmStudioDraftModelId
@@ -108,6 +125,9 @@ export class LmStudioHandler extends BaseProvider implements SingleCompletionHan
 						yield processedChunk
 					}
 				}
+				if (delta?.tool_calls) {
+					yield { type: "tool_call", toolCalls: delta.tool_calls, toolCallType: "openai" }
+				}
 			}
 
 			for (const processedChunk of matcher.final()) {

src/api/providers/openai.ts

@@ -24,6 +24,7 @@ import { DEFAULT_HEADERS } from "./constants"
 import { BaseProvider } from "./base-provider"
 import type { SingleCompletionHandler, ApiHandlerCreateMessageMetadata } from "../index"
 import { getApiRequestTimeout } from "./utils/timeout-config"
+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
@@ -92,6 +93,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
@@ -162,6 +166,10 @@ 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)
+				requestOptions.tool_choice = "auto"
+			}
 
 			// Only include temperature if explicitly set
 			if (this.options.modelTemperature !== undefined) {
@@ -205,6 +213,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,10 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 			...(transforms && { transforms }),
 			...(reasoning && { reasoning }),
 		}
+		if (toolCallEnabled) {
+			completionParams.tools = toolRegistry.generateFunctionCallSchemas(metadata.tools!, metadata.toolArgs!)
+			completionParams.tool_choice = "auto"
+		}
 
 		const stream = await this.client.chat.completions.create(completionParams)
 
@@ -156,6 +164,10 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 				yield { type: "text", text: delta.content }
 			}
 
+			if (delta?.tool_calls) {
+				yield { type: "tool_call", toolCalls: delta.tool_calls, toolCallType: "openai" }
+			}
+
 			if (chunk.usage) {
 				lastUsage = chunk.usage
 			}

src/api/providers/roo.ts

@@ -54,6 +54,10 @@ export class RooHandler extends BaseOpenAiCompatibleProvider<RooModelId> {
 					}
 				}
 
+				if (delta?.tool_calls) {
+					yield { type: "tool_call", toolCalls: delta.tool_calls, toolCallType: "openai" }
+				}
+
 				if ("reasoning_content" in delta && typeof delta.reasoning_content === "string") {
 					yield {
 						type: "reasoning",

src/api/transform/stream.ts

@@ -1,6 +1,13 @@
+import { ToolCallProviderType } from "../../shared/tools"
+
 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
+}