@travisennis/acai 0.0.6 → 0.0.8

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

@@ -1,281 +0,0 @@
-import { execSync } from "node:child_process";
-import { readFile, writeFile } from "node:fs/promises";
-import { createTwoFilesPatch } from "diff";
-import { z } from "zod";
-import style from "../terminal/style.js";
-import { joinWorkingDir, validatePath } from "./filesystem-utils.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 });
-                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;CA8D9B,CAAC"}

package/dist/tools/agent.js

@@ -1,103 +0,0 @@
-import { generateText, stepCountIs } from "ai";
-import { z } from "zod";
-import { AiConfig } from "../models/ai-config.js";
-import style from "../terminal/style.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: `\n${style.cyan(prompt)}`,
-        };
-        try {
-            const modelConfig = modelManager.getModelMetadata("task-agent");
-            const aiConfig = new AiConfig({
-                modelMetadata: modelConfig,
-                prompt: 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-completion",
-                id: toolCallId,
-                data: `Finished running the agent tool (${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/bash-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bash-utils.d.ts","sourceRoot":"","sources":["../../source/tools/bash-utils.ts"],"names":[],"mappings":"AAMA,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EAAE,EACrB,GAAG,EAAE,MAAM,EACX,YAAY,CAAC,EAAE,MAAM,EAAE,GACtB;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAgFtC;AAED,eAAO,MAAM,UAAU,GACrB,UAAU,MAAM,GAAG,IAAI,GAAG,SAAS,EACnC,YAAY,MAAM,KACjB,MAiDF,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,YAAY,MAAM,KAAG,OAmHtD,CAAC"}

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;AAEzD,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;EAqK9B,CAAC"}

package/dist/tools/code-interpreter.js

@@ -1,167 +0,0 @@
-import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { mkdir, rm, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import process from "node:process";
-import { z } from "zod";
-import { manageTokenLimit } from "../tokens/threshold.js";
-export const CodeInterpreterTool = {
-    name: "codeInterpreter",
-};
-const toolDescription = `Executes Typescript code in a separate Node.js process using Node's Permission Model. 
-
-⚠️ **IMPORTANT**: This tool uses ES Modules (ESM) only.
-- Use \`import\` statements, NOT \`require()\`
-- Examples: \`import fs from 'node:fs'\` NOT \`const fs = require('fs')\`
-- Add file extensions for relative imports: \`import { utils } from './utils.js'\`
-
-These scripts are run in the \`${process.cwd()}/.acai-ci-tmp\`. You can import project source files using relative paths from the project root with .ts extensions:
-
-\`\`\` typescript
-import { functionName } from '../source/path/to/module.ts';
-\`\`\`
-
-The interpreter supports ES Modules with TypeScript files directly.
-
-Timeout defaults to 5 seconds and can be extended up to 60 seconds.`;
-const inputSchema = z.object({
-    code: z.string().describe("The Typescript code to be executed."),
-    timeoutSeconds: z
-        .number()
-        .int()
-        .min(1)
-        .max(60)
-        .nullable()
-        .describe("Execution timeout in seconds (1-60). Default 5."),
-});
-export const createCodeInterpreterTool = async ({ tokenCounter, }) => {
-    const toolDef = {
-        description: toolDescription,
-        inputSchema,
-    };
-    async function* execute({ code, timeoutSeconds }, { toolCallId, abortSignal }) {
-        // Check if execution has been aborted
-        if (abortSignal?.aborted) {
-            throw new Error("Code interpretation aborted");
-        }
-        const workingDirectory = process.cwd();
-        const lines = code.split("\n");
-        try {
-            yield {
-                name: CodeInterpreterTool.name,
-                event: "tool-init",
-                id: toolCallId,
-                data: `Executing ${lines.length} lines of code.`,
-            };
-            if (code.trim().length === 0) {
-                throw new Error("No code provided");
-            }
-            if (abortSignal?.aborted) {
-                throw new Error("Code interpretation aborted before execution");
-            }
-            const timeoutMs = Math.min(Math.max((timeoutSeconds ?? 5) * 1000, 1000), 60000);
-            const tmpBase = join(workingDirectory, ".acai-ci-tmp");
-            await mkdir(tmpBase, { recursive: true });
-            const ext = ".ts";
-            const scriptPath = join(tmpBase, `temp_script_${Date.now()}_${randomUUID()}${ext}`);
-            await writeFile(scriptPath, code, { encoding: "utf8" });
-            const args = [
-                "--permission",
-                `--allow-fs-read=${workingDirectory}`,
-                `--allow-fs-write=${workingDirectory}`,
-                scriptPath,
-            ];
-            const child = spawn(process.execPath, args, {
-                cwd: workingDirectory,
-                // do not rely solely on spawn's timeout; we implement manual timeout below
-                stdio: "pipe",
-                env: Object.assign({}, process.env, {
-                    // biome-ignore lint/style/useNamingConvention: Environment variable keys are uppercase by convention
-                    NO_COLOR: "true",
-                    // biome-ignore lint/style/useNamingConvention: Environment variable keys are uppercase by convention
-                    NODE_OPTIONS: "",
-                    // biome-ignore lint/style/useNamingConvention: Environment variable keys are uppercase by convention
-                    ACAI_CODE_INTERPRETER: "true",
-                }),
-            });
-            // Handle abort signal by killing the child process
-            if (abortSignal) {
-                const abortHandler = () => {
-                    try {
-                        child.kill("SIGKILL");
-                    }
-                    catch { }
-                    throw new Error("Code interpretation aborted during execution");
-                };
-                abortSignal.addEventListener("abort", abortHandler);
-            }
-            let stdout = "";
-            let stderr = "";
-            let timedOut = false;
-            const timer = setTimeout(() => {
-                timedOut = true;
-                try {
-                    child.kill("SIGKILL");
-                }
-                catch { }
-            }, timeoutMs);
-            child.stdout.setEncoding("utf8");
-            child.stderr.setEncoding("utf8");
-            child.stdout.on("data", (chunk) => {
-                stdout += String(chunk);
-            });
-            child.stderr.on("data", (chunk) => {
-                stderr += String(chunk);
-            });
-            const completed = await new Promise((resolve, reject) => {
-                child.on("error", (err) => reject(err));
-                child.on("close", (code, signal) => resolve({ code, signal }));
-            });
-            clearTimeout(timer);
-            // Cleanup temp file/directory
-            await rm(scriptPath, { force: true });
-            await rm(tmpBase, { force: true, recursive: true });
-            if (timedOut) {
-                throw new Error("Script timed out");
-            }
-            if (completed.code === null) {
-                throw new Error(`Process terminated by signal ${completed.signal ?? "unknown"}`);
-            }
-            if (completed.code !== 0) {
-                const message = `Process exited with code ${completed.code}. Stderr:\n${stderr.trim()}`;
-                throw new Error(message);
-            }
-            const result = {
-                stdout: stdout.trim(),
-                stderr: stderr.trim(),
-                exitCode: completed.code ?? -1,
-            };
-            const resultJson = JSON.stringify(result, null, 2);
-            const managedResult = await manageTokenLimit(resultJson, tokenCounter, "CodeInterpreter", "Reduce script complexity or output size");
-            yield {
-                name: CodeInterpreterTool.name,
-                event: "tool-completion",
-                id: toolCallId,
-                data: `Completed successfully${managedResult.tokenCount > 0 ? ` (${managedResult.tokenCount} tokens)` : ""}`,
-            };
-            yield managedResult.content;
-        }
-        catch (err) {
-            const errorMessage = err.name === "ETIMEDOUT" ||
-                err.message.includes("timed out")
-                ? "Script timed out"
-                : err.message;
-            yield {
-                name: CodeInterpreterTool.name,
-                event: "tool-error",
-                id: toolCallId,
-                data: errorMessage,
-            };
-            yield errorMessage;
-        }
-    }
-    return {
-        toolDef,
-        execute,
-    };
-};

package/dist/tools/delete-file.d.ts

@@ -1,24 +0,0 @@
-import type { ToolCallOptions } from "ai";
-import { z } from "zod";
-import type { ToolResult } from "./types.ts";
-export declare const DeleteFileTool: {
-    name: "deleteFile";
-};
-declare const inputSchema: z.ZodObject<{
-    path: z.ZodString;
-}, z.core.$strip>;
-type DeleteFileInputSchema = z.infer<typeof inputSchema>;
-export declare const createDeleteFileTool: ({ workingDir, allowedDirs, }: {
-    workingDir: string;
-    allowedDirs?: string[];
-}) => Promise<{
-    toolDef: {
-        description: string;
-        inputSchema: z.ZodObject<{
-            path: z.ZodString;
-        }, z.core.$strip>;
-    };
-    execute({ path: userPath }: DeleteFileInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
-}>;
-export {};
-//# sourceMappingURL=delete-file.d.ts.map

package/dist/tools/delete-file.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"delete-file.d.ts","sourceRoot":"","sources":["../../source/tools/delete-file.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,cAAc;;CAE1B,CAAC;AAEF,QAAA,MAAM,WAAW;;iBAEf,CAAC;AAEH,KAAK,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEzD,eAAO,MAAM,oBAAoB,GAAU,8BAGxC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;;;;;;;gCASyB,qBAAqB,+BACZ,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EA2DhC,CAAC"}