@travisennis/acai 0.0.5 → 0.0.6

package/dist/tools/save-file.js

@@ -1,126 +1,83 @@
 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 style from "../terminal/style.js";
 import { joinWorkingDir, validatePath } from "./filesystem-utils.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'),
+});
+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 path exists and is a directory
                 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
+                    const stat = await fs.stat(filePath);
+                    if (stat.isDirectory()) {
+                        throw new Error(`Cannot save file - path is a directory: ${filePath}`);
                     }
-                    // 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,
-                    });
-                    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`,
+                };
+                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;CAqChC,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,48 @@ 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?.({
-                    event: "tool-update",
-                    id: toolCallId,
-                    data: { primary: "Thought:", secondary: [formattedThought] },
-                });
-                sendData?.({
+                    data: `\n${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;
+            }
+        },
     };
 };

package/dist/tools/types.d.ts

@@ -12,11 +12,8 @@ export declare const fileEncodingSchema: z.ZodEnum<{
     binary: "binary";
     hex: "hex";
 }>;
-interface MessageData {
-    primary: string;
-    secondary?: string[] | undefined;
-}
 interface BaseMessage {
+    name: string;
     id: string;
     retry?: number;
 }
@@ -32,11 +29,8 @@ interface ToolCompletionMessage extends BaseMessage {
     event: "tool-completion";
     data: string;
 }
-interface ToolUpdateMessage extends BaseMessage {
-    event: "tool-update";
-    data: MessageData;
-}
-export type Message = ToolInitMessage | ToolErrorMessage | ToolCompletionMessage | ToolUpdateMessage;
-export type SendData = ({ data, event, id, retry, }: Message) => void | Promise<void>;
+export type Message = ToolInitMessage | ToolErrorMessage | ToolCompletionMessage;
+export type ToolResult = Message | string;
+export declare function isToolMessage(value: unknown): value is Message;
 export {};
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../source/tools/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAY7B,CAAC;AAEH,UAAU,WAAW;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;CAClC;AAED,UAAU,WAAW;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,eAAgB,SAAQ,WAAW;IAC3C,KAAK,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,gBAAiB,SAAQ,WAAW;IAC5C,KAAK,EAAE,YAAY,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,qBAAsB,SAAQ,WAAW;IACjD,KAAK,EAAE,iBAAiB,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,iBAAkB,SAAQ,WAAW;IAC7C,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,WAAW,CAAC;CACnB;AAED,MAAM,MAAM,OAAO,GACf,eAAe,GACf,gBAAgB,GAChB,qBAAqB,GACrB,iBAAiB,CAAC;AAEtB,MAAM,MAAM,QAAQ,GAAG,CAAC,EACtB,IAAI,EACJ,KAAK,EACL,EAAE,EACF,KAAK,GACN,EAAE,OAAO,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../source/tools/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAY7B,CAAC;AAEH,UAAU,WAAW;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,UAAU,eAAgB,SAAQ,WAAW;IAC3C,KAAK,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,gBAAiB,SAAQ,WAAW;IAC5C,KAAK,EAAE,YAAY,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,qBAAsB,SAAQ,WAAW;IACjD,KAAK,EAAE,iBAAiB,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,MAAM,OAAO,GACf,eAAe,GACf,gBAAgB,GAChB,qBAAqB,CAAC;AAE1B,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,MAAM,CAAC;AAE1C,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAc9D"}

package/dist/tools/types.js

@@ -12,3 +12,12 @@ export const fileEncodingSchema = z.enum([
     "binary",
     "hex",
 ]);
+export function isToolMessage(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.event === "string" &&
+        typeof candidate.id === "string" &&
+        ("data" in candidate || "retry" in candidate));
+}

package/dist/tools/utils.d.ts

@@ -0,0 +1,14 @@
+import type { Tool } from "ai";
+export declare function prepareTools(tools: {
+    [toolName: string]: Tool;
+}): {
+    tools: undefined | Array<{
+        type: "function";
+        function: {
+            name: string;
+            description: string | undefined;
+            parameters: unknown;
+        };
+    }>;
+};
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../source/tools/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;AAG/B,wBAAgB,YAAY,CAAC,KAAK,EAAE;IAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAAG;IACjE,KAAK,EACD,SAAS,GACT,KAAK,CAAC;QACJ,IAAI,EAAE,UAAU,CAAC;QACjB,QAAQ,EAAE;YACR,IAAI,EAAE,MAAM,CAAC;YACb,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;YAChC,UAAU,EAAE,OAAO,CAAC;SACrB,CAAC;KACH,CAAC,CAAC;CACR,CAuBA"}

