Method execute

src/tools/registry.ts:414–455

(name: string, args: unknown, ctx: ToolContext)

      tools = tools.filter(t => t.name !== 'present_plan');
    }

    if (mode.allowedTools) {
      tools = tools.filter(t => mode.allowedTools!.includes(t.name));
    }
    if (mode.blockedTools) {
      tools = tools.filter(t => !mode.blockedTools!.includes(t.name));
    }

    return tools;
  }

  async execute(name: string, args: unknown, ctx: ToolContext): Promise<ToolResult> {
    const tool = this.tools.get(this.resolveName(name));
    if (!tool) {
      // Suggest the closest known tool name to nudge the model onto the right one.
      const known = Array.from(this.tools.keys());
      const guess = known.find(k => k.includes(name) || name.includes(k));
      const hint = guess ? ` Did you mean "${guess}"?` : ` Use one of the listed tools (e.g. "shell" for commands).`;
      return { content: `[ERROR] Unknown tool: ${name}.${hint}`, isError: true };
    }

    // Validate args. Two normalization passes BEFORE zod (schema stays strict, so the
    // JSON schema the model sees is unchanged):
    //   1. tool.coerceArgs  — tool-specific fixups (e.g. todo_write's stringy ids).
    //   2. coerceArgsToSchema — generic, schema-guided repair of unambiguous type
    //      mistakes ("5"→5, JSON-string→array, "true"→true). Backend-agnostic; turns
    //      a class of would-be ARGUMENT_VALIDATION_ERRORs into successful calls.
    let parsed: any;
    try {
      const jsonSchema = tool.schema().function.parameters as JsonSchemaNode;
      parsed = tool.argsSchema.parse(coerceArgsToSchema(tool.coerceArgs(args), jsonSchema));
    } catch (e: any) {
      const errMsg = e.errors
        ? e.errors.map((err: any) => `${err.path.join('.')}: ${err.message}`).join('; ')
        : e.message;
      return {
        content: `[ARGUMENT_VALIDATION_ERROR] ${errMsg}\nProvided args: ${JSON.stringify(args)}\nFix your tool arguments and try again.`,
        isError: true,
      };
    }

    logger.debug('Executing tool', { name, args: parsed });

    try {
      const result = await tool.execute(parsed, ctx);