@travisennis/acai 0.0.5 → 0.0.6

package/dist/tools/move-file.js

@@ -1,51 +1,58 @@
 import fs from "node:fs/promises";
-import { tool } from "ai";
 import { z } from "zod";
 import style from "../terminal/style.js";
 import { joinWorkingDir, validatePath } from "./filesystem-utils.js";
 export const MoveFileTool = {
     name: "moveFile",
 };
-export const createMoveFileTool = async ({ workingDir, sendData, }) => {
-    const allowedDirectory = workingDir;
+const inputSchema = z.object({
+    source: z.string(),
+    destination: z.string(),
+});
+export const createMoveFileTool = async ({ workingDir, allowedDirs, }) => {
+    const allowedDirectory = allowedDirs ?? [workingDir];
     return {
-        [MoveFileTool.name]: tool({
+        toolDef: {
             description: "Move or rename files and directories. Can move files between directories " +
                 "and rename them in a single operation. If the destination exists, the " +
                 "operation will fail. Works across different directories and can be used " +
                 "for simple renaming within the same directory. Both source and destination must be within allowed directories.",
-            inputSchema: z.object({
-                source: z.string(),
-                destination: z.string(),
-            }),
-            execute: async ({ source, destination }, { toolCallId, abortSignal }) => {
-                // Check if execution has been aborted
+            inputSchema,
+        },
+        async *execute({ source, destination }, { toolCallId, abortSignal }) {
+            try {
                 if (abortSignal?.aborted) {
                     throw new Error("File move aborted");
                 }
-                try {
-                    sendData?.({
-                        id: toolCallId,
-                        event: "tool-init",
-                        data: `Moving file from ${style.cyan(source)} to ${style.cyan(destination)}`,
-                    });
-                    const validSourcePath = await validatePath(joinWorkingDir(source, workingDir), allowedDirectory, { abortSignal });
-                    const validDestPath = await validatePath(joinWorkingDir(destination, workingDir), allowedDirectory, { requireExistence: false, abortSignal });
-                    if (abortSignal?.aborted) {
-                        throw new Error("File move aborted before file operation");
-                    }
-                    await fs.rename(validSourcePath, validDestPath);
-                    sendData?.({
-                        id: toolCallId,
-                        event: "tool-completion",
-                        data: "Done",
-                    });
-                    return `Successfully moved ${source} to ${destination}`;
-                }
-                catch (error) {
-                    return `Failed to move file: ${error.message}`;
+                yield {
+                    name: MoveFileTool.name,
+                    id: toolCallId,
+                    event: "tool-init",
+                    data: `${style.cyan(source)} => ${style.cyan(destination)}`,
+                };
+                const validSourcePath = await validatePath(joinWorkingDir(source, workingDir), allowedDirectory, { abortSignal });
+                const validDestPath = await validatePath(joinWorkingDir(destination, workingDir), allowedDirectory, { requireExistence: false, abortSignal });
+                if (abortSignal?.aborted) {
+                    throw new Error("File move aborted before file operation");
                 }
-            },
-        }),
+                await fs.rename(validSourcePath, validDestPath);
+                yield {
+                    name: MoveFileTool.name,
+                    id: toolCallId,
+                    event: "tool-completion",
+                    data: "File moved",
+                };
+                yield `Successfully moved ${source} to ${destination}`;
+            }
+            catch (error) {
+                yield {
+                    name: MoveFileTool.name,
+                    event: "tool-error",
+                    id: toolCallId,
+                    data: error.message,
+                };
+                yield `Failed to move file: ${error.message}`;
+            }
+        },
     };
 };

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

@@ -1,18 +1,56 @@
+import type { ToolCallOptions } from "ai";
+import { z } from "zod";
 import type { TokenCounter } from "../tokens/counter.ts";
-import type { SendData } from "./types.ts";
+import type { ToolResult } from "./types.ts";
 export declare const ReadFileTool: {
     name: "readFile";
 };
-export declare const createReadFileTool: ({ workingDir, sendData, tokenCounter, }: {
+declare const inputSchema: z.ZodObject<{
+    path: z.ZodString;
+    encoding: z.ZodEnum<{
+        utf8: "utf8";
+        ascii: "ascii";
+        "utf-8": "utf-8";
+        utf16le: "utf16le";
+        ucs2: "ucs2";
+        "ucs-2": "ucs-2";
+        base64: "base64";
+        base64url: "base64url";
+        latin1: "latin1";
+        binary: "binary";
+        hex: "hex";
+    }>;
+    startLine: z.ZodNullable<z.ZodCoercedNumber<unknown>>;
+    lineCount: z.ZodNullable<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+type ReadFileInputSchema = z.infer<typeof inputSchema>;
+export declare const createReadFileTool: ({ workingDir, allowedDirs, tokenCounter, }: {
     workingDir: string;
-    sendData?: SendData;
+    allowedDirs?: string[];
     tokenCounter: TokenCounter;
 }) => Promise<{
-    readFile: import("ai").Tool<{
-        path: string;
-        encoding: "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex";
-        startLine: number | null;
-        lineCount: number | null;
-    }, string>;
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            path: z.ZodString;
+            encoding: z.ZodEnum<{
+                utf8: "utf8";
+                ascii: "ascii";
+                "utf-8": "utf-8";
+                utf16le: "utf16le";
+                ucs2: "ucs2";
+                "ucs-2": "ucs-2";
+                base64: "base64";
+                base64url: "base64url";
+                latin1: "latin1";
+                binary: "binary";
+                hex: "hex";
+            }>;
+            startLine: z.ZodNullable<z.ZodCoercedNumber<unknown>>;
+            lineCount: z.ZodNullable<z.ZodCoercedNumber<unknown>>;
+        }, z.core.$strip>;
+    };
+    execute({ path: providedPath, encoding, startLine, lineCount, }: ReadFileInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
 }>;
+export {};
 //# sourceMappingURL=read-file.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"read-file.d.ts","sourceRoot":"","sources":["../../source/tools/read-file.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,yCAItC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;;;;EAkHA,CAAC"}
+{"version":3,"file":"read-file.d.ts","sourceRoot":"","sources":["../../source/tools/read-file.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;AAGzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAG7C,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;iBAef,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEvD,eAAO,MAAM,kBAAkB,GAAU,4CAItC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;;;;;;;;;;;;;;;;;;;qEAiBQ,mBAAmB,+BACO,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EAoFhC,CAAC"}

package/dist/tools/read-file.js

@@ -1,93 +1,98 @@
 import fs from "node:fs/promises";
 import { isNumber } from "@travisennis/stdlib/typeguards";
-import { tool } from "ai";
 import { z } from "zod";
-import { config } from "../config.js";
 import style from "../terminal/style.js";
+import { manageTokenLimit } from "../tokens/threshold.js";
 import { joinWorkingDir, validatePath } from "./filesystem-utils.js";
 import { fileEncodingSchema } from "./types.js";
 export const ReadFileTool = {
     name: "readFile",
 };
-export const createReadFileTool = async ({ workingDir, sendData, tokenCounter, }) => {
-    const allowedDirectory = workingDir;
+const inputSchema = z.object({
+    path: z.string().describe("Absolute path to file to read"),
+    encoding: fileEncodingSchema.describe('Encoding format for reading the file. Use "utf-8" as default for text files'),
+    startLine: z.coerce
+        .number()
+        .nullable()
+        .describe("1-based line number to start reading from. Pass null to start at beginning of file"),
+    lineCount: z.coerce
+        .number()
+        .nullable()
+        .describe("Maximum number of lines to read. Pass null to get all lines."),
+});
+export const createReadFileTool = async ({ workingDir, allowedDirs, tokenCounter, }) => {
+    const allowedDirectory = allowedDirs ?? [workingDir];
     return {
-        [ReadFileTool.name]: tool({
+        toolDef: {
             description: "Read the complete contents of a file from the file system unless startLine and lineCount are given to read a file selection. " +
                 "Handles various text encodings and provides detailed error messages " +
                 "if the file cannot be read. Use this tool when you need to examine " +
                 "the contents of a single file. Only works within allowed directories.",
-            inputSchema: z.object({
-                path: z.string().describe("Absolute path to file to read"),
-                encoding: fileEncodingSchema.describe('Encoding format for reading the file. Use "utf-8" as default for text files'),
-                startLine: z.coerce
-                    .number()
-                    .nullable()
-                    .describe("1-based line number to start reading from. Pass null to start at beginning of file"),
-                lineCount: z.coerce
-                    .number()
-                    .nullable()
-                    .describe("Maximum number of lines to read. Pass null to get all lines."),
-            }),
-            execute: async ({ path: providedPath, encoding, startLine, lineCount, }, { toolCallId, abortSignal }) => {
+            inputSchema,
+        },
+        async *execute({ path: providedPath, encoding, startLine, lineCount, }, { toolCallId, abortSignal }) {
+            try {
                 // Check if execution has been aborted
                 if (abortSignal?.aborted) {
                     throw new Error("File reading aborted");
                 }
-                sendData?.({
+                yield {
+                    name: ReadFileTool.name,
                     id: toolCallId,
                     event: "tool-init",
-                    data: `Reading file: ${style.cyan(providedPath)}${startLine ? style.cyan(`:${startLine}`) : ""}${lineCount ? style.cyan(`:${lineCount}`) : ""}`,
-                });
-                try {
-                    const filePath = await validatePath(joinWorkingDir(providedPath, workingDir), allowedDirectory, { abortSignal });
-                    if (abortSignal?.aborted) {
-                        throw new Error("File reading aborted before file read");
-                    }
-                    let file = await fs.readFile(filePath, { encoding });
-                    // Apply line-based selection if requested
-                    if (isNumber(startLine) || isNumber(lineCount)) {
-                        const lines = file.split("\n");
-                        const totalLines = lines.length;
-                        const startIndex = (startLine ?? 1) - 1; // Default to start of file if only lineCount is given
-                        const count = lineCount ?? totalLines - startIndex; // Default to read all lines from start if only startLine is given
-                        if (startIndex < 0 || startIndex >= totalLines) {
-                            return `startLine ${startLine} is out of bounds for file with ${totalLines} lines.`;
-                        }
-                        const endIndex = Math.min(startIndex + count, totalLines);
-                        file = lines.slice(startIndex, endIndex).join("\n");
-                    }
-                    let tokenCount = 0;
-                    try {
-                        // Only calculate tokens for non-image files and if encoding is text-based
-                        if (encoding.startsWith("utf")) {
-                            tokenCount = tokenCounter.count(file);
-                        }
-                    }
-                    catch (tokenError) {
-                        console.error("Error calculating token count:", tokenError);
-                        // Log or handle error, but don't block file return
-                    }
-                    const maxTokens = (await config.readProjectConfig()).tools.maxTokens;
-                    // Adjust max token check message if line selection was used
-                    const maxTokenMessage = isNumber(startLine) || isNumber(lineCount)
-                        ? `Selected file content (${tokenCount} tokens) exceeds maximum allowed tokens (${maxTokens}). Consider adjusting startLine/lineCount or using grepFiles.`
-                        : `File content (${tokenCount} tokens) exceeds maximum allowed tokens (${maxTokens}). Please use startLine and lineCount parameters to read specific portions of the file, or using grepFiles to search for specific content.`;
-                    const result = tokenCount <= maxTokens ? file : maxTokenMessage;
-                    sendData?.({
-                        id: toolCallId,
-                        event: "tool-completion",
-                        // Include token count only if calculated (i.e., for text files)
-                        data: tokenCount <= maxTokens
-                            ? `File read successfully ${tokenCount > 0 ? ` (${tokenCount} tokens)` : ""}`
-                            : result,
-                    });
-                    return result;
+                    data: `${style.cyan(providedPath)}${startLine ? style.cyan(`:${startLine}`) : ""}${lineCount ? style.cyan(`:${lineCount}`) : ""}`,
+                };
+                const filePath = await validatePath(joinWorkingDir(providedPath, workingDir), allowedDirectory, { abortSignal });
+                if (abortSignal?.aborted) {
+                    throw new Error("File reading aborted before file read");
                 }
-                catch (error) {
-                    return `Failed to read file: ${error.message}`;
+                let file = await fs.readFile(filePath, { encoding });
+                // Apply line-based selection if requested
+                if (isNumber(startLine) || isNumber(lineCount)) {
+                    const lines = file.split("\n");
+                    const totalLines = lines.length;
+                    const startIndex = (startLine ?? 1) - 1; // Default to start of file if only lineCount is given
+                    const count = lineCount ?? totalLines - startIndex; // Default to read all lines from start if only startLine is given
+                    if (startIndex < 0 || startIndex >= totalLines) {
+                        const errorMsg = `startLine ${startLine} is out of bounds for file with ${totalLines} lines.`;
+                        yield {
+                            name: ReadFileTool.name,
+                            event: "tool-error",
+                            id: toolCallId,
+                            data: errorMsg,
+                        };
+                        yield errorMsg;
+                        return;
+                    }
+                    const endIndex = Math.min(startIndex + count, totalLines);
+                    file = lines.slice(startIndex, endIndex).join("\n");
                 }
-            },
-        }),
+                const result = await manageTokenLimit(file, tokenCounter, "ReadFile", isNumber(startLine) || isNumber(lineCount)
+                    ? "Consider adjusting startLine/lineCount or using grepFiles"
+                    : "Use startLine and lineCount parameters to read specific portions, or use grepFiles for targeted access", encoding);
+                // Calculate line count for the returned content
+                const linesRead = result.content.split("\n").length;
+                yield {
+                    name: ReadFileTool.name,
+                    id: toolCallId,
+                    event: "tool-completion",
+                    // Include success, line count, and token count
+                    data: !result.truncated
+                        ? `Read ${linesRead} lines (${result.tokenCount} tokens)`
+                        : result.content,
+                };
+                yield result.content;
+            }
+            catch (error) {
+                const errorMsg = `${error.message}`;
+                yield {
+                    name: ReadFileTool.name,
+                    event: "tool-error",
+                    id: toolCallId,
+                    data: errorMsg,
+                };
+                yield errorMsg;
+            }
+        },
     };
 };

package/dist/tools/read-multiple-files.d.ts

@@ -1,15 +1,26 @@
+import type { ToolCallOptions } from "ai";
+import { z } from "zod";
 import type { TokenCounter } from "../tokens/counter.ts";
-import type { SendData } from "./types.ts";
+import type { ToolResult } from "./types.ts";
 export declare const ReadMultipleFilesTool: {
     name: "readMultipleFiles";
 };
-export declare const createReadMultipleFilesTool: ({ workingDir, sendData, tokenCounter, }: {
+declare const inputSchema: z.ZodObject<{
+    paths: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type ReadMultipleFilesInputSchema = z.infer<typeof inputSchema>;
+export declare const createReadMultipleFilesTool: ({ workingDir, allowedDirs, tokenCounter, }: {
     workingDir: string;
-    sendData?: SendData;
+    allowedDirs?: string[];
     tokenCounter: TokenCounter;
 }) => Promise<{
-    readMultipleFiles: import("ai").Tool<{
-        paths: string[];
-    }, string>;
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            paths: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    execute({ paths }: ReadMultipleFilesInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
 }>;
+export {};
 //# sourceMappingURL=read-multiple-files.d.ts.map

package/dist/tools/read-multiple-files.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"read-multiple-files.d.ts","sourceRoot":"","sources":["../../source/tools/read-multiple-files.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,qBAAqB;;CAEjC,CAAC;AAEF,eAAO,MAAM,2BAA2B,GAAU,yCAI/C;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;EAmGA,CAAC"}
+{"version":3,"file":"read-multiple-files.d.ts","sourceRoot":"","sources":["../../source/tools/read-multiple-files.ts"],"names":[],"mappings":"AACA,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;AAGzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,qBAAqB;;CAEjC,CAAC;AAEF,QAAA,MAAM,WAAW;;iBAEf,CAAC;AAEH,KAAK,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEhE,eAAO,MAAM,2BAA2B,GAAU,4CAI/C;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;;;;uBAcgB,4BAA4B,+BACV,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EAwIhC,CAAC"}

package/dist/tools/read-multiple-files.js

@@ -1,91 +1,121 @@
 import { readFile } from "node:fs/promises";
-import { tool } from "ai";
 import { z } from "zod";
-import { config } from "../config.js";
 import { formatFile } from "../formatting.js";
 import style from "../terminal/style.js";
+import { manageTokenLimit } from "../tokens/threshold.js";
 import { joinWorkingDir, validatePath } from "./filesystem-utils.js";
 export const ReadMultipleFilesTool = {
     name: "readMultipleFiles",
 };
-export const createReadMultipleFilesTool = async ({ workingDir, sendData, tokenCounter, }) => {
-    const allowedDirectory = workingDir;
+const inputSchema = z.object({
+    paths: z.array(z.string()),
+});
+export const createReadMultipleFilesTool = async ({ workingDir, allowedDirs, tokenCounter, }) => {
+    const allowedDirectory = allowedDirs ?? [workingDir];
     return {
-        [ReadMultipleFilesTool.name]: tool({
+        toolDef: {
             description: "Read the contents of multiple files simultaneously. This is more " +
                 "efficient than reading files one by one when you need to analyze " +
                 "or compare multiple files. Each file's content is returned with its " +
                 "path as a reference. Failed reads for individual files won't stop " +
                 "the entire operation. Only works within allowed directories.",
-            inputSchema: z.object({
-                paths: z.array(z.string()),
-            }),
-            execute: async ({ paths }, { toolCallId, abortSignal }) => {
+            inputSchema,
+        },
+        async *execute({ paths }, { toolCallId, abortSignal }) {
+            try {
                 // Check if execution has been aborted
                 if (abortSignal?.aborted) {
                     throw new Error("Multiple file reading aborted");
                 }
-                sendData?.({
+                yield {
+                    name: ReadMultipleFilesTool.name,
                     id: toolCallId,
                     event: "tool-init",
-                    data: `Reading files: ${paths.map((p) => style.cyan(p)).join(", ")}`,
-                });
+                    data: `${paths.map((p) => style.cyan(p)).join(", ")}`,
+                };
                 if (abortSignal?.aborted) {
                     throw new Error("Multiple file reading aborted before reading files");
                 }
-                const maxTokens = (await config.readProjectConfig()).tools.maxTokens;
                 const results = await Promise.all(paths.map(async (filePath) => {
                     if (abortSignal?.aborted) {
                         throw new Error("Multiple file reading aborted during file processing");
                     }
                     const fileResult = await validateAndReadFile(filePath, workingDir, allowedDirectory);
-                    return countTokensAndCheckLimit(fileResult, tokenCounter, maxTokens);
+                    return fileResult;
                 }));
+                const processedResults = await Promise.all(results.map(async (result) => {
+                    if (result.error) {
+                        return {
+                            path: result.path,
+                            content: `${result.path}: Error - ${result.error}`,
+                            tokenCount: 0,
+                            error: result.error,
+                            truncated: false,
+                        };
+                    }
+                    // Apply token limit check to each file
+                    const managedResult = await manageTokenLimit(result.content ?? "", tokenCounter, "ReadMultipleFiles", "Use readFile with startLine/lineCount or grepFiles for targeted access");
+                    return {
+                        path: result.path,
+                        content: formatFile(result.path, managedResult.content, "markdown"),
+                        tokenCount: managedResult.tokenCount,
+                        error: null,
+                        truncated: managedResult.truncated,
+                    };
+                }));
+                const formattedResults = processedResults.map((r) => r.content);
+                const finalResult = await manageTokenLimit(formattedResults.join("\n---\n"), tokenCounter, "ReadMultipleFiles", "Reduce number of files or use more specific paths");
+                // Aggregate results with detailed breakdown
                 let totalTokens = 0;
                 let filesReadCount = 0;
                 let filesExceededLimitCount = 0;
                 let filesErrorCount = 0;
-                const formattedResults = results.map((result) => {
-                    if (result.error) {
+                for (const processedResult of processedResults) {
+                    if (processedResult.error) {
                         filesErrorCount++;
-                        return `${result.path}: Error - ${result.error}`;
                     }
-                    // Check if tokenCount is > 0, meaning it wasn't skipped
-                    if (result.tokenCount > 0) {
-                        filesReadCount++;
-                    }
-                    else if (result.content?.includes("exceeds maximum allowed tokens")) {
+                    else if (processedResult.truncated) {
                         filesExceededLimitCount++;
+                        totalTokens += processedResult.tokenCount;
                     }
-                    totalTokens += result.tokenCount; // Add the token count (will be 0 for skipped files)
-                    // Return content (or max token message)
-                    return formatFile(result.path, result.content ?? "", "markdown");
-                });
-                let completionMessage;
-                if (filesReadCount === paths.length) {
-                    completionMessage = `Read ${paths.length} files successfully (${totalTokens} total tokens).`;
-                }
-                else {
-                    const parts = [];
-                    if (filesReadCount > 0) {
-                        parts.push(`Read ${filesReadCount} files successfully (${totalTokens} total tokens)`);
-                    }
-                    if (filesExceededLimitCount > 0) {
-                        parts.push(`${filesExceededLimitCount} files exceeded token limit and were skipped`);
-                    }
-                    if (filesErrorCount > 0) {
-                        parts.push(`${filesErrorCount} files could not be read`);
+                    else {
+                        filesReadCount++;
+                        totalTokens += processedResult.tokenCount;
                     }
-                    completionMessage = `${parts.join(", ")}.`;
                 }
-                sendData?.({
+                const parts = [];
+                if (filesReadCount > 0) {
+                    parts.push(`Read ${filesReadCount} files successfully (${totalTokens} total tokens)`);
+                }
+                if (filesExceededLimitCount > 0) {
+                    parts.push(`${filesExceededLimitCount} files exceeded token limit`);
+                }
+                if (filesErrorCount > 0) {
+                    parts.push(`${filesErrorCount} files could not be read`);
+                }
+                if (finalResult.truncated) {
+                    parts.push(`Combined output exceeded token limit. ${finalResult.content}`);
+                }
+                const completionMessage = `${parts.join(", ")}.`;
+                yield {
+                    name: ReadMultipleFilesTool.name,
                     id: toolCallId,
                     event: "tool-completion",
                     data: completionMessage,
-                });
-                return formattedResults.join("\n---\n");
-            },
-        }),
+                };
+                yield finalResult.content;
+            }
+            catch (error) {
+                const errorMsg = error.message;
+                yield {
+                    name: ReadMultipleFilesTool.name,
+                    id: toolCallId,
+                    event: "tool-error",
+                    data: errorMsg,
+                };
+                yield errorMsg;
+            }
+        },
     };
 };
 async function validateAndReadFile(filePath, workingDir, allowedDirectory) {
@@ -107,30 +137,3 @@ async function validateAndReadFile(filePath, workingDir, allowedDirectory) {
         };
     }
 }
-async function countTokensAndCheckLimit(fileResult, tokenCounter, maxTokens) {
-    if (fileResult.error || fileResult.content === null) {
-        return {
-            path: fileResult.path,
-            content: null,
-            tokenCount: 0,
-            error: fileResult.error,
-        };
-    }
-    let tokenCount = 0;
-    try {
-        tokenCount = tokenCounter.count(fileResult.content);
-    }
-    catch (tokenError) {
-        console.error("Error calculating token count:", tokenError);
-        // Handle token calculation error if needed
-    }
-    const maxTokenMessage = `File content (${tokenCount} tokens) exceeds maximum allowed tokens (${maxTokens}). Use readFile with startLine/lineCount or grepFiles for targeted access.`;
-    const finalContent = tokenCount > maxTokens ? maxTokenMessage : fileResult.content;
-    const actualTokenCount = tokenCount > maxTokens ? 0 : tokenCount; // Don't count tokens for skipped files
-    return {
-        path: fileResult.path,
-        content: finalContent,
-        tokenCount: actualTokenCount,
-        error: null,
-    };
-}

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

@@ -1,19 +1,52 @@
-import type { Terminal } from "../terminal/index.ts";
-import type { ToolExecutor } from "../tool-executor.ts";
-import { type SendData } from "./types.ts";
+import type { ToolCallOptions } from "ai";
+import { z } from "zod";
+import { type ToolResult } from "./types.ts";
 export declare const SaveFileTool: {
     name: "saveFile";
 };
-export declare const createSaveFileTool: ({ workingDir, terminal, sendData, toolExecutor, }: {
+declare const inputSchema: z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+    encoding: z.ZodEnum<{
+        utf8: "utf8";
+        ascii: "ascii";
+        "utf-8": "utf-8";
+        utf16le: "utf16le";
+        ucs2: "ucs2";
+        "ucs-2": "ucs-2";
+        base64: "base64";
+        base64url: "base64url";
+        latin1: "latin1";
+        binary: "binary";
+        hex: "hex";
+    }>;
+}, z.core.$strip>;
+type SaveFileInputSchema = z.infer<typeof inputSchema>;
+export declare const createSaveFileTool: ({ workingDir, allowedDirs, }: {
     workingDir: string;
-    terminal?: Terminal;
-    sendData?: SendData;
-    toolExecutor?: ToolExecutor;
+    allowedDirs?: string[];
 }) => Promise<{
-    saveFile: import("ai").Tool<{
-        path: string;
-        content: string;
-        encoding: "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex";
-    }, string>;
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodString;
+            encoding: z.ZodEnum<{
+                utf8: "utf8";
+                ascii: "ascii";
+                "utf-8": "utf-8";
+                utf16le: "utf16le";
+                ucs2: "ucs2";
+                "ucs-2": "ucs-2";
+                base64: "base64";
+                base64url: "base64url";
+                latin1: "latin1";
+                binary: "binary";
+                hex: "hex";
+            }>;
+        }, z.core.$strip>;
+    };
+    execute({ path: userPath, content, encoding }: SaveFileInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
 }>;
+export {};
 //# sourceMappingURL=save-file.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"save-file.d.ts","sourceRoot":"","sources":["../../source/tools/save-file.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD,OAAO,KAAK,EAAe,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAErE,OAAO,EAAsB,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE/D,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,mDAKtC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;;;;;;EAoJA,CAAC"}
+{"version":3,"file":"save-file.d.ts","sourceRoot":"","sources":["../../source/tools/save-file.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAsB,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAEjE,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;iBAMf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEvD,eAAO,MAAM,kBAAkB,GAAU,8BAGtC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;;;;;;;;;;;;;;;;;;;;;mDAa4C,mBAAmB,+BAC7B,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EAuEhC,CAAC"}