@travisennis/acai 0.0.7 → 0.0.8

package/dist/tools/advanced-edit-file.js

@@ -1,285 +0,0 @@
-import { execSync } from "node:child_process";
-import { readFile, writeFile } from "node:fs/promises";
-import { createTwoFilesPatch } from "diff";
-import { z } from "zod";
-import { config } from "../config.js";
-import style from "../terminal/style.js";
-import { joinWorkingDir, validateFileNotReadOnly, validatePath, } from "../utils/filesystem/security.js";
-export const AdvancedEditFileTool = {
-    name: "advancedEditFile",
-};
-const inputSchema = z.object({
-    path: z.string().describe("The path of the file to edit."),
-    mode: z
-        .enum(["exact", "regex", "ast"])
-        .default("exact")
-        .describe("Editing mode: exact (literal text), regex (pattern matching), or ast (AST-aware)"),
-    operations: z.array(z.object({
-        type: z
-            .enum(["replace", "insert-before", "insert-after", "delete"])
-            .describe("Type of operation to perform"),
-        pattern: z
-            .string()
-            .describe("Pattern to match (text, regex, or AST pattern depending on mode)"),
-        replacement: z
-            .string()
-            .optional()
-            .describe("Replacement text (required for replace operations)"),
-        flags: z
-            .string()
-            .optional()
-            .describe("Regex flags for regex mode (e.g., 'g', 'i', 'm')"),
-    })),
-    astPattern: z
-        .string()
-        .optional()
-        .describe("AST-grep search pattern for AST mode (e.g., 'var $V = $VAL')"),
-    astReplacement: z
-        .string()
-        .optional()
-        .describe("AST-grep replacement pattern for AST mode (e.g., 'let $V = $VAL')"),
-    dryRun: z.boolean().default(false).describe("Show changes without writing"),
-});
-export const createAdvancedEditFileTool = async ({ workingDir, allowedDirs, }) => {
-    const allowedDirectory = allowedDirs ?? [workingDir];
-    return {
-        toolDef: {
-            description: "Advanced file editing with multiple modes: exact text matching, regex pattern matching, and AST-aware editing. " +
-                "Supports replace, insert-before, insert-after, and delete operations. AST mode requires ast-grep to be installed.",
-            inputSchema,
-        },
-        async *execute({ path, mode, operations, astPattern, astReplacement, dryRun, }, { toolCallId, abortSignal }) {
-            try {
-                if (abortSignal?.aborted) {
-                    throw new Error("File editing aborted");
-                }
-                yield {
-                    name: AdvancedEditFileTool.name,
-                    id: toolCallId,
-                    event: "tool-init",
-                    data: `${style.cyan(path)} (mode: ${mode})`,
-                };
-                const validPath = await validatePath(joinWorkingDir(path, workingDir), allowedDirectory, { abortSignal });
-                // Check if file is read-only
-                const projectConfig = await config.getConfig();
-                validateFileNotReadOnly(validPath, projectConfig, workingDir);
-                const result = await applyAdvancedFileEdits(validPath, mode, operations, astPattern, astReplacement, dryRun, abortSignal);
-                yield {
-                    name: AdvancedEditFileTool.name,
-                    id: toolCallId,
-                    event: "tool-completion",
-                    data: `Applied ${operations.length} edits`,
-                };
-                yield result;
-            }
-            catch (error) {
-                yield {
-                    name: AdvancedEditFileTool.name,
-                    event: "tool-error",
-                    id: toolCallId,
-                    data: error.message,
-                };
-                yield `Failed to edit file: ${error.message}`;
-            }
-        },
-    };
-};
-// file editing and diffing utilities
-function normalizeLineEndings(text) {
-    return text.replace(/\r\n/g, "\n");
-}
-function createUnifiedDiff(originalContent, newContent, filepath = "file") {
-    // Ensure consistent line endings for diff
-    const normalizedOriginal = normalizeLineEndings(originalContent);
-    const normalizedNew = normalizeLineEndings(newContent);
-    return createTwoFilesPatch(filepath, filepath, normalizedOriginal, normalizedNew, "original", "modified");
-}
-function applyExactModeEdits(content, operations) {
-    let modifiedContent = content;
-    for (const op of operations) {
-        switch (op.type) {
-            case "replace": {
-                if (!op.replacement) {
-                    throw new Error("Replacement text required for replace operation");
-                }
-                // Exact text replacement (global)
-                let currentIndex = 0;
-                let matchCount = 0;
-                while (currentIndex < modifiedContent.length) {
-                    const matchIndex = modifiedContent.indexOf(op.pattern, currentIndex);
-                    if (matchIndex === -1) {
-                        break;
-                    }
-                    matchCount++;
-                    modifiedContent =
-                        modifiedContent.slice(0, matchIndex) +
-                            op.replacement +
-                            modifiedContent.slice(matchIndex + op.pattern.length);
-                    currentIndex = matchIndex + op.replacement.length;
-                }
-                if (matchCount === 0) {
-                    throw new Error(`Pattern not found in content: ${op.pattern}`);
-                }
-                break;
-            }
-            case "insert-before": {
-                if (!op.replacement) {
-                    throw new Error("Replacement text required for insert-before operation");
-                }
-                const beforeIndex = modifiedContent.indexOf(op.pattern);
-                if (beforeIndex === -1) {
-                    throw new Error(`Pattern not found for insert-before: ${op.pattern}`);
-                }
-                modifiedContent =
-                    modifiedContent.slice(0, beforeIndex) +
-                        op.replacement +
-                        "\n" +
-                        modifiedContent.slice(beforeIndex);
-                break;
-            }
-            case "insert-after": {
-                if (!op.replacement) {
-                    throw new Error("Replacement text required for insert-after operation");
-                }
-                const afterIndex = modifiedContent.indexOf(op.pattern);
-                if (afterIndex === -1) {
-                    throw new Error(`Pattern not found for insert-after: ${op.pattern}`);
-                }
-                const insertPosition = afterIndex + op.pattern.length;
-                modifiedContent =
-                    modifiedContent.slice(0, insertPosition) +
-                        "\n" +
-                        op.replacement +
-                        modifiedContent.slice(insertPosition);
-                break;
-            }
-            case "delete": {
-                // For delete operations, use line-based approach to handle newlines properly
-                const lines = modifiedContent.split("\n");
-                const filteredLines = lines.filter((line) => !line.includes(op.pattern));
-                if (filteredLines.length === lines.length) {
-                    throw new Error(`Pattern not found for delete: ${op.pattern}`);
-                }
-                modifiedContent = filteredLines.join("\n");
-                break;
-            }
-        }
-    }
-    return modifiedContent;
-}
-function applyRegexModeEdits(content, operations) {
-    let modifiedContent = content;
-    for (const op of operations) {
-        const flags = op.flags || "g";
-        const regex = new RegExp(op.pattern, flags);
-        switch (op.type) {
-            case "replace":
-                if (!op.replacement) {
-                    throw new Error("Replacement text required for replace operation");
-                }
-                modifiedContent = modifiedContent.replace(regex, op.replacement);
-                break;
-            case "insert-before":
-                if (!op.replacement) {
-                    throw new Error("Replacement text required for insert-before operation");
-                }
-                modifiedContent = modifiedContent.replace(regex, `${op.replacement}\n$&`);
-                break;
-            case "insert-after":
-                if (!op.replacement) {
-                    throw new Error("Replacement text required for insert-after operation");
-                }
-                modifiedContent = modifiedContent.replace(regex, `$&\n${op.replacement}`);
-                break;
-            case "delete":
-                modifiedContent = modifiedContent.replace(regex, "");
-                break;
-        }
-    }
-    return modifiedContent;
-}
-function applyAstModeEdits(filePath, astPattern, astReplacement, dryRun) {
-    if (!astPattern || !astReplacement) {
-        throw new Error("AST mode requires both astPattern and astReplacement");
-    }
-    try {
-        const cmd = [
-            "ast-grep",
-            "--pattern",
-            `"${astPattern}"`,
-            "--rewrite",
-            `"${astReplacement}"`,
-            dryRun ? "--dry-run" : "--write",
-            filePath,
-        ].join(" ");
-        if (dryRun) {
-            const output = execSync(cmd, { encoding: "utf-8" });
-            return `AST edit preview:\n${output}`;
-        }
-        execSync(cmd, { stdio: "inherit" });
-        return `AST edit applied to ${filePath}`;
-    }
-    catch (err) {
-        throw new Error(`AST edit failed: ${err.message}`);
-    }
-}
-export async function applyAdvancedFileEdits(filePath, mode, operations, astPattern, astReplacement, dryRun = false, abortSignal) {
-    if (abortSignal?.aborted) {
-        throw new Error("File edit operation aborted");
-    }
-    // Read file content literally with signal
-    const originalContent = await readFile(filePath, {
-        encoding: "utf-8",
-        signal: abortSignal,
-    });
-    let modifiedContent = originalContent;
-    let resultMessage = "";
-    if (mode === "ast") {
-        // AST mode uses external ast-grep tool
-        if (!astPattern || !astReplacement) {
-            throw new Error("AST mode requires both astPattern and astReplacement");
-        }
-        resultMessage = applyAstModeEdits(filePath, astPattern, astReplacement, dryRun);
-        if (dryRun) {
-            return resultMessage;
-        }
-        // For actual AST edits, read the modified content back
-        modifiedContent = await readFile(filePath, {
-            encoding: "utf-8",
-            signal: abortSignal,
-        });
-    }
-    else {
-        // Text-based modes (exact and regex)
-        if (operations.length === 0) {
-            throw new Error("No operations specified for text-based editing mode");
-        }
-        switch (mode) {
-            case "exact":
-                modifiedContent = applyExactModeEdits(originalContent, operations);
-                break;
-            case "regex":
-                modifiedContent = applyRegexModeEdits(originalContent, operations);
-                break;
-        }
-        // Create unified diff
-        const diff = createUnifiedDiff(originalContent, modifiedContent, filePath);
-        // Format diff with appropriate number of backticks
-        let numBackticks = 3;
-        while (diff.includes("`".repeat(numBackticks))) {
-            numBackticks++;
-        }
-        resultMessage = `${"`".repeat(numBackticks)}diff\n${diff}${"`".repeat(numBackticks)}\n\n`;
-        if (!dryRun) {
-            if (abortSignal?.aborted) {
-                throw new Error("File edit operation aborted before writing");
-            }
-            // Write the modified content with signal
-            await writeFile(filePath, modifiedContent, {
-                encoding: "utf-8",
-                signal: abortSignal,
-            });
-        }
-    }
-    return resultMessage;
-}

