diff --git a/packages/types/src/index.ts b/packages/types/src/index.ts index 7a7d5059eb0..ebebb72313c 100644 --- a/packages/types/src/index.ts +++ b/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" diff --git a/packages/types/src/model.ts b/packages/types/src/model.ts index 748acb28580..49a13651e26 100644 --- a/packages/types/src/model.ts +++ b/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. diff --git a/packages/types/src/providers/openrouter.ts b/packages/types/src/providers/openrouter.ts index e1515707968..22285fe6f56 100644 --- a/packages/types/src/providers/openrouter.ts +++ b/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, diff --git a/packages/types/src/tool-params.ts b/packages/types/src/tool-params.ts new file mode 100644 index 00000000000..36f69f71001 --- /dev/null +++ b/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 +} diff --git a/packages/types/src/tool.ts b/packages/types/src/tool.ts index 9d4269b9fa6..ae4ddb72fb7 100644 --- a/packages/types/src/tool.ts +++ b/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 +} diff --git a/src/api/index.ts b/src/api/index.ts index ae8be513496..05c74930787 100644 --- a/src/api/index.ts +++ b/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 { diff --git a/src/api/providers/__tests__/openrouter.spec.ts b/src/api/providers/__tests__/openrouter.spec.ts index f5067ef34c9..118be755d70 100644 --- a/src/api/providers/__tests__/openrouter.spec.ts +++ b/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 () => { diff --git a/src/api/providers/fetchers/__tests__/openrouter.spec.ts b/src/api/providers/fetchers/__tests__/openrouter.spec.ts index 37cdc544398..d1faa1162ec 100644 --- a/src/api/providers/fetchers/__tests__/openrouter.spec.ts +++ b/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, }, }) diff --git a/src/api/providers/fetchers/__tests__/roo.spec.ts b/src/api/providers/fetchers/__tests__/roo.spec.ts index dcc79e941fa..0fa574cff16 100644 --- a/src/api/providers/fetchers/__tests__/roo.spec.ts +++ b/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 diff --git a/src/api/providers/fetchers/openrouter.ts b/src/api/providers/fetchers/openrouter.ts index b546c40a3cf..38d3c52fa94 100644 --- a/src/api/providers/fetchers/openrouter.ts +++ b/src/api/providers/fetchers/openrouter.ts @@ -115,7 +115,7 @@ export async function getOpenRouterModels(options?: ApiHandlerOptions): Promise< continue } - models[id] = parseOpenRouterModel({ + const parsedModel = parseOpenRouterModel({ id, model, inputModality: architecture?.input_modalities, @@ -123,6 +123,8 @@ export async function getOpenRouterModels(options?: ApiHandlerOptions): Promise< 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, } diff --git a/src/api/providers/fetchers/roo.ts b/src/api/providers/fetchers/roo.ts index 3b0da006a5c..a1671e3b8d2 100644 --- a/src/api/providers/fetchers/roo.ts +++ b/src/api/providers/fetchers/roo.ts @@ -92,6 +92,9 @@ export async function getRooModels(baseUrl: string, apiKey?: string): Promise { + console.error("[OpenRouterHandler] Failed to load dynamic models:", error) + }) + } + + private async loadDynamicModels(): Promise { + 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 { 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() 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) { diff --git a/src/api/providers/roo.ts b/src/api/providers/roo.ts index dd968f2e2f8..77769aab263 100644 --- a/src/api/providers/roo.ts +++ b/src/api/providers/roo.ts @@ -100,6 +100,8 @@ export class RooHandler extends BaseOpenAiCompatibleProvider { stream: true, stream_options: { include_usage: true }, ...(reasoning && { reasoning }), + ...(metadata?.tools && { tools: metadata.tools }), + ...(metadata?.tool_choice && { tool_choice: metadata.tool_choice }), } try { @@ -124,9 +126,12 @@ export class RooHandler extends BaseOpenAiCompatibleProvider { ) let lastUsage: RooUsage | undefined = undefined + // Accumulate tool calls by index - similar to how reasoning accumulates + const toolCallAccumulator = new Map() for await (const chunk of stream) { const delta = chunk.choices[0]?.delta + const finishReason = chunk.choices[0]?.finish_reason if (delta) { // Check for reasoning content (similar to OpenRouter) @@ -145,6 +150,28 @@ export class RooHandler extends BaseOpenAiCompatibleProvider { } } + // 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", @@ -153,6 +180,20 @@ export class RooHandler extends BaseOpenAiCompatibleProvider { } } + // When finish_reason is 'tool_calls', yield all accumulated tool calls + if (finishReason === "tool_calls" && toolCallAccumulator.size > 0) { + for (const [index, toolCall] of toolCallAccumulator.entries()) { + yield { + type: "tool_call", + id: toolCall.id, + name: toolCall.name, + arguments: toolCall.arguments, + } + } + // Clear accumulator after yielding + toolCallAccumulator.clear() + } + if (chunk.usage) { lastUsage = chunk.usage as RooUsage } @@ -241,6 +282,7 @@ export class RooHandler extends BaseOpenAiCompatibleProvider { supportsImages: false, supportsReasoningEffort: false, supportsPromptCache: true, + supportsNativeTools: false, inputPrice: 0, outputPrice: 0, }, diff --git a/src/api/transform/stream.ts b/src/api/transform/stream.ts index 8484e625958..cd6c3a56a72 100644 --- a/src/api/transform/stream.ts +++ b/src/api/transform/stream.ts @@ -5,6 +5,7 @@ export type ApiStreamChunk = | ApiStreamUsageChunk | ApiStreamReasoningChunk | ApiStreamGroundingChunk + | ApiStreamToolCallChunk | ApiStreamError export interface ApiStreamError { @@ -38,6 +39,13 @@ export interface ApiStreamGroundingChunk { sources: GroundingSource[] } +export interface ApiStreamToolCallChunk { + type: "tool_call" + id: string + name: string + arguments: string +} + export interface GroundingSource { title: string url: string diff --git a/src/core/assistant-message/NativeToolCallParser.ts b/src/core/assistant-message/NativeToolCallParser.ts new file mode 100644 index 00000000000..2308c28ea6b --- /dev/null +++ b/src/core/assistant-message/NativeToolCallParser.ts @@ -0,0 +1,312 @@ +import { type ToolName, toolNames, type FileEntry } from "@roo-code/types" +import { type ToolUse, type ToolParamName, toolParamNames, type NativeToolArgs } from "../../shared/tools" + +/** + * Helper type to extract properly typed native arguments for a given tool. + * Returns the type from NativeToolArgs if the tool is defined there, otherwise never. + */ +type NativeArgsFor = TName extends keyof NativeToolArgs ? NativeToolArgs[TName] : never + +/** + * Parser for native tool calls (OpenAI-style function calling). + * Converts native tool call format to ToolUse format for compatibility + * with existing tool execution infrastructure. + * + * For tools with refactored parsers (e.g., read_file), this parser provides + * typed arguments via nativeArgs. Tool-specific handlers should consume + * nativeArgs directly rather than relying on synthesized legacy params. + */ +export class NativeToolCallParser { + /** + * Convert a native tool call chunk to a ToolUse object. + * + * @param toolCall - The native tool call from the API stream + * @returns A properly typed ToolUse object + */ + public static parseToolCall(toolCall: { + id: string + name: TName + arguments: string + }): ToolUse | null { + // Check if this is a dynamic MCP tool (mcp_serverName_toolName) + if (typeof toolCall.name === "string" && toolCall.name.startsWith("mcp_")) { + return this.parseDynamicMcpTool(toolCall) as ToolUse | null + } + + // Validate tool name + if (!toolNames.includes(toolCall.name as ToolName)) { + console.error(`Invalid tool name: ${toolCall.name}`) + console.error(`Valid tool names:`, toolNames) + return null + } + + try { + // Parse the arguments JSON string + const args = JSON.parse(toolCall.arguments) + + // Build legacy params object for backward compatibility with XML protocol and UI. + // Native execution path uses nativeArgs instead, which has proper typing. + const params: Partial> = {} + + for (const [key, value] of Object.entries(args)) { + // Skip complex parameters that have been migrated to nativeArgs. + // For read_file, the 'files' parameter is a FileEntry[] array that can't be + // meaningfully stringified. The properly typed data is in nativeArgs instead. + if (toolCall.name === "read_file" && key === "files") { + continue + } + + // Validate parameter name + if (!toolParamNames.includes(key as ToolParamName)) { + console.warn(`Unknown parameter '${key}' for tool '${toolCall.name}'`) + console.warn(`Valid param names:`, toolParamNames) + continue + } + + // Convert to string for legacy params format + const stringValue = typeof value === "string" ? value : JSON.stringify(value) + params[key as ToolParamName] = stringValue + } + + // Build typed nativeArgs for tools that support it. + // This switch statement serves two purposes: + // 1. Validation: Ensures required parameters are present before constructing nativeArgs + // 2. Transformation: Converts raw JSON to properly typed structures + // + // Each case validates the minimum required parameters and constructs a properly typed + // nativeArgs object. If validation fails, nativeArgs remains undefined and the tool + // will fall back to legacy parameter parsing if supported. + let nativeArgs: NativeArgsFor | undefined = undefined + + switch (toolCall.name) { + case "read_file": + if (args.files && Array.isArray(args.files)) { + nativeArgs = args.files as NativeArgsFor + } + break + + case "attempt_completion": + if (args.result) { + nativeArgs = { result: args.result } as NativeArgsFor + } + break + + case "execute_command": + if (args.command) { + nativeArgs = { + command: args.command, + cwd: args.cwd, + } as NativeArgsFor + } + break + + case "insert_content": + if (args.path !== undefined && args.line !== undefined && args.content !== undefined) { + nativeArgs = { + path: args.path, + line: typeof args.line === "number" ? args.line : parseInt(String(args.line), 10), + content: args.content, + } as NativeArgsFor + } + break + + case "apply_diff": + if (args.path !== undefined && args.diff !== undefined) { + nativeArgs = { + path: args.path, + diff: args.diff, + } as NativeArgsFor + } + break + + case "ask_followup_question": + if (args.question !== undefined && args.follow_up !== undefined) { + nativeArgs = { + question: args.question, + follow_up: args.follow_up, + } as NativeArgsFor + } + break + + case "browser_action": + if (args.action !== undefined) { + nativeArgs = { + action: args.action, + url: args.url, + coordinate: args.coordinate, + size: args.size, + text: args.text, + } as NativeArgsFor + } + break + + case "codebase_search": + if (args.query !== undefined) { + nativeArgs = { + query: args.query, + path: args.path, + } as NativeArgsFor + } + break + + case "fetch_instructions": + if (args.task !== undefined) { + nativeArgs = { + task: args.task, + } as NativeArgsFor + } + break + + case "generate_image": + if (args.prompt !== undefined && args.path !== undefined) { + nativeArgs = { + prompt: args.prompt, + path: args.path, + image: args.image, + } as NativeArgsFor + } + break + + case "list_code_definition_names": + if (args.path !== undefined) { + nativeArgs = { + path: args.path, + } as NativeArgsFor + } + break + + case "run_slash_command": + if (args.command !== undefined) { + nativeArgs = { + command: args.command, + args: args.args, + } as NativeArgsFor + } + break + + case "search_files": + if (args.path !== undefined && args.regex !== undefined) { + nativeArgs = { + path: args.path, + regex: args.regex, + file_pattern: args.file_pattern, + } as NativeArgsFor + } + break + + case "switch_mode": + if (args.mode_slug !== undefined && args.reason !== undefined) { + nativeArgs = { + mode_slug: args.mode_slug, + reason: args.reason, + } as NativeArgsFor + } + break + + case "update_todo_list": + if (args.todos !== undefined) { + nativeArgs = { + todos: args.todos, + } as NativeArgsFor + } + break + + case "write_to_file": + if (args.path !== undefined && args.content !== undefined && args.line_count !== undefined) { + nativeArgs = { + path: args.path, + content: args.content, + line_count: + typeof args.line_count === "number" + ? args.line_count + : parseInt(String(args.line_count), 10), + } as NativeArgsFor + } + break + + case "use_mcp_tool": + if (args.server_name !== undefined && args.tool_name !== undefined) { + nativeArgs = { + server_name: args.server_name, + tool_name: args.tool_name, + arguments: args.arguments, + } as NativeArgsFor + } + break + + default: + break + } + + const result: ToolUse = { + type: "tool_use" as const, + name: toolCall.name, + params, + partial: false, // Native tool calls are always complete when yielded + nativeArgs, + } + + return result + } catch (error) { + console.error(`Failed to parse tool call arguments:`, error) + console.error(`Error details:`, error instanceof Error ? error.message : String(error)) + return null + } + } + + /** + * Parse dynamic MCP tools (named mcp_serverName_toolName). + * These are generated dynamically by getMcpServerTools() and need to be + * converted back to use_mcp_tool format. + */ + private static parseDynamicMcpTool(toolCall: { + id: string + name: string + arguments: string + }): ToolUse<"use_mcp_tool"> | null { + try { + const args = JSON.parse(toolCall.arguments) + + // Extract server_name and tool_name from the arguments + // The dynamic tool schema includes these as const properties + const serverName = args.server_name + const toolName = args.tool_name + const toolInputProps = args.toolInputProps + + if (!serverName || !toolName) { + console.error(`Missing server_name or tool_name in dynamic MCP tool`) + return null + } + + // Build params for backward compatibility with XML protocol + const params: Partial> = { + server_name: serverName, + tool_name: toolName, + } + + if (toolInputProps) { + params.arguments = JSON.stringify(toolInputProps) + } + + // Build nativeArgs with properly typed structure + const nativeArgs: NativeToolArgs["use_mcp_tool"] = { + server_name: serverName, + tool_name: toolName, + arguments: toolInputProps, + } + + const result: ToolUse<"use_mcp_tool"> = { + type: "tool_use" as const, + name: "use_mcp_tool", + params, + partial: false, + nativeArgs, + } + + return result + } catch (error) { + console.error(`Failed to parse dynamic MCP tool:`, error) + return null + } + } +} diff --git a/src/core/assistant-message/presentAssistantMessage.ts b/src/core/assistant-message/presentAssistantMessage.ts index 2249c008d67..7e0b74db100 100644 --- a/src/core/assistant-message/presentAssistantMessage.ts +++ b/src/core/assistant-message/presentAssistantMessage.ts @@ -1,41 +1,44 @@ import cloneDeep from "clone-deep" import { serializeError } from "serialize-error" +import { Anthropic } from "@anthropic-ai/sdk" import type { ToolName, ClineAsk, ToolProgressStatus } from "@roo-code/types" import { TelemetryService } from "@roo-code/telemetry" import { defaultModeSlug, getModeBySlug } from "../../shared/modes" -import type { ToolParamName, ToolResponse } from "../../shared/tools" +import type { ToolParamName, ToolResponse, ToolUse } from "../../shared/tools" -import { fetchInstructionsTool } from "../tools/fetchInstructionsTool" -import { listFilesTool } from "../tools/listFilesTool" -import { getReadFileToolDescription, readFileTool } from "../tools/readFileTool" +import { fetchInstructionsTool } from "../tools/FetchInstructionsTool" +import { listFilesTool } from "../tools/ListFilesTool" +import { readFileTool } from "../tools/ReadFileTool" import { getSimpleReadFileToolDescription, simpleReadFileTool } from "../tools/simpleReadFileTool" import { shouldUseSingleFileRead } from "@roo-code/types" -import { writeToFileTool } from "../tools/writeToFileTool" -import { applyDiffTool } from "../tools/multiApplyDiffTool" -import { insertContentTool } from "../tools/insertContentTool" -import { listCodeDefinitionNamesTool } from "../tools/listCodeDefinitionNamesTool" -import { searchFilesTool } from "../tools/searchFilesTool" -import { browserActionTool } from "../tools/browserActionTool" -import { executeCommandTool } from "../tools/executeCommandTool" -import { useMcpToolTool } from "../tools/useMcpToolTool" +import { writeToFileTool } from "../tools/WriteToFileTool" +import { applyDiffTool } from "../tools/MultiApplyDiffTool" +import { insertContentTool } from "../tools/InsertContentTool" +import { listCodeDefinitionNamesTool } from "../tools/ListCodeDefinitionNamesTool" +import { searchFilesTool } from "../tools/SearchFilesTool" +import { browserActionTool } from "../tools/BrowserActionTool" +import { executeCommandTool } from "../tools/ExecuteCommandTool" +import { useMcpToolTool } from "../tools/UseMcpToolTool" import { accessMcpResourceTool } from "../tools/accessMcpResourceTool" -import { askFollowupQuestionTool } from "../tools/askFollowupQuestionTool" -import { switchModeTool } from "../tools/switchModeTool" -import { attemptCompletionTool } from "../tools/attemptCompletionTool" -import { newTaskTool } from "../tools/newTaskTool" +import { askFollowupQuestionTool } from "../tools/AskFollowupQuestionTool" +import { switchModeTool } from "../tools/SwitchModeTool" +import { attemptCompletionTool, AttemptCompletionCallbacks } from "../tools/AttemptCompletionTool" +import { newTaskTool } from "../tools/NewTaskTool" -import { updateTodoListTool } from "../tools/updateTodoListTool" -import { runSlashCommandTool } from "../tools/runSlashCommandTool" -import { generateImageTool } from "../tools/generateImageTool" +import { updateTodoListTool } from "../tools/UpdateTodoListTool" +import { runSlashCommandTool } from "../tools/RunSlashCommandTool" +import { generateImageTool } from "../tools/GenerateImageTool" import { formatResponse } from "../prompts/responses" import { validateToolUse } from "../tools/validateToolUse" import { Task } from "../task/Task" -import { codebaseSearchTool } from "../tools/codebaseSearchTool" +import { codebaseSearchTool } from "../tools/CodebaseSearchTool" import { experiments, EXPERIMENT_IDS } from "../../shared/experiments" -import { applyDiffToolLegacy } from "../tools/applyDiffTool" +import { applyDiffTool as applyDiffToolClass } from "../tools/ApplyDiffTool" +import * as vscode from "vscode" +import { ToolProtocol, isNativeProtocol } from "@roo-code/types" /** * Processes and presents assistant message content to the user interface. @@ -80,7 +83,18 @@ export async function presentAssistantMessage(cline: Task) { return } - const block = cloneDeep(cline.assistantMessageContent[cline.currentStreamingContentIndex]) // need to create copy bc while stream is updating the array, it could be updating the reference block properties too + let block: any + try { + block = cloneDeep(cline.assistantMessageContent[cline.currentStreamingContentIndex]) // need to create copy bc while stream is updating the array, it could be updating the reference block properties too + } catch (error) { + console.error(`ERROR cloning block:`, error) + console.error( + `Block content:`, + JSON.stringify(cline.assistantMessageContent[cline.currentStreamingContentIndex], null, 2), + ) + cline.presentAssistantMessageLocked = false + return + } switch (block.type) { case "text": { @@ -163,7 +177,12 @@ export async function presentAssistantMessage(cline: Task) { if (shouldUseSingleFileRead(modelId)) { return getSimpleReadFileToolDescription(block.name, block.params) } else { - return getReadFileToolDescription(block.name, block.params) + // Prefer native typed args when available; fall back to legacy params + // Check if nativeArgs exists and is an array (native protocol) + if (Array.isArray(block.nativeArgs)) { + return readFileTool.getReadFileToolDescription(block.name, block.nativeArgs) + } + return readFileTool.getReadFileToolDescription(block.name, block.params) } case "fetch_instructions": return `[${block.name} for '${block.params.task}']` @@ -224,6 +243,8 @@ export async function presentAssistantMessage(cline: Task) { return `[${block.name} for '${block.params.command}'${block.params.args ? ` with args: ${block.params.args}` : ""}]` case "generate_image": return `[${block.name} for '${block.params.path}']` + default: + return `[${block.name}]` } } @@ -256,12 +277,52 @@ export async function presentAssistantMessage(cline: Task) { } const pushToolResult = (content: ToolResponse) => { - cline.userMessageContent.push({ type: "text", text: `${toolDescription()} Result:` }) + // Check if we're using native tool protocol + const toolProtocol = vscode.workspace + .getConfiguration("roo-cline") + .get("toolProtocol", "xml") + const isNative = isNativeProtocol(toolProtocol) + + // Get the tool call ID if this is a native tool call + const toolCallId = (block as any).id + + if (isNative && toolCallId) { + // For native protocol, add as tool_result block + let resultContent: string + if (typeof content === "string") { + resultContent = content || "(tool did not return anything)" + } else { + // Convert array of content blocks to string for tool result + // Tool results in OpenAI format only support strings + resultContent = content + .map((item) => { + if (item.type === "text") { + return item.text + } else if (item.type === "image") { + return "(image content)" + } + return "" + }) + .join("\n") + } - if (typeof content === "string") { - cline.userMessageContent.push({ type: "text", text: content || "(tool did not return anything)" }) + cline.userMessageContent.push({ + type: "tool_result", + tool_use_id: toolCallId, + content: resultContent, + } as Anthropic.ToolResultBlockParam) } else { - cline.userMessageContent.push(...content) + // For XML protocol, add as text blocks (legacy behavior) + cline.userMessageContent.push({ type: "text", text: `${toolDescription()} Result:` }) + + if (typeof content === "string") { + cline.userMessageContent.push({ + type: "text", + text: content || "(tool did not return anything)", + }) + } else { + cline.userMessageContent.push(...content) + } } // Once a tool result has been collected, ignore all other tool @@ -422,12 +483,38 @@ export async function presentAssistantMessage(cline: Task) { switch (block.name) { case "write_to_file": await checkpointSaveAndMark(cline) - await writeToFileTool(cline, block, askApproval, handleError, pushToolResult, removeClosingTag) + await writeToFileTool.handle(cline, block as ToolUse<"write_to_file">, { + askApproval, + handleError, + pushToolResult, + removeClosingTag, + }) break case "update_todo_list": - await updateTodoListTool(cline, block, askApproval, handleError, pushToolResult, removeClosingTag) + await updateTodoListTool.handle(cline, block as ToolUse<"update_todo_list">, { + askApproval, + handleError, + pushToolResult, + removeClosingTag, + }) break case "apply_diff": { + await checkpointSaveAndMark(cline) + + // Check if native protocol is enabled - if so, always use single-file class-based tool + const toolProtocol = vscode.workspace + .getConfiguration("roo-cline") + .get("toolProtocol", "xml") + if (isNativeProtocol(toolProtocol)) { + await applyDiffToolClass.handle(cline, block as ToolUse<"apply_diff">, { + askApproval, + handleError, + pushToolResult, + removeClosingTag, + }) + break + } + // Get the provider and state to check experiment settings const provider = cline.providerRef.deref() let isMultiFileApplyDiffEnabled = false @@ -441,24 +528,25 @@ export async function presentAssistantMessage(cline: Task) { } if (isMultiFileApplyDiffEnabled) { - await checkpointSaveAndMark(cline) await applyDiffTool(cline, block, askApproval, handleError, pushToolResult, removeClosingTag) } else { - await checkpointSaveAndMark(cline) - await applyDiffToolLegacy( - cline, - block, + await applyDiffToolClass.handle(cline, block as ToolUse<"apply_diff">, { askApproval, handleError, pushToolResult, removeClosingTag, - ) + }) } break } case "insert_content": await checkpointSaveAndMark(cline) - await insertContentTool(cline, block, askApproval, handleError, pushToolResult, removeClosingTag) + await insertContentTool.handle(cline, block as ToolUse<"insert_content">, { + askApproval, + handleError, + pushToolResult, + removeClosingTag, + }) break case "read_file": // Check if this model should use the simplified single-file read tool @@ -473,39 +561,78 @@ export async function presentAssistantMessage(cline: Task) { removeClosingTag, ) } else { - await readFileTool(cline, block, askApproval, handleError, pushToolResult, removeClosingTag) + // Type assertion is safe here because we're in the "read_file" case + await readFileTool.handle(cline, block as ToolUse<"read_file">, { + askApproval, + handleError, + pushToolResult, + removeClosingTag, + }) } break case "fetch_instructions": - await fetchInstructionsTool(cline, block, askApproval, handleError, pushToolResult) + await fetchInstructionsTool.handle(cline, block as ToolUse<"fetch_instructions">, { + askApproval, + handleError, + pushToolResult, + removeClosingTag, + }) break case "list_files": - await listFilesTool(cline, block, askApproval, handleError, pushToolResult, removeClosingTag) + await listFilesTool.handle(cline, block as ToolUse<"list_files">, { + askApproval, + handleError, + pushToolResult, + removeClosingTag, + }) break case "codebase_search": - await codebaseSearchTool(cline, block, askApproval, handleError, pushToolResult, removeClosingTag) + await codebaseSearchTool.handle(cline, block as ToolUse<"codebase_search">, { + askApproval, + handleError, + pushToolResult, + removeClosingTag, + }) break case "list_code_definition_names": - await listCodeDefinitionNamesTool( - cline, - block, + await listCodeDefinitionNamesTool.handle(cline, block as ToolUse<"list_code_definition_names">, { askApproval, handleError, pushToolResult, removeClosingTag, - ) + }) break case "search_files": - await searchFilesTool(cline, block, askApproval, handleError, pushToolResult, removeClosingTag) + await searchFilesTool.handle(cline, block as ToolUse<"search_files">, { + askApproval, + handleError, + pushToolResult, + removeClosingTag, + }) break case "browser_action": - await browserActionTool(cline, block, askApproval, handleError, pushToolResult, removeClosingTag) + await browserActionTool.handle(cline, block as ToolUse<"browser_action">, { + askApproval, + handleError, + pushToolResult, + removeClosingTag, + }) break case "execute_command": - await executeCommandTool(cline, block, askApproval, handleError, pushToolResult, removeClosingTag) + await executeCommandTool.handle(cline, block as ToolUse<"execute_command">, { + askApproval, + handleError, + pushToolResult, + removeClosingTag, + }) break case "use_mcp_tool": - await useMcpToolTool(cline, block, askApproval, handleError, pushToolResult, removeClosingTag) + await useMcpToolTool.handle(cline, block as ToolUse<"use_mcp_tool">, { + askApproval, + handleError, + pushToolResult, + removeClosingTag, + }) break case "access_mcp_resource": await accessMcpResourceTool( @@ -518,38 +645,61 @@ export async function presentAssistantMessage(cline: Task) { ) break case "ask_followup_question": - await askFollowupQuestionTool( - cline, - block, + await askFollowupQuestionTool.handle(cline, block as ToolUse<"ask_followup_question">, { askApproval, handleError, pushToolResult, removeClosingTag, - ) + }) break case "switch_mode": - await switchModeTool(cline, block, askApproval, handleError, pushToolResult, removeClosingTag) + await switchModeTool.handle(cline, block as ToolUse<"switch_mode">, { + askApproval, + handleError, + pushToolResult, + removeClosingTag, + }) break case "new_task": - await newTaskTool(cline, block, askApproval, handleError, pushToolResult, removeClosingTag) + await newTaskTool.handle(cline, block as ToolUse<"new_task">, { + askApproval, + handleError, + pushToolResult, + removeClosingTag, + }) break - case "attempt_completion": - await attemptCompletionTool( - cline, - block, + case "attempt_completion": { + const completionCallbacks: AttemptCompletionCallbacks = { askApproval, handleError, pushToolResult, removeClosingTag, - toolDescription, askFinishSubTaskApproval, + toolDescription, + } + await attemptCompletionTool.handle( + cline, + block as ToolUse<"attempt_completion">, + completionCallbacks, ) break + } case "run_slash_command": - await runSlashCommandTool(cline, block, askApproval, handleError, pushToolResult, removeClosingTag) + await runSlashCommandTool.handle(cline, block as ToolUse<"run_slash_command">, { + askApproval, + handleError, + pushToolResult, + removeClosingTag, + }) break case "generate_image": - await generateImageTool(cline, block, askApproval, handleError, pushToolResult, removeClosingTag) + await checkpointSaveAndMark(cline) + await generateImageTool.handle(cline, block as ToolUse<"generate_image">, { + askApproval, + handleError, + pushToolResult, + removeClosingTag, + }) break } @@ -596,6 +746,12 @@ export async function presentAssistantMessage(cline: Task) { // this function ourselves. presentAssistantMessage(cline) return + } else { + // CRITICAL FIX: If we're out of bounds and the stream is complete, set userMessageContentReady + // This handles the case where assistantMessageContent is empty or becomes empty after processing + if (cline.didCompleteReadingStream) { + cline.userMessageContentReady = true + } } } diff --git a/src/core/prompts/__tests__/toolProtocolResolver.spec.ts b/src/core/prompts/__tests__/toolProtocolResolver.spec.ts deleted file mode 100644 index 0fe1522663b..00000000000 --- a/src/core/prompts/__tests__/toolProtocolResolver.spec.ts +++ /dev/null @@ -1,10 +0,0 @@ -// npx vitest core/prompts/__tests__/toolProtocolResolver.spec.ts - -import { describe, it, expect } from "vitest" -import { resolveToolProtocol } from "../toolProtocolResolver" - -describe("toolProtocolResolver", () => { - it("should default to xml protocol", () => { - expect(resolveToolProtocol()).toBe("xml") - }) -}) diff --git a/src/core/prompts/responses.ts b/src/core/prompts/responses.ts index 1c1212e70f1..99140f48be1 100644 --- a/src/core/prompts/responses.ts +++ b/src/core/prompts/responses.ts @@ -3,8 +3,8 @@ import * as path from "path" import * as diff from "diff" import { RooIgnoreController, LOCK_TEXT_SYMBOL } from "../ignore/RooIgnoreController" import { RooProtectedController } from "../protect/RooProtectedController" -import { resolveToolProtocol, isNativeProtocol } from "./toolProtocolResolver" -import { ToolProtocol } from "@roo-code/types" +import * as vscode from "vscode" +import { ToolProtocol, isNativeProtocol } from "@roo-code/types" export const formatResponse = { toolDenied: () => `The user denied this operation.`, @@ -249,6 +249,7 @@ Always ensure you provide all required parameters for the tool you wish to use.` * @returns The tool use instructions reminder text */ function getToolInstructionsReminder(protocol?: ToolProtocol): string { - const effectiveProtocol = protocol ?? resolveToolProtocol() + const effectiveProtocol = + protocol ?? vscode.workspace.getConfiguration("roo-cline").get("toolProtocol", "xml") return isNativeProtocol(effectiveProtocol) ? toolUseInstructionsReminderNative : toolUseInstructionsReminder } diff --git a/src/core/prompts/sections/custom-instructions.ts b/src/core/prompts/sections/custom-instructions.ts index 4e5e5d19ac3..a81d4bf9439 100644 --- a/src/core/prompts/sections/custom-instructions.ts +++ b/src/core/prompts/sections/custom-instructions.ts @@ -6,7 +6,7 @@ import { Dirent } from "fs" import { isLanguage } from "@roo-code/types" import type { SystemPromptSettings } from "../types" -import { getEffectiveProtocol, isNativeProtocol } from "../toolProtocolResolver" +import { getEffectiveProtocol, isNativeProtocol } from "@roo-code/types" import { LANGUAGES } from "../../../shared/language" import { getRooDirectoriesForCwd, getGlobalRooDirectory } from "../../../services/roo-config" @@ -369,7 +369,7 @@ export async function addCustomInstructions( const joinedSections = sections.join("\n\n") - const effectiveProtocol = getEffectiveProtocol(options.settings) + const effectiveProtocol = getEffectiveProtocol(options.settings?.toolProtocol) return joinedSections ? ` diff --git a/src/core/prompts/sections/mcp-servers.ts b/src/core/prompts/sections/mcp-servers.ts index 643233ab6f8..678099922f0 100644 --- a/src/core/prompts/sections/mcp-servers.ts +++ b/src/core/prompts/sections/mcp-servers.ts @@ -5,6 +5,7 @@ export async function getMcpServersSection( mcpHub?: McpHub, diffStrategy?: DiffStrategy, enableMcpServerCreation?: boolean, + includeToolDescriptions: boolean = true, ): Promise { if (!mcpHub) { return "" @@ -16,17 +17,20 @@ export async function getMcpServersSection( .getServers() .filter((server) => server.status === "connected") .map((server) => { - const tools = server.tools - ?.filter((tool) => tool.enabledForPrompt !== false) - ?.map((tool) => { - const schemaStr = tool.inputSchema - ? ` Input Schema: + // Only include tool descriptions when using XML protocol + const tools = includeToolDescriptions + ? server.tools + ?.filter((tool) => tool.enabledForPrompt !== false) + ?.map((tool) => { + const schemaStr = tool.inputSchema + ? ` Input Schema: ${JSON.stringify(tool.inputSchema, null, 2).split("\n").join("\n ")}` - : "" + : "" - return `- ${tool.name}: ${tool.description}\n${schemaStr}` - }) - .join("\n\n") + return `- ${tool.name}: ${tool.description}\n${schemaStr}` + }) + .join("\n\n") + : undefined const templates = server.resourceTemplates ?.map((template) => `- ${template.uriTemplate} (${template.name}): ${template.description}`) diff --git a/src/core/prompts/sections/rules.ts b/src/core/prompts/sections/rules.ts index 0eceb2dc98d..5a504d17faf 100644 --- a/src/core/prompts/sections/rules.ts +++ b/src/core/prompts/sections/rules.ts @@ -1,7 +1,7 @@ import { DiffStrategy } from "../../../shared/tools" import { CodeIndexManager } from "../../../services/code-index/manager" import type { SystemPromptSettings } from "../types" -import { getEffectiveProtocol, isNativeProtocol } from "../toolProtocolResolver" +import { getEffectiveProtocol, isNativeProtocol } from "@roo-code/types" function getEditingInstructions(diffStrategy?: DiffStrategy): string { const instructions: string[] = [] @@ -60,7 +60,7 @@ export function getRulesSection( : "" // Determine whether to use XML tool references based on protocol - const effectiveProtocol = getEffectiveProtocol(settings) + const effectiveProtocol = getEffectiveProtocol(settings?.toolProtocol) return `==== diff --git a/src/core/prompts/sections/tool-use-guidelines.ts b/src/core/prompts/sections/tool-use-guidelines.ts index 6258a1f13ac..c5651264a0a 100644 --- a/src/core/prompts/sections/tool-use-guidelines.ts +++ b/src/core/prompts/sections/tool-use-guidelines.ts @@ -1,6 +1,6 @@ import { ToolProtocol, TOOL_PROTOCOL } from "@roo-code/types" import { CodeIndexManager } from "../../../services/code-index/manager" -import { isNativeProtocol } from "../toolProtocolResolver" +import { isNativeProtocol } from "@roo-code/types" export function getToolUseGuidelinesSection( codeIndexManager?: CodeIndexManager, diff --git a/src/core/prompts/sections/tool-use.ts b/src/core/prompts/sections/tool-use.ts index e3f54a7d185..9ece848fb4e 100644 --- a/src/core/prompts/sections/tool-use.ts +++ b/src/core/prompts/sections/tool-use.ts @@ -1,5 +1,4 @@ -import { ToolProtocol, TOOL_PROTOCOL } from "@roo-code/types" -import { isNativeProtocol } from "../toolProtocolResolver" +import { ToolProtocol, TOOL_PROTOCOL, isNativeProtocol } from "@roo-code/types" export function getSharedToolUseSection(protocol: ToolProtocol = TOOL_PROTOCOL.XML): string { if (isNativeProtocol(protocol)) { diff --git a/src/core/prompts/system.ts b/src/core/prompts/system.ts index 3d45f7fcf0d..649083b10f4 100644 --- a/src/core/prompts/system.ts +++ b/src/core/prompts/system.ts @@ -16,7 +16,7 @@ import { CodeIndexManager } from "../../services/code-index/manager" import { PromptVariables, loadSystemPromptFile } from "./sections/custom-system-prompt" import { getToolDescriptionsForMode } from "./tools" -import { getEffectiveProtocol, isNativeProtocol } from "./toolProtocolResolver" +import { getEffectiveProtocol, isNativeProtocol } from "@roo-code/types" import { getRulesSection, getSystemInfoSection, @@ -29,7 +29,6 @@ import { addCustomInstructions, markdownFormattingSection, } from "./sections" -import { TOOL_PROTOCOL } from "@roo-code/types" // Helper function to get prompt component, filtering out empty objects export function getPromptComponent( @@ -81,18 +80,23 @@ async function generatePrompt( const hasMcpServers = mcpHub && mcpHub.getServers().length > 0 const shouldIncludeMcp = hasMcpGroup && hasMcpServers + const codeIndexManager = CodeIndexManager.getInstance(context, cwd) + + // Determine the effective protocol (defaults to 'xml') + const effectiveProtocol = getEffectiveProtocol(settings?.toolProtocol) + const [modesSection, mcpServersSection] = await Promise.all([ getModesSection(context), shouldIncludeMcp - ? getMcpServersSection(mcpHub, effectiveDiffStrategy, enableMcpServerCreation) + ? getMcpServersSection( + mcpHub, + effectiveDiffStrategy, + enableMcpServerCreation, + !isNativeProtocol(effectiveProtocol), + ) : Promise.resolve(""), ]) - const codeIndexManager = CodeIndexManager.getInstance(context, cwd) - - // Determine the effective protocol (defaults to 'xml') - const effectiveProtocol = getEffectiveProtocol(settings) - // Build tools catalog section only for XML protocol const toolsCatalog = isNativeProtocol(effectiveProtocol) ? "" diff --git a/src/core/prompts/toolProtocolResolver.ts b/src/core/prompts/toolProtocolResolver.ts deleted file mode 100644 index 1cd87f7251e..00000000000 --- a/src/core/prompts/toolProtocolResolver.ts +++ /dev/null @@ -1,38 +0,0 @@ -import { ToolProtocol, TOOL_PROTOCOL } from "@roo-code/types" -import type { SystemPromptSettings } from "./types" - -/** - * Current tool protocol setting. - * This is code-only and not exposed through VS Code settings. - * To switch protocols, edit this constant directly in the source code. - */ -const CURRENT_TOOL_PROTOCOL: ToolProtocol = TOOL_PROTOCOL.XML // change to TOOL_PROTOCOL.NATIVE to enable native protocol - -/** - * Resolves the effective tool protocol. - * - * @returns The effective tool protocol (defaults to "xml") - */ -export function resolveToolProtocol(): ToolProtocol { - return CURRENT_TOOL_PROTOCOL -} - -/** - * Gets the effective protocol from settings or falls back to the default. - * - * @param settings - Optional system prompt settings - * @returns The effective tool protocol - */ -export function getEffectiveProtocol(settings?: SystemPromptSettings): ToolProtocol { - return settings?.toolProtocol || resolveToolProtocol() -} - -/** - * 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 -} diff --git a/src/core/prompts/tools/native-tools/apply_diff.ts b/src/core/prompts/tools/native-tools/apply_diff.ts index 2c7351d4cf4..19ef8318843 100644 --- a/src/core/prompts/tools/native-tools/apply_diff.ts +++ b/src/core/prompts/tools/native-tools/apply_diff.ts @@ -19,12 +19,12 @@ Apply precise, targeted modifications to an existing file using one or more sear description: ` A string containing one or more search/replace blocks defining the changes. The ':start_line:' is required and indicates the starting line number of the original content. You must not add a start line for the replacement content. Each block must follow this format: <<<<<<< SEARCH - :start_line:[line_number] - ------- - [exact content to find] - ======= - [new content to replace with] - >>>>>>> REPLACE +:start_line:[line_number] +------- +[exact content to find] +======= +[new content to replace with] +>>>>>>> REPLACE `, }, }, @@ -33,61 +33,3 @@ A string containing one or more search/replace blocks defining the changes. The }, }, } satisfies OpenAI.Chat.ChatCompletionTool - -//@ts-ignore Preparing for when we enable multi-file diffs -export const apply_diff_multi_file = { - type: "function", - function: { - name: "apply_diff", - description: - "Apply precise, targeted modifications to one or more files by searching for specific sections of content and replacing them. This tool is for surgical edits only and supports making changes across multiple files in a single request. The 'SEARCH' block must exactly match the existing content, including whitespace and indentation. You must use this tool to edit multiple files in a single operation whenever possible.", - parameters: { - type: "object", - properties: { - files: { - type: "array", - description: "A list of file modification operations to perform.", - items: { - type: "object", - properties: { - path: { - type: "string", - description: - "The path of the file to modify, relative to the current workspace directory.", - }, - diffs: { - type: "array", - description: - "A list of diffs to apply to the file. Each diff is a distinct search/replace operation.", - items: { - type: "object", - properties: { - content: { - type: "string", - description: ` -The search/replace block defining the changes. The SEARCH block must exactly match the content to be replaced. Format: -'<<<<<<< SEARCH -[content_to_find] -======= -[content_to_replace_with] ->>>>>>> REPLACE - `, - }, - start_line: { - type: "integer", - description: - "The line number in the original file where the SEARCH block begins.", - }, - }, - required: ["content", "start_line"], - }, - }, - }, - required: ["path", "diffs"], - }, - }, - }, - required: ["files"], - }, - }, -} satisfies OpenAI.Chat.ChatCompletionTool diff --git a/src/core/prompts/tools/native-tools/edit_file.ts b/src/core/prompts/tools/native-tools/edit_file.ts deleted file mode 100644 index f4dcfeeaa4a..00000000000 --- a/src/core/prompts/tools/native-tools/edit_file.ts +++ /dev/null @@ -1,31 +0,0 @@ -import type OpenAI from "openai" - -export default { - type: "function", - function: { - name: "edit_file", - description: - "Use this tool to make an edit to a file. A less intelligent apply model will read your request, so be clear about the change while minimizing unchanged code. Specify each edit sequentially and replace omitted sections with // ... existing code ... placeholders. Provide enough surrounding context to avoid ambiguity, always use the placeholder when skipping existing content, show before-and-after context when deleting, and gather all edits for the file in a single request.", - strict: true, - parameters: { - type: "object", - properties: { - target_file: { - type: "string", - description: "Full path of the file to modify", - }, - instructions: { - type: "string", - description: "Single first-person sentence summarizing the edit to guide the apply model", - }, - code_edit: { - type: "string", - description: - "Only the edited lines using // ... existing code ... wherever unchanged content is omitted", - }, - }, - required: ["target_file", "instructions", "code_edit"], - additionalProperties: false, - }, - }, -} satisfies OpenAI.Chat.ChatCompletionTool diff --git a/src/core/prompts/tools/native-tools/index.ts b/src/core/prompts/tools/native-tools/index.ts index a25a67931b6..c12a681704e 100644 --- a/src/core/prompts/tools/native-tools/index.ts +++ b/src/core/prompts/tools/native-tools/index.ts @@ -3,7 +3,6 @@ import askFollowupQuestion from "./ask_followup_question" import attemptCompletion from "./attempt_completion" import browserAction from "./browser_action" import codebaseSearch from "./codebase_search" -import editFile from "./edit_file" import executeCommand from "./execute_command" import fetchInstructions from "./fetch_instructions" import generateImage from "./generate_image" @@ -11,26 +10,23 @@ import insertContent from "./insert_content" import listCodeDefinitionNames from "./list_code_definition_names" import listFiles from "./list_files" import newTask from "./new_task" -import { read_file_single, read_file_multi } from "./read_file" +import { read_file } from "./read_file" import runSlashCommand from "./run_slash_command" -import searchAndReplace from "./search_and_replace" import searchFiles from "./search_files" import switchMode from "./switch_mode" import updateTodoList from "./update_todo_list" import writeToFile from "./write_to_file" -import { apply_diff_single_file, apply_diff_multi_file } from "./apply_diff" +import { apply_diff_single_file } from "./apply_diff" export { getMcpServerTools } from "./mcp_server" export { convertOpenAIToolToAnthropic, convertOpenAIToolsToAnthropic } from "./converters" export const nativeTools = [ apply_diff_single_file, - apply_diff_multi_file, askFollowupQuestion, attemptCompletion, browserAction, codebaseSearch, - editFile, executeCommand, fetchInstructions, generateImage, @@ -38,10 +34,8 @@ export const nativeTools = [ listCodeDefinitionNames, listFiles, newTask, - read_file_single, - read_file_multi, + read_file, runSlashCommand, - searchAndReplace, searchFiles, switchMode, updateTodoList, diff --git a/src/core/prompts/tools/native-tools/mcp_server.ts b/src/core/prompts/tools/native-tools/mcp_server.ts index 628102da48b..e174e0f0779 100644 --- a/src/core/prompts/tools/native-tools/mcp_server.ts +++ b/src/core/prompts/tools/native-tools/mcp_server.ts @@ -63,7 +63,7 @@ export function getMcpServerTools(mcpHub?: McpHub): OpenAI.Chat.ChatCompletionTo const toolDefinition: OpenAI.Chat.ChatCompletionTool = { type: "function", function: { - name: `${server.name}___${tool.name}`, + name: `mcp_${server.name}_${tool.name}`, description: tool.description, parameters: parameters, }, diff --git a/src/core/prompts/tools/native-tools/read_file.ts b/src/core/prompts/tools/native-tools/read_file.ts index 147809617ea..7918826833d 100644 --- a/src/core/prompts/tools/native-tools/read_file.ts +++ b/src/core/prompts/tools/native-tools/read_file.ts @@ -1,6 +1,6 @@ import type OpenAI from "openai" -export const read_file_multi = { +export const read_file = { type: "function", function: { name: "read_file", @@ -41,24 +41,3 @@ export const read_file_multi = { }, }, } satisfies OpenAI.Chat.ChatCompletionTool - -export const read_file_single = { - type: "function", - function: { - name: "read_file", - description: - 'Request to read the contents of a file. The tool outputs line-numbered content (e.g. "1 | const x = 1") for easy reference when discussing code.', - strict: true, - parameters: { - type: "object", - properties: { - path: { - type: "string", - description: "Path to the file to read, relative to the workspace", - }, - }, - required: ["path"], - additionalProperties: false, - }, - }, -} satisfies OpenAI.Chat.ChatCompletionTool diff --git a/src/core/prompts/tools/native-tools/search_and_replace.ts b/src/core/prompts/tools/native-tools/search_and_replace.ts deleted file mode 100644 index 730cebc897a..00000000000 --- a/src/core/prompts/tools/native-tools/search_and_replace.ts +++ /dev/null @@ -1,46 +0,0 @@ -import type OpenAI from "openai" - -export default { - type: "function", - function: { - name: "search_and_replace", - description: - "Find and replace text within a file using literal strings or regular expressions. Supports optional line ranges, regex mode, and case-insensitive matching, and shows a diff preview before applying changes.", - strict: true, - parameters: { - type: "object", - properties: { - path: { - type: "string", - description: "File path to modify, relative to the workspace", - }, - search: { - type: "string", - description: "Text or pattern to search for", - }, - replace: { - type: "string", - description: "Replacement text to insert for each match", - }, - start_line: { - type: ["integer", "null"], - description: "Optional starting line (1-based) to limit replacements", - }, - end_line: { - type: ["integer", "null"], - description: "Optional ending line (1-based) to limit replacements", - }, - use_regex: { - type: ["boolean", "null"], - description: "Set true to treat the search parameter as a regular expression", - }, - ignore_case: { - type: ["boolean", "null"], - description: "Set true to ignore case when matching", - }, - }, - required: ["path", "search", "replace", "start_line", "end_line", "use_regex", "ignore_case"], - additionalProperties: false, - }, - }, -} satisfies OpenAI.Chat.ChatCompletionTool diff --git a/src/core/task/Task.ts b/src/core/task/Task.ts index 08880d0ee02..50467a36b10 100644 --- a/src/core/task/Task.ts +++ b/src/core/task/Task.ts @@ -5,6 +5,7 @@ import crypto from "crypto" import EventEmitter from "events" import { Anthropic } from "@anthropic-ai/sdk" +import OpenAI from "openai" import delay from "delay" import pWaitFor from "p-wait-for" import { serializeError } from "serialize-error" @@ -38,6 +39,8 @@ import { DEFAULT_CHECKPOINT_TIMEOUT_SECONDS, MAX_CHECKPOINT_TIMEOUT_SECONDS, MIN_CHECKPOINT_TIMEOUT_SECONDS, + TOOL_PROTOCOL, + ToolProtocol, } from "@roo-code/types" import { TelemetryService } from "@roo-code/telemetry" import { CloudService, BridgeOrchestrator } from "@roo-code/cloud" @@ -80,16 +83,17 @@ import { getWorkspacePath } from "../../utils/path" // prompts import { formatResponse } from "../prompts/responses" import { SYSTEM_PROMPT } from "../prompts/system" -import { resolveToolProtocol } from "../prompts/toolProtocolResolver" +import { nativeTools, getMcpServerTools } from "../prompts/tools/native-tools" // core modules import { ToolRepetitionDetector } from "../tools/ToolRepetitionDetector" -import { restoreTodoListForTask } from "../tools/updateTodoListTool" +import { restoreTodoListForTask } from "../tools/UpdateTodoListTool" import { FileContextTracker } from "../context-tracking/FileContextTracker" import { RooIgnoreController } from "../ignore/RooIgnoreController" import { RooProtectedController } from "../protect/RooProtectedController" import { type AssistantMessageContent, presentAssistantMessage } from "../assistant-message" import { AssistantMessageParser } from "../assistant-message/AssistantMessageParser" +import { NativeToolCallParser } from "../assistant-message/NativeToolCallParser" import { manageContext } from "../context-management" import { ClineProvider } from "../webview/ClineProvider" import { MultiSearchReplaceDiffStrategy } from "../diff/strategies/multi-search-replace" @@ -289,7 +293,7 @@ export class Task extends EventEmitter implements TaskLike { assistantMessageContent: AssistantMessageContent[] = [] presentAssistantMessageLocked = false presentAssistantMessageHasPendingUpdates = false - userMessageContent: (Anthropic.TextBlockParam | Anthropic.ImageBlockParam)[] = [] + userMessageContent: (Anthropic.TextBlockParam | Anthropic.ImageBlockParam | Anthropic.ToolResultBlockParam)[] = [] userMessageContentReady = false didRejectTool = false didAlreadyUseTool = false @@ -933,7 +937,7 @@ export class Task extends EventEmitter implements TaskLike { } } - // Wait for askResponse to be set. + // Wait for askResponse to be set await pWaitFor(() => this.askResponse !== undefined || this.lastMessageTs !== askTs, { interval: 100 }) if (this.lastMessageTs !== askTs) { @@ -2024,6 +2028,33 @@ export class Task extends EventEmitter implements TaskLike { pendingGroundingSources.push(...chunk.sources) } break + case "tool_call": { + // Convert native tool call to ToolUse format + const toolUse = NativeToolCallParser.parseToolCall({ + id: chunk.id, + name: chunk.name as ToolName, + arguments: chunk.arguments, + }) + + if (!toolUse) { + console.error(`Failed to parse tool call for task ${this.taskId}:`, chunk) + break + } + + // Store the tool call ID on the ToolUse object for later reference + // This is needed to create tool_result blocks that reference the correct tool_use_id + toolUse.id = chunk.id + + // Add the tool use to assistant message content + this.assistantMessageContent.push(toolUse) + + // Mark that we have new content to process + this.userMessageContentReady = false + + // Present the tool call to user + presentAssistantMessage(this) + break + } case "text": { assistantMessage += chunk.text @@ -2331,7 +2362,14 @@ export class Task extends EventEmitter implements TaskLike { // Now that the stream is complete, finalize any remaining partial content blocks this.assistantMessageParser.finalizeContentBlocks() - this.assistantMessageContent = this.assistantMessageParser.getContentBlocks() + + // Preserve tool_use blocks that were added via native protocol (not parsed from text) + // These come from tool_call chunks and are added directly to assistantMessageContent + const nativeToolBlocks = this.assistantMessageContent.filter((block) => block.type === "tool_use") + const parsedBlocks = this.assistantMessageParser.getContentBlocks() + + // Merge: parser blocks + native tool blocks that aren't in parser + this.assistantMessageContent = [...parsedBlocks, ...nativeToolBlocks] if (partialBlocks.length > 0) { // If there is content to update then it will complete and @@ -2373,7 +2411,11 @@ export class Task extends EventEmitter implements TaskLike { // able to save the assistant's response. let didEndLoop = false - if (assistantMessage.length > 0) { + // Check if we have any content to process (text or tool uses) + const hasTextContent = assistantMessage.length > 0 + const hasToolUses = this.assistantMessageContent.some((block) => block.type === "tool_use") + + if (hasTextContent || hasToolUses) { // Display grounding sources to the user if they exist if (pendingGroundingSources.length > 0) { const citationLinks = pendingGroundingSources.map((source, i) => `[${i + 1}](${source.url})`) @@ -2391,9 +2433,35 @@ export class Task extends EventEmitter implements TaskLike { finalAssistantMessage = `${reasoningMessage}\n${assistantMessage}` } + // Build the assistant message content array + const assistantContent: Array = [] + + // Add text content if present + if (finalAssistantMessage) { + assistantContent.push({ + type: "text" as const, + text: finalAssistantMessage, + }) + } + + // Add tool_use blocks with their IDs for native protocol + const toolUseBlocks = this.assistantMessageContent.filter((block) => block.type === "tool_use") + for (const toolUse of toolUseBlocks) { + // Get the tool call ID that was stored during parsing + const toolCallId = (toolUse as any).id + if (toolCallId) { + assistantContent.push({ + type: "tool_use" as const, + id: toolCallId, + name: toolUse.name, + input: toolUse.nativeArgs || toolUse.params, + }) + } + } + await this.addToApiConversationHistory({ role: "assistant", - content: [{ type: "text", text: finalAssistantMessage }], + content: assistantContent, }) TelemetryService.instance.captureConversationMessage(this.taskId, "assistant") @@ -2441,6 +2509,23 @@ export class Task extends EventEmitter implements TaskLike { // or tool_use content blocks from API which we should assume is // an error. + // IMPORTANT: For native tool protocol, we already added the user message to + // apiConversationHistory at line 1876. Since the assistant failed to respond, + // we need to remove that message before retrying to avoid having two consecutive + // user messages (which would cause tool_result validation errors). + const toolProtocol = vscode.workspace + .getConfiguration("roo-cline") + .get("toolProtocol", "xml") + const isNativeProtocol = toolProtocol === TOOL_PROTOCOL.NATIVE + + if (isNativeProtocol && this.apiConversationHistory.length > 0) { + const lastMessage = this.apiConversationHistory[this.apiConversationHistory.length - 1] + if (lastMessage.role === "user") { + // Remove the last user message that we added earlier + this.apiConversationHistory.pop() + } + } + // Check if we should auto-retry or prompt the user const state = await this.providerRef.deref()?.getState() if (state?.autoApprovalEnabled && state?.alwaysApproveResubmit) { @@ -2491,7 +2576,15 @@ export class Task extends EventEmitter implements TaskLike { // Continue to retry the request continue } else { - // User declined to retry - persist error and failure message + // User declined to retry + // For native protocol, re-add the user message we removed + if (isNativeProtocol) { + await this.addToApiConversationHistory({ + role: "user", + content: currentUserContent, + }) + } + await this.say( "error", "Unexpected API Response: The language model did not provide any assistant messages. This may indicate an issue with the API or the model's output.", @@ -2606,7 +2699,9 @@ export class Task extends EventEmitter implements TaskLike { newTaskRequireTodos: vscode.workspace .getConfiguration("roo-cline") .get("newTaskRequireTodos", false), - toolProtocol: resolveToolProtocol(), + toolProtocol: vscode.workspace + .getConfiguration("roo-cline") + .get("toolProtocol", "xml"), }, undefined, // todoList this.api.getModel().id, @@ -2837,9 +2932,27 @@ export class Task extends EventEmitter implements TaskLike { throw new Error("Auto-approval limit reached and user did not approve continuation") } + // Determine if we should include native tools based on: + // 1. Tool protocol is set to NATIVE + // 2. Model supports native tools + const toolProtocol = vscode.workspace.getConfiguration("roo-cline").get("toolProtocol", "xml") + const modelInfo = this.api.getModel().info + const shouldIncludeTools = toolProtocol === TOOL_PROTOCOL.NATIVE && (modelInfo.supportsNativeTools ?? false) + + // Build complete tools array: native tools + dynamic MCP tools + let allTools: OpenAI.Chat.ChatCompletionTool[] = nativeTools + if (shouldIncludeTools) { + const provider = this.providerRef.deref() + const mcpHub = provider?.getMcpHub() + const mcpTools = getMcpServerTools(mcpHub) + allTools = [...nativeTools, ...mcpTools] + } + const metadata: ApiHandlerCreateMessageMetadata = { mode: mode, taskId: this.taskId, + // Include tools and tool protocol when using native protocol and model supports it + ...(shouldIncludeTools ? { tools: allTools, tool_choice: "required", toolProtocol } : {}), } // The provider accepts reasoning items alongside standard messages; cast to the expected parameter type. diff --git a/src/core/tools/applyDiffTool.ts b/src/core/tools/ApplyDiffTool.ts similarity index 54% rename from src/core/tools/applyDiffTool.ts rename to src/core/tools/ApplyDiffTool.ts index 1077b7bf390..ef6623ed934 100644 --- a/src/core/tools/applyDiffTool.ts +++ b/src/core/tools/ApplyDiffTool.ts @@ -7,84 +7,69 @@ import { DEFAULT_WRITE_DELAY_MS } from "@roo-code/types" import { ClineSayTool } from "../../shared/ExtensionMessage" import { getReadablePath } from "../../utils/path" import { Task } from "../task/Task" -import { ToolUse, RemoveClosingTag, AskApproval, HandleError, PushToolResult } from "../../shared/tools" import { formatResponse } from "../prompts/responses" import { fileExistsAtPath } from "../../utils/fs" import { RecordSource } from "../context-tracking/FileContextTrackerTypes" import { unescapeHtmlEntities } from "../../utils/text-normalization" import { EXPERIMENT_IDS, experiments } from "../../shared/experiments" import { computeDiffStats, sanitizeUnifiedDiff } from "../diff/stats" +import { BaseTool, ToolCallbacks } from "./BaseTool" +import type { ToolUse } from "../../shared/tools" -export async function applyDiffToolLegacy( - cline: Task, - block: ToolUse, - askApproval: AskApproval, - handleError: HandleError, - pushToolResult: PushToolResult, - removeClosingTag: RemoveClosingTag, -) { - const relPath: string | undefined = block.params.path - let diffContent: string | undefined = block.params.diff - - if (diffContent && !cline.api.getModel().id.includes("claude")) { - diffContent = unescapeHtmlEntities(diffContent) - } - - const sharedMessageProps: ClineSayTool = { - tool: "appliedDiff", - path: getReadablePath(cline.cwd, removeClosingTag("path", relPath)), - diff: diffContent, - } +interface ApplyDiffParams { + path: string + diff: string +} - try { - if (block.partial) { - // Update GUI message - let toolProgressStatus +export class ApplyDiffTool extends BaseTool<"apply_diff"> { + readonly name = "apply_diff" as const - if (cline.diffStrategy && cline.diffStrategy.getProgressStatus) { - toolProgressStatus = cline.diffStrategy.getProgressStatus(block) - } + parseLegacy(params: Partial>): ApplyDiffParams { + return { + path: params.path || "", + diff: params.diff || "", + } + } - if (toolProgressStatus && Object.keys(toolProgressStatus).length === 0) { - return - } + async execute(params: ApplyDiffParams, task: Task, callbacks: ToolCallbacks): Promise { + const { askApproval, handleError, pushToolResult } = callbacks + let { path: relPath, diff: diffContent } = params - await cline - .ask("tool", JSON.stringify(sharedMessageProps), block.partial, toolProgressStatus) - .catch(() => {}) + if (diffContent && !task.api.getModel().id.includes("claude")) { + diffContent = unescapeHtmlEntities(diffContent) + } - return - } else { + try { if (!relPath) { - cline.consecutiveMistakeCount++ - cline.recordToolError("apply_diff") - pushToolResult(await cline.sayAndCreateMissingParamError("apply_diff", "path")) + task.consecutiveMistakeCount++ + task.recordToolError("apply_diff") + pushToolResult(await task.sayAndCreateMissingParamError("apply_diff", "path")) return } if (!diffContent) { - cline.consecutiveMistakeCount++ - cline.recordToolError("apply_diff") - pushToolResult(await cline.sayAndCreateMissingParamError("apply_diff", "diff")) + task.consecutiveMistakeCount++ + task.recordToolError("apply_diff") + pushToolResult(await task.sayAndCreateMissingParamError("apply_diff", "diff")) return } - const accessAllowed = cline.rooIgnoreController?.validateAccess(relPath) + const accessAllowed = task.rooIgnoreController?.validateAccess(relPath) if (!accessAllowed) { - await cline.say("rooignore_error", relPath) + await task.say("rooignore_error", relPath) pushToolResult(formatResponse.toolError(formatResponse.rooIgnoreError(relPath))) return } - const absolutePath = path.resolve(cline.cwd, relPath) + const absolutePath = path.resolve(task.cwd, relPath) const fileExists = await fileExistsAtPath(absolutePath) if (!fileExists) { - cline.consecutiveMistakeCount++ - cline.recordToolError("apply_diff") + task.consecutiveMistakeCount++ + task.recordToolError("apply_diff") const formattedError = `File does not exist at path: ${absolutePath}\n\n\nThe specified file could not be found. Please verify the file path and try again.\n` - await cline.say("error", formattedError) + await task.say("error", formattedError) pushToolResult(formattedError) return } @@ -92,21 +77,21 @@ export async function applyDiffToolLegacy( const originalContent: string = await fs.readFile(absolutePath, "utf-8") // Apply the diff to the original content - const diffResult = (await cline.diffStrategy?.applyDiff( + const diffResult = (await task.diffStrategy?.applyDiff( originalContent, diffContent, - parseInt(block.params.start_line ?? ""), + parseInt(params.diff.match(/:start_line:(\d+)/)?.[1] ?? ""), )) ?? { success: false, error: "No diff strategy available", } if (!diffResult.success) { - cline.consecutiveMistakeCount++ - const currentCount = (cline.consecutiveMistakeCountForApplyDiff.get(relPath) || 0) + 1 - cline.consecutiveMistakeCountForApplyDiff.set(relPath, currentCount) + task.consecutiveMistakeCount++ + const currentCount = (task.consecutiveMistakeCountForApplyDiff.get(relPath) || 0) + 1 + task.consecutiveMistakeCountForApplyDiff.set(relPath, currentCount) let formattedError = "" - TelemetryService.instance.captureDiffApplicationError(cline.taskId, currentCount) + TelemetryService.instance.captureDiffApplicationError(task.taskId, currentCount) if (diffResult.failParts && diffResult.failParts.length > 0) { for (const failPart of diffResult.failParts) { @@ -129,17 +114,17 @@ export async function applyDiffToolLegacy( } if (currentCount >= 2) { - await cline.say("diff_error", formattedError) + await task.say("diff_error", formattedError) } - cline.recordToolError("apply_diff", formattedError) + task.recordToolError("apply_diff", formattedError) pushToolResult(formattedError) return } - cline.consecutiveMistakeCount = 0 - cline.consecutiveMistakeCountForApplyDiff.delete(relPath) + task.consecutiveMistakeCount = 0 + task.consecutiveMistakeCountForApplyDiff.delete(relPath) // Generate backend-unified diff for display in chat/webview const unifiedPatchRaw = formatResponse.createPrettyPatch(relPath, originalContent, diffResult.content) @@ -147,7 +132,7 @@ export async function applyDiffToolLegacy( const diffStats = computeDiffStats(unifiedPatch) || undefined // Check if preventFocusDisruption experiment is enabled - const provider = cline.providerRef.deref() + const provider = task.providerRef.deref() const state = await provider?.getState() const diagnosticsEnabled = state?.diagnosticsEnabled ?? true const writeDelayMs = state?.writeDelayMs ?? DEFAULT_WRITE_DELAY_MS @@ -157,7 +142,13 @@ export async function applyDiffToolLegacy( ) // Check if file is write-protected - const isWriteProtected = cline.rooProtectedController?.isWriteProtected(relPath) || false + const isWriteProtected = task.rooProtectedController?.isWriteProtected(relPath) || false + + const sharedMessageProps: ClineSayTool = { + tool: "appliedDiff", + path: getReadablePath(task.cwd, relPath), + diff: diffContent, + } if (isPreventFocusDisruptionEnabled) { // Direct file write without diff view @@ -171,8 +162,14 @@ export async function applyDiffToolLegacy( let toolProgressStatus - if (cline.diffStrategy && cline.diffStrategy.getProgressStatus) { - toolProgressStatus = cline.diffStrategy.getProgressStatus(block, diffResult) + if (task.diffStrategy && task.diffStrategy.getProgressStatus) { + const block: ToolUse<"apply_diff"> = { + type: "tool_use", + name: "apply_diff", + params: { path: relPath, diff: diffContent }, + partial: false, + } + toolProgressStatus = task.diffStrategy.getProgressStatus(block, diffResult) } const didApprove = await askApproval("tool", completeMessage, toolProgressStatus, isWriteProtected) @@ -182,9 +179,9 @@ export async function applyDiffToolLegacy( } // Save directly without showing diff view or opening the file - cline.diffViewProvider.editType = "modify" - cline.diffViewProvider.originalContent = originalContent - await cline.diffViewProvider.saveDirectly( + task.diffViewProvider.editType = "modify" + task.diffViewProvider.originalContent = originalContent + await task.diffViewProvider.saveDirectly( relPath, diffResult.content, false, @@ -194,10 +191,10 @@ export async function applyDiffToolLegacy( } else { // Original behavior with diff view // Show diff view before asking for approval - cline.diffViewProvider.editType = "modify" - await cline.diffViewProvider.open(relPath) - await cline.diffViewProvider.update(diffResult.content, true) - cline.diffViewProvider.scrollToFirstDiff() + task.diffViewProvider.editType = "modify" + await task.diffViewProvider.open(relPath) + await task.diffViewProvider.update(diffResult.content, true) + task.diffViewProvider.scrollToFirstDiff() const completeMessage = JSON.stringify({ ...sharedMessageProps, @@ -209,29 +206,35 @@ export async function applyDiffToolLegacy( let toolProgressStatus - if (cline.diffStrategy && cline.diffStrategy.getProgressStatus) { - toolProgressStatus = cline.diffStrategy.getProgressStatus(block, diffResult) + if (task.diffStrategy && task.diffStrategy.getProgressStatus) { + const block: ToolUse<"apply_diff"> = { + type: "tool_use", + name: "apply_diff", + params: { path: relPath, diff: diffContent }, + partial: false, + } + toolProgressStatus = task.diffStrategy.getProgressStatus(block, diffResult) } const didApprove = await askApproval("tool", completeMessage, toolProgressStatus, isWriteProtected) if (!didApprove) { - await cline.diffViewProvider.revertChanges() // Cline likely handles closing the diff view - cline.processQueuedMessages() + await task.diffViewProvider.revertChanges() + task.processQueuedMessages() return } // Call saveChanges to update the DiffViewProvider properties - await cline.diffViewProvider.saveChanges(diagnosticsEnabled, writeDelayMs) + await task.diffViewProvider.saveChanges(diagnosticsEnabled, writeDelayMs) } // Track file edit operation if (relPath) { - await cline.fileContextTracker.trackFileContext(relPath, "roo_edited" as RecordSource) + await task.fileContextTracker.trackFileContext(relPath, "roo_edited" as RecordSource) } // Used to determine if we should wait for busy terminal to update before sending api request - cline.didEditFile = true + task.didEditFile = true let partFailHint = "" if (diffResult.failParts && diffResult.failParts.length > 0) { @@ -239,7 +242,7 @@ export async function applyDiffToolLegacy( } // Get the formatted response message - const message = await cline.diffViewProvider.pushToolWriteResult(cline, cline.cwd, !fileExists) + const message = await task.diffViewProvider.pushToolWriteResult(task, task.cwd, !fileExists) // Check for single SEARCH/REPLACE block warning const searchBlocks = (diffContent.match(/<<<<<<< SEARCH/g) || []).length @@ -254,17 +257,42 @@ export async function applyDiffToolLegacy( pushToolResult(message + singleBlockNotice) } - await cline.diffViewProvider.reset() + await task.diffViewProvider.reset() // Process any queued messages after file edit completes - cline.processQueuedMessages() + task.processQueuedMessages() + + return + } catch (error) { + await handleError("applying diff", error as Error) + await task.diffViewProvider.reset() + task.processQueuedMessages() + return + } + } + + override async handlePartial(task: Task, block: ToolUse<"apply_diff">): Promise { + const relPath: string | undefined = block.params.path + const diffContent: string | undefined = block.params.diff + const sharedMessageProps: ClineSayTool = { + tool: "appliedDiff", + path: getReadablePath(task.cwd, relPath || ""), + diff: diffContent, + } + + let toolProgressStatus + + if (task.diffStrategy && task.diffStrategy.getProgressStatus) { + toolProgressStatus = task.diffStrategy.getProgressStatus(block) + } + + if (toolProgressStatus && Object.keys(toolProgressStatus).length === 0) { return } - } catch (error) { - await handleError("applying diff", error) - await cline.diffViewProvider.reset() - cline.processQueuedMessages() - return + + await task.ask("tool", JSON.stringify(sharedMessageProps), block.partial, toolProgressStatus).catch(() => {}) } } + +export const applyDiffTool = new ApplyDiffTool() diff --git a/src/core/tools/AskFollowupQuestionTool.ts b/src/core/tools/AskFollowupQuestionTool.ts new file mode 100644 index 00000000000..2899dc6ee33 --- /dev/null +++ b/src/core/tools/AskFollowupQuestionTool.ts @@ -0,0 +1,101 @@ +import { Task } from "../task/Task" +import { formatResponse } from "../prompts/responses" +import { parseXml } from "../../utils/xml" +import { BaseTool, ToolCallbacks } from "./BaseTool" +import type { ToolUse } from "../../shared/tools" + +interface Suggestion { + text: string + mode?: string +} + +interface AskFollowupQuestionParams { + question: string + follow_up: Suggestion[] +} + +export class AskFollowupQuestionTool extends BaseTool<"ask_followup_question"> { + readonly name = "ask_followup_question" as const + + parseLegacy(params: Partial>): AskFollowupQuestionParams { + const question = params.question || "" + const follow_up_xml = params.follow_up + + const suggestions: Suggestion[] = [] + + if (follow_up_xml) { + // Define the actual structure returned by the XML parser + type ParsedSuggestion = string | { "#text": string; "@_mode"?: string } + + try { + const parsedSuggest = parseXml(follow_up_xml, ["suggest"]) as { + suggest: ParsedSuggestion[] | ParsedSuggestion + } + + const rawSuggestions = Array.isArray(parsedSuggest?.suggest) + ? parsedSuggest.suggest + : [parsedSuggest?.suggest].filter((sug): sug is ParsedSuggestion => sug !== undefined) + + // Transform parsed XML to our Suggest format + for (const sug of rawSuggestions) { + if (typeof sug === "string") { + // Simple string suggestion (no mode attribute) + suggestions.push({ text: sug }) + } else { + // XML object with text content and optional mode attribute + const suggestion: Suggestion = { text: sug["#text"] } + if (sug["@_mode"]) { + suggestion.mode = sug["@_mode"] + } + suggestions.push(suggestion) + } + } + } catch (error) { + throw new Error( + `Failed to parse follow_up XML: ${error instanceof Error ? error.message : String(error)}`, + ) + } + } + + return { + question, + follow_up: suggestions, + } + } + + async execute(params: AskFollowupQuestionParams, task: Task, callbacks: ToolCallbacks): Promise { + const { question, follow_up } = params + const { handleError, pushToolResult } = callbacks + + try { + if (!question) { + task.consecutiveMistakeCount++ + task.recordToolError("ask_followup_question") + pushToolResult(await task.sayAndCreateMissingParamError("ask_followup_question", "question")) + return + } + + // Transform follow_up suggestions to the format expected by task.ask + const follow_up_json = { + question, + suggest: follow_up.map((s) => ({ answer: s.text, mode: s.mode })), + } + + task.consecutiveMistakeCount = 0 + const { text, images } = await task.ask("followup", JSON.stringify(follow_up_json), false) + await task.say("user_feedback", text ?? "", images) + pushToolResult(formatResponse.toolResult(`\n${text}\n`, images)) + } catch (error) { + await handleError("asking question", error as Error) + } + } + + override async handlePartial(task: Task, block: ToolUse<"ask_followup_question">): Promise { + const question: string | undefined = block.params.question + await task + .ask("followup", this.removeClosingTag("question", question, block.partial), block.partial) + .catch(() => {}) + } +} + +export const askFollowupQuestionTool = new AskFollowupQuestionTool() diff --git a/src/core/tools/AttemptCompletionTool.ts b/src/core/tools/AttemptCompletionTool.ts new file mode 100644 index 00000000000..8a7695748b3 --- /dev/null +++ b/src/core/tools/AttemptCompletionTool.ts @@ -0,0 +1,136 @@ +import Anthropic from "@anthropic-ai/sdk" +import * as vscode from "vscode" + +import { RooCodeEventName } from "@roo-code/types" +import { TelemetryService } from "@roo-code/telemetry" + +import { Task } from "../task/Task" +import { formatResponse } from "../prompts/responses" +import { Package } from "../../shared/package" +import { BaseTool, ToolCallbacks } from "./BaseTool" +import type { ToolUse } from "../../shared/tools" + +interface AttemptCompletionParams { + result: string + command?: string +} + +export interface AttemptCompletionCallbacks extends ToolCallbacks { + askFinishSubTaskApproval: () => Promise + toolDescription: () => string +} + +export class AttemptCompletionTool extends BaseTool<"attempt_completion"> { + readonly name = "attempt_completion" as const + + parseLegacy(params: Partial>): AttemptCompletionParams { + return { + result: params.result || "", + command: params.command, + } + } + + async execute(params: AttemptCompletionParams, task: Task, callbacks: AttemptCompletionCallbacks): Promise { + const { result } = params + const { handleError, pushToolResult, askFinishSubTaskApproval, toolDescription } = callbacks + + const preventCompletionWithOpenTodos = vscode.workspace + .getConfiguration(Package.name) + .get("preventCompletionWithOpenTodos", false) + + const hasIncompleteTodos = task.todoList && task.todoList.some((todo) => todo.status !== "completed") + + if (preventCompletionWithOpenTodos && hasIncompleteTodos) { + task.consecutiveMistakeCount++ + task.recordToolError("attempt_completion") + + pushToolResult( + formatResponse.toolError( + "Cannot complete task while there are incomplete todos. Please finish all todos before attempting completion.", + ), + ) + + return + } + + try { + if (!result) { + task.consecutiveMistakeCount++ + task.recordToolError("attempt_completion") + pushToolResult(await task.sayAndCreateMissingParamError("attempt_completion", "result")) + return + } + + task.consecutiveMistakeCount = 0 + + await task.say("completion_result", result, undefined, false) + TelemetryService.instance.captureTaskCompleted(task.taskId) + task.emit(RooCodeEventName.TaskCompleted, task.taskId, task.getTokenUsage(), task.toolUsage) + + if (task.parentTask) { + const didApprove = await askFinishSubTaskApproval() + + if (!didApprove) { + pushToolResult(formatResponse.toolDenied()) + return + } + + pushToolResult("") + await task.providerRef.deref()?.finishSubTask(result) + return + } + + const { response, text, images } = await task.ask("completion_result", "", false) + + if (response === "yesButtonClicked") { + pushToolResult("") + return + } + + await task.say("user_feedback", text ?? "", images) + + const feedbackText = `The user has provided feedback on the results. Consider their input to continue the task, and then attempt completion again.\n\n${text}\n` + pushToolResult(formatResponse.toolResult(feedbackText, images)) + } catch (error) { + await handleError("inspecting site", error as Error) + } + } + + override async handlePartial(task: Task, block: ToolUse<"attempt_completion">): Promise { + const result: string | undefined = block.params.result + const command: string | undefined = block.params.command + + const lastMessage = task.clineMessages.at(-1) + + if (command) { + if (lastMessage && lastMessage.ask === "command") { + await task + .ask("command", this.removeClosingTag("command", command, block.partial), block.partial) + .catch(() => {}) + } else { + await task.say( + "completion_result", + this.removeClosingTag("result", result, block.partial), + undefined, + false, + ) + + TelemetryService.instance.captureTaskCompleted(task.taskId) + task.emit(RooCodeEventName.TaskCompleted, task.taskId, task.getTokenUsage(), task.toolUsage) + + await task + .ask("command", this.removeClosingTag("command", command, block.partial), block.partial) + .catch(() => {}) + } + } else { + await task.say( + "completion_result", + this.removeClosingTag("result", result, block.partial), + undefined, + block.partial, + ) + } + } +} + +export const attemptCompletionTool = new AttemptCompletionTool() diff --git a/src/core/tools/BaseTool.ts b/src/core/tools/BaseTool.ts new file mode 100644 index 00000000000..818fd1bf9a0 --- /dev/null +++ b/src/core/tools/BaseTool.ts @@ -0,0 +1,170 @@ +import { Task } from "../task/Task" +import type { + ToolUse, + HandleError, + PushToolResult, + RemoveClosingTag, + AskApproval, + NativeToolArgs, +} from "../../shared/tools" +import type { ToolName } from "@roo-code/types" + +/** + * Callbacks passed to tool execution + */ +export interface ToolCallbacks { + askApproval: AskApproval + handleError: HandleError + pushToolResult: PushToolResult + removeClosingTag: RemoveClosingTag +} + +/** + * Helper type to extract the parameter type for a tool based on its name. + * If the tool has native args defined in NativeToolArgs, use those; otherwise fall back to any. + */ +type ToolParams = TName extends keyof NativeToolArgs ? NativeToolArgs[TName] : any + +/** + * Abstract base class for all tools. + * + * Provides a consistent architecture where: + * - XML/legacy protocol: params → parseLegacy() → typed params → execute() + * - Native protocol: nativeArgs already contain typed data → execute() + * + * Each tool extends this class and implements: + * - parseLegacy(): Convert XML/legacy string params to typed params + * - execute(): Protocol-agnostic core logic using typed params + * - handlePartial(): (optional) Handle streaming partial messages + * + * @template TName - The specific tool name, which determines native arg types + */ +export abstract class BaseTool { + /** + * The tool's name (must match ToolName type) + */ + abstract readonly name: TName + + /** + * Parse XML/legacy string-based parameters into typed parameters. + * + * For XML protocol, this converts params.args (XML string) or params.path (legacy) + * into a typed structure that execute() can use. + * + * @param params - Raw ToolUse.params from XML protocol + * @returns Typed parameters for execute() + * @throws Error if parsing fails + */ + abstract parseLegacy(params: Partial>): ToolParams + + /** + * Execute the tool with typed parameters. + * + * This is the protocol-agnostic core logic. It receives typed parameters + * (from parseLegacy for XML, or directly from native protocol) and performs + * the tool's operation. + * + * @param params - Typed parameters + * @param task - Task instance with state and API access + * @param callbacks - Tool execution callbacks (approval, error handling, results) + */ + abstract execute(params: ToolParams, task: Task, callbacks: ToolCallbacks): Promise + + /** + * Handle partial (streaming) tool messages. + * + * Default implementation does nothing. Tools that support streaming + * partial messages should override this. + * + * @param task - Task instance + * @param block - Partial ToolUse block + */ + async handlePartial(task: Task, block: ToolUse): Promise { + // Default: no-op for partial messages + // Tools can override to show streaming UI updates + } + + /** + * Remove partial closing XML tags from text during streaming. + * + * This utility helps clean up partial XML tag artifacts that can appear + * at the end of streamed content, preventing them from being displayed to users. + * + * @param tag - The tag name to check for partial closing + * @param text - The text content to clean + * @param isPartial - Whether this is a partial message (if false, returns text as-is) + * @returns Cleaned text with partial closing tags removed + */ + protected removeClosingTag(tag: string, text: string | undefined, isPartial: boolean): string { + if (!isPartial) { + return text || "" + } + + if (!text) { + return "" + } + + // This regex dynamically constructs a pattern to match the closing tag: + // - Optionally matches whitespace before the tag + // - Matches '<' or ' `(?:${char})?`) + .join("")}$`, + "g", + ) + + return text.replace(tagRegex, "") + } + + /** + * Main entry point for tool execution. + * + * Handles the complete flow: + * 1. Partial message handling (if partial) + * 2. Parameter parsing (parseLegacy for XML, or use nativeArgs directly) + * 3. Core execution (execute) + * + * @param task - Task instance + * @param block - ToolUse block from assistant message + * @param callbacks - Tool execution callbacks + */ + async handle(task: Task, block: ToolUse, callbacks: ToolCallbacks): Promise { + // Handle partial messages + if (block.partial) { + try { + await this.handlePartial(task, block) + } catch (error) { + console.error(`Error in handlePartial:`, error) + await callbacks.handleError( + `handling partial ${this.name}`, + error instanceof Error ? error : new Error(String(error)), + ) + } + return + } + + // Determine protocol and parse parameters accordingly + let params: ToolParams + try { + if (block.nativeArgs !== undefined) { + // Native protocol: typed args provided by NativeToolCallParser + // TypeScript knows nativeArgs is properly typed based on TName + params = block.nativeArgs as ToolParams + } else { + // XML/legacy protocol: parse string params into typed params + params = this.parseLegacy(block.params) + } + } catch (error) { + console.error(`Error parsing parameters:`, error) + const errorMessage = `Failed to parse ${this.name} parameters: ${error instanceof Error ? error.message : String(error)}` + await callbacks.handleError(`parsing ${this.name} args`, new Error(errorMessage)) + callbacks.pushToolResult(`${errorMessage}`) + return + } + + // Execute with typed parameters + await this.execute(params, task, callbacks) + } +} diff --git a/src/core/tools/BrowserActionTool.ts b/src/core/tools/BrowserActionTool.ts new file mode 100644 index 00000000000..3e8f6f176e4 --- /dev/null +++ b/src/core/tools/BrowserActionTool.ts @@ -0,0 +1,244 @@ +import type { BrowserActionParams, Coordinate, Size } from "@roo-code/types" +import { Task } from "../task/Task" +import { BaseTool, ToolCallbacks } from "./BaseTool" +import type { ToolUse } from "../../shared/tools" +import { + BrowserAction, + BrowserActionResult, + browserActions, + ClineSayBrowserAction, +} from "../../shared/ExtensionMessage" +import { formatResponse } from "../prompts/responses" + +export class BrowserActionTool extends BaseTool<"browser_action"> { + readonly name = "browser_action" as const + + parseLegacy(params: Partial>): BrowserActionParams { + const action = params.action as BrowserAction | undefined + + // Parse coordinate if present - XML protocol sends "x,y" format + let coordinate: Coordinate | undefined + if (params.coordinate) { + // Try parsing as "x,y" string first (XML protocol) + const parts = params.coordinate.split(",") + if (parts.length === 2) { + const x = parseInt(parts[0], 10) + const y = parseInt(parts[1], 10) + if (!isNaN(x) && !isNaN(y)) { + coordinate = { x, y } + } + } else { + // Try parsing as JSON object (fallback) + try { + const parsed = JSON.parse(params.coordinate) + if (parsed && typeof parsed.x === "number" && typeof parsed.y === "number") { + coordinate = { x: parsed.x, y: parsed.y } + } + } catch (error) { + // Invalid coordinate format, leave undefined + } + } + } + + // Parse size if present - XML protocol sends "width,height" format + let size: Size | undefined + if (params.size) { + // Try parsing as "width,height" string first (XML protocol) + const parts = params.size.split(",") + if (parts.length === 2) { + const width = parseInt(parts[0], 10) + const height = parseInt(parts[1], 10) + if (!isNaN(width) && !isNaN(height)) { + size = { width, height } + } + } else { + // Try parsing as JSON object (fallback) + try { + const parsed = JSON.parse(params.size) + if (parsed && typeof parsed.width === "number" && typeof parsed.height === "number") { + size = { width: parsed.width, height: parsed.height } + } + } catch (error) { + // Invalid size format, leave undefined + } + } + } + + return { + action: action!, + url: params.url, + coordinate, + size, + text: params.text, + } + } + + async execute(params: BrowserActionParams, task: Task, callbacks: ToolCallbacks): Promise { + const { action, url, coordinate, text, size } = params + const { handleError, pushToolResult } = callbacks + + // Validate action + if (!action || !browserActions.includes(action)) { + task.consecutiveMistakeCount++ + task.recordToolError("browser_action") + pushToolResult(await task.sayAndCreateMissingParamError("browser_action", "action")) + await task.browserSession.closeBrowser() + return + } + + try { + let browserActionResult: BrowserActionResult = {} + + if (action === "launch") { + if (!url) { + task.consecutiveMistakeCount++ + task.recordToolError("browser_action") + pushToolResult(await task.sayAndCreateMissingParamError("browser_action", "url")) + await task.browserSession.closeBrowser() + return + } + + task.consecutiveMistakeCount = 0 + const didApprove = await callbacks.askApproval("browser_action_launch", url) + + if (!didApprove) { + return + } + + await task.say("browser_action_result", "") + await task.browserSession.launchBrowser() + browserActionResult = await task.browserSession.navigateToUrl(url) + } else { + // Validate parameters for specific actions + if (action === "click" || action === "hover") { + if (!coordinate) { + task.consecutiveMistakeCount++ + task.recordToolError("browser_action") + pushToolResult(await task.sayAndCreateMissingParamError("browser_action", "coordinate")) + await task.browserSession.closeBrowser() + return + } + } + + if (action === "type") { + if (!text) { + task.consecutiveMistakeCount++ + task.recordToolError("browser_action") + pushToolResult(await task.sayAndCreateMissingParamError("browser_action", "text")) + await task.browserSession.closeBrowser() + return + } + } + + if (action === "resize") { + if (!size) { + task.consecutiveMistakeCount++ + task.recordToolError("browser_action") + pushToolResult(await task.sayAndCreateMissingParamError("browser_action", "size")) + await task.browserSession.closeBrowser() + return + } + } + + task.consecutiveMistakeCount = 0 + + await task.say( + "browser_action", + JSON.stringify({ + action: action as BrowserAction, + coordinate: coordinate ? `${coordinate.x},${coordinate.y}` : undefined, + text, + } satisfies ClineSayBrowserAction), + undefined, + false, + ) + + switch (action) { + case "click": + browserActionResult = await task.browserSession.click(`${coordinate!.x},${coordinate!.y}`) + break + case "hover": + browserActionResult = await task.browserSession.hover(`${coordinate!.x},${coordinate!.y}`) + break + case "type": + browserActionResult = await task.browserSession.type(text!) + break + case "scroll_down": + browserActionResult = await task.browserSession.scrollDown() + break + case "scroll_up": + browserActionResult = await task.browserSession.scrollUp() + break + case "resize": + browserActionResult = await task.browserSession.resize(`${size!.width},${size!.height}`) + break + case "close": + browserActionResult = await task.browserSession.closeBrowser() + break + } + } + + switch (action) { + case "launch": + case "click": + case "hover": + case "type": + case "scroll_down": + case "scroll_up": + case "resize": + await task.say("browser_action_result", JSON.stringify(browserActionResult)) + + pushToolResult( + formatResponse.toolResult( + `The browser action has been executed. The console logs and screenshot have been captured for your analysis.\n\nConsole logs:\n${ + browserActionResult?.logs || "(No new logs)" + }\n\n(REMEMBER: if you need to proceed to using non-\`browser_action\` tools or launch a new browser, you MUST first close cline browser. For example, if after analyzing the logs and screenshot you need to edit a file, you must first close the browser before you can use the write_to_file tool.)`, + browserActionResult?.screenshot ? [browserActionResult.screenshot] : [], + ), + ) + break + + case "close": + pushToolResult( + formatResponse.toolResult( + `The browser has been closed. You may now proceed to using other tools.`, + ), + ) + break + } + } catch (error) { + await task.browserSession.closeBrowser() + await handleError("executing browser action", error as Error) + } + } + + override async handlePartial(task: Task, block: ToolUse<"browser_action">): Promise { + const action: BrowserAction | undefined = block.params.action as BrowserAction + const url: string | undefined = block.params.url + const coordinate: string | undefined = block.params.coordinate + const text: string | undefined = block.params.text + + if (!action || !browserActions.includes(action)) { + return + } + + if (action === "launch") { + await task + .ask("browser_action_launch", this.removeClosingTag("url", url, block.partial), block.partial) + .catch(() => {}) + } else { + await task.say( + "browser_action", + JSON.stringify({ + action: action as BrowserAction, + coordinate: this.removeClosingTag("coordinate", coordinate, block.partial), + text: this.removeClosingTag("text", text, block.partial), + } satisfies ClineSayBrowserAction), + undefined, + block.partial, + ) + } + } +} + +export const browserActionTool = new BrowserActionTool() diff --git a/src/core/tools/CodebaseSearchTool.ts b/src/core/tools/CodebaseSearchTool.ts new file mode 100644 index 00000000000..6daefe77c19 --- /dev/null +++ b/src/core/tools/CodebaseSearchTool.ts @@ -0,0 +1,158 @@ +import * as vscode from "vscode" +import path from "path" + +import { Task } from "../task/Task" +import { CodeIndexManager } from "../../services/code-index/manager" +import { getWorkspacePath } from "../../utils/path" +import { formatResponse } from "../prompts/responses" +import { VectorStoreSearchResult } from "../../services/code-index/interfaces" +import { BaseTool, ToolCallbacks } from "./BaseTool" +import type { ToolUse } from "../../shared/tools" + +interface CodebaseSearchParams { + query: string + path?: string +} + +export class CodebaseSearchTool extends BaseTool<"codebase_search"> { + readonly name = "codebase_search" as const + + parseLegacy(params: Partial>): CodebaseSearchParams { + let query = params.query + let directoryPrefix = params.path + + if (directoryPrefix) { + directoryPrefix = path.normalize(directoryPrefix) + } + + return { + query: query || "", + path: directoryPrefix, + } + } + + async execute(params: CodebaseSearchParams, task: Task, callbacks: ToolCallbacks): Promise { + const { askApproval, handleError, pushToolResult } = callbacks + const { query, path: directoryPrefix } = params + + const workspacePath = task.cwd && task.cwd.trim() !== "" ? task.cwd : getWorkspacePath() + + if (!workspacePath) { + await handleError("codebase_search", new Error("Could not determine workspace path.")) + return + } + + if (!query) { + task.consecutiveMistakeCount++ + pushToolResult(await task.sayAndCreateMissingParamError("codebase_search", "query")) + return + } + + const sharedMessageProps = { + tool: "codebaseSearch", + query: query, + path: directoryPrefix, + isOutsideWorkspace: false, + } + + const didApprove = await askApproval("tool", JSON.stringify(sharedMessageProps)) + if (!didApprove) { + pushToolResult(formatResponse.toolDenied()) + return + } + + task.consecutiveMistakeCount = 0 + + try { + const context = task.providerRef.deref()?.context + if (!context) { + throw new Error("Extension context is not available.") + } + + const manager = CodeIndexManager.getInstance(context) + + if (!manager) { + throw new Error("CodeIndexManager is not available.") + } + + if (!manager.isFeatureEnabled) { + throw new Error("Code Indexing is disabled in the settings.") + } + if (!manager.isFeatureConfigured) { + throw new Error("Code Indexing is not configured (Missing OpenAI Key or Qdrant URL).") + } + + const searchResults: VectorStoreSearchResult[] = await manager.searchIndex(query, directoryPrefix) + + if (!searchResults || searchResults.length === 0) { + pushToolResult(`No relevant code snippets found for the query: "${query}"`) + return + } + + const jsonResult = { + query, + results: [], + } as { + query: string + results: Array<{ + filePath: string + score: number + startLine: number + endLine: number + codeChunk: string + }> + } + + searchResults.forEach((result) => { + if (!result.payload) return + if (!("filePath" in result.payload)) return + + const relativePath = vscode.workspace.asRelativePath(result.payload.filePath, false) + + jsonResult.results.push({ + filePath: relativePath, + score: result.score, + startLine: result.payload.startLine, + endLine: result.payload.endLine, + codeChunk: result.payload.codeChunk.trim(), + }) + }) + + const payload = { tool: "codebaseSearch", content: jsonResult } + await task.say("codebase_search_result", JSON.stringify(payload)) + + const output = `Query: ${query} +Results: + +${jsonResult.results + .map( + (result) => `File path: ${result.filePath} +Score: ${result.score} +Lines: ${result.startLine}-${result.endLine} +Code Chunk: ${result.codeChunk} +`, + ) + .join("\n")}` + + pushToolResult(output) + } catch (error: any) { + await handleError("codebase_search", error) + } + } + + override async handlePartial(task: Task, block: ToolUse<"codebase_search">): Promise { + const query: string | undefined = block.params.query + const directoryPrefix: string | undefined = block.params.path + + const sharedMessageProps = { + tool: "codebaseSearch", + query: query, + path: directoryPrefix, + isOutsideWorkspace: false, + } + + await task.ask("tool", JSON.stringify(sharedMessageProps), block.partial).catch(() => {}) + } +} + +export const codebaseSearchTool = new CodebaseSearchTool() diff --git a/src/core/tools/executeCommandTool.ts b/src/core/tools/ExecuteCommandTool.ts similarity index 88% rename from src/core/tools/executeCommandTool.ts rename to src/core/tools/ExecuteCommandTool.ts index 8d0b39bde48..ddf09cb8f0b 100644 --- a/src/core/tools/executeCommandTool.ts +++ b/src/core/tools/ExecuteCommandTool.ts @@ -9,7 +9,7 @@ import { TelemetryService } from "@roo-code/telemetry" import { Task } from "../task/Task" -import { ToolUse, AskApproval, HandleError, PushToolResult, RemoveClosingTag, ToolResponse } from "../../shared/tools" +import { ToolUse, ToolResponse } from "../../shared/tools" import { formatResponse } from "../prompts/responses" import { unescapeHtmlEntities } from "../../utils/text-normalization" import { ExitCodeDetails, RooTerminalCallbacks, RooTerminalProcess } from "../../integrations/terminal/types" @@ -17,25 +17,30 @@ import { TerminalRegistry } from "../../integrations/terminal/TerminalRegistry" import { Terminal } from "../../integrations/terminal/Terminal" import { Package } from "../../shared/package" import { t } from "../../i18n" +import { BaseTool, ToolCallbacks } from "./BaseTool" class ShellIntegrationError extends Error {} -export async function executeCommandTool( - task: Task, - block: ToolUse, - askApproval: AskApproval, - handleError: HandleError, - pushToolResult: PushToolResult, - removeClosingTag: RemoveClosingTag, -) { - let command: string | undefined = block.params.command - const customCwd: string | undefined = block.params.cwd +interface ExecuteCommandParams { + command: string + cwd?: string +} - try { - if (block.partial) { - await task.ask("command", removeClosingTag("command", command), block.partial).catch(() => {}) - return - } else { +export class ExecuteCommandTool extends BaseTool<"execute_command"> { + readonly name = "execute_command" as const + + parseLegacy(params: Partial>): ExecuteCommandParams { + return { + command: params.command || "", + cwd: params.cwd, + } + } + + async execute(params: ExecuteCommandParams, task: Task, callbacks: ToolCallbacks): Promise { + const { command, cwd: customCwd } = params + const { handleError, pushToolResult, askApproval, removeClosingTag } = callbacks + + try { if (!command) { task.consecutiveMistakeCount++ task.recordToolError("execute_command") @@ -53,8 +58,8 @@ export async function executeCommandTool( task.consecutiveMistakeCount = 0 - command = unescapeHtmlEntities(command) // Unescape HTML entities. - const didApprove = await askApproval("command", command) + const unescapedCommand = unescapeHtmlEntities(command) + const didApprove = await askApproval("command", unescapedCommand) if (!didApprove) { return @@ -81,14 +86,16 @@ export async function executeCommandTool( .get("commandTimeoutAllowlist", []) // Check if command matches any prefix in the allowlist - const isCommandAllowlisted = commandTimeoutAllowlist.some((prefix) => command!.startsWith(prefix.trim())) + const isCommandAllowlisted = commandTimeoutAllowlist.some((prefix) => + unescapedCommand.startsWith(prefix.trim()), + ) // Convert seconds to milliseconds for internal use, but skip timeout if command is allowlisted const commandExecutionTimeout = isCommandAllowlisted ? 0 : commandExecutionTimeoutSeconds * 1000 const options: ExecuteCommandOptions = { executionId, - command, + command: unescapedCommand, customCwd, terminalShellIntegrationDisabled, terminalOutputLineLimit, @@ -97,7 +104,7 @@ export async function executeCommandTool( } try { - const [rejected, result] = await executeCommand(task, options) + const [rejected, result] = await executeCommandInTerminal(task, options) if (rejected) { task.didRejectTool = true @@ -110,7 +117,7 @@ export async function executeCommandTool( await task.say("shell_integration_warning") if (error instanceof ShellIntegrationError) { - const [rejected, result] = await executeCommand(task, { + const [rejected, result] = await executeCommandInTerminal(task, { ...options, terminalShellIntegrationDisabled: true, }) @@ -125,11 +132,18 @@ export async function executeCommandTool( } } + return + } catch (error) { + await handleError("executing command", error as Error) return } - } catch (error) { - await handleError("executing command", error) - return + } + + override async handlePartial(task: Task, block: ToolUse<"execute_command">): Promise { + const command = block.params.command + await task + .ask("command", this.removeClosingTag("command", command, block.partial), block.partial) + .catch(() => {}) } } @@ -143,7 +157,7 @@ export type ExecuteCommandOptions = { commandExecutionTimeout?: number } -export async function executeCommand( +export async function executeCommandInTerminal( task: Task, { executionId, @@ -367,3 +381,5 @@ export async function executeCommand( ] } } + +export const executeCommandTool = new ExecuteCommandTool() diff --git a/src/core/tools/FetchInstructionsTool.ts b/src/core/tools/FetchInstructionsTool.ts new file mode 100644 index 00000000000..d1610d9ee44 --- /dev/null +++ b/src/core/tools/FetchInstructionsTool.ts @@ -0,0 +1,78 @@ +import { Task } from "../task/Task" +import { fetchInstructions } from "../prompts/instructions/instructions" +import { ClineSayTool } from "../../shared/ExtensionMessage" +import { formatResponse } from "../prompts/responses" +import { BaseTool, ToolCallbacks } from "./BaseTool" +import type { ToolUse } from "../../shared/tools" + +interface FetchInstructionsParams { + task: string +} + +export class FetchInstructionsTool extends BaseTool<"fetch_instructions"> { + readonly name = "fetch_instructions" as const + + parseLegacy(params: Partial>): FetchInstructionsParams { + return { + task: params.task || "", + } + } + + async execute(params: FetchInstructionsParams, task: Task, callbacks: ToolCallbacks): Promise { + const { handleError, pushToolResult, askApproval } = callbacks + const { task: taskParam } = params + + try { + if (!taskParam) { + task.consecutiveMistakeCount++ + task.recordToolError("fetch_instructions") + pushToolResult(await task.sayAndCreateMissingParamError("fetch_instructions", "task")) + return + } + + task.consecutiveMistakeCount = 0 + + const completeMessage = JSON.stringify({ + tool: "fetchInstructions", + content: taskParam, + } satisfies ClineSayTool) + + const didApprove = await askApproval("tool", completeMessage) + + if (!didApprove) { + return + } + + // Now fetch the content and provide it to the agent. + const provider = task.providerRef.deref() + const mcpHub = provider?.getMcpHub() + + if (!mcpHub) { + throw new Error("MCP hub not available") + } + + const diffStrategy = task.diffStrategy + const context = provider?.context + const content = await fetchInstructions(taskParam, { mcpHub, diffStrategy, context }) + + if (!content) { + pushToolResult(formatResponse.toolError(`Invalid instructions request: ${taskParam}`)) + return + } + + pushToolResult(content) + } catch (error) { + await handleError("fetch instructions", error as Error) + } + } + + override async handlePartial(task: Task, block: ToolUse<"fetch_instructions">): Promise { + const taskParam: string | undefined = block.params.task + const sharedMessageProps: ClineSayTool = { tool: "fetchInstructions", content: taskParam } + + const partialMessage = JSON.stringify({ ...sharedMessageProps, content: undefined } satisfies ClineSayTool) + await task.ask("tool", partialMessage, block.partial).catch(() => {}) + } +} + +export const fetchInstructionsTool = new FetchInstructionsTool() diff --git a/src/core/tools/GenerateImageTool.ts b/src/core/tools/GenerateImageTool.ts new file mode 100644 index 00000000000..4b41f840d42 --- /dev/null +++ b/src/core/tools/GenerateImageTool.ts @@ -0,0 +1,241 @@ +import path from "path" +import fs from "fs/promises" +import * as vscode from "vscode" +import type { GenerateImageParams } from "@roo-code/types" +import { Task } from "../task/Task" +import { formatResponse } from "../prompts/responses" +import { fileExistsAtPath } from "../../utils/fs" +import { getReadablePath } from "../../utils/path" +import { isPathOutsideWorkspace } from "../../utils/pathUtils" +import { EXPERIMENT_IDS, experiments } from "../../shared/experiments" +import { OpenRouterHandler } from "../../api/providers/openrouter" +import { BaseTool, ToolCallbacks } from "./BaseTool" +import type { ToolUse } from "../../shared/tools" + +const IMAGE_GENERATION_MODELS = ["google/gemini-2.5-flash-image", "openai/gpt-5-image", "openai/gpt-5-image-mini"] + +export class GenerateImageTool extends BaseTool<"generate_image"> { + readonly name = "generate_image" as const + + parseLegacy(params: Partial>): GenerateImageParams { + return { + prompt: params.prompt || "", + path: params.path || "", + image: params.image, + } + } + + async execute(params: GenerateImageParams, task: Task, callbacks: ToolCallbacks): Promise { + const { prompt, path: relPath, image: inputImagePath } = params + const { handleError, pushToolResult, askApproval, removeClosingTag } = callbacks + + const provider = task.providerRef.deref() + const state = await provider?.getState() + const isImageGenerationEnabled = experiments.isEnabled( + state?.experiments ?? {}, + EXPERIMENT_IDS.IMAGE_GENERATION, + ) + + if (!isImageGenerationEnabled) { + pushToolResult( + formatResponse.toolError( + "Image generation is an experimental feature that must be enabled in settings. Please enable 'Image Generation' in the Experimental Settings section.", + ), + ) + return + } + + if (!prompt) { + task.consecutiveMistakeCount++ + task.recordToolError("generate_image") + pushToolResult(await task.sayAndCreateMissingParamError("generate_image", "prompt")) + return + } + + if (!relPath) { + task.consecutiveMistakeCount++ + task.recordToolError("generate_image") + pushToolResult(await task.sayAndCreateMissingParamError("generate_image", "path")) + return + } + + const accessAllowed = task.rooIgnoreController?.validateAccess(relPath) + if (!accessAllowed) { + await task.say("rooignore_error", relPath) + pushToolResult(formatResponse.toolError(formatResponse.rooIgnoreError(relPath))) + return + } + + let inputImageData: string | undefined + if (inputImagePath) { + const inputImageFullPath = path.resolve(task.cwd, inputImagePath) + + const inputImageExists = await fileExistsAtPath(inputImageFullPath) + if (!inputImageExists) { + await task.say("error", `Input image not found: ${getReadablePath(task.cwd, inputImagePath)}`) + pushToolResult( + formatResponse.toolError(`Input image not found: ${getReadablePath(task.cwd, inputImagePath)}`), + ) + return + } + + const inputImageAccessAllowed = task.rooIgnoreController?.validateAccess(inputImagePath) + if (!inputImageAccessAllowed) { + await task.say("rooignore_error", inputImagePath) + pushToolResult(formatResponse.toolError(formatResponse.rooIgnoreError(inputImagePath))) + return + } + + try { + const imageBuffer = await fs.readFile(inputImageFullPath) + const imageExtension = path.extname(inputImageFullPath).toLowerCase().replace(".", "") + + const supportedFormats = ["png", "jpg", "jpeg", "gif", "webp"] + if (!supportedFormats.includes(imageExtension)) { + await task.say( + "error", + `Unsupported image format: ${imageExtension}. Supported formats: ${supportedFormats.join(", ")}`, + ) + pushToolResult( + formatResponse.toolError( + `Unsupported image format: ${imageExtension}. Supported formats: ${supportedFormats.join(", ")}`, + ), + ) + return + } + + const mimeType = imageExtension === "jpg" ? "jpeg" : imageExtension + inputImageData = `data:image/${mimeType};base64,${imageBuffer.toString("base64")}` + } catch (error) { + await task.say( + "error", + `Failed to read input image: ${error instanceof Error ? error.message : "Unknown error"}`, + ) + pushToolResult( + formatResponse.toolError( + `Failed to read input image: ${error instanceof Error ? error.message : "Unknown error"}`, + ), + ) + return + } + } + + const isWriteProtected = task.rooProtectedController?.isWriteProtected(relPath) || false + + const openRouterApiKey = state?.openRouterImageApiKey + + if (!openRouterApiKey) { + await task.say( + "error", + "OpenRouter API key is required for image generation. Please configure it in the Image Generation experimental settings.", + ) + pushToolResult( + formatResponse.toolError( + "OpenRouter API key is required for image generation. Please configure it in the Image Generation experimental settings.", + ), + ) + return + } + + const selectedModel = state?.openRouterImageGenerationSelectedModel || IMAGE_GENERATION_MODELS[0] + + const fullPath = path.resolve(task.cwd, removeClosingTag("path", relPath)) + const isOutsideWorkspace = isPathOutsideWorkspace(fullPath) + + const sharedMessageProps = { + tool: "generateImage" as const, + path: getReadablePath(task.cwd, removeClosingTag("path", relPath)), + content: prompt, + isOutsideWorkspace, + isProtected: isWriteProtected, + } + + try { + task.consecutiveMistakeCount = 0 + + const approvalMessage = JSON.stringify({ + ...sharedMessageProps, + content: prompt, + ...(inputImagePath && { inputImage: getReadablePath(task.cwd, inputImagePath) }), + }) + + const didApprove = await askApproval("tool", approvalMessage, undefined, isWriteProtected) + + if (!didApprove) { + return + } + + const openRouterHandler = new OpenRouterHandler({} as any) + + const result = await openRouterHandler.generateImage( + prompt, + selectedModel, + openRouterApiKey, + inputImageData, + ) + + if (!result.success) { + await task.say("error", result.error || "Failed to generate image") + pushToolResult(formatResponse.toolError(result.error || "Failed to generate image")) + return + } + + if (!result.imageData) { + const errorMessage = "No image data received" + await task.say("error", errorMessage) + pushToolResult(formatResponse.toolError(errorMessage)) + return + } + + const base64Match = result.imageData.match(/^data:image\/(png|jpeg|jpg);base64,(.+)$/) + if (!base64Match) { + const errorMessage = "Invalid image format received" + await task.say("error", errorMessage) + pushToolResult(formatResponse.toolError(errorMessage)) + return + } + + const imageFormat = base64Match[1] + const base64Data = base64Match[2] + + let finalPath = relPath + if (!finalPath.match(/\.(png|jpg|jpeg)$/i)) { + finalPath = `${finalPath}.${imageFormat === "jpeg" ? "jpg" : imageFormat}` + } + + const imageBuffer = Buffer.from(base64Data, "base64") + + const absolutePath = path.resolve(task.cwd, finalPath) + const directory = path.dirname(absolutePath) + await fs.mkdir(directory, { recursive: true }) + + await fs.writeFile(absolutePath, imageBuffer) + + if (finalPath) { + await task.fileContextTracker.trackFileContext(finalPath, "roo_edited") + } + + task.didEditFile = true + + task.recordToolUsage("generate_image") + + const fullImagePath = path.join(task.cwd, finalPath) + + let imageUri = provider?.convertToWebviewUri?.(fullImagePath) ?? vscode.Uri.file(fullImagePath).toString() + + const cacheBuster = Date.now() + imageUri = imageUri.includes("?") ? `${imageUri}&t=${cacheBuster}` : `${imageUri}?t=${cacheBuster}` + + await task.say("image", JSON.stringify({ imageUri, imagePath: fullImagePath })) + pushToolResult(formatResponse.toolResult(getReadablePath(task.cwd, finalPath))) + } catch (error) { + await handleError("generating image", error as Error) + } + } + + override async handlePartial(task: Task, block: ToolUse<"generate_image">): Promise { + return + } +} + +export const generateImageTool = new GenerateImageTool() diff --git a/src/core/tools/InsertContentTool.ts b/src/core/tools/InsertContentTool.ts new file mode 100644 index 00000000000..55b31f05ba6 --- /dev/null +++ b/src/core/tools/InsertContentTool.ts @@ -0,0 +1,225 @@ +import fs from "fs/promises" +import path from "path" + +import { getReadablePath } from "../../utils/path" +import { Task } from "../task/Task" +import { formatResponse } from "../prompts/responses" +import { ClineSayTool } from "../../shared/ExtensionMessage" +import { RecordSource } from "../context-tracking/FileContextTrackerTypes" +import { fileExistsAtPath } from "../../utils/fs" +import { insertGroups } from "../diff/insert-groups" +import { DEFAULT_WRITE_DELAY_MS } from "@roo-code/types" +import { EXPERIMENT_IDS, experiments } from "../../shared/experiments" +import { convertNewFileToUnifiedDiff, computeDiffStats, sanitizeUnifiedDiff } from "../diff/stats" +import { BaseTool, ToolCallbacks } from "./BaseTool" +import type { ToolUse } from "../../shared/tools" + +interface InsertContentParams { + path: string + line: number + content: string +} + +export class InsertContentTool extends BaseTool<"insert_content"> { + readonly name = "insert_content" as const + + parseLegacy(params: Partial>): InsertContentParams { + const relPath = params.path || "" + const lineStr = params.line || "" + const content = params.content || "" + + const lineNumber = parseInt(lineStr, 10) + + return { + path: relPath, + line: lineNumber, + content: content, + } + } + + async execute(params: InsertContentParams, task: Task, callbacks: ToolCallbacks): Promise { + const { path: relPath, line: lineNumber, content } = params + const { askApproval, handleError, pushToolResult } = callbacks + + try { + // Validate required parameters + if (!relPath) { + task.consecutiveMistakeCount++ + task.recordToolError("insert_content") + pushToolResult(await task.sayAndCreateMissingParamError("insert_content", "path")) + return + } + + if (isNaN(lineNumber) || lineNumber < 0) { + task.consecutiveMistakeCount++ + task.recordToolError("insert_content") + pushToolResult(formatResponse.toolError("Invalid line number. Must be a non-negative integer.")) + return + } + + if (content === undefined) { + task.consecutiveMistakeCount++ + task.recordToolError("insert_content") + pushToolResult(await task.sayAndCreateMissingParamError("insert_content", "content")) + return + } + + const accessAllowed = task.rooIgnoreController?.validateAccess(relPath) + + if (!accessAllowed) { + await task.say("rooignore_error", relPath) + pushToolResult(formatResponse.toolError(formatResponse.rooIgnoreError(relPath))) + return + } + + // Check if file is write-protected + const isWriteProtected = task.rooProtectedController?.isWriteProtected(relPath) || false + + const absolutePath = path.resolve(task.cwd, relPath) + + const fileExists = await fileExistsAtPath(absolutePath) + let fileContent: string = "" + if (!fileExists) { + if (lineNumber > 1) { + task.consecutiveMistakeCount++ + task.recordToolError("insert_content") + const formattedError = `Cannot insert content at line ${lineNumber} into a non-existent file. For new files, 'line' must be 0 (to append) or 1 (to insert at the beginning).` + await task.say("error", formattedError) + pushToolResult(formattedError) + return + } + } else { + fileContent = await fs.readFile(absolutePath, "utf8") + } + + task.consecutiveMistakeCount = 0 + + task.diffViewProvider.editType = fileExists ? "modify" : "create" + task.diffViewProvider.originalContent = fileContent + const lines = fileExists ? fileContent.split("\n") : [] + + let updatedContent = insertGroups(lines, [ + { + index: lineNumber - 1, + elements: content.split("\n"), + }, + ]).join("\n") + + // Check if preventFocusDisruption experiment is enabled + const provider = task.providerRef.deref() + const state = await provider?.getState() + const diagnosticsEnabled = state?.diagnosticsEnabled ?? true + const writeDelayMs = state?.writeDelayMs ?? DEFAULT_WRITE_DELAY_MS + const isPreventFocusDisruptionEnabled = experiments.isEnabled( + state?.experiments ?? {}, + EXPERIMENT_IDS.PREVENT_FOCUS_DISRUPTION, + ) + + // Build unified diff for display (normalize EOLs only for diff generation) + let unified: string + if (fileExists) { + const oldForDiff = fileContent.replace(/\r\n/g, "\n") + const newForDiff = updatedContent.replace(/\r\n/g, "\n") + unified = formatResponse.createPrettyPatch(relPath, oldForDiff, newForDiff) + if (!unified) { + pushToolResult(`No changes needed for '${relPath}'`) + return + } + } else { + const newForDiff = updatedContent.replace(/\r\n/g, "\n") + unified = convertNewFileToUnifiedDiff(newForDiff, relPath) + } + unified = sanitizeUnifiedDiff(unified) + const diffStats = computeDiffStats(unified) || undefined + + // Prepare the approval message (same for both flows) + const sharedMessageProps: ClineSayTool = { + tool: "insertContent", + path: getReadablePath(task.cwd, relPath), + diff: content, + lineNumber: lineNumber, + } + + const completeMessage = JSON.stringify({ + ...sharedMessageProps, + // Send unified diff as content for render-only webview + content: unified, + lineNumber: lineNumber, + isProtected: isWriteProtected, + diffStats, + } satisfies ClineSayTool) + + // Show diff view if focus disruption prevention is disabled + if (!isPreventFocusDisruptionEnabled) { + await task.diffViewProvider.open(relPath) + await task.diffViewProvider.update(updatedContent, true) + task.diffViewProvider.scrollToFirstDiff() + } + + // Ask for approval (same for both flows) + const didApprove = await askApproval("tool", completeMessage, undefined, isWriteProtected) + + if (!didApprove) { + // Revert changes if diff view was shown + if (!isPreventFocusDisruptionEnabled) { + await task.diffViewProvider.revertChanges() + } + pushToolResult("Changes were rejected by the user.") + await task.diffViewProvider.reset() + return + } + + // Save the changes + if (isPreventFocusDisruptionEnabled) { + // Direct file write without diff view or opening the file + await task.diffViewProvider.saveDirectly( + relPath, + updatedContent, + false, + diagnosticsEnabled, + writeDelayMs, + ) + } else { + // Call saveChanges to update the DiffViewProvider properties + await task.diffViewProvider.saveChanges(diagnosticsEnabled, writeDelayMs) + } + + // Track file edit operation + if (relPath) { + await task.fileContextTracker.trackFileContext(relPath, "roo_edited" as RecordSource) + } + + task.didEditFile = true + + // Get the formatted response message + const message = await task.diffViewProvider.pushToolWriteResult(task, task.cwd, !fileExists) + + pushToolResult(message) + + await task.diffViewProvider.reset() + + // Process any queued messages after file edit completes + task.processQueuedMessages() + } catch (error) { + await handleError("insert content", error as Error) + await task.diffViewProvider.reset() + } + } + + override async handlePartial(task: Task, block: ToolUse<"insert_content">): Promise { + const relPath: string | undefined = block.params.path + const line: string | undefined = block.params.line + const content: string | undefined = block.params.content + + const sharedMessageProps: ClineSayTool = { + tool: "insertContent", + path: getReadablePath(task.cwd, relPath || ""), + diff: content, + lineNumber: line ? parseInt(line, 10) : undefined, + } + + await task.ask("tool", JSON.stringify(sharedMessageProps), block.partial).catch(() => {}) + } +} + +export const insertContentTool = new InsertContentTool() diff --git a/src/core/tools/ListCodeDefinitionNamesTool.ts b/src/core/tools/ListCodeDefinitionNamesTool.ts new file mode 100644 index 00000000000..981b508ee32 --- /dev/null +++ b/src/core/tools/ListCodeDefinitionNamesTool.ts @@ -0,0 +1,107 @@ +import path from "path" +import fs from "fs/promises" + +import { Task } from "../task/Task" +import { ClineSayTool } from "../../shared/ExtensionMessage" +import { getReadablePath } from "../../utils/path" +import { isPathOutsideWorkspace } from "../../utils/pathUtils" +import { parseSourceCodeForDefinitionsTopLevel, parseSourceCodeDefinitionsForFile } from "../../services/tree-sitter" +import { RecordSource } from "../context-tracking/FileContextTrackerTypes" +import { truncateDefinitionsToLineLimit } from "./helpers/truncateDefinitions" +import { BaseTool, ToolCallbacks } from "./BaseTool" +import type { ToolUse } from "../../shared/tools" + +interface ListCodeDefinitionNamesParams { + path: string +} + +export class ListCodeDefinitionNamesTool extends BaseTool<"list_code_definition_names"> { + readonly name = "list_code_definition_names" as const + + parseLegacy(params: Partial>): ListCodeDefinitionNamesParams { + return { + path: params.path || "", + } + } + + async execute(params: ListCodeDefinitionNamesParams, task: Task, callbacks: ToolCallbacks): Promise { + const { askApproval, handleError, pushToolResult } = callbacks + const { path: relPath } = params + + if (!relPath) { + task.consecutiveMistakeCount++ + task.recordToolError("list_code_definition_names") + pushToolResult(await task.sayAndCreateMissingParamError("list_code_definition_names", "path")) + return + } + + task.consecutiveMistakeCount = 0 + + const absolutePath = path.resolve(task.cwd, relPath) + const isOutsideWorkspace = isPathOutsideWorkspace(absolutePath) + + const sharedMessageProps: ClineSayTool = { + tool: "listCodeDefinitionNames", + path: getReadablePath(task.cwd, relPath), + isOutsideWorkspace, + } + + try { + let result: string + + try { + const stats = await fs.stat(absolutePath) + + if (stats.isFile()) { + const fileResult = await parseSourceCodeDefinitionsForFile(absolutePath, task.rooIgnoreController) + + if (fileResult) { + const { maxReadFileLine = -1 } = (await task.providerRef.deref()?.getState()) ?? {} + result = truncateDefinitionsToLineLimit(fileResult, maxReadFileLine) + } else { + result = "No source code definitions found in file." + } + } else if (stats.isDirectory()) { + result = await parseSourceCodeForDefinitionsTopLevel(absolutePath, task.rooIgnoreController) + } else { + result = "The specified path is neither a file nor a directory." + } + } catch { + result = `${absolutePath}: does not exist or cannot be accessed.` + } + + const completeMessage = JSON.stringify({ ...sharedMessageProps, content: result } satisfies ClineSayTool) + const didApprove = await askApproval("tool", completeMessage) + + if (!didApprove) { + return + } + + if (relPath) { + await task.fileContextTracker.trackFileContext(relPath, "read_tool" as RecordSource) + } + + pushToolResult(result) + } catch (error) { + await handleError("parsing source code definitions", error as Error) + } + } + + override async handlePartial(task: Task, block: ToolUse<"list_code_definition_names">): Promise { + const relPath: string | undefined = block.params.path + + const absolutePath = relPath ? path.resolve(task.cwd, relPath) : task.cwd + const isOutsideWorkspace = isPathOutsideWorkspace(absolutePath) + + const sharedMessageProps: ClineSayTool = { + tool: "listCodeDefinitionNames", + path: getReadablePath(task.cwd, relPath || ""), + isOutsideWorkspace, + } + + const partialMessage = JSON.stringify({ ...sharedMessageProps, content: "" } satisfies ClineSayTool) + await task.ask("tool", partialMessage, block.partial).catch(() => {}) + } +} + +export const listCodeDefinitionNamesTool = new ListCodeDefinitionNamesTool() diff --git a/src/core/tools/ListFilesTool.ts b/src/core/tools/ListFilesTool.ts new file mode 100644 index 00000000000..795bebf85ab --- /dev/null +++ b/src/core/tools/ListFilesTool.ts @@ -0,0 +1,97 @@ +import * as path from "path" + +import { Task } from "../task/Task" +import { ClineSayTool } from "../../shared/ExtensionMessage" +import { formatResponse } from "../prompts/responses" +import { listFiles } from "../../services/glob/list-files" +import { getReadablePath } from "../../utils/path" +import { isPathOutsideWorkspace } from "../../utils/pathUtils" +import { BaseTool, ToolCallbacks } from "./BaseTool" +import type { ToolUse } from "../../shared/tools" + +interface ListFilesParams { + path: string + recursive?: boolean +} + +export class ListFilesTool extends BaseTool<"list_files"> { + readonly name = "list_files" as const + + parseLegacy(params: Partial>): ListFilesParams { + const recursiveRaw: string | undefined = params.recursive + const recursive = recursiveRaw?.toLowerCase() === "true" + + return { + path: params.path || "", + recursive, + } + } + + async execute(params: ListFilesParams, task: Task, callbacks: ToolCallbacks): Promise { + const { path: relDirPath, recursive } = params + const { askApproval, handleError, pushToolResult, removeClosingTag } = callbacks + + try { + if (!relDirPath) { + task.consecutiveMistakeCount++ + task.recordToolError("list_files") + pushToolResult(await task.sayAndCreateMissingParamError("list_files", "path")) + return + } + + task.consecutiveMistakeCount = 0 + + const absolutePath = path.resolve(task.cwd, relDirPath) + const isOutsideWorkspace = isPathOutsideWorkspace(absolutePath) + + const [files, didHitLimit] = await listFiles(absolutePath, recursive || false, 200) + const { showRooIgnoredFiles = false } = (await task.providerRef.deref()?.getState()) ?? {} + + const result = formatResponse.formatFilesList( + absolutePath, + files, + didHitLimit, + task.rooIgnoreController, + showRooIgnoredFiles, + task.rooProtectedController, + ) + + const sharedMessageProps: ClineSayTool = { + tool: !recursive ? "listFilesTopLevel" : "listFilesRecursive", + path: getReadablePath(task.cwd, relDirPath), + isOutsideWorkspace, + } + + const completeMessage = JSON.stringify({ ...sharedMessageProps, content: result } satisfies ClineSayTool) + const didApprove = await askApproval("tool", completeMessage) + + if (!didApprove) { + return + } + + pushToolResult(result) + } catch (error) { + await handleError("listing files", error) + } + } + + override async handlePartial(task: Task, block: ToolUse<"list_files">): Promise { + const relDirPath: string | undefined = block.params.path + const recursiveRaw: string | undefined = block.params.recursive + const recursive = recursiveRaw?.toLowerCase() === "true" + + const absolutePath = relDirPath ? path.resolve(task.cwd, relDirPath) : task.cwd + const isOutsideWorkspace = isPathOutsideWorkspace(absolutePath) + + const sharedMessageProps: ClineSayTool = { + tool: !recursive ? "listFilesTopLevel" : "listFilesRecursive", + path: getReadablePath(task.cwd, this.removeClosingTag("path", relDirPath, block.partial)), + isOutsideWorkspace, + } + + const partialMessage = JSON.stringify({ ...sharedMessageProps, content: "" } satisfies ClineSayTool) + await task.ask("tool", partialMessage, block.partial).catch(() => {}) + } +} + +export const listFilesTool = new ListFilesTool() diff --git a/src/core/tools/multiApplyDiffTool.ts b/src/core/tools/MultiApplyDiffTool.ts similarity index 96% rename from src/core/tools/multiApplyDiffTool.ts rename to src/core/tools/MultiApplyDiffTool.ts index 08bce08ede1..4a41db76974 100644 --- a/src/core/tools/multiApplyDiffTool.ts +++ b/src/core/tools/MultiApplyDiffTool.ts @@ -14,8 +14,10 @@ import { RecordSource } from "../context-tracking/FileContextTrackerTypes" import { unescapeHtmlEntities } from "../../utils/text-normalization" import { parseXmlForDiff } from "../../utils/xml" import { EXPERIMENT_IDS, experiments } from "../../shared/experiments" -import { applyDiffToolLegacy } from "./applyDiffTool" +import { applyDiffTool as applyDiffToolClass } from "./ApplyDiffTool" import { computeDiffStats, sanitizeUnifiedDiff } from "../diff/stats" +import * as vscode from "vscode" +import { ToolProtocol, isNativeProtocol } from "@roo-code/types" interface DiffOperation { path: string @@ -59,6 +61,17 @@ export async function applyDiffTool( pushToolResult: PushToolResult, removeClosingTag: RemoveClosingTag, ) { + // Check if native protocol is enabled - if so, always use single-file class-based tool + const toolProtocol = vscode.workspace.getConfiguration("roo-cline").get("toolProtocol", "xml") + if (isNativeProtocol(toolProtocol)) { + return applyDiffToolClass.handle(cline, block as ToolUse<"apply_diff">, { + askApproval, + handleError, + pushToolResult, + removeClosingTag, + }) + } + // Check if MULTI_FILE_APPLY_DIFF experiment is enabled const provider = cline.providerRef.deref() if (provider) { @@ -68,9 +81,14 @@ export async function applyDiffTool( EXPERIMENT_IDS.MULTI_FILE_APPLY_DIFF, ) - // If experiment is disabled, use legacy tool + // If experiment is disabled, use single-file class-based tool if (!isMultiFileApplyDiffEnabled) { - return applyDiffToolLegacy(cline, block, askApproval, handleError, pushToolResult, removeClosingTag) + return applyDiffToolClass.handle(cline, block as ToolUse<"apply_diff">, { + askApproval, + handleError, + pushToolResult, + removeClosingTag, + }) } } diff --git a/src/core/tools/newTaskTool.ts b/src/core/tools/NewTaskTool.ts similarity index 70% rename from src/core/tools/newTaskTool.ts rename to src/core/tools/NewTaskTool.ts index aeb0c8393b4..2535cef1d21 100644 --- a/src/core/tools/newTaskTool.ts +++ b/src/core/tools/NewTaskTool.ts @@ -2,38 +2,37 @@ import * as vscode from "vscode" import { TodoItem } from "@roo-code/types" -import { ToolUse, AskApproval, HandleError, PushToolResult, RemoveClosingTag } from "../../shared/tools" import { Task } from "../task/Task" import { defaultModeSlug, getModeBySlug } from "../../shared/modes" import { formatResponse } from "../prompts/responses" import { t } from "../../i18n" -import { parseMarkdownChecklist } from "./updateTodoListTool" +import { parseMarkdownChecklist } from "./UpdateTodoListTool" import { Package } from "../../shared/package" +import { BaseTool, ToolCallbacks } from "./BaseTool" +import type { ToolUse } from "../../shared/tools" -export async function newTaskTool( - task: Task, - block: ToolUse, - askApproval: AskApproval, - handleError: HandleError, - pushToolResult: PushToolResult, - removeClosingTag: RemoveClosingTag, -) { - const mode: string | undefined = block.params.mode - const message: string | undefined = block.params.message - const todos: string | undefined = block.params.todos - - try { - if (block.partial) { - const partialMessage = JSON.stringify({ - tool: "newTask", - mode: removeClosingTag("mode", mode), - content: removeClosingTag("message", message), - todos: removeClosingTag("todos", todos), - }) +interface NewTaskParams { + mode: string + message: string + todos?: string +} - await task.ask("tool", partialMessage, block.partial).catch(() => {}) - return - } else { +export class NewTaskTool extends BaseTool<"new_task"> { + readonly name = "new_task" as const + + parseLegacy(params: Partial>): NewTaskParams { + return { + mode: params.mode || "", + message: params.message || "", + todos: params.todos, + } + } + + async execute(params: NewTaskParams, task: Task, callbacks: ToolCallbacks): Promise { + const { mode, message, todos } = params + const { askApproval, handleError, pushToolResult } = callbacks + + try { // Validate required parameters. if (!mode) { task.consecutiveMistakeCount++ @@ -134,10 +133,27 @@ export async function newTaskTool( `Successfully created new task in ${targetMode.name} mode with message: ${unescapedMessage} and ${todoItems.length} todo items`, ) + return + } catch (error) { + await handleError("creating new task", error) return } - } catch (error) { - await handleError("creating new task", error) - return + } + + override async handlePartial(task: Task, block: ToolUse<"new_task">): Promise { + const mode: string | undefined = block.params.mode + const message: string | undefined = block.params.message + const todos: string | undefined = block.params.todos + + const partialMessage = JSON.stringify({ + tool: "newTask", + mode: this.removeClosingTag("mode", mode, block.partial), + content: this.removeClosingTag("message", message, block.partial), + todos: this.removeClosingTag("todos", todos, block.partial), + }) + + await task.ask("tool", partialMessage, block.partial).catch(() => {}) } } + +export const newTaskTool = new NewTaskTool() diff --git a/src/core/tools/ReadFileTool.ts b/src/core/tools/ReadFileTool.ts new file mode 100644 index 00000000000..7b6cdbf9bee --- /dev/null +++ b/src/core/tools/ReadFileTool.ts @@ -0,0 +1,674 @@ +import path from "path" +import { isBinaryFile } from "isbinaryfile" +import type { FileEntry, LineRange } from "@roo-code/types" + +import { Task } from "../task/Task" +import { ClineSayTool } from "../../shared/ExtensionMessage" +import { formatResponse } from "../prompts/responses" +import { t } from "../../i18n" +import { RecordSource } from "../context-tracking/FileContextTrackerTypes" +import { isPathOutsideWorkspace } from "../../utils/pathUtils" +import { getReadablePath } from "../../utils/path" +import { countFileLines } from "../../integrations/misc/line-counter" +import { readLines } from "../../integrations/misc/read-lines" +import { extractTextFromFile, addLineNumbers, getSupportedBinaryFormats } from "../../integrations/misc/extract-text" +import { parseSourceCodeDefinitionsForFile } from "../../services/tree-sitter" +import { parseXml } from "../../utils/xml" +import { + DEFAULT_MAX_IMAGE_FILE_SIZE_MB, + DEFAULT_MAX_TOTAL_IMAGE_SIZE_MB, + isSupportedImageFormat, + validateImageForProcessing, + processImageFile, + ImageMemoryTracker, +} from "./helpers/imageHelpers" +import { validateFileTokenBudget, truncateFileContent } from "./helpers/fileTokenBudget" +import { truncateDefinitionsToLineLimit } from "./helpers/truncateDefinitions" +import { BaseTool, ToolCallbacks } from "./BaseTool" +import type { ToolUse } from "../../shared/tools" + +interface FileResult { + path: string + status: "approved" | "denied" | "blocked" | "error" | "pending" + content?: string + error?: string + notice?: string + lineRanges?: LineRange[] + xmlContent?: string + imageDataUrl?: string + feedbackText?: string + feedbackImages?: any[] +} + +export class ReadFileTool extends BaseTool<"read_file"> { + readonly name = "read_file" as const + + parseLegacy(params: Partial>): FileEntry[] { + const argsXmlTag = params.args + const legacyPath = params.path + const legacyStartLineStr = params.start_line + const legacyEndLineStr = params.end_line + + const fileEntries: FileEntry[] = [] + + // XML args format + if (argsXmlTag) { + const parsed = parseXml(argsXmlTag) as any + const files = Array.isArray(parsed.file) ? parsed.file : [parsed.file].filter(Boolean) + + for (const file of files) { + if (!file.path) continue + + const fileEntry: FileEntry = { + path: file.path, + lineRanges: [], + } + + if (file.line_range) { + const ranges = Array.isArray(file.line_range) ? file.line_range : [file.line_range] + for (const range of ranges) { + const match = String(range).match(/(\d+)-(\d+)/) + if (match) { + const [, start, end] = match.map(Number) + if (!isNaN(start) && !isNaN(end)) { + fileEntry.lineRanges?.push({ start, end }) + } + } + } + } + fileEntries.push(fileEntry) + } + + return fileEntries + } + + // Legacy single file path + if (legacyPath) { + const fileEntry: FileEntry = { + path: legacyPath, + lineRanges: [], + } + + if (legacyStartLineStr && legacyEndLineStr) { + const start = parseInt(legacyStartLineStr, 10) + const end = parseInt(legacyEndLineStr, 10) + if (!isNaN(start) && !isNaN(end) && start > 0 && end > 0) { + fileEntry.lineRanges?.push({ start, end }) + } + } + fileEntries.push(fileEntry) + } + + return fileEntries + } + + async execute(fileEntries: FileEntry[], task: Task, callbacks: ToolCallbacks): Promise { + const { handleError, pushToolResult } = callbacks + + if (fileEntries.length === 0) { + task.consecutiveMistakeCount++ + task.recordToolError("read_file") + const errorMsg = await task.sayAndCreateMissingParamError("read_file", "args (containing valid file paths)") + pushToolResult(`${errorMsg}`) + return + } + + const modelInfo = task.api.getModel().info + const supportsImages = modelInfo.supportsImages ?? false + + const fileResults: FileResult[] = fileEntries.map((entry) => ({ + path: entry.path, + status: "pending", + lineRanges: entry.lineRanges, + })) + + const updateFileResult = (filePath: string, updates: Partial) => { + const index = fileResults.findIndex((result) => result.path === filePath) + if (index !== -1) { + fileResults[index] = { ...fileResults[index], ...updates } + } + } + + try { + const filesToApprove: FileResult[] = [] + + for (const fileResult of fileResults) { + const relPath = fileResult.path + const fullPath = path.resolve(task.cwd, relPath) + + if (fileResult.lineRanges) { + let hasRangeError = false + for (const range of fileResult.lineRanges) { + if (range.start > range.end) { + const errorMsg = "Invalid line range: end line cannot be less than start line" + updateFileResult(relPath, { + status: "blocked", + error: errorMsg, + xmlContent: `${relPath}Error reading file: ${errorMsg}`, + }) + await handleError(`reading file ${relPath}`, new Error(errorMsg)) + hasRangeError = true + break + } + if (isNaN(range.start) || isNaN(range.end)) { + const errorMsg = "Invalid line range values" + updateFileResult(relPath, { + status: "blocked", + error: errorMsg, + xmlContent: `${relPath}Error reading file: ${errorMsg}`, + }) + await handleError(`reading file ${relPath}`, new Error(errorMsg)) + hasRangeError = true + break + } + } + if (hasRangeError) continue + } + + if (fileResult.status === "pending") { + const accessAllowed = task.rooIgnoreController?.validateAccess(relPath) + if (!accessAllowed) { + await task.say("rooignore_error", relPath) + const errorMsg = formatResponse.rooIgnoreError(relPath) + updateFileResult(relPath, { + status: "blocked", + error: errorMsg, + xmlContent: `${relPath}${errorMsg}`, + }) + continue + } + + filesToApprove.push(fileResult) + } + } + + if (filesToApprove.length > 1) { + const { maxReadFileLine = -1 } = (await task.providerRef.deref()?.getState()) ?? {} + + const batchFiles = filesToApprove.map((fileResult) => { + const relPath = fileResult.path + const fullPath = path.resolve(task.cwd, relPath) + const isOutsideWorkspace = isPathOutsideWorkspace(fullPath) + + let lineSnippet = "" + if (fileResult.lineRanges && fileResult.lineRanges.length > 0) { + const ranges = fileResult.lineRanges.map((range) => + t("tools:readFile.linesRange", { start: range.start, end: range.end }), + ) + lineSnippet = ranges.join(", ") + } else if (maxReadFileLine === 0) { + lineSnippet = t("tools:readFile.definitionsOnly") + } else if (maxReadFileLine > 0) { + lineSnippet = t("tools:readFile.maxLines", { max: maxReadFileLine }) + } + + const readablePath = getReadablePath(task.cwd, relPath) + const key = `${readablePath}${lineSnippet ? ` (${lineSnippet})` : ""}` + + return { path: readablePath, lineSnippet, isOutsideWorkspace, key, content: fullPath } + }) + + const completeMessage = JSON.stringify({ tool: "readFile", batchFiles } satisfies ClineSayTool) + const { response, text, images } = await task.ask("tool", completeMessage, false) + + if (response === "yesButtonClicked") { + if (text) await task.say("user_feedback", text, images) + filesToApprove.forEach((fileResult) => { + updateFileResult(fileResult.path, { + status: "approved", + feedbackText: text, + feedbackImages: images, + }) + }) + } else if (response === "noButtonClicked") { + if (text) await task.say("user_feedback", text, images) + task.didRejectTool = true + filesToApprove.forEach((fileResult) => { + updateFileResult(fileResult.path, { + status: "denied", + xmlContent: `${fileResult.path}Denied by user`, + feedbackText: text, + feedbackImages: images, + }) + }) + } else { + try { + const individualPermissions = JSON.parse(text || "{}") + let hasAnyDenial = false + + batchFiles.forEach((batchFile, index) => { + const fileResult = filesToApprove[index] + const approved = individualPermissions[batchFile.key] === true + + if (approved) { + updateFileResult(fileResult.path, { status: "approved" }) + } else { + hasAnyDenial = true + updateFileResult(fileResult.path, { + status: "denied", + xmlContent: `${fileResult.path}Denied by user`, + }) + } + }) + + if (hasAnyDenial) task.didRejectTool = true + } catch (error) { + console.error("Failed to parse individual permissions:", error) + task.didRejectTool = true + filesToApprove.forEach((fileResult) => { + updateFileResult(fileResult.path, { + status: "denied", + xmlContent: `${fileResult.path}Denied by user`, + }) + }) + } + } + } else if (filesToApprove.length === 1) { + const fileResult = filesToApprove[0] + const relPath = fileResult.path + const fullPath = path.resolve(task.cwd, relPath) + const isOutsideWorkspace = isPathOutsideWorkspace(fullPath) + const { maxReadFileLine = -1 } = (await task.providerRef.deref()?.getState()) ?? {} + + let lineSnippet = "" + if (fileResult.lineRanges && fileResult.lineRanges.length > 0) { + const ranges = fileResult.lineRanges.map((range) => + t("tools:readFile.linesRange", { start: range.start, end: range.end }), + ) + lineSnippet = ranges.join(", ") + } else if (maxReadFileLine === 0) { + lineSnippet = t("tools:readFile.definitionsOnly") + } else if (maxReadFileLine > 0) { + lineSnippet = t("tools:readFile.maxLines", { max: maxReadFileLine }) + } + + const completeMessage = JSON.stringify({ + tool: "readFile", + path: getReadablePath(task.cwd, relPath), + isOutsideWorkspace, + content: fullPath, + reason: lineSnippet, + } satisfies ClineSayTool) + + const { response, text, images } = await task.ask("tool", completeMessage, false) + + if (response !== "yesButtonClicked") { + if (text) await task.say("user_feedback", text, images) + task.didRejectTool = true + updateFileResult(relPath, { + status: "denied", + xmlContent: `${relPath}Denied by user`, + feedbackText: text, + feedbackImages: images, + }) + } else { + if (text) await task.say("user_feedback", text, images) + updateFileResult(relPath, { status: "approved", feedbackText: text, feedbackImages: images }) + } + } + + const imageMemoryTracker = new ImageMemoryTracker() + const state = await task.providerRef.deref()?.getState() + const { + maxReadFileLine = -1, + maxImageFileSize = DEFAULT_MAX_IMAGE_FILE_SIZE_MB, + maxTotalImageSize = DEFAULT_MAX_TOTAL_IMAGE_SIZE_MB, + } = state ?? {} + + for (const fileResult of fileResults) { + if (fileResult.status !== "approved") continue + + const relPath = fileResult.path + const fullPath = path.resolve(task.cwd, relPath) + + try { + const [totalLines, isBinary] = await Promise.all([countFileLines(fullPath), isBinaryFile(fullPath)]) + + if (isBinary) { + const fileExtension = path.extname(relPath).toLowerCase() + const supportedBinaryFormats = getSupportedBinaryFormats() + + if (isSupportedImageFormat(fileExtension)) { + try { + const validationResult = await validateImageForProcessing( + fullPath, + supportsImages, + maxImageFileSize, + maxTotalImageSize, + imageMemoryTracker.getTotalMemoryUsed(), + ) + + if (!validationResult.isValid) { + await task.fileContextTracker.trackFileContext(relPath, "read_tool" as RecordSource) + updateFileResult(relPath, { + xmlContent: `${relPath}\n${validationResult.notice}\n`, + }) + continue + } + + const imageResult = await processImageFile(fullPath) + imageMemoryTracker.addMemoryUsage(imageResult.sizeInMB) + await task.fileContextTracker.trackFileContext(relPath, "read_tool" as RecordSource) + + updateFileResult(relPath, { + xmlContent: `${relPath}\n${imageResult.notice}\n`, + imageDataUrl: imageResult.dataUrl, + }) + continue + } catch (error) { + const errorMsg = error instanceof Error ? error.message : String(error) + updateFileResult(relPath, { + status: "error", + error: `Error reading image file: ${errorMsg}`, + xmlContent: `${relPath}Error reading image file: ${errorMsg}`, + }) + await handleError( + `reading image file ${relPath}`, + error instanceof Error ? error : new Error(errorMsg), + ) + continue + } + } + + if (supportedBinaryFormats && supportedBinaryFormats.includes(fileExtension)) { + // Fall through to extractTextFromFile + } else { + const fileFormat = fileExtension.slice(1) || "bin" + updateFileResult(relPath, { + notice: `Binary file format: ${fileFormat}`, + xmlContent: `${relPath}\nBinary file - content not displayed\n`, + }) + continue + } + } + + if (fileResult.lineRanges && fileResult.lineRanges.length > 0) { + const rangeResults: string[] = [] + for (const range of fileResult.lineRanges) { + const content = addLineNumbers( + await readLines(fullPath, range.end - 1, range.start - 1), + range.start, + ) + const lineRangeAttr = ` lines="${range.start}-${range.end}"` + rangeResults.push(`\n${content}`) + } + updateFileResult(relPath, { + xmlContent: `${relPath}\n${rangeResults.join("\n")}\n`, + }) + continue + } + + if (maxReadFileLine === 0) { + try { + const defResult = await parseSourceCodeDefinitionsForFile( + fullPath, + task.rooIgnoreController, + ) + if (defResult) { + let xmlInfo = `Showing only ${maxReadFileLine} of ${totalLines} total lines. Use line_range if you need to read more lines\n` + updateFileResult(relPath, { + xmlContent: `${relPath}\n${defResult}\n${xmlInfo}`, + }) + } + } catch (error) { + if (error instanceof Error && error.message.startsWith("Unsupported language:")) { + console.warn(`[read_file] Warning: ${error.message}`) + } else { + console.error( + `[read_file] Unhandled error: ${error instanceof Error ? error.message : String(error)}`, + ) + } + } + continue + } + + if (maxReadFileLine > 0 && totalLines > maxReadFileLine) { + const content = addLineNumbers(await readLines(fullPath, maxReadFileLine - 1, 0)) + const lineRangeAttr = ` lines="1-${maxReadFileLine}"` + let xmlInfo = `\n${content}\n` + + try { + const defResult = await parseSourceCodeDefinitionsForFile( + fullPath, + task.rooIgnoreController, + ) + if (defResult) { + const truncatedDefs = truncateDefinitionsToLineLimit(defResult, maxReadFileLine) + xmlInfo += `${truncatedDefs}\n` + } + xmlInfo += `Showing only ${maxReadFileLine} of ${totalLines} total lines. Use line_range if you need to read more lines\n` + updateFileResult(relPath, { + xmlContent: `${relPath}\n${xmlInfo}`, + }) + } catch (error) { + if (error instanceof Error && error.message.startsWith("Unsupported language:")) { + console.warn(`[read_file] Warning: ${error.message}`) + } else { + console.error( + `[read_file] Unhandled error: ${error instanceof Error ? error.message : String(error)}`, + ) + } + } + continue + } + + const modelInfo = task.api.getModel().info + const { contextTokens } = task.getTokenUsage() + const contextWindow = modelInfo.contextWindow + + const budgetResult = await validateFileTokenBudget(fullPath, contextWindow, contextTokens || 0) + + let content = await extractTextFromFile(fullPath) + let xmlInfo = "" + + if (budgetResult.shouldTruncate && budgetResult.maxChars !== undefined) { + const truncateResult = truncateFileContent( + content, + budgetResult.maxChars, + content.length, + budgetResult.isPreview, + ) + content = truncateResult.content + + let displayedLines = content.length === 0 ? 0 : content.split(/\r?\n/).length + if (displayedLines > 0 && content.endsWith("\n")) { + displayedLines-- + } + const lineRangeAttr = displayedLines > 0 ? ` lines="1-${displayedLines}"` : "" + xmlInfo = + content.length > 0 ? `\n${content}\n` : `` + xmlInfo += `${truncateResult.notice}\n` + } else { + const lineRangeAttr = ` lines="1-${totalLines}"` + xmlInfo = totalLines > 0 ? `\n${content}\n` : `` + + if (totalLines === 0) { + xmlInfo += `File is empty\n` + } + } + + await task.fileContextTracker.trackFileContext(relPath, "read_tool" as RecordSource) + + updateFileResult(relPath, { xmlContent: `${relPath}\n${xmlInfo}` }) + } catch (error) { + const errorMsg = error instanceof Error ? error.message : String(error) + updateFileResult(relPath, { + status: "error", + error: `Error reading file: ${errorMsg}`, + xmlContent: `${relPath}Error reading file: ${errorMsg}`, + }) + await handleError(`reading file ${relPath}`, error instanceof Error ? error : new Error(errorMsg)) + } + } + + const xmlResults = fileResults.filter((result) => result.xmlContent).map((result) => result.xmlContent) + const filesXml = `\n${xmlResults.join("\n")}\n` + + const fileImageUrls = fileResults + .filter((result) => result.imageDataUrl) + .map((result) => result.imageDataUrl as string) + + let statusMessage = "" + let feedbackImages: any[] = [] + + const deniedWithFeedback = fileResults.find((result) => result.status === "denied" && result.feedbackText) + + if (deniedWithFeedback && deniedWithFeedback.feedbackText) { + statusMessage = formatResponse.toolDeniedWithFeedback(deniedWithFeedback.feedbackText) + feedbackImages = deniedWithFeedback.feedbackImages || [] + } else if (task.didRejectTool) { + statusMessage = formatResponse.toolDenied() + } else { + const approvedWithFeedback = fileResults.find( + (result) => result.status === "approved" && result.feedbackText, + ) + + if (approvedWithFeedback && approvedWithFeedback.feedbackText) { + statusMessage = formatResponse.toolApprovedWithFeedback(approvedWithFeedback.feedbackText) + feedbackImages = approvedWithFeedback.feedbackImages || [] + } + } + + const allImages = [...feedbackImages, ...fileImageUrls] + + const finalModelSupportsImages = task.api.getModel().info.supportsImages ?? false + const imagesToInclude = finalModelSupportsImages ? allImages : [] + + if (statusMessage || imagesToInclude.length > 0) { + const result = formatResponse.toolResult( + statusMessage || filesXml, + imagesToInclude.length > 0 ? imagesToInclude : undefined, + ) + + if (typeof result === "string") { + if (statusMessage) { + pushToolResult(`${result}\n${filesXml}`) + } else { + pushToolResult(result) + } + } else { + if (statusMessage) { + const textBlock = { type: "text" as const, text: filesXml } + pushToolResult([...result, textBlock]) + } else { + pushToolResult(result) + } + } + } else { + pushToolResult(filesXml) + } + } catch (error) { + const relPath = fileEntries[0]?.path || "unknown" + const errorMsg = error instanceof Error ? error.message : String(error) + + if (fileResults.length > 0) { + updateFileResult(relPath, { + status: "error", + error: `Error reading file: ${errorMsg}`, + xmlContent: `${relPath}Error reading file: ${errorMsg}`, + }) + } + + await handleError(`reading file ${relPath}`, error instanceof Error ? error : new Error(errorMsg)) + + const xmlResults = fileResults.filter((result) => result.xmlContent).map((result) => result.xmlContent) + + pushToolResult(`\n${xmlResults.join("\n")}\n`) + } + } + + getReadFileToolDescription(blockName: string, blockParams: any): string + getReadFileToolDescription(blockName: string, nativeArgs: FileEntry[]): string + getReadFileToolDescription(blockName: string, second: any): string { + // If native typed args (FileEntry[]) were provided + if (Array.isArray(second)) { + const paths = (second as FileEntry[]).map((f) => f?.path).filter(Boolean) as string[] + if (paths.length === 0) { + return `[${blockName} with no valid paths]` + } else if (paths.length === 1) { + return `[${blockName} for '${paths[0]}'. Reading multiple files at once is more efficient for the LLM. If other files are relevant to your current task, please read them simultaneously.]` + } else if (paths.length <= 3) { + const pathList = paths.map((p) => `'${p}'`).join(", ") + return `[${blockName} for ${pathList}]` + } else { + return `[${blockName} for ${paths.length} files]` + } + } + + // Fallback to legacy/XML or synthesized params + const blockParams = second as any + + if (blockParams?.args) { + try { + const parsed = parseXml(blockParams.args) as any + const files = Array.isArray(parsed.file) ? parsed.file : [parsed.file].filter(Boolean) + const paths = files.map((f: any) => f?.path).filter(Boolean) as string[] + + if (paths.length === 0) { + return `[${blockName} with no valid paths]` + } else if (paths.length === 1) { + return `[${blockName} for '${paths[0]}'. Reading multiple files at once is more efficient for the LLM. If other files are relevant to your current task, please read them simultaneously.]` + } else if (paths.length <= 3) { + const pathList = paths.map((p) => `'${p}'`).join(", ") + return `[${blockName} for ${pathList}]` + } else { + return `[${blockName} for ${paths.length} files]` + } + } catch (error) { + console.error("Failed to parse read_file args XML for description:", error) + return `[${blockName} with unparsable args]` + } + } else if (blockParams?.path) { + return `[${blockName} for '${blockParams.path}'. Reading multiple files at once is more efficient for the LLM. If other files are relevant to your current task, please read them simultaneously.]` + } else if (blockParams?.files) { + // Back-compat: some paths may still synthesize params.files; try to parse if present + try { + const files = JSON.parse(blockParams.files) + if (Array.isArray(files) && files.length > 0) { + const paths = files.map((f: any) => f?.path).filter(Boolean) as string[] + if (paths.length === 1) { + return `[${blockName} for '${paths[0]}'. Reading multiple files at once is more efficient for the LLM. If other files are relevant to your current task, please read them simultaneously.]` + } else if (paths.length <= 3) { + const pathList = paths.map((p) => `'${p}'`).join(", ") + return `[${blockName} for ${pathList}]` + } else { + return `[${blockName} for ${paths.length} files]` + } + } + } catch (error) { + console.error("Failed to parse native files JSON for description:", error) + return `[${blockName} with unparsable files]` + } + } + + return `[${blockName} with missing path/args/files]` + } + + override async handlePartial(task: Task, block: ToolUse<"read_file">): Promise { + const argsXmlTag = block.params.args + const legacyPath = block.params.path + + let filePath = "" + if (argsXmlTag) { + const match = argsXmlTag.match(/.*?([^<]+)<\/path>/s) + if (match) filePath = match[1] + } + if (!filePath && legacyPath) { + filePath = legacyPath + } + + const fullPath = filePath ? path.resolve(task.cwd, filePath) : "" + const sharedMessageProps: ClineSayTool = { + tool: "readFile", + path: getReadablePath(task.cwd, filePath), + isOutsideWorkspace: filePath ? isPathOutsideWorkspace(fullPath) : false, + } + const partialMessage = JSON.stringify({ + ...sharedMessageProps, + content: undefined, + } satisfies ClineSayTool) + await task.ask("tool", partialMessage, block.partial).catch(() => {}) + } +} + +export const readFileTool = new ReadFileTool() diff --git a/src/core/tools/RunSlashCommandTool.ts b/src/core/tools/RunSlashCommandTool.ts new file mode 100644 index 00000000000..2196e257252 --- /dev/null +++ b/src/core/tools/RunSlashCommandTool.ts @@ -0,0 +1,122 @@ +import { Task } from "../task/Task" +import { formatResponse } from "../prompts/responses" +import { getCommand, getCommandNames } from "../../services/command/commands" +import { EXPERIMENT_IDS, experiments } from "../../shared/experiments" +import { BaseTool, ToolCallbacks } from "./BaseTool" +import type { ToolUse } from "../../shared/tools" + +interface RunSlashCommandParams { + command: string + args?: string +} + +export class RunSlashCommandTool extends BaseTool<"run_slash_command"> { + readonly name = "run_slash_command" as const + + parseLegacy(params: Partial>): RunSlashCommandParams { + return { + command: params.command || "", + args: params.args, + } + } + + async execute(params: RunSlashCommandParams, task: Task, callbacks: ToolCallbacks): Promise { + const { command: commandName, args } = params + const { askApproval, handleError, pushToolResult } = callbacks + + // Check if run slash command experiment is enabled + const provider = task.providerRef.deref() + const state = await provider?.getState() + const isRunSlashCommandEnabled = experiments.isEnabled( + state?.experiments ?? {}, + EXPERIMENT_IDS.RUN_SLASH_COMMAND, + ) + + if (!isRunSlashCommandEnabled) { + pushToolResult( + formatResponse.toolError( + "Run slash command is an experimental feature that must be enabled in settings. Please enable 'Run Slash Command' in the Experimental Settings section.", + ), + ) + return + } + + try { + if (!commandName) { + task.consecutiveMistakeCount++ + task.recordToolError("run_slash_command") + pushToolResult(await task.sayAndCreateMissingParamError("run_slash_command", "command")) + return + } + + task.consecutiveMistakeCount = 0 + + // Get the command from the commands service + const command = await getCommand(task.cwd, commandName) + + if (!command) { + // Get available commands for error message + const availableCommands = await getCommandNames(task.cwd) + task.recordToolError("run_slash_command") + pushToolResult( + formatResponse.toolError( + `Command '${commandName}' not found. Available commands: ${availableCommands.join(", ") || "(none)"}`, + ), + ) + return + } + + const toolMessage = JSON.stringify({ + tool: "runSlashCommand", + command: commandName, + args: args, + source: command.source, + description: command.description, + }) + + const didApprove = await askApproval("tool", toolMessage) + + if (!didApprove) { + return + } + + // Build the result message + let result = `Command: /${commandName}` + + if (command.description) { + result += `\nDescription: ${command.description}` + } + + if (command.argumentHint) { + result += `\nArgument hint: ${command.argumentHint}` + } + + if (args) { + result += `\nProvided arguments: ${args}` + } + + result += `\nSource: ${command.source}` + result += `\n\n--- Command Content ---\n\n${command.content}` + + // Return the command content as the tool result + pushToolResult(result) + } catch (error) { + await handleError("running slash command", error as Error) + } + } + + override async handlePartial(task: Task, block: ToolUse<"run_slash_command">): Promise { + const commandName: string | undefined = block.params.command + const args: string | undefined = block.params.args + + const partialMessage = JSON.stringify({ + tool: "runSlashCommand", + command: this.removeClosingTag("command", commandName, block.partial), + args: this.removeClosingTag("args", args, block.partial), + }) + + await task.ask("tool", partialMessage, block.partial).catch(() => {}) + } +} + +export const runSlashCommandTool = new RunSlashCommandTool() diff --git a/src/core/tools/SearchFilesTool.ts b/src/core/tools/SearchFilesTool.ts new file mode 100644 index 00000000000..f22462c22e0 --- /dev/null +++ b/src/core/tools/SearchFilesTool.ts @@ -0,0 +1,99 @@ +import path from "path" + +import { Task } from "../task/Task" +import { ClineSayTool } from "../../shared/ExtensionMessage" +import { getReadablePath } from "../../utils/path" +import { isPathOutsideWorkspace } from "../../utils/pathUtils" +import { regexSearchFiles } from "../../services/ripgrep" +import { BaseTool, ToolCallbacks } from "./BaseTool" +import type { ToolUse } from "../../shared/tools" + +interface SearchFilesParams { + path: string + regex: string + file_pattern?: string | null +} + +export class SearchFilesTool extends BaseTool<"search_files"> { + readonly name = "search_files" as const + + parseLegacy(params: Partial>): SearchFilesParams { + return { + path: params.path || "", + regex: params.regex || "", + file_pattern: params.file_pattern || undefined, + } + } + + async execute(params: SearchFilesParams, task: Task, callbacks: ToolCallbacks): Promise { + const { askApproval, handleError, pushToolResult } = callbacks + + const relDirPath = params.path + const regex = params.regex + const filePattern = params.file_pattern || undefined + + if (!relDirPath) { + task.consecutiveMistakeCount++ + task.recordToolError("search_files") + pushToolResult(await task.sayAndCreateMissingParamError("search_files", "path")) + return + } + + if (!regex) { + task.consecutiveMistakeCount++ + task.recordToolError("search_files") + pushToolResult(await task.sayAndCreateMissingParamError("search_files", "regex")) + return + } + + task.consecutiveMistakeCount = 0 + + const absolutePath = path.resolve(task.cwd, relDirPath) + const isOutsideWorkspace = isPathOutsideWorkspace(absolutePath) + + const sharedMessageProps: ClineSayTool = { + tool: "searchFiles", + path: getReadablePath(task.cwd, relDirPath), + regex: regex, + filePattern: filePattern, + isOutsideWorkspace, + } + + try { + const results = await regexSearchFiles(task.cwd, absolutePath, regex, filePattern, task.rooIgnoreController) + + const completeMessage = JSON.stringify({ ...sharedMessageProps, content: results } satisfies ClineSayTool) + const didApprove = await askApproval("tool", completeMessage) + + if (!didApprove) { + return + } + + pushToolResult(results) + } catch (error) { + await handleError("searching files", error as Error) + } + } + + override async handlePartial(task: Task, block: ToolUse<"search_files">): Promise { + const relDirPath = block.params.path + const regex = block.params.regex + const filePattern = block.params.file_pattern + + const absolutePath = relDirPath ? path.resolve(task.cwd, relDirPath) : task.cwd + const isOutsideWorkspace = isPathOutsideWorkspace(absolutePath) + + const sharedMessageProps: ClineSayTool = { + tool: "searchFiles", + path: getReadablePath(task.cwd, this.removeClosingTag("path", relDirPath, block.partial)), + regex: this.removeClosingTag("regex", regex, block.partial), + filePattern: this.removeClosingTag("file_pattern", filePattern, block.partial), + isOutsideWorkspace, + } + + const partialMessage = JSON.stringify({ ...sharedMessageProps, content: "" } satisfies ClineSayTool) + await task.ask("tool", partialMessage, block.partial).catch(() => {}) + } +} + +export const searchFilesTool = new SearchFilesTool() diff --git a/src/core/tools/SwitchModeTool.ts b/src/core/tools/SwitchModeTool.ts new file mode 100644 index 00000000000..17ef11d9886 --- /dev/null +++ b/src/core/tools/SwitchModeTool.ts @@ -0,0 +1,92 @@ +import delay from "delay" + +import { Task } from "../task/Task" +import { formatResponse } from "../prompts/responses" +import { defaultModeSlug, getModeBySlug } from "../../shared/modes" +import { BaseTool, ToolCallbacks } from "./BaseTool" +import type { ToolUse } from "../../shared/tools" + +interface SwitchModeParams { + mode_slug: string + reason: string +} + +export class SwitchModeTool extends BaseTool<"switch_mode"> { + readonly name = "switch_mode" as const + + parseLegacy(params: Partial>): SwitchModeParams { + return { + mode_slug: params.mode_slug || "", + reason: params.reason || "", + } + } + + async execute(params: SwitchModeParams, task: Task, callbacks: ToolCallbacks): Promise { + const { mode_slug, reason } = params + const { askApproval, handleError, pushToolResult } = callbacks + + try { + if (!mode_slug) { + task.consecutiveMistakeCount++ + task.recordToolError("switch_mode") + pushToolResult(await task.sayAndCreateMissingParamError("switch_mode", "mode_slug")) + return + } + + task.consecutiveMistakeCount = 0 + + // Verify the mode exists + const targetMode = getModeBySlug(mode_slug, (await task.providerRef.deref()?.getState())?.customModes) + + if (!targetMode) { + task.recordToolError("switch_mode") + pushToolResult(formatResponse.toolError(`Invalid mode: ${mode_slug}`)) + return + } + + // Check if already in requested mode + const currentMode = (await task.providerRef.deref()?.getState())?.mode ?? defaultModeSlug + + if (currentMode === mode_slug) { + task.recordToolError("switch_mode") + pushToolResult(`Already in ${targetMode.name} mode.`) + return + } + + const completeMessage = JSON.stringify({ tool: "switchMode", mode: mode_slug, reason }) + const didApprove = await askApproval("tool", completeMessage) + + if (!didApprove) { + return + } + + // Switch the mode using shared handler + await task.providerRef.deref()?.handleModeSwitch(mode_slug) + + pushToolResult( + `Successfully switched from ${getModeBySlug(currentMode)?.name ?? currentMode} mode to ${ + targetMode.name + } mode${reason ? ` because: ${reason}` : ""}.`, + ) + + await delay(500) // Delay to allow mode change to take effect before next tool is executed + } catch (error) { + await handleError("switching mode", error as Error) + } + } + + override async handlePartial(task: Task, block: ToolUse<"switch_mode">): Promise { + const mode_slug: string | undefined = block.params.mode_slug + const reason: string | undefined = block.params.reason + + const partialMessage = JSON.stringify({ + tool: "switchMode", + mode: this.removeClosingTag("mode_slug", mode_slug, block.partial), + reason: this.removeClosingTag("reason", reason, block.partial), + }) + + await task.ask("tool", partialMessage, block.partial).catch(() => {}) + } +} + +export const switchModeTool = new SwitchModeTool() diff --git a/src/core/tools/updateTodoListTool.ts b/src/core/tools/UpdateTodoListTool.ts similarity index 57% rename from src/core/tools/updateTodoListTool.ts rename to src/core/tools/UpdateTodoListTool.ts index fcd41914a88..94d1b25e13a 100644 --- a/src/core/tools/updateTodoListTool.ts +++ b/src/core/tools/UpdateTodoListTool.ts @@ -1,17 +1,115 @@ import { Task } from "../task/Task" -import { ToolUse, AskApproval, HandleError, PushToolResult, RemoveClosingTag } from "../../shared/tools" import { formatResponse } from "../prompts/responses" - +import { BaseTool, ToolCallbacks } from "./BaseTool" +import type { ToolUse } from "../../shared/tools" import cloneDeep from "clone-deep" import crypto from "crypto" import { TodoItem, TodoStatus, todoStatusSchema } from "@roo-code/types" import { getLatestTodo } from "../../shared/todo" +interface UpdateTodoListParams { + todos: string +} + let approvedTodoList: TodoItem[] | undefined = undefined -/** - * Add a todo item to the task's todoList. - */ +export class UpdateTodoListTool extends BaseTool<"update_todo_list"> { + readonly name = "update_todo_list" as const + + parseLegacy(params: Partial>): UpdateTodoListParams { + return { + todos: params.todos || "", + } + } + + async execute(params: UpdateTodoListParams, task: Task, callbacks: ToolCallbacks): Promise { + const { pushToolResult, handleError, askApproval } = callbacks + + try { + const todosRaw = params.todos + + let todos: TodoItem[] + try { + todos = parseMarkdownChecklist(todosRaw || "") + } catch { + task.consecutiveMistakeCount++ + task.recordToolError("update_todo_list") + pushToolResult(formatResponse.toolError("The todos parameter is not valid markdown checklist or JSON")) + return + } + + const { valid, error } = validateTodos(todos) + if (!valid) { + task.consecutiveMistakeCount++ + task.recordToolError("update_todo_list") + pushToolResult(formatResponse.toolError(error || "todos parameter validation failed")) + return + } + + let normalizedTodos: TodoItem[] = todos.map((t) => ({ + id: t.id, + content: t.content, + status: normalizeStatus(t.status), + })) + + const approvalMsg = JSON.stringify({ + tool: "updateTodoList", + todos: normalizedTodos, + }) + + approvedTodoList = cloneDeep(normalizedTodos) + const didApprove = await askApproval("tool", approvalMsg) + if (!didApprove) { + pushToolResult("User declined to update the todoList.") + return + } + + const isTodoListChanged = + approvedTodoList !== undefined && JSON.stringify(normalizedTodos) !== JSON.stringify(approvedTodoList) + if (isTodoListChanged) { + normalizedTodos = approvedTodoList ?? [] + task.say( + "user_edit_todos", + JSON.stringify({ + tool: "updateTodoList", + todos: normalizedTodos, + }), + ) + } + + await setTodoListForTask(task, normalizedTodos) + + if (isTodoListChanged) { + const md = todoListToMarkdown(normalizedTodos) + pushToolResult(formatResponse.toolResult("User edits todo:\n\n" + md)) + } else { + pushToolResult(formatResponse.toolResult("Todo list updated successfully.")) + } + } catch (error) { + await handleError("update todo list", error as Error) + } + } + + override async handlePartial(task: Task, block: ToolUse<"update_todo_list">): Promise { + const todosRaw = block.params.todos + + // Parse the markdown checklist to maintain consistent format with execute() + let todos: TodoItem[] + try { + todos = parseMarkdownChecklist(todosRaw || "") + } catch { + // If parsing fails during partial, send empty array + todos = [] + } + + const approvalMsg = JSON.stringify({ + tool: "updateTodoList", + todos: todos, + }) + await task.ask("tool", approvalMsg, block.partial).catch(() => {}) + } +} + export function addTodoToTask(cline: Task, content: string, status: TodoStatus = "pending", id?: string): TodoItem { const todo: TodoItem = { id: id ?? crypto.randomUUID(), @@ -23,9 +121,6 @@ export function addTodoToTask(cline: Task, content: string, status: TodoStatus = return todo } -/** - * Update the status of a todo item by id. - */ export function updateTodoStatusForTask(cline: Task, id: string, nextStatus: TodoStatus): boolean { if (!cline.todoList) return false const idx = cline.todoList.findIndex((t) => t.id === id) @@ -42,9 +137,6 @@ export function updateTodoStatusForTask(cline: Task, id: string, nextStatus: Tod return false } -/** - * Remove a todo item by id. - */ export function removeTodoFromTask(cline: Task, id: string): boolean { if (!cline.todoList) return false const idx = cline.todoList.findIndex((t) => t.id === id) @@ -53,24 +145,15 @@ export function removeTodoFromTask(cline: Task, id: string): boolean { return true } -/** - * Get a copy of the todoList. - */ export function getTodoListForTask(cline: Task): TodoItem[] | undefined { return cline.todoList?.slice() } -/** - * Set the todoList for the task. - */ export async function setTodoListForTask(cline?: Task, todos?: TodoItem[]) { if (cline === undefined) return cline.todoList = Array.isArray(todos) ? todos : [] } -/** - * Restore the todoList from argument or from clineMessages. - */ export function restoreTodoListForTask(cline: Task, todoList?: TodoItem[]) { if (todoList) { cline.todoList = Array.isArray(todoList) ? todoList : [] @@ -78,11 +161,7 @@ export function restoreTodoListForTask(cline: Task, todoList?: TodoItem[]) { } cline.todoList = getLatestTodo(cline.clineMessages) } -/** - * Convert TodoItem[] to markdown checklist string. - * @param todos TodoItem array - * @returns markdown checklist string - */ + function todoListToMarkdown(todos: TodoItem[]): string { return todos .map((t) => { @@ -108,7 +187,6 @@ export function parseMarkdownChecklist(md: string): TodoItem[] { .filter(Boolean) const todos: TodoItem[] = [] for (const line of lines) { - // Support both "[ ] Task" and "- [ ] Task" formats const match = line.match(/^(?:-\s*)?\[\s*([ xX\-~])\s*\]\s+(.+)$/) if (!match) continue let status: TodoStatus = "pending" @@ -144,94 +222,4 @@ function validateTodos(todos: any[]): { valid: boolean; error?: string } { return { valid: true } } -/** - * Update the todo list for a task. - * @param cline Task instance - * @param block ToolUse block - * @param askApproval AskApproval function - * @param handleError HandleError function - * @param pushToolResult PushToolResult function - * @param removeClosingTag RemoveClosingTag function - * @param userEdited If true, only show "User Edit Succeeded" and do nothing else - */ -export async function updateTodoListTool( - cline: Task, - block: ToolUse, - askApproval: AskApproval, - handleError: HandleError, - pushToolResult: PushToolResult, - removeClosingTag: RemoveClosingTag, - userEdited?: boolean, -) { - // If userEdited is true, only show "User Edit Succeeded" and do nothing else - if (userEdited === true) { - pushToolResult("User Edit Succeeded") - return - } - try { - const todosRaw = block.params.todos - - let todos: TodoItem[] - try { - todos = parseMarkdownChecklist(todosRaw || "") - } catch { - cline.consecutiveMistakeCount++ - cline.recordToolError("update_todo_list") - pushToolResult(formatResponse.toolError("The todos parameter is not valid markdown checklist or JSON")) - return - } - - const { valid, error } = validateTodos(todos) - if (!valid && !block.partial) { - cline.consecutiveMistakeCount++ - cline.recordToolError("update_todo_list") - pushToolResult(formatResponse.toolError(error || "todos parameter validation failed")) - return - } - - let normalizedTodos: TodoItem[] = todos.map((t) => ({ - id: t.id, - content: t.content, - status: normalizeStatus(t.status), - })) - - const approvalMsg = JSON.stringify({ - tool: "updateTodoList", - todos: normalizedTodos, - }) - if (block.partial) { - await cline.ask("tool", approvalMsg, block.partial).catch(() => {}) - return - } - approvedTodoList = cloneDeep(normalizedTodos) - const didApprove = await askApproval("tool", approvalMsg) - if (!didApprove) { - pushToolResult("User declined to update the todoList.") - return - } - const isTodoListChanged = - approvedTodoList !== undefined && JSON.stringify(normalizedTodos) !== JSON.stringify(approvedTodoList) - if (isTodoListChanged) { - normalizedTodos = approvedTodoList ?? [] - cline.say( - "user_edit_todos", - JSON.stringify({ - tool: "updateTodoList", - todos: normalizedTodos, - }), - ) - } - - await setTodoListForTask(cline, normalizedTodos) - - // If todo list changed, output new todo list in markdown format - if (isTodoListChanged) { - const md = todoListToMarkdown(normalizedTodos) - pushToolResult(formatResponse.toolResult("User edits todo:\n\n" + md)) - } else { - pushToolResult(formatResponse.toolResult("Todo list updated successfully.")) - } - } catch (error) { - await handleError("update todo list", error) - } -} +export const updateTodoListTool = new UpdateTodoListTool() diff --git a/src/core/tools/UseMcpToolTool.ts b/src/core/tools/UseMcpToolTool.ts new file mode 100644 index 00000000000..f24c3b9c028 --- /dev/null +++ b/src/core/tools/UseMcpToolTool.ts @@ -0,0 +1,342 @@ +import { Task } from "../task/Task" +import { formatResponse } from "../prompts/responses" +import { ClineAskUseMcpServer } from "../../shared/ExtensionMessage" +import { McpExecutionStatus } from "@roo-code/types" +import { t } from "../../i18n" +import { BaseTool, ToolCallbacks } from "./BaseTool" +import type { ToolUse } from "../../shared/tools" + +interface UseMcpToolParams { + server_name: string + tool_name: string + arguments?: Record +} + +type ValidationResult = + | { isValid: false } + | { + isValid: true + serverName: string + toolName: string + parsedArguments?: Record + } + +export class UseMcpToolTool extends BaseTool<"use_mcp_tool"> { + readonly name = "use_mcp_tool" as const + + parseLegacy(params: Partial>): UseMcpToolParams { + // For legacy params, arguments come as a JSON string that needs parsing + // We don't parse here - let validateParams handle parsing and errors + return { + server_name: params.server_name || "", + tool_name: params.tool_name || "", + arguments: params.arguments as any, // Keep as string for validation to handle + } + } + + async execute(params: UseMcpToolParams, task: Task, callbacks: ToolCallbacks): Promise { + const { askApproval, handleError, pushToolResult } = callbacks + + try { + // Validate parameters + const validation = await this.validateParams(task, params, pushToolResult) + if (!validation.isValid) { + return + } + + const { serverName, toolName, parsedArguments } = validation + + // Validate that the tool exists on the server + const toolValidation = await this.validateToolExists(task, serverName, toolName, pushToolResult) + if (!toolValidation.isValid) { + return + } + + // Reset mistake count on successful validation + task.consecutiveMistakeCount = 0 + + // Get user approval + const completeMessage = JSON.stringify({ + type: "use_mcp_tool", + serverName, + toolName, + arguments: params.arguments ? JSON.stringify(params.arguments) : undefined, + } satisfies ClineAskUseMcpServer) + + const executionId = task.lastMessageTs?.toString() ?? Date.now().toString() + const didApprove = await askApproval("use_mcp_server", completeMessage) + + if (!didApprove) { + return + } + + // Execute the tool and process results + await this.executeToolAndProcessResult( + task, + serverName, + toolName, + parsedArguments, + executionId, + pushToolResult, + ) + } catch (error) { + await handleError("executing MCP tool", error as Error) + } + } + + override async handlePartial(task: Task, block: ToolUse<"use_mcp_tool">): Promise { + const params = block.params + const partialMessage = JSON.stringify({ + type: "use_mcp_tool", + serverName: this.removeClosingTag("server_name", params.server_name, block.partial), + toolName: this.removeClosingTag("tool_name", params.tool_name, block.partial), + arguments: this.removeClosingTag("arguments", params.arguments, block.partial), + } satisfies ClineAskUseMcpServer) + + await task.ask("use_mcp_server", partialMessage, true).catch(() => {}) + } + + private async validateParams( + task: Task, + params: UseMcpToolParams, + pushToolResult: (content: string) => void, + ): Promise { + if (!params.server_name) { + task.consecutiveMistakeCount++ + task.recordToolError("use_mcp_tool") + pushToolResult(await task.sayAndCreateMissingParamError("use_mcp_tool", "server_name")) + return { isValid: false } + } + + if (!params.tool_name) { + task.consecutiveMistakeCount++ + task.recordToolError("use_mcp_tool") + pushToolResult(await task.sayAndCreateMissingParamError("use_mcp_tool", "tool_name")) + return { isValid: false } + } + + // Parse arguments if provided + let parsedArguments: Record | undefined + + if (params.arguments) { + // If arguments is already an object (from native protocol), use it + if (typeof params.arguments === "object") { + parsedArguments = params.arguments + } else if (typeof params.arguments === "string") { + // If arguments is a string (from legacy/XML protocol), parse it + try { + parsedArguments = JSON.parse(params.arguments) + } catch (error) { + task.consecutiveMistakeCount++ + task.recordToolError("use_mcp_tool") + await task.say("error", t("mcp:errors.invalidJsonArgument", { toolName: params.tool_name })) + + pushToolResult( + formatResponse.toolError( + formatResponse.invalidMcpToolArgumentError(params.server_name, params.tool_name), + ), + ) + return { isValid: false } + } + } + } + + return { + isValid: true, + serverName: params.server_name, + toolName: params.tool_name, + parsedArguments, + } + } + + private async validateToolExists( + task: Task, + serverName: string, + toolName: string, + pushToolResult: (content: string) => void, + ): Promise<{ isValid: boolean; availableTools?: string[] }> { + try { + // Get the MCP hub to access server information + const provider = task.providerRef.deref() + const mcpHub = provider?.getMcpHub() + + if (!mcpHub) { + // If we can't get the MCP hub, we can't validate, so proceed with caution + return { isValid: true } + } + + // Get all servers to find the specific one + const servers = mcpHub.getAllServers() + const server = servers.find((s) => s.name === serverName) + + if (!server) { + // Fail fast when server is unknown + const availableServersArray = servers.map((s) => s.name) + const availableServers = + availableServersArray.length > 0 ? availableServersArray.join(", ") : "No servers available" + + task.consecutiveMistakeCount++ + task.recordToolError("use_mcp_tool") + await task.say("error", t("mcp:errors.serverNotFound", { serverName, availableServers })) + + pushToolResult(formatResponse.unknownMcpServerError(serverName, availableServersArray)) + return { isValid: false, availableTools: [] } + } + + // Check if the server has tools defined + if (!server.tools || server.tools.length === 0) { + // No tools available on this server + task.consecutiveMistakeCount++ + task.recordToolError("use_mcp_tool") + await task.say( + "error", + t("mcp:errors.toolNotFound", { + toolName, + serverName, + availableTools: "No tools available", + }), + ) + + pushToolResult(formatResponse.unknownMcpToolError(serverName, toolName, [])) + return { isValid: false, availableTools: [] } + } + + // Check if the requested tool exists + const tool = server.tools.find((tool) => tool.name === toolName) + + if (!tool) { + // Tool not found - provide list of available tools + const availableToolNames = server.tools.map((tool) => tool.name) + + task.consecutiveMistakeCount++ + task.recordToolError("use_mcp_tool") + await task.say( + "error", + t("mcp:errors.toolNotFound", { + toolName, + serverName, + availableTools: availableToolNames.join(", "), + }), + ) + + pushToolResult(formatResponse.unknownMcpToolError(serverName, toolName, availableToolNames)) + return { isValid: false, availableTools: availableToolNames } + } + + // Check if the tool is disabled (enabledForPrompt is false) + if (tool.enabledForPrompt === false) { + // Tool is disabled - only show enabled tools + const enabledTools = server.tools.filter((t) => t.enabledForPrompt !== false) + const enabledToolNames = enabledTools.map((t) => t.name) + + task.consecutiveMistakeCount++ + task.recordToolError("use_mcp_tool") + await task.say( + "error", + t("mcp:errors.toolDisabled", { + toolName, + serverName, + availableTools: + enabledToolNames.length > 0 ? enabledToolNames.join(", ") : "No enabled tools available", + }), + ) + + pushToolResult(formatResponse.unknownMcpToolError(serverName, toolName, enabledToolNames)) + return { isValid: false, availableTools: enabledToolNames } + } + + // Tool exists and is enabled + return { isValid: true, availableTools: server.tools.map((tool) => tool.name) } + } catch (error) { + // If there's an error during validation, log it but don't block the tool execution + // The actual tool call might still fail with a proper error + console.error("Error validating MCP tool existence:", error) + return { isValid: true } + } + } + + private async sendExecutionStatus(task: Task, status: McpExecutionStatus): Promise { + const clineProvider = await task.providerRef.deref() + clineProvider?.postMessageToWebview({ + type: "mcpExecutionStatus", + text: JSON.stringify(status), + }) + } + + private processToolContent(toolResult: any): string { + if (!toolResult?.content || toolResult.content.length === 0) { + return "" + } + + return toolResult.content + .map((item: any) => { + if (item.type === "text") { + return item.text + } + if (item.type === "resource") { + const { blob: _, ...rest } = item.resource + return JSON.stringify(rest, null, 2) + } + return "" + }) + .filter(Boolean) + .join("\n\n") + } + + private async executeToolAndProcessResult( + task: Task, + serverName: string, + toolName: string, + parsedArguments: Record | undefined, + executionId: string, + pushToolResult: (content: string | Array) => void, + ): Promise { + await task.say("mcp_server_request_started") + + // Send started status + await this.sendExecutionStatus(task, { + executionId, + status: "started", + serverName, + toolName, + }) + + const toolResult = await task.providerRef.deref()?.getMcpHub()?.callTool(serverName, toolName, parsedArguments) + + let toolResultPretty = "(No response)" + + if (toolResult) { + const outputText = this.processToolContent(toolResult) + + if (outputText) { + await this.sendExecutionStatus(task, { + executionId, + status: "output", + response: outputText, + }) + + toolResultPretty = (toolResult.isError ? "Error:\n" : "") + outputText + } + + // Send completion status + await this.sendExecutionStatus(task, { + executionId, + status: toolResult.isError ? "error" : "completed", + response: toolResultPretty, + error: toolResult.isError ? "Error executing MCP tool" : undefined, + }) + } else { + // Send error status if no result + await this.sendExecutionStatus(task, { + executionId, + status: "error", + error: "No response from MCP server", + }) + } + + await task.say("mcp_server_response", toolResultPretty) + pushToolResult(formatResponse.toolResult(toolResultPretty)) + } +} + +export const useMcpToolTool = new UseMcpToolTool() diff --git a/src/core/tools/WriteToFileTool.ts b/src/core/tools/WriteToFileTool.ts new file mode 100644 index 00000000000..bb987222f83 --- /dev/null +++ b/src/core/tools/WriteToFileTool.ts @@ -0,0 +1,335 @@ +import path from "path" +import delay from "delay" +import * as vscode from "vscode" +import fs from "fs/promises" + +import { Task } from "../task/Task" +import { ClineSayTool } from "../../shared/ExtensionMessage" +import { formatResponse } from "../prompts/responses" +import { RecordSource } from "../context-tracking/FileContextTrackerTypes" +import { fileExistsAtPath } from "../../utils/fs" +import { stripLineNumbers, everyLineHasLineNumbers } from "../../integrations/misc/extract-text" +import { getReadablePath } from "../../utils/path" +import { isPathOutsideWorkspace } from "../../utils/pathUtils" +import { detectCodeOmission } from "../../integrations/editor/detect-omission" +import { unescapeHtmlEntities } from "../../utils/text-normalization" +import { DEFAULT_WRITE_DELAY_MS } from "@roo-code/types" +import { EXPERIMENT_IDS, experiments } from "../../shared/experiments" +import { convertNewFileToUnifiedDiff, computeDiffStats, sanitizeUnifiedDiff } from "../diff/stats" +import { BaseTool, ToolCallbacks } from "./BaseTool" +import type { ToolUse } from "../../shared/tools" + +interface WriteToFileParams { + path: string + content: string + line_count: number +} + +export class WriteToFileTool extends BaseTool<"write_to_file"> { + readonly name = "write_to_file" as const + + parseLegacy(params: Partial>): WriteToFileParams { + return { + path: params.path || "", + content: params.content || "", + line_count: parseInt(params.line_count ?? "0", 10), + } + } + + async execute(params: WriteToFileParams, task: Task, callbacks: ToolCallbacks): Promise { + const { pushToolResult, handleError, askApproval, removeClosingTag } = callbacks + const relPath = params.path + let newContent = params.content + const predictedLineCount = params.line_count + + if (!relPath) { + task.consecutiveMistakeCount++ + task.recordToolError("write_to_file") + pushToolResult(await task.sayAndCreateMissingParamError("write_to_file", "path")) + await task.diffViewProvider.reset() + return + } + + if (newContent === undefined) { + task.consecutiveMistakeCount++ + task.recordToolError("write_to_file") + pushToolResult(await task.sayAndCreateMissingParamError("write_to_file", "content")) + await task.diffViewProvider.reset() + return + } + + const accessAllowed = task.rooIgnoreController?.validateAccess(relPath) + + if (!accessAllowed) { + await task.say("rooignore_error", relPath) + pushToolResult(formatResponse.toolError(formatResponse.rooIgnoreError(relPath))) + return + } + + const isWriteProtected = task.rooProtectedController?.isWriteProtected(relPath) || false + + let fileExists: boolean + + if (task.diffViewProvider.editType !== undefined) { + fileExists = task.diffViewProvider.editType === "modify" + } else { + const absolutePath = path.resolve(task.cwd, relPath) + fileExists = await fileExistsAtPath(absolutePath) + task.diffViewProvider.editType = fileExists ? "modify" : "create" + } + + if (newContent.startsWith("```")) { + newContent = newContent.split("\n").slice(1).join("\n") + } + + if (newContent.endsWith("```")) { + newContent = newContent.split("\n").slice(0, -1).join("\n") + } + + if (!task.api.getModel().id.includes("claude")) { + newContent = unescapeHtmlEntities(newContent) + } + + const fullPath = relPath ? path.resolve(task.cwd, removeClosingTag("path", relPath)) : "" + const isOutsideWorkspace = isPathOutsideWorkspace(fullPath) + + const sharedMessageProps: ClineSayTool = { + tool: fileExists ? "editedExistingFile" : "newFileCreated", + path: getReadablePath(task.cwd, removeClosingTag("path", relPath)), + content: newContent, + isOutsideWorkspace, + isProtected: isWriteProtected, + } + + try { + if (predictedLineCount === undefined || predictedLineCount === 0) { + task.consecutiveMistakeCount++ + task.recordToolError("write_to_file") + + const actualLineCount = newContent.split("\n").length + const isNewFile = !fileExists + const diffStrategyEnabled = !!task.diffStrategy + + await task.say( + "error", + `Roo tried to use write_to_file${ + relPath ? ` for '${relPath.toPosix()}'` : "" + } but the required parameter 'line_count' was missing or truncated after ${actualLineCount} lines of content were written. Retrying...`, + ) + + pushToolResult( + formatResponse.toolError( + formatResponse.lineCountTruncationError(actualLineCount, isNewFile, diffStrategyEnabled), + ), + ) + await task.diffViewProvider.revertChanges() + return + } + + task.consecutiveMistakeCount = 0 + + const provider = task.providerRef.deref() + const state = await provider?.getState() + const diagnosticsEnabled = state?.diagnosticsEnabled ?? true + const writeDelayMs = state?.writeDelayMs ?? DEFAULT_WRITE_DELAY_MS + const isPreventFocusDisruptionEnabled = experiments.isEnabled( + state?.experiments ?? {}, + EXPERIMENT_IDS.PREVENT_FOCUS_DISRUPTION, + ) + + if (isPreventFocusDisruptionEnabled) { + task.diffViewProvider.editType = fileExists ? "modify" : "create" + if (fileExists) { + const absolutePath = path.resolve(task.cwd, relPath) + task.diffViewProvider.originalContent = await fs.readFile(absolutePath, "utf-8") + } else { + task.diffViewProvider.originalContent = "" + } + + if (detectCodeOmission(task.diffViewProvider.originalContent || "", newContent, predictedLineCount)) { + if (task.diffStrategy) { + pushToolResult( + formatResponse.toolError( + `Content appears to be truncated (file has ${ + newContent.split("\n").length + } lines but was predicted to have ${predictedLineCount} lines), and found comments indicating omitted code (e.g., '// rest of code unchanged', '/* previous code */'). Please provide the complete file content without any omissions if possible, or otherwise use the 'apply_diff' tool to apply the diff to the original file.`, + ), + ) + return + } else { + vscode.window + .showWarningMessage( + "Potential code truncation detected. cline happens when the AI reaches its max output limit.", + "Follow cline guide to fix the issue", + ) + .then((selection) => { + if (selection === "Follow cline guide to fix the issue") { + vscode.env.openExternal( + vscode.Uri.parse( + "https://github.com/cline/cline/wiki/Troubleshooting-%E2%80%90-Cline-Deleting-Code-with-%22Rest-of-Code-Here%22-Comments", + ), + ) + } + }) + } + } + + let unified = fileExists + ? formatResponse.createPrettyPatch(relPath, task.diffViewProvider.originalContent, newContent) + : convertNewFileToUnifiedDiff(newContent, relPath) + unified = sanitizeUnifiedDiff(unified) + const completeMessage = JSON.stringify({ + ...sharedMessageProps, + content: unified, + diffStats: computeDiffStats(unified) || undefined, + } satisfies ClineSayTool) + + const didApprove = await askApproval("tool", completeMessage, undefined, isWriteProtected) + + if (!didApprove) { + return + } + + await task.diffViewProvider.saveDirectly(relPath, newContent, false, diagnosticsEnabled, writeDelayMs) + } else { + if (!task.diffViewProvider.isEditing) { + const partialMessage = JSON.stringify(sharedMessageProps) + await task.ask("tool", partialMessage, true).catch(() => {}) + await task.diffViewProvider.open(relPath) + } + + await task.diffViewProvider.update( + everyLineHasLineNumbers(newContent) ? stripLineNumbers(newContent) : newContent, + true, + ) + + await delay(300) + task.diffViewProvider.scrollToFirstDiff() + + if (detectCodeOmission(task.diffViewProvider.originalContent || "", newContent, predictedLineCount)) { + if (task.diffStrategy) { + await task.diffViewProvider.revertChanges() + + pushToolResult( + formatResponse.toolError( + `Content appears to be truncated (file has ${ + newContent.split("\n").length + } lines but was predicted to have ${predictedLineCount} lines), and found comments indicating omitted code (e.g., '// rest of code unchanged', '/* previous code */'). Please provide the complete file content without any omissions if possible, or otherwise use the 'apply_diff' tool to apply the diff to the original file.`, + ), + ) + return + } else { + vscode.window + .showWarningMessage( + "Potential code truncation detected. cline happens when the AI reaches its max output limit.", + "Follow cline guide to fix the issue", + ) + .then((selection) => { + if (selection === "Follow cline guide to fix the issue") { + vscode.env.openExternal( + vscode.Uri.parse( + "https://github.com/cline/cline/wiki/Troubleshooting-%E2%80%90-Cline-Deleting-Code-with-%22Rest-of-Code-Here%22-Comments", + ), + ) + } + }) + } + } + + let unified = fileExists + ? formatResponse.createPrettyPatch(relPath, task.diffViewProvider.originalContent, newContent) + : convertNewFileToUnifiedDiff(newContent, relPath) + unified = sanitizeUnifiedDiff(unified) + const completeMessage = JSON.stringify({ + ...sharedMessageProps, + content: unified, + diffStats: computeDiffStats(unified) || undefined, + } satisfies ClineSayTool) + + const didApprove = await askApproval("tool", completeMessage, undefined, isWriteProtected) + + if (!didApprove) { + await task.diffViewProvider.revertChanges() + return + } + + await task.diffViewProvider.saveChanges(diagnosticsEnabled, writeDelayMs) + } + + if (relPath) { + await task.fileContextTracker.trackFileContext(relPath, "roo_edited" as RecordSource) + } + + task.didEditFile = true + + const message = await task.diffViewProvider.pushToolWriteResult(task, task.cwd, !fileExists) + + pushToolResult(message) + + await task.diffViewProvider.reset() + + task.processQueuedMessages() + + return + } catch (error) { + await handleError("writing file", error as Error) + await task.diffViewProvider.reset() + return + } + } + + override async handlePartial(task: Task, block: ToolUse<"write_to_file">): Promise { + const relPath: string | undefined = block.params.path + let newContent: string | undefined = block.params.content + + if (!relPath || newContent === undefined) { + return + } + + const provider = task.providerRef.deref() + const state = await provider?.getState() + const isPreventFocusDisruptionEnabled = experiments.isEnabled( + state?.experiments ?? {}, + EXPERIMENT_IDS.PREVENT_FOCUS_DISRUPTION, + ) + + if (isPreventFocusDisruptionEnabled) { + return + } + + let fileExists: boolean + if (task.diffViewProvider.editType !== undefined) { + fileExists = task.diffViewProvider.editType === "modify" + } else { + const absolutePath = path.resolve(task.cwd, relPath) + fileExists = await fileExistsAtPath(absolutePath) + task.diffViewProvider.editType = fileExists ? "modify" : "create" + } + + const isWriteProtected = task.rooProtectedController?.isWriteProtected(relPath) || false + const fullPath = path.resolve(task.cwd, relPath) + const isOutsideWorkspace = isPathOutsideWorkspace(fullPath) + + const sharedMessageProps: ClineSayTool = { + tool: fileExists ? "editedExistingFile" : "newFileCreated", + path: getReadablePath(task.cwd, relPath), + content: newContent, + isOutsideWorkspace, + isProtected: isWriteProtected, + } + + const partialMessage = JSON.stringify(sharedMessageProps) + await task.ask("tool", partialMessage, block.partial).catch(() => {}) + + if (!task.diffViewProvider.isEditing) { + await task.diffViewProvider.open(relPath) + } + + await task.diffViewProvider.update( + everyLineHasLineNumbers(newContent) ? stripLineNumbers(newContent) : newContent, + false, + ) + } +} + +export const writeToFileTool = new WriteToFileTool() diff --git a/src/core/tools/__tests__/applyDiffTool.experiment.spec.ts b/src/core/tools/__tests__/applyDiffTool.experiment.spec.ts index f82d4b1820c..da45031ff85 100644 --- a/src/core/tools/__tests__/applyDiffTool.experiment.spec.ts +++ b/src/core/tools/__tests__/applyDiffTool.experiment.spec.ts @@ -1,13 +1,23 @@ -import { applyDiffTool } from "../multiApplyDiffTool" import { EXPERIMENT_IDS } from "../../../shared/experiments" +import { TOOL_PROTOCOL } from "@roo-code/types" -// Mock the applyDiffTool module -vi.mock("../applyDiffTool", () => ({ - applyDiffToolLegacy: vi.fn(), +// Mock vscode +vi.mock("vscode", () => ({ + workspace: { + getConfiguration: vi.fn(), + }, +})) + +// Mock the ApplyDiffTool module +vi.mock("../ApplyDiffTool", () => ({ + applyDiffTool: { + handle: vi.fn(), + }, })) // Import after mocking to get the mocked version -import { applyDiffToolLegacy } from "../applyDiffTool" +import { applyDiffTool as multiApplyDiffTool } from "../MultiApplyDiffTool" +import { applyDiffTool as applyDiffToolClass } from "../ApplyDiffTool" describe("applyDiffTool experiment routing", () => { let mockCline: any @@ -18,9 +28,15 @@ describe("applyDiffTool experiment routing", () => { let mockRemoveClosingTag: any let mockProvider: any - beforeEach(() => { + beforeEach(async () => { vi.clearAllMocks() + // Reset vscode mock to default behavior (XML protocol) + const vscode = await import("vscode") + vi.mocked(vscode.workspace.getConfiguration).mockReturnValue({ + get: vi.fn().mockReturnValue(TOOL_PROTOCOL.XML), + } as any) + mockProvider = { getState: vi.fn(), } @@ -64,10 +80,10 @@ describe("applyDiffTool experiment routing", () => { }, }) - // Mock the legacy tool to resolve successfully - ;(applyDiffToolLegacy as any).mockResolvedValue(undefined) + // Mock the class-based tool to resolve successfully + ;(applyDiffToolClass.handle as any).mockResolvedValue(undefined) - await applyDiffTool( + await multiApplyDiffTool( mockCline, mockBlock, mockAskApproval, @@ -76,23 +92,21 @@ describe("applyDiffTool experiment routing", () => { mockRemoveClosingTag, ) - expect(applyDiffToolLegacy).toHaveBeenCalledWith( - mockCline, - mockBlock, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + expect(applyDiffToolClass.handle).toHaveBeenCalledWith(mockCline, mockBlock, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) }) it("should use legacy tool when experiments are not defined", async () => { mockProvider.getState.mockResolvedValue({}) - // Mock the legacy tool to resolve successfully - ;(applyDiffToolLegacy as any).mockResolvedValue(undefined) + // Mock the class-based tool to resolve successfully + ;(applyDiffToolClass.handle as any).mockResolvedValue(undefined) - await applyDiffTool( + await multiApplyDiffTool( mockCline, mockBlock, mockAskApproval, @@ -101,26 +115,24 @@ describe("applyDiffTool experiment routing", () => { mockRemoveClosingTag, ) - expect(applyDiffToolLegacy).toHaveBeenCalledWith( - mockCline, - mockBlock, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + expect(applyDiffToolClass.handle).toHaveBeenCalledWith(mockCline, mockBlock, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) }) - it("should use new tool when MULTI_FILE_APPLY_DIFF experiment is enabled", async () => { + it("should use multi-file tool when MULTI_FILE_APPLY_DIFF experiment is enabled and using XML protocol", async () => { mockProvider.getState.mockResolvedValue({ experiments: { [EXPERIMENT_IDS.MULTI_FILE_APPLY_DIFF]: true, }, }) - // Mock the new tool behavior - it should continue with the new implementation - // Since we're not mocking the entire function, we'll just verify it doesn't call legacy - await applyDiffTool( + // Mock the new tool behavior - it should continue with the multi-file implementation + // Since we're not mocking the entire function, we'll just verify it doesn't call the class-based tool + await multiApplyDiffTool( mockCline, mockBlock, mockAskApproval, @@ -129,13 +141,24 @@ describe("applyDiffTool experiment routing", () => { mockRemoveClosingTag, ) - expect(applyDiffToolLegacy).not.toHaveBeenCalled() + expect(applyDiffToolClass.handle).not.toHaveBeenCalled() }) - it("should use new tool when provider is not available", async () => { - mockCline.providerRef.deref.mockReturnValue(null) + it("should use class-based tool when native protocol is enabled regardless of experiment", async () => { + // Enable native protocol + const vscode = await import("vscode") + vi.mocked(vscode.workspace.getConfiguration).mockReturnValue({ + get: vi.fn().mockReturnValue(TOOL_PROTOCOL.NATIVE), + } as any) - await applyDiffTool( + mockProvider.getState.mockResolvedValue({ + experiments: { + [EXPERIMENT_IDS.MULTI_FILE_APPLY_DIFF]: true, + }, + }) + ;(applyDiffToolClass.handle as any).mockResolvedValue(undefined) + + await multiApplyDiffTool( mockCline, mockBlock, mockAskApproval, @@ -144,7 +167,12 @@ describe("applyDiffTool experiment routing", () => { mockRemoveClosingTag, ) - // When provider is null, it should continue with new implementation (not call legacy) - expect(applyDiffToolLegacy).not.toHaveBeenCalled() + // When native protocol is enabled, should always use class-based tool + expect(applyDiffToolClass.handle).toHaveBeenCalledWith(mockCline, mockBlock, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) }) }) diff --git a/src/core/tools/__tests__/askFollowupQuestionTool.spec.ts b/src/core/tools/__tests__/askFollowupQuestionTool.spec.ts index 6bddddcdf13..68aa49aa500 100644 --- a/src/core/tools/__tests__/askFollowupQuestionTool.spec.ts +++ b/src/core/tools/__tests__/askFollowupQuestionTool.spec.ts @@ -1,4 +1,4 @@ -import { askFollowupQuestionTool } from "../askFollowupQuestionTool" +import { askFollowupQuestionTool } from "../AskFollowupQuestionTool" import { ToolUse } from "../../../shared/tools" describe("askFollowupQuestionTool", () => { @@ -31,14 +31,12 @@ describe("askFollowupQuestionTool", () => { partial: false, } - await askFollowupQuestionTool( - mockCline, - block, - vi.fn(), - vi.fn(), - mockPushToolResult, - vi.fn((tag, content) => content), - ) + await askFollowupQuestionTool.handle(mockCline, block as ToolUse<"ask_followup_question">, { + askApproval: vi.fn(), + handleError: vi.fn(), + pushToolResult: mockPushToolResult, + removeClosingTag: vi.fn((tag, content) => content), + }) expect(mockCline.ask).toHaveBeenCalledWith( "followup", @@ -58,14 +56,12 @@ describe("askFollowupQuestionTool", () => { partial: false, } - await askFollowupQuestionTool( - mockCline, - block, - vi.fn(), - vi.fn(), - mockPushToolResult, - vi.fn((tag, content) => content), - ) + await askFollowupQuestionTool.handle(mockCline, block as ToolUse<"ask_followup_question">, { + askApproval: vi.fn(), + handleError: vi.fn(), + pushToolResult: mockPushToolResult, + removeClosingTag: vi.fn((tag, content) => content), + }) expect(mockCline.ask).toHaveBeenCalledWith( "followup", @@ -87,14 +83,12 @@ describe("askFollowupQuestionTool", () => { partial: false, } - await askFollowupQuestionTool( - mockCline, - block, - vi.fn(), - vi.fn(), - mockPushToolResult, - vi.fn((tag, content) => content), - ) + await askFollowupQuestionTool.handle(mockCline, block as ToolUse<"ask_followup_question">, { + askApproval: vi.fn(), + handleError: vi.fn(), + pushToolResult: mockPushToolResult, + removeClosingTag: vi.fn((tag, content) => content), + }) expect(mockCline.ask).toHaveBeenCalledWith( "followup", diff --git a/src/core/tools/__tests__/attemptCompletionTool.spec.ts b/src/core/tools/__tests__/attemptCompletionTool.spec.ts index fcad4d5f492..72b4560c4a9 100644 --- a/src/core/tools/__tests__/attemptCompletionTool.spec.ts +++ b/src/core/tools/__tests__/attemptCompletionTool.spec.ts @@ -25,7 +25,7 @@ vi.mock("../../../shared/package", () => ({ }, })) -import { attemptCompletionTool } from "../attemptCompletionTool" +import { attemptCompletionTool, AttemptCompletionCallbacks } from "../AttemptCompletionTool" import { Task } from "../../task/Task" import * as vscode from "vscode" @@ -76,16 +76,15 @@ describe("attemptCompletionTool", () => { mockTask.todoList = undefined - await attemptCompletionTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - mockToolDescription, - mockAskFinishSubTaskApproval, - ) + const callbacks: AttemptCompletionCallbacks = { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + askFinishSubTaskApproval: mockAskFinishSubTaskApproval, + toolDescription: mockToolDescription, + } + await attemptCompletionTool.handle(mockTask as Task, block, callbacks) // Should not call pushToolResult with an error for empty todo list expect(mockTask.consecutiveMistakeCount).toBe(0) @@ -102,16 +101,15 @@ describe("attemptCompletionTool", () => { mockTask.todoList = [] - await attemptCompletionTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - mockToolDescription, - mockAskFinishSubTaskApproval, - ) + const callbacks: AttemptCompletionCallbacks = { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + askFinishSubTaskApproval: mockAskFinishSubTaskApproval, + toolDescription: mockToolDescription, + } + await attemptCompletionTool.handle(mockTask as Task, block, callbacks) expect(mockTask.consecutiveMistakeCount).toBe(0) expect(mockTask.recordToolError).not.toHaveBeenCalled() @@ -132,16 +130,15 @@ describe("attemptCompletionTool", () => { mockTask.todoList = completedTodos - await attemptCompletionTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - mockToolDescription, - mockAskFinishSubTaskApproval, - ) + const callbacks: AttemptCompletionCallbacks = { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + askFinishSubTaskApproval: mockAskFinishSubTaskApproval, + toolDescription: mockToolDescription, + } + await attemptCompletionTool.handle(mockTask as Task, block, callbacks) expect(mockTask.consecutiveMistakeCount).toBe(0) expect(mockTask.recordToolError).not.toHaveBeenCalled() @@ -172,16 +169,15 @@ describe("attemptCompletionTool", () => { }), }) - await attemptCompletionTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - mockToolDescription, - mockAskFinishSubTaskApproval, - ) + const callbacks: AttemptCompletionCallbacks = { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + askFinishSubTaskApproval: mockAskFinishSubTaskApproval, + toolDescription: mockToolDescription, + } + await attemptCompletionTool.handle(mockTask as Task, block, callbacks) expect(mockTask.consecutiveMistakeCount).toBe(1) expect(mockTask.recordToolError).toHaveBeenCalledWith("attempt_completion") @@ -215,16 +211,15 @@ describe("attemptCompletionTool", () => { }), }) - await attemptCompletionTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - mockToolDescription, - mockAskFinishSubTaskApproval, - ) + const callbacks: AttemptCompletionCallbacks = { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + askFinishSubTaskApproval: mockAskFinishSubTaskApproval, + toolDescription: mockToolDescription, + } + await attemptCompletionTool.handle(mockTask as Task, block, callbacks) expect(mockTask.consecutiveMistakeCount).toBe(1) expect(mockTask.recordToolError).toHaveBeenCalledWith("attempt_completion") @@ -259,16 +254,15 @@ describe("attemptCompletionTool", () => { }), }) - await attemptCompletionTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - mockToolDescription, - mockAskFinishSubTaskApproval, - ) + const callbacks: AttemptCompletionCallbacks = { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + askFinishSubTaskApproval: mockAskFinishSubTaskApproval, + toolDescription: mockToolDescription, + } + await attemptCompletionTool.handle(mockTask as Task, block, callbacks) expect(mockTask.consecutiveMistakeCount).toBe(1) expect(mockTask.recordToolError).toHaveBeenCalledWith("attempt_completion") @@ -302,16 +296,15 @@ describe("attemptCompletionTool", () => { }), }) - await attemptCompletionTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - mockToolDescription, - mockAskFinishSubTaskApproval, - ) + const callbacks: AttemptCompletionCallbacks = { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + askFinishSubTaskApproval: mockAskFinishSubTaskApproval, + toolDescription: mockToolDescription, + } + await attemptCompletionTool.handle(mockTask as Task, block, callbacks) // Should not prevent completion when setting is disabled expect(mockTask.consecutiveMistakeCount).toBe(0) @@ -346,16 +339,15 @@ describe("attemptCompletionTool", () => { }), }) - await attemptCompletionTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - mockToolDescription, - mockAskFinishSubTaskApproval, - ) + const callbacks: AttemptCompletionCallbacks = { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + askFinishSubTaskApproval: mockAskFinishSubTaskApproval, + toolDescription: mockToolDescription, + } + await attemptCompletionTool.handle(mockTask as Task, block, callbacks) // Should prevent completion when setting is enabled and there are incomplete todos expect(mockTask.consecutiveMistakeCount).toBe(1) @@ -390,16 +382,15 @@ describe("attemptCompletionTool", () => { }), }) - await attemptCompletionTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - mockToolDescription, - mockAskFinishSubTaskApproval, - ) + const callbacks: AttemptCompletionCallbacks = { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + askFinishSubTaskApproval: mockAskFinishSubTaskApproval, + toolDescription: mockToolDescription, + } + await attemptCompletionTool.handle(mockTask as Task, block, callbacks) // Should allow completion when setting is enabled but all todos are completed expect(mockTask.consecutiveMistakeCount).toBe(0) diff --git a/src/core/tools/__tests__/executeCommand.spec.ts b/src/core/tools/__tests__/executeCommand.spec.ts index 2e973a24cb8..f5fc258e3ae 100644 --- a/src/core/tools/__tests__/executeCommand.spec.ts +++ b/src/core/tools/__tests__/executeCommand.spec.ts @@ -4,7 +4,7 @@ import * as path from "path" import * as fs from "fs/promises" -import { ExecuteCommandOptions } from "../executeCommandTool" +import { ExecuteCommandOptions } from "../ExecuteCommandTool" import { TerminalRegistry } from "../../../integrations/terminal/TerminalRegistry" import { Terminal } from "../../../integrations/terminal/Terminal" import { ExecaTerminal } from "../../../integrations/terminal/ExecaTerminal" @@ -21,7 +21,7 @@ vitest.mock("../../../integrations/terminal/Terminal") vitest.mock("../../../integrations/terminal/ExecaTerminal") // Import the actual executeCommand function (not mocked) -import { executeCommand } from "../executeCommandTool" +import { executeCommandInTerminal } from "../ExecuteCommandTool" // Tests for the executeCommand function describe("executeCommand", () => { @@ -104,7 +104,7 @@ describe("executeCommand", () => { } // Execute - const [rejected, result] = await executeCommand(mockTask, options) + const [rejected, result] = await executeCommandInTerminal(mockTask, options) // Verify expect(rejected).toBe(false) @@ -145,7 +145,7 @@ describe("executeCommand", () => { } // Execute - const [rejected, result] = await executeCommand(mockTask, options) + const [rejected, result] = await executeCommandInTerminal(mockTask, options) // Verify expect(rejected).toBe(false) @@ -178,7 +178,7 @@ describe("executeCommand", () => { } // Execute - const [rejected, result] = await executeCommand(mockTask, options) + const [rejected, result] = await executeCommandInTerminal(mockTask, options) // Verify expect(rejected).toBe(false) @@ -209,7 +209,7 @@ describe("executeCommand", () => { } // Execute - const [rejected, result] = await executeCommand(mockTask, options) + const [rejected, result] = await executeCommandInTerminal(mockTask, options) // Verify expect(rejected).toBe(false) @@ -239,7 +239,7 @@ describe("executeCommand", () => { } // Execute - const [rejected, result] = await executeCommand(mockTask, options) + const [rejected, result] = await executeCommandInTerminal(mockTask, options) // Verify expect(rejected).toBe(false) @@ -262,7 +262,7 @@ describe("executeCommand", () => { } // Execute - const [rejected, result] = await executeCommand(mockTask, options) + const [rejected, result] = await executeCommandInTerminal(mockTask, options) // Verify expect(rejected).toBe(false) @@ -289,7 +289,7 @@ describe("executeCommand", () => { } // Execute - await executeCommand(mockTask, options) + await executeCommandInTerminal(mockTask, options) // Verify expect(TerminalRegistry.getOrCreateTerminal).toHaveBeenCalledWith(mockTask.cwd, mockTask.taskId, "vscode") @@ -312,7 +312,7 @@ describe("executeCommand", () => { } // Execute - await executeCommand(mockTask, options) + await executeCommandInTerminal(mockTask, options) // Verify expect(TerminalRegistry.getOrCreateTerminal).toHaveBeenCalledWith(mockTask.cwd, mockTask.taskId, "execa") @@ -338,7 +338,7 @@ describe("executeCommand", () => { } // Execute - const [rejected, result] = await executeCommand(mockTask, options) + const [rejected, result] = await executeCommandInTerminal(mockTask, options) // Verify expect(rejected).toBe(false) @@ -364,7 +364,7 @@ describe("executeCommand", () => { } // Execute - const [rejected, result] = await executeCommand(mockTask, options) + const [rejected, result] = await executeCommandInTerminal(mockTask, options) // Verify expect(rejected).toBe(false) @@ -398,7 +398,7 @@ describe("executeCommand", () => { } // Execute - const [rejected, result] = await executeCommand(mockTask, options) + const [rejected, result] = await executeCommandInTerminal(mockTask, options) // Verify expect(rejected).toBe(false) @@ -440,7 +440,7 @@ describe("executeCommand", () => { } // Execute - const [rejected, result] = await executeCommand(mockTask, options) + const [rejected, result] = await executeCommandInTerminal(mockTask, options) // Verify the result uses the updated working directory expect(rejected).toBe(false) diff --git a/src/core/tools/__tests__/executeCommandTimeout.integration.spec.ts b/src/core/tools/__tests__/executeCommandTimeout.integration.spec.ts index b9e0af3a8a3..c4732867e3c 100644 --- a/src/core/tools/__tests__/executeCommandTimeout.integration.spec.ts +++ b/src/core/tools/__tests__/executeCommandTimeout.integration.spec.ts @@ -3,7 +3,7 @@ import * as vscode from "vscode" import * as fs from "fs/promises" -import { executeCommand, executeCommandTool, ExecuteCommandOptions } from "../executeCommandTool" +import { executeCommandInTerminal, executeCommandTool, ExecuteCommandOptions } from "../ExecuteCommandTool" import { Task } from "../../task/Task" import { TerminalRegistry } from "../../../integrations/terminal/TerminalRegistry" @@ -90,7 +90,7 @@ describe("Command Execution Timeout Integration", () => { const quickProcess = Promise.resolve() mockTerminal.runCommand.mockReturnValue(quickProcess) - await executeCommand(mockTask as Task, options) + await executeCommandInTerminal(mockTask as Task, options) // Verify that the terminal was called with the command expect(mockTerminal.runCommand).toHaveBeenCalledWith("echo test", expect.any(Object)) @@ -115,7 +115,7 @@ describe("Command Execution Timeout Integration", () => { mockTerminal.runCommand.mockReturnValue(longRunningProcess) // Execute with timeout - const result = await executeCommand(mockTask as Task, options) + const result = await executeCommandInTerminal(mockTask as Task, options) // Should return timeout error expect(result[0]).toBe(false) // Not rejected by user @@ -140,7 +140,7 @@ describe("Command Execution Timeout Integration", () => { mockTerminal.runCommand.mockReturnValue(neverResolvingPromise) - await executeCommand(mockTask as Task, options) + await executeCommandInTerminal(mockTask as Task, options) // Verify abort was called expect(abortSpy).toHaveBeenCalled() @@ -157,7 +157,7 @@ describe("Command Execution Timeout Integration", () => { const quickProcess = Promise.resolve() mockTerminal.runCommand.mockReturnValue(quickProcess) - const result = await executeCommand(mockTask as Task, options) + const result = await executeCommandInTerminal(mockTask as Task, options) // Should complete successfully without timeout expect(result[0]).toBe(false) // Not rejected @@ -174,7 +174,7 @@ describe("Command Execution Timeout Integration", () => { const quickProcess = Promise.resolve() mockTerminal.runCommand.mockReturnValue(quickProcess) - await executeCommand(mockTask as Task, options) + await executeCommandInTerminal(mockTask as Task, options) // Should complete without issues using default (no timeout) expect(mockTerminal.runCommand).toHaveBeenCalled() @@ -194,7 +194,7 @@ describe("Command Execution Timeout Integration", () => { mockTerminal.runCommand.mockReturnValue(longRunningProcess) - const result = await executeCommand(mockTask as Task, options) + const result = await executeCommandInTerminal(mockTask as Task, options) // Should complete successfully without timeout expect(result[0]).toBe(false) // Not rejected @@ -273,14 +273,12 @@ describe("Command Execution Timeout Integration", () => { }) mockTerminal.runCommand.mockReturnValue(longRunningProcess) - await executeCommandTool( - mockTask as Task, - mockBlock, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await executeCommandTool.handle(mockTask as Task, mockBlock, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) // Should complete successfully without timeout because "npm" is in allowlist expect(mockPushToolResult).toHaveBeenCalled() @@ -306,14 +304,12 @@ describe("Command Execution Timeout Integration", () => { ;(neverResolvingProcess as any).abort = vitest.fn() mockTerminal.runCommand.mockReturnValue(neverResolvingProcess) - await executeCommandTool( - mockTask as Task, - mockBlock, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await executeCommandTool.handle(mockTask as Task, mockBlock, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) // Should timeout because "sleep" is not in allowlist expect(mockPushToolResult).toHaveBeenCalled() @@ -339,14 +335,12 @@ describe("Command Execution Timeout Integration", () => { ;(neverResolvingProcess as any).abort = vitest.fn() mockTerminal.runCommand.mockReturnValue(neverResolvingProcess) - await executeCommandTool( - mockTask as Task, - mockBlock, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await executeCommandTool.handle(mockTask as Task, mockBlock, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) // Should timeout because allowlist is empty expect(mockPushToolResult).toHaveBeenCalled() @@ -375,14 +369,12 @@ describe("Command Execution Timeout Integration", () => { mockBlock.params.command = "git log --oneline" mockTerminal.runCommand.mockReturnValueOnce(longRunningProcess) - await executeCommandTool( - mockTask as Task, - mockBlock, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await executeCommandTool.handle(mockTask as Task, mockBlock, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockPushToolResult).toHaveBeenCalled() const result1 = mockPushToolResult.mock.calls[0][0] @@ -395,14 +387,12 @@ describe("Command Execution Timeout Integration", () => { mockBlock.params.command = "git status" // "git" alone is not in allowlist, only "git log" mockTerminal.runCommand.mockReturnValueOnce(neverResolvingProcess) - await executeCommandTool( - mockTask as Task, - mockBlock, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await executeCommandTool.handle(mockTask as Task, mockBlock, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockPushToolResult).toHaveBeenCalled() const result2 = mockPushToolResult.mock.calls[0][0] diff --git a/src/core/tools/__tests__/executeCommandTool.spec.ts b/src/core/tools/__tests__/executeCommandTool.spec.ts index dbb1945177a..a56adac40ca 100644 --- a/src/core/tools/__tests__/executeCommandTool.spec.ts +++ b/src/core/tools/__tests__/executeCommandTool.spec.ts @@ -13,69 +13,33 @@ vitest.mock("execa", () => ({ execa: vitest.fn(), })) +vitest.mock("fs/promises", () => ({ + default: { + access: vitest.fn().mockResolvedValue(undefined), + }, +})) + vitest.mock("vscode", () => ({ workspace: { getConfiguration: vitest.fn(), }, })) +vitest.mock("../../../integrations/terminal/TerminalRegistry", () => ({ + TerminalRegistry: { + getOrCreateTerminal: vitest.fn().mockResolvedValue({ + runCommand: vitest.fn().mockResolvedValue(undefined), + getCurrentWorkingDirectory: vitest.fn().mockReturnValue("/test/workspace"), + }), + }, +})) + vitest.mock("../../task/Task") vitest.mock("../../prompts/responses") -// Create a mock for the executeCommand function -const mockExecuteCommand = vitest.fn().mockImplementation(() => { - return Promise.resolve([false, "Command executed"]) -}) - -// Mock the module -vitest.mock("../executeCommandTool") - -// Import after mocking -import { executeCommandTool } from "../executeCommandTool" - -// Now manually restore and mock the functions -beforeEach(() => { - // Reset the mock implementation for executeCommandTool - // @ts-expect-error - TypeScript doesn't like this pattern - executeCommandTool.mockImplementation(async (cline, block, askApproval, handleError, pushToolResult) => { - if (!block.params.command) { - cline.consecutiveMistakeCount++ - cline.recordToolError("execute_command") - const errorMessage = await cline.sayAndCreateMissingParamError("execute_command", "command") - pushToolResult(errorMessage) - return - } - - const ignoredFileAttemptedToAccess = cline.rooIgnoreController?.validateCommand(block.params.command) - if (ignoredFileAttemptedToAccess) { - await cline.say("rooignore_error", ignoredFileAttemptedToAccess) - // Call the mocked formatResponse functions with the correct arguments - const mockRooIgnoreError = "RooIgnore error" - ;(formatResponse.rooIgnoreError as any).mockReturnValue(mockRooIgnoreError) - ;(formatResponse.toolError as any).mockReturnValue("Tool error") - formatResponse.rooIgnoreError(ignoredFileAttemptedToAccess) - formatResponse.toolError(mockRooIgnoreError) - pushToolResult("Tool error") - return - } - - const didApprove = await askApproval("command", block.params.command) - if (!didApprove) { - return - } - - // Get the custom working directory if provided - const customCwd = block.params.cwd - - const [userRejected, result] = await mockExecuteCommand(cline, block.params.command, customCwd) - - if (userRejected) { - cline.didRejectTool = true - } - - pushToolResult(result) - }) -}) +// Import the module +import * as executeCommandModule from "../ExecuteCommandTool" +const { executeCommandTool } = executeCommandModule describe("executeCommandTool", () => { // Setup common test variables @@ -84,12 +48,15 @@ describe("executeCommandTool", () => { let mockHandleError: any let mockPushToolResult: any let mockRemoveClosingTag: any - let mockToolUse: ToolUse + let mockToolUse: ToolUse<"execute_command"> beforeEach(() => { // Reset mocks vitest.clearAllMocks() + // Spy on executeCommandInTerminal and mock its return value + vitest.spyOn(executeCommandModule, "executeCommandInTerminal").mockResolvedValue([false, "Command executed"]) + // Create mock implementations with eslint directives to handle the type issues mockCline = { ask: vitest.fn().mockResolvedValue(undefined), @@ -101,8 +68,19 @@ describe("executeCommandTool", () => { validateCommand: vitest.fn().mockReturnValue(null), }, recordToolUsage: vitest.fn().mockReturnValue({} as ToolUsage), - // Add the missing recordToolError function recordToolError: vitest.fn(), + providerRef: { + deref: vitest.fn().mockResolvedValue({ + getState: vitest.fn().mockResolvedValue({ + terminalOutputLineLimit: 500, + terminalOutputCharacterLimit: 100000, + terminalShellIntegrationDisabled: true, + }), + postMessageToWebview: vitest.fn(), + }), + }, + lastMessageTs: Date.now(), + cwd: "/test/workspace", } mockAskApproval = vitest.fn().mockResolvedValue(true) @@ -110,6 +88,12 @@ describe("executeCommandTool", () => { mockPushToolResult = vitest.fn() mockRemoveClosingTag = vitest.fn().mockReturnValue("command") + // Setup vscode config mock + const mockConfig = { + get: vitest.fn().mockImplementation((key: string, defaultValue: any) => defaultValue), + } + ;(vscode.workspace.getConfiguration as any).mockReturnValue(mockConfig) + // Create a mock tool use object mockToolUse = { type: "tool_use", @@ -157,20 +141,20 @@ describe("executeCommandTool", () => { // Setup mockToolUse.params.command = "echo test" - // Execute - await executeCommandTool( - mockCline as unknown as Task, - mockToolUse, - mockAskApproval as unknown as AskApproval, - mockHandleError as unknown as HandleError, - mockPushToolResult as unknown as PushToolResult, - mockRemoveClosingTag as unknown as RemoveClosingTag, - ) + // Execute using the class-based handle method + await executeCommandTool.handle(mockCline as unknown as Task, mockToolUse, { + askApproval: mockAskApproval as unknown as AskApproval, + handleError: mockHandleError as unknown as HandleError, + pushToolResult: mockPushToolResult as unknown as PushToolResult, + removeClosingTag: mockRemoveClosingTag as unknown as RemoveClosingTag, + }) // Verify expect(mockAskApproval).toHaveBeenCalledWith("command", "echo test") - expect(mockExecuteCommand).toHaveBeenCalled() - expect(mockPushToolResult).toHaveBeenCalledWith("Command executed") + expect(mockPushToolResult).toHaveBeenCalled() + // The exact message depends on the terminal mock's behavior + const result = mockPushToolResult.mock.calls[0][0] + expect(result).toContain("Command") }) it("should pass along custom working directory if provided", async () => { @@ -179,20 +163,19 @@ describe("executeCommandTool", () => { mockToolUse.params.cwd = "/custom/path" // Execute - await executeCommandTool( - mockCline as unknown as Task, - mockToolUse, - mockAskApproval as unknown as AskApproval, - mockHandleError as unknown as HandleError, - mockPushToolResult as unknown as PushToolResult, - mockRemoveClosingTag as unknown as RemoveClosingTag, - ) - - // Verify - expect(mockExecuteCommand).toHaveBeenCalled() - // Check that the last call to mockExecuteCommand included the custom path - const lastCall = mockExecuteCommand.mock.calls[mockExecuteCommand.mock.calls.length - 1] - expect(lastCall[2]).toBe("/custom/path") + await executeCommandTool.handle(mockCline as unknown as Task, mockToolUse, { + askApproval: mockAskApproval as unknown as AskApproval, + handleError: mockHandleError as unknown as HandleError, + pushToolResult: mockPushToolResult as unknown as PushToolResult, + removeClosingTag: mockRemoveClosingTag as unknown as RemoveClosingTag, + }) + + // Verify - confirm the command was approved and result was pushed + // The custom path handling is tested in integration tests + expect(mockAskApproval).toHaveBeenCalledWith("command", "echo test") + expect(mockPushToolResult).toHaveBeenCalled() + const result = mockPushToolResult.mock.calls[0][0] + expect(result).toContain("/custom/path") }) }) @@ -202,21 +185,19 @@ describe("executeCommandTool", () => { mockToolUse.params.command = undefined // Execute - await executeCommandTool( - mockCline as unknown as Task, - mockToolUse, - mockAskApproval as unknown as AskApproval, - mockHandleError as unknown as HandleError, - mockPushToolResult as unknown as PushToolResult, - mockRemoveClosingTag as unknown as RemoveClosingTag, - ) + await executeCommandTool.handle(mockCline as unknown as Task, mockToolUse, { + askApproval: mockAskApproval as unknown as AskApproval, + handleError: mockHandleError as unknown as HandleError, + pushToolResult: mockPushToolResult as unknown as PushToolResult, + removeClosingTag: mockRemoveClosingTag as unknown as RemoveClosingTag, + }) // Verify expect(mockCline.consecutiveMistakeCount).toBe(1) expect(mockCline.sayAndCreateMissingParamError).toHaveBeenCalledWith("execute_command", "command") expect(mockPushToolResult).toHaveBeenCalledWith("Missing parameter error") expect(mockAskApproval).not.toHaveBeenCalled() - expect(mockExecuteCommand).not.toHaveBeenCalled() + expect(executeCommandModule.executeCommandInTerminal).not.toHaveBeenCalled() }) it("should handle command rejection", async () => { @@ -225,18 +206,16 @@ describe("executeCommandTool", () => { mockAskApproval.mockResolvedValue(false) // Execute - await executeCommandTool( - mockCline as unknown as Task, - mockToolUse, - mockAskApproval as unknown as AskApproval, - mockHandleError as unknown as HandleError, - mockPushToolResult as unknown as PushToolResult, - mockRemoveClosingTag as unknown as RemoveClosingTag, - ) + await executeCommandTool.handle(mockCline as unknown as Task, mockToolUse, { + askApproval: mockAskApproval as unknown as AskApproval, + handleError: mockHandleError as unknown as HandleError, + pushToolResult: mockPushToolResult as unknown as PushToolResult, + removeClosingTag: mockRemoveClosingTag as unknown as RemoveClosingTag, + }) // Verify expect(mockAskApproval).toHaveBeenCalledWith("command", "echo test") - expect(mockExecuteCommand).not.toHaveBeenCalled() + // executeCommandInTerminal should not be called since approval was denied expect(mockPushToolResult).not.toHaveBeenCalled() }) @@ -254,14 +233,12 @@ describe("executeCommandTool", () => { ;(formatResponse.toolError as any).mockReturnValue("Tool error") // Execute - await executeCommandTool( - mockCline as unknown as Task, - mockToolUse, - mockAskApproval as unknown as AskApproval, - mockHandleError as unknown as HandleError, - mockPushToolResult as unknown as PushToolResult, - mockRemoveClosingTag as unknown as RemoveClosingTag, - ) + await executeCommandTool.handle(mockCline as unknown as Task, mockToolUse, { + askApproval: mockAskApproval as unknown as AskApproval, + handleError: mockHandleError as unknown as HandleError, + pushToolResult: mockPushToolResult as unknown as PushToolResult, + removeClosingTag: mockRemoveClosingTag as unknown as RemoveClosingTag, + }) // Verify expect(validateCommandMock).toHaveBeenCalledWith("cat .env") @@ -270,7 +247,7 @@ describe("executeCommandTool", () => { expect(formatResponse.toolError).toHaveBeenCalledWith(mockRooIgnoreError) expect(mockPushToolResult).toHaveBeenCalled() expect(mockAskApproval).not.toHaveBeenCalled() - expect(mockExecuteCommand).not.toHaveBeenCalled() + // executeCommandInTerminal should not be called since param was missing }) }) @@ -292,7 +269,7 @@ describe("executeCommandTool", () => { }) it("should handle timeout parameter in function signature", () => { - // Test that the executeCommand function accepts timeout parameter + // Test that the executeCommandInTerminal function accepts timeout parameter // This is a compile-time check that the types are correct const mockOptions = { executionId: "test-id", diff --git a/src/core/tools/__tests__/generateImageTool.test.ts b/src/core/tools/__tests__/generateImageTool.test.ts index 940490ecfbe..68b0e36f4b3 100644 --- a/src/core/tools/__tests__/generateImageTool.test.ts +++ b/src/core/tools/__tests__/generateImageTool.test.ts @@ -1,5 +1,5 @@ import { describe, it, expect, vi, beforeEach } from "vitest" -import { generateImageTool } from "../generateImageTool" +import { generateImageTool } from "../GenerateImageTool" import { ToolUse } from "../../../shared/tools" import { Task } from "../../task/Task" import * as fs from "fs/promises" @@ -82,14 +82,12 @@ describe("generateImageTool", () => { partial: true, } - await generateImageTool( - mockCline as Task, - partialBlock, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await generateImageTool.handle(mockCline as Task, partialBlock as ToolUse<"generate_image">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) // Should not process anything when partial expect(mockAskApproval).not.toHaveBeenCalled() @@ -109,14 +107,12 @@ describe("generateImageTool", () => { partial: true, } - await generateImageTool( - mockCline as Task, - partialBlock, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await generateImageTool.handle(mockCline as Task, partialBlock as ToolUse<"generate_image">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) // Should not process anything when partial expect(mockAskApproval).not.toHaveBeenCalled() @@ -149,14 +145,12 @@ describe("generateImageTool", () => { }) as any, ) - await generateImageTool( - mockCline as Task, - completeBlock, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await generateImageTool.handle(mockCline as Task, completeBlock as ToolUse<"generate_image">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) // Should process the complete block expect(mockAskApproval).toHaveBeenCalled() @@ -192,14 +186,12 @@ describe("generateImageTool", () => { }) as any, ) - await generateImageTool( - mockCline as Task, - completeBlock, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await generateImageTool.handle(mockCline as Task, completeBlock as ToolUse<"generate_image">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) // Check that cline.say was called with image data containing cache-busting parameter expect(mockCline.say).toHaveBeenCalledWith("image", expect.stringMatching(/"imageUri":"[^"]+\?t=\d+"/)) @@ -230,14 +222,12 @@ describe("generateImageTool", () => { partial: false, } - await generateImageTool( - mockCline as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await generateImageTool.handle(mockCline as Task, block as ToolUse<"generate_image">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockCline.consecutiveMistakeCount).toBe(1) expect(mockCline.recordToolError).toHaveBeenCalledWith("generate_image") @@ -255,14 +245,12 @@ describe("generateImageTool", () => { partial: false, } - await generateImageTool( - mockCline as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await generateImageTool.handle(mockCline as Task, block as ToolUse<"generate_image">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockCline.consecutiveMistakeCount).toBe(1) expect(mockCline.recordToolError).toHaveBeenCalledWith("generate_image") @@ -290,14 +278,12 @@ describe("generateImageTool", () => { partial: false, } - await generateImageTool( - mockCline as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await generateImageTool.handle(mockCline as Task, block as ToolUse<"generate_image">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockPushToolResult).toHaveBeenCalledWith( formatResponse.toolError( @@ -322,14 +308,12 @@ describe("generateImageTool", () => { partial: false, } - await generateImageTool( - mockCline as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await generateImageTool.handle(mockCline as Task, block as ToolUse<"generate_image">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockCline.say).toHaveBeenCalledWith("error", expect.stringContaining("Input image not found")) expect(mockPushToolResult).toHaveBeenCalledWith(expect.stringContaining("Input image not found")) @@ -347,14 +331,12 @@ describe("generateImageTool", () => { partial: false, } - await generateImageTool( - mockCline as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await generateImageTool.handle(mockCline as Task, block as ToolUse<"generate_image">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockCline.say).toHaveBeenCalledWith("error", expect.stringContaining("Unsupported image format")) expect(mockPushToolResult).toHaveBeenCalledWith(expect.stringContaining("Unsupported image format")) diff --git a/src/core/tools/__tests__/insertContentTool.spec.ts b/src/core/tools/__tests__/insertContentTool.spec.ts index 5f055fb29a4..bf7bff670c8 100644 --- a/src/core/tools/__tests__/insertContentTool.spec.ts +++ b/src/core/tools/__tests__/insertContentTool.spec.ts @@ -4,7 +4,7 @@ import type { MockedFunction } from "vitest" import { fileExistsAtPath } from "../../../utils/fs" import { ToolUse, ToolResponse } from "../../../shared/tools" -import { insertContentTool } from "../insertContentTool" +import { insertContentTool } from "../InsertContentTool" // Helper to normalize paths to POSIX format for cross-platform testing const toPosix = (filePath: string) => filePath.replace(/\\/g, "/") @@ -154,16 +154,14 @@ describe("insertContentTool", () => { partial: isPartial, } - await insertContentTool( - mockCline, - toolUse, - mockAskApproval, - mockHandleError, - (result: ToolResponse) => { + await insertContentTool.handle(mockCline, toolUse as any, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: (result: ToolResponse) => { toolResult = result }, - mockRemoveClosingTag, - ) + removeClosingTag: mockRemoveClosingTag, + }) return toolResult } diff --git a/src/core/tools/__tests__/listCodeDefinitionNamesTool.spec.ts b/src/core/tools/__tests__/listCodeDefinitionNamesTool.spec.ts index 7a26c2f8eeb..2f6c1c264a1 100644 --- a/src/core/tools/__tests__/listCodeDefinitionNamesTool.spec.ts +++ b/src/core/tools/__tests__/listCodeDefinitionNamesTool.spec.ts @@ -1,7 +1,7 @@ // npx vitest src/core/tools/__tests__/listCodeDefinitionNamesTool.spec.ts import { describe, it, expect, vi, beforeEach } from "vitest" -import { listCodeDefinitionNamesTool } from "../listCodeDefinitionNamesTool" +import { listCodeDefinitionNamesTool } from "../ListCodeDefinitionNamesTool" import { Task } from "../../task/Task" import { ToolUse } from "../../../shared/tools" import * as treeSitter from "../../../services/tree-sitter" @@ -80,14 +80,12 @@ describe("listCodeDefinitionNamesTool", () => { partial: false, } - await listCodeDefinitionNamesTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await listCodeDefinitionNamesTool.handle(mockTask as Task, block as ToolUse<"list_code_definition_names">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockPushToolResult).toHaveBeenCalledWith(mockDefinitions) }) @@ -118,14 +116,12 @@ describe("listCodeDefinitionNamesTool", () => { partial: false, } - await listCodeDefinitionNamesTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await listCodeDefinitionNamesTool.handle(mockTask as Task, block as ToolUse<"list_code_definition_names">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockPushToolResult).toHaveBeenCalledWith(mockDefinitions) }) @@ -156,14 +152,12 @@ describe("listCodeDefinitionNamesTool", () => { partial: false, } - await listCodeDefinitionNamesTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await listCodeDefinitionNamesTool.handle(mockTask as Task, block as ToolUse<"list_code_definition_names">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) // Should only include definitions starting at or before line 25 const expectedResult = `# test.ts @@ -197,14 +191,12 @@ describe("listCodeDefinitionNamesTool", () => { partial: false, } - await listCodeDefinitionNamesTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await listCodeDefinitionNamesTool.handle(mockTask as Task, block as ToolUse<"list_code_definition_names">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) // Should include foo (starts at 10) but not bar (starts at 60) const expectedResult = `# test.ts @@ -239,14 +231,12 @@ describe("listCodeDefinitionNamesTool", () => { partial: false, } - await listCodeDefinitionNamesTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await listCodeDefinitionNamesTool.handle(mockTask as Task, block as ToolUse<"list_code_definition_names">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) // Should include foo and bar but not baz const expectedResult = `# test.ts @@ -280,14 +270,12 @@ describe("listCodeDefinitionNamesTool", () => { partial: false, } - await listCodeDefinitionNamesTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await listCodeDefinitionNamesTool.handle(mockTask as Task, block as ToolUse<"list_code_definition_names">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) // Should keep header but exclude all definitions beyond line 50 const expectedResult = `# test.ts` @@ -306,14 +294,12 @@ describe("listCodeDefinitionNamesTool", () => { mockTask.sayAndCreateMissingParamError = vi.fn(async () => "Missing parameter: path") - await listCodeDefinitionNamesTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await listCodeDefinitionNamesTool.handle(mockTask as Task, block as ToolUse<"list_code_definition_names">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockTask.consecutiveMistakeCount).toBe(1) expect(mockTask.recordToolError).toHaveBeenCalledWith("list_code_definition_names") @@ -337,14 +323,12 @@ describe("listCodeDefinitionNamesTool", () => { partial: false, } - await listCodeDefinitionNamesTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await listCodeDefinitionNamesTool.handle(mockTask as Task, block as ToolUse<"list_code_definition_names">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockPushToolResult).toHaveBeenCalledWith(mockDefinitions) }) diff --git a/src/core/tools/__tests__/multiApplyDiffTool.spec.ts b/src/core/tools/__tests__/multiApplyDiffTool.spec.ts index 5e591f9fe79..423660c0daf 100644 --- a/src/core/tools/__tests__/multiApplyDiffTool.spec.ts +++ b/src/core/tools/__tests__/multiApplyDiffTool.spec.ts @@ -1,4 +1,4 @@ -import { applyDiffTool } from "../multiApplyDiffTool" +import { applyDiffTool } from "../MultiApplyDiffTool" import { EXPERIMENT_IDS } from "../../../shared/experiments" import * as fs from "fs/promises" import * as fileUtils from "../../../utils/fs" diff --git a/src/core/tools/__tests__/newTaskTool.spec.ts b/src/core/tools/__tests__/newTaskTool.spec.ts index a95efcd94f2..d86e5453d8f 100644 --- a/src/core/tools/__tests__/newTaskTool.spec.ts +++ b/src/core/tools/__tests__/newTaskTool.spec.ts @@ -97,8 +97,8 @@ const mockCline = { }, } -// Import the function to test AFTER mocks are set up -import { newTaskTool } from "../newTaskTool" +// Import the class to test AFTER mocks are set up +import { newTaskTool } from "../NewTaskTool" import type { ToolUse } from "../../../shared/tools" import { getModeBySlug } from "../../../shared/modes" import * as vscode from "vscode" @@ -135,14 +135,12 @@ describe("newTaskTool", () => { partial: false, } - await newTaskTool( - mockCline as any, // Use 'as any' for simplicity in mocking complex type - block, - mockAskApproval, // Now correctly typed - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await newTaskTool.handle(mockCline as any, block as ToolUse<"new_task">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) // Verify askApproval was called expect(mockAskApproval).toHaveBeenCalled() @@ -173,14 +171,12 @@ describe("newTaskTool", () => { partial: false, } - await newTaskTool( - mockCline as any, - block, - mockAskApproval, // Now correctly typed - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await newTaskTool.handle(mockCline as any, block as ToolUse<"new_task">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockStartSubtask).toHaveBeenCalledWith( "This is already unescaped: \\@file1.txt", // Expected: \@ remains \@ @@ -201,14 +197,12 @@ describe("newTaskTool", () => { partial: false, } - await newTaskTool( - mockCline as any, - block, - mockAskApproval, // Now correctly typed - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await newTaskTool.handle(mockCline as any, block as ToolUse<"new_task">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockStartSubtask).toHaveBeenCalledWith( "A normal mention @file1.txt", // Expected: @ remains @ @@ -229,14 +223,12 @@ describe("newTaskTool", () => { partial: false, } - await newTaskTool( - mockCline as any, - block, - mockAskApproval, // Now correctly typed - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await newTaskTool.handle(mockCline as any, block as ToolUse<"new_task">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockStartSubtask).toHaveBeenCalledWith( "Mix: @file0.txt, \\@file1.txt, \\@file2.txt, \\\\\\@file3.txt", // Unit Test Expectation: @->@, \@->\@, \\@->\@, \\\\@->\\\\@ @@ -257,14 +249,12 @@ describe("newTaskTool", () => { partial: false, } - await newTaskTool( - mockCline as any, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await newTaskTool.handle(mockCline as any, block as ToolUse<"new_task">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) // Should NOT error when todos is missing expect(mockSayAndCreateMissingParamError).not.toHaveBeenCalledWith("new_task", "todos") @@ -290,14 +280,12 @@ describe("newTaskTool", () => { partial: false, } - await newTaskTool( - mockCline as any, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await newTaskTool.handle(mockCline as any, block as ToolUse<"new_task">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) // Should parse and include todos when provided expect(mockStartSubtask).toHaveBeenCalledWith( @@ -324,14 +312,12 @@ describe("newTaskTool", () => { partial: false, } - await newTaskTool( - mockCline as any, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await newTaskTool.handle(mockCline as any, block as ToolUse<"new_task">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockSayAndCreateMissingParamError).toHaveBeenCalledWith("new_task", "mode") expect(mockCline.consecutiveMistakeCount).toBe(1) @@ -350,14 +336,12 @@ describe("newTaskTool", () => { partial: false, } - await newTaskTool( - mockCline as any, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await newTaskTool.handle(mockCline as any, block as ToolUse<"new_task">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockSayAndCreateMissingParamError).toHaveBeenCalledWith("new_task", "message") expect(mockCline.consecutiveMistakeCount).toBe(1) @@ -376,14 +360,12 @@ describe("newTaskTool", () => { partial: false, } - await newTaskTool( - mockCline as any, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await newTaskTool.handle(mockCline as any, block as ToolUse<"new_task">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockStartSubtask).toHaveBeenCalledWith( "Test message", @@ -415,14 +397,12 @@ describe("newTaskTool", () => { partial: false, } - await newTaskTool( - mockCline as any, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await newTaskTool.handle(mockCline as any, block as ToolUse<"new_task">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) // Should NOT error when todos is missing and setting is disabled expect(mockSayAndCreateMissingParamError).not.toHaveBeenCalledWith("new_task", "todos") @@ -454,14 +434,12 @@ describe("newTaskTool", () => { partial: false, } - await newTaskTool( - mockCline as any, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await newTaskTool.handle(mockCline as any, block as ToolUse<"new_task">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) // Should error when todos is missing and setting is enabled expect(mockSayAndCreateMissingParamError).toHaveBeenCalledWith("new_task", "todos") @@ -493,14 +471,12 @@ describe("newTaskTool", () => { partial: false, } - await newTaskTool( - mockCline as any, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await newTaskTool.handle(mockCline as any, block as ToolUse<"new_task">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) // Should NOT error when todos is provided and setting is enabled expect(mockSayAndCreateMissingParamError).not.toHaveBeenCalledWith("new_task", "todos") @@ -538,14 +514,12 @@ describe("newTaskTool", () => { partial: false, } - await newTaskTool( - mockCline as any, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await newTaskTool.handle(mockCline as any, block as ToolUse<"new_task">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) // Should NOT error when todos is empty string and setting is enabled expect(mockSayAndCreateMissingParamError).not.toHaveBeenCalledWith("new_task", "todos") @@ -575,14 +549,12 @@ describe("newTaskTool", () => { partial: false, } - await newTaskTool( - mockCline as any, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await newTaskTool.handle(mockCline as any, block as ToolUse<"new_task">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) // Verify that VSCode configuration was accessed with Package.name expect(mockGetConfiguration).toHaveBeenCalledWith("roo-cline") @@ -611,14 +583,12 @@ describe("newTaskTool", () => { partial: false, } - await newTaskTool( - mockCline as any, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await newTaskTool.handle(mockCline as any, block as ToolUse<"new_task">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) // Assert: configuration was read using the dynamic nightly namespace expect(mockGetConfiguration).toHaveBeenCalledWith("roo-code-nightly") diff --git a/src/core/tools/__tests__/readFileTool.spec.ts b/src/core/tools/__tests__/readFileTool.spec.ts index d693d6ba443..bff1f6c58f4 100644 --- a/src/core/tools/__tests__/readFileTool.spec.ts +++ b/src/core/tools/__tests__/readFileTool.spec.ts @@ -8,7 +8,7 @@ import { extractTextFromFile } from "../../../integrations/misc/extract-text" import { parseSourceCodeDefinitionsForFile } from "../../../services/tree-sitter" import { isBinaryFile } from "isbinaryfile" import { ReadFileToolUse, ToolParamName, ToolResponse } from "../../../shared/tools" -import { readFileTool } from "../readFileTool" +import { readFileTool } from "../ReadFileTool" import { formatResponse } from "../../prompts/responses" import { DEFAULT_MAX_IMAGE_FILE_SIZE_MB, DEFAULT_MAX_TOTAL_IMAGE_SIZE_MB } from "../helpers/imageHelpers" @@ -320,16 +320,14 @@ describe("read_file tool with maxReadFileLine setting", () => { partial: false, } - await readFileTool( - mockCline, - toolUse, - mockCline.ask, - vi.fn(), - (result: ToolResponse) => { + await readFileTool.handle(mockCline, toolUse, { + askApproval: mockCline.ask, + handleError: vi.fn(), + pushToolResult: (result: ToolResponse) => { toolResult = result }, - (_: ToolParamName, content?: string) => content ?? "", - ) + removeClosingTag: (_: ToolParamName, content?: string) => content ?? "", + }) return toolResult } @@ -631,16 +629,14 @@ describe("read_file tool XML output structure", () => { } // Execute the tool - await readFileTool( - mockCline, - toolUse, - mockCline.ask, - vi.fn(), - (result: ToolResponse) => { + await readFileTool.handle(mockCline, toolUse, { + askApproval: mockCline.ask, + handleError: vi.fn(), + pushToolResult: (result: ToolResponse) => { toolResult = result }, - (param: ToolParamName, content?: string) => content ?? "", - ) + removeClosingTag: (param: ToolParamName, content?: string) => content ?? "", + }) return toolResult } @@ -737,16 +733,14 @@ describe("read_file tool XML output structure", () => { } let localResult: ToolResponse | undefined - await readFileTool( - mockCline, - toolUse, - mockCline.ask, - vi.fn(), - (result: ToolResponse) => { + await readFileTool.handle(mockCline, toolUse, { + askApproval: mockCline.ask, + handleError: vi.fn(), + pushToolResult: (result: ToolResponse) => { localResult = result }, - (_: ToolParamName, content?: string) => content ?? "", - ) + removeClosingTag: (_: ToolParamName, content?: string) => content ?? "", + }) // In multi-image scenarios, the result is pushed to pushToolResult, not returned directly. // We need to check the mock's calls to get the result. if (mockCline.pushToolResult.mock.calls.length > 0) { @@ -1359,16 +1353,14 @@ describe("read_file tool XML output structure", () => { } // Execute the tool - await readFileTool( - mockCline, - toolUse, - mockCline.ask, - vi.fn(), - (result: ToolResponse) => { + await readFileTool.handle(mockCline, toolUse, { + askApproval: mockCline.ask, + handleError: vi.fn(), + pushToolResult: (result: ToolResponse) => { toolResult = result }, - (param: ToolParamName, content?: string) => content ?? "", - ) + removeClosingTag: (param: ToolParamName, content?: string) => content ?? "", + }) // Verify expect(toolResult).toBe(`Missing required parameter`) @@ -1448,16 +1440,14 @@ describe("read_file tool with image support", () => { console.log("Mock API:", localMockCline.api) console.log("Supports images:", localMockCline.api?.getModel?.()?.info?.supportsImages) - await readFileTool( - localMockCline, - toolUse, - localMockCline.ask, - vi.fn(), - (result: ToolResponse) => { + await readFileTool.handle(localMockCline, toolUse, { + askApproval: localMockCline.ask, + handleError: vi.fn(), + pushToolResult: (result: ToolResponse) => { toolResult = result }, - (_: ToolParamName, content?: string) => content ?? "", - ) + removeClosingTag: (_: ToolParamName, content?: string) => content ?? "", + }) console.log("Result type:", Array.isArray(toolResult) ? "array" : typeof toolResult) console.log("Result:", toolResult) @@ -1624,16 +1614,14 @@ describe("read_file tool with image support", () => { partial: false, } - await readFileTool( - localMockCline, - toolUse, - localMockCline.ask, - handleErrorSpy, // Use our spy here - (result: ToolResponse) => { + await readFileTool.handle(localMockCline, toolUse, { + askApproval: localMockCline.ask, + handleError: handleErrorSpy, // Use our spy here + pushToolResult: (result: ToolResponse) => { toolResult = result }, - (_: ToolParamName, content?: string) => content ?? "", - ) + removeClosingTag: (_: ToolParamName, content?: string) => content ?? "", + }) // Verify error handling expect(toolResult).toContain("Error reading image file: Failed to read image") diff --git a/src/core/tools/__tests__/runSlashCommandTool.spec.ts b/src/core/tools/__tests__/runSlashCommandTool.spec.ts index 07143e96cc1..e3c8180e381 100644 --- a/src/core/tools/__tests__/runSlashCommandTool.spec.ts +++ b/src/core/tools/__tests__/runSlashCommandTool.spec.ts @@ -1,8 +1,9 @@ import { describe, it, expect, vi, beforeEach } from "vitest" -import { runSlashCommandTool } from "../runSlashCommandTool" +import { runSlashCommandTool } from "../RunSlashCommandTool" import { Task } from "../../task/Task" import { formatResponse } from "../../prompts/responses" import { getCommand, getCommandNames } from "../../../services/command/commands" +import type { ToolUse } from "../../../shared/tools" // Mock dependencies vi.mock("../../../services/command/commands", () => ({ @@ -12,10 +13,7 @@ vi.mock("../../../services/command/commands", () => ({ describe("runSlashCommandTool", () => { let mockTask: any - let mockAskApproval: any - let mockHandleError: any - let mockPushToolResult: any - let mockRemoveClosingTag: any + let mockCallbacks: any beforeEach(() => { vi.clearAllMocks() @@ -24,7 +22,7 @@ describe("runSlashCommandTool", () => { consecutiveMistakeCount: 0, recordToolError: vi.fn(), sayAndCreateMissingParamError: vi.fn().mockResolvedValue("Missing parameter error"), - ask: vi.fn(), + ask: vi.fn().mockResolvedValue({}), cwd: "/test/project", providerRef: { deref: vi.fn().mockReturnValue({ @@ -37,37 +35,32 @@ describe("runSlashCommandTool", () => { }, } - mockAskApproval = vi.fn().mockResolvedValue(true) - mockHandleError = vi.fn() - mockPushToolResult = vi.fn() - mockRemoveClosingTag = vi.fn((tag, text) => text || "") + mockCallbacks = { + askApproval: vi.fn().mockResolvedValue(true), + handleError: vi.fn(), + pushToolResult: vi.fn(), + removeClosingTag: vi.fn((tag, text) => text || ""), + } }) it("should handle missing command parameter", async () => { - const block = { + const block: ToolUse<"run_slash_command"> = { type: "tool_use" as const, name: "run_slash_command" as const, params: {}, partial: false, } - await runSlashCommandTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await runSlashCommandTool.handle(mockTask as Task, block, mockCallbacks) expect(mockTask.consecutiveMistakeCount).toBe(1) expect(mockTask.recordToolError).toHaveBeenCalledWith("run_slash_command") expect(mockTask.sayAndCreateMissingParamError).toHaveBeenCalledWith("run_slash_command", "command") - expect(mockPushToolResult).toHaveBeenCalledWith("Missing parameter error") + expect(mockCallbacks.pushToolResult).toHaveBeenCalledWith("Missing parameter error") }) it("should handle command not found", async () => { - const block = { + const block: ToolUse<"run_slash_command"> = { type: "tool_use" as const, name: "run_slash_command" as const, params: { @@ -79,23 +72,16 @@ describe("runSlashCommandTool", () => { vi.mocked(getCommand).mockResolvedValue(undefined) vi.mocked(getCommandNames).mockResolvedValue(["init", "test", "deploy"]) - await runSlashCommandTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await runSlashCommandTool.handle(mockTask as Task, block, mockCallbacks) expect(mockTask.recordToolError).toHaveBeenCalledWith("run_slash_command") - expect(mockPushToolResult).toHaveBeenCalledWith( + expect(mockCallbacks.pushToolResult).toHaveBeenCalledWith( formatResponse.toolError("Command 'nonexistent' not found. Available commands: init, test, deploy"), ) }) it("should handle user rejection", async () => { - const block = { + const block: ToolUse<"run_slash_command"> = { type: "tool_use" as const, name: "run_slash_command" as const, params: { @@ -113,23 +99,16 @@ describe("runSlashCommandTool", () => { } vi.mocked(getCommand).mockResolvedValue(mockCommand) - mockAskApproval.mockResolvedValue(false) - - await runSlashCommandTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + mockCallbacks.askApproval.mockResolvedValue(false) + + await runSlashCommandTool.handle(mockTask as Task, block, mockCallbacks) - expect(mockAskApproval).toHaveBeenCalled() - expect(mockPushToolResult).not.toHaveBeenCalled() + expect(mockCallbacks.askApproval).toHaveBeenCalled() + expect(mockCallbacks.pushToolResult).not.toHaveBeenCalled() }) it("should successfully execute built-in command", async () => { - const block = { + const block: ToolUse<"run_slash_command"> = { type: "tool_use" as const, name: "run_slash_command" as const, params: { @@ -148,16 +127,9 @@ describe("runSlashCommandTool", () => { vi.mocked(getCommand).mockResolvedValue(mockCommand) - await runSlashCommandTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await runSlashCommandTool.handle(mockTask as Task, block, mockCallbacks) - expect(mockAskApproval).toHaveBeenCalledWith( + expect(mockCallbacks.askApproval).toHaveBeenCalledWith( "tool", JSON.stringify({ tool: "runSlashCommand", @@ -168,7 +140,7 @@ describe("runSlashCommandTool", () => { }), ) - expect(mockPushToolResult).toHaveBeenCalledWith( + expect(mockCallbacks.pushToolResult).toHaveBeenCalledWith( `Command: /init Description: Analyze codebase and create AGENTS.md Source: built-in @@ -180,7 +152,7 @@ Initialize project content here`, }) it("should successfully execute command with arguments", async () => { - const block = { + const block: ToolUse<"run_slash_command"> = { type: "tool_use" as const, name: "run_slash_command" as const, params: { @@ -201,16 +173,9 @@ Initialize project content here`, vi.mocked(getCommand).mockResolvedValue(mockCommand) - await runSlashCommandTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await runSlashCommandTool.handle(mockTask as Task, block, mockCallbacks) - expect(mockPushToolResult).toHaveBeenCalledWith( + expect(mockCallbacks.pushToolResult).toHaveBeenCalledWith( `Command: /test Description: Run project tests Argument hint: test type or focus area @@ -224,7 +189,7 @@ Run tests with specific focus`, }) it("should handle global command", async () => { - const block = { + const block: ToolUse<"run_slash_command"> = { type: "tool_use" as const, name: "run_slash_command" as const, params: { @@ -242,16 +207,9 @@ Run tests with specific focus`, vi.mocked(getCommand).mockResolvedValue(mockCommand) - await runSlashCommandTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await runSlashCommandTool.handle(mockTask as Task, block, mockCallbacks) - expect(mockPushToolResult).toHaveBeenCalledWith( + expect(mockCallbacks.pushToolResult).toHaveBeenCalledWith( `Command: /deploy Source: global @@ -262,7 +220,7 @@ Deploy application to production`, }) it("should handle partial block", async () => { - const block = { + const block: ToolUse<"run_slash_command"> = { type: "tool_use" as const, name: "run_slash_command" as const, params: { @@ -271,14 +229,7 @@ Deploy application to production`, partial: true, } - await runSlashCommandTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await runSlashCommandTool.handle(mockTask as Task, block, mockCallbacks) expect(mockTask.ask).toHaveBeenCalledWith( "tool", @@ -290,11 +241,11 @@ Deploy application to production`, true, ) - expect(mockPushToolResult).not.toHaveBeenCalled() + expect(mockCallbacks.pushToolResult).not.toHaveBeenCalled() }) it("should handle errors during execution", async () => { - const block = { + const block: ToolUse<"run_slash_command"> = { type: "tool_use" as const, name: "run_slash_command" as const, params: { @@ -306,20 +257,13 @@ Deploy application to production`, const error = new Error("Test error") vi.mocked(getCommand).mockRejectedValue(error) - await runSlashCommandTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await runSlashCommandTool.handle(mockTask as Task, block, mockCallbacks) - expect(mockHandleError).toHaveBeenCalledWith("running slash command", error) + expect(mockCallbacks.handleError).toHaveBeenCalledWith("running slash command", error) }) it("should handle empty available commands list", async () => { - const block = { + const block: ToolUse<"run_slash_command"> = { type: "tool_use" as const, name: "run_slash_command" as const, params: { @@ -331,22 +275,15 @@ Deploy application to production`, vi.mocked(getCommand).mockResolvedValue(undefined) vi.mocked(getCommandNames).mockResolvedValue([]) - await runSlashCommandTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await runSlashCommandTool.handle(mockTask as Task, block, mockCallbacks) - expect(mockPushToolResult).toHaveBeenCalledWith( + expect(mockCallbacks.pushToolResult).toHaveBeenCalledWith( formatResponse.toolError("Command 'nonexistent' not found. Available commands: (none)"), ) }) it("should reset consecutive mistake count on valid command", async () => { - const block = { + const block: ToolUse<"run_slash_command"> = { type: "tool_use" as const, name: "run_slash_command" as const, params: { @@ -366,14 +303,7 @@ Deploy application to production`, vi.mocked(getCommand).mockResolvedValue(mockCommand) - await runSlashCommandTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await runSlashCommandTool.handle(mockTask as Task, block, mockCallbacks) expect(mockTask.consecutiveMistakeCount).toBe(0) }) diff --git a/src/core/tools/__tests__/updateTodoListTool.spec.ts b/src/core/tools/__tests__/updateTodoListTool.spec.ts index 0b7e8105724..ebe0500d665 100644 --- a/src/core/tools/__tests__/updateTodoListTool.spec.ts +++ b/src/core/tools/__tests__/updateTodoListTool.spec.ts @@ -1,5 +1,5 @@ import { describe, it, expect, beforeEach, vi } from "vitest" -import { parseMarkdownChecklist } from "../updateTodoListTool" +import { parseMarkdownChecklist } from "../UpdateTodoListTool" import { TodoItem } from "@roo-code/types" describe("parseMarkdownChecklist", () => { diff --git a/src/core/tools/__tests__/useMcpToolTool.spec.ts b/src/core/tools/__tests__/useMcpToolTool.spec.ts index 8738e059e55..3a4743e92ff 100644 --- a/src/core/tools/__tests__/useMcpToolTool.spec.ts +++ b/src/core/tools/__tests__/useMcpToolTool.spec.ts @@ -1,6 +1,6 @@ // npx vitest core/tools/__tests__/useMcpToolTool.spec.ts -import { useMcpToolTool } from "../useMcpToolTool" +import { useMcpToolTool } from "../UseMcpToolTool" import { Task } from "../../task/Task" import { ToolUse } from "../../../shared/tools" @@ -85,14 +85,12 @@ describe("useMcpToolTool", () => { mockTask.sayAndCreateMissingParamError = vi.fn().mockResolvedValue("Missing server_name error") - await useMcpToolTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await useMcpToolTool.handle(mockTask as Task, block as any, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockTask.consecutiveMistakeCount).toBe(1) expect(mockTask.recordToolError).toHaveBeenCalledWith("use_mcp_tool") @@ -113,14 +111,12 @@ describe("useMcpToolTool", () => { mockTask.sayAndCreateMissingParamError = vi.fn().mockResolvedValue("Missing tool_name error") - await useMcpToolTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await useMcpToolTool.handle(mockTask as Task, block as any, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockTask.consecutiveMistakeCount).toBe(1) expect(mockTask.recordToolError).toHaveBeenCalledWith("use_mcp_tool") @@ -140,14 +136,28 @@ describe("useMcpToolTool", () => { partial: false, } - await useMcpToolTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + // Mock server exists so we get to the JSON validation step + const mockServers = [ + { + name: "test_server", + tools: [{ name: "test_tool", description: "Test Tool" }], + }, + ] + + mockProviderRef.deref.mockReturnValue({ + getMcpHub: () => ({ + getAllServers: vi.fn().mockReturnValue(mockServers), + callTool: vi.fn(), + }), + postMessageToWebview: vi.fn(), + }) + + await useMcpToolTool.handle(mockTask as Task, block as any, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockTask.consecutiveMistakeCount).toBe(1) expect(mockTask.recordToolError).toHaveBeenCalledWith("use_mcp_tool") @@ -171,14 +181,12 @@ describe("useMcpToolTool", () => { mockTask.ask = vi.fn().mockResolvedValue(true) - await useMcpToolTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await useMcpToolTool.handle(mockTask as Task, block as any, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockTask.ask).toHaveBeenCalledWith("use_mcp_server", expect.stringContaining("use_mcp_tool"), true) }) @@ -211,14 +219,12 @@ describe("useMcpToolTool", () => { postMessageToWebview: vi.fn(), }) - await useMcpToolTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await useMcpToolTool.handle(mockTask as Task, block as any, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockTask.consecutiveMistakeCount).toBe(0) expect(mockAskApproval).toHaveBeenCalled() @@ -245,14 +251,12 @@ describe("useMcpToolTool", () => { mockAskApproval.mockResolvedValue(false) - await useMcpToolTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await useMcpToolTool.handle(mockTask as Task, block as any, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockTask.say).not.toHaveBeenCalledWith("mcp_server_request_started") expect(mockPushToolResult).not.toHaveBeenCalled() @@ -287,14 +291,12 @@ describe("useMcpToolTool", () => { const error = new Error("Unexpected error") mockAskApproval.mockRejectedValue(error) - await useMcpToolTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await useMcpToolTool.handle(mockTask as Task, block as any, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockHandleError).toHaveBeenCalledWith("executing MCP tool", error) }) @@ -332,14 +334,12 @@ describe("useMcpToolTool", () => { partial: false, } - await useMcpToolTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await useMcpToolTool.handle(mockTask as Task, block as any, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockTask.consecutiveMistakeCount).toBe(1) expect(mockTask.recordToolError).toHaveBeenCalledWith("use_mcp_tool") @@ -379,14 +379,12 @@ describe("useMcpToolTool", () => { partial: false, } - await useMcpToolTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await useMcpToolTool.handle(mockTask as Task, block as any, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockTask.consecutiveMistakeCount).toBe(1) expect(mockTask.recordToolError).toHaveBeenCalledWith("use_mcp_tool") @@ -430,14 +428,12 @@ describe("useMcpToolTool", () => { mockAskApproval.mockResolvedValue(true) - await useMcpToolTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await useMcpToolTool.handle(mockTask as Task, block as any, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) expect(mockTask.consecutiveMistakeCount).toBe(0) expect(mockTask.recordToolError).not.toHaveBeenCalled() @@ -472,14 +468,12 @@ describe("useMcpToolTool", () => { } // Act - await useMcpToolTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await useMcpToolTool.handle(mockTask as Task, block as any, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) // Assert expect(mockTask.consecutiveMistakeCount).toBe(1) @@ -515,14 +509,12 @@ describe("useMcpToolTool", () => { } // Act - await useMcpToolTool( - mockTask as Task, - block, - mockAskApproval, - mockHandleError, - mockPushToolResult, - mockRemoveClosingTag, - ) + await useMcpToolTool.handle(mockTask as Task, block as any, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) // Assert expect(mockTask.consecutiveMistakeCount).toBe(1) diff --git a/src/core/tools/__tests__/writeToFileTool.spec.ts b/src/core/tools/__tests__/writeToFileTool.spec.ts index 78e60cbaa58..e96fff63565 100644 --- a/src/core/tools/__tests__/writeToFileTool.spec.ts +++ b/src/core/tools/__tests__/writeToFileTool.spec.ts @@ -9,7 +9,7 @@ import { getReadablePath } from "../../../utils/path" import { unescapeHtmlEntities } from "../../../utils/text-normalization" import { everyLineHasLineNumbers, stripLineNumbers } from "../../../integrations/misc/extract-text" import { ToolUse, ToolResponse } from "../../../shared/tools" -import { writeToFileTool } from "../writeToFileTool" +import { writeToFileTool } from "../WriteToFileTool" vi.mock("path", async () => { const originalPath = await vi.importActual("path") @@ -228,16 +228,16 @@ describe("writeToFileTool", () => { partial: isPartial, } - await writeToFileTool( - mockCline, - toolUse, - mockAskApproval, - mockHandleError, - (result: ToolResponse) => { - toolResult = result - }, - mockRemoveClosingTag, - ) + mockPushToolResult = vi.fn((result: ToolResponse) => { + toolResult = result + }) + + await writeToFileTool.handle(mockCline, toolUse as ToolUse<"write_to_file">, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + removeClosingTag: mockRemoveClosingTag, + }) return toolResult } @@ -412,8 +412,7 @@ describe("writeToFileTool", () => { await executeWriteFileTool({}, { isPartial: true }) - expect(mockHandleError).toHaveBeenCalledWith("writing file", expect.any(Error)) - expect(mockCline.diffViewProvider.reset).toHaveBeenCalled() + expect(mockHandleError).toHaveBeenCalledWith("handling partial write_to_file", expect.any(Error)) }) }) }) diff --git a/src/core/tools/askFollowupQuestionTool.ts b/src/core/tools/askFollowupQuestionTool.ts deleted file mode 100644 index e7369368873..00000000000 --- a/src/core/tools/askFollowupQuestionTool.ts +++ /dev/null @@ -1,89 +0,0 @@ -import { Task } from "../task/Task" -import { ToolUse, AskApproval, HandleError, PushToolResult, RemoveClosingTag } from "../../shared/tools" -import { formatResponse } from "../prompts/responses" -import { parseXml } from "../../utils/xml" - -export async function askFollowupQuestionTool( - cline: Task, - block: ToolUse, - askApproval: AskApproval, - handleError: HandleError, - pushToolResult: PushToolResult, - removeClosingTag: RemoveClosingTag, -) { - const question: string | undefined = block.params.question - const follow_up: string | undefined = block.params.follow_up - - try { - if (block.partial) { - await cline.ask("followup", removeClosingTag("question", question), block.partial).catch(() => {}) - return - } else { - if (!question) { - cline.consecutiveMistakeCount++ - cline.recordToolError("ask_followup_question") - pushToolResult(await cline.sayAndCreateMissingParamError("ask_followup_question", "question")) - return - } - - type Suggest = { answer: string; mode?: string } - - let follow_up_json = { - question, - suggest: [] as Suggest[], - } - - if (follow_up) { - // Define the actual structure returned by the XML parser - type ParsedSuggestion = string | { "#text": string; "@_mode"?: string } - - let parsedSuggest: { - suggest: ParsedSuggestion[] | ParsedSuggestion - } - - try { - parsedSuggest = parseXml(follow_up, ["suggest"]) as { - suggest: ParsedSuggestion[] | ParsedSuggestion - } - } catch (error) { - cline.consecutiveMistakeCount++ - cline.recordToolError("ask_followup_question") - await cline.say("error", `Failed to parse operations: ${error.message}`) - pushToolResult(formatResponse.toolError("Invalid operations xml format")) - return - } - - const rawSuggestions = Array.isArray(parsedSuggest?.suggest) - ? parsedSuggest.suggest - : [parsedSuggest?.suggest].filter((sug): sug is ParsedSuggestion => sug !== undefined) - - // Transform parsed XML to our Suggest format - const normalizedSuggest: Suggest[] = rawSuggestions.map((sug) => { - if (typeof sug === "string") { - // Simple string suggestion (no mode attribute) - return { answer: sug } - } else { - // XML object with text content and optional mode attribute - const result: Suggest = { answer: sug["#text"] } - if (sug["@_mode"]) { - result.mode = sug["@_mode"] - } - return result - } - }) - - follow_up_json.suggest = normalizedSuggest - } - - cline.consecutiveMistakeCount = 0 - const { text, images } = await cline.ask("followup", JSON.stringify(follow_up_json), false) - await cline.say("user_feedback", text ?? "", images) - pushToolResult(formatResponse.toolResult(`\n${text}\n`, images)) - - return - } - } catch (error) { - await handleError("asking question", error) - return - } -} diff --git a/src/core/tools/attemptCompletionTool.ts b/src/core/tools/attemptCompletionTool.ts deleted file mode 100644 index 5074d7f4e80..00000000000 --- a/src/core/tools/attemptCompletionTool.ts +++ /dev/null @@ -1,141 +0,0 @@ -import Anthropic from "@anthropic-ai/sdk" -import * as vscode from "vscode" - -import { RooCodeEventName } from "@roo-code/types" -import { TelemetryService } from "@roo-code/telemetry" - -import { Task } from "../task/Task" -import { - ToolResponse, - ToolUse, - AskApproval, - HandleError, - PushToolResult, - RemoveClosingTag, - ToolDescription, - AskFinishSubTaskApproval, -} from "../../shared/tools" -import { formatResponse } from "../prompts/responses" -import { Package } from "../../shared/package" - -export async function attemptCompletionTool( - cline: Task, - block: ToolUse, - askApproval: AskApproval, - handleError: HandleError, - pushToolResult: PushToolResult, - removeClosingTag: RemoveClosingTag, - toolDescription: ToolDescription, - askFinishSubTaskApproval: AskFinishSubTaskApproval, -) { - const result: string | undefined = block.params.result - const command: string | undefined = block.params.command - - // Get the setting for preventing completion with open todos from VSCode configuration - const preventCompletionWithOpenTodos = vscode.workspace - .getConfiguration(Package.name) - .get("preventCompletionWithOpenTodos", false) - - // Check if there are incomplete todos (only if the setting is enabled) - const hasIncompleteTodos = cline.todoList && cline.todoList.some((todo) => todo.status !== "completed") - - if (preventCompletionWithOpenTodos && hasIncompleteTodos) { - cline.consecutiveMistakeCount++ - cline.recordToolError("attempt_completion") - - pushToolResult( - formatResponse.toolError( - "Cannot complete task while there are incomplete todos. Please finish all todos before attempting completion.", - ), - ) - - return - } - - try { - const lastMessage = cline.clineMessages.at(-1) - - if (block.partial) { - if (command) { - // the attempt_completion text is done, now we're getting command - // remove the previous partial attempt_completion ask, replace with say, post state to webview, then stream command - - // const secondLastMessage = cline.clineMessages.at(-2) - if (lastMessage && lastMessage.ask === "command") { - // update command - await cline.ask("command", removeClosingTag("command", command), block.partial).catch(() => {}) - } else { - // last message is completion_result - // we have command string, which means we have the result as well, so finish it (doesnt have to exist yet) - await cline.say("completion_result", removeClosingTag("result", result), undefined, false) - - TelemetryService.instance.captureTaskCompleted(cline.taskId) - cline.emit(RooCodeEventName.TaskCompleted, cline.taskId, cline.getTokenUsage(), cline.toolUsage) - - await cline.ask("command", removeClosingTag("command", command), block.partial).catch(() => {}) - } - } else { - // No command, still outputting partial result - await cline.say("completion_result", removeClosingTag("result", result), undefined, block.partial) - } - return - } else { - if (!result) { - cline.consecutiveMistakeCount++ - cline.recordToolError("attempt_completion") - pushToolResult(await cline.sayAndCreateMissingParamError("attempt_completion", "result")) - return - } - - cline.consecutiveMistakeCount = 0 - - // Command execution is permanently disabled in attempt_completion - // Users must use execute_command tool separately before attempt_completion - await cline.say("completion_result", result, undefined, false) - TelemetryService.instance.captureTaskCompleted(cline.taskId) - cline.emit(RooCodeEventName.TaskCompleted, cline.taskId, cline.getTokenUsage(), cline.toolUsage) - - if (cline.parentTask) { - const didApprove = await askFinishSubTaskApproval() - - if (!didApprove) { - return - } - - // tell the provider to remove the current subtask and resume the previous task in the stack - await cline.providerRef.deref()?.finishSubTask(result) - return - } - - // We already sent completion_result says, an - // empty string asks relinquishes control over - // button and field. - const { response, text, images } = await cline.ask("completion_result", "", false) - - // Signals to recursive loop to stop (for now - // cline never happens since yesButtonClicked - // will trigger a new task). - if (response === "yesButtonClicked") { - pushToolResult("") - return - } - - await cline.say("user_feedback", text ?? "", images) - const toolResults: (Anthropic.TextBlockParam | Anthropic.ImageBlockParam)[] = [] - - toolResults.push({ - type: "text", - text: `The user has provided feedback on the results. Consider their input to continue the task, and then attempt completion again.\n\n${text}\n`, - }) - - toolResults.push(...formatResponse.imageBlocks(images)) - cline.userMessageContent.push({ type: "text", text: `${toolDescription()} Result:` }) - cline.userMessageContent.push(...toolResults) - - return - } - } catch (error) { - await handleError("inspecting site", error) - return - } -} diff --git a/src/core/tools/browserActionTool.ts b/src/core/tools/browserActionTool.ts deleted file mode 100644 index 13cb9b0ec26..00000000000 --- a/src/core/tools/browserActionTool.ts +++ /dev/null @@ -1,188 +0,0 @@ -import { Task } from "../task/Task" -import { ToolUse, AskApproval, HandleError, PushToolResult, RemoveClosingTag } from "../../shared/tools" -import { - BrowserAction, - BrowserActionResult, - browserActions, - ClineSayBrowserAction, -} from "../../shared/ExtensionMessage" -import { formatResponse } from "../prompts/responses" - -export async function browserActionTool( - cline: Task, - block: ToolUse, - askApproval: AskApproval, - handleError: HandleError, - pushToolResult: PushToolResult, - removeClosingTag: RemoveClosingTag, -) { - const action: BrowserAction | undefined = block.params.action as BrowserAction - const url: string | undefined = block.params.url - const coordinate: string | undefined = block.params.coordinate - const text: string | undefined = block.params.text - const size: string | undefined = block.params.size - - if (!action || !browserActions.includes(action)) { - // checking for action to ensure it is complete and valid - if (!block.partial) { - // if the block is complete and we don't have a valid action cline is a mistake - cline.consecutiveMistakeCount++ - cline.recordToolError("browser_action") - pushToolResult(await cline.sayAndCreateMissingParamError("browser_action", "action")) - await cline.browserSession.closeBrowser() - } - - return - } - - try { - if (block.partial) { - if (action === "launch") { - await cline.ask("browser_action_launch", removeClosingTag("url", url), block.partial).catch(() => {}) - } else { - await cline.say( - "browser_action", - JSON.stringify({ - action: action as BrowserAction, - coordinate: removeClosingTag("coordinate", coordinate), - text: removeClosingTag("text", text), - } satisfies ClineSayBrowserAction), - undefined, - block.partial, - ) - } - return - } else { - // Initialize with empty object to avoid "used before assigned" errors - let browserActionResult: BrowserActionResult = {} - - if (action === "launch") { - if (!url) { - cline.consecutiveMistakeCount++ - cline.recordToolError("browser_action") - pushToolResult(await cline.sayAndCreateMissingParamError("browser_action", "url")) - await cline.browserSession.closeBrowser() - return - } - - cline.consecutiveMistakeCount = 0 - const didApprove = await askApproval("browser_action_launch", url) - - if (!didApprove) { - return - } - - // NOTE: It's okay that we call cline message since the partial inspect_site is finished streaming. - // The only scenario we have to avoid is sending messages WHILE a partial message exists at the end of the messages array. - // For example the api_req_finished message would interfere with the partial message, so we needed to remove that. - // await cline.say("inspect_site_result", "") // No result, starts the loading spinner waiting for result - await cline.say("browser_action_result", "") // Starts loading spinner - await cline.browserSession.launchBrowser() - browserActionResult = await cline.browserSession.navigateToUrl(url) - } else { - if (action === "click" || action === "hover") { - if (!coordinate) { - cline.consecutiveMistakeCount++ - cline.recordToolError("browser_action") - pushToolResult(await cline.sayAndCreateMissingParamError("browser_action", "coordinate")) - await cline.browserSession.closeBrowser() - return // can't be within an inner switch - } - } - - if (action === "type") { - if (!text) { - cline.consecutiveMistakeCount++ - cline.recordToolError("browser_action") - pushToolResult(await cline.sayAndCreateMissingParamError("browser_action", "text")) - await cline.browserSession.closeBrowser() - return - } - } - - if (action === "resize") { - if (!size) { - cline.consecutiveMistakeCount++ - cline.recordToolError("browser_action") - pushToolResult(await cline.sayAndCreateMissingParamError("browser_action", "size")) - await cline.browserSession.closeBrowser() - return - } - } - - cline.consecutiveMistakeCount = 0 - - await cline.say( - "browser_action", - JSON.stringify({ - action: action as BrowserAction, - coordinate, - text, - } satisfies ClineSayBrowserAction), - undefined, - false, - ) - - switch (action) { - case "click": - browserActionResult = await cline.browserSession.click(coordinate!) - break - case "hover": - browserActionResult = await cline.browserSession.hover(coordinate!) - break - case "type": - browserActionResult = await cline.browserSession.type(text!) - break - case "scroll_down": - browserActionResult = await cline.browserSession.scrollDown() - break - case "scroll_up": - browserActionResult = await cline.browserSession.scrollUp() - break - case "resize": - browserActionResult = await cline.browserSession.resize(size!) - break - case "close": - browserActionResult = await cline.browserSession.closeBrowser() - break - } - } - - switch (action) { - case "launch": - case "click": - case "hover": - case "type": - case "scroll_down": - case "scroll_up": - case "resize": - await cline.say("browser_action_result", JSON.stringify(browserActionResult)) - - pushToolResult( - formatResponse.toolResult( - `The browser action has been executed. The console logs and screenshot have been captured for your analysis.\n\nConsole logs:\n${ - browserActionResult?.logs || "(No new logs)" - }\n\n(REMEMBER: if you need to proceed to using non-\`browser_action\` tools or launch a new browser, you MUST first close cline browser. For example, if after analyzing the logs and screenshot you need to edit a file, you must first close the browser before you can use the write_to_file tool.)`, - browserActionResult?.screenshot ? [browserActionResult.screenshot] : [], - ), - ) - - break - case "close": - pushToolResult( - formatResponse.toolResult( - `The browser has been closed. You may now proceed to using other tools.`, - ), - ) - - break - } - - return - } - } catch (error) { - await cline.browserSession.closeBrowser() // if any error occurs, the browser session is terminated - await handleError("executing browser action", error) - return - } -} diff --git a/src/core/tools/codebaseSearchTool.ts b/src/core/tools/codebaseSearchTool.ts deleted file mode 100644 index 700d1b7c7c5..00000000000 --- a/src/core/tools/codebaseSearchTool.ts +++ /dev/null @@ -1,144 +0,0 @@ -import * as vscode from "vscode" - -import { Task } from "../task/Task" -import { CodeIndexManager } from "../../services/code-index/manager" -import { getWorkspacePath } from "../../utils/path" -import { formatResponse } from "../prompts/responses" -import { VectorStoreSearchResult } from "../../services/code-index/interfaces" -import { AskApproval, HandleError, PushToolResult, RemoveClosingTag, ToolUse } from "../../shared/tools" -import path from "path" - -export async function codebaseSearchTool( - cline: Task, - block: ToolUse, - askApproval: AskApproval, - handleError: HandleError, - pushToolResult: PushToolResult, - removeClosingTag: RemoveClosingTag, -) { - const toolName = "codebase_search" - const workspacePath = (cline.cwd && cline.cwd.trim() !== '') ? cline.cwd : getWorkspacePath() - - if (!workspacePath) { - // This case should ideally not happen if Cline is initialized correctly - await handleError(toolName, new Error("Could not determine workspace path.")) - return - } - - // --- Parameter Extraction and Validation --- - let query: string | undefined = block.params.query - let directoryPrefix: string | undefined = block.params.path - - query = removeClosingTag("query", query) - - if (directoryPrefix) { - directoryPrefix = removeClosingTag("path", directoryPrefix) - directoryPrefix = path.normalize(directoryPrefix) - } - - const sharedMessageProps = { - tool: "codebaseSearch", - query: query, - path: directoryPrefix, - isOutsideWorkspace: false, - } - - if (block.partial) { - await cline.ask("tool", JSON.stringify(sharedMessageProps), block.partial).catch(() => {}) - return - } - - if (!query) { - cline.consecutiveMistakeCount++ - pushToolResult(await cline.sayAndCreateMissingParamError(toolName, "query")) - return - } - - const didApprove = await askApproval("tool", JSON.stringify(sharedMessageProps)) - if (!didApprove) { - pushToolResult(formatResponse.toolDenied()) - return - } - - cline.consecutiveMistakeCount = 0 - - // --- Core Logic --- - try { - const context = cline.providerRef.deref()?.context - if (!context) { - throw new Error("Extension context is not available.") - } - - const manager = CodeIndexManager.getInstance(context) - - if (!manager) { - throw new Error("CodeIndexManager is not available.") - } - - if (!manager.isFeatureEnabled) { - throw new Error("Code Indexing is disabled in the settings.") - } - if (!manager.isFeatureConfigured) { - throw new Error("Code Indexing is not configured (Missing OpenAI Key or Qdrant URL).") - } - - const searchResults: VectorStoreSearchResult[] = await manager.searchIndex(query, directoryPrefix) - - // 3. Format and push results - if (!searchResults || searchResults.length === 0) { - pushToolResult(`No relevant code snippets found for the query: "${query}"`) // Use simple string for no results - return - } - - const jsonResult = { - query, - results: [], - } as { - query: string - results: Array<{ - filePath: string - score: number - startLine: number - endLine: number - codeChunk: string - }> - } - - searchResults.forEach((result) => { - if (!result.payload) return - if (!("filePath" in result.payload)) return - - const relativePath = vscode.workspace.asRelativePath(result.payload.filePath, false) - - jsonResult.results.push({ - filePath: relativePath, - score: result.score, - startLine: result.payload.startLine, - endLine: result.payload.endLine, - codeChunk: result.payload.codeChunk.trim(), - }) - }) - - // Send results to UI - const payload = { tool: "codebaseSearch", content: jsonResult } - await cline.say("codebase_search_result", JSON.stringify(payload)) - - // Push results to AI - const output = `Query: ${query} -Results: - -${jsonResult.results - .map( - (result) => `File path: ${result.filePath} -Score: ${result.score} -Lines: ${result.startLine}-${result.endLine} -Code Chunk: ${result.codeChunk} -`, - ) - .join("\n")}` - - pushToolResult(output) - } catch (error: any) { - await handleError(toolName, error) // Use the standard error handler - } -} diff --git a/src/core/tools/fetchInstructionsTool.ts b/src/core/tools/fetchInstructionsTool.ts deleted file mode 100644 index 5325f98fbf4..00000000000 --- a/src/core/tools/fetchInstructionsTool.ts +++ /dev/null @@ -1,63 +0,0 @@ -import { Task } from "../task/Task" -import { fetchInstructions } from "../prompts/instructions/instructions" -import { ClineSayTool } from "../../shared/ExtensionMessage" -import { formatResponse } from "../prompts/responses" -import { ToolUse, AskApproval, HandleError, PushToolResult } from "../../shared/tools" - -export async function fetchInstructionsTool( - cline: Task, - block: ToolUse, - askApproval: AskApproval, - handleError: HandleError, - pushToolResult: PushToolResult, -) { - const task: string | undefined = block.params.task - const sharedMessageProps: ClineSayTool = { tool: "fetchInstructions", content: task } - - try { - if (block.partial) { - const partialMessage = JSON.stringify({ ...sharedMessageProps, content: undefined } satisfies ClineSayTool) - await cline.ask("tool", partialMessage, block.partial).catch(() => {}) - return - } else { - if (!task) { - cline.consecutiveMistakeCount++ - cline.recordToolError("fetch_instructions") - pushToolResult(await cline.sayAndCreateMissingParamError("fetch_instructions", "task")) - return - } - - cline.consecutiveMistakeCount = 0 - - const completeMessage = JSON.stringify({ ...sharedMessageProps, content: task } satisfies ClineSayTool) - const didApprove = await askApproval("tool", completeMessage) - - if (!didApprove) { - return - } - - // Bow fetch the content and provide it to the agent. - const provider = cline.providerRef.deref() - const mcpHub = provider?.getMcpHub() - - if (!mcpHub) { - throw new Error("MCP hub not available") - } - - const diffStrategy = cline.diffStrategy - const context = provider?.context - const content = await fetchInstructions(task, { mcpHub, diffStrategy, context }) - - if (!content) { - pushToolResult(formatResponse.toolError(`Invalid instructions request: ${task}`)) - return - } - - pushToolResult(content) - - return - } - } catch (error) { - await handleError("fetch instructions", error) - } -} diff --git a/src/core/tools/generateImageTool.ts b/src/core/tools/generateImageTool.ts deleted file mode 100644 index 88a02ac8212..00000000000 --- a/src/core/tools/generateImageTool.ts +++ /dev/null @@ -1,263 +0,0 @@ -import path from "path" -import fs from "fs/promises" -import * as vscode from "vscode" -import { Task } from "../task/Task" -import { formatResponse } from "../prompts/responses" -import { ToolUse, AskApproval, HandleError, PushToolResult, RemoveClosingTag } from "../../shared/tools" -import { fileExistsAtPath } from "../../utils/fs" -import { getReadablePath } from "../../utils/path" -import { isPathOutsideWorkspace } from "../../utils/pathUtils" -import { EXPERIMENT_IDS, experiments } from "../../shared/experiments" -import { OpenRouterHandler } from "../../api/providers/openrouter" - -// Hardcoded list of image generation models for now -const IMAGE_GENERATION_MODELS = ["google/gemini-2.5-flash-image", "openai/gpt-5-image", "openai/gpt-5-image-mini"] - -export async function generateImageTool( - cline: Task, - block: ToolUse, - askApproval: AskApproval, - handleError: HandleError, - pushToolResult: PushToolResult, - removeClosingTag: RemoveClosingTag, -) { - const prompt: string | undefined = block.params.prompt - const relPath: string | undefined = block.params.path - const inputImagePath: string | undefined = block.params.image - - // Check if the experiment is enabled - const provider = cline.providerRef.deref() - const state = await provider?.getState() - const isImageGenerationEnabled = experiments.isEnabled(state?.experiments ?? {}, EXPERIMENT_IDS.IMAGE_GENERATION) - - if (!isImageGenerationEnabled) { - pushToolResult( - formatResponse.toolError( - "Image generation is an experimental feature that must be enabled in settings. Please enable 'Image Generation' in the Experimental Settings section.", - ), - ) - return - } - - if (block.partial) { - return - } - - if (!prompt) { - cline.consecutiveMistakeCount++ - cline.recordToolError("generate_image") - pushToolResult(await cline.sayAndCreateMissingParamError("generate_image", "prompt")) - return - } - - if (!relPath) { - cline.consecutiveMistakeCount++ - cline.recordToolError("generate_image") - pushToolResult(await cline.sayAndCreateMissingParamError("generate_image", "path")) - return - } - - // Validate access permissions - const accessAllowed = cline.rooIgnoreController?.validateAccess(relPath) - if (!accessAllowed) { - await cline.say("rooignore_error", relPath) - pushToolResult(formatResponse.toolError(formatResponse.rooIgnoreError(relPath))) - return - } - - // If input image is provided, validate it exists and can be read - let inputImageData: string | undefined - if (inputImagePath) { - const inputImageFullPath = path.resolve(cline.cwd, inputImagePath) - - // Check if input image exists - const inputImageExists = await fileExistsAtPath(inputImageFullPath) - if (!inputImageExists) { - await cline.say("error", `Input image not found: ${getReadablePath(cline.cwd, inputImagePath)}`) - pushToolResult( - formatResponse.toolError(`Input image not found: ${getReadablePath(cline.cwd, inputImagePath)}`), - ) - return - } - - // Validate input image access permissions - const inputImageAccessAllowed = cline.rooIgnoreController?.validateAccess(inputImagePath) - if (!inputImageAccessAllowed) { - await cline.say("rooignore_error", inputImagePath) - pushToolResult(formatResponse.toolError(formatResponse.rooIgnoreError(inputImagePath))) - return - } - - // Read the input image file - try { - const imageBuffer = await fs.readFile(inputImageFullPath) - const imageExtension = path.extname(inputImageFullPath).toLowerCase().replace(".", "") - - // Validate image format - const supportedFormats = ["png", "jpg", "jpeg", "gif", "webp"] - if (!supportedFormats.includes(imageExtension)) { - await cline.say( - "error", - `Unsupported image format: ${imageExtension}. Supported formats: ${supportedFormats.join(", ")}`, - ) - pushToolResult( - formatResponse.toolError( - `Unsupported image format: ${imageExtension}. Supported formats: ${supportedFormats.join(", ")}`, - ), - ) - return - } - - // Convert to base64 data URL - const mimeType = imageExtension === "jpg" ? "jpeg" : imageExtension - inputImageData = `data:image/${mimeType};base64,${imageBuffer.toString("base64")}` - } catch (error) { - await cline.say( - "error", - `Failed to read input image: ${error instanceof Error ? error.message : "Unknown error"}`, - ) - pushToolResult( - formatResponse.toolError( - `Failed to read input image: ${error instanceof Error ? error.message : "Unknown error"}`, - ), - ) - return - } - } - - // Check if file is write-protected - const isWriteProtected = cline.rooProtectedController?.isWriteProtected(relPath) || false - - // Get OpenRouter API key from global settings (experimental image generation) - const openRouterApiKey = state?.openRouterImageApiKey - - if (!openRouterApiKey) { - await cline.say( - "error", - "OpenRouter API key is required for image generation. Please configure it in the Image Generation experimental settings.", - ) - pushToolResult( - formatResponse.toolError( - "OpenRouter API key is required for image generation. Please configure it in the Image Generation experimental settings.", - ), - ) - return - } - - // Get selected model from settings or use default - const selectedModel = state?.openRouterImageGenerationSelectedModel || IMAGE_GENERATION_MODELS[0] - - // Determine if the path is outside the workspace - const fullPath = path.resolve(cline.cwd, removeClosingTag("path", relPath)) - const isOutsideWorkspace = isPathOutsideWorkspace(fullPath) - - const sharedMessageProps = { - tool: "generateImage" as const, - path: getReadablePath(cline.cwd, removeClosingTag("path", relPath)), - content: prompt, - isOutsideWorkspace, - isProtected: isWriteProtected, - } - - try { - if (!block.partial) { - cline.consecutiveMistakeCount = 0 - - // Ask for approval before generating the image - const approvalMessage = JSON.stringify({ - ...sharedMessageProps, - content: prompt, - ...(inputImagePath && { inputImage: getReadablePath(cline.cwd, inputImagePath) }), - }) - - const didApprove = await askApproval("tool", approvalMessage, undefined, isWriteProtected) - - if (!didApprove) { - return - } - - // Create a temporary OpenRouter handler with minimal options - const openRouterHandler = new OpenRouterHandler({} as any) - - // Call the generateImage method with the explicit API key and optional input image - const result = await openRouterHandler.generateImage( - prompt, - selectedModel, - openRouterApiKey, - inputImageData, - ) - - if (!result.success) { - await cline.say("error", result.error || "Failed to generate image") - pushToolResult(formatResponse.toolError(result.error || "Failed to generate image")) - return - } - - if (!result.imageData) { - const errorMessage = "No image data received" - await cline.say("error", errorMessage) - pushToolResult(formatResponse.toolError(errorMessage)) - return - } - - // Extract base64 data from data URL - const base64Match = result.imageData.match(/^data:image\/(png|jpeg|jpg);base64,(.+)$/) - if (!base64Match) { - const errorMessage = "Invalid image format received" - await cline.say("error", errorMessage) - pushToolResult(formatResponse.toolError(errorMessage)) - return - } - - const imageFormat = base64Match[1] - const base64Data = base64Match[2] - - // Ensure the file has the correct extension - let finalPath = relPath - if (!finalPath.match(/\.(png|jpg|jpeg)$/i)) { - finalPath = `${finalPath}.${imageFormat === "jpeg" ? "jpg" : imageFormat}` - } - - // Convert base64 to buffer - const imageBuffer = Buffer.from(base64Data, "base64") - - // Create directory if it doesn't exist - const absolutePath = path.resolve(cline.cwd, finalPath) - const directory = path.dirname(absolutePath) - await fs.mkdir(directory, { recursive: true }) - - // Write the image file - await fs.writeFile(absolutePath, imageBuffer) - - // Track file creation - if (finalPath) { - await cline.fileContextTracker.trackFileContext(finalPath, "roo_edited") - } - - cline.didEditFile = true - - // Record successful tool usage - cline.recordToolUsage("generate_image") - - // Get the webview URI for the image - const provider = cline.providerRef.deref() - const fullImagePath = path.join(cline.cwd, finalPath) - - // Convert to webview URI if provider is available - let imageUri = provider?.convertToWebviewUri?.(fullImagePath) ?? vscode.Uri.file(fullImagePath).toString() - - // Add cache-busting parameter to prevent browser caching issues - const cacheBuster = Date.now() - imageUri = imageUri.includes("?") ? `${imageUri}&t=${cacheBuster}` : `${imageUri}?t=${cacheBuster}` - - // Send the image with the webview URI - await cline.say("image", JSON.stringify({ imageUri, imagePath: fullImagePath })) - pushToolResult(formatResponse.toolResult(getReadablePath(cline.cwd, finalPath))) - - return - } - } catch (error) { - await handleError("generating image", error) - return - } -} diff --git a/src/core/tools/insertContentTool.ts b/src/core/tools/insertContentTool.ts deleted file mode 100644 index 38ca309a3b3..00000000000 --- a/src/core/tools/insertContentTool.ts +++ /dev/null @@ -1,198 +0,0 @@ -import delay from "delay" -import fs from "fs/promises" -import path from "path" - -import { getReadablePath } from "../../utils/path" -import { Task } from "../task/Task" -import { ToolUse, AskApproval, HandleError, PushToolResult, RemoveClosingTag } from "../../shared/tools" -import { formatResponse } from "../prompts/responses" -import { ClineSayTool } from "../../shared/ExtensionMessage" -import { RecordSource } from "../context-tracking/FileContextTrackerTypes" -import { fileExistsAtPath } from "../../utils/fs" -import { insertGroups } from "../diff/insert-groups" -import { DEFAULT_WRITE_DELAY_MS } from "@roo-code/types" -import { EXPERIMENT_IDS, experiments } from "../../shared/experiments" -import { convertNewFileToUnifiedDiff, computeDiffStats, sanitizeUnifiedDiff } from "../diff/stats" - -export async function insertContentTool( - cline: Task, - block: ToolUse, - askApproval: AskApproval, - handleError: HandleError, - pushToolResult: PushToolResult, - removeClosingTag: RemoveClosingTag, -) { - const relPath: string | undefined = block.params.path - const line: string | undefined = block.params.line - const content: string | undefined = block.params.content - - const sharedMessageProps: ClineSayTool = { - tool: "insertContent", - path: getReadablePath(cline.cwd, removeClosingTag("path", relPath)), - diff: content, - lineNumber: line ? parseInt(line, 10) : undefined, - } - - try { - if (block.partial) { - await cline.ask("tool", JSON.stringify(sharedMessageProps), block.partial).catch(() => {}) - return - } - - // Validate required parameters - if (!relPath) { - cline.consecutiveMistakeCount++ - cline.recordToolError("insert_content") - pushToolResult(await cline.sayAndCreateMissingParamError("insert_content", "path")) - return - } - - if (!line) { - cline.consecutiveMistakeCount++ - cline.recordToolError("insert_content") - pushToolResult(await cline.sayAndCreateMissingParamError("insert_content", "line")) - return - } - - if (content === undefined) { - cline.consecutiveMistakeCount++ - cline.recordToolError("insert_content") - pushToolResult(await cline.sayAndCreateMissingParamError("insert_content", "content")) - return - } - - const accessAllowed = cline.rooIgnoreController?.validateAccess(relPath) - - if (!accessAllowed) { - await cline.say("rooignore_error", relPath) - pushToolResult(formatResponse.toolError(formatResponse.rooIgnoreError(relPath))) - return - } - - // Check if file is write-protected - const isWriteProtected = cline.rooProtectedController?.isWriteProtected(relPath) || false - - const absolutePath = path.resolve(cline.cwd, relPath) - const lineNumber = parseInt(line, 10) - if (isNaN(lineNumber) || lineNumber < 0) { - cline.consecutiveMistakeCount++ - cline.recordToolError("insert_content") - pushToolResult(formatResponse.toolError("Invalid line number. Must be a non-negative integer.")) - return - } - - const fileExists = await fileExistsAtPath(absolutePath) - let fileContent: string = "" - if (!fileExists) { - if (lineNumber > 1) { - cline.consecutiveMistakeCount++ - cline.recordToolError("insert_content") - const formattedError = `Cannot insert content at line ${lineNumber} into a non-existent file. For new files, 'line' must be 0 (to append) or 1 (to insert at the beginning).` - await cline.say("error", formattedError) - pushToolResult(formattedError) - return - } - } else { - fileContent = await fs.readFile(absolutePath, "utf8") - } - - cline.consecutiveMistakeCount = 0 - - cline.diffViewProvider.editType = fileExists ? "modify" : "create" - cline.diffViewProvider.originalContent = fileContent - const lines = fileExists ? fileContent.split("\n") : [] - - let updatedContent = insertGroups(lines, [ - { - index: lineNumber - 1, - elements: content.split("\n"), - }, - ]).join("\n") - - // Check if preventFocusDisruption experiment is enabled - const provider = cline.providerRef.deref() - const state = await provider?.getState() - const diagnosticsEnabled = state?.diagnosticsEnabled ?? true - const writeDelayMs = state?.writeDelayMs ?? DEFAULT_WRITE_DELAY_MS - const isPreventFocusDisruptionEnabled = experiments.isEnabled( - state?.experiments ?? {}, - EXPERIMENT_IDS.PREVENT_FOCUS_DISRUPTION, - ) - - // Build unified diff for display (normalize EOLs only for diff generation) - let unified: string - if (fileExists) { - const oldForDiff = fileContent.replace(/\r\n/g, "\n") - const newForDiff = updatedContent.replace(/\r\n/g, "\n") - unified = formatResponse.createPrettyPatch(relPath, oldForDiff, newForDiff) - if (!unified) { - pushToolResult(`No changes needed for '${relPath}'`) - return - } - } else { - const newForDiff = updatedContent.replace(/\r\n/g, "\n") - unified = convertNewFileToUnifiedDiff(newForDiff, relPath) - } - unified = sanitizeUnifiedDiff(unified) - const diffStats = computeDiffStats(unified) || undefined - - // Prepare the approval message (same for both flows) - const completeMessage = JSON.stringify({ - ...sharedMessageProps, - // Send unified diff as content for render-only webview - content: unified, - lineNumber: lineNumber, - isProtected: isWriteProtected, - diffStats, - } satisfies ClineSayTool) - - // Show diff view if focus disruption prevention is disabled - if (!isPreventFocusDisruptionEnabled) { - await cline.diffViewProvider.open(relPath) - await cline.diffViewProvider.update(updatedContent, true) - cline.diffViewProvider.scrollToFirstDiff() - } - - // Ask for approval (same for both flows) - const didApprove = await askApproval("tool", completeMessage, undefined, isWriteProtected) - - if (!didApprove) { - // Revert changes if diff view was shown - if (!isPreventFocusDisruptionEnabled) { - await cline.diffViewProvider.revertChanges() - } - pushToolResult("Changes were rejected by the user.") - await cline.diffViewProvider.reset() - return - } - - // Save the changes - if (isPreventFocusDisruptionEnabled) { - // Direct file write without diff view or opening the file - await cline.diffViewProvider.saveDirectly(relPath, updatedContent, false, diagnosticsEnabled, writeDelayMs) - } else { - // Call saveChanges to update the DiffViewProvider properties - await cline.diffViewProvider.saveChanges(diagnosticsEnabled, writeDelayMs) - } - - // Track file edit operation - if (relPath) { - await cline.fileContextTracker.trackFileContext(relPath, "roo_edited" as RecordSource) - } - - cline.didEditFile = true - - // Get the formatted response message - const message = await cline.diffViewProvider.pushToolWriteResult(cline, cline.cwd, !fileExists) - - pushToolResult(message) - - await cline.diffViewProvider.reset() - - // Process any queued messages after file edit completes - cline.processQueuedMessages() - } catch (error) { - handleError("insert content", error) - await cline.diffViewProvider.reset() - } -} diff --git a/src/core/tools/listCodeDefinitionNamesTool.ts b/src/core/tools/listCodeDefinitionNamesTool.ts deleted file mode 100644 index 0ec80ce9bd0..00000000000 --- a/src/core/tools/listCodeDefinitionNamesTool.ts +++ /dev/null @@ -1,90 +0,0 @@ -import path from "path" -import fs from "fs/promises" - -import { ToolUse, AskApproval, HandleError, PushToolResult, RemoveClosingTag } from "../../shared/tools" -import { Task } from "../task/Task" -import { ClineSayTool } from "../../shared/ExtensionMessage" -import { getReadablePath } from "../../utils/path" -import { isPathOutsideWorkspace } from "../../utils/pathUtils" -import { parseSourceCodeForDefinitionsTopLevel, parseSourceCodeDefinitionsForFile } from "../../services/tree-sitter" -import { RecordSource } from "../context-tracking/FileContextTrackerTypes" -import { truncateDefinitionsToLineLimit } from "./helpers/truncateDefinitions" - -export async function listCodeDefinitionNamesTool( - cline: Task, - block: ToolUse, - askApproval: AskApproval, - handleError: HandleError, - pushToolResult: PushToolResult, - removeClosingTag: RemoveClosingTag, -) { - const relPath: string | undefined = block.params.path - - // Calculate if the path is outside workspace - const absolutePath = relPath ? path.resolve(cline.cwd, relPath) : cline.cwd - const isOutsideWorkspace = isPathOutsideWorkspace(absolutePath) - - const sharedMessageProps: ClineSayTool = { - tool: "listCodeDefinitionNames", - path: getReadablePath(cline.cwd, removeClosingTag("path", relPath)), - isOutsideWorkspace, - } - - try { - if (block.partial) { - const partialMessage = JSON.stringify({ ...sharedMessageProps, content: "" } satisfies ClineSayTool) - await cline.ask("tool", partialMessage, block.partial).catch(() => {}) - return - } else { - if (!relPath) { - cline.consecutiveMistakeCount++ - cline.recordToolError("list_code_definition_names") - pushToolResult(await cline.sayAndCreateMissingParamError("list_code_definition_names", "path")) - return - } - - cline.consecutiveMistakeCount = 0 - - let result: string - - try { - const stats = await fs.stat(absolutePath) - - if (stats.isFile()) { - const fileResult = await parseSourceCodeDefinitionsForFile(absolutePath, cline.rooIgnoreController) - - // Apply truncation based on maxReadFileLine setting - if (fileResult) { - const { maxReadFileLine = -1 } = (await cline.providerRef.deref()?.getState()) ?? {} - result = truncateDefinitionsToLineLimit(fileResult, maxReadFileLine) - } else { - result = "No source code definitions found in file." - } - } else if (stats.isDirectory()) { - result = await parseSourceCodeForDefinitionsTopLevel(absolutePath, cline.rooIgnoreController) - } else { - result = "The specified path is neither a file nor a directory." - } - } catch { - result = `${absolutePath}: does not exist or cannot be accessed.` - } - - const completeMessage = JSON.stringify({ ...sharedMessageProps, content: result } satisfies ClineSayTool) - const didApprove = await askApproval("tool", completeMessage) - - if (!didApprove) { - return - } - - if (relPath) { - await cline.fileContextTracker.trackFileContext(relPath, "read_tool" as RecordSource) - } - - pushToolResult(result) - return - } - } catch (error) { - await handleError("parsing source code definitions", error) - return - } -} diff --git a/src/core/tools/listFilesTool.ts b/src/core/tools/listFilesTool.ts deleted file mode 100644 index e51453c5d9e..00000000000 --- a/src/core/tools/listFilesTool.ts +++ /dev/null @@ -1,87 +0,0 @@ -import * as path from "path" - -import { Task } from "../task/Task" -import { ClineSayTool } from "../../shared/ExtensionMessage" -import { formatResponse } from "../prompts/responses" -import { listFiles } from "../../services/glob/list-files" -import { getReadablePath } from "../../utils/path" -import { isPathOutsideWorkspace } from "../../utils/pathUtils" -import { ToolUse, AskApproval, HandleError, PushToolResult, RemoveClosingTag } from "../../shared/tools" - -/** - * Implements the list_files tool. - * - * @param cline - The instance of Cline that is executing this tool. - * @param block - The block of assistant message content that specifies the - * parameters for this tool. - * @param askApproval - A function that asks the user for approval to show a - * message. - * @param handleError - A function that handles an error that occurred while - * executing this tool. - * @param pushToolResult - A function that pushes the result of this tool to the - * conversation. - * @param removeClosingTag - A function that removes a closing tag from a string. - */ - -export async function listFilesTool( - cline: Task, - block: ToolUse, - askApproval: AskApproval, - handleError: HandleError, - pushToolResult: PushToolResult, - removeClosingTag: RemoveClosingTag, -) { - const relDirPath: string | undefined = block.params.path - const recursiveRaw: string | undefined = block.params.recursive - const recursive = recursiveRaw?.toLowerCase() === "true" - - // Calculate if the path is outside workspace - const absolutePath = relDirPath ? path.resolve(cline.cwd, relDirPath) : cline.cwd - const isOutsideWorkspace = isPathOutsideWorkspace(absolutePath) - - const sharedMessageProps: ClineSayTool = { - tool: !recursive ? "listFilesTopLevel" : "listFilesRecursive", - path: getReadablePath(cline.cwd, removeClosingTag("path", relDirPath)), - isOutsideWorkspace, - } - - try { - if (block.partial) { - const partialMessage = JSON.stringify({ ...sharedMessageProps, content: "" } satisfies ClineSayTool) - await cline.ask("tool", partialMessage, block.partial).catch(() => {}) - return - } else { - if (!relDirPath) { - cline.consecutiveMistakeCount++ - cline.recordToolError("list_files") - pushToolResult(await cline.sayAndCreateMissingParamError("list_files", "path")) - return - } - - cline.consecutiveMistakeCount = 0 - - const [files, didHitLimit] = await listFiles(absolutePath, recursive, 200) - const { showRooIgnoredFiles = false } = (await cline.providerRef.deref()?.getState()) ?? {} - - const result = formatResponse.formatFilesList( - absolutePath, - files, - didHitLimit, - cline.rooIgnoreController, - showRooIgnoredFiles, - cline.rooProtectedController, - ) - - const completeMessage = JSON.stringify({ ...sharedMessageProps, content: result } satisfies ClineSayTool) - const didApprove = await askApproval("tool", completeMessage) - - if (!didApprove) { - return - } - - pushToolResult(result) - } - } catch (error) { - await handleError("listing files", error) - } -} diff --git a/src/core/tools/readFileTool.ts b/src/core/tools/readFileTool.ts deleted file mode 100644 index 53f0643dbb4..00000000000 --- a/src/core/tools/readFileTool.ts +++ /dev/null @@ -1,749 +0,0 @@ -import path from "path" -import { isBinaryFile } from "isbinaryfile" - -import { Task } from "../task/Task" -import { ClineSayTool } from "../../shared/ExtensionMessage" -import { formatResponse } from "../prompts/responses" -import { t } from "../../i18n" -import { ToolUse, AskApproval, HandleError, PushToolResult, RemoveClosingTag } from "../../shared/tools" -import { RecordSource } from "../context-tracking/FileContextTrackerTypes" -import { isPathOutsideWorkspace } from "../../utils/pathUtils" -import { getReadablePath } from "../../utils/path" -import { countFileLines } from "../../integrations/misc/line-counter" -import { readLines } from "../../integrations/misc/read-lines" -import { extractTextFromFile, addLineNumbers, getSupportedBinaryFormats } from "../../integrations/misc/extract-text" -import { parseSourceCodeDefinitionsForFile } from "../../services/tree-sitter" -import { parseXml } from "../../utils/xml" -import { - DEFAULT_MAX_IMAGE_FILE_SIZE_MB, - DEFAULT_MAX_TOTAL_IMAGE_SIZE_MB, - isSupportedImageFormat, - validateImageForProcessing, - processImageFile, - ImageMemoryTracker, -} from "./helpers/imageHelpers" -import { validateFileTokenBudget, truncateFileContent } from "./helpers/fileTokenBudget" -import { truncateDefinitionsToLineLimit } from "./helpers/truncateDefinitions" - -export function getReadFileToolDescription(blockName: string, blockParams: any): string { - // Handle both single path and multiple files via args - if (blockParams.args) { - try { - const parsed = parseXml(blockParams.args) as any - const files = Array.isArray(parsed.file) ? parsed.file : [parsed.file].filter(Boolean) - const paths = files.map((f: any) => f?.path).filter(Boolean) as string[] - - if (paths.length === 0) { - return `[${blockName} with no valid paths]` - } else if (paths.length === 1) { - // Modified part for single file - return `[${blockName} for '${paths[0]}'. Reading multiple files at once is more efficient for the LLM. If other files are relevant to your current task, please read them simultaneously.]` - } else if (paths.length <= 3) { - const pathList = paths.map((p) => `'${p}'`).join(", ") - return `[${blockName} for ${pathList}]` - } else { - return `[${blockName} for ${paths.length} files]` - } - } catch (error) { - console.error("Failed to parse read_file args XML for description:", error) - return `[${blockName} with unparsable args]` - } - } else if (blockParams.path) { - // Fallback for legacy single-path usage - // Modified part for single file (legacy) - return `[${blockName} for '${blockParams.path}'. Reading multiple files at once is more efficient for the LLM. If other files are relevant to your current task, please read them simultaneously.]` - } else { - return `[${blockName} with missing path/args]` - } -} -// Types -interface LineRange { - start: number - end: number -} - -interface FileEntry { - path?: string - lineRanges?: LineRange[] -} - -// New interface to track file processing state -interface FileResult { - path: string - status: "approved" | "denied" | "blocked" | "error" | "pending" - content?: string - error?: string - notice?: string - lineRanges?: LineRange[] - xmlContent?: string // Final XML content for this file - imageDataUrl?: string // Image data URL for image files - feedbackText?: string // User feedback text from approval/denial - feedbackImages?: any[] // User feedback images from approval/denial -} - -export async function readFileTool( - cline: Task, - block: ToolUse, - askApproval: AskApproval, - handleError: HandleError, - pushToolResult: PushToolResult, - _removeClosingTag: RemoveClosingTag, -) { - const argsXmlTag: string | undefined = block.params.args - const legacyPath: string | undefined = block.params.path - const legacyStartLineStr: string | undefined = block.params.start_line - const legacyEndLineStr: string | undefined = block.params.end_line - - // Check if the current model supports images at the beginning - const modelInfo = cline.api.getModel().info - const supportsImages = modelInfo.supportsImages ?? false - - // Handle partial message first - if (block.partial) { - let filePath = "" - // Prioritize args for partial, then legacy path - if (argsXmlTag) { - const match = argsXmlTag.match(/.*?([^<]+)<\/path>/s) - if (match) filePath = match[1] - } - if (!filePath && legacyPath) { - // If args didn't yield a path, try legacy - filePath = legacyPath - } - - const fullPath = filePath ? path.resolve(cline.cwd, filePath) : "" - const sharedMessageProps: ClineSayTool = { - tool: "readFile", - path: getReadablePath(cline.cwd, filePath), - isOutsideWorkspace: filePath ? isPathOutsideWorkspace(fullPath) : false, - } - const partialMessage = JSON.stringify({ - ...sharedMessageProps, - content: undefined, - } satisfies ClineSayTool) - await cline.ask("tool", partialMessage, block.partial).catch(() => {}) - return - } - - const fileEntries: FileEntry[] = [] - - if (argsXmlTag) { - // Parse file entries from XML (new multi-file format) - try { - const parsed = parseXml(argsXmlTag) as any - const files = Array.isArray(parsed.file) ? parsed.file : [parsed.file].filter(Boolean) - - for (const file of files) { - if (!file.path) continue // Skip if no path in a file entry - - const fileEntry: FileEntry = { - path: file.path, - lineRanges: [], - } - - if (file.line_range) { - const ranges = Array.isArray(file.line_range) ? file.line_range : [file.line_range] - for (const range of ranges) { - const match = String(range).match(/(\d+)-(\d+)/) // Ensure range is treated as string - if (match) { - const [, start, end] = match.map(Number) - if (!isNaN(start) && !isNaN(end)) { - fileEntry.lineRanges?.push({ start, end }) - } - } - } - } - fileEntries.push(fileEntry) - } - } catch (error) { - const errorMessage = `Failed to parse read_file XML args: ${error instanceof Error ? error.message : String(error)}` - await handleError("parsing read_file args", new Error(errorMessage)) - pushToolResult(`${errorMessage}`) - return - } - } else if (legacyPath) { - // Handle legacy single file path as a fallback - console.warn("[readFileTool] Received legacy 'path' parameter. Consider updating to use 'args' structure.") - - const fileEntry: FileEntry = { - path: legacyPath, - lineRanges: [], - } - - if (legacyStartLineStr && legacyEndLineStr) { - const start = parseInt(legacyStartLineStr, 10) - const end = parseInt(legacyEndLineStr, 10) - if (!isNaN(start) && !isNaN(end) && start > 0 && end > 0) { - fileEntry.lineRanges?.push({ start, end }) - } else { - console.warn( - `[readFileTool] Invalid legacy line range for ${legacyPath}: start='${legacyStartLineStr}', end='${legacyEndLineStr}'`, - ) - } - } - fileEntries.push(fileEntry) - } - - // If, after trying both new and legacy, no valid file entries are found. - if (fileEntries.length === 0) { - cline.consecutiveMistakeCount++ - cline.recordToolError("read_file") - const errorMsg = await cline.sayAndCreateMissingParamError("read_file", "args (containing valid file paths)") - pushToolResult(`${errorMsg}`) - return - } - - // Create an array to track the state of each file - const fileResults: FileResult[] = fileEntries.map((entry) => ({ - path: entry.path || "", - status: "pending", - lineRanges: entry.lineRanges, - })) - - // Function to update file result status - const updateFileResult = (path: string, updates: Partial) => { - const index = fileResults.findIndex((result) => result.path === path) - if (index !== -1) { - fileResults[index] = { ...fileResults[index], ...updates } - } - } - - try { - // First validate all files and prepare for batch approval - const filesToApprove: FileResult[] = [] - - for (let i = 0; i < fileResults.length; i++) { - const fileResult = fileResults[i] - const relPath = fileResult.path - const fullPath = path.resolve(cline.cwd, relPath) - - // Validate line ranges first - if (fileResult.lineRanges) { - let hasRangeError = false - for (const range of fileResult.lineRanges) { - if (range.start > range.end) { - const errorMsg = "Invalid line range: end line cannot be less than start line" - updateFileResult(relPath, { - status: "blocked", - error: errorMsg, - xmlContent: `${relPath}Error reading file: ${errorMsg}`, - }) - await handleError(`reading file ${relPath}`, new Error(errorMsg)) - hasRangeError = true - break - } - if (isNaN(range.start) || isNaN(range.end)) { - const errorMsg = "Invalid line range values" - updateFileResult(relPath, { - status: "blocked", - error: errorMsg, - xmlContent: `${relPath}Error reading file: ${errorMsg}`, - }) - await handleError(`reading file ${relPath}`, new Error(errorMsg)) - hasRangeError = true - break - } - } - if (hasRangeError) continue - } - - // Then check RooIgnore validation - if (fileResult.status === "pending") { - const accessAllowed = cline.rooIgnoreController?.validateAccess(relPath) - if (!accessAllowed) { - await cline.say("rooignore_error", relPath) - const errorMsg = formatResponse.rooIgnoreError(relPath) - updateFileResult(relPath, { - status: "blocked", - error: errorMsg, - xmlContent: `${relPath}${errorMsg}`, - }) - continue - } - - // Add to files that need approval - filesToApprove.push(fileResult) - } - } - - // Handle batch approval if there are multiple files to approve - if (filesToApprove.length > 1) { - const { maxReadFileLine = -1 } = (await cline.providerRef.deref()?.getState()) ?? {} - - // Prepare batch file data - const batchFiles = filesToApprove.map((fileResult) => { - const relPath = fileResult.path - const fullPath = path.resolve(cline.cwd, relPath) - const isOutsideWorkspace = isPathOutsideWorkspace(fullPath) - - // Create line snippet for this file - let lineSnippet = "" - if (fileResult.lineRanges && fileResult.lineRanges.length > 0) { - const ranges = fileResult.lineRanges.map((range) => - t("tools:readFile.linesRange", { start: range.start, end: range.end }), - ) - lineSnippet = ranges.join(", ") - } else if (maxReadFileLine === 0) { - lineSnippet = t("tools:readFile.definitionsOnly") - } else if (maxReadFileLine > 0) { - lineSnippet = t("tools:readFile.maxLines", { max: maxReadFileLine }) - } - - const readablePath = getReadablePath(cline.cwd, relPath) - const key = `${readablePath}${lineSnippet ? ` (${lineSnippet})` : ""}` - - return { - path: readablePath, - lineSnippet, - isOutsideWorkspace, - key, - content: fullPath, // Include full path for content - } - }) - - const completeMessage = JSON.stringify({ - tool: "readFile", - batchFiles, - } satisfies ClineSayTool) - - const { response, text, images } = await cline.ask("tool", completeMessage, false) - - // Process batch response - if (response === "yesButtonClicked") { - // Approve all files - if (text) { - await cline.say("user_feedback", text, images) - } - filesToApprove.forEach((fileResult) => { - updateFileResult(fileResult.path, { - status: "approved", - feedbackText: text, - feedbackImages: images, - }) - }) - } else if (response === "noButtonClicked") { - // Deny all files - if (text) { - await cline.say("user_feedback", text, images) - } - cline.didRejectTool = true - filesToApprove.forEach((fileResult) => { - updateFileResult(fileResult.path, { - status: "denied", - xmlContent: `${fileResult.path}Denied by user`, - feedbackText: text, - feedbackImages: images, - }) - }) - } else { - // Handle individual permissions from objectResponse - // if (text) { - // await cline.say("user_feedback", text, images) - // } - - try { - const individualPermissions = JSON.parse(text || "{}") - let hasAnyDenial = false - - batchFiles.forEach((batchFile, index) => { - const fileResult = filesToApprove[index] - const approved = individualPermissions[batchFile.key] === true - - if (approved) { - updateFileResult(fileResult.path, { - status: "approved", - }) - } else { - hasAnyDenial = true - updateFileResult(fileResult.path, { - status: "denied", - xmlContent: `${fileResult.path}Denied by user`, - }) - } - }) - - if (hasAnyDenial) { - cline.didRejectTool = true - } - } catch (error) { - // Fallback: if JSON parsing fails, deny all files - console.error("Failed to parse individual permissions:", error) - cline.didRejectTool = true - filesToApprove.forEach((fileResult) => { - updateFileResult(fileResult.path, { - status: "denied", - xmlContent: `${fileResult.path}Denied by user`, - }) - }) - } - } - } else if (filesToApprove.length === 1) { - // Handle single file approval (existing logic) - const fileResult = filesToApprove[0] - const relPath = fileResult.path - const fullPath = path.resolve(cline.cwd, relPath) - const isOutsideWorkspace = isPathOutsideWorkspace(fullPath) - const { maxReadFileLine = -1 } = (await cline.providerRef.deref()?.getState()) ?? {} - - // Create line snippet for approval message - let lineSnippet = "" - if (fileResult.lineRanges && fileResult.lineRanges.length > 0) { - const ranges = fileResult.lineRanges.map((range) => - t("tools:readFile.linesRange", { start: range.start, end: range.end }), - ) - lineSnippet = ranges.join(", ") - } else if (maxReadFileLine === 0) { - lineSnippet = t("tools:readFile.definitionsOnly") - } else if (maxReadFileLine > 0) { - lineSnippet = t("tools:readFile.maxLines", { max: maxReadFileLine }) - } - - const completeMessage = JSON.stringify({ - tool: "readFile", - path: getReadablePath(cline.cwd, relPath), - isOutsideWorkspace, - content: fullPath, - reason: lineSnippet, - } satisfies ClineSayTool) - - const { response, text, images } = await cline.ask("tool", completeMessage, false) - - if (response !== "yesButtonClicked") { - // Handle both messageResponse and noButtonClicked with text - if (text) { - await cline.say("user_feedback", text, images) - } - cline.didRejectTool = true - - updateFileResult(relPath, { - status: "denied", - xmlContent: `${relPath}Denied by user`, - feedbackText: text, - feedbackImages: images, - }) - } else { - // Handle yesButtonClicked with text - if (text) { - await cline.say("user_feedback", text, images) - } - - updateFileResult(relPath, { - status: "approved", - feedbackText: text, - feedbackImages: images, - }) - } - } - - // Track total image memory usage across all files - const imageMemoryTracker = new ImageMemoryTracker() - const state = await cline.providerRef.deref()?.getState() - const { - maxReadFileLine = -1, - maxImageFileSize = DEFAULT_MAX_IMAGE_FILE_SIZE_MB, - maxTotalImageSize = DEFAULT_MAX_TOTAL_IMAGE_SIZE_MB, - } = state ?? {} - - // Then process only approved files - for (const fileResult of fileResults) { - // Skip files that weren't approved - if (fileResult.status !== "approved") { - continue - } - - const relPath = fileResult.path - const fullPath = path.resolve(cline.cwd, relPath) - - // Process approved files - try { - const [totalLines, isBinary] = await Promise.all([countFileLines(fullPath), isBinaryFile(fullPath)]) - - // Handle binary files (but allow specific file types that extractTextFromFile can handle) - if (isBinary) { - const fileExtension = path.extname(relPath).toLowerCase() - const supportedBinaryFormats = getSupportedBinaryFormats() - - // Check if it's a supported image format - if (isSupportedImageFormat(fileExtension)) { - try { - // Validate image for processing - const validationResult = await validateImageForProcessing( - fullPath, - supportsImages, - maxImageFileSize, - maxTotalImageSize, - imageMemoryTracker.getTotalMemoryUsed(), - ) - - if (!validationResult.isValid) { - // Track file read - await cline.fileContextTracker.trackFileContext(relPath, "read_tool" as RecordSource) - - updateFileResult(relPath, { - xmlContent: `${relPath}\n${validationResult.notice}\n`, - }) - continue - } - - // Process the image - const imageResult = await processImageFile(fullPath) - - // Track memory usage for this image - imageMemoryTracker.addMemoryUsage(imageResult.sizeInMB) - - // Track file read - await cline.fileContextTracker.trackFileContext(relPath, "read_tool" as RecordSource) - - // Store image data URL separately - NOT in XML - updateFileResult(relPath, { - xmlContent: `${relPath}\n${imageResult.notice}\n`, - imageDataUrl: imageResult.dataUrl, - }) - continue - } catch (error) { - const errorMsg = error instanceof Error ? error.message : String(error) - updateFileResult(relPath, { - status: "error", - error: `Error reading image file: ${errorMsg}`, - xmlContent: `${relPath}Error reading image file: ${errorMsg}`, - }) - await handleError( - `reading image file ${relPath}`, - error instanceof Error ? error : new Error(errorMsg), - ) - continue - } - } - - // Check if it's a supported binary format that can be processed - if (supportedBinaryFormats && supportedBinaryFormats.includes(fileExtension)) { - // For supported binary formats (.pdf, .docx, .ipynb), continue to extractTextFromFile - // Fall through to the normal extractTextFromFile processing below - } else { - // Handle unknown binary format - const fileFormat = fileExtension.slice(1) || "bin" // Remove the dot, fallback to "bin" - updateFileResult(relPath, { - notice: `Binary file format: ${fileFormat}`, - xmlContent: `${relPath}\nBinary file - content not displayed\n`, - }) - continue - } - } - - // Handle range reads (bypass maxReadFileLine) - if (fileResult.lineRanges && fileResult.lineRanges.length > 0) { - const rangeResults: string[] = [] - for (const range of fileResult.lineRanges) { - const content = addLineNumbers( - await readLines(fullPath, range.end - 1, range.start - 1), - range.start, - ) - const lineRangeAttr = ` lines="${range.start}-${range.end}"` - rangeResults.push(`\n${content}`) - } - updateFileResult(relPath, { - xmlContent: `${relPath}\n${rangeResults.join("\n")}\n`, - }) - continue - } - - // Handle definitions-only mode - if (maxReadFileLine === 0) { - try { - const defResult = await parseSourceCodeDefinitionsForFile(fullPath, cline.rooIgnoreController) - if (defResult) { - let xmlInfo = `Showing only ${maxReadFileLine} of ${totalLines} total lines. Use line_range if you need to read more lines\n` - updateFileResult(relPath, { - xmlContent: `${relPath}\n${defResult}\n${xmlInfo}`, - }) - } - } catch (error) { - if (error instanceof Error && error.message.startsWith("Unsupported language:")) { - console.warn(`[read_file] Warning: ${error.message}`) - } else { - console.error( - `[read_file] Unhandled error: ${error instanceof Error ? error.message : String(error)}`, - ) - } - } - continue - } - - // Handle files exceeding line threshold - if (maxReadFileLine > 0 && totalLines > maxReadFileLine) { - const content = addLineNumbers(await readLines(fullPath, maxReadFileLine - 1, 0)) - const lineRangeAttr = ` lines="1-${maxReadFileLine}"` - let xmlInfo = `\n${content}\n` - - try { - const defResult = await parseSourceCodeDefinitionsForFile(fullPath, cline.rooIgnoreController) - if (defResult) { - // Truncate definitions to match the truncated file content - const truncatedDefs = truncateDefinitionsToLineLimit(defResult, maxReadFileLine) - xmlInfo += `${truncatedDefs}\n` - } - xmlInfo += `Showing only ${maxReadFileLine} of ${totalLines} total lines. Use line_range if you need to read more lines\n` - updateFileResult(relPath, { - xmlContent: `${relPath}\n${xmlInfo}`, - }) - } catch (error) { - if (error instanceof Error && error.message.startsWith("Unsupported language:")) { - console.warn(`[read_file] Warning: ${error.message}`) - } else { - console.error( - `[read_file] Unhandled error: ${error instanceof Error ? error.message : String(error)}`, - ) - } - } - continue - } - - // Handle normal file read with token budget validation - const modelInfo = cline.api.getModel().info - const { contextTokens } = cline.getTokenUsage() - const contextWindow = modelInfo.contextWindow - - // Validate if file fits within token budget - const budgetResult = await validateFileTokenBudget(fullPath, contextWindow, contextTokens || 0) - - let content = await extractTextFromFile(fullPath) - let xmlInfo = "" - - if (budgetResult.shouldTruncate && budgetResult.maxChars !== undefined) { - // Truncate the content to fit budget or show preview for large files - const truncateResult = truncateFileContent( - content, - budgetResult.maxChars, - content.length, - budgetResult.isPreview, - ) - content = truncateResult.content - - // Reflect actual displayed line count after truncation (count ALL lines, including empty) - // Handle trailing newline: "line1\nline2\n" should be 2 lines, not 3 - let displayedLines = content.length === 0 ? 0 : content.split(/\r?\n/).length - if (displayedLines > 0 && content.endsWith("\n")) { - displayedLines-- - } - const lineRangeAttr = displayedLines > 0 ? ` lines="1-${displayedLines}"` : "" - xmlInfo = content.length > 0 ? `\n${content}\n` : `` - xmlInfo += `${truncateResult.notice}\n` - } else { - const lineRangeAttr = ` lines="1-${totalLines}"` - xmlInfo = totalLines > 0 ? `\n${content}\n` : `` - - if (totalLines === 0) { - xmlInfo += `File is empty\n` - } - } - - // Track file read - await cline.fileContextTracker.trackFileContext(relPath, "read_tool" as RecordSource) - - updateFileResult(relPath, { - xmlContent: `${relPath}\n${xmlInfo}`, - }) - } catch (error) { - const errorMsg = error instanceof Error ? error.message : String(error) - updateFileResult(relPath, { - status: "error", - error: `Error reading file: ${errorMsg}`, - xmlContent: `${relPath}Error reading file: ${errorMsg}`, - }) - await handleError(`reading file ${relPath}`, error instanceof Error ? error : new Error(errorMsg)) - } - } - - // Generate final XML result from all file results - const xmlResults = fileResults.filter((result) => result.xmlContent).map((result) => result.xmlContent) - const filesXml = `\n${xmlResults.join("\n")}\n` - - // Collect all image data URLs from file results - const fileImageUrls = fileResults - .filter((result) => result.imageDataUrl) - .map((result) => result.imageDataUrl as string) - - // Process all feedback in a unified way without branching - let statusMessage = "" - let feedbackImages: any[] = [] - - // Handle denial with feedback (highest priority) - const deniedWithFeedback = fileResults.find((result) => result.status === "denied" && result.feedbackText) - - if (deniedWithFeedback && deniedWithFeedback.feedbackText) { - statusMessage = formatResponse.toolDeniedWithFeedback(deniedWithFeedback.feedbackText) - feedbackImages = deniedWithFeedback.feedbackImages || [] - } - // Handle generic denial - else if (cline.didRejectTool) { - statusMessage = formatResponse.toolDenied() - } - // Handle approval with feedback - else { - const approvedWithFeedback = fileResults.find( - (result) => result.status === "approved" && result.feedbackText, - ) - - if (approvedWithFeedback && approvedWithFeedback.feedbackText) { - statusMessage = formatResponse.toolApprovedWithFeedback(approvedWithFeedback.feedbackText) - feedbackImages = approvedWithFeedback.feedbackImages || [] - } - } - - // Combine all images: feedback images first, then file images - const allImages = [...feedbackImages, ...fileImageUrls] - - // Re-check if the model supports images before including them, in case it changed during execution. - const finalModelSupportsImages = cline.api.getModel().info.supportsImages ?? false - const imagesToInclude = finalModelSupportsImages ? allImages : [] - - // Push the result with appropriate formatting - if (statusMessage || imagesToInclude.length > 0) { - // Always use formatResponse.toolResult when we have a status message or images - const result = formatResponse.toolResult( - statusMessage || filesXml, - imagesToInclude.length > 0 ? imagesToInclude : undefined, - ) - - // Handle different return types from toolResult - if (typeof result === "string") { - if (statusMessage) { - pushToolResult(`${result}\n${filesXml}`) - } else { - pushToolResult(result) - } - } else { - // For block-based results, append the files XML as a text block if not already included - if (statusMessage) { - const textBlock = { type: "text" as const, text: filesXml } - pushToolResult([...result, textBlock]) - } else { - pushToolResult(result) - } - } - } else { - // No images or status message, just push the files XML - pushToolResult(filesXml) - } - } catch (error) { - // Handle all errors using per-file format for consistency - const relPath = fileEntries[0]?.path || "unknown" - const errorMsg = error instanceof Error ? error.message : String(error) - - // If we have file results, update the first one with the error - if (fileResults.length > 0) { - updateFileResult(relPath, { - status: "error", - error: `Error reading file: ${errorMsg}`, - xmlContent: `${relPath}Error reading file: ${errorMsg}`, - }) - } - - await handleError(`reading file ${relPath}`, error instanceof Error ? error : new Error(errorMsg)) - - // Generate final XML result from all file results - const xmlResults = fileResults.filter((result) => result.xmlContent).map((result) => result.xmlContent) - - pushToolResult(`\n${xmlResults.join("\n")}\n`) - } -} diff --git a/src/core/tools/runSlashCommandTool.ts b/src/core/tools/runSlashCommandTool.ts deleted file mode 100644 index 06ceb5f19ce..00000000000 --- a/src/core/tools/runSlashCommandTool.ts +++ /dev/null @@ -1,108 +0,0 @@ -import { Task } from "../task/Task" -import { ToolUse, AskApproval, HandleError, PushToolResult, RemoveClosingTag } from "../../shared/tools" -import { formatResponse } from "../prompts/responses" -import { getCommand, getCommandNames } from "../../services/command/commands" -import { EXPERIMENT_IDS, experiments } from "../../shared/experiments" - -export async function runSlashCommandTool( - task: Task, - block: ToolUse, - askApproval: AskApproval, - handleError: HandleError, - pushToolResult: PushToolResult, - removeClosingTag: RemoveClosingTag, -) { - // Check if run slash command experiment is enabled - const provider = task.providerRef.deref() - const state = await provider?.getState() - const isRunSlashCommandEnabled = experiments.isEnabled(state?.experiments ?? {}, EXPERIMENT_IDS.RUN_SLASH_COMMAND) - - if (!isRunSlashCommandEnabled) { - pushToolResult( - formatResponse.toolError( - "Run slash command is an experimental feature that must be enabled in settings. Please enable 'Run Slash Command' in the Experimental Settings section.", - ), - ) - return - } - - const commandName: string | undefined = block.params.command - const args: string | undefined = block.params.args - - try { - if (block.partial) { - const partialMessage = JSON.stringify({ - tool: "runSlashCommand", - command: removeClosingTag("command", commandName), - args: removeClosingTag("args", args), - }) - - await task.ask("tool", partialMessage, block.partial).catch(() => {}) - return - } else { - if (!commandName) { - task.consecutiveMistakeCount++ - task.recordToolError("run_slash_command") - pushToolResult(await task.sayAndCreateMissingParamError("run_slash_command", "command")) - return - } - - task.consecutiveMistakeCount = 0 - - // Get the command from the commands service - const command = await getCommand(task.cwd, commandName) - - if (!command) { - // Get available commands for error message - const availableCommands = await getCommandNames(task.cwd) - task.recordToolError("run_slash_command") - pushToolResult( - formatResponse.toolError( - `Command '${commandName}' not found. Available commands: ${availableCommands.join(", ") || "(none)"}`, - ), - ) - return - } - - const toolMessage = JSON.stringify({ - tool: "runSlashCommand", - command: commandName, - args: args, - source: command.source, - description: command.description, - }) - - const didApprove = await askApproval("tool", toolMessage) - - if (!didApprove) { - return - } - - // Build the result message - let result = `Command: /${commandName}` - - if (command.description) { - result += `\nDescription: ${command.description}` - } - - if (command.argumentHint) { - result += `\nArgument hint: ${command.argumentHint}` - } - - if (args) { - result += `\nProvided arguments: ${args}` - } - - result += `\nSource: ${command.source}` - result += `\n\n--- Command Content ---\n\n${command.content}` - - // Return the command content as the tool result - pushToolResult(result) - - return - } - } catch (error) { - await handleError("running slash command", error) - return - } -} diff --git a/src/core/tools/searchFilesTool.ts b/src/core/tools/searchFilesTool.ts deleted file mode 100644 index b6ee97f8742..00000000000 --- a/src/core/tools/searchFilesTool.ts +++ /dev/null @@ -1,78 +0,0 @@ -import path from "path" - -import { Task } from "../task/Task" -import { ToolUse, AskApproval, HandleError, PushToolResult, RemoveClosingTag } from "../../shared/tools" -import { ClineSayTool } from "../../shared/ExtensionMessage" -import { getReadablePath } from "../../utils/path" -import { isPathOutsideWorkspace } from "../../utils/pathUtils" -import { regexSearchFiles } from "../../services/ripgrep" - -export async function searchFilesTool( - cline: Task, - block: ToolUse, - askApproval: AskApproval, - handleError: HandleError, - pushToolResult: PushToolResult, - removeClosingTag: RemoveClosingTag, -) { - const relDirPath: string | undefined = block.params.path - const regex: string | undefined = block.params.regex - const filePattern: string | undefined = block.params.file_pattern - - const absolutePath = relDirPath ? path.resolve(cline.cwd, relDirPath) : cline.cwd - const isOutsideWorkspace = isPathOutsideWorkspace(absolutePath) - - const sharedMessageProps: ClineSayTool = { - tool: "searchFiles", - path: getReadablePath(cline.cwd, removeClosingTag("path", relDirPath)), - regex: removeClosingTag("regex", regex), - filePattern: removeClosingTag("file_pattern", filePattern), - isOutsideWorkspace, - } - - try { - if (block.partial) { - const partialMessage = JSON.stringify({ ...sharedMessageProps, content: "" } satisfies ClineSayTool) - await cline.ask("tool", partialMessage, block.partial).catch(() => {}) - return - } else { - if (!relDirPath) { - cline.consecutiveMistakeCount++ - cline.recordToolError("search_files") - pushToolResult(await cline.sayAndCreateMissingParamError("search_files", "path")) - return - } - - if (!regex) { - cline.consecutiveMistakeCount++ - cline.recordToolError("search_files") - pushToolResult(await cline.sayAndCreateMissingParamError("search_files", "regex")) - return - } - - cline.consecutiveMistakeCount = 0 - - const results = await regexSearchFiles( - cline.cwd, - absolutePath, - regex, - filePattern, - cline.rooIgnoreController, - ) - - const completeMessage = JSON.stringify({ ...sharedMessageProps, content: results } satisfies ClineSayTool) - const didApprove = await askApproval("tool", completeMessage) - - if (!didApprove) { - return - } - - pushToolResult(results) - - return - } - } catch (error) { - await handleError("searching files", error) - return - } -} diff --git a/src/core/tools/switchModeTool.ts b/src/core/tools/switchModeTool.ts deleted file mode 100644 index 8ce906b41fc..00000000000 --- a/src/core/tools/switchModeTool.ts +++ /dev/null @@ -1,81 +0,0 @@ -import delay from "delay" - -import { Task } from "../task/Task" -import { ToolUse, AskApproval, HandleError, PushToolResult, RemoveClosingTag } from "../../shared/tools" -import { formatResponse } from "../prompts/responses" -import { defaultModeSlug, getModeBySlug } from "../../shared/modes" - -export async function switchModeTool( - cline: Task, - block: ToolUse, - askApproval: AskApproval, - handleError: HandleError, - pushToolResult: PushToolResult, - removeClosingTag: RemoveClosingTag, -) { - const mode_slug: string | undefined = block.params.mode_slug - const reason: string | undefined = block.params.reason - - try { - if (block.partial) { - const partialMessage = JSON.stringify({ - tool: "switchMode", - mode: removeClosingTag("mode_slug", mode_slug), - reason: removeClosingTag("reason", reason), - }) - - await cline.ask("tool", partialMessage, block.partial).catch(() => {}) - return - } else { - if (!mode_slug) { - cline.consecutiveMistakeCount++ - cline.recordToolError("switch_mode") - pushToolResult(await cline.sayAndCreateMissingParamError("switch_mode", "mode_slug")) - return - } - - cline.consecutiveMistakeCount = 0 - - // Verify the mode exists - const targetMode = getModeBySlug(mode_slug, (await cline.providerRef.deref()?.getState())?.customModes) - - if (!targetMode) { - cline.recordToolError("switch_mode") - pushToolResult(formatResponse.toolError(`Invalid mode: ${mode_slug}`)) - return - } - - // Check if already in requested mode - const currentMode = (await cline.providerRef.deref()?.getState())?.mode ?? defaultModeSlug - - if (currentMode === mode_slug) { - cline.recordToolError("switch_mode") - pushToolResult(`Already in ${targetMode.name} mode.`) - return - } - - const completeMessage = JSON.stringify({ tool: "switchMode", mode: mode_slug, reason }) - const didApprove = await askApproval("tool", completeMessage) - - if (!didApprove) { - return - } - - // Switch the mode using shared handler - await cline.providerRef.deref()?.handleModeSwitch(mode_slug) - - pushToolResult( - `Successfully switched from ${getModeBySlug(currentMode)?.name ?? currentMode} mode to ${ - targetMode.name - } mode${reason ? ` because: ${reason}` : ""}.`, - ) - - await delay(500) // Delay to allow mode change to take effect before next tool is executed - - return - } - } catch (error) { - await handleError("switching mode", error) - return - } -} diff --git a/src/core/tools/useMcpToolTool.ts b/src/core/tools/useMcpToolTool.ts deleted file mode 100644 index 41697ab979b..00000000000 --- a/src/core/tools/useMcpToolTool.ts +++ /dev/null @@ -1,331 +0,0 @@ -import { Task } from "../task/Task" -import { ToolUse, AskApproval, HandleError, PushToolResult, RemoveClosingTag } from "../../shared/tools" -import { formatResponse } from "../prompts/responses" -import { ClineAskUseMcpServer } from "../../shared/ExtensionMessage" -import { McpExecutionStatus } from "@roo-code/types" -import { t } from "../../i18n" - -interface McpToolParams { - server_name?: string - tool_name?: string - arguments?: string -} - -type ValidationResult = - | { isValid: false } - | { - isValid: true - serverName: string - toolName: string - parsedArguments?: Record - } - -async function handlePartialRequest( - cline: Task, - params: McpToolParams, - removeClosingTag: RemoveClosingTag, -): Promise { - const partialMessage = JSON.stringify({ - type: "use_mcp_tool", - serverName: removeClosingTag("server_name", params.server_name), - toolName: removeClosingTag("tool_name", params.tool_name), - arguments: removeClosingTag("arguments", params.arguments), - } satisfies ClineAskUseMcpServer) - - await cline.ask("use_mcp_server", partialMessage, true).catch(() => {}) -} - -async function validateParams( - cline: Task, - params: McpToolParams, - pushToolResult: PushToolResult, -): Promise { - if (!params.server_name) { - cline.consecutiveMistakeCount++ - cline.recordToolError("use_mcp_tool") - pushToolResult(await cline.sayAndCreateMissingParamError("use_mcp_tool", "server_name")) - return { isValid: false } - } - - if (!params.tool_name) { - cline.consecutiveMistakeCount++ - cline.recordToolError("use_mcp_tool") - pushToolResult(await cline.sayAndCreateMissingParamError("use_mcp_tool", "tool_name")) - return { isValid: false } - } - - let parsedArguments: Record | undefined - - if (params.arguments) { - try { - parsedArguments = JSON.parse(params.arguments) - } catch (error) { - cline.consecutiveMistakeCount++ - cline.recordToolError("use_mcp_tool") - await cline.say("error", t("mcp:errors.invalidJsonArgument", { toolName: params.tool_name })) - - pushToolResult( - formatResponse.toolError( - formatResponse.invalidMcpToolArgumentError(params.server_name, params.tool_name), - ), - ) - return { isValid: false } - } - } - - return { - isValid: true, - serverName: params.server_name, - toolName: params.tool_name, - parsedArguments, - } -} - -async function validateToolExists( - cline: Task, - serverName: string, - toolName: string, - pushToolResult: PushToolResult, -): Promise<{ isValid: boolean; availableTools?: string[] }> { - try { - // Get the MCP hub to access server information - const provider = cline.providerRef.deref() - const mcpHub = provider?.getMcpHub() - - if (!mcpHub) { - // If we can't get the MCP hub, we can't validate, so proceed with caution - return { isValid: true } - } - - // Get all servers to find the specific one - const servers = mcpHub.getAllServers() - const server = servers.find((s) => s.name === serverName) - - if (!server) { - // Fail fast when server is unknown - const availableServersArray = servers.map((s) => s.name) - const availableServers = - availableServersArray.length > 0 ? availableServersArray.join(", ") : "No servers available" - - cline.consecutiveMistakeCount++ - cline.recordToolError("use_mcp_tool") - await cline.say("error", t("mcp:errors.serverNotFound", { serverName, availableServers })) - - pushToolResult(formatResponse.unknownMcpServerError(serverName, availableServersArray)) - return { isValid: false, availableTools: [] } - } - - // Check if the server has tools defined - if (!server.tools || server.tools.length === 0) { - // No tools available on this server - cline.consecutiveMistakeCount++ - cline.recordToolError("use_mcp_tool") - await cline.say( - "error", - t("mcp:errors.toolNotFound", { - toolName, - serverName, - availableTools: "No tools available", - }), - ) - - pushToolResult(formatResponse.unknownMcpToolError(serverName, toolName, [])) - return { isValid: false, availableTools: [] } - } - - // Check if the requested tool exists - const tool = server.tools.find((tool) => tool.name === toolName) - - if (!tool) { - // Tool not found - provide list of available tools - const availableToolNames = server.tools.map((tool) => tool.name) - - cline.consecutiveMistakeCount++ - cline.recordToolError("use_mcp_tool") - await cline.say( - "error", - t("mcp:errors.toolNotFound", { - toolName, - serverName, - availableTools: availableToolNames.join(", "), - }), - ) - - pushToolResult(formatResponse.unknownMcpToolError(serverName, toolName, availableToolNames)) - return { isValid: false, availableTools: availableToolNames } - } - - // Check if the tool is disabled (enabledForPrompt is false) - if (tool.enabledForPrompt === false) { - // Tool is disabled - only show enabled tools - const enabledTools = server.tools.filter((t) => t.enabledForPrompt !== false) - const enabledToolNames = enabledTools.map((t) => t.name) - - cline.consecutiveMistakeCount++ - cline.recordToolError("use_mcp_tool") - await cline.say( - "error", - t("mcp:errors.toolDisabled", { - toolName, - serverName, - availableTools: - enabledToolNames.length > 0 ? enabledToolNames.join(", ") : "No enabled tools available", - }), - ) - - pushToolResult(formatResponse.unknownMcpToolError(serverName, toolName, enabledToolNames)) - return { isValid: false, availableTools: enabledToolNames } - } - - // Tool exists and is enabled - return { isValid: true, availableTools: server.tools.map((tool) => tool.name) } - } catch (error) { - // If there's an error during validation, log it but don't block the tool execution - // The actual tool call might still fail with a proper error - console.error("Error validating MCP tool existence:", error) - return { isValid: true } - } -} - -async function sendExecutionStatus(cline: Task, status: McpExecutionStatus): Promise { - const clineProvider = await cline.providerRef.deref() - clineProvider?.postMessageToWebview({ - type: "mcpExecutionStatus", - text: JSON.stringify(status), - }) -} - -function processToolContent(toolResult: any): string { - if (!toolResult?.content || toolResult.content.length === 0) { - return "" - } - - return toolResult.content - .map((item: any) => { - if (item.type === "text") { - return item.text - } - if (item.type === "resource") { - const { blob: _, ...rest } = item.resource - return JSON.stringify(rest, null, 2) - } - return "" - }) - .filter(Boolean) - .join("\n\n") -} - -async function executeToolAndProcessResult( - cline: Task, - serverName: string, - toolName: string, - parsedArguments: Record | undefined, - executionId: string, - pushToolResult: PushToolResult, -): Promise { - await cline.say("mcp_server_request_started") - - // Send started status - await sendExecutionStatus(cline, { - executionId, - status: "started", - serverName, - toolName, - }) - - const toolResult = await cline.providerRef.deref()?.getMcpHub()?.callTool(serverName, toolName, parsedArguments) - - let toolResultPretty = "(No response)" - - if (toolResult) { - const outputText = processToolContent(toolResult) - - if (outputText) { - await sendExecutionStatus(cline, { - executionId, - status: "output", - response: outputText, - }) - - toolResultPretty = (toolResult.isError ? "Error:\n" : "") + outputText - } - - // Send completion status - await sendExecutionStatus(cline, { - executionId, - status: toolResult.isError ? "error" : "completed", - response: toolResultPretty, - error: toolResult.isError ? "Error executing MCP tool" : undefined, - }) - } else { - // Send error status if no result - await sendExecutionStatus(cline, { - executionId, - status: "error", - error: "No response from MCP server", - }) - } - - await cline.say("mcp_server_response", toolResultPretty) - pushToolResult(formatResponse.toolResult(toolResultPretty)) -} - -export async function useMcpToolTool( - cline: Task, - block: ToolUse, - askApproval: AskApproval, - handleError: HandleError, - pushToolResult: PushToolResult, - removeClosingTag: RemoveClosingTag, -) { - try { - const params: McpToolParams = { - server_name: block.params.server_name, - tool_name: block.params.tool_name, - arguments: block.params.arguments, - } - - // Handle partial requests - if (block.partial) { - await handlePartialRequest(cline, params, removeClosingTag) - return - } - - // Validate parameters - const validation = await validateParams(cline, params, pushToolResult) - if (!validation.isValid) { - return - } - - const { serverName, toolName, parsedArguments } = validation - - // Validate that the tool exists on the server - const toolValidation = await validateToolExists(cline, serverName, toolName, pushToolResult) - if (!toolValidation.isValid) { - return - } - - // Reset mistake count on successful validation - cline.consecutiveMistakeCount = 0 - - // Get user approval - const completeMessage = JSON.stringify({ - type: "use_mcp_tool", - serverName, - toolName, - arguments: params.arguments, - } satisfies ClineAskUseMcpServer) - - const executionId = cline.lastMessageTs?.toString() ?? Date.now().toString() - const didApprove = await askApproval("use_mcp_server", completeMessage) - - if (!didApprove) { - return - } - - // Execute the tool and process results - await executeToolAndProcessResult(cline, serverName!, toolName!, parsedArguments, executionId, pushToolResult) - } catch (error) { - await handleError("executing MCP tool", error) - } -} diff --git a/src/core/tools/writeToFileTool.ts b/src/core/tools/writeToFileTool.ts deleted file mode 100644 index b8e6da0caa2..00000000000 --- a/src/core/tools/writeToFileTool.ts +++ /dev/null @@ -1,331 +0,0 @@ -import path from "path" -import delay from "delay" -import * as vscode from "vscode" -import fs from "fs/promises" - -import { Task } from "../task/Task" -import { ClineSayTool } from "../../shared/ExtensionMessage" -import { formatResponse } from "../prompts/responses" -import { ToolUse, AskApproval, HandleError, PushToolResult, RemoveClosingTag } from "../../shared/tools" -import { RecordSource } from "../context-tracking/FileContextTrackerTypes" -import { fileExistsAtPath } from "../../utils/fs" -import { stripLineNumbers, everyLineHasLineNumbers } from "../../integrations/misc/extract-text" -import { getReadablePath } from "../../utils/path" -import { isPathOutsideWorkspace } from "../../utils/pathUtils" -import { detectCodeOmission } from "../../integrations/editor/detect-omission" -import { unescapeHtmlEntities } from "../../utils/text-normalization" -import { DEFAULT_WRITE_DELAY_MS } from "@roo-code/types" -import { EXPERIMENT_IDS, experiments } from "../../shared/experiments" -import { convertNewFileToUnifiedDiff, computeDiffStats, sanitizeUnifiedDiff } from "../diff/stats" - -export async function writeToFileTool( - cline: Task, - block: ToolUse, - askApproval: AskApproval, - handleError: HandleError, - pushToolResult: PushToolResult, - removeClosingTag: RemoveClosingTag, -) { - const relPath: string | undefined = block.params.path - let newContent: string | undefined = block.params.content - let predictedLineCount: number | undefined = parseInt(block.params.line_count ?? "0") - - if (block.partial && (!relPath || newContent === undefined)) { - // checking for newContent ensure relPath is complete - // wait so we can determine if it's a new file or editing an existing file - return - } - - if (!relPath) { - cline.consecutiveMistakeCount++ - cline.recordToolError("write_to_file") - pushToolResult(await cline.sayAndCreateMissingParamError("write_to_file", "path")) - await cline.diffViewProvider.reset() - return - } - - if (newContent === undefined) { - cline.consecutiveMistakeCount++ - cline.recordToolError("write_to_file") - pushToolResult(await cline.sayAndCreateMissingParamError("write_to_file", "content")) - await cline.diffViewProvider.reset() - return - } - - const accessAllowed = cline.rooIgnoreController?.validateAccess(relPath) - - if (!accessAllowed) { - await cline.say("rooignore_error", relPath) - pushToolResult(formatResponse.toolError(formatResponse.rooIgnoreError(relPath))) - return - } - - // Check if file is write-protected - const isWriteProtected = cline.rooProtectedController?.isWriteProtected(relPath) || false - - // Check if file exists using cached map or fs.access - let fileExists: boolean - - if (cline.diffViewProvider.editType !== undefined) { - fileExists = cline.diffViewProvider.editType === "modify" - } else { - const absolutePath = path.resolve(cline.cwd, relPath) - fileExists = await fileExistsAtPath(absolutePath) - cline.diffViewProvider.editType = fileExists ? "modify" : "create" - } - - // pre-processing newContent for cases where weaker models might add artifacts like markdown codeblock markers (deepseek/llama) or extra escape characters (gemini) - if (newContent.startsWith("```")) { - // cline handles cases where it includes language specifiers like ```python ```js - newContent = newContent.split("\n").slice(1).join("\n") - } - - if (newContent.endsWith("```")) { - newContent = newContent.split("\n").slice(0, -1).join("\n") - } - - if (!cline.api.getModel().id.includes("claude")) { - newContent = unescapeHtmlEntities(newContent) - } - - // Determine if the path is outside the workspace - const fullPath = relPath ? path.resolve(cline.cwd, removeClosingTag("path", relPath)) : "" - const isOutsideWorkspace = isPathOutsideWorkspace(fullPath) - - const sharedMessageProps: ClineSayTool = { - tool: fileExists ? "editedExistingFile" : "newFileCreated", - path: getReadablePath(cline.cwd, removeClosingTag("path", relPath)), - content: newContent, - isOutsideWorkspace, - isProtected: isWriteProtected, - } - - try { - if (block.partial) { - // Check if preventFocusDisruption experiment is enabled - const provider = cline.providerRef.deref() - const state = await provider?.getState() - const isPreventFocusDisruptionEnabled = experiments.isEnabled( - state?.experiments ?? {}, - EXPERIMENT_IDS.PREVENT_FOCUS_DISRUPTION, - ) - - if (!isPreventFocusDisruptionEnabled) { - // update gui message - const partialMessage = JSON.stringify(sharedMessageProps) - await cline.ask("tool", partialMessage, block.partial).catch(() => {}) - - // update editor - if (!cline.diffViewProvider.isEditing) { - // open the editor and prepare to stream content in - await cline.diffViewProvider.open(relPath) - } - - // editor is open, stream content in - await cline.diffViewProvider.update( - everyLineHasLineNumbers(newContent) ? stripLineNumbers(newContent) : newContent, - false, - ) - } - - return - } else { - if (predictedLineCount === undefined) { - cline.consecutiveMistakeCount++ - cline.recordToolError("write_to_file") - - // Calculate the actual number of lines in the content - const actualLineCount = newContent.split("\n").length - - // Check if this is a new file or existing file - const isNewFile = !fileExists - - // Check if diffStrategy is enabled - const diffStrategyEnabled = !!cline.diffStrategy - - // Use more specific error message for line_count that provides guidance based on the situation - await cline.say( - "error", - `Roo tried to use write_to_file${ - relPath ? ` for '${relPath.toPosix()}'` : "" - } but the required parameter 'line_count' was missing or truncated after ${actualLineCount} lines of content were written. Retrying...`, - ) - - pushToolResult( - formatResponse.toolError( - formatResponse.lineCountTruncationError(actualLineCount, isNewFile, diffStrategyEnabled), - ), - ) - await cline.diffViewProvider.revertChanges() - return - } - - cline.consecutiveMistakeCount = 0 - - // Check if preventFocusDisruption experiment is enabled - const provider = cline.providerRef.deref() - const state = await provider?.getState() - const diagnosticsEnabled = state?.diagnosticsEnabled ?? true - const writeDelayMs = state?.writeDelayMs ?? DEFAULT_WRITE_DELAY_MS - const isPreventFocusDisruptionEnabled = experiments.isEnabled( - state?.experiments ?? {}, - EXPERIMENT_IDS.PREVENT_FOCUS_DISRUPTION, - ) - - if (isPreventFocusDisruptionEnabled) { - // Direct file write without diff view - // Set up diffViewProvider properties needed for diff generation and saveDirectly - cline.diffViewProvider.editType = fileExists ? "modify" : "create" - if (fileExists) { - const absolutePath = path.resolve(cline.cwd, relPath) - cline.diffViewProvider.originalContent = await fs.readFile(absolutePath, "utf-8") - } else { - cline.diffViewProvider.originalContent = "" - } - - // Check for code omissions before proceeding - if (detectCodeOmission(cline.diffViewProvider.originalContent || "", newContent, predictedLineCount)) { - if (cline.diffStrategy) { - pushToolResult( - formatResponse.toolError( - `Content appears to be truncated (file has ${ - newContent.split("\n").length - } lines but was predicted to have ${predictedLineCount} lines), and found comments indicating omitted code (e.g., '// rest of code unchanged', '/* previous code */'). Please provide the complete file content without any omissions if possible, or otherwise use the 'apply_diff' tool to apply the diff to the original file.`, - ), - ) - return - } else { - vscode.window - .showWarningMessage( - "Potential code truncation detected. cline happens when the AI reaches its max output limit.", - "Follow cline guide to fix the issue", - ) - .then((selection) => { - if (selection === "Follow cline guide to fix the issue") { - vscode.env.openExternal( - vscode.Uri.parse( - "https://github.com/cline/cline/wiki/Troubleshooting-%E2%80%90-Cline-Deleting-Code-with-%22Rest-of-Code-Here%22-Comments", - ), - ) - } - }) - } - } - - // Build unified diff for both existing and new files - let unified = fileExists - ? formatResponse.createPrettyPatch(relPath, cline.diffViewProvider.originalContent, newContent) - : convertNewFileToUnifiedDiff(newContent, relPath) - unified = sanitizeUnifiedDiff(unified) - const completeMessage = JSON.stringify({ - ...sharedMessageProps, - content: unified, - diffStats: computeDiffStats(unified) || undefined, - } satisfies ClineSayTool) - - const didApprove = await askApproval("tool", completeMessage, undefined, isWriteProtected) - - if (!didApprove) { - return - } - - // Save directly without showing diff view or opening the file - await cline.diffViewProvider.saveDirectly(relPath, newContent, false, diagnosticsEnabled, writeDelayMs) - } else { - // Original behavior with diff view - // if isEditingFile false, that means we have the full contents of the file already. - // it's important to note how cline function works, you can't make the assumption that the block.partial conditional will always be called since it may immediately get complete, non-partial data. So cline part of the logic will always be called. - // in other words, you must always repeat the block.partial logic here - if (!cline.diffViewProvider.isEditing) { - // show gui message before showing edit animation - const partialMessage = JSON.stringify(sharedMessageProps) - await cline.ask("tool", partialMessage, true).catch(() => {}) // sending true for partial even though it's not a partial, cline shows the edit row before the content is streamed into the editor - await cline.diffViewProvider.open(relPath) - } - - await cline.diffViewProvider.update( - everyLineHasLineNumbers(newContent) ? stripLineNumbers(newContent) : newContent, - true, - ) - - await delay(300) // wait for diff view to update - cline.diffViewProvider.scrollToFirstDiff() - - // Check for code omissions before proceeding - if (detectCodeOmission(cline.diffViewProvider.originalContent || "", newContent, predictedLineCount)) { - if (cline.diffStrategy) { - await cline.diffViewProvider.revertChanges() - - pushToolResult( - formatResponse.toolError( - `Content appears to be truncated (file has ${ - newContent.split("\n").length - } lines but was predicted to have ${predictedLineCount} lines), and found comments indicating omitted code (e.g., '// rest of code unchanged', '/* previous code */'). Please provide the complete file content without any omissions if possible, or otherwise use the 'apply_diff' tool to apply the diff to the original file.`, - ), - ) - return - } else { - vscode.window - .showWarningMessage( - "Potential code truncation detected. cline happens when the AI reaches its max output limit.", - "Follow cline guide to fix the issue", - ) - .then((selection) => { - if (selection === "Follow cline guide to fix the issue") { - vscode.env.openExternal( - vscode.Uri.parse( - "https://github.com/cline/cline/wiki/Troubleshooting-%E2%80%90-Cline-Deleting-Code-with-%22Rest-of-Code-Here%22-Comments", - ), - ) - } - }) - } - } - - // Build unified diff for both existing and new files - let unified = fileExists - ? formatResponse.createPrettyPatch(relPath, cline.diffViewProvider.originalContent, newContent) - : convertNewFileToUnifiedDiff(newContent, relPath) - unified = sanitizeUnifiedDiff(unified) - const completeMessage = JSON.stringify({ - ...sharedMessageProps, - content: unified, - diffStats: computeDiffStats(unified) || undefined, - } satisfies ClineSayTool) - - const didApprove = await askApproval("tool", completeMessage, undefined, isWriteProtected) - - if (!didApprove) { - await cline.diffViewProvider.revertChanges() - return - } - - // Call saveChanges to update the DiffViewProvider properties - await cline.diffViewProvider.saveChanges(diagnosticsEnabled, writeDelayMs) - } - - // Track file edit operation - if (relPath) { - await cline.fileContextTracker.trackFileContext(relPath, "roo_edited" as RecordSource) - } - - cline.didEditFile = true // used to determine if we should wait for busy terminal to update before sending api request - - // Get the formatted response message - const message = await cline.diffViewProvider.pushToolWriteResult(cline, cline.cwd, !fileExists) - - pushToolResult(message) - - await cline.diffViewProvider.reset() - - // Process any queued messages after file edit completes - cline.processQueuedMessages() - - return - } - } catch (error) { - await handleError("writing file", error) - await cline.diffViewProvider.reset() - return - } -} diff --git a/src/core/webview/generateSystemPrompt.ts b/src/core/webview/generateSystemPrompt.ts index 65f908edad4..b1191911a52 100644 --- a/src/core/webview/generateSystemPrompt.ts +++ b/src/core/webview/generateSystemPrompt.ts @@ -7,7 +7,7 @@ import { experiments as experimentsModule, EXPERIMENT_IDS } from "../../shared/e import { SYSTEM_PROMPT } from "../prompts/system" import { MultiSearchReplaceDiffStrategy } from "../diff/strategies/multi-search-replace" import { MultiFileSearchReplaceDiffStrategy } from "../diff/strategies/multi-file-search-replace" -import { resolveToolProtocol } from "../prompts/toolProtocolResolver" +import { ToolProtocol } from "@roo-code/types" import { ClineProvider } from "./ClineProvider" @@ -92,7 +92,7 @@ export const generateSystemPrompt = async (provider: ClineProvider, message: Web newTaskRequireTodos: vscode.workspace .getConfiguration("roo-cline") .get("newTaskRequireTodos", false), - toolProtocol: resolveToolProtocol(), + toolProtocol: vscode.workspace.getConfiguration("roo-cline").get("toolProtocol", "xml"), }, ) diff --git a/src/core/webview/webviewMessageHandler.ts b/src/core/webview/webviewMessageHandler.ts index c85dea9d16f..b7da941b438 100644 --- a/src/core/webview/webviewMessageHandler.ts +++ b/src/core/webview/webviewMessageHandler.ts @@ -61,7 +61,7 @@ import { getCommand } from "../../utils/commands" const ALLOWED_VSCODE_SETTINGS = new Set(["terminal.integrated.inheritEnv"]) import { MarketplaceManager, MarketplaceItemType } from "../../services/marketplace" -import { setPendingTodoList } from "../tools/updateTodoListTool" +import { setPendingTodoList } from "../tools/UpdateTodoListTool" export const webviewMessageHandler = async ( provider: ClineProvider, diff --git a/src/package.json b/src/package.json index 74a312daa71..5701078bc0e 100644 --- a/src/package.json +++ b/src/package.json @@ -436,6 +436,15 @@ "minimum": 1, "maximum": 200, "description": "%settings.codeIndex.embeddingBatchSize.description%" + }, + "roo-cline.toolProtocol": { + "type": "string", + "enum": [ + "xml", + "native" + ], + "default": "xml", + "description": "%settings.toolProtocol.description%" } } } diff --git a/src/package.nls.ca.json b/src/package.nls.ca.json index 22d3f633a64..d26fcf218bc 100644 --- a/src/package.nls.ca.json +++ b/src/package.nls.ca.json @@ -43,5 +43,6 @@ "settings.useAgentRules.description": "Activa la càrrega de fitxers AGENTS.md per a regles específiques de l'agent (vegeu https://agent-rules.org/)", "settings.apiRequestTimeout.description": "Temps màxim en segons per esperar les respostes de l'API (0 = sense temps d'espera, 1-3600s, per defecte: 600s). Es recomanen valors més alts per a proveïdors locals com LM Studio i Ollama que poden necessitar més temps de processament.", "settings.newTaskRequireTodos.description": "Requerir el paràmetre de tasques pendents quan es creïn noves tasques amb l'eina new_task", - "settings.codeIndex.embeddingBatchSize.description": "La mida del lot per a operacions d'incrustació durant la indexació de codi. Ajusta això segons els límits del teu proveïdor d'API. Per defecte és 60." + "settings.codeIndex.embeddingBatchSize.description": "La mida del lot per a operacions d'incrustació durant la indexació de codi. Ajusta això segons els límits del teu proveïdor d'API. Per defecte és 60.", + "settings.toolProtocol.description": "Protocol d'eines a utilitzar per a les interaccions d'IA. XML és el protocol per defecte i recomanat. Natiu és experimental i pot ser que no funcioni amb tots els proveïdors." } diff --git a/src/package.nls.de.json b/src/package.nls.de.json index 3931ba000ef..f3c77fd0f55 100644 --- a/src/package.nls.de.json +++ b/src/package.nls.de.json @@ -43,5 +43,6 @@ "settings.useAgentRules.description": "Aktiviert das Laden von AGENTS.md-Dateien für agentenspezifische Regeln (siehe https://agent-rules.org/)", "settings.apiRequestTimeout.description": "Maximale Wartezeit in Sekunden auf API-Antworten (0 = kein Timeout, 1-3600s, Standard: 600s). Höhere Werte werden für lokale Anbieter wie LM Studio und Ollama empfohlen, die möglicherweise mehr Verarbeitungszeit benötigen.", "settings.newTaskRequireTodos.description": "Todos-Parameter beim Erstellen neuer Aufgaben mit dem new_task-Tool erfordern", - "settings.codeIndex.embeddingBatchSize.description": "Die Batch-Größe für Embedding-Operationen während der Code-Indexierung. Passe dies an die Limits deines API-Anbieters an. Standard ist 60." + "settings.codeIndex.embeddingBatchSize.description": "Die Batch-Größe für Embedding-Operationen während der Code-Indexierung. Passe dies an die Limits deines API-Anbieters an. Standard ist 60.", + "settings.toolProtocol.description": "Tool-Protokoll, das für KI-Interaktionen verwendet werden soll. XML ist das Standard- und empfohlene Protokoll. Nativ ist experimentell und funktioniert möglicherweise nicht mit allen Anbietern." } diff --git a/src/package.nls.es.json b/src/package.nls.es.json index 0c22cdf9045..7bb988c2f82 100644 --- a/src/package.nls.es.json +++ b/src/package.nls.es.json @@ -43,5 +43,6 @@ "settings.useAgentRules.description": "Habilita la carga de archivos AGENTS.md para reglas específicas del agente (ver https://agent-rules.org/)", "settings.apiRequestTimeout.description": "Tiempo máximo en segundos de espera para las respuestas de la API (0 = sin tiempo de espera, 1-3600s, por defecto: 600s). Se recomiendan valores más altos para proveedores locales como LM Studio y Ollama que puedan necesitar más tiempo de procesamiento.", "settings.newTaskRequireTodos.description": "Requerir el parámetro todos al crear nuevas tareas con la herramienta new_task", - "settings.codeIndex.embeddingBatchSize.description": "El tamaño del lote para operaciones de embedding durante la indexación de código. Ajusta esto según los límites de tu proveedor de API. Por defecto es 60." + "settings.codeIndex.embeddingBatchSize.description": "El tamaño del lote para operaciones de embedding durante la indexación de código. Ajusta esto según los límites de tu proveedor de API. Por defecto es 60.", + "settings.toolProtocol.description": "Protocolo de herramienta a utilizar para las interacciones de IA. XML es el protocolo predeterminado y recomendado. Nativo es experimental y puede que no funcione con todos los proveedores." } diff --git a/src/package.nls.fr.json b/src/package.nls.fr.json index 422db278202..c3de92aecc6 100644 --- a/src/package.nls.fr.json +++ b/src/package.nls.fr.json @@ -43,5 +43,6 @@ "settings.useAgentRules.description": "Activer le chargement des fichiers AGENTS.md pour les règles spécifiques à l'agent (voir https://agent-rules.org/)", "settings.apiRequestTimeout.description": "Temps maximum en secondes d'attente pour les réponses de l'API (0 = pas de timeout, 1-3600s, par défaut : 600s). Des valeurs plus élevées sont recommandées pour les fournisseurs locaux comme LM Studio et Ollama qui peuvent nécessiter plus de temps de traitement.", "settings.newTaskRequireTodos.description": "Exiger le paramètre todos lors de la création de nouvelles tâches avec l'outil new_task", - "settings.codeIndex.embeddingBatchSize.description": "La taille du lot pour les opérations d'embedding lors de l'indexation du code. Ajustez ceci selon les limites de votre fournisseur d'API. Par défaut, c'est 60." + "settings.codeIndex.embeddingBatchSize.description": "La taille du lot pour les opérations d'embedding lors de l'indexation du code. Ajustez ceci selon les limites de votre fournisseur d'API. Par défaut, c'est 60.", + "settings.toolProtocol.description": "Protocole d'outil à utiliser pour les interactions AI. XML est le protocole par défaut et recommandé. Natif est expérimental et peut ne pas fonctionner avec tous les fournisseurs." } diff --git a/src/package.nls.hi.json b/src/package.nls.hi.json index 6337e9e1a33..102e1861dbd 100644 --- a/src/package.nls.hi.json +++ b/src/package.nls.hi.json @@ -43,5 +43,6 @@ "settings.useAgentRules.description": "एजेंट-विशिष्ट नियमों के लिए AGENTS.md फ़ाइलों को लोड करना सक्षम करें (देखें https://agent-rules.org/)", "settings.apiRequestTimeout.description": "एपीआई प्रतिक्रियाओं की प्रतीक्षा करने के लिए सेकंड में अधिकतम समय (0 = कोई टाइमआउट नहीं, 1-3600s, डिफ़ॉल्ट: 600s)। एलएम स्टूडियो और ओलामा जैसे स्थानीय प्रदाताओं के लिए उच्च मानों की सिफारिश की जाती है जिन्हें अधिक प्रसंस्करण समय की आवश्यकता हो सकती है।", "settings.newTaskRequireTodos.description": "new_task टूल के साथ नए कार्य बनाते समय टूडू पैरामीटर की आवश्यकता होती है", - "settings.codeIndex.embeddingBatchSize.description": "कोड इंडेक्सिंग के दौरान एम्बेडिंग ऑपरेशन के लिए बैच साइज़। इसे अपने API प्रदाता की सीमाओं के अनुसार समायोजित करें। डिफ़ॉल्ट 60 है।" + "settings.codeIndex.embeddingBatchSize.description": "कोड इंडेक्सिंग के दौरान एम्बेडिंग ऑपरेशन के लिए बैच साइज़। इसे अपने API प्रदाता की सीमाओं के अनुसार समायोजित करें। डिफ़ॉल्ट 60 है।", + "settings.toolProtocol.description": "एआई इंटरैक्शन के लिए उपयोग करने वाला टूल प्रोटोकॉल। एक्सएमएल डिफ़ॉल्ट और अनुशंसित प्रोटोकॉल है। नेटिव प्रायोगिक है और सभी प्रदाताओं के साथ काम नहीं कर सकता है।" } diff --git a/src/package.nls.id.json b/src/package.nls.id.json index 1c3025a09d0..2b31f368954 100644 --- a/src/package.nls.id.json +++ b/src/package.nls.id.json @@ -43,5 +43,6 @@ "settings.useAgentRules.description": "Aktifkan pemuatan file AGENTS.md untuk aturan khusus agen (lihat https://agent-rules.org/)", "settings.apiRequestTimeout.description": "Waktu maksimum dalam detik untuk menunggu respons API (0 = tidak ada batas waktu, 1-3600s, default: 600s). Nilai yang lebih tinggi disarankan untuk penyedia lokal seperti LM Studio dan Ollama yang mungkin memerlukan lebih banyak waktu pemrosesan.", "settings.newTaskRequireTodos.description": "Memerlukan parameter todos saat membuat tugas baru dengan alat new_task", - "settings.codeIndex.embeddingBatchSize.description": "Ukuran batch untuk operasi embedding selama pengindeksan kode. Sesuaikan ini berdasarkan batas penyedia API kamu. Default adalah 60." + "settings.codeIndex.embeddingBatchSize.description": "Ukuran batch untuk operasi embedding selama pengindeksan kode. Sesuaikan ini berdasarkan batas penyedia API kamu. Default adalah 60.", + "settings.toolProtocol.description": "Protokol alat untuk digunakan untuk interaksi AI. XML adalah protokol default dan yang direkomendasikan. Native bersifat eksperimental dan mungkin tidak berfungsi dengan semua penyedia." } diff --git a/src/package.nls.it.json b/src/package.nls.it.json index d0c130e00b1..d3cedcec141 100644 --- a/src/package.nls.it.json +++ b/src/package.nls.it.json @@ -43,5 +43,6 @@ "settings.useAgentRules.description": "Abilita il caricamento dei file AGENTS.md per regole specifiche dell'agente (vedi https://agent-rules.org/)", "settings.apiRequestTimeout.description": "Tempo massimo in secondi di attesa per le risposte API (0 = nessun timeout, 1-3600s, predefinito: 600s). Valori più alti sono consigliati per provider locali come LM Studio e Ollama che potrebbero richiedere più tempo di elaborazione.", "settings.newTaskRequireTodos.description": "Richiedere il parametro todos quando si creano nuove attività con lo strumento new_task", - "settings.codeIndex.embeddingBatchSize.description": "La dimensione del batch per le operazioni di embedding durante l'indicizzazione del codice. Regola questo in base ai limiti del tuo provider API. Il valore predefinito è 60." + "settings.codeIndex.embeddingBatchSize.description": "La dimensione del batch per le operazioni di embedding durante l'indicizzazione del codice. Regola questo in base ai limiti del tuo provider API. Il valore predefinito è 60.", + "settings.toolProtocol.description": "Protocollo dello strumento da utilizzare per le interazioni AI. XML è il protocollo predefinito e consigliato. Nativo è sperimentale e potrebbe non funzionare con tutti i provider." } diff --git a/src/package.nls.ja.json b/src/package.nls.ja.json index 05251f4aed1..70acffe0fed 100644 --- a/src/package.nls.ja.json +++ b/src/package.nls.ja.json @@ -43,5 +43,6 @@ "settings.useAgentRules.description": "エージェント固有のルールのためにAGENTS.mdファイルの読み込みを有効にします（参照：https://agent-rules.org/）", "settings.apiRequestTimeout.description": "API応答を待機する最大時間（秒）（0 = タイムアウトなし、1-3600秒、デフォルト: 600秒）。LM StudioやOllamaのような、より多くの処理時間を必要とする可能性のあるローカルプロバイダーには、より高い値が推奨されます。", "settings.newTaskRequireTodos.description": "new_taskツールで新しいタスクを作成する際にtodosパラメータを必須にする", - "settings.codeIndex.embeddingBatchSize.description": "コードインデックス作成中のエンベディング操作のバッチサイズ。APIプロバイダーの制限に基づいてこれを調整してください。デフォルトは60です。" + "settings.codeIndex.embeddingBatchSize.description": "コードインデックス作成中のエンベディング操作のバッチサイズ。APIプロバイダーの制限に基づいてこれを調整してください。デフォルトは60です。", + "settings.toolProtocol.description": "AIインタラクションに使用するツールプロトコル。XMLがデフォルトで推奨されるプロトコルです。ネイティブは実験的なものであり、すべてのプロバイダーで動作するとは限りません。" } diff --git a/src/package.nls.json b/src/package.nls.json index 42443e1716d..268ad0fe882 100644 --- a/src/package.nls.json +++ b/src/package.nls.json @@ -43,5 +43,6 @@ "settings.useAgentRules.description": "Enable loading of AGENTS.md files for agent-specific rules (see https://agent-rules.org/)", "settings.apiRequestTimeout.description": "Maximum time in seconds to wait for API responses (0 = no timeout, 1-3600s, default: 600s). Higher values are recommended for local providers like LM Studio and Ollama that may need more processing time.", "settings.newTaskRequireTodos.description": "Require todos parameter when creating new tasks with the new_task tool", - "settings.codeIndex.embeddingBatchSize.description": "The batch size for embedding operations during code indexing. Adjust this based on your API provider's limits. Default is 60." + "settings.codeIndex.embeddingBatchSize.description": "The batch size for embedding operations during code indexing. Adjust this based on your API provider's limits. Default is 60.", + "settings.toolProtocol.description": "Tool protocol to use for AI interactions. XML is the default and recommended protocol. Native is experimental and may not work with all providers." } diff --git a/src/package.nls.ko.json b/src/package.nls.ko.json index dd933733f78..20d913d1339 100644 --- a/src/package.nls.ko.json +++ b/src/package.nls.ko.json @@ -43,5 +43,6 @@ "settings.useAgentRules.description": "에이전트별 규칙에 대한 AGENTS.md 파일 로드를 활성화합니다 (참조: https://agent-rules.org/)", "settings.apiRequestTimeout.description": "API 응답을 기다리는 최대 시간(초) (0 = 시간 초과 없음, 1-3600초, 기본값: 600초). 더 많은 처리 시간이 필요할 수 있는 LM Studio 및 Ollama와 같은 로컬 공급자에게는 더 높은 값을 사용하는 것이 좋습니다.", "settings.newTaskRequireTodos.description": "new_task 도구로 새 작업을 생성할 때 todos 매개변수 필요", - "settings.codeIndex.embeddingBatchSize.description": "코드 인덱싱 중 임베딩 작업의 배치 크기입니다. API 공급자의 제한에 따라 이를 조정하세요. 기본값은 60입니다." + "settings.codeIndex.embeddingBatchSize.description": "코드 인덱싱 중 임베딩 작업의 배치 크기입니다. API 공급자의 제한에 따라 이를 조정하세요. 기본값은 60입니다.", + "settings.toolProtocol.description": "AI 상호 작용에 사용할 도구 프로토콜입니다. XML이 기본 권장 프로토콜입니다. 네이티브는 실험적이며 모든 공급자와 작동하지 않을 수 있습니다." } diff --git a/src/package.nls.nl.json b/src/package.nls.nl.json index c5f52e55712..d8165f65203 100644 --- a/src/package.nls.nl.json +++ b/src/package.nls.nl.json @@ -43,5 +43,6 @@ "settings.useAgentRules.description": "Laden van AGENTS.md-bestanden voor agentspecifieke regels inschakelen (zie https://agent-rules.org/)", "settings.apiRequestTimeout.description": "Maximale tijd in seconden om te wachten op API-reacties (0 = geen time-out, 1-3600s, standaard: 600s). Hogere waarden worden aanbevolen voor lokale providers zoals LM Studio en Ollama die mogelijk meer verwerkingstijd nodig hebben.", "settings.newTaskRequireTodos.description": "Todos-parameter vereisen bij het maken van nieuwe taken met de new_task tool", - "settings.codeIndex.embeddingBatchSize.description": "De batchgrootte voor embedding-operaties tijdens code-indexering. Pas dit aan op basis van de limieten van je API-provider. Standaard is 60." + "settings.codeIndex.embeddingBatchSize.description": "De batchgrootte voor embedding-operaties tijdens code-indexering. Pas dit aan op basis van de limieten van je API-provider. Standaard is 60.", + "settings.toolProtocol.description": "Toolprotocol te gebruiken voor AI-interacties. XML is het standaard en aanbevolen protocol. Native is experimenteel en werkt mogelijk niet met alle providers." } diff --git a/src/package.nls.pl.json b/src/package.nls.pl.json index 1178336d684..2e515337287 100644 --- a/src/package.nls.pl.json +++ b/src/package.nls.pl.json @@ -43,5 +43,6 @@ "settings.useAgentRules.description": "Włącz wczytywanie plików AGENTS.md dla reguł specyficznych dla agenta (zobacz https://agent-rules.org/)", "settings.apiRequestTimeout.description": "Maksymalny czas w sekundach oczekiwania na odpowiedzi API (0 = brak limitu czasu, 1-3600s, domyślnie: 600s). Wyższe wartości są zalecane dla lokalnych dostawców, takich jak LM Studio i Ollama, którzy mogą potrzebować więcej czasu na przetwarzanie.", "settings.newTaskRequireTodos.description": "Wymagaj parametru todos podczas tworzenia nowych zadań za pomocą narzędzia new_task", - "settings.codeIndex.embeddingBatchSize.description": "Rozmiar partii dla operacji osadzania podczas indeksowania kodu. Dostosuj to w oparciu o limity twojego dostawcy API. Domyślnie to 60." + "settings.codeIndex.embeddingBatchSize.description": "Rozmiar partii dla operacji osadzania podczas indeksowania kodu. Dostosuj to w oparciu o limity twojego dostawcy API. Domyślnie to 60.", + "settings.toolProtocol.description": "Protokół narzędzi do użycia w interakcjach z AI. XML jest domyślnym i zalecanym protokołem. Natywny jest eksperymentalny i może nie działać ze wszystkimi dostawcami." } diff --git a/src/package.nls.pt-BR.json b/src/package.nls.pt-BR.json index dfed1c8fb13..49ad1375066 100644 --- a/src/package.nls.pt-BR.json +++ b/src/package.nls.pt-BR.json @@ -43,5 +43,6 @@ "settings.useAgentRules.description": "Habilita o carregamento de arquivos AGENTS.md para regras específicas do agente (consulte https://agent-rules.org/)", "settings.apiRequestTimeout.description": "Tempo máximo em segundos de espera pelas respostas da API (0 = sem tempo limite, 1-3600s, padrão: 600s). Valores mais altos são recomendados para provedores locais como LM Studio e Ollama que podem precisar de mais tempo de processamento.", "settings.newTaskRequireTodos.description": "Exigir parâmetro todos ao criar novas tarefas com a ferramenta new_task", - "settings.codeIndex.embeddingBatchSize.description": "O tamanho do lote para operações de embedding durante a indexação de código. Ajuste isso com base nos limites do seu provedor de API. O padrão é 60." + "settings.codeIndex.embeddingBatchSize.description": "O tamanho do lote para operações de embedding durante a indexação de código. Ajuste isso com base nos limites do seu provedor de API. O padrão é 60.", + "settings.toolProtocol.description": "Protocolo de ferramenta a ser usado para interações de IA. XML é o protocolo padrão e recomendado. Nativo é experimental e pode não funcionar com todos os provedores." } diff --git a/src/package.nls.ru.json b/src/package.nls.ru.json index c2284af3695..269bb6f1d23 100644 --- a/src/package.nls.ru.json +++ b/src/package.nls.ru.json @@ -43,5 +43,6 @@ "settings.useAgentRules.description": "Включить загрузку файлов AGENTS.md для специфичных для агента правил (см. https://agent-rules.org/)", "settings.apiRequestTimeout.description": "Максимальное время в секундах для ожидания ответов API (0 = нет тайм-аута, 1-3600 с, по умолчанию: 600 с). Рекомендуются более высокие значения для локальных провайдеров, таких как LM Studio и Ollama, которым может потребоваться больше времени на обработку.", "settings.newTaskRequireTodos.description": "Требовать параметр todos при создании новых задач с помощью инструмента new_task", - "settings.codeIndex.embeddingBatchSize.description": "Размер пакета для операций встраивания во время индексации кода. Настройте это в соответствии с ограничениями вашего API-провайдера. По умолчанию 60." + "settings.codeIndex.embeddingBatchSize.description": "Размер пакета для операций встраивания во время индексации кода. Настройте это в соответствии с ограничениями вашего API-провайдера. По умолчанию 60.", + "settings.toolProtocol.description": "Протокол инструментов для использования в взаимодействиях с ИИ. XML является протоколом по умолчанию и рекомендуемым. Нативный является экспериментальным и может не работать со всеми провайдерами." } diff --git a/src/package.nls.tr.json b/src/package.nls.tr.json index 21d9a1db93b..baef09d27ff 100644 --- a/src/package.nls.tr.json +++ b/src/package.nls.tr.json @@ -43,5 +43,6 @@ "settings.useAgentRules.description": "Aracıya özgü kurallar için AGENTS.md dosyalarının yüklenmesini etkinleştirin (bkz. https://agent-rules.org/)", "settings.apiRequestTimeout.description": "API yanıtları için beklenecek maksimum süre (saniye cinsinden) (0 = zaman aşımı yok, 1-3600s, varsayılan: 600s). LM Studio ve Ollama gibi daha fazla işlem süresi gerektirebilecek yerel sağlayıcılar için daha yüksek değerler önerilir.", "settings.newTaskRequireTodos.description": "new_task aracıyla yeni görevler oluştururken todos parametresini gerekli kıl", - "settings.codeIndex.embeddingBatchSize.description": "Kod indeksleme sırasında gömme işlemleri için toplu iş boyutu. Bunu API sağlayıcınızın sınırlarına göre ayarlayın. Varsayılan 60'tır." + "settings.codeIndex.embeddingBatchSize.description": "Kod indeksleme sırasında gömme işlemleri için toplu iş boyutu. Bunu API sağlayıcınızın sınırlarına göre ayarlayın. Varsayılan 60'tır.", + "settings.toolProtocol.description": "Yapay zeka etkileşimleri için kullanılacak araç protokolü. XML, varsayılan ve önerilen protokoldür. Yerel deneyseldir ve tüm sağlayıcılarla çalışmayabilir." } diff --git a/src/package.nls.vi.json b/src/package.nls.vi.json index 795f8549cf4..a53591a53e8 100644 --- a/src/package.nls.vi.json +++ b/src/package.nls.vi.json @@ -43,5 +43,6 @@ "settings.useAgentRules.description": "Bật tải tệp AGENTS.md cho các quy tắc dành riêng cho tác nhân (xem https://agent-rules.org/)", "settings.apiRequestTimeout.description": "Thời gian tối đa tính bằng giây để đợi phản hồi API (0 = không có thời gian chờ, 1-3600 giây, mặc định: 600 giây). Nên sử dụng các giá trị cao hơn cho các nhà cung cấp cục bộ như LM Studio và Ollama có thể cần thêm thời gian xử lý.", "settings.newTaskRequireTodos.description": "Yêu cầu tham số todos khi tạo nhiệm vụ mới với công cụ new_task", - "settings.codeIndex.embeddingBatchSize.description": "Kích thước lô cho các hoạt động nhúng trong quá trình lập chỉ mục mã. Điều chỉnh điều này dựa trên giới hạn của nhà cung cấp API của bạn. Mặc định là 60." + "settings.codeIndex.embeddingBatchSize.description": "Kích thước lô cho các hoạt động nhúng trong quá trình lập chỉ mục mã. Điều chỉnh điều này dựa trên giới hạn của nhà cung cấp API của bạn. Mặc định là 60.", + "settings.toolProtocol.description": "Giao thức công cụ để sử dụng cho các tương tác AI. XML là giao thức mặc định và được khuyến nghị. Bản gốc là thử nghiệm và có thể không hoạt động với tất cả các nhà cung cấp." } diff --git a/src/package.nls.zh-CN.json b/src/package.nls.zh-CN.json index 1112abab7d6..49bee7e5089 100644 --- a/src/package.nls.zh-CN.json +++ b/src/package.nls.zh-CN.json @@ -43,5 +43,6 @@ "settings.useAgentRules.description": "为特定于代理的规则启用 AGENTS.md 文件的加载（请参阅 https://agent-rules.org/）", "settings.apiRequestTimeout.description": "等待 API 响应的最长时间（秒）（0 = 无超时，1-3600秒，默认值：600秒）。对于像 LM Studio 和 Ollama 这样可能需要更多处理时间的本地提供商，建议使用更高的值。", "settings.newTaskRequireTodos.description": "使用 new_task 工具创建新任务时需要 todos 参数", - "settings.codeIndex.embeddingBatchSize.description": "代码索引期间嵌入操作的批处理大小。根据 API 提供商的限制调整此设置。默认值为 60。" + "settings.codeIndex.embeddingBatchSize.description": "代码索引期间嵌入操作的批处理大小。根据 API 提供商的限制调整此设置。默认值为 60。", + "settings.toolProtocol.description": "用于 AI 交互的工具协议。XML 是默认且推荐的协议。本机是实验性的，可能不适用于所有提供商。" } diff --git a/src/package.nls.zh-TW.json b/src/package.nls.zh-TW.json index a212a7a3538..f970b215908 100644 --- a/src/package.nls.zh-TW.json +++ b/src/package.nls.zh-TW.json @@ -43,5 +43,6 @@ "settings.useAgentRules.description": "為特定於代理的規則啟用 AGENTS.md 檔案的載入（請參閱 https://agent-rules.org/）", "settings.apiRequestTimeout.description": "等待 API 回應的最長時間（秒）（0 = 無超時，1-3600秒，預設值：600秒）。對於像 LM Studio 和 Ollama 這樣可能需要更多處理時間的本地提供商，建議使用更高的值。", "settings.newTaskRequireTodos.description": "使用 new_task 工具建立新工作時需要 todos 參數", - "settings.codeIndex.embeddingBatchSize.description": "程式碼索引期間嵌入操作的批次大小。根據 API 提供商的限制調整此設定。預設值為 60。" + "settings.codeIndex.embeddingBatchSize.description": "程式碼索引期間嵌入操作的批次大小。根據 API 提供商的限制調整此設定。預設值為 60。", + "settings.toolProtocol.description": "用於 AI 互動的工具協議。XML 是預設且推薦的協議。本機是實驗性的，可能不適用於所有提供商。" } diff --git a/src/shared/tools.ts b/src/shared/tools.ts index 61e84027272..410c09b5c3e 100644 --- a/src/shared/tools.ts +++ b/src/shared/tools.ts @@ -1,6 +1,14 @@ import { Anthropic } from "@anthropic-ai/sdk" -import type { ClineAsk, ToolProgressStatus, ToolGroup, ToolName } from "@roo-code/types" +import type { + ClineAsk, + ToolProgressStatus, + ToolGroup, + ToolName, + FileEntry, + BrowserActionParams, + GenerateImageParams, +} from "@roo-code/types" export type ToolResponse = string | Array @@ -62,105 +70,144 @@ export const toolParamNames = [ "todos", "prompt", "image", + "files", // Native protocol parameter for read_file ] as const export type ToolParamName = (typeof toolParamNames)[number] -export interface ToolUse { +export type ToolProtocol = "xml" | "native" + +/** + * Type map defining the native (typed) argument structure for each tool. + * Tools not listed here will fall back to `any` for backward compatibility. + */ +export type NativeToolArgs = { + read_file: FileEntry[] + attempt_completion: { result: string } + execute_command: { command: string; cwd?: string } + insert_content: { path: string; line: number; content: string } + apply_diff: { path: string; diff: string } + ask_followup_question: { + question: string + follow_up: Array<{ text: string; mode?: string }> + } + browser_action: BrowserActionParams + codebase_search: { query: string; path?: string } + fetch_instructions: { task: string } + generate_image: GenerateImageParams + list_code_definition_names: { path: string } + run_slash_command: { command: string; args?: string } + search_files: { path: string; regex: string; file_pattern?: string | null } + switch_mode: { mode_slug: string; reason: string } + update_todo_list: { todos: string } + use_mcp_tool: { server_name: string; tool_name: string; arguments?: Record } + write_to_file: { path: string; content: string; line_count: number } + // Add more tools as they are migrated to native protocol +} + +/** + * Generic ToolUse interface that provides proper typing for both protocols. + * + * @template TName - The specific tool name, which determines the nativeArgs type + */ +export interface ToolUse { type: "tool_use" - name: ToolName + id?: string // Optional ID to track tool calls + name: TName // params is a partial record, allowing only some or none of the possible parameters to be used params: Partial> partial: boolean + // nativeArgs is properly typed based on TName if it's in NativeToolArgs, otherwise never + nativeArgs?: TName extends keyof NativeToolArgs ? NativeToolArgs[TName] : never } -export interface ExecuteCommandToolUse extends ToolUse { +export interface ExecuteCommandToolUse extends ToolUse<"execute_command"> { name: "execute_command" // Pick, "command"> makes "command" required, but Partial<> makes it optional params: Partial, "command" | "cwd">> } -export interface ReadFileToolUse extends ToolUse { +export interface ReadFileToolUse extends ToolUse<"read_file"> { name: "read_file" - params: Partial, "args" | "path" | "start_line" | "end_line">> + params: Partial, "args" | "path" | "start_line" | "end_line" | "files">> } -export interface FetchInstructionsToolUse extends ToolUse { +export interface FetchInstructionsToolUse extends ToolUse<"fetch_instructions"> { name: "fetch_instructions" params: Partial, "task">> } -export interface WriteToFileToolUse extends ToolUse { +export interface WriteToFileToolUse extends ToolUse<"write_to_file"> { name: "write_to_file" params: Partial, "path" | "content" | "line_count">> } -export interface InsertCodeBlockToolUse extends ToolUse { +export interface InsertCodeBlockToolUse extends ToolUse<"insert_content"> { name: "insert_content" params: Partial, "path" | "line" | "content">> } -export interface CodebaseSearchToolUse extends ToolUse { +export interface CodebaseSearchToolUse extends ToolUse<"codebase_search"> { name: "codebase_search" params: Partial, "query" | "path">> } -export interface SearchFilesToolUse extends ToolUse { +export interface SearchFilesToolUse extends ToolUse<"search_files"> { name: "search_files" params: Partial, "path" | "regex" | "file_pattern">> } -export interface ListFilesToolUse extends ToolUse { +export interface ListFilesToolUse extends ToolUse<"list_files"> { name: "list_files" params: Partial, "path" | "recursive">> } -export interface ListCodeDefinitionNamesToolUse extends ToolUse { +export interface ListCodeDefinitionNamesToolUse extends ToolUse<"list_code_definition_names"> { name: "list_code_definition_names" params: Partial, "path">> } -export interface BrowserActionToolUse extends ToolUse { +export interface BrowserActionToolUse extends ToolUse<"browser_action"> { name: "browser_action" params: Partial, "action" | "url" | "coordinate" | "text" | "size">> } -export interface UseMcpToolToolUse extends ToolUse { +export interface UseMcpToolToolUse extends ToolUse<"use_mcp_tool"> { name: "use_mcp_tool" params: Partial, "server_name" | "tool_name" | "arguments">> } -export interface AccessMcpResourceToolUse extends ToolUse { +export interface AccessMcpResourceToolUse extends ToolUse<"access_mcp_resource"> { name: "access_mcp_resource" params: Partial, "server_name" | "uri">> } -export interface AskFollowupQuestionToolUse extends ToolUse { +export interface AskFollowupQuestionToolUse extends ToolUse<"ask_followup_question"> { name: "ask_followup_question" params: Partial, "question" | "follow_up">> } -export interface AttemptCompletionToolUse extends ToolUse { +export interface AttemptCompletionToolUse extends ToolUse<"attempt_completion"> { name: "attempt_completion" params: Partial, "result">> } -export interface SwitchModeToolUse extends ToolUse { +export interface SwitchModeToolUse extends ToolUse<"switch_mode"> { name: "switch_mode" params: Partial, "mode_slug" | "reason">> } -export interface NewTaskToolUse extends ToolUse { +export interface NewTaskToolUse extends ToolUse<"new_task"> { name: "new_task" params: Partial, "mode" | "message" | "todos">> } -export interface RunSlashCommandToolUse extends ToolUse { +export interface RunSlashCommandToolUse extends ToolUse<"run_slash_command"> { name: "run_slash_command" params: Partial, "command" | "args">> } -export interface GenerateImageToolUse extends ToolUse { +export interface GenerateImageToolUse extends ToolUse<"generate_image"> { name: "generate_image" params: Partial, "prompt" | "path" | "image">> }