feat: Implement function calling

- Added function call converter with methods to detect function calls, extract text, and convert responses to XML.
- Created unit tests for function call converter to ensure proper detection and conversion of various tool call formats.
- Introduced tool registry to manage supported tools and their schemas, including generation of OpenAI and Anthropic schemas.
- Defined schemas for new tools: apply_diff, insert_content, list_code_definition_names, list_files, read_file, search_and_replace, search_files, and write_to_file.
- Enhanced API to support tool calling based on provider type.
- Updated UI to include settings for enabling function calling, with appropriate translations.

Author: NaccOll

packages/types/src/provider-settings.ts

@@ -69,6 +69,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

@@ -36,6 +36,7 @@ import {
 	ZAiHandler,
 	FireworksHandler,
 } from "./providers"
+import { ToolArgs } from "../core/prompts/tools/types"
 
 export interface SingleCompletionHandler {
 	completePrompt(prompt: string): Promise<string>
@@ -44,6 +45,8 @@ export interface SingleCompletionHandler {
 export interface ApiHandlerCreateMessageMetadata {
 	mode?: string
 	taskId: string
+	tools?: string[]
+	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/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!)
+			}
 
 			// 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/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(),
 })
@@ -156,6 +157,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 +279,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 = true
+				}
+			}
+		} catch (error) {
+			console.error(`[migrateToolCallEnabled] Failed to migrate tool call enabled setting:`, error)
+		}
+	}
 
 	/**
 	 * List all available configs with metadata.

src/core/prompts/tools/index.ts

@@ -24,6 +24,7 @@ import { getNewTaskDescription } from "./new-task"
 import { getCodebaseSearchDescription } from "./codebase-search"
 import { getUpdateTodoListDescription } from "./update-todo-list"
 import { CodeIndexManager } from "../../../services/code-index/manager"
+import { getToolRegistry } from "../../tools/schemas/tool-registry"
 
 // Map of tool names to their description functions
 const toolDescriptionMap: Record<string, (args: ToolArgs) => string | undefined> = {
@@ -118,7 +119,21 @@ export function getToolDescriptionsForMode(
 		tools.delete("update_todo_list")
 	}
 
-	// Map tool descriptions for allowed tools
+	// If toolCallEnabled is true, skip XML tool descriptions for supported tools
+	let supportedTools = []
+	if (settings?.toolCallEnabled === true) {
+		const toolRegistry = getToolRegistry()
+		supportedTools = toolRegistry.getSupportedTools(Array.from(tools))
+
+		for (const tool of supportedTools) {
+			// tools.delete(tool)
+			toolDescriptionMap[tool] = (args) => {
+				return `## ${tool}\n\nMUST USE ${tool} TOOL BY LLM NATIVE TOOL CALL. NOT USING XML FORMAT.`
+			}
+		}
+	}
+
+	// Map tool descriptions for allowed tools (traditional XML mode)
 	const descriptions = Array.from(tools).map((toolName) => {
 		const descriptionFn = toolDescriptionMap[toolName]
 		if (!descriptionFn) {

src/core/prompts/types.ts

@@ -4,5 +4,6 @@
 export interface SystemPromptSettings {
 	maxConcurrentFileReads: number
 	todoListEnabled: boolean
+	toolCallEnabled?: boolean
 	useAgentRules: boolean
 }

src/core/task/Task.ts

@@ -36,6 +36,8 @@ import { CloudService } from "@roo-code/cloud"
 
 // api
 import { ApiHandler, ApiHandlerCreateMessageMetadata, buildApiHandler } from "../../api"
+import { getToolRegistry } from "../tools/schemas/tool-registry"
+import { getGroupName, getToolsForMode } from "../../shared/modes"
 import { ApiStream } from "../../api/transform/stream"
 
 // shared
@@ -46,10 +48,10 @@ import { t } from "../../i18n"
 import { ClineApiReqCancelReason, ClineApiReqInfo } from "../../shared/ExtensionMessage"
 import { getApiMetrics } from "../../shared/getApiMetrics"
 import { ClineAskResponse } from "../../shared/WebviewMessage"
-import { defaultModeSlug } from "../../shared/modes"
-import { DiffStrategy } from "../../shared/tools"
+import { defaultModeSlug, modes, getModeBySlug } from "../../shared/modes"
+import { DiffStrategy, ToolUse } from "../../shared/tools"
 import { EXPERIMENT_IDS, experiments } from "../../shared/experiments"
-import { getModelMaxOutputTokens } from "../../shared/api"
+import { getModelMaxOutputTokens, supportToolCall } from "../../shared/api"
 
 // services
 import { UrlContentFetcher } from "../../services/browser/UrlContentFetcher"
@@ -99,6 +101,8 @@ import { getMessagesSinceLastSummary, summarizeConversation } from "../condense"
 import { maybeRemoveImageBlocks } from "../../api/transform/image-cleaning"
 import { restoreTodoListForTask } from "../tools/updateTodoListTool"
 import { AutoApprovalHandler } from "./AutoApprovalHandler"
+import { handleOpenaiToolCall } from "./tool-call-helper"
+import { ToolArgs } from "../prompts/tools/types"
 
 const MAX_EXPONENTIAL_BACKOFF_SECONDS = 600 // 10 minutes
 
@@ -1568,6 +1572,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 			const stream = this.attemptApiRequest()
 			let assistantMessage = ""
 			let reasoningMessage = ""
+			let accumulatedToolCalls: any[] = []
 			this.isStreaming = true
 
 			try {
@@ -1612,6 +1617,37 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 							presentAssistantMessage(this)
 							break
 						}
+						case "tool_call": {
+							if (chunk.toolCallType === "openai") {
+								const xmlContent = handleOpenaiToolCall(accumulatedToolCalls, chunk)
+								if (xmlContent) {
+									console.log(
+										`[RooCode#recursivelyMakeRooRequests] OpenAI tool call XML content:\n${xmlContent}`,
+									)
+									assistantMessage += xmlContent
+
+									// Parse raw assistant message chunk into content blocks.
+									const prevLength = this.assistantMessageContent.length
+									if (this.isAssistantMessageParserEnabled && this.assistantMessageParser) {
+										this.assistantMessageContent =
+											this.assistantMessageParser.processChunk(xmlContent)
+									} else {
+										// Use the old parsing method when experiment is disabled
+										this.assistantMessageContent = parseAssistantMessage(assistantMessage)
+									}
+
+									if (this.assistantMessageContent.length > prevLength) {
+										// New content we need to present, reset to
+										// false in case previous content set this to true.
+										this.userMessageContentReady = false
+									}
+
+									// Present content to user.
+									presentAssistantMessage(this)
+									break
+								}
+							}
+						}
 					}
 
 					if (this.abort) {
@@ -1884,6 +1920,7 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 				{
 					maxConcurrentFileReads: maxConcurrentFileReads ?? 5,
 					todoListEnabled: apiConfiguration?.todoListEnabled ?? true,
+					toolCallEnabled: apiConfiguration?.toolCallEnabled ?? false,
 					useAgentRules: vscode.workspace.getConfiguration("roo-cline").get<boolean>("useAgentRules") ?? true,
 				},
 			)
@@ -1902,6 +1939,12 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 			autoCondenseContext = true,
 			autoCondenseContextPercent = 100,
 			profileThresholds = {},
+			browserViewportSize,
+			experiments,
+			enableMcpServerCreation,
+			maxConcurrentFileReads,
+			maxReadFileLine,
+			browserToolEnabled,
 		} = state ?? {}
 
 		// Get condensing configuration for automatic triggers.
@@ -2024,9 +2067,69 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 			throw new Error("Auto-approval limit reached and user did not approve continuation")
 		}
 
+		// Generate tool schemas if toolCallEnabled is true
+		let tools: string[] | undefined = undefined
+		let toolArgs: ToolArgs | undefined
+		const apiProvider = this.apiConfiguration.apiProvider
+		if (this.apiConfiguration.toolCallEnabled === true && supportToolCall(apiProvider)) {
+			const toolRegistry = getToolRegistry()
+			const provider = this.providerRef.deref()
+
+			if (provider) {
+				const state = await provider.getState()
+				const modeConfig =
+					getModeBySlug(mode!, state.customModes) || modes.find((m) => m.slug === mode) || modes[0]
+				const availableTools = getToolsForMode(modeConfig.groups)
+				const supportedTools = toolRegistry.getSupportedTools(availableTools)
+				tools = supportedTools
+
+				// Determine if browser tools can be used based on model support, mode, and user settings
+				let modelSupportsComputerUse = false
+
+				// Create a temporary API handler to check if the model supports computer use
+				// This avoids relying on an active Cline instance which might not exist during preview
+				try {
+					const tempApiHandler = buildApiHandler(apiConfiguration!)
+					modelSupportsComputerUse = tempApiHandler.getModel().info.supportsComputerUse ?? false
+				} catch (error) {
+					console.error("Error checking if model supports computer use:", error)
+				}
+
+				const modeSupportsBrowser =
+					modeConfig?.groups.some((group) => getGroupName(group) === "browser") ?? false
+
+				// Only enable browser tools if the model supports it, the mode includes browser tools,
+				// and browser tools are enabled in settings
+				const canUseBrowserTool =
+					modelSupportsComputerUse && modeSupportsBrowser && (browserToolEnabled ?? true)
+
+				toolArgs = {
+					cwd: this.cwd,
+					supportsComputerUse: canUseBrowserTool,
+					diffStrategy: this.diffStrategy,
+					browserViewportSize,
+					mcpHub: provider.getMcpHub(),
+					partialReadsEnabled: maxReadFileLine !== -1,
+					settings: {
+						...{
+							maxConcurrentFileReads: maxConcurrentFileReads ?? 5,
+							todoListEnabled: apiConfiguration?.todoListEnabled ?? true,
+							toolCallEnabled: apiConfiguration?.toolCallEnabled ?? false,
+							useAgentRules:
+								vscode.workspace.getConfiguration("roo-cline").get<boolean>("useAgentRules") ?? true,
+						},
+						enableMcpServerCreation,
+					},
+					experiments,
+				}
+			}
+		}
+
 		const metadata: ApiHandlerCreateMessageMetadata = {
 			mode: mode,
 			taskId: this.taskId,
+			tools: tools,
+			toolArgs: toolArgs,
 		}
 
 		const stream = this.api.createMessage(systemPrompt, cleanConversationHistory, metadata)