package/dist/tools/agent.d.ts

@@ -1,29 +0,0 @@
-import { type ToolCallOptions } from "ai";
-import { z } from "zod";
-import type { WorkspaceContext } from "../index.ts";
-import type { ModelManager } from "../models/manager.ts";
-import type { TokenCounter } from "../tokens/counter.ts";
-import type { TokenTracker } from "../tokens/tracker.ts";
-import type { ToolResult } from "./types.ts";
-export declare const AgentTool: {
-    name: "agent";
-};
-declare const inputSchema: z.ZodObject<{
-    prompt: z.ZodString;
-}, z.core.$strip>;
-export declare const createAgentTools: (options: {
-    modelManager: ModelManager;
-    tokenTracker: TokenTracker;
-    tokenCounter: TokenCounter;
-    workspace: WorkspaceContext;
-}) => {
-    toolDef: {
-        description: string;
-        inputSchema: z.ZodObject<{
-            prompt: z.ZodString;
-        }, z.core.$strip>;
-    };
-    execute: ({ prompt }: z.infer<typeof inputSchema>, { toolCallId, abortSignal }: ToolCallOptions) => AsyncGenerator<ToolResult>;
-};
-export {};
-//# sourceMappingURL=agent.d.ts.map

package/dist/tools/agent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../source/tools/agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,KAAK,eAAe,EAAE,MAAM,IAAI,CAAC;AACrE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAOzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,SAAS;;CAErB,CAAC;AAiCF,QAAA,MAAM,WAAW;;iBAEf,CAAC;AAEH,eAAO,MAAM,gBAAgB,GAAI,SAAS;IACxC,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;0BASe,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,+BACV,eAAe,KAC3C,cAAc,CAAC,UAAU,CAAC;CA+E9B,CAAC"}

