@travisennis/acai 0.0.9 → 0.0.11

package/dist/agent/index.js

@@ -1,41 +1,44 @@
-import { generateText, InvalidToolInputError, NoOutputGeneratedError, NoSuchToolError, Output, streamText, tool, } from "ai";
-import { config } from "../config.js";
-import { logger } from "../logger.js";
+import { generateText, InvalidToolInputError, NoOutputGeneratedError, NoSuchToolError, Output, streamText, } from "ai";
 import { AiConfig } from "../models/ai-config.js";
+import { toAiSdkTools } from "../tools/utils.js";
+import { logger } from "../utils/logger.js";
 export class Agent {
     opts;
+    config;
     _state;
     abortController;
     constructor(opts) {
         this.opts = opts;
+        this.config = opts.config;
         this.abortController = new AbortController();
         this._state = this.resetState();
     }
+    setConfig(config) {
+        this.config = config;
+    }
     get state() {
         return this._state;
     }
     get abortSignal() {
         return this.abortController.signal;
     }
+    // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: will be refactored in a future task
     async *run(args) {
-        const { modelManager, sessionManager, tokenTracker, maxIterations = (await config.getConfig()).loop.maxIterations, maxRetries = 2, } = this.opts;
+        yield {
+            type: "agent-start",
+        };
+        const { systemPrompt, input, tools, activeTools, abortSignal } = args;
         this.resetState();
         this._state.timestamps.start = performance.now();
-        const { systemPrompt, input, tools, activeTools, abortSignal } = args;
+        const { modelManager, sessionManager, tokenTracker } = this.opts;
+        const maxIterations = args.maxIterations ?? this.config.loop.maxIterations ?? 200;
+        const maxRetries = args.maxRetries ?? 2;
         const langModel = modelManager.getModel("repl");
         const modelConfig = modelManager.getModelMetadata("repl");
         const aiConfig = new AiConfig({
             modelMetadata: modelConfig,
             prompt: input,
         });
-        yield {
-            type: "agent-start",
-        };
-        yield {
-            type: "message",
-            role: "user",
-            content: input,
-        };
         let iter = 0;
         let consecutiveErrors = 0;
         let hasEmittedTerminalEvent = false;
@@ -57,18 +60,18 @@ export class Agent {
                 if (abortSignal?.aborted) {
                     throw new Error("Agent aborted before streamText");
                 }
+                const messages = sessionManager.get();
+                const aiSdkTools = toAiSdkTools(tools, false);
                 const result = streamText({
                     model: langModel,
                     maxOutputTokens: aiConfig.maxOutputTokens(),
                     system: systemPrompt,
-                    messages: sessionManager.get(),
+                    messages,
                     temperature: aiConfig.temperature(),
                     topP: aiConfig.topP(),
                     maxRetries: 2,
                     providerOptions: aiConfig.providerOptions(),
-                    tools: Object.fromEntries(
-                    // biome-ignore lint/suspicious/noExplicitAny: temporary
-                    Object.entries(tools).map((t) => [t[0], tool(t[1].toolDef)])),
+                    tools: aiSdkTools,
                     activeTools,
                     // biome-ignore lint/style/useNamingConvention: third-party controlled
                     experimental_repairToolCall: toolCallRepair(modelManager),
@@ -98,195 +101,58 @@ export class Agent {
                     toolCalls: thisStepToolCalls,
                     toolResults: thisStepToolResults,
                 });
-                const toolMessages = [];
+                const pendingToolCalls = [];
                 for await (const chunk of result.fullStream) {
-                    if (chunk.type === "reasoning-start") {
-                        yield {
-                            type: "thinking-start",
-                            content: "",
-                        };
-                    }
-                    else if (chunk.type === "reasoning-delta") {
-                        accumulatedReasoning += chunk.text;
-                        yield {
-                            type: "thinking",
-                            content: accumulatedReasoning,
-                        };
-                    }
-                    else if (chunk.type === "reasoning-end") {
-                        yield {
-                            type: "thinking-end",
-                            content: accumulatedReasoning,
-                        };
-                    }
-                    else if (chunk.type === "text-start") {
-                        yield {
-                            type: "message-start",
-                            role: "assistant",
-                            content: "",
-                        };
-                    }
-                    else if (chunk.type === "text-delta") {
-                        accumulatedText += chunk.text;
-                        yield {
-                            type: "message",
-                            role: "assistant",
-                            content: accumulatedText,
-                        };
-                    }
-                    else if (chunk.type === "text-end") {
-                        yield {
-                            type: "message-end",
-                            role: "assistant",
-                            content: accumulatedText,
-                        };
-                    }
-                    else if (chunk.type === "tool-call") {
-                        const call = chunk;
-                        const toolName = call.toolName;
-                        const iTool = tools[toolName];
-                        yield this.processToolEvent(toolsCalled, {
-                            type: "tool-call-start",
-                            name: toolName,
-                            toolCallId: call.toolCallId,
-                            // biome-ignore lint/suspicious/noExplicitAny: unknown
-                            msg: iTool ? iTool.display(call.input) : "",
-                            args: call.input,
-                        });
-                        if (call.invalid) {
-                            yield this.processToolEvent(toolsCalled, {
-                                type: "tool-call-error",
-                                name: call.toolName,
-                                toolCallId: call.toolCallId,
-                                msg: String(call.error),
-                                args: call.input,
-                            });
-                            continue;
-                        }
-                        let resultOutput = "Unknown result.";
-                        try {
-                            thisStepToolCalls.push({ toolName });
-                            thisStepToolResults.push({ toolName });
-                            const iTool = tools[toolName];
-                            if (!iTool) {
-                                resultOutput = `No executor for tool ${toolName}`;
-                            }
-                            else {
-                                // Pre-validate tool input to catch malformed JSON early
-                                if (typeof call.input === "string") {
-                                    // If input is a string, try to validate it's proper JSON
-                                    try {
-                                        JSON.parse(call.input);
-                                    }
-                                    catch {
-                                        // Malformed JSON detected - emit error and skip execution
-                                        const errorMsg = `Invalid tool input: malformed JSON. Received: "${call.input.slice(0, 50)}${call.input.length > 50 ? "..." : ""}". Expected a JSON object.`;
-                                        yield this.processToolEvent(toolsCalled, {
-                                            type: "tool-call-error",
-                                            name: toolName,
-                                            toolCallId: call.toolCallId,
-                                            msg: errorMsg,
-                                            args: null,
-                                        });
-                                        continue;
-                                    }
-                                }
-                                else if (call.input === null || call.input === undefined) {
-                                    // Null/undefined input
-                                    const errorMsg = "Invalid tool input: received null/undefined. Expected a JSON object matching the schema.";
-                                    yield this.processToolEvent(toolsCalled, {
-                                        type: "tool-call-error",
-                                        name: toolName,
-                                        toolCallId: call.toolCallId,
-                                        msg: errorMsg,
-                                        args: null,
-                                    });
-                                    continue;
-                                }
-                                const toolExec = iTool.execute;
-                                try {
-                                    const output = await toolExec(call.input, {
-                                        toolCallId: call.toolCallId,
-                                        messages: sessionManager.get(),
-                                        abortSignal,
-                                    });
-                                    resultOutput = formatToolResult(output);
-                                    yield this.processToolEvent(toolsCalled, {
-                                        type: "tool-call-end",
-                                        name: call.toolName,
-                                        toolCallId: call.toolCallId,
-                                        msg: resultOutput,
-                                        args: call.input,
-                                    });
-                                }
-                                catch (err) {
-                                    resultOutput = `Tool error: ${err instanceof Error ? err.message : String(err)}`;
-                                    yield this.processToolEvent(toolsCalled, {
-                                        type: "tool-call-error",
-                                        name: toolName,
-                                        toolCallId: call.toolCallId,
-                                        msg: resultOutput,
-                                        args: null,
-                                    });
-                                }
-                            }
-                        }
-                        catch (error) {
-                            resultOutput = `Tool error: ${error instanceof Error ? error.message : String(error)}`;
-                            yield this.processToolEvent(toolsCalled, {
-                                type: "tool-call-error",
-                                name: toolName,
-                                toolCallId: call.toolCallId,
-                                msg: resultOutput,
-                                args: null,
-                            });
-                        }
-                        toolMessages.push({
-                            role: "tool",
-                            content: [
-                                {
-                                    type: "tool-result",
-                                    toolName,
-                                    toolCallId: call.toolCallId,
-                                    output: {
-                                        type: "text",
-                                        value: resultOutput,
-                                    },
-                                },
-                            ],
-                        });
+                    const event = this.handleStreamChunk(chunk, {
+                        accumulatedText,
+                        accumulatedReasoning,
+                        toolsCalled,
+                        tools,
+                        pendingToolCalls,
+                    });
+                    if (event) {
+                        accumulatedText = event.accumulatedText;
+                        accumulatedReasoning = event.accumulatedReasoning;
+                        yield event.agentEvent;
                     }
                 }
+                // ============================================================
+                // PARALLEL TOOL EXECUTION
+                // ============================================================
+                const { collectedEvents, parallelToolMessages } = await this.executeToolsInParallel({
+                    pendingToolCalls,
+                    abortSignal,
+                    toolsCalled,
+                    stepToolCalls: thisStepToolCalls,
+                    stepToolResults: thisStepToolResults,
+                });
+                // Yield all collected events in order
+                for (const event of collectedEvents) {
+                    yield event;
+                }
                 // Get response and tool calls
                 const response = await result.response;
                 const responseMessages = response.messages;
-                sessionManager.appendResponseMessages(responseMessages);
+                // Filter out tool-result messages from responseMessages since we manually
+                // execute tools and add their results via appendToolMessages below.
+                // The AI SDK may include tool-result messages in response.messages even
+                // when tools don't have an execute function.
+                const nonToolMessages = responseMessages.filter((msg) => msg.role !== "tool");
+                sessionManager.appendResponseMessages(nonToolMessages);
                 const stepUsage = await result.usage;
-                this._state.usage.inputTokens = stepUsage.inputTokens ?? 0;
-                this._state.usage.outputTokens = stepUsage.outputTokens ?? 0;
-                this._state.usage.totalTokens = stepUsage.totalTokens ?? 0;
-                this._state.usage.cachedInputTokens =
-                    stepUsage.inputTokenDetails.cacheReadTokens ?? 0;
-                this._state.usage.reasoningTokens =
-                    stepUsage.outputTokenDetails.reasoningTokens ?? 0;
-                sessionManager.setContextWindow(stepUsage.totalTokens ?? 0);
-                this._state.totalUsage.inputTokens += stepUsage.inputTokens ?? 0;
-                this._state.totalUsage.outputTokens += stepUsage.outputTokens ?? 0;
-                this._state.totalUsage.totalTokens += stepUsage.totalTokens ?? 0;
-                this._state.totalUsage.cachedInputTokens +=
-                    stepUsage.inputTokenDetails.cacheReadTokens ?? 0;
-                this._state.totalUsage.reasoningTokens +=
-                    stepUsage.outputTokenDetails.reasoningTokens ?? 0;
+                this.updateUsageStats(stepUsage, sessionManager);
                 // If finishReason is not tool-calls, break
                 const finishReason = await result.finishReason;
                 if (finishReason !== "tool-calls") {
+                    // Track aggregate usage before yielding agent-stop so footer can display it
+                    tokenTracker.trackUsage("repl", this._state.totalUsage);
                     yield {
                         type: "agent-stop",
                     };
                     hasEmittedTerminalEvent = true;
                     break;
                 }
-                sessionManager.appendToolMessages(toolMessages);
+                sessionManager.appendToolMessages(parallelToolMessages);
                 // Consume the rest of the team if necessary
                 // await result.consumeStream();
                 yield {
@@ -307,8 +173,30 @@ export class Agent {
                     // Continue loop to allow user to provide corrected input
                 }
                 else {
-                    logger.error(error, // Log the full error object
-                    `Error on manual agent loop streamText (attempt ${consecutiveErrors}/${maxRetries + 1})`);
+                    // Extract additional error context for better debugging
+                    const err = error;
+                    const errorContext = {
+                        modelId: modelConfig?.id ?? langModel.modelId ?? "unknown",
+                        sessionId: sessionManager.getSessionId(),
+                        messageCount: sessionManager.get().length,
+                        attempt: consecutiveErrors,
+                        maxRetries,
+                    };
+                    // Add response info if available (common for Bad Request errors from AI SDK)
+                    if (err.cause) {
+                        const cause = err.cause;
+                        if (cause.response) {
+                            errorContext["responseStatus"] = cause.response.status;
+                            errorContext["responseStatusText"] = cause.response.statusText;
+                            // Add body snippet if available (truncated to avoid log bloat)
+                            if (cause.response.body &&
+                                typeof cause.response.body === "object") {
+                                const body = cause.response.body;
+                                errorContext["responseBody"] = JSON.stringify(body).slice(0, 500);
+                            }
+                        }
+                    }
+                    logger.error({ ...errorContext, error: err }, `Error on manual agent loop streamText (attempt ${consecutiveErrors}/${maxRetries + 1})`);
                     const errorMsg = error.message.length > 100
                         ? `${error.message.slice(0, 100)}...`
                         : error.message;
@@ -337,12 +225,12 @@ export class Agent {
         }
         // Emit agent-stop if loop ended without emitting a terminal event (maxIterations reached)
         if (!hasEmittedTerminalEvent) {
+            // Track aggregate usage before yielding agent-stop so footer can display it
+            tokenTracker.trackUsage("repl", this._state.totalUsage);
             yield {
                 type: "agent-stop",
             };
         }
-        // Track aggregate usage across all steps when available
-        tokenTracker.trackUsage("repl", this._state.totalUsage);
     }
     abort() {
         this.abortController.abort();
@@ -396,6 +284,124 @@ export class Agent {
         };
         return this._state;
     }
+    handleStreamChunk(
+    // biome-ignore lint/suspicious/noExplicitAny: chunk type from AI SDK fullStream is a complex discriminated union
+    chunk, ctx) {
+        if (chunk.type === "reasoning-start") {
+            return {
+                agentEvent: { type: "thinking-start", content: "" },
+                accumulatedText: ctx.accumulatedText,
+                accumulatedReasoning: ctx.accumulatedReasoning,
+            };
+        }
+        if (chunk.type === "reasoning-delta") {
+            const accumulatedReasoning = ctx.accumulatedReasoning + chunk.text;
+            return {
+                agentEvent: { type: "thinking", content: accumulatedReasoning },
+                accumulatedText: ctx.accumulatedText,
+                accumulatedReasoning,
+            };
+        }
+        if (chunk.type === "reasoning-end") {
+            return {
+                agentEvent: {
+                    type: "thinking-end",
+                    content: ctx.accumulatedReasoning,
+                },
+                accumulatedText: ctx.accumulatedText,
+                accumulatedReasoning: ctx.accumulatedReasoning,
+            };
+        }
+        if (chunk.type === "text-start") {
+            return {
+                agentEvent: { type: "message-start", role: "assistant", content: "" },
+                accumulatedText: ctx.accumulatedText,
+                accumulatedReasoning: ctx.accumulatedReasoning,
+            };
+        }
+        if (chunk.type === "text-delta") {
+            const accumulatedText = ctx.accumulatedText + chunk.text;
+            return {
+                agentEvent: {
+                    type: "message",
+                    role: "assistant",
+                    content: accumulatedText,
+                },
+                accumulatedText,
+                accumulatedReasoning: ctx.accumulatedReasoning,
+            };
+        }
+        if (chunk.type === "text-end") {
+            return {
+                agentEvent: {
+                    type: "message-end",
+                    role: "assistant",
+                    content: ctx.accumulatedText,
+                },
+                accumulatedText: ctx.accumulatedText,
+                accumulatedReasoning: ctx.accumulatedReasoning,
+            };
+        }
+        if (chunk.type === "tool-call") {
+            const call = chunk;
+            const toolName = call.toolName;
+            const iTool = ctx.tools[toolName];
+            const agentEvent = this.processToolEvent(ctx.toolsCalled, {
+                type: "tool-call-start",
+                name: toolName,
+                toolCallId: call.toolCallId,
+                // biome-ignore lint/suspicious/noExplicitAny: unknown
+                msg: iTool ? iTool.display(call.input) : "",
+                args: call.input,
+            });
+            ctx.pendingToolCalls.push({ call, toolName, iTool });
+            return {
+                agentEvent,
+                accumulatedText: ctx.accumulatedText,
+                accumulatedReasoning: ctx.accumulatedReasoning,
+            };
+        }
+        return null;
+    }
+    updateUsageStats(stepUsage, sessionManager) {
+        // Extract values with null coalescing once
+        const inputTokens = stepUsage.inputTokens ?? 0;
+        const outputTokens = stepUsage.outputTokens ?? 0;
+        const totalTokens = stepUsage.totalTokens ?? 0;
+        const cacheReadTokens = stepUsage.inputTokenDetails.cacheReadTokens ?? 0;
+        const reasoningTokens = stepUsage.outputTokenDetails.reasoningTokens ?? 0;
+        // Update step usage
+        this._state.usage.inputTokens = inputTokens;
+        this._state.usage.outputTokens = outputTokens;
+        this._state.usage.totalTokens = totalTokens;
+        this._state.usage.cachedInputTokens = cacheReadTokens;
+        this._state.usage.inputTokenDetails.cacheReadTokens = cacheReadTokens;
+        this._state.usage.reasoningTokens = reasoningTokens;
+        sessionManager.setContextWindow(totalTokens);
+        // Update total usage (accumulate)
+        this._state.totalUsage.inputTokens += inputTokens;
+        this._state.totalUsage.outputTokens += outputTokens;
+        this._state.totalUsage.totalTokens += totalTokens;
+        this._state.totalUsage.cachedInputTokens += cacheReadTokens;
+        this._state.totalUsage.inputTokenDetails.cacheReadTokens += cacheReadTokens;
+        this._state.totalUsage.reasoningTokens += reasoningTokens;
+        sessionManager.recordTurnUsage({
+            inputTokens,
+            outputTokens,
+            totalTokens,
+            cachedInputTokens: cacheReadTokens,
+            reasoningTokens,
+            inputTokenDetails: {
+                noCacheTokens: stepUsage.inputTokenDetails.noCacheTokens ?? 0,
+                cacheReadTokens,
+                cacheWriteTokens: stepUsage.inputTokenDetails.cacheWriteTokens ?? 0,
+            },
+            outputTokenDetails: {
+                textTokens: stepUsage.outputTokenDetails.textTokens ?? 0,
+                reasoningTokens,
+            },
+        });
+    }
     processToolEvent(toolsCalled, event) {
         const toolCallId = event.toolCallId;
         let events;
@@ -420,6 +426,172 @@ export class Agent {
             events,
         };
     }
+    async executeToolsInParallel({ pendingToolCalls, abortSignal, toolsCalled, stepToolCalls, stepToolResults, }) {
+        const results = new Array(pendingToolCalls.length);
+        const collectedEvents = [];
+        // Phase 2a: Validate all inputs first (before any execution)
+        const validationErrors = this.validateToolInputs(pendingToolCalls);
+        // Emit validation errors and mark those tools as failed
+        for (const { index, error } of validationErrors) {
+            const { call, toolName } = pendingToolCalls[index];
+            const event = this.processToolEvent(toolsCalled, {
+                type: "tool-call-error",
+                name: toolName,
+                toolCallId: call.toolCallId,
+                msg: error,
+                args: null,
+            });
+            collectedEvents.push(event);
+            results[index] = {
+                toolCallId: call.toolCallId,
+                toolName,
+                resultOutput: error,
+                success: false,
+            };
+        }
+        // Phase 2b: Execute valid tools in parallel
+        const sessionManager = this.opts.sessionManager;
+        const executionPromises = pendingToolCalls.map(async (pending, index) => {
+            if (validationErrors.some((e) => e.index === index)) {
+                return;
+            }
+            await this.executeSingleTool({
+                pending,
+                index,
+                sessionManager,
+                abortSignal,
+                toolsCalled,
+                collectedEvents,
+                results,
+                stepToolCalls,
+                stepToolResults,
+            });
+        });
+        // Wait for all executions to complete
+        await Promise.allSettled(executionPromises);
+        // Phase 2c: Build toolMessages in original call order
+        const parallelToolMessages = this.buildToolMessages(results);
+        return { collectedEvents, parallelToolMessages };
+    }
+    validateToolInputs(pendingToolCalls) {
+        const validationErrors = [];
+        for (let i = 0; i < pendingToolCalls.length; i++) {
+            const { call } = pendingToolCalls[i];
+            // Check for invalid call from AI SDK
+            if (call.invalid) {
+                validationErrors.push({
+                    index: i,
+                    error: String(call.error),
+                });
+                continue;
+            }
+            // Validate JSON input
+            if (typeof call.input === "string") {
+                try {
+                    JSON.parse(call.input);
+                }
+                catch {
+                    validationErrors.push({
+                        index: i,
+                        error: `Invalid tool input: malformed JSON. Received: "${call.input.slice(0, 50)}${call.input.length > 50 ? "..." : ""}". Expected a JSON object.`,
+                    });
+                }
+            }
+            else if (call.input === null || call.input === undefined) {
+                validationErrors.push({
+                    index: i,
+                    error: "Invalid tool input: received null/undefined. Expected a JSON object matching the schema.",
+                });
+            }
+        }
+        return validationErrors;
+    }
+    async executeSingleTool({ pending, index, sessionManager, abortSignal, toolsCalled, collectedEvents, results, stepToolCalls, stepToolResults, }) {
+        const { call, toolName, iTool } = pending;
+        // Track in step stats
+        stepToolCalls.push({ toolName });
+        if (!iTool) {
+            const errorMsg = `No executor for tool ${toolName}`;
+            const event = this.processToolEvent(toolsCalled, {
+                type: "tool-call-error",
+                name: toolName,
+                toolCallId: call.toolCallId,
+                msg: errorMsg,
+                args: null,
+            });
+            collectedEvents.push(event);
+            results[index] = {
+                toolCallId: call.toolCallId,
+                toolName,
+                resultOutput: errorMsg,
+                success: false,
+            };
+            return;
+        }
+        const toolExec = iTool.execute;
+        try {
+            const output = await toolExec(call.input, {
+                toolCallId: call.toolCallId,
+                messages: sessionManager.get(),
+                abortSignal,
+            });
+            const resultOutput = formatToolResult(output);
+            const event = this.processToolEvent(toolsCalled, {
+                type: "tool-call-end",
+                name: call.toolName,
+                toolCallId: call.toolCallId,
+                msg: resultOutput,
+                args: call.input,
+            });
+            collectedEvents.push(event);
+            stepToolResults.push({ toolName });
+            results[index] = {
+                toolCallId: call.toolCallId,
+                toolName,
+                resultOutput,
+                success: true,
+            };
+        }
+        catch (err) {
+            const resultOutput = `Tool error: ${err instanceof Error ? err.message : String(err)}`;
+            const event = this.processToolEvent(toolsCalled, {
+                type: "tool-call-error",
+                name: toolName,
+                toolCallId: call.toolCallId,
+                msg: resultOutput,
+                args: null,
+            });
+            collectedEvents.push(event);
+            results[index] = {
+                toolCallId: call.toolCallId,
+                toolName,
+                resultOutput,
+                success: false,
+            };
+        }
+    }
+    buildToolMessages(results) {
+        const parallelToolMessages = [];
+        for (const result of results) {
+            if (!result)
+                continue; // Skip if somehow undefined
+            parallelToolMessages.push({
+                role: "tool",
+                content: [
+                    {
+                        type: "tool-result",
+                        toolName: result.toolName,
+                        toolCallId: result.toolCallId,
+                        output: {
+                            type: "text",
+                            value: result.resultOutput,
+                        },
+                    },
+                ],
+            });
+        }
+        return parallelToolMessages;
+    }
 }
 function formatToolResult(value) {
     if (typeof value === "string") {
@@ -450,6 +622,7 @@ const toolCallRepair = (modelManager) => {
         if (NoSuchToolError.isInstance(error)) {
             return null; // do not attempt to fix invalid tool names
         }
+        logger.error(`Attemping to repair tool call: ${toolCall.toolName} - ${toolCall.input}`);
         const tool = tools[toolCall.toolName];
         try {
             const { output: repairedArgs } = await generateText({
@@ -458,11 +631,19 @@ const toolCallRepair = (modelManager) => {
                     schema: tool.inputSchema,
                 }),
                 prompt: [
-                    `The model tried to call the tool "${toolCall.toolName}" with the following arguments:`,
-                    JSON.stringify(toolCall.input),
-                    "The tool accepts the following schema:",
-                    JSON.stringify(inputSchema(toolCall)),
-                    "Please fix the arguments.",
+                    `The model tried to call the tool "${toolCall.toolName}" but the input did not match the expected schema.`,
+                    "",
+                    "<invalid_input>",
+                    JSON.stringify(toolCall.input, null, 2),
+                    "</invalid_input>",
+                    "",
+                    "<expected_schema>",
+                    JSON.stringify(await inputSchema({ toolName: toolCall.toolName }), null, 2),
+                    "</expected_schema>",
+                    "",
+                    "If any field is missing or undefined in the corrected input, you MUST explicitly set its value to null. Do NOT omit fields - every field in the schema must be present, even if with a null value.",
+                    "",
+                    "Return a corrected version of the input that conforms to the expected schema.",
                 ].join("\n"),
             });
             return { ...toolCall, args: JSON.stringify(repairedArgs) };