@travisennis/acai 0.0.5 → 0.0.7

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

@@ -1,91 +1,178 @@
 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 { joinWorkingDir, validatePath } from "./filesystem-utils.js";
+import { manageTokenLimit, TokenLimitExceededError, } from "../tokens/threshold.js";
+import { joinWorkingDir, validatePath } from "../utils/filesystem/security.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;
                 }));
-                let totalTokens = 0;
-                let filesReadCount = 0;
-                let filesExceededLimitCount = 0;
-                let filesErrorCount = 0;
-                const formattedResults = results.map((result) => {
+                const processedResults = await Promise.all(results.map(async (result) => {
                     if (result.error) {
-                        filesErrorCount++;
-                        return `${result.path}: Error - ${result.error}`;
+                        return {
+                            path: result.path,
+                            content: `${result.path}: Error - ${result.error}`,
+                            tokenCount: 0,
+                            error: result.error,
+                            truncated: false,
+                        };
                     }
-                    // Check if tokenCount is > 0, meaning it wasn't skipped
-                    if (result.tokenCount > 0) {
-                        filesReadCount++;
+                    // Apply token limit check to each file
+                    try {
+                        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,
+                            exceededLimit: false,
+                        };
                     }
-                    else if (result.content?.includes("exceeds maximum allowed tokens")) {
-                        filesExceededLimitCount++;
+                    catch (error) {
+                        if (error instanceof TokenLimitExceededError) {
+                            return {
+                                path: result.path,
+                                content: error.message,
+                                tokenCount: 0,
+                                error: null,
+                                exceededLimit: true,
+                            };
+                        }
+                        throw error;
+                    }
+                }));
+                const formattedResults = processedResults.map((r) => r.content);
+                try {
+                    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;
+                    for (const processedResult of processedResults) {
+                        if (processedResult.error) {
+                            filesErrorCount++;
+                        }
+                        else if (processedResult.exceededLimit) {
+                            filesExceededLimitCount++;
+                            totalTokens += processedResult.tokenCount;
+                        }
+                        else {
+                            filesReadCount++;
+                            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`);
+                        parts.push(`${filesExceededLimitCount} files exceeded token limit`);
                     }
                     if (filesErrorCount > 0) {
                         parts.push(`${filesErrorCount} files could not be read`);
                     }
-                    completionMessage = `${parts.join(", ")}.`;
+                    // Note: If we reach here, finalResult succeeded (no TokenLimitExceededError thrown)
+                    const completionMessage = `${parts.join(", ")}.`;
+                    yield {
+                        name: ReadMultipleFilesTool.name,
+                        id: toolCallId,
+                        event: "tool-completion",
+                        data: completionMessage,
+                    };
+                    yield finalResult.content;
+                }
+                catch (error) {
+                    if (error instanceof TokenLimitExceededError) {
+                        // Combined output exceeded limit
+                        const parts = [];
+                        let totalTokens = 0;
+                        let filesReadCount = 0;
+                        let filesExceededLimitCount = 0;
+                        let filesErrorCount = 0;
+                        for (const processedResult of processedResults) {
+                            if (processedResult.error) {
+                                filesErrorCount++;
+                            }
+                            else if (processedResult.exceededLimit) {
+                                filesExceededLimitCount++;
+                                totalTokens += processedResult.tokenCount;
+                            }
+                            else {
+                                filesReadCount++;
+                                totalTokens += processedResult.tokenCount;
+                            }
+                        }
+                        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`);
+                        }
+                        parts.push(`Combined output exceeded token limit. ${error.message}`);
+                        const completionMessage = `${parts.join(", ")}.`;
+                        yield {
+                            name: ReadMultipleFilesTool.name,
+                            event: "tool-error",
+                            id: toolCallId,
+                            data: completionMessage,
+                        };
+                        yield error.message;
+                        return;
+                    }
+                    throw error;
                 }
-                sendData?.({
+            }
+            catch (error) {
+                const errorMsg = error.message;
+                yield {
+                    name: ReadMultipleFilesTool.name,
                     id: toolCallId,
-                    event: "tool-completion",
-                    data: completionMessage,
-                });
-                return formattedResults.join("\n---\n");
-            },
-        }),
+                    event: "tool-error",
+                    data: errorMsg,
+                };
+                yield errorMsg;
+            }
+        },
     };
 };
 async function validateAndReadFile(filePath, workingDir, allowedDirectory) {
@@ -107,30 +194,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.ZodDefault<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.ZodDefault<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;AASxB,OAAO,EAAsB,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAEjE,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;iBAQf,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;EAuFhC,CAAC"}

package/dist/tools/save-file.js

@@ -1,126 +1,101 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { tool } from "ai";
 import { z } from "zod";
-import { formatCodeBlock } from "../formatting.js";
+import { config } from "../config.js";
+import { clearProjectStatusCache } from "../repl/project-status-line.js";
 import style from "../terminal/style.js";
-import { joinWorkingDir, validatePath } from "./filesystem-utils.js";
+import { joinWorkingDir, validateFileNotReadOnly, validatePath, } from "../utils/filesystem/security.js";
 import { fileEncodingSchema } from "./types.js";
 export const SaveFileTool = {
     name: "saveFile",
 };
-export const createSaveFileTool = async ({ workingDir, terminal, sendData, toolExecutor, }) => {
-    const allowedDirectory = workingDir;
+const inputSchema = z.object({
+    path: z.string().describe("Absolute path to file to save to"),
+    content: z.string().describe("Content to save in the file"),
+    encoding: fileEncodingSchema
+        .describe('Encoding format for saving the file. Use "utf-8" as default for text files')
+        .default("utf-8"),
+});
+export const createSaveFileTool = async ({ workingDir, allowedDirs, }) => {
+    const allowedDirectory = allowedDirs ?? [workingDir];
     return {
-        [SaveFileTool.name]: tool({
+        toolDef: {
             description: "Create a new file or completely overwrite an existing file with new content. " +
                 "Automatically creates all missing parent directories. " +
                 "Use with caution as it will overwrite existing files without warning. " +
                 "Handles text content with proper encoding. Only works within allowed directories.",
-            inputSchema: z.object({
-                path: z.string().describe("Absolute path to file to save to"),
-                content: z.string().describe("Content to save in the file"),
-                encoding: fileEncodingSchema.describe('Encoding format for saving the file. Use "utf-8" as default for text files'),
-            }),
-            execute: async ({ path: userPath, content, encoding, }, { toolCallId, abortSignal }) => {
-                // Check if execution has been aborted
+            inputSchema,
+        },
+        async *execute({ path: userPath, content, encoding }, { toolCallId, abortSignal }) {
+            try {
                 if (abortSignal?.aborted) {
                     throw new Error("File saving aborted");
                 }
-                sendData?.({
-                    id: toolCallId,
+                yield {
+                    name: SaveFileTool.name,
                     event: "tool-init",
-                    data: `Saving file: ${style.cyan(userPath)}`,
-                });
+                    id: toolCallId,
+                    data: `${style.cyan(userPath)}`,
+                };
+                const filePath = await validatePath(joinWorkingDir(userPath, workingDir), allowedDirectory, { requireExistence: false, abortSignal });
+                // Check if file is read-only (only if it exists)
                 try {
-                    const filePath = await validatePath(joinWorkingDir(userPath, workingDir), allowedDirectory, { requireExistence: false, abortSignal });
-                    if (terminal) {
-                        terminal.writeln(`\n${style.blue.bold("●")} Proposing file save: ${style.cyan(userPath)}`);
-                        terminal.lineBreak();
-                        terminal.writeln("Proposed file content:");
-                        terminal.hr();
-                        terminal.display(formatCodeBlock(userPath, content));
-                        terminal.hr();
-                        // Determine overwrite status for display
-                        let overwriteMessage = "";
-                        try {
-                            const stat = await fs.stat(filePath);
-                            if (stat.isFile()) {
-                                overwriteMessage = style.yellow("(Will overwrite existing file)");
-                            }
-                        }
-                        catch {
-                            overwriteMessage = style.green("(Will create new file)");
-                        }
-                        let userResponse;
-                        if (toolExecutor) {
-                            const ctx = {
-                                toolName: SaveFileTool.name,
-                                toolCallId,
-                                message: `What would you like to do with this save? ${overwriteMessage}`,
-                                choices: {
-                                    accept: "Accept this save",
-                                    acceptAll: "Accept all future saves (including this)",
-                                    reject: "Reject this save",
-                                },
-                            };
-                            try {
-                                userResponse = await toolExecutor.ask(ctx, { abortSignal });
-                            }
-                            catch (e) {
-                                if (e.name === "AbortError") {
-                                    throw new Error("File saving 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 saves"));
-                            terminal.lineBreak();
-                        }
-                        if (userChoice === "reject") {
-                            terminal.lineBreak();
-                            const rejectionReason = reason || "No reason provided";
-                            sendData?.({
-                                id: toolCallId,
-                                event: "tool-completion",
-                                data: `Save rejected by user. Reason: ${rejectionReason}`,
-                            });
-                            return `The user rejected this save. Reason: ${rejectionReason}`;
-                        }
-                        // If accepted, proceed to write file
+                    await fs.stat(filePath);
+                    const projectConfig = await config.getConfig();
+                    validateFileNotReadOnly(filePath, projectConfig, workingDir);
+                }
+                catch (error) {
+                    // File doesn't exist, so it's not read-only
+                    if (error.code !== "ENOENT") {
+                        throw error;
                     }
-                    // Pre-side-effect check
-                    if (abortSignal?.aborted) {
-                        throw new Error("File saving aborted before writing");
+                }
+                // Check if path exists and is a directory
+                try {
+                    const stat = await fs.stat(filePath);
+                    if (stat.isDirectory()) {
+                        throw new Error(`Cannot save file - path is a directory: ${filePath}`);
                     }
-                    // Ensure parent directory exists (create missing parents)
-                    const parentDir = path.dirname(filePath);
-                    await fs.mkdir(parentDir, { recursive: true });
-                    await fs.writeFile(filePath, content, {
-                        encoding,
-                        signal: abortSignal,
-                    });
-                    sendData?.({
-                        id: toolCallId,
-                        event: "tool-completion",
-                        data: `File saved successfully: ${userPath}`,
-                    });
-                    return `File saved successfully: ${filePath}`;
                 }
                 catch (error) {
-                    sendData?.({
-                        id: toolCallId,
-                        event: "tool-error",
-                        data: `Failed to save file: ${error.message}`,
-                    });
-                    return `Failed to save file: ${error.message}`;
+                    // Only re-throw if it's our directory error, otherwise continue (file doesn't exist)
+                    if (error instanceof Error &&
+                        error.message.includes("is a directory")) {
+                        throw error;
+                    }
+                }
+                // Pre-side-effect check
+                if (abortSignal?.aborted) {
+                    throw new Error("File saving aborted before writing");
                 }
-            },
-        }),
+                // Ensure parent directory exists (create missing parents)
+                const parentDir = path.dirname(filePath);
+                await fs.mkdir(parentDir, { recursive: true });
+                await fs.writeFile(filePath, content, {
+                    encoding,
+                    signal: abortSignal,
+                });
+                const lines = content.split("\n").length;
+                const bytes = Buffer.byteLength(content, encoding);
+                yield {
+                    name: SaveFileTool.name,
+                    event: "tool-completion",
+                    id: toolCallId,
+                    data: `Saved ${lines} lines, ${bytes} bytes`,
+                };
+                // Clear project status cache since file operations change git status
+                clearProjectStatusCache();
+                yield `File saved successfully: ${filePath}`;
+            }
+            catch (error) {
+                yield {
+                    name: SaveFileTool.name,
+                    event: "tool-error",
+                    id: toolCallId,
+                    data: error.message,
+                };
+                yield `Failed to save file: ${error.message}`;
+            }
+        },
     };
 };

package/dist/tools/think.d.ts

@@ -1,12 +1,20 @@
-import type { SendData } from "./types.ts";
+import type { ToolCallOptions } from "ai";
+import { z } from "zod";
+import type { ToolResult } from "./types.ts";
 export declare const ThinkTool: {
     name: "think";
 };
-export declare const createThinkTool: (options?: {
-    sendData?: SendData | undefined;
-}) => {
-    think: import("ai").Tool<{
-        thought: string;
-    }, string>;
+declare const inputSchema: z.ZodObject<{
+    thought: z.ZodString;
+}, z.core.$strip>;
+export declare const createThinkTool: () => {
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            thought: z.ZodString;
+        }, z.core.$strip>;
+    };
+    execute({ thought }: z.infer<typeof inputSchema>, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
 };
+export {};
 //# sourceMappingURL=think.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"think.d.ts","sourceRoot":"","sources":["../../source/tools/think.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,SAAS;;CAErB,CAAC;AAYF,eAAO,MAAM,eAAe,GAC1B,UAAS;IAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAA;CAAO;;;;CAmClD,CAAC"}
+{"version":3,"file":"think.d.ts","sourceRoot":"","sources":["../../source/tools/think.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,SAAS;;CAErB,CAAC;AAWF,QAAA,MAAM,WAAW;;iBAEf,CAAC;AAGH,eAAO,MAAM,eAAe;;;;;;;yBAOT,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,+BACX,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;CA4ChC,CAAC"}

package/dist/tools/think.js

@@ -1,4 +1,3 @@
-import { tool } from "ai";
 import { z } from "zod";
 export const ThinkTool = {
     name: "think",
@@ -11,39 +10,54 @@ Common use cases:
 4. When designing a new feature, use this tool to think through architecture decisions and implementation details
 5. When debugging a complex issue, use this tool to organize your thoughts and hypotheses
 The tool simply logs your thought process for better transparency and does not execute any code or make changes.`;
+const inputSchema = z.object({
+    thought: z.string().describe("Your thought"),
+});
 // This is a no-op tool that logs a thought. It is inspired by the tau-bench think tool.
-export const createThinkTool = (options = {}) => {
-    const { sendData } = options;
+export const createThinkTool = () => {
     return {
-        [ThinkTool.name]: tool({
+        toolDef: {
             description: toolDescription,
-            inputSchema: z.object({
-                thought: z.string().describe("Your thought"),
-            }),
-            execute: ({ thought }, { toolCallId, abortSignal }) => {
+            inputSchema,
+        },
+        async *execute({ thought }, { toolCallId, abortSignal }) {
+            try {
                 // Check if execution has been aborted
                 if (abortSignal?.aborted) {
                     throw new Error("Thinking process aborted");
                 }
                 // Replace literal '\\n' with actual newline characters
                 const formattedThought = thought.replace(/\\n/g, "\n");
-                sendData?.({
+                yield {
+                    name: ThinkTool.name,
                     event: "tool-init",
                     id: toolCallId,
-                    data: "Logging Thought",
-                });
-                sendData?.({
+                    data: "Logging thought",
+                };
+                yield {
+                    name: ThinkTool.name,
                     event: "tool-update",
                     id: toolCallId,
-                    data: { primary: "Thought:", secondary: [formattedThought] },
-                });
-                sendData?.({
+                    data: `${formattedThought}`,
+                };
+                yield {
+                    name: ThinkTool.name,
                     event: "tool-completion",
                     id: toolCallId,
-                    data: "Done",
-                });
-                return Promise.resolve("Your thought has been logged.");
-            },
-        }),
+                    data: "Thought logged",
+                };
+                yield "Your thought has been logged.";
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                yield {
+                    name: ThinkTool.name,
+                    event: "tool-error",
+                    id: toolCallId,
+                    data: errorMessage,
+                };
+                yield errorMessage;
+            }
+        },
     };
 };