package/dist/tools/agent.js

@@ -1,117 +0,0 @@
-import { generateText, stepCountIs } from "ai";
-import { z } from "zod";
-import { AiConfig } from "../models/ai-config.js";
-import { DirectoryTreeTool } from "./directory-tree.js";
-import { GlobTool } from "./glob.js";
-import { GrepTool } from "./grep.js";
-import { initCliTools } from "./index.js";
-import { ReadFileTool } from "./read-file.js";
-import { ReadMultipleFilesTool } from "./read-multiple-files.js";
-export const AgentTool = {
-    name: "agent",
-};
-const TOOLS = [
-    GrepTool.name,
-    GlobTool.name,
-    ReadFileTool.name,
-    ReadMultipleFilesTool.name,
-    DirectoryTreeTool.name,
-];
-function getToolDescription() {
-    const toolNames = TOOLS.join(", ");
-    return `Launch a new agent that has access to the following tools: ${toolNames}. This agent is specifically designed for file discovery and code search tasks. Use the ${AgentTool.name} tool when you need to search for files or code patterns across the codebase.
-
-Use cases:
-- Search for files matching specific patterns (e.g., "*.ts", "**/*.test.ts") using ${GlobTool.name}
-- Find code patterns or text within files using ${GrepTool.name}
-- Read specific files or multiple files using ${ReadFileTool.name} and ${ReadMultipleFilesTool.name}
-
-Important limitations:
-- This agent cannot execute shell commands or run external tools
-- It is focused purely on file discovery and content reading
-- For complex operations or command execution, use the main assistant directly
-
-Usage notes:
-1. Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
-2. When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
-3. Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.
-4. The agent's outputs should generally be trusted.`;
-}
-const inputSchema = z.object({
-    prompt: z.string().describe("The task for the agent to perform"),
-});
-export const createAgentTools = (options) => {
-    const { modelManager, tokenTracker, tokenCounter } = options;
-    const toolDef = {
-        description: getToolDescription(),
-        inputSchema,
-    };
-    async function* execute({ prompt }, { toolCallId, abortSignal }) {
-        if (abortSignal?.aborted) {
-            throw new Error("Agent execution aborted");
-        }
-        yield {
-            name: AgentTool.name,
-            event: "tool-init",
-            id: toolCallId,
-            data: "Invoking agent...",
-        };
-        yield {
-            name: AgentTool.name,
-            event: "tool-update",
-            id: toolCallId,
-            data: `## Prompt:\n\n${prompt}`,
-        };
-        try {
-            const modelConfig = modelManager.getModelMetadata("task-agent");
-            const aiConfig = new AiConfig({
-                modelMetadata: modelConfig,
-                prompt,
-            });
-            const { text, usage } = await generateText({
-                model: modelManager.getModel("task-agent"),
-                maxOutputTokens: aiConfig.maxOutputTokens(),
-                system: "You are a code search assistant that will be given a task that will require you to search a code base to find relevant code and files.",
-                prompt: prompt,
-                temperature: aiConfig.temperature(),
-                topP: aiConfig.topP(),
-                stopWhen: stepCountIs(30),
-                providerOptions: aiConfig.providerOptions(),
-                tools: (await initCliTools({
-                    tokenCounter,
-                    workspace: options.workspace,
-                })).toolDefs,
-                abortSignal: abortSignal,
-                // biome-ignore lint/style/useNamingConvention: third-party code
-                experimental_activeTools: [...TOOLS],
-            });
-            tokenTracker.trackUsage("task-agent", usage);
-            yield {
-                name: AgentTool.name,
-                event: "tool-update",
-                id: toolCallId,
-                data: `## Response:\n\n${text}`,
-            };
-            yield {
-                name: AgentTool.name,
-                event: "tool-completion",
-                id: toolCallId,
-                data: `Finished (${usage.totalTokens} tokens)`,
-            };
-            yield text;
-        }
-        catch (error) {
-            yield {
-                name: AgentTool.name,
-                event: "tool-error",
-                id: toolCallId,
-                data: error.message,
-            };
-            yield error.message;
-        }
-    }
-    return {
-        toolDef,
-        execute,
-    };
-};

