@travisennis/acai 0.0.5 → 0.0.6

package/dist/tools/agent.js

@@ -1,9 +1,9 @@
-import { generateText, stepCountIs, tool } from "ai";
+import { generateText, stepCountIs } from "ai";
 import { z } from "zod";
 import { AiConfig } from "../models/ai-config.js";
 import style from "../terminal/style.js";
-import { BashTool } from "./bash.js";
-// import { DirectoryTreeTool } from "./directory-tree.ts";
+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";
@@ -13,18 +13,24 @@ export const AgentTool = {
 };
 const TOOLS = [
     GrepTool.name,
-    BashTool.name,
+    GlobTool.name,
     ReadFileTool.name,
     ReadMultipleFilesTool.name,
-    // DirectoryTreeTool.name,
+    DirectoryTreeTool.name,
 ];
 function getToolDescription() {
     const toolNames = TOOLS.join(", ");
-    return `Launch a new agent that has access to the following tools: ${toolNames}. When you are searching for a keyword or file and are not confident that you will find the right match on the first try, use the ${AgentTool.name} tool to perform the search for you. For example:
+    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.
 
-- If you are searching for a keyword like "config" or "logger", the ${AgentTool.name} tool is appropriate
-- If you want to read a specific file path, use the ${ReadFileTool.name} or appropriate command via the ${BashTool.name} tool instead of this tool, to find the match more quickly
-- If you are searching for a specific class definition like "class Foo", use the ${GrepTool.name} tool instead, to find the match more quickly
+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
@@ -36,55 +42,62 @@ const inputSchema = z.object({
     prompt: z.string().describe("The task for the agent to perform"),
 });
 export const createAgentTools = (options) => {
-    const { modelManager, tokenTracker, tokenCounter, sendData } = 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 {
-        [AgentTool.name]: tool({
-            description: getToolDescription(),
-            inputSchema: inputSchema,
-            execute: async ({ prompt }, { abortSignal, toolCallId }) => {
-                if (abortSignal?.aborted) {
-                    throw new Error("Agent execution aborted");
-                }
-                sendData?.({
-                    event: "tool-init",
-                    id: toolCallId,
-                    data: `Initializing agent with prompt: ${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.getMaxTokens(),
-                        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,
-                        stopWhen: stepCountIs(30),
-                        providerOptions: aiConfig.getProviderOptions(),
-                        tools: await initCliTools({ tokenCounter }),
-                        abortSignal: abortSignal,
-                        // biome-ignore lint/style/useNamingConvention: third-party code
-                        experimental_activeTools: [...TOOLS],
-                    });
-                    tokenTracker.trackUsage("task-agent", usage);
-                    sendData?.({
-                        event: "tool-completion",
-                        id: toolCallId,
-                        data: "Finished running the agent tool.",
-                    });
-                    return text;
-                }
-                catch (error) {
-                    sendData?.({
-                        event: "tool-error",
-                        id: toolCallId,
-                        data: "Error running agent tool.",
-                    });
-                    return Promise.resolve(error.message);
-                }
-            },
-        }),
+        toolDef,
+        execute,
     };
 };

package/dist/tools/bash-utils.d.ts

