@travisennis/acai 0.0.4 → 0.0.6

package/dist/tools/bash-utils.js

@@ -0,0 +1,220 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { isPathWithinAllowedDirs } from "./filesystem-utils.js";
+// Validate path arguments to ensure they're within the project
+export function validatePaths(command, allowedDirs, cwd, allowedPaths) {
+    // Simple tokenization - split on spaces but respect quotes
+    const tokens = [];
+    let current = "";
+    let inQuotes = false;
+    let quoteChar = "";
+    for (let i = 0; i < command.length; i++) {
+        const char = command[i] ?? "";
+        if ((char === '"' || char === "'") && !inQuotes) {
+            inQuotes = true;
+            quoteChar = char;
+            current += char;
+        }
+        else if (char === quoteChar && inQuotes) {
+            inQuotes = false;
+            quoteChar = "";
+            current += char;
+        }
+        else if (char === " " && !inQuotes) {
+            if (current) {
+                tokens.push(current);
+                current = "";
+            }
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current)
+        tokens.push(current);
+    // Check each token that looks like a path
+    for (let i = 1; i < tokens.length; i++) {
+        // Skip the command itself
+        const token = tokens[i];
+        if (!token)
+            continue;
+        // Remove quotes for path checking
+        const cleanToken = token.replace(/^['"]|['"]$/g, "");
+        // Skip if it's clearly not a path
+        if (cleanToken.startsWith("-") ||
+            cleanToken.includes("://") ||
+            (!cleanToken.includes("/") && cleanToken !== "~")) {
+            continue;
+        }
+        // Skip git commit messages and other special cases
+        const prevToken = tokens[i - 1]?.replace(/^['"]|['"]$/g, "");
+        if (prevToken === "-m" || prevToken === "--message") {
+            continue;
+        }
+        try {
+            // 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 allowed directories (${resolvedPath}). All paths must be within ${allowedDirs.join(", ")}`,
+                };
+            }
+        }
+        catch (_e) { }
+    }
+    return { isValid: true };
+}
+export const resolveCwd = (cwdInput, workingDir) => {
+    const projectRootAbs = path.resolve(workingDir);
+    let projectRoot = projectRootAbs;
+    try {
+        projectRoot = fs.realpathSync(projectRootAbs);
+    }
+    catch {
+        // Fallback to resolved path
+    }
+    const raw = typeof cwdInput === "string" && cwdInput.trim() !== ""
+        ? cwdInput.trim()
+        : projectRoot;
+    const abs = path.isAbsolute(raw) ? raw : path.resolve(projectRoot, raw);
+    let target = abs;
+    try {
+        target = fs.realpathSync(abs);
+    }
+    catch {
+        // If the path doesn't exist entirely, validate intended path
+    }
+    const rel = path.relative(projectRoot, target);
+    const inside = rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+    if (!inside) {
+        throw new Error(`Working directory must be within the project directory: ${projectRoot}. Received: ${cwdInput ?? "<default>"} -> ${target}`);
+    }
+    // Check existence and that it's a directory
+    let stats;
+    try {
+        stats = fs.statSync(target);
+    }
+    catch (err) {
+        const error = err;
+        if (error.code === "ENOENT") {
+            throw new Error(`Working directory does not exist: ${target} (from ${cwdInput ?? "<default>"})`);
+        }
+        throw error;
+    }
+    if (!stats.isDirectory()) {
+        throw new Error(`Working directory is not a directory: ${target}`);
+    }
+    return target;
+};
+export const isMutatingCommand = (rawCommand) => {
+    const command = rawCommand.trim();
+    // Redirections that write to disk
+    if (/>|>>/.test(command)) {
+        return true;
+    }
+    // Normalize whitespace and split into simple segments (does not fully parse shell)
+    const segments = command
+        .split(/\s*(?:&&|\|\||;|\|)\s*/)
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    const mutatingBinaries = new Set([
+        "rm",
+        "mv",
+        "cp",
+        "mkdir",
+        "rmdir",
+        "touch",
+        "chmod",
+        "chown",
+        "ln",
+        "truncate",
+        "dd",
+        "tee",
+    ]);
+    const npmMutating = new Set([
+        "install",
+        "uninstall",
+        "update",
+        "ci",
+        "publish",
+        "link",
+        "dedupe",
+        "prune",
+        "rebuild",
+        "add",
+    ]);
+    const gitMutating = new Set([
+        "add",
+        "am",
+        "apply",
+        "branch",
+        "checkout",
+        "switch",
+        "cherry-pick",
+        "clean",
+        "commit",
+        "merge",
+        "mv",
+        "pull",
+        "push",
+        "rebase",
+        "reset",
+        "revert",
+        "stash",
+        "tag",
+        "worktree",
+        "submodule",
+        "config",
+    ]);
+    // Generic action words that should be considered mutating when present in the command
+    const actionMutating = new Set(["create", "update", "upgrade", "install"]);
+    for (const seg of segments) {
+        const tokens = seg.split(/\s+/);
+        if (tokens.length === 0)
+            continue;
+        const bin = tokens[0];
+        if (!bin)
+            continue;
+        // If any token is an action-like mutating word, consider mutating
+        if (tokens.some((t) => actionMutating.has(t))) {
+            return true;
+        }
+        // sed -i is mutating
+        if (bin === "sed") {
+            if (tokens.some((t) => /^-i/.test(t))) {
+                return true;
+            }
+            // sed without -i is not mutating
+        }
+        if (mutatingBinaries.has(bin)) {
+            return true;
+        }
+        if (bin === "git" && tokens.length > 1) {
+            const sub = tokens[1];
+            if (typeof sub === "string" && gitMutating.has(sub)) {
+                return true;
+            }
+        }
+        if (bin === "npm" && tokens.length > 1) {
+            const sub = tokens[1];
+            if (typeof sub === "string" && npmMutating.has(sub)) {
+                return true;
+            }
+        }
+        if ((bin === "pnpm" || bin === "yarn") && tokens.length > 1) {
+            const sub = tokens[1];
+            if (typeof sub === "string" && npmMutating.has(sub)) {
+                return true;
+            }
+        }
+    }
+    return false;
+};

package/dist/tools/bash.d.ts

@@ -1,19 +1,30 @@
-import type { Terminal } from "../terminal/index.ts";
-import type { TokenCounter } from "../token-utils.ts";
-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 BashTool: {
     name: "bash";
 };
-export declare const createBashTool: ({ baseDir, sendData, tokenCounter, terminal, autoAcceptAll, }: {
+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 | undefined;
+    allowedDirs?: string[];
     tokenCounter: TokenCounter;
-    terminal?: Terminal;
-    autoAcceptAll: boolean;
-}) => {
-    bash: import("ai").Tool<{
-        cwd: string | null;
-        timeout: number | null;
-        command: string;
-    }, string>;
-};
+}) => Promise<{
+    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

@@ -0,0 +1 @@
+{"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,272 +1,108 @@
-import path from "node:path";
-import { input, select } from "@inquirer/prompts";
-import { tool } from "ai";
-import chalk from "chalk";
 import { z } from "zod";
 import { config } from "../config.js";
-import { executeCommand } from "../utils/process.js";
-import { CommandValidation } from "./command-validation.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 { isPathWithinAllowedDirs } from "./filesystem-utils.js";
 export const BashTool = {
     name: "bash",
 };
-// Whitelist of allowed commands
-const ALLOWED_COMMANDS = [
-    "chmod",
-    "ls",
-    "pwd",
-    "cat",
-    "grep",
-    "find",
-    "echo",
-    "mkdir",
-    "touch",
-    "cp",
-    "mv",
-    "pwd",
-    "wc",
-    "diff",
-    "sort",
-    "head",
-    "tail",
-    "sleep",
-    "npm",
-    "npx",
-    "node",
-    "git",
-    "gh",
-    "rg",
-    "jq",
-    "sed",
-    "awk",
-];
 // Command execution timeout in milliseconds
 const DEFAULT_TIMEOUT = 1.5 * 60 * 1000; // 1.5 minutes
-// Ensure path is within base directory
-function isPathWithinBaseDir(requestedPath, baseDir) {
-    const normalizedRequestedPath = path.normalize(requestedPath);
-    const normalizedBaseDir = path.normalize(baseDir);
-    return normalizedRequestedPath.startsWith(normalizedBaseDir);
-}
-// Validate path arguments to ensure they're within the project
-function validatePaths(command, baseDir, cwd) {
-    // Simple tokenization - split on spaces but respect quotes
-    const tokens = [];
-    let current = "";
-    let inQuotes = false;
-    let quoteChar = "";
-    for (let i = 0; i < command.length; i++) {
-        const char = command[i];
-        if ((char === '"' || char === "'") && !inQuotes) {
-            inQuotes = true;
-            quoteChar = char;
-            current += char;
-        }
-        else if (char === quoteChar && inQuotes) {
-            inQuotes = false;
-            quoteChar = "";
-            current += char;
-        }
-        else if (char === " " && !inQuotes) {
-            if (current) {
-                tokens.push(current);
-                current = "";
-            }
-        }
-        else {
-            current += char;
-        }
-    }
-    if (current)
-        tokens.push(current);
-    // Check each token that looks like a path
-    for (let i = 1; i < tokens.length; i++) {
-        // Skip the command itself
-        const token = tokens[i];
-        if (!token)
-            continue;
-        // Remove quotes for path checking
-        const cleanToken = token.replace(/^['"]|['"]$/g, "");
-        // Skip if it's clearly not a path
-        if (cleanToken.startsWith("-") ||
-            cleanToken.includes("://") ||
-            !cleanToken.includes("/")) {
-            continue;
-        }
-        // Skip git commit messages and other special cases
-        const prevToken = tokens[i - 1]?.replace(/^['"]|['"]$/g, "");
-        if (prevToken === "-m" || prevToken === "--message") {
-            continue;
-        }
-        try {
-            const resolvedPath = path.resolve(cwd, cleanToken);
-            if (!isPathWithinBaseDir(resolvedPath, baseDir)) {
-                return {
-                    isValid: false,
-                    error: `Path '${cleanToken}' resolves outside the project directory (${resolvedPath}). All paths must be within ${baseDir}`,
-                };
-            }
-        }
-        catch (_e) { }
-    }
-    return { isValid: true };
-}
-// Initialize command validator with allowed commands
-const commandValidator = new CommandValidation(ALLOWED_COMMANDS);
-export const createBashTool = ({ baseDir, sendData, tokenCounter, terminal, autoAcceptAll, }) => {
-    let autoAcceptCommands = autoAcceptAll;
+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({
-            description: `Execute commands without a shell. Restrictions: no pipes (|), redirects (>, >>, <, <<), chaining (&&, ||, ;), background (&), or command substitution (\`...\`, $()). Pass a single allowed base command with quoted args. Compose by running multiple tool calls or using program flags (e.g., rg, jq). Commands execute only within the project directory. Always use absolute paths. Allowed commands: ${ALLOWED_COMMANDS.join(", ")}.`,
-            inputSchema: z.object({
-                command: z.string().describe("Full CLI command to execute."),
-                cwd: z
-                    .string()
-                    .nullable()
-                    .describe("Working directory (default: project root). Must be within the project directory."),
-                timeout: z
-                    .number()
-                    .nullable()
-                    .describe(`Command execution timeout in milliseconds. Default: ${DEFAULT_TIMEOUT}ms`),
-            }),
-            execute: async ({ command, cwd, timeout }, { toolCallId }) => {
-                // Guard against null cwd and timeout
-                const safeCwd = cwd == null ? baseDir : cwd;
-                const safeTimeout = timeout == null ? DEFAULT_TIMEOUT : timeout;
-                sendData?.({
+        toolDef: {
+            description: "Execute commands in a shell. Commands execute only within the project directory. Always use absolute paths.",
+            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: `Executing: ${chalk.cyan(command)} in ${chalk.cyan(safeCwd)}`,
-                });
-                // Validate working directory
-                if (!isPathWithinBaseDir(safeCwd, baseDir)) {
-                    const errorMsg = `Working directory must be within the project directory: ${baseDir}`;
-                    sendData?.({ event: "tool-error", id: toolCallId, data: errorMsg });
-                    return errorMsg;
-                }
-                // Validate command using improved validation
-                const commandValidation = commandValidator.isValid(command);
-                if (!commandValidation.isValid) {
-                    sendData?.({
+                    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: commandValidation.error ?? "Unknown error.",
-                    });
-                    return commandValidation.error ?? "Unknown error.";
+                        data: errorMsg,
+                    };
+                    yield errorMsg;
+                    return;
                 }
-                // Validate paths
-                const pathValidation = validatePaths(command, baseDir, safeCwd);
+                const pathValidation = validatePaths(command, allowedDirectories, resolvedCwd, allowedPaths);
                 if (!pathValidation.isValid) {
-                    sendData?.({
+                    yield {
+                        name: BashTool.name,
                         event: "tool-error",
                         id: toolCallId,
                         data: pathValidation.error ?? "Unknown error.",
-                    });
-                    return pathValidation.error ?? "Unknown error.";
-                }
-                // Prompt user for command execution approval (only in interactive mode)
-                if (terminal) {
-                    if (!autoAcceptCommands) {
-                        await new Promise((resolve) => setTimeout(resolve, 1000));
-                        terminal.lineBreak();
-                        terminal.writeln(`${chalk.blue.bold("●")} About to execute command: ${chalk.cyan(command)}`);
-                        terminal.writeln(`${chalk.gray("Working directory:")} ${safeCwd}`);
-                        terminal.lineBreak();
-                    }
-                    let userChoice;
-                    if (autoAcceptCommands) {
-                        terminal.writeln(chalk.green("✓ Auto-accepting command (all future commands will be accepted)"));
-                        userChoice = "accept";
-                    }
-                    else {
-                        userChoice = await select({
-                            message: "What would you like to do with this command?",
-                            choices: [
-                                { name: "Execute this command", value: "accept" },
-                                {
-                                    name: "Execute all future commands (including this)",
-                                    value: "accept-all",
-                                },
-                                { name: "Reject this command", value: "reject" },
-                            ],
-                            default: "accept",
-                        });
-                    }
-                    terminal.lineBreak();
-                    if (userChoice === "accept-all") {
-                        autoAcceptCommands = true;
-                        terminal.writeln(chalk.yellow("✓ Auto-accept mode enabled for all future commands"));
-                        terminal.lineBreak();
-                    }
-                    if (userChoice === "reject") {
-                        const reason = await input({ message: "Feedback: " });
-                        terminal.lineBreak();
-                        const rejectionMsg = `Command rejected by user. Reason: ${reason}`;
-                        sendData?.({
-                            event: "tool-completion",
-                            id: toolCallId,
-                            data: rejectionMsg,
-                        });
-                        return rejectionMsg;
-                    }
-                }
-                // Execute command
-                try {
-                    const result = await executeCommand(command, {
-                        cwd: safeCwd,
-                        timeout: safeTimeout,
-                        shell: false,
-                        throwOnError: false,
-                    });
-                    if (result.signal === "SIGTERM") {
-                        const timeoutMessage = `Command timed out after ${safeTimeout}ms. This might be because the command is waiting for input.`;
-                        sendData?.({
-                            event: "tool-error",
-                            id: toolCallId,
-                            data: timeoutMessage,
-                        });
-                        return timeoutMessage;
-                    }
-                    const formattedResult = format(result);
-                    sendData?.({
-                        event: "tool-update",
-                        id: toolCallId,
-                        data: {
-                            primary: "Result",
-                            secondary: formattedResult.split("\n").slice(-5),
-                        },
-                    });
-                    let tokenCount = 0;
-                    try {
-                        tokenCount = tokenCounter.count(formattedResult);
-                    }
-                    catch (tokenError) {
-                        console.error("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 ? formattedResult : maxTokenMessage;
-                    sendData?.({
-                        event: "tool-completion",
-                        id: toolCallId,
-                        data: tokenCount <= maxTokens
-                            ? "Command executed successfully."
-                            : `Output of command (${tokenCount} tokens) exceeds maximum allowed tokens (${maxTokens}).`,
-                    });
-                    return finalResult;
+                    };
+                    yield pathValidation.error ?? "Unknown error.";
+                    return;
                 }
-                catch (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;
+            }
+        },
     };
 };
-function format({ stdout, stderr, }) {
-    return `${stdout}\n${stderr}`;
-}

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;
-        type: "Typescript" | "JavaScript" | null;
-        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

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