@travisennis/acai 0.0.5 → 0.0.7

package/dist/agent/index.js

@@ -0,0 +1,434 @@
+import { NoOutputGeneratedError, streamText, } 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;
+    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 = (await config.getConfig()).loop.maxIterations, maxRetries = 2, toolCallRepair, } = this.opts;
+        this.resetState();
+        this._state.timestamps.start = performance.now();
+        const { systemPrompt, input, toolDefs, activeTools = undefined, 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;
+        let hasEmittedTerminalEvent = false;
+        while (iter < maxIterations) {
+            if (abortSignal?.aborted) {
+                logger.warn("The agent loop was aborted by the 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(),
+                    temperature: aiConfig.temperature(),
+                    topP: aiConfig.topP(),
+                    maxRetries: 2,
+                    providerOptions: aiConfig.providerOptions(),
+                    tools: toolDefs,
+                    activeTools,
+                    // biome-ignore lint/style/useNamingConvention: third-party code
+                    experimental_repairToolCall: toolCallRepair,
+                    abortSignal,
+                    onAbort: ({ steps }) => {
+                        logger.debug(`Aborting and processing ${steps.length} steps`);
+                        steps.forEach((step) => {
+                            messageHistory.appendResponseMessages(step.response.messages);
+                        });
+                    },
+                });
+                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 {
+                            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;
+                        yield this.processToolEvent(toolsCalled, {
+                            type: "tool-call-start",
+                            name: toolName,
+                            toolCallId: call.toolCallId,
+                            msg: "",
+                            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 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)) {
+                                                if (call.toolCallId !== value.id) {
+                                                    logger.debug(`Tool ${call.toolName} ids don't match: ${call.toolCallId} != ${value.id}`);
+                                                }
+                                                const event = value.event;
+                                                switch (event) {
+                                                    case "tool-completion":
+                                                        yield this.processToolEvent(toolsCalled, {
+                                                            type: "tool-call-end",
+                                                            name: value.name,
+                                                            toolCallId: call.toolCallId,
+                                                            msg: value.data,
+                                                            args: call.input,
+                                                        });
+                                                        break;
+                                                    case "tool-error":
+                                                        yield this.processToolEvent(toolsCalled, {
+                                                            type: "tool-call-error",
+                                                            name: value.name,
+                                                            toolCallId: call.toolCallId,
+                                                            msg: value.data,
+                                                            args: call.input,
+                                                        });
+                                                        break;
+                                                    case "tool-update":
+                                                        yield this.processToolEvent(toolsCalled, {
+                                                            type: "tool-call-update",
+                                                            name: value.name,
+                                                            toolCallId: call.toolCallId,
+                                                            msg: value.data,
+                                                            args: call.input,
+                                                        });
+                                                        break;
+                                                    case "tool-init":
+                                                        yield this.processToolEvent(toolsCalled, {
+                                                            type: "tool-call-init",
+                                                            name: value.name,
+                                                            toolCallId: call.toolCallId,
+                                                            msg: value.data,
+                                                            args: call.input,
+                                                        });
+                                                        break;
+                                                    default:
+                                                        event;
+                                                        logger.debug(`Unhandled tool message event: ${event}`);
+                                                        break;
+                                                }
+                                            }
+                                            else {
+                                                toolResultValues.push(value);
+                                            }
+                                        }
+                                        const finalValue = toolResultValues.length > 0
+                                            ? toolResultValues.at(-1)
+                                            : undefined;
+                                        resultOutput = formatToolResult(finalValue);
+                                    }
+                                    else {
+                                        resultOutput = formatToolResult(output);
+                                        yield this.processToolEvent(toolsCalled, {
+                                            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 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,
+                                    },
+                                },
+                            ],
+                        });
+                    }
+                }
+                // Get response and tool calls
+                const response = await result.response;
+                const responseMessages = response.messages;
+                messageHistory.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;
+                messageHistory.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;
+                this._state.totalUsage.reasoningTokens +=
+                    stepUsage.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;
+                }
+                messageHistory.appendToolMessages(toolMessages);
+                // 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)) {
+                    hasEmittedTerminalEvent = true;
+                    break;
+                }
+                // Break loop if we exceed max retries
+                if (consecutiveErrors > maxRetries) {
+                    yield {
+                        type: "agent-error",
+                        message: `Exceeded maximum retry attempts (${maxRetries}). Stopping manual loop.`,
+                    };
+                    hasEmittedTerminalEvent = true;
+                    break;
+                }
+            }
+            finally {
+                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);
+    }
+    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;
+    }
+    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") {
+        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/api/exa/index.js

