@travisennis/acai 0.0.5 → 0.0.7

package/dist/tools/bash.js

@@ -1,113 +1,117 @@
-import { tool } from "ai";
+import { execSync } from "node:child_process";
 import { z } from "zod";
-import { config } from "../config.js";
 import { initExecutionEnvironment } from "../execution/index.js";
 import { logger } from "../logger.js";
 import style from "../terminal/style.js";
-import { isMutatingCommand, resolveCwd, validatePaths } from "./bash-utils.js";
-import { isPathWithinBaseDir } from "./filesystem-utils.js";
+import { manageTokenLimit, TokenLimitExceededError, } from "../tokens/threshold.js";
+import { isMutatingCommand, resolveCwd, validatePaths } from "../utils/bash.js";
 export const BashTool = {
     name: "bash",
 };
+const installedTools = getInstalledTools();
+const toolDescription = `Execute commands in a shell. Commands can execute only within the allowed directories. Always use absolute paths.
+
+Tools available:
+${installedTools}`;
 // Command execution timeout in milliseconds
 const DEFAULT_TIMEOUT = 1.5 * 60 * 1000; // 1.5 minutes
-export const createBashTool = async ({ baseDir, sendData, tokenCounter, terminal, toolExecutor, }) => {
+const inputSchema = z.object({
+    command: z.string().describe("Full CLI command to execute."),
+    cwd: z
+        .string()
+        .nullable()
+        .describe("Working directory file path (default: project root). Must be within the project directory. Required but nullable."),
+    timeout: z.coerce
+        .number()
+        .nullable()
+        .describe(`Command execution timeout in milliseconds. Required but nullable. If null, the default value is ${DEFAULT_TIMEOUT}ms`),
+    background: z
+        .boolean()
+        .optional()
+        .describe("Run command in background. If true, command will run until program exit."),
+});
+export const createBashTool = async ({ baseDir, allowedDirs, tokenCounter, }) => {
     const execEnv = await initExecutionEnvironment();
+    const allowedDirectories = allowedDirs ?? [baseDir];
     return {
-        [BashTool.name]: tool({
-            description: "Execute commands in a shell. Commands execute only within the project directory. Always use absolute paths.",
-            inputSchema: z.object({
-                command: z.string().describe("Full CLI command to execute."),
-                cwd: z
-                    .string()
-                    .nullable()
-                    .describe("Working directory file path (default: project root). Must be within the project directory."),
-                timeout: z.coerce
-                    .number()
-                    .nullable()
-                    .describe(`Command execution timeout in milliseconds. Default: ${DEFAULT_TIMEOUT}ms`),
-            }),
-            execute: async ({ command, cwd, timeout }, { toolCallId, abortSignal }) => {
-                try {
-                    if (abortSignal?.aborted) {
-                        throw new Error("Command execution aborted");
-                    }
-                    // grok doesn't follow my instructions
-                    const safeCwd = cwd === "null" ? null : cwd;
-                    const resolvedCwd = resolveCwd(safeCwd, baseDir);
-                    const safeTimeout = timeout ?? DEFAULT_TIMEOUT;
-                    sendData?.({
-                        event: "tool-init",
+        toolDef: {
+            description: toolDescription,
+            inputSchema,
+        },
+        async *execute({ command, cwd, timeout, background }, { toolCallId, abortSignal }) {
+            try {
+                if (abortSignal?.aborted) {
+                    throw new Error("Command execution aborted");
+                }
+                // grok doesn't follow my instructions
+                const safeCwd = cwd === "null" ? null : cwd;
+                const resolvedCwd = resolveCwd(safeCwd, baseDir, allowedDirectories);
+                const safeTimeout = timeout ?? DEFAULT_TIMEOUT;
+                // Safety warning for potentially mutating commands
+                const isMutating = isMutatingCommand(command);
+                yield {
+                    name: BashTool.name,
+                    event: "tool-init",
+                    id: toolCallId,
+                    data: `${style.cyan(command)}`,
+                };
+                const pathValidation = validatePaths(command, allowedDirectories, resolvedCwd);
+                if (!pathValidation.isValid) {
+                    yield {
+                        name: BashTool.name,
+                        event: "tool-error",
                         id: toolCallId,
-                        data: `Executing: ${style.cyan(command)} in ${style.cyan(resolvedCwd)}`,
-                    });
-                    if (!isPathWithinBaseDir(resolvedCwd, baseDir)) {
-                        const errorMsg = `Working directory must be within the project directory: ${baseDir}`;
-                        sendData?.({ event: "tool-error", id: toolCallId, data: errorMsg });
-                        return errorMsg;
-                    }
-                    const pathValidation = validatePaths(command, baseDir, resolvedCwd);
-                    if (!pathValidation.isValid) {
-                        sendData?.({
-                            event: "tool-error",
-                            id: toolCallId,
-                            data: pathValidation.error ?? "Unknown error.",
-                        });
-                        return pathValidation.error ?? "Unknown error.";
-                    }
-                    if (terminal) {
-                        let userResponse;
-                        // Prompt only for potentially mutating commands when a toolExecutor is present
-                        if (toolExecutor && isMutatingCommand(command)) {
-                            // Display if autoAccept is false
-                            if (!toolExecutor.autoAccept(BashTool.name)) {
-                                terminal.writeln(`\n${style.blue.bold("●")} Proposing to execute command: ${style.cyan(command)} in ${style.cyan(resolvedCwd)}`);
-                                terminal.lineBreak();
-                            }
-                            const ctx = {
-                                toolName: BashTool.name,
-                                toolCallId,
-                                message: "What would you like to do with this command execution?",
-                                choices: {
-                                    accept: "Execute this command",
-                                    acceptAll: "Accept all future command executions (including this)",
-                                    reject: "Reject this command execution",
-                                },
-                            };
-                            try {
-                                userResponse = await toolExecutor.ask(ctx, { abortSignal });
-                            }
-                            catch (e) {
-                                if (e.name === "AbortError") {
-                                    throw new Error("Command execution aborted during user input");
-                                }
-                                throw e;
-                            }
-                        }
-                        const { result: userChoice, reason } = userResponse ?? {
-                            result: "accept",
-                        };
-                        terminal.lineBreak();
-                        if (userChoice === "accept-all") {
-                            terminal.writeln(style.yellow("✓ Auto-accept mode enabled for all command executions"));
-                            terminal.lineBreak();
-                        }
-                        if (userChoice === "reject") {
-                            terminal.lineBreak();
-                            const rejectionReason = reason || "No reason provided";
-                            sendData?.({
-                                event: "tool-completion",
-                                id: toolCallId,
-                                data: `Command execution rejected by user. Reason: ${rejectionReason}`,
-                            });
-                            return `The user rejected this command execution. Reason: ${rejectionReason}`;
-                        }
+                        data: pathValidation.error ?? "Unknown error.",
+                    };
+                    yield pathValidation.error ?? "Unknown error.";
+                    return;
+                }
+                if (abortSignal?.aborted) {
+                    throw new Error("Command execution aborted before running the command");
+                }
+                // Handle background execution
+                if (background) {
+                    // Strip any existing & from command to avoid double backgrounding
+                    let processedCommand = command.trim();
+                    if (processedCommand.endsWith("&")) {
+                        logger.warn(`Stripping '&' from command since background=true: ${command}`);
+                        processedCommand = processedCommand.slice(0, -1).trim();
                     }
-                    if (abortSignal?.aborted) {
-                        throw new Error("Command execution aborted before running the command");
+                    // Fix rg commands that don't have an explicit path
+                    processedCommand = fixRgCommand(processedCommand);
+                    const backgroundProcess = execEnv.executeCommandInBackground(processedCommand, {
+                        cwd: resolvedCwd,
+                        abortSignal,
+                        onOutput: (output) => {
+                            logger.debug({ output }, "Background command output:");
+                        },
+                        onError: (error) => {
+                            logger.debug({ error }, "Background command error:");
+                        },
+                        onExit: (code) => {
+                            logger.debug(`Background command exited with code ${code}`);
+                        },
+                    });
+                    yield {
+                        name: BashTool.name,
+                        event: "tool-completion",
+                        id: toolCallId,
+                        data: `Background process started with PID: ${backgroundProcess.pid}`,
+                    };
+                    yield `Background process started with PID: ${backgroundProcess.pid}`;
+                }
+                else {
+                    // Handle regular synchronous execution
+                    // Strip & if present to ensure synchronous behavior
+                    let processedCommand = command.trim();
+                    if (processedCommand.endsWith("&")) {
+                        logger.warn(`Stripping '&' from command since background=false: ${command}`);
+                        processedCommand = processedCommand.slice(0, -1).trim();
                     }
-                    terminal?.startProgress();
-                    const { output, exitCode } = await execEnv.executeCommand(command, {
+                    // Fix rg commands that don't have an explicit path
+                    // rg hangs when stdin is a socket and no path is given
+                    processedCommand = fixRgCommand(processedCommand);
+                    const { output, exitCode } = await execEnv.executeCommand(processedCommand, {
                         cwd: resolvedCwd,
                         timeout: safeTimeout,
                         abortSignal,
@@ -115,41 +119,152 @@ export const createBashTool = async ({ baseDir, sendData, tokenCounter, terminal
                         captureStderr: true,
                         throwOnError: false,
                     });
-                    sendData?.({
-                        event: "tool-update",
-                        id: toolCallId,
-                        data: {
-                            primary: "Result",
-                            secondary: output.trim().split("\n").slice(-20),
-                        },
-                    });
-                    let tokenCount = 0;
                     try {
-                        tokenCount = tokenCounter.count(output);
+                        const result = await manageTokenLimit(output, tokenCounter, "Bash", "Adjust command to return more specific results");
+                        const statusText = exitCode === 0 ? "success" : "error";
+                        yield {
+                            name: BashTool.name,
+                            event: "tool-completion",
+                            id: toolCallId,
+                            data: `${statusText}${isMutating ? " *" : ""} (${result.tokenCount} tokens)`,
+                        };
+                        yield result.content;
                     }
-                    catch (tokenError) {
-                        console.info("Error calculating token count:", tokenError);
+                    catch (error) {
+                        if (error instanceof TokenLimitExceededError) {
+                            yield {
+                                name: BashTool.name,
+                                event: "tool-error",
+                                id: toolCallId,
+                                data: error.message,
+                            };
+                            yield error.message;
+                            return;
+                        }
+                        throw error;
                     }
-                    const maxTokens = (await config.readProjectConfig()).tools.maxTokens;
-                    const maxTokenMessage = `Output of command (${tokenCount} tokens) exceeds maximum allowed tokens (${maxTokens}). Please adjust how you call the command to get back more specific results.`;
-                    const finalResult = tokenCount <= maxTokens ? output : maxTokenMessage;
-                    sendData?.({
-                        event: "tool-completion",
-                        id: toolCallId,
-                        data: tokenCount <= maxTokens
-                            ? `Command executed successfully: ${exitCode} (${tokenCount} tokens)`
-                            : `Output of command (${tokenCount} tokens) exceeds maximum allowed tokens (${maxTokens}).`,
-                    });
-                    terminal?.stopProgress();
-                    return finalResult;
-                }
-                catch (error) {
-                    logger.error(error, "Bash Tool Error:");
-                    const errorMsg = `Command failed: ${error.message}`;
-                    sendData?.({ event: "tool-error", id: toolCallId, data: errorMsg });
-                    return errorMsg;
                 }
-            },
-        }),
+            }
+            catch (error) {
+                logger.error(error, "Bash Tool Error:");
+                yield {
+                    name: BashTool.name,
+                    event: "tool-error",
+                    id: toolCallId,
+                    data: error.message,
+                };
+                yield error.message;
+            }
+        },
     };
 };
+function getInstalledTools() {
+    // Check for required bash tools
+    const tools = [
+        {
+            name: "git",
+            command: "git --version",
+            description: "Version control system - used for cloning repositories, checking out branches, committing changes, viewing history, and managing code versions",
+        },
+        {
+            name: "gh",
+            command: "gh --version",
+            description: "GitHub CLI - used for creating pull requests, managing issues, interacting with GitHub API, and automating GitHub workflows",
+        },
+        {
+            name: "rg",
+            command: "rg --version",
+            description: "ripgrep - fast text search tool for searching code patterns, file contents, and regular expressions across the codebase (use this instead of grep)",
+        },
+        {
+            name: "fd",
+            command: "fd --version",
+            description: "Fast file finder - alternative to find command, used for finding files by name, pattern, or type with intuitive syntax (use this instead of find)",
+        },
+        {
+            name: "ast-grep",
+            command: "ast-grep --version",
+            description: "AST-based code search - used for structural code search, refactoring, finding patterns in abstract syntax trees, and code transformations",
+        },
+        {
+            name: "jq",
+            command: "jq --version",
+            description: "JSON processor - used for parsing, filtering, and manipulating JSON output from APIs, commands, and configuration files",
+        },
+        {
+            name: "yq",
+            command: "yq --version",
+            description: "YAML processor - used for parsing and manipulating YAML files (configs, CI/CD pipelines, Kubernetes manifests) with jq-like syntax",
+        },
+    ];
+    const toolStatus = tools
+        .map((tool) => {
+        let status = false;
+        try {
+            execSync(tool.command, { stdio: "ignore", timeout: 5000 });
+            status = true;
+        }
+        catch (_error) {
+            // Ignore error, tool is not installed
+        }
+        return { name: tool.name, description: tool.description, status };
+    })
+        .filter((tool) => tool.status)
+        .map((tool) => `- **${tool.name}**: ${tool.description}`)
+        .join("\n");
+    return toolStatus;
+}
+/**
+ * Fix rg commands that don't have an explicit path
+ * rg hangs when stdin is a socket and no path is given
+ * See: https://github.com/BurntSushi/ripgrep/discussions/2047
+ */
+function fixRgCommand(command) {
+    const trimmed = command.trim();
+    // Check if command starts with rg
+    if (!trimmed.startsWith("rg ") && !trimmed.startsWith("rg\\")) {
+        return command;
+    }
+    // Check if command already has stdin redirection or piping
+    // Don't modify commands like: cat file.txt | rg pattern
+    // or rg pattern < input.txt
+    if (trimmed.includes("|") || trimmed.includes("<") || trimmed.includes(">")) {
+        return command;
+    }
+    // Simple heuristic: if last token starts with -, add .
+    // This handles cases like: rg -l pattern --type ts --type js
+    const tokens = trimmed.split(/\\s+/);
+    const lastToken = tokens[tokens.length - 1];
+    if (lastToken?.startsWith("-")) {
+        // Command ends with an option, need to add path
+        logger.debug(`Adding '.' to rg command: ${command}`);
+        return `${command} .`;
+    }
+    // Last token doesn't start with -, could be a path or pattern
+    if (lastToken) {
+        // If it's ., ./, /, or contains /, assume it's a path
+        if (lastToken === "." ||
+            lastToken.startsWith("./") ||
+            lastToken.startsWith("/") ||
+            lastToken.includes("/") ||
+            lastToken === "..") {
+            // Already has a path
+            return command;
+        }
+        // Check if it's a simple pattern (no special chars that would make it a path)
+        // If it's just alphanumeric with maybe some regex chars, it's probably a pattern
+        // Common pattern chars: ., *, +, ?, [, ], ^, $, (, ), |, \\
+        // But we want to be conservative - if it looks like a filename without path, add .
+        if (!lastToken.includes("/") && !lastToken.includes("*")) {
+            // Doesn't look like a path with glob or directory, likely a pattern
+            // Need to add path
+            logger.debug(`Adding '.' to rg command: ${command}`);
+            return `${command} .`;
+        }
+        // Complex case with * or other chars, could be a glob pattern
+        // Default to adding . to be safe
+    }
+    // No last token or complex case, add . to be safe
+    logger.debug(`Adding '.' to rg command: ${command}`);
+    return `${command} .`;
+}

package/dist/tools/batch.d.ts

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,174 @@
+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,13 +1,25 @@
-import type { SendData } from "./types.ts";
+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";
 };
-export declare const createCodeInterpreterTool: ({ sendData, }: Readonly<{
-    sendData?: SendData | undefined;
-}>) => {
-    codeInterpreter: import("ai").Tool<{
-        code: string;
-        timeoutSeconds: number | null;
-    }, string>;
-};
+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 +1 @@
-{"version":3,"file":"code-interpreter.d.ts","sourceRoot":"","sources":["../../source/tools/code-interpreter.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,mBAAmB;;CAE/B,CAAC;AAmBF,eAAO,MAAM,yBAAyB,GAAI,eAEvC,QAAQ,CAAC;IACV,QAAQ,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CACjC,CAAC;;;;;CAiLD,CAAC"}
+{"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"}