@@ -1,4 +1,4 @@
-export declare function validatePaths(command: string, baseDir: string, cwd: string): {
+export declare function validatePaths(command: string, allowedDirs: string[], cwd: string, allowedPaths?: string[]): {
     isValid: boolean;
     error?: string;
 };

package/dist/tools/bash-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bash-utils.d.ts","sourceRoot":"","sources":["../../source/tools/bash-utils.ts"],"names":[],"mappings":"AAKA,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,GACV;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAiEtC;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"}
+{"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/bash-utils.js

@@ -1,8 +1,9 @@
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
-import { isPathWithinBaseDir } from "./filesystem-utils.js";
+import { isPathWithinAllowedDirs } from "./filesystem-utils.js";
 // Validate path arguments to ensure they're within the project
-export function validatePaths(command, baseDir, cwd) {
+export function validatePaths(command, allowedDirs, cwd, allowedPaths) {
     // Simple tokenization - split on spaces but respect quotes
     const tokens = [];
     let current = "";
@@ -43,7 +44,7 @@ export function validatePaths(command, baseDir, cwd) {
         // Skip if it's clearly not a path
         if (cleanToken.startsWith("-") ||
             cleanToken.includes("://") ||
-            !cleanToken.includes("/")) {
+            (!cleanToken.includes("/") && cleanToken !== "~")) {
             continue;
         }
         // Skip git commit messages and other special cases
@@ -52,11 +53,18 @@ export function validatePaths(command, baseDir, cwd) {
             continue;
         }
         try {
-            const resolvedPath = path.resolve(cwd, cleanToken);
-            if (!isPathWithinBaseDir(resolvedPath, baseDir)) {
+            // Expand ~ to home directory for proper validation
+            const expandedToken = cleanToken.startsWith("~/") || cleanToken === "~"
+                ? path.join(os.homedir(), cleanToken.slice(1))
+                : cleanToken;
+            const resolvedPath = path.resolve(cwd, expandedToken);
+            // Allow access to explicitly allowed paths
+            const isAllowedPath = allowedPaths?.some((allowedPath) => resolvedPath === path.resolve(allowedPath));
+            if (!isAllowedPath &&
+                !isPathWithinAllowedDirs(resolvedPath, allowedDirs)) {
                 return {
                     isValid: false,
-                    error: `Path '${cleanToken}' resolves outside the project directory (${resolvedPath}). All paths must be within ${baseDir}`,
+                    error: `Path '${cleanToken}' resolves outside the allowed directories (${resolvedPath}). All paths must be within ${allowedDirs.join(", ")}`,
                 };
             }
         }

package/dist/tools/bash.d.ts

@@ -1,21 +1,30 @@
-import type { Terminal } from "../terminal/index.ts";
+import type { ToolCallOptions } from "ai";
+import { z } from "zod";
 import type { TokenCounter } from "../tokens/counter.ts";
-import type { ToolExecutor } from "../tool-executor.ts";
-import type { SendData } from "./types.ts";
+import type { ToolResult } from "./types.ts";
 export declare const BashTool: {
     name: "bash";
 };
-export declare const createBashTool: ({ baseDir, sendData, tokenCounter, terminal, toolExecutor, }: {
+declare const inputSchema: z.ZodObject<{
+    command: z.ZodString;
+    cwd: z.ZodNullable<z.ZodString>;
+    timeout: z.ZodNullable<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+type BashInputSchema = z.infer<typeof inputSchema>;
+export declare const createBashTool: ({ baseDir, allowedDirs, tokenCounter, }: {
     baseDir: string;
-    sendData?: SendData;
+    allowedDirs?: string[];
     tokenCounter: TokenCounter;
-    terminal?: Terminal;
-    toolExecutor?: ToolExecutor;
 }) => Promise<{
-    bash: import("ai").Tool<{
-        command: string;
-        cwd: string | null;
-        timeout: number | null;
-    }, string>;
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            command: z.ZodString;
+            cwd: z.ZodNullable<z.ZodString>;
+            timeout: z.ZodNullable<z.ZodCoercedNumber<unknown>>;
+        }, z.core.$strip>;
+    };
+    execute({ command, cwd, timeout }: BashInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
 }>;
+export {};
 //# sourceMappingURL=bash.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../source/tools/bash.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAe,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGrE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AAKF,eAAO,MAAM,cAAc,GAAU,8DAMlC;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,YAAY,EAAE,YAAY,CAAC;IAC3B,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;;;;;;EAkLA,CAAC"}
+{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../source/tools/bash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAIzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AAKF,QAAA,MAAM,WAAW;;;;iBAcf,CAAC;AAEH,KAAK,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,eAAO,MAAM,cAAc,GAAU,yCAIlC;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;;;;;;uCAcgC,eAAe,+BACb,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EAyFhC,CAAC"}

package/dist/tools/bash.js

@@ -1,155 +1,108 @@
-import { tool } from "ai";
 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 { manageTokenLimit } from "../tokens/threshold.js";
 import { isMutatingCommand, resolveCwd, validatePaths } from "./bash-utils.js";
-import { isPathWithinBaseDir } from "./filesystem-utils.js";
+import { isPathWithinAllowedDirs } from "./filesystem-utils.js";
 export const BashTool = {
     name: "bash",
 };
 // 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."),
+    timeout: z.coerce
+        .number()
+        .nullable()
+        .describe(`Command execution timeout in milliseconds. Default: ${DEFAULT_TIMEOUT}ms`),
+});
+export const createBashTool = async ({ baseDir, allowedDirs, tokenCounter, }) => {
     const execEnv = await initExecutionEnvironment();
+    const projectConfig = await config.readProjectConfig();
+    const allowedPaths = projectConfig.logs?.path
+        ? [projectConfig.logs.path]
+        : [];
+    const allowedDirectories = allowedDirs ?? [baseDir];
     return {
-        [BashTool.name]: tool({
+        toolDef: {
             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",
-                        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}`;
-                        }
-                    }
-                    if (abortSignal?.aborted) {
-                        throw new Error("Command execution aborted before running the command");
-                    }
-                    terminal?.startProgress();
-                    const { output, exitCode } = await execEnv.executeCommand(command, {
-                        cwd: resolvedCwd,
-                        timeout: safeTimeout,
-                        abortSignal,
-                        preserveOutputOnError: true,
-                        captureStderr: true,
-                        throwOnError: false,
-                    });
-                    sendData?.({
-                        event: "tool-update",
+            inputSchema,
+        },
+        async *execute({ 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;
+                // Safety warning for potentially mutating commands
+                const isMutating = isMutatingCommand(command);
+                yield {
+                    name: BashTool.name,
+                    event: "tool-init",
+                    id: toolCallId,
+                    data: `${style.cyan(command)}${isMutating ? " *" : ""}`,
+                };
+                if (!isPathWithinAllowedDirs(resolvedCwd, allowedDirectories)) {
+                    const errorMsg = `Working directory must be within the allowed directories: ${allowedDirectories.join(", ")}`;
+                    yield {
+                        name: BashTool.name,
+                        event: "tool-error",
                         id: toolCallId,
-                        data: {
-                            primary: "Result",
-                            secondary: output.trim().split("\n").slice(-20),
-                        },
-                    });
-                    let tokenCount = 0;
-                    try {
-                        tokenCount = tokenCounter.count(output);
-                    }
-                    catch (tokenError) {
-                        console.info("Error calculating token count:", tokenError);
-                    }
-                    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",
+                        data: errorMsg,
+                    };
+                    yield errorMsg;
+                    return;
+                }
+                const pathValidation = validatePaths(command, allowedDirectories, resolvedCwd, allowedPaths);
+                if (!pathValidation.isValid) {
+                    yield {
+                        name: BashTool.name,
+                        event: "tool-error",
                         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;
+                        data: pathValidation.error ?? "Unknown error.",
+                    };
+                    yield pathValidation.error ?? "Unknown error.";
+                    return;
                 }
-                catch (error) {
-                    logger.error(error, "Bash Tool Error:");
-                    const errorMsg = `Command failed: ${error.message}`;
-                    sendData?.({ event: "tool-error", id: toolCallId, data: errorMsg });
-                    return errorMsg;
+                if (abortSignal?.aborted) {
+                    throw new Error("Command execution aborted before running the command");
                 }
-            },
-        }),
+                const { output, exitCode } = await execEnv.executeCommand(command, {
+                    cwd: resolvedCwd,
+                    timeout: safeTimeout,
+                    abortSignal,
+                    preserveOutputOnError: true,
+                    captureStderr: true,
+                    throwOnError: false,
+                });
+                const result = await manageTokenLimit(output, tokenCounter, "Bash", "Adjust command to return more specific results");
+                yield {
+                    name: BashTool.name,
+                    event: "tool-completion",
+                    id: toolCallId,
+                    data: `${exitCode} (${result.tokenCount} tokens)`,
+                };
+                yield result.content;
+            }
+            catch (error) {
+                logger.error(error, "Bash Tool Error:");
+                yield {
+                    name: BashTool.name,
+                    event: "tool-error",
+                    id: toolCallId,
+                    data: error.message,
+                };
+                yield error.message;
+            }
+        },
     };
 };

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;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"}