@travisennis/acai 0.0.6 → 0.0.8

package/dist/agent/index.js

@@ -1,8 +1,7 @@
-import { NoOutputGeneratedError, streamText, } from "ai";
+import { generateText, InvalidToolInputError, NoOutputGeneratedError, NoSuchToolError, Output, streamText, tool, } from "ai";
+import { config } from "../config.js";
 import { logger } from "../logger.js";
 import { AiConfig } from "../models/ai-config.js";
-import { isToolMessage } from "../tools/types.js";
-import { isAsyncIterable } from "../utils/iterables.js";
 export class Agent {
     opts;
     _state;
@@ -19,10 +18,10 @@ export class Agent {
         return this.abortController.signal;
     }
     async *run(args) {
-        const { modelManager, messageHistory, tokenTracker, maxIterations = 90, maxRetries = 2, toolCallRepair, } = this.opts;
+        const { modelManager, sessionManager, tokenTracker, maxIterations = (await config.getConfig()).loop.maxIterations, maxRetries = 2, } = this.opts;
         this.resetState();
         this._state.timestamps.start = performance.now();
-        const { systemPrompt, input, toolDefs, executors, abortSignal } = args;
+        const { systemPrompt, input, tools, activeTools, abortSignal } = args;
         const langModel = modelManager.getModel("repl");
         const modelConfig = modelManager.getModelMetadata("repl");
         const aiConfig = new AiConfig({
@@ -39,35 +38,67 @@ export class Agent {
         };
         let iter = 0;
         let consecutiveErrors = 0;
+        let hasEmittedTerminalEvent = false;
         while (iter < maxIterations) {
             if (abortSignal?.aborted) {
                 logger.warn("The agent loop was aborted by the user.");
-                // terminal.warn("Operation aborted by user.");
                 yield {
                     type: "agent-stop",
                 };
+                hasEmittedTerminalEvent = true;
                 break;
             }
             yield {
                 type: "step-start",
             };
+            const toolsCalled = new Map();
             try {
+                // Check abort signal again before starting streamText
+                if (abortSignal?.aborted) {
+                    throw new Error("Agent aborted before streamText");
+                }
                 const result = streamText({
                     model: langModel,
                     maxOutputTokens: aiConfig.maxOutputTokens(),
                     system: systemPrompt,
-                    messages: messageHistory.get(),
+                    messages: sessionManager.get(),
                     temperature: aiConfig.temperature(),
                     topP: aiConfig.topP(),
                     maxRetries: 2,
                     providerOptions: aiConfig.providerOptions(),
-                    tools: toolDefs,
-                    // biome-ignore lint/style/useNamingConvention: third-party code
-                    experimental_repairToolCall: toolCallRepair,
+                    tools: Object.fromEntries(
+                    // biome-ignore lint/suspicious/noExplicitAny: temporary
+                    Object.entries(tools).map((t) => [t[0], tool(t[1].toolDef)])),
+                    activeTools,
+                    // biome-ignore lint/style/useNamingConvention: third-party controlled
+                    experimental_repairToolCall: toolCallRepair(modelManager),
                     abortSignal,
+                    onAbort: ({ steps }) => {
+                        logger.debug(`Aborting and processing ${steps.length} steps`);
+                        steps.forEach((step) => {
+                            sessionManager.appendResponseMessages(step.response.messages);
+                        });
+                    },
+                    onError({ error }) {
+                        if (typeof error === "object" &&
+                            error != null &&
+                            "message" in error) {
+                            logger.error(error.message);
+                        }
+                        else {
+                            logger.error(error);
+                        }
+                    },
                 });
                 let accumulatedText = "";
                 let accumulatedReasoning = "";
+                const thisStepToolCalls = [];
+                const thisStepToolResults = [];
+                this._state.steps.push({
+                    toolCalls: thisStepToolCalls,
+                    toolResults: thisStepToolResults,
+                });
+                const toolMessages = [];
                 for await (const chunk of result.fullStream) {
                     if (chunk.type === "reasoning-start") {
                         yield {
@@ -110,203 +141,121 @@ export class Agent {
                             content: accumulatedText,
                         };
                     }
-                }
-                // Get response and tool calls
-                const response = await result.response;
-                const responseMessages = response.messages;
-                messageHistory.appendResponseMessages(responseMessages);
-                const toolCalls = await result.toolCalls;
-                const thisStepToolCalls = [];
-                const thisStepToolResults = [];
-                this._state.steps.push({
-                    toolCalls: thisStepToolCalls,
-                    toolResults: thisStepToolResults,
-                });
-                // If finishReason is not tool-calls, break
-                const finishReason = await result.finishReason;
-                if (finishReason !== "tool-calls") {
-                    yield {
-                        type: "agent-stop",
-                    };
-                    break;
-                }
-                // Execute tools in parallel (order not guaranteed)
-                // Check response.messages for already-processed tool results
-                const alreadyProcessedToolCallIds = new Set();
-                // Look for tool results and tool errors in the response messages
-                for (const message of responseMessages) {
-                    if (message.role === "tool" && Array.isArray(message.content)) {
-                        for (const content of message.content) {
-                            if ((content.type === "tool-result" ||
-                                content.type === "tool-error") &&
-                                content.toolCallId) {
-                                logger.debug(content, "Invalid tool call:");
-                                yield {
-                                    type: "tool-call-start",
-                                    name: content.toolName,
-                                    toolCallId: content.toolCallId,
-                                    args: toolCalls.find((call) => call.toolCallId === content.toolCallId)?.input,
-                                    msg: "",
-                                };
-                                yield {
-                                    type: "tool-call-error",
-                                    name: content.toolName,
-                                    toolCallId: content.toolCallId,
-                                    msg: "invalid tool call",
-                                    args: toolCalls.find((call) => call.toolCallId === content.toolCallId)?.input,
-                                };
-                                alreadyProcessedToolCallIds.add(content.toolCallId);
-                            }
-                        }
-                    }
-                }
-                // Filter out tool calls that have already been processed or are invalid
-                const validToolCalls = toolCalls.filter((call) => !alreadyProcessedToolCallIds.has(call.toolCallId) &&
-                    // Also check if the tool call is marked as invalid by the AI SDK
-                    !call.invalid);
-                if (validToolCalls.length === 0) {
-                    // All tool calls were already processed by the AI SDK
-                    logger.debug(`All ${toolCalls.length} tool calls were already processed by AI SDK, skipping manual execution`);
-                    continue;
-                }
-                if (validToolCalls.length < toolCalls.length) {
-                    logger.debug(`Filtered out ${toolCalls.length - validToolCalls.length} already-processed tool calls, executing ${validToolCalls.length} remaining`);
-                }
-                // Process all tools
-                const toolMessages = [];
-                for (const call of validToolCalls) {
-                    const toolName = call.toolName;
-                    yield {
-                        type: "tool-call-start",
-                        name: toolName,
-                        toolCallId: call.toolCallId,
-                        msg: "",
-                        args: call.input,
-                    };
-                    let resultOutput = "Unknown result.";
-                    try {
-                        thisStepToolCalls.push({ toolName });
-                        thisStepToolResults.push({ toolName });
-                        const toolExec = executors.get(toolName);
-                        if (!toolExec) {
-                            resultOutput = `No executor for tool ${toolName}`;
+                    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;
                         }
-                        else {
-                            try {
-                                const output = await toolExec(call.input, {
-                                    toolCallId: call.toolCallId,
-                                    messages: messageHistory.get(),
-                                    abortSignal,
-                                });
-                                if (isAsyncIterable(output)) {
-                                    const toolResultValues = [];
-                                    for await (const value of output) {
-                                        if (isToolMessage(value)) {
-                                            switch (value.event) {
-                                                case "tool-completion":
-                                                    yield {
-                                                        type: "tool-call-end",
-                                                        name: value.name,
-                                                        toolCallId: value.id,
-                                                        msg: value.data,
-                                                        args: call.input,
-                                                    };
-                                                    break;
-                                                case "tool-error":
-                                                    yield {
-                                                        type: "tool-call-error",
-                                                        name: value.name,
-                                                        toolCallId: value.id,
-                                                        msg: value.data,
-                                                        args: call.input,
-                                                    };
-                                                    break;
-                                                case "tool-init":
-                                                    yield {
-                                                        type: "tool-call-update",
-                                                        name: value.name,
-                                                        toolCallId: value.id,
-                                                        msg: value.data,
-                                                        args: call.input,
-                                                    };
-                                                    break;
-                                                default:
-                                                    logger.debug(`Unhandled tool message event: ${value.event}`);
-                                                    break;
-                                            }
-                                        }
-                                        else {
-                                            toolResultValues.push(value);
-                                        }
-                                    }
-                                    const finalValue = toolResultValues.length > 0
-                                        ? toolResultValues.at(-1)
-                                        : undefined;
-                                    resultOutput = formatToolResult(finalValue);
-                                }
-                                else {
+                        let resultOutput = "Unknown result.";
+                        try {
+                            thisStepToolCalls.push({ toolName });
+                            thisStepToolResults.push({ toolName });
+                            const iTool = tools[toolName];
+                            if (!iTool) {
+                                resultOutput = `No executor for tool ${toolName}`;
+                            }
+                            else {
+                                const toolExec = iTool.execute;
+                                try {
+                                    const output = await toolExec(call.input, {
+                                        toolCallId: call.toolCallId,
+                                        messages: sessionManager.get(),
+                                        abortSignal,
+                                    });
                                     resultOutput = formatToolResult(output);
-                                    yield {
+                                    yield this.processToolEvent(toolsCalled, {
                                         type: "tool-call-end",
                                         name: call.toolName,
                                         toolCallId: call.toolCallId,
-                                        msg: "success",
+                                        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 (err) {
-                                resultOutput = `Tool error: ${err instanceof Error ? err.message : String(err)}`;
-                                yield {
-                                    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 {
-                            type: "tool-call-error",
-                            name: toolName,
-                            toolCallId: call.toolCallId,
-                            msg: resultOutput,
-                            args: null,
-                        };
-                    }
-                    toolMessages.push({
-                        role: "tool",
-                        content: [
-                            {
-                                type: "tool-result",
-                                toolName,
+                        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,
-                                output: {
-                                    type: "text",
-                                    value: resultOutput,
+                                msg: resultOutput,
+                                args: null,
+                            });
+                        }
+                        toolMessages.push({
+                            role: "tool",
+                            content: [
+                                {
+                                    type: "tool-result",
+                                    toolName,
+                                    toolCallId: call.toolCallId,
+                                    output: {
+                                        type: "text",
+                                        value: resultOutput,
+                                    },
                                 },
-                            },
-                        ],
-                    });
+                            ],
+                        });
+                    }
                 }
-                messageHistory.appendToolMessages(toolMessages);
-                // Calculate usage for the current step/iteration
+                // Get response and tool calls
+                const response = await result.response;
+                const responseMessages = response.messages;
+                sessionManager.appendResponseMessages(responseMessages);
                 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.cachedInputTokens ?? 0;
-                this._state.usage.reasoningTokens = stepUsage.reasoningTokens ?? 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.cachedInputTokens ?? 0;
+                    stepUsage.inputTokenDetails.cacheReadTokens ?? 0;
                 this._state.totalUsage.reasoningTokens +=
-                    stepUsage.reasoningTokens ?? 0;
+                    stepUsage.outputTokenDetails.reasoningTokens ?? 0;
+                // If finishReason is not tool-calls, break
+                const finishReason = await result.finishReason;
+                if (finishReason !== "tool-calls") {
+                    yield {
+                        type: "agent-stop",
+                    };
+                    hasEmittedTerminalEvent = true;
+                    break;
+                }
+                sessionManager.appendToolMessages(toolMessages);
                 // Consume the rest of the team if necessary
                 // await result.consumeStream();
                 yield {
@@ -317,17 +266,29 @@ export class Agent {
             }
             catch (error) {
                 consecutiveErrors += 1;
-                logger.error(error, // Log the full error object
-                `Error on manual agent loop streamText (attempt ${consecutiveErrors}/${maxRetries + 1})`);
-                const errorMsg = error.message.length > 100
-                    ? `${error.message.slice(0, 100)}...`
-                    : error.message;
-                yield {
-                    type: "agent-error",
-                    message: errorMsg,
-                };
-                if (NoOutputGeneratedError.isInstance(error)) {
-                    break;
+                // Handle AI SDK invalid tool input errors gracefully
+                if (InvalidToolInputError.isInstance(error)) {
+                    logger.warn(error, `Invalid tool input detected - returning error to allow recovery (attempt ${consecutiveErrors}/${maxRetries + 1})`);
+                    yield {
+                        type: "agent-error",
+                        message: `Tool input validation failed: ${error.message}. Try again with valid arguments.`,
+                    };
+                    // 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})`);
+                    const errorMsg = error.message.length > 100
+                        ? `${error.message.slice(0, 100)}...`
+                        : error.message;
+                    yield {
+                        type: "agent-error",
+                        message: errorMsg,
+                    };
+                    if (NoOutputGeneratedError.isInstance(error)) {
+                        hasEmittedTerminalEvent = true;
+                        break;
+                    }
                 }
                 // Break loop if we exceed max retries
                 if (consecutiveErrors > maxRetries) {
@@ -335,6 +296,7 @@ export class Agent {
                         type: "agent-error",
                         message: `Exceeded maximum retry attempts (${maxRetries}). Stopping manual loop.`,
                     };
+                    hasEmittedTerminalEvent = true;
                     break;
                 }
             }
@@ -342,6 +304,12 @@ export class Agent {
                 this._state.timestamps.stop = performance.now();
             }
         }
+        // Emit agent-stop if loop ended without emitting a terminal event (maxIterations reached)
+        if (!hasEmittedTerminalEvent) {
+            yield {
+                type: "agent-stop",
+            };
+        }
         // Track aggregate usage across all steps when available
         tokenTracker.trackUsage("repl", this._state.totalUsage);
     }
@@ -352,7 +320,7 @@ export class Agent {
     }
     resetState() {
         const { modelManager,
-        // messageHistory,
+        // sessionManager,
          } = this.opts;
         this._state = {
             modelId: modelManager.getModel("repl").modelId,
@@ -363,6 +331,15 @@ export class Agent {
                 totalTokens: 0,
                 reasoningTokens: 0,
                 cachedInputTokens: 0,
+                inputTokenDetails: {
+                    noCacheTokens: 0,
+                    cacheReadTokens: 0,
+                    cacheWriteTokens: 0,
+                },
+                outputTokenDetails: {
+                    textTokens: 0,
+                    reasoningTokens: 0,
+                },
             },
             totalUsage: {
                 inputTokens: 0,
@@ -370,6 +347,15 @@ export class Agent {
                 totalTokens: 0,
                 reasoningTokens: 0,
                 cachedInputTokens: 0,
+                inputTokenDetails: {
+                    noCacheTokens: 0,
+                    cacheReadTokens: 0,
+                    cacheWriteTokens: 0,
+                },
+                outputTokenDetails: {
+                    textTokens: 0,
+                    reasoningTokens: 0,
+                },
             },
             steps: [],
             timestamps: {
@@ -379,6 +365,30 @@ export class Agent {
         };
         return this._state;
     }
+    processToolEvent(toolsCalled, event) {
+        const toolCallId = event.toolCallId;
+        let events;
+        if (toolsCalled.has(toolCallId)) {
+            const currentEvents = toolsCalled.get(toolCallId);
+            if (currentEvents) {
+                events = currentEvents;
+                events.push(event);
+            }
+            else {
+                events = [event];
+                toolsCalled.set(toolCallId, events);
+            }
+        }
+        else {
+            events = [event];
+            toolsCalled.set(toolCallId, events);
+        }
+        return {
+            type: "tool-call-lifecycle",
+            toolCallId: toolCallId,
+            events,
+        };
+    }
 }
 function formatToolResult(value) {
     if (typeof value === "string") {
@@ -404,3 +414,32 @@ function formatToolResult(value) {
     }
     return String(value);
 }
+const toolCallRepair = (modelManager) => {
+    const fn = async ({ toolCall, tools, inputSchema, error, }) => {
+        if (NoSuchToolError.isInstance(error)) {
+            return null; // do not attempt to fix invalid tool names
+        }
+        const tool = tools[toolCall.toolName];
+        try {
+            const { output: repairedArgs } = await generateText({
+                model: modelManager.getModel("tool-repair"),
+                output: Output.object({
+                    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.",
+                ].join("\n"),
+            });
+            return { ...toolCall, args: JSON.stringify(repairedArgs) };
+        }
+        catch (err) {
+            logger.error(err, `Failed to repair tool call: ${toolCall.toolName}.`);
+            return null;
+        }
+    };
+    return fn;
+};

package/dist/cli.d.ts

@@ -1,20 +1,21 @@
 import type { WorkspaceContext } from "./index.ts";
-import type { MessageHistory } from "./messages.ts";
 import type { ModelManager } from "./models/manager.js";
 import type { PromptManager } from "./prompts/manager.ts";
+import type { SessionManager } from "./sessions/manager.ts";
 import type { TokenCounter } from "./tokens/counter.ts";
 import type { TokenTracker } from "./tokens/tracker.ts";
 interface CliOptions {
-    messageHistory: MessageHistory;
+    messageHistory: SessionManager;
     promptManager: PromptManager;
     modelManager: ModelManager;
     tokenTracker: TokenTracker;
-    config: Record<PropertyKey, unknown>;
     tokenCounter: TokenCounter;
     workspace: WorkspaceContext;
+    skillsEnabled?: boolean;
 }
 export declare class Cli {
     private options;
+    private skillsEnabled;
     constructor(options: CliOptions);
     run(): Promise<void>;
 }

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../source/cli.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AASxD,UAAU,UAAU;IAClB,cAAc,EAAE,cAAc,CAAC;IAC/B,aAAa,EAAE,aAAa,CAAC;IAC7B,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;IACrC,YAAY,EAAE,YAAY,CAAC;IAC3B,SAAS,EAAE,gBAAgB,CAAC;CAC7B;AAWD,qBAAa,GAAG;IACd,OAAO,CAAC,OAAO,CAAa;gBAChB,OAAO,EAAE,UAAU;IAIzB,GAAG;CAkFV"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../source/cli.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAGnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAQxD,UAAU,UAAU;IAClB,cAAc,EAAE,cAAc,CAAC;IAC/B,aAAa,EAAE,aAAa,CAAC;IAC7B,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,SAAS,EAAE,gBAAgB,CAAC;IAC5B,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAUD,qBAAa,GAAG;IACd,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,aAAa,CAAU;gBACnB,OAAO,EAAE,UAAU;IAKzB,GAAG;CAsHV"}