Add native tool call support

packages/types/src/index.ts

@@ -20,6 +20,7 @@ export * from "./todo.js"
 export * from "./telemetry.js"
 export * from "./terminal.js"
 export * from "./tool.js"
+export * from "./tool-params.js"
 export * from "./type-fu.js"
 export * from "./vscode.js"
 

packages/types/src/model.ts

@@ -84,6 +84,8 @@ export const modelInfoSchema = z.object({
 	deprecated: z.boolean().optional(),
 	// Flag to indicate if the model is free (no cost)
 	isFree: z.boolean().optional(),
+	// Flag to indicate if the model supports native tool calling (OpenAI-style function calling)
+	supportsNativeTools: z.boolean().optional(),
 	/**
 	 * Service tiers with pricing information.
 	 * Each tier can have a name (for OpenAI service tiers) and pricing overrides.

packages/types/src/providers/openrouter.ts

@@ -8,6 +8,7 @@ export const openRouterDefaultModelInfo: ModelInfo = {
 	contextWindow: 200_000,
 	supportsImages: true,
 	supportsPromptCache: true,
+	supportsNativeTools: true,
 	inputPrice: 3.0,
 	outputPrice: 15.0,
 	cacheWritesPrice: 3.75,

packages/types/src/tool-params.ts

@@ -0,0 +1,37 @@
+/**
+ * Tool parameter type definitions for native protocol
+ */
+
+export interface LineRange {
+	start: number
+	end: number
+}
+
+export interface FileEntry {
+	path: string
+	lineRanges?: LineRange[]
+}
+
+export interface Coordinate {
+	x: number
+	y: number
+}
+
+export interface Size {
+	width: number
+	height: number
+}
+
+export interface BrowserActionParams {
+	action: "launch" | "click" | "hover" | "type" | "scroll_down" | "scroll_up" | "resize" | "close"
+	url?: string
+	coordinate?: Coordinate
+	size?: Size
+	text?: string
+}
+
+export interface GenerateImageParams {
+	prompt: string
+	path: string
+	image?: string
+}

packages/types/src/tool.ts

@@ -68,3 +68,24 @@ export const TOOL_PROTOCOL = {
  * Derived from TOOL_PROTOCOL constants to ensure type safety
  */
 export type ToolProtocol = (typeof TOOL_PROTOCOL)[keyof typeof TOOL_PROTOCOL]
+
+/**
+ * Checks if the protocol is native (non-XML).
+ *
+ * @param protocol - The tool protocol to check
+ * @returns True if protocol is native
+ */
+export function isNativeProtocol(protocol: ToolProtocol): boolean {
+	return protocol === TOOL_PROTOCOL.NATIVE
+}
+
+/**
+ * Gets the effective protocol from settings or falls back to the default XML.
+ * This function is safe to use in webview-accessible code as it doesn't depend on vscode module.
+ *
+ * @param toolProtocol - Optional tool protocol from settings
+ * @returns The effective tool protocol (defaults to "xml")
+ */
+export function getEffectiveProtocol(toolProtocol?: ToolProtocol): ToolProtocol {
+	return toolProtocol || TOOL_PROTOCOL.XML
+}

src/api/index.ts

@@ -1,6 +1,7 @@
 import { Anthropic } from "@anthropic-ai/sdk"
+import OpenAI from "openai"
 
-import type { ProviderSettings, ModelInfo } from "@roo-code/types"
+import type { ProviderSettings, ModelInfo, ToolProtocol } from "@roo-code/types"
 
 import { ApiStream } from "./transform/stream"
 
@@ -63,6 +64,30 @@ export interface ApiHandlerCreateMessageMetadata {
 	 * - Unbound: Sent in unbound_metadata
 	 */
 	mode?: string
+	suppressPreviousResponseId?: boolean
+	/**
+	 * Controls whether the response should be stored for 30 days in OpenAI's Responses API.
+	 * When true (default), responses are stored and can be referenced in future requests
+	 * using the previous_response_id for efficient conversation continuity.
+	 * Set to false to opt out of response storage for privacy or compliance reasons.
+	 * @default true
+	 */
+	store?: boolean
+	/**
+	 * Optional array of tool definitions to pass to the model.
+	 * For OpenAI-compatible providers, these are ChatCompletionTool definitions.
+	 */
+	tools?: OpenAI.Chat.ChatCompletionTool[]
+	/**
+	 * Controls which (if any) tool is called by the model.
+	 * Can be "none", "auto", "required", or a specific tool choice.
+	 */
+	tool_choice?: OpenAI.Chat.ChatCompletionCreateParams["tool_choice"]
+	/**
+	 * The tool protocol being used (XML or Native).
+	 * Used by providers to determine whether to include native tool definitions.
+	 */
+	toolProtocol?: ToolProtocol
 }
 
 export interface ApiHandler {

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

@@ -33,6 +33,7 @@ vitest.mock("../fetchers/modelCache", () => ({
 				contextWindow: 200000,
 				supportsImages: true,
 				supportsPromptCache: true,
+				supportsNativeTools: true,
 				inputPrice: 3,
 				outputPrice: 15,
 				cacheWritesPrice: 3.75,
@@ -97,6 +98,7 @@ describe("OpenRouterHandler", () => {
 			const result = await handler.fetchModel()
 			expect(result.id).toBe("anthropic/claude-sonnet-4.5")
 			expect(result.info.supportsPromptCache).toBe(true)
+			expect(result.info.supportsNativeTools).toBe(true)
 		})
 
 		it("honors custom maxTokens for thinking models", async () => {

src/api/providers/fetchers/__tests__/openrouter.spec.ts

@@ -28,6 +28,7 @@ describe("OpenRouter API", () => {
 				description: expect.any(String),
 				supportsReasoningBudget: false,
 				supportsReasoningEffort: false,
+				supportsNativeTools: true,
 				supportedParameters: ["max_tokens", "temperature", "reasoning", "include_reasoning"],
 			})
 
@@ -44,6 +45,7 @@ describe("OpenRouter API", () => {
 				supportsReasoningBudget: true,
 				requiredReasoningBudget: true,
 				supportsReasoningEffort: true,
+				supportsNativeTools: true,
 				supportedParameters: ["max_tokens", "temperature", "reasoning", "include_reasoning"],
 			})
 
@@ -96,6 +98,7 @@ describe("OpenRouter API", () => {
 					cacheReadsPrice: 0.31,
 					description: undefined,
 					supportsReasoningEffort: undefined,
+					supportsNativeTools: undefined,
 					supportedParameters: undefined,
 				},
 				"google-ai-studio": {
@@ -110,6 +113,7 @@ describe("OpenRouter API", () => {
 					cacheReadsPrice: 0.31,
 					description: undefined,
 					supportsReasoningEffort: undefined,
+					supportsNativeTools: undefined,
 					supportedParameters: undefined,
 				},
 			})

src/api/providers/fetchers/__tests__/roo.spec.ts

@@ -68,6 +68,7 @@ describe("getRooModels", () => {
 				supportsImages: true,
 				supportsReasoningEffort: true,
 				requiredReasoningEffort: false,
+				supportsNativeTools: false,
 				supportsPromptCache: true,
 				inputPrice: 100, // 0.0001 * 1_000_000
 				outputPrice: 200, // 0.0002 * 1_000_000
@@ -116,6 +117,7 @@ describe("getRooModels", () => {
 			supportsImages: false,
 			supportsReasoningEffort: true,
 			requiredReasoningEffort: true,
+			supportsNativeTools: false,
 			supportsPromptCache: false,
 			inputPrice: 100, // 0.0001 * 1_000_000
 			outputPrice: 200, // 0.0002 * 1_000_000
@@ -162,6 +164,7 @@ describe("getRooModels", () => {
 			supportsImages: false,
 			supportsReasoningEffort: false,
 			requiredReasoningEffort: false,
+			supportsNativeTools: false,
 			supportsPromptCache: false,
 			inputPrice: 100, // 0.0001 * 1_000_000
 			outputPrice: 200, // 0.0002 * 1_000_000

src/api/providers/fetchers/openrouter.ts

@@ -115,14 +115,16 @@ export async function getOpenRouterModels(options?: ApiHandlerOptions): Promise<
 				continue
 			}
 
-			models[id] = parseOpenRouterModel({
+			const parsedModel = parseOpenRouterModel({
 				id,
 				model,
 				inputModality: architecture?.input_modalities,
 				outputModality: architecture?.output_modalities,
 				maxTokens: top_provider?.max_completion_tokens,
 				supportedParameters: supported_parameters,
 			})
+
+			models[id] = parsedModel
 		}
 	} catch (error) {
 		console.error(
@@ -216,6 +218,7 @@ export const parseOpenRouterModel = ({
 		cacheReadsPrice,
 		description: model.description,
 		supportsReasoningEffort: supportedParameters ? supportedParameters.includes("reasoning") : undefined,
+		supportsNativeTools: supportedParameters ? supportedParameters.includes("tools") : undefined,
 		supportedParameters: supportedParameters ? supportedParameters.filter(isModelParameter) : undefined,
 	}
 

src/api/providers/fetchers/roo.ts

@@ -92,6 +92,9 @@ export async function getRooModels(baseUrl: string, apiKey?: string): Promise<Mo
 				// Determine if the model requires reasoning effort based on tags
 				const requiredReasoningEffort = tags.includes("reasoning-required")
 
+				// Determine if the model supports native tool calling based on tags
+				const supportsNativeTools = tags.includes("tool-use")
+
 				// Parse pricing (API returns strings, convert to numbers)
 				const inputPrice = parseApiPrice(pricing.input)
 				const outputPrice = parseApiPrice(pricing.output)
@@ -104,6 +107,7 @@ export async function getRooModels(baseUrl: string, apiKey?: string): Promise<Mo
 					supportsImages,
 					supportsReasoningEffort,
 					requiredReasoningEffort,
+					supportsNativeTools,
 					supportsPromptCache: Boolean(cacheReadPrice !== undefined),
 					inputPrice,
 					outputPrice,

src/api/providers/openrouter.ts

@@ -24,7 +24,7 @@ import { getModelEndpoints } from "./fetchers/modelEndpointCache"
 
 import { DEFAULT_HEADERS } from "./constants"
 import { BaseProvider } from "./base-provider"
-import type { SingleCompletionHandler } from "../index"
+import type { ApiHandlerCreateMessageMetadata, SingleCompletionHandler } from "../index"
 import { handleOpenAIError } from "./utils/openai-error-handler"
 
 // Image generation types
@@ -96,11 +96,38 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 		const apiKey = this.options.openRouterApiKey ?? "not-provided"
 
 		this.client = new OpenAI({ baseURL, apiKey, defaultHeaders: DEFAULT_HEADERS })
+
+		// Load models asynchronously to populate cache before getModel() is called
+		this.loadDynamicModels().catch((error) => {
+			console.error("[OpenRouterHandler] Failed to load dynamic models:", error)
+		})
+	}
+
+	private async loadDynamicModels(): Promise<void> {
+		try {
+			const [models, endpoints] = await Promise.all([
+				getModels({ provider: "openrouter" }),
+				getModelEndpoints({
+					router: "openrouter",
+					modelId: this.options.openRouterModelId,
+					endpoint: this.options.openRouterSpecificProvider,
+				}),
+			])
+
+			this.models = models
+			this.endpoints = endpoints
+		} catch (error) {
+			console.error("[OpenRouterHandler] Error loading dynamic models:", {
+				error: error instanceof Error ? error.message : String(error),
+				stack: error instanceof Error ? error.stack : undefined,
+			})
+		}
 	}
 
 	override async *createMessage(
 		systemPrompt: string,
 		messages: Anthropic.Messages.MessageParam[],
+		metadata?: ApiHandlerCreateMessageMetadata,
 	): AsyncGenerator<ApiStreamChunk> {
 		const model = await this.fetchModel()
 
@@ -159,8 +186,11 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 						allow_fallbacks: false,
 					},
 				}),
+			parallel_tool_calls: false, // Ensure only one tool call at a time
 			...(transforms && { transforms }),
 			...(reasoning && { reasoning }),
+			...(metadata?.tools && { tools: metadata.tools }),
+			...(metadata?.tool_choice && { tool_choice: metadata.tool_choice }),
 		}
 
 		let stream
@@ -171,6 +201,7 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 		}
 
 		let lastUsage: CompletionUsage | undefined = undefined
+		const toolCallAccumulator = new Map<number, { id: string; name: string; arguments: string }>()
 
 		for await (const chunk of stream) {
 			// OpenRouter returns an error object instead of the OpenAI SDK throwing an error.
@@ -181,13 +212,52 @@ export class OpenRouterHandler extends BaseProvider implements SingleCompletionH
 			}
 
 			const delta = chunk.choices[0]?.delta
+			const finishReason = chunk.choices[0]?.finish_reason
+
+			if (delta) {
+				if ("reasoning" in delta && delta.reasoning && typeof delta.reasoning === "string") {
+					yield { type: "reasoning", text: delta.reasoning }
+				}
 
-			if ("reasoning" in delta && delta.reasoning && typeof delta.reasoning === "string") {
-				yield { type: "reasoning", text: delta.reasoning }
+				// Check for tool calls in delta
+				if ("tool_calls" in delta && Array.isArray(delta.tool_calls)) {
+					for (const toolCall of delta.tool_calls) {
+						const index = toolCall.index
+						const existing = toolCallAccumulator.get(index)
+
+						if (existing) {
+							// Accumulate arguments for existing tool call
+							if (toolCall.function?.arguments) {
+								existing.arguments += toolCall.function.arguments
+							}
+						} else {
+							// Start new tool call accumulation
+							toolCallAccumulator.set(index, {
+								id: toolCall.id || "",
+								name: toolCall.function?.name || "",
+								arguments: toolCall.function?.arguments || "",
+							})
+						}
+					}
+				}
+
+				if (delta.content) {
+					yield { type: "text", text: delta.content }
+				}
 			}
 
-			if (delta?.content) {
-				yield { type: "text", text: delta.content }
+			// When finish_reason is 'tool_calls', yield all accumulated tool calls
+			if (finishReason === "tool_calls" && toolCallAccumulator.size > 0) {
+				for (const toolCall of toolCallAccumulator.values()) {
+					yield {
+						type: "tool_call",
+						id: toolCall.id,
+						name: toolCall.name,
+						arguments: toolCall.arguments,
+					}
+				}
+				// Clear accumulator after yielding
+				toolCallAccumulator.clear()
 			}
 
 			if (chunk.usage) {