@@ -1,4 +1,4 @@
-import { isZodSchema, zodToJsonSchema } from "../../utils/zod-utils.js";
+import { isZodSchema, zodToJsonSchema } from "../../utils/zod.js";
 // Prefer global fetch/Headers from Node >= 18
 const fetchImpl = globalThis.fetch;
 const HeadersImpl = globalThis.Headers;

package/dist/cli.d.ts

@@ -1,3 +1,4 @@
+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";
@@ -8,11 +9,13 @@ interface CliOptions {
     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":"AAUA,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;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,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;IACrC,YAAY,EAAE,YAAY,CAAC;CAC5B;AAID,qBAAa,GAAG;IACd,OAAO,CAAC,OAAO,CAAa;gBAChB,OAAO,EAAE,UAAU;IAIzB,GAAG;CAgGV"}
+{"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,YAAY,EAAE,YAAY,CAAC;IAC3B,SAAS,EAAE,gBAAgB,CAAC;IAC5B,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAWD,qBAAa,GAAG;IACd,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,aAAa,CAAU;gBACnB,OAAO,EAAE,UAAU;IAKzB,GAAG;CAiHV"}

package/dist/cli.js

@@ -1,21 +1,31 @@
 import { generateObject, generateText, NoSuchToolError, stepCountIs, } from "ai";
 import { logger } from "./logger.js";
 import { AiConfig } from "./models/ai-config.js";
-import { minSystemPrompt } from "./prompts.js";
-import { DeleteFileTool } from "./tools/delete-file.js";
+import { systemPrompt } from "./prompts.js";
+import { BashTool } from "./tools/bash.js";
+import { CodeInterpreterTool } from "./tools/code-interpreter.js";
 import { EditFileTool } from "./tools/edit-file.js";
+import { GlobTool } from "./tools/glob.js";
+import { GrepTool } from "./tools/grep.js";
 import { initCliTools } from "./tools/index.js";
-import { MoveFileTool } from "./tools/move-file.js";
-import { SaveFileTool } from "./tools/save-file.js";
-import { ThinkTool } from "./tools/think.js";
+import { ReadFileTool } from "./tools/read-file.js";
+const activeTools = [
+    EditFileTool.name,
+    ReadFileTool.name,
+    BashTool.name,
+    GrepTool.name,
+    GlobTool.name,
+    CodeInterpreterTool.name,
+];
 export class Cli {
     options;
+    skillsEnabled;
     constructor(options) {
         this.options = options;
+        this.skillsEnabled = options.skillsEnabled ?? true;
     }
     async run() {
-        const { config, promptManager, modelManager, tokenTracker, messageHistory, tokenCounter, } = this.options;
-        logger.info(config, "Config:");
+        const { promptManager, modelManager, tokenTracker, messageHistory, tokenCounter, } = this.options;
         const abortController = new AbortController();
         const { signal } = abortController;
         const cb = () => {
@@ -28,46 +38,39 @@ export class Cli {
         const userPrompt = promptManager.get();
         const userMsg = promptManager.getUserMessage();
         messageHistory.appendUserMessage(userMsg);
-        const finalSystemPrompt = await minSystemPrompt();
+        const finalSystemPrompt = await systemPrompt({
+            type: "cli",
+            activeTools,
+            allowedDirs: this.options.workspace.allowedDirs,
+            skillsEnabled: this.skillsEnabled,
+        });
         const aiConfig = new AiConfig({
             modelMetadata: modelConfig,
             prompt: userPrompt,
         });
-        const maxTokens = aiConfig.getMaxTokens();
-        const tools = modelConfig.supportsToolCalling
-            ? await initCliTools({ tokenCounter })
-            : undefined;
+        const tools = await initCliTools({
+            tokenCounter,
+            workspace: this.options.workspace,
+        });
+        // Cleanup function to remove signal handler
+        const cleanup = () => {
+            process.removeListener("SIGINT", cb);
+        };
         try {
             const result = await generateText({
                 model: langModel,
-                maxOutputTokens: maxTokens,
-                messages: [
-                    {
-                        role: "system",
-                        content: finalSystemPrompt,
-                        providerOptions: {
-                            anthropic: { cacheControl: { type: "ephemeral" } },
-                        },
-                    },
-                    ...messageHistory.get(),
-                ],
-                temperature: modelConfig.defaultTemperature,
+                maxOutputTokens: aiConfig.maxOutputTokens(),
+                system: finalSystemPrompt,
+                messages: messageHistory.get(),
+                temperature: aiConfig.temperature(),
+                topP: aiConfig.topP(),
                 stopWhen: stepCountIs(60),
                 maxRetries: 2,
-                providerOptions: aiConfig.getProviderOptions(),
-                tools,
-                // biome-ignore lint/style/useNamingConvention: third-party controlled
-                experimental_activeTools: [
-                    EditFileTool.name,
-                    SaveFileTool.name,
-                    MoveFileTool.name,
-                    DeleteFileTool.name,
-                    ThinkTool.name,
-                ],
+                providerOptions: aiConfig.providerOptions(),
+                tools: tools.toolDefs,
+                activeTools,
                 // biome-ignore lint/style/useNamingConvention: third-party controlled
-                experimental_repairToolCall: modelConfig.supportsToolCalling
-                    ? toolCallRepair(modelManager)
-                    : undefined,
+                experimental_repairToolCall: toolCallRepair(modelManager),
                 abortSignal: signal,
             });
             if (result.response.messages.length > 0) {
@@ -75,14 +78,38 @@ export class Cli {
             }
             // this tracks the usage of every step in the call to streamText. it's a cumulative usage.
             tokenTracker.trackUsage("cli", result.usage);
+            messageHistory.save();
             process.stdout.end(result.text.endsWith("\n") ? result.text : `${result.text}\n`);
+            cleanup();
         }
         catch (e) {
-            if (e instanceof Error) {
-                logger.error(e);
+            // Always cleanup signal handler
+            cleanup();
+            // Check if it's an abort error
+            const isAbortError = e instanceof Error &&
+                (e.name === "AbortError" ||
+                    e.message.includes("aborted") ||
+                    e.message.includes("No output generated"));
+            if (isAbortError) {
+                logger.info("CLI execution interrupted by user");
+                // Try to save message history before exiting
+                try {
+                    await messageHistory.save();
+                }
+                catch (_saveError) {
+                    // Ignore save errors on abort
+                    logger.warn("Failed to save message history on interrupt");
+                }
+                process.exit(0); // Exit gracefully
             }
             else {
-                logger.error(JSON.stringify(e, null, 2));
+                if (e instanceof Error) {
+                    logger.error(e);
+                }
+                else {
+                    logger.error(JSON.stringify(e, null, 2));
+                }
+                process.exit(1);
             }
         }
     }

package/dist/commands/add-directory-command.d.ts

@@ -0,0 +1,3 @@
+import type { CommandOptions, ReplCommand } from "./types.ts";
+export declare const addDirectoryCommand: ({ workspace, }: CommandOptions) => ReplCommand;
+//# sourceMappingURL=add-directory-command.d.ts.map

package/dist/commands/add-directory-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-directory-command.d.ts","sourceRoot":"","sources":["../../source/commands/add-directory-command.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,eAAO,MAAM,mBAAmB,GAAI,gBAEjC,cAAc,KAAG,WA2FnB,CAAC"}