package/dist/tools/batch.d.ts

@@ -1,34 +0,0 @@
-import type { ToolCallOptions } from "ai";
-import { z } from "zod";
-import type { TokenCounter } from "../tokens/counter.ts";
-import type { ToolResult } from "./types.ts";
-export declare const BatchTool: {
-    name: "batch";
-};
-declare const inputSchema: z.ZodObject<{
-    calls: z.ZodArray<z.ZodObject<{
-        tool: z.ZodString;
-        arguments: z.ZodRecord<z.ZodAny, z.ZodAny>;
-        id: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-type BatchInputSchema = z.infer<typeof inputSchema>;
-type ToolExecutor = (args: Record<string, unknown>, options: ToolCallOptions) => AsyncGenerator<ToolResult> | Promise<string>;
-export declare const createBatchTool: ({ tokenCounter, executors, }: {
-    tokenCounter: TokenCounter;
-    executors: Map<string, ToolExecutor>;
-}) => Promise<{
-    toolDef: {
-        description: string;
-        inputSchema: z.ZodObject<{
-            calls: z.ZodArray<z.ZodObject<{
-                tool: z.ZodString;
-                arguments: z.ZodRecord<z.ZodAny, z.ZodAny>;
-                id: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>;
-    };
-    execute({ calls }: BatchInputSchema, { toolCallId, messages, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
-}>;
-export {};
-//# sourceMappingURL=batch.d.ts.map

package/dist/tools/batch.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"batch.d.ts","sourceRoot":"","sources":["../../source/tools/batch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAKzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,SAAS;;CAErB,CAAC;AAaF,QAAA,MAAM,WAAW;;;;;;iBAMf,CAAC;AAEH,KAAK,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AACpD,KAAK,YAAY,GAAG,CAClB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,eAAe,KACrB,cAAc,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;AAElD,eAAO,MAAM,eAAe,GAAU,8BAGnC;IACD,YAAY,EAAE,YAAY,CAAC;IAC3B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;CACtC;;;;;;;;;;;uBAQgB,gBAAgB,yCACY,eAAe,GACrD,cAAc,CAAC,UAAU,CAAC;EAkLhC,CAAC"}

package/dist/tools/batch.js

@@ -1,174 +0,0 @@
-import { z } from "zod";
-import { logger } from "../logger.js";
-import style from "../terminal/style.js";
-import { manageTokenLimit, TokenLimitExceededError, } from "../tokens/threshold.js";
-export const BatchTool = {
-    name: "batch",
-};
-const toolCallSchema = z.object({
-    tool: z.string().describe("Name of the tool to execute"),
-    arguments: z
-        .record(z.any(), z.any())
-        .describe("Arguments to pass to the tool"),
-    id: z
-        .string()
-        .optional()
-        .describe("Optional ID for tracking this specific call"),
-});
-const inputSchema = z.object({
-    calls: z
-        .array(toolCallSchema)
-        .min(1)
-        .max(10)
-        .describe("Array of tool calls to execute in sequence"),
-});
-export const createBatchTool = async ({ tokenCounter, executors, }) => {
-    return {
-        toolDef: {
-            description: "Execute multiple tool calls in a single request. Reduces roundtrips by batching operations. Tools are executed sequentially in the order provided.",
-            inputSchema,
-        },
-        async *execute({ calls }, { toolCallId, messages, abortSignal }) {
-            try {
-                if (abortSignal?.aborted) {
-                    throw new Error("Batch execution aborted");
-                }
-                const totalCalls = calls.length;
-                yield {
-                    name: BatchTool.name,
-                    event: "tool-init",
-                    id: toolCallId,
-                    data: `Starting batch execution of ${totalCalls} tool calls`,
-                };
-                const results = [];
-                for (let i = 0; i < calls.length; i++) {
-                    const call = calls[i];
-                    const { tool: toolName, arguments: args, id: callId } = call;
-                    const callNumber = i + 1;
-                    if (abortSignal?.aborted) {
-                        results.push({
-                            tool: toolName,
-                            id: callId,
-                            status: "error",
-                            error: "Batch execution aborted",
-                        });
-                        continue;
-                    }
-                    const executor = executors.get(toolName);
-                    if (!executor) {
-                        results.push({
-                            tool: toolName,
-                            id: callId,
-                            status: "error",
-                            error: `Unknown tool '${toolName}'`,
-                        });
-                        continue;
-                    }
-                    yield {
-                        name: BatchTool.name,
-                        event: "tool-update",
-                        id: toolCallId,
-                        data: `[${callNumber}/${totalCalls}] ${style.cyan(toolName)}${callId ? ` (${callId})` : ""} ${style.dim(JSON.stringify(args).slice(0, 60))}...`,
-                    };
-                    try {
-                        const executorResult = executor(args, {
-                            toolCallId: callId || `${toolCallId}-${i}`,
-                            messages,
-                            abortSignal,
-                        });
-                        let toolOutput = "";
-                        // Handle both async generators and regular async functions
-                        if (typeof executorResult[Symbol.asyncIterator] === "function") {
-                            // It's an async generator
-                            const generator = executorResult;
-                            for await (const chunk of generator) {
-                                if (typeof chunk === "string") {
-                                    toolOutput += chunk;
-                                }
-                                else if (chunk.event === "tool-completion") {
-                                    // Capture completion message
-                                    toolOutput += chunk.data;
-                                }
-                            }
-                        }
-                        else {
-                            // It's a regular async function returning a string
-                            toolOutput = await executorResult;
-                        }
-                        results.push({
-                            tool: toolName,
-                            id: callId,
-                            status: "success",
-                            result: toolOutput,
-                        });
-                    }
-                    catch (error) {
-                        const errorMessage = error instanceof Error ? error.message : String(error);
-                        logger.error({ error, toolName, args }, "Batch tool execution failed");
-                        results.push({
-                            tool: toolName,
-                            id: callId,
-                            status: "error",
-                            error: errorMessage,
-                        });
-                        // Yield update for failed command
-                        yield {
-                            name: BatchTool.name,
-                            event: "tool-update",
-                            id: toolCallId,
-                            data: `[${callNumber}/${totalCalls}] ${style.red("✗")} ${style.cyan(toolName)} failed: ${errorMessage.slice(0, 100)}`,
-                        };
-                    }
-                }
-                // Format results as JSON
-                const jsonResults = JSON.stringify(results, null, 2);
-                try {
-                    const result = await manageTokenLimit(jsonResults, tokenCounter, "Batch", "Consider reducing the number of calls or using more specific tool calls");
-                    // Create a more informative completion message
-                    const successful = results.filter((r) => r.status === "success").length;
-                    const failed = results.filter((r) => r.status === "error").length;
-                    let completionMessage = `Batch execution completed: ${successful}/${totalCalls} successful`;
-                    if (failed > 0) {
-                        const failedTools = results
-                            .filter((r) => r.status === "error")
-                            .map((r) => `${r.tool}${r.id ? ` (${r.id})` : ""}`)
-                            .join(", ");
-                        completionMessage += `, ${failed} failed: ${failedTools}`;
-                    }
-                    completionMessage += ` (${result.tokenCount} tokens)`;
-                    yield {
-                        name: BatchTool.name,
-                        event: "tool-completion",
-                        id: toolCallId,
-                        data: completionMessage,
-                    };
-                    yield result.content;
-                }
-                catch (error) {
-                    if (error instanceof TokenLimitExceededError) {
-                        yield {
-                            name: BatchTool.name,
-                            event: "tool-error",
-                            id: toolCallId,
-                            data: error.message,
-                        };
-                        yield error.message;
-                        return;
-                    }
-                    throw error;
-                }
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                logger.error({ error }, "Batch tool failed");
-                yield {
-                    name: BatchTool.name,
-                    event: "tool-error",
-                    id: toolCallId,
-                    data: errorMessage,
-                };
-                yield errorMessage;
-            }
-        },
-    };
-};

package/dist/tools/code-interpreter.d.ts

@@ -1,25 +0,0 @@
-import type { ToolCallOptions } from "ai";
-import { z } from "zod";
-import type { TokenCounter } from "../tokens/counter.ts";
-import type { ToolResult } from "./types.ts";
-export declare const CodeInterpreterTool: {
-    name: "codeInterpreter";
-};
-declare const inputSchema: z.ZodObject<{
-    code: z.ZodString;
-    timeoutSeconds: z.ZodNullable<z.ZodNumber>;
-}, z.core.$strip>;
-export declare const createCodeInterpreterTool: ({ tokenCounter, }: {
-    tokenCounter: TokenCounter;
-}) => Promise<{
-    toolDef: {
-        description: string;
-        inputSchema: z.ZodObject<{
-            code: z.ZodString;
-            timeoutSeconds: z.ZodNullable<z.ZodNumber>;
-        }, z.core.$strip>;
-    };
-    execute: ({ code, timeoutSeconds }: z.infer<typeof inputSchema>, { toolCallId, abortSignal }: ToolCallOptions) => AsyncGenerator<ToolResult>;
-}>;
-export {};
-//# sourceMappingURL=code-interpreter.d.ts.map

package/dist/tools/code-interpreter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"code-interpreter.d.ts","sourceRoot":"","sources":["../../source/tools/code-interpreter.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAKzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,mBAAmB;;CAE/B,CAAC;AAmBF,QAAA,MAAM,WAAW;;;iBASf,CAAC;AAEH,eAAO,MAAM,yBAAyB,GAAU,mBAE7C;IACD,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;;;;;wCAO6B,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,+BACxB,eAAe,KAC3C,cAAc,CAAC,UAAU,CAAC;EAoL9B,CAAC"}