@travisennis/acai 0.0.7 → 0.0.9

package/dist/terminal/string-width.js

@@ -1,25 +1,32 @@
 import { eastAsianWidth } from "./east-asian-width.js";
+import { getSegmenter } from "./segmenter.js";
 import stripAnsi from "./strip-ansi.js";
-const segmenter = new Intl.Segmenter();
+// Precompile regexes (these are already at module level, which is good)
 // Whole-cluster zero-width
 const zeroWidthClusterRegex = /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Mark}|\p{Surrogate})+$/v;
 // Pick the base scalar if the cluster starts with Prepend/Format/Marks
 const leadingNonPrintingRegex = /^[\p{Default_Ignorable_Code_Point}\p{Control}\p{Format}\p{Mark}\p{Surrogate}]+/v;
 // RGI emoji sequences
 const rgiEmojiRegex = /^\p{RGI_Emoji}$/v;
-function baseVisible(segment) {
-    return segment.replace(leadingNonPrintingRegex, "");
-}
-function isZeroWidthCluster(segment) {
-    return zeroWidthClusterRegex.test(segment);
-}
+// Halfwidth/Fullwidth range constants
+const HALFWIDTH_START = 0xff00;
+const HALFWIDTH_END = 0xffef;
 function trailingHalfwidthWidth(segment, eastAsianWidthOptions) {
+    const len = segment.length;
+    if (len <= 1) {
+        return 0;
+    }
     let extra = 0;
-    if (segment.length > 1) {
-        for (const char of segment.slice(1)) {
-            const codePoint = char.codePointAt(0);
-            if (codePoint !== undefined && char >= "\\uFF00" && char <= "\\uFFEF") {
-                extra += eastAsianWidth(codePoint, eastAsianWidthOptions);
+    // Use for loop with index for better performance
+    for (let i = 1; i < len; i++) {
+        const codePoint = segment.codePointAt(i);
+        if (codePoint !== undefined &&
+            codePoint >= HALFWIDTH_START &&
+            codePoint <= HALFWIDTH_END) {
+            extra += eastAsianWidth(codePoint, eastAsianWidthOptions);
+            // Skip next char if this was a surrogate pair
+            if (codePoint > 0xffff) {
+                i++;
             }
         }
     }
@@ -33,15 +40,17 @@ export default function stringWidth(input, options = {}) {
     let string = input;
     if (!countAnsiEscapeCodes) {
         string = stripAnsi(string);
-    }
-    if (string.length === 0) {
-        return 0;
+        if (string.length === 0) {
+            return 0;
+        }
     }
     let width = 0;
     const eastAsianWidthOptions = { ambiguousAsWide: !ambiguousIsNarrow };
+    // Use lazy segmenter initialization
+    const segmenter = getSegmenter();
     for (const { segment } of segmenter.segment(string)) {
-        // Zero-width / non-printing clusters
-        if (isZeroWidthCluster(segment)) {
+        // Zero-width clusters - inline test for hot path
+        if (zeroWidthClusterRegex.test(segment)) {
             continue;
         }
         // Emoji width logic
@@ -49,12 +58,22 @@ export default function stringWidth(input, options = {}) {
             width += 2;
             continue;
         }
-        // Everything else: EAW of the cluster’s first visible scalar
-        const codePoint = baseVisible(segment).codePointAt(0);
+        // Get first code point directly, avoiding intermediate string
+        const firstCodePoint = segment.codePointAt(0);
+        if (firstCodePoint === undefined) {
+            continue;
+        }
+        // Check if we need to strip leading non-printing characters
+        const hasLeadingNonPrinting = leadingNonPrintingRegex.test(segment);
+        const codePoint = hasLeadingNonPrinting
+            ? segment.replace(leadingNonPrintingRegex, "").codePointAt(0)
+            : firstCodePoint;
         if (codePoint !== undefined) {
             width += eastAsianWidth(codePoint, eastAsianWidthOptions);
-            // Add width for trailing Halfwidth and Fullwidth Forms (e.g., ﾞ, ﾟ, ｰ)
-            width += trailingHalfwidthWidth(segment, eastAsianWidthOptions);
+            // Only check trailing width if segment has multiple characters
+            if (segment.length > 1) {
+                width += trailingHalfwidthWidth(segment, eastAsianWidthOptions);
+            }
         }
     }
     return width;

package/dist/terminal/strip-ansi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"strip-ansi.d.ts","sourceRoot":"","sources":["../../source/terminal/strip-ansi.ts"],"names":[],"mappings":"AAkBA,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CASxD"}
+{"version":3,"file":"strip-ansi.d.ts","sourceRoot":"","sources":["../../source/terminal/strip-ansi.ts"],"names":[],"mappings":"AAUA,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAKxD"}

package/dist/terminal/strip-ansi.js

@@ -1,20 +1,14 @@
-// Inline from sindresorhus/strip-ansi v7.1.0
-const ansiRegex = ({ onlyFirst = false } = {}) => {
-    // Valid string terminator sequences are BEL, ESC\\, and 0x9c
-    const St = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
-    // OSC sequences only: ESC ] ... ST (non-greedy until the first ST)
-    const osc = `(?:\\u001B\\][\\s\\S]*?${St})`;
-    // CSI and related: ESC/C1, optional intermediates, optional params (supports ; and :) then final byte
-    const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
-    const pattern = `${osc}|${csi}`;
-    return new RegExp(pattern, onlyFirst ? undefined : "g");
-};
+// Pre-compile the regex outside the function to avoid recreation on every call
+const ANSI_REGEX = (() => {
+    const St = "(?:\u0007|\u001B\u005C|\u009C)";
+    // biome-ignore lint/suspicious/noUselessEscapeInString: later
+    const osc = `(?:\u001B\][\\s\\S]*?${St})`;
+    const csi = "[\u001B\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
+    return new RegExp(`${osc}|${csi}`, "g");
+})();
 export default function stripAnsi(string) {
     if (typeof string !== "string") {
         throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
     }
-    // Even though the regex is global, we don't need to reset the `.lastIndex`
-    // because unlike `.exec()` and `.test()`, `.replace()` does it automatically
-    // and doing it manually has a performance penalty.
-    return string.replace(ansiRegex(), "");
+    return string.replace(ANSI_REGEX, "");
 }

package/dist/tokens/tracker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tracker.d.ts","sourceRoot":"","sources":["../../source/tokens/tracker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,IAAI,CAAC;AAO7C,UAAU,kBAAkB;IAC1B,KAAK,EAAE,CAAC,kBAAkB,CAAC,CAAC;CAC7B;AAED,qBAAa,YAAa,SAAQ,YAAY,CAAC,kBAAkB,CAAC;IAChE,OAAO,CAAC,MAAM,CAAoB;IAElC,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,GAAG,SAAS;IAQ9D,aAAa,IAAI,kBAAkB;IAcnC,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB;IAoB9C,iBAAiB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAY3C,YAAY;CAOb"}
+{"version":3,"file":"tracker.d.ts","sourceRoot":"","sources":["../../source/tokens/tracker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,IAAI,CAAC;AAO7C,UAAU,kBAAkB;IAC1B,KAAK,EAAE,CAAC,kBAAkB,CAAC,CAAC;CAC7B;AAED,qBAAa,YAAa,SAAQ,YAAY,CAAC,kBAAkB,CAAC;IAChE,OAAO,CAAC,MAAM,CAAoB;IAElC,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,GAAG,SAAS;IAQ9D,aAAa,IAAI,kBAAkB;IA0CnC,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB;IA0C9C,iBAAiB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAY3C,YAAY;CAOb"}

package/dist/tokens/tracker.js

@@ -11,29 +11,71 @@ export class TokenTracker extends EventEmitter {
     }
     getTotalUsage() {
         return this.usages.reduce((acc, { usage }) => {
-            acc.inputTokens += isNumber(usage.inputTokens) ? usage.inputTokens : 0;
-            acc.outputTokens += isNumber(usage.outputTokens)
-                ? usage.outputTokens
-                : 0;
-            acc.totalTokens += isNumber(usage.totalTokens) ? usage.totalTokens : 0;
+            // After AI SDK v6 upgrade, all usage is in the unified format
+            const inputTokens = usage.inputTokens ?? 0;
+            const outputTokens = usage.outputTokens ?? 0;
+            const totalTokens = usage.totalTokens ?? inputTokens + outputTokens;
+            acc.inputTokens += isNumber(inputTokens) ? inputTokens : 0;
+            acc.outputTokens += isNumber(outputTokens) ? outputTokens : 0;
+            acc.totalTokens += isNumber(totalTokens) ? totalTokens : 0;
+            // Input token details
+            acc.inputTokenDetails.noCacheTokens +=
+                usage.inputTokenDetails?.noCacheTokens ?? 0;
+            acc.inputTokenDetails.cacheReadTokens +=
+                usage.inputTokenDetails?.cacheReadTokens ?? 0;
+            acc.inputTokenDetails.cacheWriteTokens +=
+                usage.inputTokenDetails?.cacheWriteTokens ?? 0;
+            // Output token details
+            const v3OutputDetails = usage.outputTokenDetails;
+            acc.outputTokenDetails.textTokens += v3OutputDetails?.textTokens ?? 0;
+            acc.outputTokenDetails.reasoningTokens +=
+                v3OutputDetails?.reasoningTokens ?? 0;
             return acc;
-        }, { inputTokens: 0, outputTokens: 0, totalTokens: 0 });
+        }, {
+            inputTokens: 0,
+            outputTokens: 0,
+            totalTokens: 0,
+            inputTokenDetails: {
+                noCacheTokens: 0,
+                cacheReadTokens: 0,
+                cacheWriteTokens: 0,
+            },
+            outputTokenDetails: { textTokens: 0, reasoningTokens: 0 },
+        });
     }
     getUsageByApp(app) {
         return this.usages
             .filter(({ tool }) => tool === app)
             .reduce((acc, { usage }) => {
-            acc.inputTokens += isNumber(usage.inputTokens)
-                ? usage.inputTokens
-                : 0;
-            acc.outputTokens += isNumber(usage.outputTokens)
-                ? usage.outputTokens
-                : 0;
-            acc.totalTokens += isNumber(usage.totalTokens)
-                ? usage.totalTokens
-                : 0;
+            const inputTokens = usage.inputTokens ?? 0;
+            const outputTokens = usage.outputTokens ?? 0;
+            const totalTokens = usage.totalTokens ?? inputTokens + outputTokens;
+            acc.inputTokens += isNumber(inputTokens) ? inputTokens : 0;
+            acc.outputTokens += isNumber(outputTokens) ? outputTokens : 0;
+            acc.totalTokens += isNumber(totalTokens) ? totalTokens : 0;
+            const v3InputDetails = usage.inputTokenDetails;
+            acc.inputTokenDetails.cacheReadTokens +=
+                v3InputDetails?.cacheReadTokens ?? 0;
+            acc.inputTokenDetails.noCacheTokens +=
+                v3InputDetails?.noCacheTokens ?? 0;
+            acc.inputTokenDetails.cacheWriteTokens +=
+                v3InputDetails?.cacheWriteTokens ?? 0;
+            const v3OutputDetails = usage.outputTokenDetails;
+            acc.outputTokenDetails.textTokens += v3OutputDetails?.textTokens ?? 0;
+            acc.outputTokenDetails.reasoningTokens +=
+                v3OutputDetails?.reasoningTokens ?? 0;
             return acc;
-        }, { inputTokens: 0, outputTokens: 0, totalTokens: 0 });
+        }, {
+            inputTokens: 0,
+            outputTokens: 0,
+            totalTokens: 0,
+            inputTokenDetails: {
+                noCacheTokens: 0,
+                cacheReadTokens: 0,
+                cacheWriteTokens: 0,
+            },
+            outputTokenDetails: { textTokens: 0, reasoningTokens: 0 },
+        });
     }
     getUsageBreakdown() {
         return this.usages.reduce((acc, { tool, usage }) => {

package/dist/tools/bash.d.ts

@@ -1,32 +1,30 @@
-import type { ToolCallOptions } from "ai";
 import { z } from "zod";
-import type { TokenCounter } from "../tokens/counter.ts";
-import type { ToolResult } from "./types.ts";
+import type { ToolExecutionOptions } from "./types.ts";
 export declare const BashTool: {
-    name: "bash";
+    name: "Bash";
 };
 declare const inputSchema: z.ZodObject<{
     command: z.ZodString;
-    cwd: z.ZodNullable<z.ZodString>;
-    timeout: z.ZodNullable<z.ZodCoercedNumber<unknown>>;
+    cwd: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodString>>;
+    timeout: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
     background: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 type BashInputSchema = z.infer<typeof inputSchema>;
-export declare const createBashTool: ({ baseDir, allowedDirs, tokenCounter, }: {
+export declare const createBashTool: ({ baseDir, allowedDirs, }: {
     baseDir: string;
     allowedDirs?: string[];
-    tokenCounter: TokenCounter;
 }) => Promise<{
     toolDef: {
         description: string;
         inputSchema: z.ZodObject<{
             command: z.ZodString;
-            cwd: z.ZodNullable<z.ZodString>;
-            timeout: z.ZodNullable<z.ZodCoercedNumber<unknown>>;
+            cwd: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodString>>;
+            timeout: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
             background: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>;
     };
-    execute({ command, cwd, timeout, background }: BashInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
+    display({ command }: BashInputSchema): string;
+    execute({ command, cwd, timeout, background }: BashInputSchema, { abortSignal }: ToolExecutionOptions): Promise<string>;
 }>;
 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":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAMzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AAYF,QAAA,MAAM,WAAW;;;;;iBAoBf,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;;;;;;;;;;mDAS4C,eAAe,+BACzB,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EAqJhC,CAAC"}
+{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../source/tools/bash.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAqCvD,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AAYF,QAAA,MAAM,WAAW;;;;;iBAkBf,CAAC;AAEH,KAAK,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,eAAO,MAAM,cAAc,GAAU,2BAGlC;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;;;;;;;;;;yBAQwB,eAAe;mDAIK,eAAe,mBACrC,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EAgGrB,CAAC"}

package/dist/tools/bash.js

@@ -3,10 +3,40 @@ import { z } from "zod";
 import { initExecutionEnvironment } from "../execution/index.js";
 import { logger } from "../logger.js";
 import style from "../terminal/style.js";
-import { manageTokenLimit, TokenLimitExceededError, } from "../tokens/threshold.js";
-import { isMutatingCommand, resolveCwd, validatePaths } from "../utils/bash.js";
+import { resolveCwd, validatePaths } from "../utils/bash.js";
+import { convertNullString } from "../utils/zod.js";
+/**
+ * Detects git commit commands with multi-line -m messages that will fail in shell.
+ * Returns an error message if detected, or null if the command is safe.
+ */
+function detectMultilineGitCommit(command) {
+    const trimmed = command.trim();
+    // Check if it's a git commit command
+    if (!trimmed.startsWith("git commit") && !trimmed.startsWith("git ")) {
+        return null;
+    }
+    // Look for -m flag with a message containing newlines
+    // Match patterns like: git commit -m "message\nwith\nnewlines"
+    // Using [\s\S] instead of [^] to match any character including newlines
+    const messageMatch = trimmed.match(/-m\s+["']([\s\S]*?)["']/);
+    if (!messageMatch) {
+        return null;
+    }
+    const message = messageMatch[1];
+    if (message.includes("\n")) {
+        return `Multi-line commit messages with -m flag cause shell parsing errors. Instead:
+1. Write the commit message to a temporary file (e.g., /tmp/acai/commit-msg.txt)
+2. Use: git commit -F /tmp/acai/commit-msg.txt
+3. Optionally remove the temp file after committing
+
+Example:
+  First, create the file with the commit message using the write_file tool.
+  Then run: git commit -F /tmp/acai/commit-msg.txt`;
+    }
+    return null;
+}
 export const BashTool = {
-    name: "bash",
+    name: "Bash",
 };
 const installedTools = getInstalledTools();
 const toolDescription = `Execute commands in a shell. Commands can execute only within the allowed directories. Always use absolute paths.
@@ -18,19 +48,17 @@ const DEFAULT_TIMEOUT = 1.5 * 60 * 1000; // 1.5 minutes
 const inputSchema = z.object({
     command: z.string().describe("Full CLI command to execute."),
     cwd: z
-        .string()
-        .nullable()
+        .preprocess((val) => convertNullString(val), 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()
+    timeout: z
+        .preprocess((val) => convertNullString(val), 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, }) => {
+export const createBashTool = async ({ baseDir, allowedDirs, }) => {
     const execEnv = await initExecutionEnvironment();
     const allowedDirectories = allowedDirs ?? [baseDir];
     return {
@@ -38,123 +66,76 @@ export const createBashTool = async ({ baseDir, allowedDirs, tokenCounter, }) =>
             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: 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();
-                    }
-                    // 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();
-                    }
-                    // 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,
-                        preserveOutputOnError: true,
-                        captureStderr: true,
-                        throwOnError: false,
-                    });
-                    try {
-                        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 (error) {
-                        if (error instanceof TokenLimitExceededError) {
-                            yield {
-                                name: BashTool.name,
-                                event: "tool-error",
-                                id: toolCallId,
-                                data: error.message,
-                            };
-                            yield error.message;
-                            return;
-                        }
-                        throw error;
-                    }
+        display({ command }) {
+            return `\n> ${style.cyan(command)}`;
+        },
+        async execute({ command, cwd, timeout, background }, { abortSignal }) {
+            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;
+            const pathValidation = validatePaths(command, allowedDirectories, resolvedCwd);
+            if (!pathValidation.isValid) {
+                throw new Error(pathValidation.error ?? "Unknown error.");
+            }
+            // Check for multi-line git commit messages that will fail
+            const multilineError = detectMultilineGitCommit(command);
+            if (multilineError) {
+                throw new Error(multilineError);
+            }
+            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();
                 }
+                // 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}`);
+                    },
+                });
+                return `Background process started with PID: ${backgroundProcess.pid}`;
+            }
+            // 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();
             }
-            catch (error) {
-                logger.error(error, "Bash Tool Error:");
-                yield {
-                    name: BashTool.name,
-                    event: "tool-error",
-                    id: toolCallId,
-                    data: error.message,
-                };
-                yield error.message;
+            // 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,
+                preserveOutputOnError: true,
+                captureStderr: true,
+                throwOnError: false,
+            });
+            if (exitCode !== 0) {
+                throw new Error(output);
             }
+            return output;
         },
     };
 };

package/dist/tools/directory-tree.d.ts

@@ -1,26 +1,28 @@
-import type { ToolCallOptions } from "ai";
 import { z } from "zod";
-import type { TokenCounter } from "../tokens/counter.ts";
-import type { ToolResult } from "./types.ts";
+import type { ToolExecutionOptions } from "./types.ts";
 export declare const DirectoryTreeTool: {
-    name: "directoryTree";
+    name: "DirectoryTree";
 };
 declare const inputSchema: z.ZodObject<{
     path: z.ZodString;
+    maxResults: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+    maxDepth: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
 }, z.core.$strip>;
 type DirectoryTreeInputSchema = z.infer<typeof inputSchema>;
-export declare const createDirectoryTreeTool: ({ workingDir, allowedDirs, tokenCounter, }: {
+export declare const createDirectoryTreeTool: ({ workingDir, allowedDirs, }: {
     workingDir: string;
     allowedDirs?: string[];
-    tokenCounter: TokenCounter;
 }) => Promise<{
     toolDef: {
         description: string;
         inputSchema: z.ZodObject<{
             path: z.ZodString;
+            maxResults: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+            maxDepth: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         }, z.core.$strip>;
     };
-    execute({ path }: DirectoryTreeInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
+    display({ path, maxDepth, maxResults }: DirectoryTreeInputSchema): string;
+    execute({ path, maxResults, maxDepth }: DirectoryTreeInputSchema, { abortSignal }: ToolExecutionOptions): Promise<string>;
 }>;
 export {};
 //# sourceMappingURL=directory-tree.d.ts.map

package/dist/tools/directory-tree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"directory-tree.d.ts","sourceRoot":"","sources":["../../source/tools/directory-tree.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAOzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,iBAAiB;;CAE7B,CAAC;AAEF,QAAA,MAAM,WAAW;;iBAEf,CAAC;AAEH,KAAK,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAE5D,eAAO,MAAM,uBAAuB,GAAU,4CAI3C;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;;;;sBASe,wBAAwB,+BACL,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EAyEhC,CAAC"}
+{"version":3,"file":"directory-tree.d.ts","sourceRoot":"","sources":["../../source/tools/directory-tree.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAKvD,eAAO,MAAM,iBAAiB;;CAE7B,CAAC;AAEF,QAAA,MAAM,WAAW;;;;iBAYf,CAAC;AAEH,KAAK,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAE5D,eAAO,MAAM,uBAAuB,GAAU,8BAG3C;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;;;;;;;;;4CAO2C,wBAAwB;4CAW9B,wBAAwB,mBACvC,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EAyBrB,CAAC"}