@travisennis/acai 0.0.7 → 0.0.8

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

@@ -1,196 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { z } from "zod";
-import { formatFile } from "../formatting.js";
-import style from "../terminal/style.js";
-import { manageTokenLimit, TokenLimitExceededError, } from "../tokens/threshold.js";
-import { joinWorkingDir, validatePath } from "../utils/filesystem/security.js";
-export const ReadMultipleFilesTool = {
-    name: "readMultipleFiles",
-};
-const inputSchema = z.object({
-    paths: z.array(z.string()),
-});
-export const createReadMultipleFilesTool = async ({ workingDir, allowedDirs, tokenCounter, }) => {
-    const allowedDirectory = allowedDirs ?? [workingDir];
-    return {
-        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,
-        },
-        async *execute({ paths }, { toolCallId, abortSignal }) {
-            try {
-                // Check if execution has been aborted
-                if (abortSignal?.aborted) {
-                    throw new Error("Multiple file reading aborted");
-                }
-                yield {
-                    name: ReadMultipleFilesTool.name,
-                    id: toolCallId,
-                    event: "tool-init",
-                    data: `${paths.map((p) => style.cyan(p)).join(", ")}`,
-                };
-                if (abortSignal?.aborted) {
-                    throw new Error("Multiple file reading aborted before reading files");
-                }
-                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 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
-                    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,
-                        };
-                    }
-                    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;
-                        }
-                    }
-                    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`);
-                    }
-                    // 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;
-                }
-            }
-            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) {
-    try {
-        const validPath = await validatePath(joinWorkingDir(filePath, workingDir), allowedDirectory);
-        const content = await readFile(validPath, "utf-8");
-        return {
-            path: filePath,
-            content,
-            error: null,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return {
-            path: filePath,
-            content: null,
-            error: errorMessage,
-        };
-    }
-}

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

@@ -1,56 +0,0 @@
-import type { ToolCallOptions } from "ai";
-import { z } from "zod";
-import type { TokenCounter } from "../tokens/counter.ts";
-import type { ToolResult } from "./types.ts";
-export declare const WebFetchTool: {
-    name: "webFetch";
-};
-export declare const createWebFetchTool: (options: {
-    tokenCounter: TokenCounter;
-}) => {
-    toolDef: {
-        description: string;
-        inputSchema: z.ZodObject<{
-            url: z.ZodString;
-        }, z.core.$strip>;
-    };
-    execute({ url }: {
-        url: 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 = {
-    contentType: ContentType;
-    data: string;
-};
-export declare function readUrl(url: string, abortSignal?: AbortSignal | undefined): Promise<ReadUrlResult>;
-export declare class HtmlCleaner {
-    static new(html: string): HtmlCleaner;
-    private html;
-    private constructor();
-    /**
-     * Cleans HTML content by removing unnecessary elements and simplifying structure
-     * @param {Object} [options] - Configuration options for cleaning
-     * @param {boolean} [options.simplify=true] - Whether to simplify HTML structure by removing redundant elements
-     * @param {boolean} [options.empty=true] - Whether to remove empty elements from the HTML
-     * @returns {string} Cleaned HTML content with removed whitespace and line breaks
-     */
-    clean(options?: {
-        simplify?: boolean;
-        empty?: boolean;
-    }): string;
-    /**
-     * Removes scripts, styles, and comments from HTML
-     */
-    private removeUnnecessaryElements;
-    /**
-     * Simplifies HTML structure by merging redundant tags
-     */
-    private simplifyStructure;
-    /**
-     * Removes empty elements from HTML
-     */
-    private removeEmptyElements;
-}
-export {};
-//# sourceMappingURL=web-fetch.d.ts.map

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

@@ -1 +0,0 @@
-{"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,247 +0,0 @@
-import { load } from "cheerio";
-import { z } from "zod";
-import { logger } from "../logger.js";
-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) => {
-    return {
-        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,
-        },
-        async *execute({ url }, { toolCallId, abortSignal }) {
-            try {
-                yield {
-                    name: WebFetchTool.name,
-                    event: "tool-init",
-                    id: toolCallId,
-                    data: `${style.cyan(url)}`,
-                };
-                logger.info(`${style.cyan(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) {
-    let initialResponse;
-    try {
-        // Initial fetch to check content type and potentially use directly
-        logger.debug(`Performing initial fetch for: ${url}`);
-        initialResponse = await fetch(url, { signal: abortSignal });
-        if (!initialResponse.ok) {
-            throw new Error(`HTTP error! status: ${initialResponse.status} ${initialResponse.statusText}`);
-        }
-        logger.debug(`Initial fetch successful for: ${url}, Status: ${initialResponse.status}`);
-    }
-    catch (error) {
-        // If the initial fetch fails entirely, rethrow
-        logger.error(`Initial fetch failed for ${url}: ${error}`);
-        throw new Error(`Error fetching initial data for ${url}: ${error}`);
-    }
-    const contentType = initialResponse.headers.get("content-type") ??
-        "text/plain";
-    logger.debug(`Content-Type for ${url}: ${contentType}`);
-    // If content type is HTML, try Jina first
-    if (contentType.includes("text/html")) {
-        logger.info(`Detected HTML content for ${url}. Attempting Jina AI fetch.`);
-        try {
-            const apiKey = process.env["JINA_READER_API_KEY"];
-            if (!apiKey) {
-                logger.warn("JINA_READER_API_KEY not set. Skipping Jina fetch.");
-                throw new Error("Jina API key not available"); // Skip to fallback
-            }
-            const jinaReadUrl = `https://r.jina.ai/${url}`;
-            logger.debug(`Fetching with Jina: ${jinaReadUrl}`);
-            const jinaResponse = await fetch(jinaReadUrl, {
-                method: "GET",
-                headers: {
-                    // biome-ignore lint/style/useNamingConvention: API requirement
-                    Authorization: `Bearer ${apiKey}`,
-                    "X-With-Generated-Alt": "true", // Optional: Ask Jina to include image descriptions
-                    "X-With-Links-Summary": "true", // Optional: Ask Jina for a summary of links
-                },
-                signal: abortSignal,
-            });
-            if (jinaResponse.ok) {
-                const data = await jinaResponse.text();
-                logger.info(`Successfully fetched and processed HTML URL with Jina: ${url}`);
-                return {
-                    contentType,
-                    data,
-                };
-            }
-            logger.warn(`Jina fetch failed for ${url} with status ${jinaResponse.status}: ${jinaResponse.statusText}. Falling back to direct fetch and clean.`);
-            // Fall through to use the initialResponse if Jina fails
-        }
-        catch (error) {
-            logger.warn(`Error fetching from Jina for ${url}: ${error.message}. Falling back to direct fetch and clean.`);
-            // Fall through to use the initialResponse if Jina fails
-        }
-        // Fallback for HTML: Use the initial response and clean it
-        try {
-            logger.warn(`Falling back to direct fetch and cleaning for HTML URL: ${url}`);
-            const htmlText = await initialResponse.text();
-            logger.debug(`Cleaning HTML content for ${url} (length: ${htmlText.length})`);
-            const cleaner = HtmlCleaner.new(htmlText);
-            const processedText = cleaner.clean();
-            logger.info(`Successfully cleaned HTML content for ${url} (length: ${processedText.length})`);
-            return {
-                contentType,
-                data: processedText,
-            };
-        }
-        catch (cleanError) {
-            logger.error(`Error cleaning HTML from fallback fetch for ${url}: ${cleanError}`);
-            throw new Error(`Error cleaning HTML from fallback fetch for ${url}: ${cleanError}`);
-        }
-    }
-    else {
-        // If not HTML, return the text directly from the initial response
-        logger.info(`Fetched non-HTML content directly: ${url} (Content-Type: ${contentType})`);
-        try {
-            if (contentType.startsWith("image/")) {
-                const arrayBuffer = await initialResponse.arrayBuffer();
-                const base64 = Buffer.from(arrayBuffer).toString("base64");
-                const base64Url = `data:${contentType};base64,${base64}`;
-                logger.debug(`Returning base64 image data for ${url} (length: ${base64.length})`);
-                return {
-                    contentType,
-                    data: base64Url,
-                };
-            }
-            const textContent = await initialResponse.text();
-            logger.debug(`Returning raw text content for ${url} (length: ${textContent.length})`);
-            return {
-                contentType,
-                data: textContent,
-            };
-        }
-        catch (textError) {
-            logger.error(`Error reading response for ${url}: ${textError}`);
-            throw new Error(`Error reading response for ${url}: ${textError}`);
-        }
-    }
-}
-export class HtmlCleaner {
-    static new(html) {
-        return new HtmlCleaner(html);
-    }
-    html;
-    constructor(html) {
-        this.html = html;
-    }
-    /**
-     * Cleans HTML content by removing unnecessary elements and simplifying structure
-     * @param {Object} [options] - Configuration options for cleaning
-     * @param {boolean} [options.simplify=true] - Whether to simplify HTML structure by removing redundant elements
-     * @param {boolean} [options.empty=true] - Whether to remove empty elements from the HTML
-     * @returns {string} Cleaned HTML content with removed whitespace and line breaks
-     */
-    clean(options) {
-        const { simplify = true, empty = true } = options ?? {};
-        const $ = load(this.html);
-        // Remove scripts, styles, and comments
-        this.removeUnnecessaryElements($);
-        // Simplify HTML structure
-        if (simplify) {
-            this.simplifyStructure($);
-        }
-        // Remove empty elements
-        if (empty) {
-            this.removeEmptyElements($);
-        }
-        // Get cleaned HTML
-        return $.html()
-            .trim()
-            .replace(/^\s*[\r\n]/gm, "");
-    }
-    /**
-     * Removes scripts, styles, and comments from HTML
-     */
-    removeUnnecessaryElements($) {
-        // Remove all script tags
-        $("script").remove();
-        // Remove all noscript tags
-        $("noscript").remove();
-        // Remove all style tags
-        $("style").remove();
-        // Remove all link tags (external stylesheets)
-        $('link[rel="stylesheet"]').remove();
-        // Remove all preload link tags
-        $('link[rel="preload"]').remove();
-        // Remove all link tags
-        $("link").remove();
-        // Remove all forms
-        $("form").remove();
-        // Remove comments
-        $("*")
-            .contents()
-            .each((_, element) => {
-            if (element.type === "comment") {
-                $(element).remove();
-            }
-        });
-        // Remove all inline styles
-        $("[style]").removeAttr("style");
-        // Remove all class attributes
-        $("[class]").removeAttr("class");
-        // Remove all id attributes
-        $("[id]").removeAttr("id");
-    }
-    /**
-     * Simplifies HTML structure by merging redundant tags
-     */
-    simplifyStructure($) {
-        // Merge nested divs
-        $("div div").each((_, element) => {
-            const $element = $(element);
-            const parent = $element.parent();
-            if (parent.children().length === 1 && parent.get(0)?.tagName === "div") {
-                $element.unwrap();
-            }
-        });
-        // Remove redundant spans
-        $("span").each((_, element) => {
-            const $element = $(element);
-            if (!$element.attr() || Object.keys($element.attr() ?? {}).length === 0) {
-                const h = $element.html();
-                if (h) {
-                    $element.replaceWith(h);
-                }
-            }
-        });
-    }
-    /**
-     * Removes empty elements from HTML
-     */
-    removeEmptyElements($) {
-        $(":empty").remove();
-    }
-}

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

@@ -1,23 +0,0 @@
-import type { ToolCallOptions } from "ai";
-import { z } from "zod";
-import type { TokenCounter } from "../tokens/counter.ts";
-import type { ToolResult } from "./types.ts";
-export declare const WebSearchTool: {
-    name: "webSearch";
-};
-declare const inputSchema: z.ZodObject<{
-    query: z.ZodString;
-}, z.core.$strip>;
-export declare const createWebSearchTool: ({ tokenCounter, }: {
-    tokenCounter: TokenCounter;
-}) => {
-    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 +0,0 @@
-{"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;AAKzD,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;CAwE9B,CAAC"}

package/dist/tools/web-search.js

@@ -1,148 +0,0 @@
-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, TokenLimitExceededError, } from "../tokens/threshold.js";
-export const WebSearchTool = {
-    name: "webSearch",
-};
-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")}`;
-            try {
-                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) {
-                if (error instanceof TokenLimitExceededError) {
-                    yield {
-                        name: WebSearchTool.name,
-                        event: "tool-error",
-                        id: toolCallId,
-                        data: error.message,
-                    };
-                    yield error.message;
-                    return;
-                }
-                throw error;
-            }
-        }
-        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 {
-        toolDef,
-        execute,
-        // No ask method needed for read-only tool
-    };
-};
-async function performSearch(query, abortSignal) {
-    // Check if EXA API key is available
-    const hasExaApiKey = process.env["EXA_API_KEY"] && process.env["EXA_API_KEY"].trim() !== "";
-    if (hasExaApiKey) {
-        // Use Exa search
-        try {
-            if (abortSignal?.aborted) {
-                throw new Error("Web search aborted before Exa search");
-            }
-            const exa = new Exa(process.env["EXA_API_KEY"]);
-            // Create a promise that races with the abort signal
-            const searchPromise = exa.searchAndContents(query, {
-                numResults: 5,
-                text: true,
-            });
-            const result = await Promise.race([
-                searchPromise,
-                new Promise((_, reject) => {
-                    if (abortSignal) {
-                        abortSignal.addEventListener("abort", () => {
-                            reject(new Error("Web search aborted during Exa search"));
-                        });
-                    }
-                }),
-            ]);
-            return result;
-        }
-        catch (error) {
-            // If Exa fails, fall back to duck duck scrape
-            console.info("Exa search failed, falling back to DuckDuckGo:", error);
-            return await searchWithDuckDuckGo(query, abortSignal);
-        }
-    }
-    else {
-        // Use DuckDuckGo search as fallback
-        console.info("EXA_API_KEY not set, using DuckDuckGo search");
-        return await searchWithDuckDuckGo(query, abortSignal);
-    }
-}
-async function searchWithDuckDuckGo(query, abortSignal) {
-    try {
-        if (abortSignal?.aborted) {
-            throw new Error("Web search aborted before DuckDuckGo search");
-        }
-        // Create a promise that races with the abort signal
-        const searchPromise = search(query, {
-            safeSearch: SafeSearchType.MODERATE,
-        });
-        const searchResults = await Promise.race([
-            searchPromise,
-            new Promise((_, reject) => {
-                if (abortSignal) {
-                    abortSignal.addEventListener("abort", () => {
-                        reject(new Error("Web search aborted during DuckDuckGo search"));
-                    });
-                }
-            }),
-        ]);
-        // Transform duck-duck-scrape results to match Exa format
-        // Take only first 5 results to match Exa behavior
-        const results = searchResults.results
-            .slice(0, 5)
-            .map((result) => ({
-            title: result.title,
-            url: result.url,
-            text: result.description || "",
-        }));
-        return { results };
-    }
-    catch (error) {
-        throw new Error(`Failed to perform web search: ${error}`);
-    }
-}