package/dist/tools/utils.js

@@ -0,0 +1,16 @@
+import z from "zod";
+export function prepareTools(tools) {
+    const openaiCompatTools = [];
+    for (const tool of Object.entries(tools)) {
+        openaiCompatTools.push({
+            type: "function",
+            function: {
+                name: tool[0],
+                description: tool[1].description,
+                // biome-ignore lint/suspicious/noExplicitAny:  try to figure it out for now
+                parameters: z.toJSONSchema(tool[1].inputSchema),
+            },
+        });
+    }
+    return { tools: openaiCompatTools };
+}

package/dist/tools/web-fetch.d.ts

@@ -1,15 +1,22 @@
+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 WebFetchTool: {
     name: "webFetch";
 };
 export declare const createWebFetchTool: (options: {
-    sendData?: SendData | undefined;
     tokenCounter: TokenCounter;
 }) => {
-    webFetch: import("ai").Tool<{
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            url: z.ZodString;
+        }, z.core.$strip>;
+    };
+    execute({ url }: {
         url: string;
-    }, string>;
+    }, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
 };
 type ContentType = "text/plain" | "text/html" | "text/markdown" | "application/json" | "application/xml" | "application/pdf" | "image/png" | "image/jpeg" | "image/gif" | "image/webp" | "image/svg+xml" | "audio/mpeg" | "audio/wav" | "video/mp4" | "video/webm" | "application/zip" | "application/octet-stream";
 export type ReadUrlResult = {

package/dist/tools/web-fetch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"web-fetch.d.ts","sourceRoot":"","sources":["../../source/tools/web-fetch.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,SAAS;IAC1C,QAAQ,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAChC,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;CAyCA,CAAC;AAEF,KAAK,WAAW,GACZ,YAAY,GACZ,WAAW,GACX,eAAe,GACf,kBAAkB,GAClB,iBAAiB,GACjB,iBAAiB,GACjB,WAAW,GACX,YAAY,GACZ,WAAW,GACX,YAAY,GACZ,eAAe,GACf,YAAY,GACZ,WAAW,GACX,WAAW,GACX,YAAY,GACZ,iBAAiB,GACjB,0BAA0B,CAAC;AAE/B,MAAM,MAAM,aAAa,GAAG;IAAE,WAAW,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvE,wBAAsB,OAAO,CAC3B,GAAG,EAAE,MAAM,EACX,WAAW,CAAC,EAAE,WAAW,GAAG,SAAS,GACpC,OAAO,CAAC,aAAa,CAAC,CA6HxB;AAED,qBAAa,WAAW;IACtB,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW;IAIrC,OAAO,CAAC,IAAI,CAAS;IAErB,OAAO;IAIP;;;;;;OAMG;IACH,KAAK,CAAC,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,MAAM;IAuBhE;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAyCjC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAuBzB;;OAEG;IACH,OAAO,CAAC,mBAAmB;CAG5B"}
+{"version":3,"file":"web-fetch.d.ts","sourceRoot":"","sources":["../../source/tools/web-fetch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAE1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,YAAY;;CAExB,CAAC;AAMF,eAAO,MAAM,kBAAkB,GAAI,SAAS;IAAE,YAAY,EAAE,YAAY,CAAA;CAAE;;;;;;;qBAQ3D;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,+BACK,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;CAmChC,CAAC;AAEF,KAAK,WAAW,GACZ,YAAY,GACZ,WAAW,GACX,eAAe,GACf,kBAAkB,GAClB,iBAAiB,GACjB,iBAAiB,GACjB,WAAW,GACX,YAAY,GACZ,WAAW,GACX,YAAY,GACZ,eAAe,GACf,YAAY,GACZ,WAAW,GACX,WAAW,GACX,YAAY,GACZ,iBAAiB,GACjB,0BAA0B,CAAC;AAE/B,MAAM,MAAM,aAAa,GAAG;IAAE,WAAW,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvE,wBAAsB,OAAO,CAC3B,GAAG,EAAE,MAAM,EACX,WAAW,CAAC,EAAE,WAAW,GAAG,SAAS,GACpC,OAAO,CAAC,aAAa,CAAC,CA6HxB;AAED,qBAAa,WAAW;IACtB,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW;IAIrC,OAAO,CAAC,IAAI,CAAS;IAErB,OAAO;IAIP;;;;;;OAMG;IACH,KAAK,CAAC,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,MAAM;IAuBhE;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAyCjC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAuBzB;;OAEG;IACH,OAAO,CAAC,mBAAmB;CAG5B"}

package/dist/tools/web-fetch.js

@@ -1,4 +1,3 @@
-import { tool } from "ai";
 import { load } from "cheerio";
 import { z } from "zod";
 import { logger } from "../logger.js";
@@ -6,46 +5,48 @@ import style from "../terminal/style.js";
 export const WebFetchTool = {
     name: "webFetch",
 };
+const inputSchema = z.object({
+    url: z.string().describe("The URL to fetch content from."),
+});
 export const createWebFetchTool = (options) => {
-    const { sendData } = options;
     return {
-        [WebFetchTool.name]: tool({
+        toolDef: {
             description: "Fetches the content of a given URL. It intelligently handles HTML content by attempting to use a specialized service for cleaner extraction, falling back to local cleaning if needed. For non-HTML content (like plain text or markdown), it fetches the raw content directly. IMPORTANT: Does not retrieve binary files.",
-            inputSchema: z.object({
-                url: z.string().describe("The URL to fetch content from."),
-            }),
-            execute: async ({ url }, { toolCallId, abortSignal }) => {
-                try {
-                    sendData?.({
-                        event: "tool-init",
-                        id: toolCallId,
-                        data: `Reading URL: ${style.cyan(url)}`,
-                    });
-                    logger.info(`Initiating fetch for URL: ${url}`);
-                    const result = await readUrl(url, abortSignal);
-                    const urlContent = result.data;
-                    const tokenCount = options.tokenCounter.count(urlContent);
-                    sendData?.({
-                        event: "tool-completion",
-                        id: toolCallId,
-                        data: `Read URL successfully (${tokenCount} tokens)`,
-                    });
-                    logger.info(`Successfully read URL: ${url} (${tokenCount} tokens)`);
-                    return urlContent;
-                }
-                catch (error) {
-                    const errorMessage = error.message;
-                    sendData?.({
-                        event: "tool-error",
-                        id: toolCallId,
-                        data: `Error reading URL ${url}: ${errorMessage}`,
-                    });
-                    logger.error(`Error reading URL ${url}: ${errorMessage}`);
-                    // Return the error message so the LLM knows the tool failed.
-                    return `Failed to read URL: ${errorMessage}`;
-                }
-            },
-        }),
+            inputSchema,
+        },
+        async *execute({ url }, { toolCallId, abortSignal }) {
+            try {
+                yield {
+                    name: WebFetchTool.name,
+                    event: "tool-init",
+                    id: toolCallId,
+                    data: `${style.cyan(url)}`,
+                };
+                logger.info(`Initiating fetch for URL: ${url}`);
+                const result = await readUrl(url, abortSignal);
+                const urlContent = result.data;
+                const tokenCount = options.tokenCounter.count(urlContent);
+                yield {
+                    name: WebFetchTool.name,
+                    event: "tool-completion",
+                    id: toolCallId,
+                    data: `Fetched URL (${tokenCount} tokens)`,
+                };
+                logger.info(`Successfully read URL: ${url} (${tokenCount} tokens)`);
+                yield urlContent;
+            }
+            catch (error) {
+                const errorMessage = error.message;
+                yield {
+                    name: WebFetchTool.name,
+                    event: "tool-error",
+                    id: toolCallId,
+                    data: `${style.cyan(url)} ${errorMessage}`,
+                };
+                logger.error(`Error reading URL ${url}: ${errorMessage}`);
+                yield `Failed to read URL: ${errorMessage}`;
+            }
+        },
     };
 };
 export async function readUrl(url, abortSignal) {

package/dist/tools/web-search.d.ts

@@ -1,14 +1,23 @@
+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 WebSearchTool: {
     name: "webSearch";
 };
-export declare const createWebSearchTool: ({ sendData, tokenCounter, }: {
-    sendData?: SendData;
+declare const inputSchema: z.ZodObject<{
+    query: z.ZodString;
+}, z.core.$strip>;
+export declare const createWebSearchTool: ({ tokenCounter, }: {
     tokenCounter: TokenCounter;
 }) => {
-    webSearch: import("ai").Tool<{
-        query: string;
-    }, string>;
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            query: z.ZodString;
+        }, z.core.$strip>;
+    };
+    execute: ({ query }: z.infer<typeof inputSchema>, { toolCallId, abortSignal }: ToolCallOptions) => AsyncGenerator<ToolResult>;
 };
+export {};
 //# sourceMappingURL=web-search.d.ts.map

package/dist/tools/web-search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"web-search.d.ts","sourceRoot":"","sources":["../../source/tools/web-search.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,aAAa;;CAEzB,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,6BAGjC;IACD,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;CA0CA,CAAC"}
+{"version":3,"file":"web-search.d.ts","sourceRoot":"","sources":["../../source/tools/web-search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAE1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,aAAa;;CAEzB,CAAC;AAEF,QAAA,MAAM,WAAW;;iBAEf,CAAC;AAEH,eAAO,MAAM,mBAAmB,GAAI,mBAEjC;IACD,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;;;;yBAQc,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,+BACT,eAAe,KAC3C,cAAc,CAAC,UAAU,CAAC;CA0D9B,CAAC"}

package/dist/tools/web-search.js

@@ -1,43 +1,61 @@
-import { tool } from "ai";
 import { SafeSearchType, search } from "duck-duck-scrape";
 import { z } from "zod";
 import Exa from "../api/exa/index.js";
 import style from "../terminal/style.js";
+import { manageTokenLimit } from "../tokens/threshold.js";
 export const WebSearchTool = {
     name: "webSearch",
 };
-export const createWebSearchTool = ({ sendData, tokenCounter, }) => {
+const inputSchema = z.object({
+    query: z.string().describe("The search query."),
+});
+export const createWebSearchTool = ({ tokenCounter, }) => {
+    const toolDef = {
+        description: "Searches the web and returns match documents with their title, url, and text content. The query should be formulated as a natural language question.",
+        inputSchema,
+    };
+    const execute = async function* ({ query }, { toolCallId, abortSignal }) {
+        try {
+            // Check if execution has been aborted
+            if (abortSignal?.aborted) {
+                throw new Error("Web search aborted");
+            }
+            yield {
+                name: WebSearchTool.name,
+                event: "tool-init",
+                id: toolCallId,
+                data: `${style.cyan(query)}`,
+            };
+            if (abortSignal?.aborted) {
+                throw new Error("Web search aborted before search execution");
+            }
+            const result = await performSearch(query, abortSignal);
+            const sources = result.results.map((source) => `## ${source.title}\nURL: ${source.url}\n\n${source.text}`);
+            const resultText = `# Search Results:\n\n${sources.join("\n\n")}`;
+            const searchResult = await manageTokenLimit(resultText, tokenCounter, "WebSearch", "Use more specific search queries or reduce number of results");
+            yield {
+                name: WebSearchTool.name,
+                event: "tool-completion",
+                id: toolCallId,
+                data: `Found ${result.results.length} results (${searchResult.tokenCount} tokens)`,
+            };
+            yield searchResult.content;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            yield {
+                name: WebSearchTool.name,
+                event: "tool-error",
+                id: toolCallId,
+                data: errorMessage,
+            };
+            yield errorMessage;
+        }
+    };
     return {
-        [WebSearchTool.name]: tool({
-            description: "Searches the web and returns match documents with their title, url, and text content. The query should be formulated as a natural language question.",
-            inputSchema: z.object({
-                query: z.string().describe("The search query."),
-            }),
-            execute: async ({ query }, { toolCallId, abortSignal }) => {
-                // Check if execution has been aborted
-                if (abortSignal?.aborted) {
-                    throw new Error("Web search aborted");
-                }
-                sendData?.({
-                    id: toolCallId,
-                    event: "tool-init",
-                    data: `Web search: ${style.cyan(query)}`,
-                });
-                if (abortSignal?.aborted) {
-                    throw new Error("Web search aborted before search execution");
-                }
-                const result = await performSearch(query, abortSignal);
-                const sources = result.results.map((source) => `## ${source.title}\nURL: ${source.url}\n\n${source.text}`);
-                const resultText = `# Search Results:\n\n${sources.join("\n\n")}`;
-                const tokenCount = tokenCounter.count(resultText);
-                sendData?.({
-                    id: toolCallId,
-                    event: "tool-completion",
-                    data: `Found ${result.results.length} results. (${tokenCount} tokens)`,
-                });
-                return resultText;
-            },
-        }),
+        toolDef,
+        execute,
+        // No ask method needed for read-only tool
     };
 };
 async function performSearch(query, abortSignal) {