@travisennis/acai 0.0.4 → 0.0.6

package/dist/agent/index.js

@@ -0,0 +1,406 @@
+import { NoOutputGeneratedError, streamText, } from "ai";
+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;
+    abortController;
+    constructor(opts) {
+        this.opts = opts;
+        this.abortController = new AbortController();
+        this._state = this.resetState();
+    }
+    get state() {
+        return this._state;
+    }
+    get abortSignal() {
+        return this.abortController.signal;
+    }
+    async *run(args) {
+        const { modelManager, messageHistory, tokenTracker, maxIterations = 90, maxRetries = 2, toolCallRepair, } = this.opts;
+        this.resetState();
+        this._state.timestamps.start = performance.now();
+        const { systemPrompt, input, toolDefs, executors, abortSignal } = args;
+        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;
+        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",
+                };
+                break;
+            }
+            yield {
+                type: "step-start",
+            };
+            try {
+                const result = streamText({
+                    model: langModel,
+                    maxOutputTokens: aiConfig.maxOutputTokens(),
+                    system: systemPrompt,
+                    messages: messageHistory.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,
+                    abortSignal,
+                });
+                let accumulatedText = "";
+                let accumulatedReasoning = "";
+                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,
+                        };
+                    }
+                }
+                // 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 {
+                            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 {
+                                    resultOutput = formatToolResult(output);
+                                    yield {
+                                        type: "tool-call-end",
+                                        name: call.toolName,
+                                        toolCallId: call.toolCallId,
+                                        msg: "success",
+                                        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,
+                                toolCallId: call.toolCallId,
+                                output: {
+                                    type: "text",
+                                    value: resultOutput,
+                                },
+                            },
+                        ],
+                    });
+                }
+                messageHistory.appendToolMessages(toolMessages);
+                // Calculate usage for the current step/iteration
+                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.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;
+                this._state.totalUsage.reasoningTokens +=
+                    stepUsage.reasoningTokens ?? 0;
+                // Consume the rest of the team if necessary
+                // await result.consumeStream();
+                yield {
+                    type: "step-stop",
+                };
+                // continue iterations
+                iter += 1;
+            }
+            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;
+                }
+                // Break loop if we exceed max retries
+                if (consecutiveErrors > maxRetries) {
+                    yield {
+                        type: "agent-error",
+                        message: `Exceeded maximum retry attempts (${maxRetries}). Stopping manual loop.`,
+                    };
+                    break;
+                }
+            }
+            finally {
+                this._state.timestamps.stop = performance.now();
+            }
+        }
+        // Track aggregate usage across all steps when available
+        tokenTracker.trackUsage("repl", this._state.totalUsage);
+    }
+    abort() {
+        this.abortController.abort();
+        // Reset the abort controller for the next run
+        this.abortController = new AbortController();
+    }
+    resetState() {
+        const { modelManager,
+        // messageHistory,
+         } = this.opts;
+        this._state = {
+            modelId: modelManager.getModel("repl").modelId,
+            modelConfig: modelManager.getModelMetadata("repl"),
+            usage: {
+                inputTokens: 0,
+                outputTokens: 0,
+                totalTokens: 0,
+                reasoningTokens: 0,
+                cachedInputTokens: 0,
+            },
+            totalUsage: {
+                inputTokens: 0,
+                outputTokens: 0,
+                totalTokens: 0,
+                reasoningTokens: 0,
+                cachedInputTokens: 0,
+            },
+            steps: [],
+            timestamps: {
+                start: 0,
+                stop: 0,
+            },
+        };
+        return this._state;
+    }
+}
+function formatToolResult(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value === undefined) {
+        return "";
+    }
+    if (value === null) {
+        return "null";
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    try {
+        const serialized = JSON.stringify(value);
+        if (typeof serialized === "string") {
+            return serialized;
+        }
+    }
+    catch {
+        // noop - fallback below
+    }
+    return String(value);
+}

package/dist/agent/manual-loop.d.ts

@@ -0,0 +1,41 @@
+import type { LanguageModelUsage, ToolExecuteFunction } from "ai";
+import { type ToolCallRepairFunction } from "ai";
+import type { MessageHistory } from "../messages.ts";
+import type { ModelManager } from "../models/manager.ts";
+import type { Terminal } from "../terminal/index.ts";
+import type { CompleteToolSet } from "../tools/index.ts";
+type ManualLoopOptions = {
+    modelManager: ModelManager;
+    terminal: Terminal;
+    messageHistory: MessageHistory;
+    systemPrompt: string;
+    input: string;
+    toolDefs: CompleteToolSet;
+    executors: Map<keyof CompleteToolSet, ToolExecuteFunction<unknown, string>>;
+    maxIterations?: number;
+    maxRetries?: number;
+    abortSignal?: AbortSignal;
+    toolCallRepair?: ToolCallRepairFunction<CompleteToolSet>;
+};
+type ManualLoopResult = {
+    steps: {
+        toolResults: Array<{
+            toolName: string;
+        }>;
+        toolCalls: Array<{
+            toolName: string;
+        }>;
+    }[];
+    usage: {
+        [K in keyof LanguageModelUsage]-?: number;
+    };
+    totalUsage: {
+        [K in keyof LanguageModelUsage]-?: number;
+    };
+};
+export declare function runManualLoop(opts: ManualLoopOptions): Promise<ManualLoopResult>;
+export declare function consumeToolAsyncIterable(iterable: AsyncIterable<unknown>, terminal?: Terminal): Promise<{
+    finalValue: unknown;
+}>;
+export {};
+//# sourceMappingURL=manual-loop.d.ts.map

package/dist/agent/manual-loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manual-loop.d.ts","sourceRoot":"","sources":["../../source/agent/manual-loop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,mBAAmB,EAEpB,MAAM,IAAI,CAAC;AACZ,OAAO,EAGL,KAAK,sBAAsB,EAC5B,MAAM,IAAI,CAAC;AAEZ,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAIzD,KAAK,iBAAiB,GAAG;IACvB,YAAY,EAAE,YAAY,CAAC;IAC3B,QAAQ,EAAE,QAAQ,CAAC;IACnB,cAAc,EAAE,cAAc,CAAC;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,eAAe,CAAC;IAC1B,SAAS,EAAE,GAAG,CAAC,MAAM,eAAe,EAAE,mBAAmB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC;IAC5E,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,cAAc,CAAC,EAAE,sBAAsB,CAAC,eAAe,CAAC,CAAC;CAC1D,CAAC;AAEF,KAAK,gBAAgB,GAAG;IACtB,KAAK,EAAE;QACL,WAAW,EAAE,KAAK,CAAC;YAAE,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;QACzC,SAAS,EAAE,KAAK,CAAC;YAAE,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KACxC,EAAE,CAAC;IACJ,KAAK,EAAE;SAAG,CAAC,IAAI,MAAM,kBAAkB,CAAC,CAAC,GAAG,MAAM;KAAE,CAAC;IACrD,UAAU,EAAE;SAAG,CAAC,IAAI,MAAM,kBAAkB,CAAC,CAAC,GAAG,MAAM;KAAE,CAAC;CAC3D,CAAC;AAEF,wBAAsB,aAAa,CACjC,IAAI,EAAE,iBAAiB,GACtB,OAAO,CAAC,gBAAgB,CAAC,CAoS3B;AAED,wBAAsB,wBAAwB,CAC5C,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,EAChC,QAAQ,CAAC,EAAE,QAAQ,GAClB,OAAO,CAAC;IAAE,UAAU,EAAE,OAAO,CAAA;CAAE,CAAC,CAuBlC"}