@travisennis/acai 0.0.9 → 0.0.11

package/dist/tools/skill.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import type { ToolExecutionOptions } from "./types.ts";
+export declare const SkillTool: {
+    name: "Skill";
+};
+declare const inputSchema: z.ZodObject<{
+    skill: z.ZodString;
+    args: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SkillInputSchema = z.infer<typeof inputSchema>;
+export declare function createSkillTool(): Promise<{
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            skill: z.ZodString;
+            args: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    display({ skill: skillName }: SkillInputSchema): string;
+    execute({ skill: skillName, args }: SkillInputSchema, { abortSignal }: ToolExecutionOptions): Promise<string>;
+}>;
+export {};
+//# sourceMappingURL=skill.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skill.d.ts","sourceRoot":"","sources":["../../source/tools/skill.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,SAAS;;CAErB,CAAC;AAEF,QAAA,MAAM,WAAW;;;iBAKf,CAAC;AAEH,KAAK,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEpD,wBAAsB,eAAe;;;;;;;;kCAWH,gBAAgB,GAAG,MAAM;wCAIzB,gBAAgB,mBAC3B,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;GA4CrB"}

package/dist/tools/skill.js

@@ -0,0 +1,65 @@
+import { readFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { z } from "zod";
+import { loadSkills } from "../skills/index.js";
+import style from "../terminal/style.js";
+import { replaceArgumentPlaceholders } from "../utils/templates.js";
+export const SkillTool = {
+    name: "Skill",
+};
+const inputSchema = z.object({
+    skill: z
+        .string()
+        .describe('The skill name. E.g., "commit", "review-pr", or "pdf"'),
+    args: z.string().optional().describe("Optional arguments for the skill"),
+});
+export async function createSkillTool() {
+    const skills = await loadSkills();
+    const modelInvocableSkills = skills.getModelInvocable();
+    const description = "Run a skill (e.g., commit, review-pr).";
+    return {
+        toolDef: {
+            description,
+            inputSchema,
+        },
+        display({ skill: skillName }) {
+            return style.cyan(skillName);
+        },
+        async execute({ skill: skillName, args }, { abortSignal }) {
+            try {
+                if (abortSignal?.aborted) {
+                    throw new Error("Skill execution aborted");
+                }
+                // Find the skill
+                const skill = modelInvocableSkills.find((s) => s.name === skillName);
+                if (!skill) {
+                    const availableSkillNames = modelInvocableSkills
+                        .map((s) => s.name)
+                        .join(", ");
+                    const errorMsg = `Skill "${skillName}" not found. Available skills: ${availableSkillNames}`;
+                    return errorMsg;
+                }
+                if (skill.disableModelInvocation) {
+                    return `Skill "${skillName}" is not available for model invocation.`;
+                }
+                // Read the skill file
+                const content = await readFile(skill.filePath, "utf8");
+                let result = `# Skill Name: ${skill.name}`;
+                result += `\n**Base directory**: ${dirname(skill.filePath)}\n\n`;
+                result +=
+                    "Relative paths in this skill (e.g., scripts/, reference/) are relative to this base directory.\n";
+                // Parse frontmatter and body
+                const yamlStart = content.indexOf("---");
+                const yamlEnd = content.indexOf("---", yamlStart + 3);
+                const body = yamlEnd !== -1 ? content.slice(yamlEnd + 3).trim() : content;
+                const argsArray = args ? args.split(/\s+/).filter(Boolean) : [];
+                result += replaceArgumentPlaceholders(body, argsArray);
+                return result;
+            }
+            catch (error) {
+                const errorMsg = `${error.message}`;
+                return errorMsg;
+            }
+        },
+    };
+}

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

@@ -1 +1 @@
-{"version":3,"file":"think.d.ts","sourceRoot":"","sources":["../../source/tools/think.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,SAAS;;CAErB,CAAC;AAWF,QAAA,MAAM,WAAW;;iBAEf,CAAC;AAGH,eAAO,MAAM,eAAe;;;;;;;;yBAUT,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,mBACvB,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;CAUrB,CAAC"}
+{"version":3,"file":"think.d.ts","sourceRoot":"","sources":["../../source/tools/think.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,SAAS;;CAErB,CAAC;AAIF,QAAA,MAAM,WAAW;;iBAEf,CAAC;AAGH,eAAO,MAAM,eAAe;;;;;;;;yBAUT,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,mBACvB,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;CAUrB,CAAC"}

package/dist/tools/think.js

@@ -2,14 +2,7 @@ import { z } from "zod";
 export const ThinkTool = {
     name: "Think",
 };
-const toolDescription = `Use the tool to think about something. It will not obtain new information or make any changes to the repository, but just log the thought. Use it when complex reasoning or brainstorming is needed.
-Common use cases:
-1. When exploring a repository and discovering the source of a bug, call this tool to brainstorm several unique ways of fixing the bug, and assess which change(s) are likely to be simplest and most effective
-2. After receiving test results, use this tool to brainstorm ways to fix failing tests
-3. When planning a complex refactoring, use this tool to outline different approaches and their tradeoffs
-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 toolDescription = "Think through a problem step-by-step.";
 const inputSchema = z.object({
     thought: z.string().describe("Your thought"),
 });
@@ -21,7 +14,7 @@ export const createThinkTool = () => {
             inputSchema,
         },
         display() {
-            return "\n> Logging thought";
+            return "Logging thought";
         },
         async execute({ thought }, { abortSignal }) {
             if (abortSignal?.aborted) {

package/dist/tools/utils.d.ts

@@ -1,4 +1,6 @@
 import type { Tool } from "ai";
+import type { CompleteToolSet, CompleteTools } from "./index.ts";
+export declare function toAiSdkTools(tools: CompleteToolSet, includeExecute?: boolean): CompleteTools;
 export declare function prepareTools(tools: {
     [toolName: string]: Tool;
 }): {

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

@@ -1 +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"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../source/tools/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAuB,MAAM,IAAI,CAAC;AAGpD,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEjE,wBAAgB,YAAY,CAC1B,KAAK,EAAE,eAAe,EACtB,cAAc,UAAO,GACpB,aAAa,CAYf;AAED,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

@@ -1,4 +1,16 @@
+import { tool } from "ai";
 import z from "zod";
+export function toAiSdkTools(tools, includeExecute = true) {
+    return Object.fromEntries(Object.entries(tools).map(([name, toolObj]) => [
+        name,
+        tool({
+            ...toolObj.toolDef,
+            execute: (includeExecute
+                ? toolObj.execute
+                : undefined),
+        }),
+    ]));
+}
 export function prepareTools(tools) {
     const openaiCompatTools = [];
     for (const tool of Object.entries(tools)) {

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

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import type { ToolExecutionOptions } from "./types.ts";
+export declare const WebFetchTool: {
+    name: "WebFetch";
+};
+/**
+ * Input schema for the web fetch tool
+ */
+declare const inputSchema: z.ZodObject<{
+    url: z.ZodString;
+    output: z.ZodDefault<z.ZodEnum<{
+        markdown: "markdown";
+        text: "text";
+        html: "html";
+        json: "json";
+    }>>;
+    jina: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | null, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+    timeout: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | null, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
+    headers: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | null, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+}, z.core.$strip>;
+type WebFetchInputSchema = z.infer<typeof inputSchema>;
+/**
+ * Execute web fetch
+ */
+export declare function executeWebFetch(options: WebFetchInputSchema, executionOptions: ToolExecutionOptions): Promise<string>;
+/**
+ * Create the web fetch tool
+ */
+export declare const createWebFetchTool: () => Promise<{
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            url: z.ZodString;
+            output: z.ZodDefault<z.ZodEnum<{
+                markdown: "markdown";
+                text: "text";
+                html: "html";
+                json: "json";
+            }>>;
+            jina: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | null, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+            timeout: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | null, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
+            headers: z.ZodOptional<z.ZodPipe<z.ZodTransform<string | null, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+        }, z.core.$strip>;
+    };
+    display({ url }: WebFetchInputSchema): string;
+    execute(options: WebFetchInputSchema, executionOptions: ToolExecutionOptions): Promise<string>;
+}>;
+export type WebFetchTool = Awaited<ReturnType<typeof createWebFetchTool>>;
+export {};
+//# sourceMappingURL=web-fetch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"web-fetch.d.ts","sourceRoot":"","sources":["../../source/tools/web-fetch.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,YAAY;;CAExB,CAAC;AAQF;;GAEG;AACH,QAAA,MAAM,WAAW;;;;;;;;;;;iBAkBf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AA6bvD;;GAEG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,mBAAmB,EAC5B,gBAAgB,EAAE,oBAAoB,GACrC,OAAO,CAAC,MAAM,CAAC,CAiEjB;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;qBAQV,mBAAmB;qBAIzB,mBAAmB,oBACV,oBAAoB,GACrC,OAAO,CAAC,MAAM,CAAC;EAIrB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC"}

package/dist/tools/web-fetch.js

@@ -0,0 +1,446 @@
+import { load } from "cheerio";
+import { z } from "zod";
+import style from "../terminal/style.js";
+export const WebFetchTool = {
+    name: "WebFetch",
+};
+// Constants
+const DEFAULT_TIMEOUT = 30000; // 30 seconds
+const MAX_REDIRECTS = 5;
+const MAX_URL_LENGTH = 2048;
+const JINA_API_BASE = "https://r.jina.ai";
+/**
+ * Input schema for the web fetch tool
+ */
+const inputSchema = z.object({
+    url: z.string().describe("URL to fetch"),
+    output: z
+        .enum(["text", "html", "markdown", "json"])
+        .default("text")
+        .describe("Output format (default: text)"),
+    jina: z
+        .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
+        .optional()
+        .describe("Use Jina AI for HTML cleaning"),
+    timeout: z
+        .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
+        .optional()
+        .describe(`Timeout in milliseconds (default: ${DEFAULT_TIMEOUT}ms)`),
+    headers: z
+        .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
+        .optional()
+        .describe("Include HTTP headers in output"),
+});
+/**
+ * Convert null/undefined to string for preprocessing
+ */
+function convertNullString(val) {
+    if (val === null ||
+        val === undefined ||
+        val === "null" ||
+        val === "undefined") {
+        return null;
+    }
+    return String(val);
+}
+/**
+ * Count tokens (simple estimation: 4 characters per token)
+ */
+function countTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Validate URL
+ */
+function isValidUrl(url) {
+    try {
+        if (typeof url !== "string" || url.length === 0)
+            return false;
+        if (url.length > MAX_URL_LENGTH)
+            return false;
+        const parsed = new URL(url);
+        return parsed.protocol === "http:" || parsed.protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Factory function for creating abort handlers.
+ * Defined at module level to avoid capturing closure scope.
+ */
+function createAbortHandler(ctrl, signal) {
+    return () => {
+        ctrl.abort(signal?.reason ?? new Error("Aborted"));
+    };
+}
+/**
+ * Create an AbortSignal that combines a timeout with an optional parent signal
+ */
+function createTimeoutSignal(timeoutMs, parentSignal) {
+    const controller = new AbortController();
+    // Use bind() to avoid capturing scope in timeout callback
+    const abort = controller.abort.bind(controller);
+    const timeoutId = setTimeout(() => abort(new Error(`Request timed out after ${timeoutMs}ms`)), timeoutMs);
+    // Create abort handler using factory to avoid capturing scope
+    const abortHandler = createAbortHandler(controller, parentSignal);
+    if (parentSignal) {
+        if (parentSignal.aborted) {
+            abortHandler();
+        }
+        else {
+            parentSignal.addEventListener("abort", abortHandler, { once: true });
+        }
+    }
+    return {
+        signal: controller.signal,
+        cleanup: () => {
+            clearTimeout(timeoutId);
+            if (parentSignal) {
+                parentSignal.removeEventListener("abort", abortHandler);
+            }
+        },
+    };
+}
+/**
+ * Get content type from response headers
+ */
+function getContentType(response) {
+    const header = response.headers.get("content-type") || "text/plain";
+    return header.split(";")[0].trim();
+}
+/**
+ * HTML Cleaner class using Cheerio
+ */
+class HtmlCleaner {
+    html;
+    constructor(html) {
+        this.html = html;
+    }
+    static new(html) {
+        return new HtmlCleaner(html);
+    }
+    clean(options = { simplify: true, empty: true }) {
+        const { simplify, empty } = options;
+        const $ = load(this.html);
+        this.removeUnnecessaryElements($);
+        if (simplify) {
+            this.simplifyStructure($);
+        }
+        if (empty) {
+            this.removeEmptyElements($);
+        }
+        return $.html()
+            .trim()
+            .replace(/^\s*[\r\n]/gm, "");
+    }
+    removeUnnecessaryElements($) {
+        $("script").remove();
+        $("noscript").remove();
+        $("style").remove();
+        $('link[rel="stylesheet"]').remove();
+        $('link[rel="preload"]').remove();
+        $("link").remove();
+        $("form").remove();
+        $("*")
+            .contents()
+            .each((_, element) => {
+            if (element.type === "comment") {
+                $(element).remove();
+            }
+        });
+        $("[style]").removeAttr("style");
+        $("[class]").removeAttr("class");
+        $("[id]").removeAttr("id");
+    }
+    simplifyStructure($) {
+        $("div div").each((_, element) => {
+            const $element = $(element);
+            const parent = $element.parent();
+            if (parent.children().length === 1 && parent.get(0)?.tagName === "div") {
+                $element.unwrap();
+            }
+        });
+        $("span").each((_, element) => {
+            const $element = $(element);
+            if (!$element.attr() || Object.keys($element.attr() ?? {}).length === 0) {
+                const h = $element.html();
+                if (h) {
+                    $element.replaceWith(h);
+                }
+            }
+        });
+    }
+    removeEmptyElements($) {
+        $(":empty").remove();
+    }
+}
+/**
+ * Convert HTML to Markdown
+ */
+function htmlToMarkdown(html) {
+    return html
+        .replace(/<h1>(.*?)<\/h1>/g, "# $1\n\n")
+        .replace(/<h2>(.*?)<\/h2>/g, "## $1\n\n")
+        .replace(/<h3>(.*?)<\/h3>/g, "### $1\n\n")
+        .replace(/<h4>(.*?)<\/h4>/g, "#### $1\n\n")
+        .replace(/<h5>(.*?)<\/h5>/g, "##### $1\n\n")
+        .replace(/<h6>(.*?)<\/h6>/g, "###### $1\n\n")
+        .replace(/<p>(.*?)<\/p>/g, "$1\n\n")
+        .replace(/<br\s*\/?>/g, "\n")
+        .replace(/<strong>(.*?)<\/strong>/g, "**$1**")
+        .replace(/<b>(.*?)<\/b>/g, "**$1**")
+        .replace(/<em>(.*?)<\/em>/g, "*$1*")
+        .replace(/<i>(.*?)<\/i>/g, "*$1*")
+        .replace(/<a[^>]*href="([^"]*)"[^>]*>(.*?)<\/a>/g, "[$2]($1)")
+        .replace(/<li>(.*?)<\/li>/g, "- $1\n")
+        .replace(/<ul[^>]*>/g, "\n")
+        .replace(/<\/ul>/g, "\n")
+        .replace(/<ol[^>]*>/g, "\n")
+        .replace(/<\/ol>/g, "\n")
+        .replace(/<code>(.*?)<\/code>/g, "`$1`")
+        .replace(/<pre>(.*?)<\/pre>/gs, "```\n$1\n```\n")
+        .replace(/<[^>]*>/g, "")
+        .replace(/\n\n\n+/g, "\n\n")
+        .trim();
+}
+/**
+ * Fetch using Jina AI reader
+ */
+async function fetchWithJina(url, signal) {
+    const apiKey = process.env["JINA_READER_API_KEY"];
+    if (!apiKey) {
+        throw new Error("JINA_READER_API_KEY environment variable is not set");
+    }
+    const jinaUrl = `${JINA_API_BASE}/${encodeURIComponent(url)}`;
+    const response = await fetch(jinaUrl, {
+        method: "GET",
+        headers: {
+            // biome-ignore lint/style/useNamingConvention: HTTP header names are case-sensitive
+            Authorization: `Bearer ${apiKey}`,
+            "X-With-Generated-Alt": "true",
+            "X-With-Links-Summary": "true",
+        },
+        signal,
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Jina API error: ${response.status} - ${errorText}`);
+    }
+    const content = await response.text();
+    const tokenCount = countTokens(content);
+    return {
+        content,
+        contentType: "text/html",
+        sourceUrl: url,
+        tokenCount,
+        success: true,
+        provider: "jina",
+    };
+}
+/**
+ * Handle HTML response
+ */
+async function handleHtmlResponse(response, useJina, signal, verbose = false) {
+    const html = await response.text();
+    if (useJina) {
+        try {
+            const jinaResult = await fetchWithJina(response.url, signal);
+            return jinaResult;
+        }
+        catch (error) {
+            if (verbose) {
+                console.error(`Jina AI failed: ${error instanceof Error ? error.message : String(error)}, falling back to local cleaning`);
+            }
+        }
+    }
+    const cleaner = HtmlCleaner.new(html);
+    const cleaned = cleaner.clean();
+    const tokenCount = countTokens(cleaned);
+    return {
+        content: cleaned,
+        contentType: "text/html",
+        sourceUrl: response.url,
+        tokenCount,
+        success: true,
+        provider: "local",
+    };
+}
+/**
+ * Handle image response (convert to base64 data URL)
+ */
+async function handleImageResponse(response, contentType) {
+    const arrayBuffer = await response.arrayBuffer();
+    const base64 = Buffer.from(arrayBuffer).toString("base64");
+    const base64Url = `data:${contentType};base64,${base64}`;
+    return {
+        content: base64Url,
+        contentType,
+        sourceUrl: response.url,
+        tokenCount: 0,
+        success: true,
+        provider: "direct",
+    };
+}
+/**
+ * Handle text response
+ */
+async function handleTextResponse(response, contentType) {
+    const text = await response.text();
+    const tokenCount = countTokens(text);
+    return {
+        content: text,
+        contentType,
+        sourceUrl: response.url,
+        tokenCount,
+        success: true,
+        provider: "direct",
+    };
+}
+/**
+ * Main fetch function with redirect handling
+ */
+async function fetchUrl(url, options) {
+    const { useJina = false, timeout = DEFAULT_TIMEOUT, verbose = false, headers: includeHeaders = false, abortSignal, } = options;
+    let redirectCount = 0;
+    let currentUrl = url;
+    while (redirectCount < MAX_REDIRECTS) {
+        const { signal, cleanup } = createTimeoutSignal(timeout, abortSignal);
+        try {
+            // Standard browser headers to avoid 403 errors on bot-protected sites
+            const requestHeaders = {
+                "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+                // biome-ignore lint/style/useNamingConvention: HTTP header name must match specification
+                Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
+                "Accept-Language": "en-US,en;q=0.9",
+                "Accept-Encoding": "gzip, deflate, br",
+                // biome-ignore lint/style/useNamingConvention: HTTP header name must match specification
+                Connection: "keep-alive",
+                "Upgrade-Insecure-Requests": "1",
+                "Sec-Fetch-Dest": "document",
+                "Sec-Fetch-Mode": "navigate",
+                "Sec-Fetch-Site": "none",
+                "Sec-Fetch-User": "?1",
+                "Cache-Control": "max-age=0",
+            };
+            const response = await fetch(currentUrl, {
+                signal,
+                redirect: "manual",
+                headers: requestHeaders,
+            });
+            // Handle redirects
+            if (response.status >= 300 && response.status < 400) {
+                const location = response.headers.get("location");
+                if (location) {
+                    const redirectUrl = new URL(location, currentUrl).toString();
+                    if (verbose) {
+                        console.error(`Redirecting to: ${redirectUrl}`);
+                    }
+                    currentUrl = redirectUrl;
+                    redirectCount++;
+                    continue;
+                }
+            }
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status} ${response.statusText}`);
+            }
+            const contentType = getContentType(response);
+            const responseHeaders = {};
+            if (includeHeaders) {
+                response.headers.forEach((value, key) => {
+                    responseHeaders[key] = value;
+                });
+            }
+            let result;
+            if (contentType.includes("text/html")) {
+                result = await handleHtmlResponse(response, useJina, signal, verbose);
+            }
+            else if (contentType.startsWith("image/")) {
+                result = await handleImageResponse(response, contentType);
+            }
+            else {
+                result = await handleTextResponse(response, contentType);
+            }
+            if (includeHeaders) {
+                result.headers = responseHeaders;
+            }
+            return result;
+        }
+        finally {
+            cleanup();
+        }
+    }
+    throw new Error(`Too many redirects (max: ${MAX_REDIRECTS})`);
+}
+/**
+ * Execute web fetch
+ */
+export async function executeWebFetch(options, executionOptions) {
+    const { url, output = "text", jina = false, timeout, headers = false, } = options;
+    if (executionOptions.abortSignal?.aborted) {
+        throw new Error("Web fetch aborted");
+    }
+    if (!isValidUrl(url)) {
+        throw new Error("Invalid URL format. URL must start with http:// or https:// and be less than 2048 characters");
+    }
+    const effectiveTimeout = timeout ?? DEFAULT_TIMEOUT;
+    const effectiveJina = jina ?? false;
+    const effectiveHeaders = headers ?? false;
+    let result;
+    try {
+        result = await fetchUrl(url, {
+            useJina: effectiveJina,
+            timeout: effectiveTimeout,
+            verbose: false,
+            headers: effectiveHeaders,
+            abortSignal: executionOptions.abortSignal,
+        });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Web fetch failed: ${errorMessage}`);
+    }
+    switch (output) {
+        case "json": {
+            const jsonOutput = {
+                content: result.content,
+                contentType: result.contentType,
+                sourceUrl: result.sourceUrl,
+                tokenCount: result.tokenCount,
+                success: result.success,
+                provider: result.provider,
+            };
+            if (headers && result.headers) {
+                jsonOutput["headers"] = result["headers"];
+            }
+            return JSON.stringify(jsonOutput, null, 2);
+        }
+        case "html":
+            return result.content;
+        case "markdown":
+            if (result.contentType.includes("text/html")) {
+                return htmlToMarkdown(result.content);
+            }
+            return result.content;
+        default:
+            return result.content;
+    }
+}
+/**
+ * Create the web fetch tool
+ */
+export const createWebFetchTool = async () => {
+    const toolDescription = "Fetch and extract content from a URL.";
+    return {
+        toolDef: {
+            description: toolDescription,
+            inputSchema,
+        },
+        display({ url }) {
+            return `🌐 ${style.cyan(url)}`;
+        },
+        async execute(options, executionOptions) {
+            return executeWebFetch(options, executionOptions);
+        },
+    };
+};