@oyasmi/pipiclaw 0.5.7 → 0.5.9

package/dist/tools/web-fetch.js

@@ -0,0 +1,29 @@
+import { Type } from "@sinclair/typebox";
+import { resolveWebFetchRequest } from "../web/config.js";
+import { runWebFetch } from "../web/fetch.js";
+const webFetchSchema = Type.Object({
+    label: Type.String({ description: "Brief description of what you're fetching and why (shown to user)" }),
+    url: Type.String({ description: "HTTP or HTTPS URL to fetch" }),
+    extractMode: Type.Optional(Type.Union([Type.Literal("markdown"), Type.Literal("text")], {
+        description: "Preferred text extraction format for HTML pages",
+    })),
+    maxChars: Type.Optional(Type.Number({ description: "Maximum extracted text characters to return" })),
+});
+export function createWebFetchTool(options) {
+    return {
+        name: "web_fetch",
+        label: "web_fetch",
+        description: "Fetch a public URL and extract readable content. Returns text for HTML/JSON/text pages and image content blocks for images.",
+        parameters: webFetchSchema,
+        execute: async (_toolCallId, { url, extractMode, maxChars, }, signal) => {
+            const request = resolveWebFetchRequest(options.webConfig.fetch, url, extractMode, maxChars);
+            const result = await runWebFetch({
+                webConfig: options.webConfig,
+                securityConfig: options.securityConfig,
+                workspaceDir: options.workspaceDir,
+                channelId: options.channelId,
+            }, request, signal);
+            return result;
+        },
+    };
+}

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

@@ -0,0 +1,16 @@
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+import type { SecurityConfig } from "../security/types.js";
+import type { PipiclawWebToolsConfig } from "./config.js";
+declare const webSearchSchema: import("@sinclair/typebox").TObject<{
+    label: import("@sinclair/typebox").TString;
+    query: import("@sinclair/typebox").TString;
+    count: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export interface WebSearchToolOptions {
+    webConfig: PipiclawWebToolsConfig;
+    securityConfig: SecurityConfig;
+    workspaceDir: string;
+    channelId?: string;
+}
+export declare function createWebSearchTool(options: WebSearchToolOptions): AgentTool<typeof webSearchSchema>;
+export {};

package/dist/tools/web-search.js

@@ -0,0 +1,29 @@
+import { Type } from "@sinclair/typebox";
+import { resolveWebSearchRequest } from "../web/config.js";
+import { runWebSearch } from "../web/search.js";
+const webSearchSchema = Type.Object({
+    label: Type.String({ description: "Brief description of what you're searching for and why (shown to user)" }),
+    query: Type.String({ description: "Search query" }),
+    count: Type.Optional(Type.Number({ description: "Maximum number of results to return (1-10)" })),
+});
+export function createWebSearchTool(options) {
+    return {
+        name: "web_search",
+        label: "web_search",
+        description: "Search the public web and return titles, URLs, and snippets from the configured provider.",
+        parameters: webSearchSchema,
+        execute: async (_toolCallId, { query, count }, signal) => {
+            const request = resolveWebSearchRequest(options.webConfig.search, query, count);
+            const result = await runWebSearch({
+                webConfig: options.webConfig,
+                securityConfig: options.securityConfig,
+                workspaceDir: options.workspaceDir,
+                channelId: options.channelId,
+            }, request.query, request.count, signal);
+            return {
+                content: [{ type: "text", text: result.content }],
+                details: result.details,
+            };
+        },
+    };
+}

package/dist/tools/write-content.js

@@ -1,9 +1,10 @@
+import { dirname } from "node:path";
 import { DEFAULT_SECURITY_CONFIG } from "../security/config.js";
 import { logSecurityEvent } from "../security/logger.js";
 import { guardPath } from "../security/path-guard.js";
-import { shellEscape } from "../shared/shell-escape.js";
+import { shellEscapePath } from "../shared/shell-escape.js";
 function getDir(path) {
-    return path.includes("/") ? path.substring(0, path.lastIndexOf("/")) : ".";
+    return dirname(path);
 }
 function ensureSuccess(result, path) {
     if (result.code !== 0) {
@@ -41,8 +42,8 @@ export async function writeContent(executor, path, content, signal, options) {
             throw new Error(lines.join("\n"));
         }
     }
-    const dirPrefix = createParentDir ? `mkdir -p ${shellEscape(getDir(path))} && ` : "";
-    const result = await executor.exec(`${dirPrefix}cat > ${shellEscape(path)}`, {
+    const dirPrefix = createParentDir ? `mkdir -p ${shellEscapePath(getDir(path))} && ` : "";
+    const result = await executor.exec(`${dirPrefix}cat > ${shellEscapePath(path)}`, {
         signal,
         stdin: content,
     });

package/dist/web/client.d.ts

@@ -0,0 +1,40 @@
+import { Buffer } from "node:buffer";
+import type { SecurityConfig } from "../security/types.js";
+import type { PipiclawWebToolsConfig } from "../tools/config.js";
+export declare const WEB_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_7_2) AppleWebKit/537.36 (KHTML, like Gecko) Pipiclaw/0.5";
+export interface WebRuntimeContext {
+    webConfig: PipiclawWebToolsConfig;
+    securityConfig: SecurityConfig;
+    workspaceDir: string;
+    channelId?: string;
+}
+export interface WebHttpResponse {
+    status: number;
+    finalUrl: string;
+    headers: Record<string, string>;
+    body: Buffer;
+}
+export interface WebHttpRequestOptions {
+    method?: "GET" | "POST";
+    url: string;
+    headers?: Record<string, string>;
+    params?: Record<string, string | number | boolean | undefined>;
+    data?: unknown;
+    timeoutMs: number;
+    signal?: AbortSignal;
+    maxRedirects?: number;
+}
+export declare class WebHttpClient {
+    private readonly context;
+    constructor(context: WebRuntimeContext);
+    request(options: WebHttpRequestOptions): Promise<WebHttpResponse>;
+    requestJson<T>(options: WebHttpRequestOptions): Promise<{
+        response: WebHttpResponse;
+        data: T;
+    }>;
+    requestText(options: WebHttpRequestOptions): Promise<{
+        response: WebHttpResponse;
+        text: string;
+    }>;
+}
+export declare function createWebHttpClient(context: WebRuntimeContext): WebHttpClient;

package/dist/web/client.js

@@ -0,0 +1,181 @@
+import { Buffer } from "node:buffer";
+import axios from "axios";
+import { HttpProxyAgent } from "http-proxy-agent";
+import { HttpsProxyAgent } from "https-proxy-agent";
+import { getProxyForUrl } from "proxy-from-env";
+import { SocksProxyAgent } from "socks-proxy-agent";
+import { logSecurityEvent } from "../security/logger.js";
+import { NetworkGuardError, validateNetworkTarget, validateRedirectTarget } from "../security/network.js";
+export const WEB_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_7_2) AppleWebKit/537.36 (KHTML, like Gecko) Pipiclaw/0.5";
+const agentCache = new Map();
+function normalizeHeaders(headers) {
+    if (!headers || typeof headers !== "object") {
+        return {};
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (typeof value === "string") {
+            result[key.toLowerCase()] = value;
+        }
+        else if (Array.isArray(value)) {
+            result[key.toLowerCase()] = value.join(", ");
+        }
+        else if (value !== undefined && value !== null) {
+            result[key.toLowerCase()] = String(value);
+        }
+    }
+    return result;
+}
+function buildUrlWithParams(url, params) {
+    if (!params) {
+        return url;
+    }
+    const resolved = new URL(url);
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined) {
+            continue;
+        }
+        resolved.searchParams.set(key, String(value));
+    }
+    return resolved.toString();
+}
+function getProxyAgent(requestUrl, explicitProxy) {
+    const proxyUrl = explicitProxy?.trim() || getProxyForUrl(requestUrl);
+    if (!proxyUrl) {
+        return undefined;
+    }
+    const requestProtocol = new URL(requestUrl).protocol;
+    const proxyProtocol = new URL(proxyUrl).protocol;
+    const cacheKey = `${requestProtocol}|${proxyUrl}`;
+    const cached = agentCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    let agent;
+    if (proxyProtocol.startsWith("socks")) {
+        agent = new SocksProxyAgent(proxyUrl);
+    }
+    else if (requestProtocol === "https:") {
+        agent = new HttpsProxyAgent(proxyUrl);
+    }
+    else {
+        agent = new HttpProxyAgent(proxyUrl);
+    }
+    agentCache.set(cacheKey, agent);
+    return agent;
+}
+function logBlockedRequest(context, error) {
+    logSecurityEvent(context.workspaceDir, context.securityConfig, {
+        type: "network",
+        tool: "web",
+        channelId: context.channelId,
+        url: error.url,
+        stage: error.stage,
+        resolvedHost: error.resolvedHost,
+        resolvedAddress: error.resolvedAddress,
+        category: error.category,
+        reason: error.message,
+    });
+}
+function decodeBody(body) {
+    return new TextDecoder("utf-8", { fatal: false }).decode(body);
+}
+function isRedirectStatus(status) {
+    return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
+}
+export class WebHttpClient {
+    constructor(context) {
+        this.context = context;
+    }
+    async request(options) {
+        const maxRedirects = options.maxRedirects ?? this.context.securityConfig.networkGuard.maxRedirects;
+        let currentUrl = buildUrlWithParams(options.url, options.params);
+        let method = options.method ?? "GET";
+        let data = options.data;
+        for (let redirectCount = 0; redirectCount <= maxRedirects; redirectCount++) {
+            try {
+                if (redirectCount === 0) {
+                    await validateNetworkTarget(currentUrl, { config: this.context.securityConfig });
+                }
+                else {
+                    await validateRedirectTarget(currentUrl, { config: this.context.securityConfig });
+                }
+            }
+            catch (error) {
+                if (error instanceof NetworkGuardError) {
+                    logBlockedRequest(this.context, error);
+                }
+                throw error;
+            }
+            const agent = getProxyAgent(currentUrl, this.context.webConfig.proxy);
+            const response = await axios.request({
+                method,
+                url: currentUrl,
+                data,
+                headers: {
+                    "User-Agent": WEB_USER_AGENT,
+                    Accept: "*/*",
+                    ...options.headers,
+                },
+                responseType: "arraybuffer",
+                validateStatus: () => true,
+                timeout: options.timeoutMs,
+                signal: options.signal,
+                maxRedirects: 0,
+                proxy: false,
+                httpAgent: agent,
+                httpsAgent: agent,
+            });
+            const headers = normalizeHeaders(response.headers);
+            const body = Buffer.isBuffer(response.data) ? response.data : Buffer.from(response.data);
+            if (isRedirectStatus(response.status) && headers.location) {
+                if (redirectCount === maxRedirects) {
+                    throw new Error(`Too many redirects while fetching ${options.url}`);
+                }
+                currentUrl = new URL(headers.location, currentUrl).toString();
+                if (response.status === 303 ||
+                    ((response.status === 301 || response.status === 302) && method === "POST")) {
+                    method = "GET";
+                    data = undefined;
+                }
+                continue;
+            }
+            return {
+                status: response.status,
+                finalUrl: currentUrl,
+                headers,
+                body,
+            };
+        }
+        throw new Error(`Too many redirects while fetching ${options.url}`);
+    }
+    async requestJson(options) {
+        const response = await this.request({
+            ...options,
+            headers: {
+                Accept: "application/json",
+                ...options.headers,
+            },
+        });
+        const text = decodeBody(response.body);
+        try {
+            return {
+                response,
+                data: JSON.parse(text),
+            };
+        }
+        catch (error) {
+            throw new Error(`Expected JSON response from ${options.url}, got invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async requestText(options) {
+        const response = await this.request(options);
+        return {
+            response,
+            text: decodeBody(response.body),
+        };
+    }
+}
+export function createWebHttpClient(context) {
+    return new WebHttpClient(context);
+}

package/dist/web/config.d.ts

@@ -0,0 +1,18 @@
+import type { PipiclawWebFetchConfig, PipiclawWebSearchConfig, PipiclawWebToolsConfig } from "../tools/config.js";
+export interface ResolvedWebSearchRequest {
+    query: string;
+    count: number;
+    timeoutMs: number;
+}
+export interface ResolvedWebFetchRequest {
+    url: string;
+    extractMode: "markdown" | "text";
+    maxChars: number;
+    timeoutMs: number;
+    maxImageBytes: number;
+    preferJina: boolean;
+    enableJinaFallback: boolean;
+}
+export declare function resolveWebSearchRequest(config: PipiclawWebSearchConfig, query: string, count?: number): ResolvedWebSearchRequest;
+export declare function resolveWebFetchRequest(config: PipiclawWebFetchConfig, url: string, extractMode?: "markdown" | "text", maxChars?: number): ResolvedWebFetchRequest;
+export declare function isWebToolsEnabled(config: PipiclawWebToolsConfig): boolean;

package/dist/web/config.js

@@ -0,0 +1,34 @@
+export function resolveWebSearchRequest(config, query, count) {
+    return {
+        query: query.trim(),
+        count: clamp(count, config.maxResults, 1, 10),
+        timeoutMs: config.timeoutMs,
+    };
+}
+export function resolveWebFetchRequest(config, url, extractMode, maxChars) {
+    return {
+        url: url.trim(),
+        extractMode: extractMode === "text" ? "text" : extractMode === "markdown" ? "markdown" : config.defaultExtractMode,
+        maxChars: clamp(maxChars, config.maxChars, 100),
+        timeoutMs: config.timeoutMs,
+        maxImageBytes: config.maxImageBytes,
+        preferJina: config.preferJina,
+        enableJinaFallback: config.enableJinaFallback,
+    };
+}
+export function isWebToolsEnabled(config) {
+    return config.enable !== false;
+}
+function clamp(value, fallback, minimum, maximum) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return fallback;
+    }
+    const normalized = Math.floor(value);
+    if (normalized < minimum) {
+        return fallback;
+    }
+    if (maximum !== undefined && normalized > maximum) {
+        return fallback;
+    }
+    return normalized;
+}

package/dist/web/extract.d.ts

@@ -0,0 +1,7 @@
+export declare function htmlToText(html: string): string;
+export declare function htmlToMarkdown(html: string): string;
+export declare function extractReadableContent(html: string, url: string, extractMode: "markdown" | "text"): {
+    title: string;
+    content: string;
+    extractor: string;
+};

package/dist/web/extract.js

@@ -0,0 +1,122 @@
+import { Readability } from "@mozilla/readability";
+import { JSDOM, VirtualConsole } from "jsdom";
+const ELEMENT_NODE = 1;
+const TEXT_NODE = 3;
+function createSilentVirtualConsole() {
+    const virtualConsole = new VirtualConsole();
+    virtualConsole.on("jsdomError", (_error) => {
+        // Ignore parser noise such as malformed inline CSS. These pages are still
+        // often readable enough for Readability / text extraction, and forwarding
+        // jsdom's internal parse warnings pollutes Pipiclaw runtime logs.
+    });
+    return virtualConsole;
+}
+function createDom(html, url) {
+    const options = {
+        virtualConsole: createSilentVirtualConsole(),
+        ...(url ? { url } : {}),
+    };
+    return new JSDOM(html, options);
+}
+function normalizeWhitespace(value) {
+    return value
+        .replace(/\r\n/g, "\n")
+        .replace(/[ \t]+\n/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+function escapeMarkdown(value) {
+    return value.replace(/([\\`*_{}[\]()#+.!>-])/g, "\\$1");
+}
+function renderNode(node) {
+    const domNode = node;
+    if (domNode.nodeType === TEXT_NODE) {
+        return escapeMarkdown(domNode.textContent ?? "");
+    }
+    if (domNode.nodeType !== ELEMENT_NODE) {
+        return "";
+    }
+    const element = node;
+    const children = Array.from(element.childNodes ?? [])
+        .map(renderNode)
+        .join("")
+        .trim();
+    const tag = element.tagName.toLowerCase();
+    switch (tag) {
+        case "h1":
+            return `# ${children}\n\n`;
+        case "h2":
+            return `## ${children}\n\n`;
+        case "h3":
+            return `### ${children}\n\n`;
+        case "h4":
+            return `#### ${children}\n\n`;
+        case "h5":
+            return `##### ${children}\n\n`;
+        case "h6":
+            return `###### ${children}\n\n`;
+        case "p":
+            return `${children}\n\n`;
+        case "br":
+            return "\n";
+        case "strong":
+        case "b":
+            return `**${children}**`;
+        case "em":
+        case "i":
+            return `*${children}*`;
+        case "code":
+            return `\`${children}\``;
+        case "pre":
+            return `\`\`\`\n${element.textContent?.trim() ?? ""}\n\`\`\`\n\n`;
+        case "blockquote":
+            return `${children
+                .split("\n")
+                .map((line) => (line.trim() ? `> ${line}` : ">"))
+                .join("\n")}\n\n`;
+        case "ul":
+            return `${Array.from(element.children ?? [])
+                .map((child) => `- ${renderNode(child).trim()}`)
+                .join("\n")}\n\n`;
+        case "ol":
+            return `${Array.from(element.children ?? [])
+                .map((child, index) => `${index + 1}. ${renderNode(child).trim()}`)
+                .join("\n")}\n\n`;
+        case "li":
+            return children;
+        case "a": {
+            const href = element.getAttribute("href");
+            return href ? `[${children || href}](${href})` : children;
+        }
+        default:
+            return children ? `${children}${["div", "section", "article"].includes(tag) ? "\n\n" : ""}` : "";
+    }
+}
+export function htmlToText(html) {
+    const dom = createDom(html);
+    return normalizeWhitespace(dom.window.document.body.textContent ?? "");
+}
+export function htmlToMarkdown(html) {
+    const dom = createDom(html);
+    const body = dom.window.document.body;
+    return normalizeWhitespace(Array.from(body.childNodes).map(renderNode).join(""));
+}
+export function extractReadableContent(html, url, extractMode) {
+    const dom = createDom(html, url);
+    const article = new Readability(dom.window.document).parse();
+    if (!article) {
+        const fallbackContent = extractMode === "text" ? htmlToText(html) : htmlToMarkdown(html);
+        return {
+            title: dom.window.document.title?.trim() ?? "",
+            content: fallbackContent,
+            extractor: extractMode === "text" ? "html-text" : "html-markdown",
+        };
+    }
+    const articleContent = article.content ?? "";
+    const content = extractMode === "text" ? htmlToText(articleContent) : htmlToMarkdown(articleContent);
+    return {
+        title: article.title?.trim() ?? "",
+        content,
+        extractor: extractMode === "text" ? "readability-text" : "readability-markdown",
+    };
+}

package/dist/web/fetch.d.ts

@@ -0,0 +1,22 @@
+import type { ImageContent, TextContent } from "@mariozechner/pi-ai";
+import type { SecurityConfig } from "../security/types.js";
+import type { PipiclawWebToolsConfig } from "../tools/config.js";
+import { type FormattedFetchDetails } from "./format.js";
+export interface WebFetchExecutionContext {
+    webConfig: PipiclawWebToolsConfig;
+    securityConfig: SecurityConfig;
+    workspaceDir: string;
+    channelId?: string;
+}
+export interface WebFetchOutput {
+    content: Array<TextContent | ImageContent>;
+    details: FormattedFetchDetails;
+}
+export declare function runWebFetch(context: WebFetchExecutionContext, request: {
+    url: string;
+    extractMode: "markdown" | "text";
+    maxChars: number;
+    maxImageBytes: number;
+    preferJina: boolean;
+    enableJinaFallback: boolean;
+}, signal?: AbortSignal): Promise<WebFetchOutput>;

package/dist/web/fetch.js

@@ -0,0 +1,148 @@
+import { createWebHttpClient } from "./client.js";
+import { extractReadableContent } from "./extract.js";
+import { buildFetchedImageContent, buildFetchedTextContent } from "./format.js";
+function trimToMaxChars(text, maxChars) {
+    if (text.length <= maxChars) {
+        return { text, truncated: false };
+    }
+    return {
+        text: text.slice(0, maxChars),
+        truncated: true,
+    };
+}
+function decodeUtf8(body) {
+    return new TextDecoder("utf-8", { fatal: false }).decode(body);
+}
+function isHtmlContent(contentType, body) {
+    if (contentType.includes("text/html")) {
+        return true;
+    }
+    const head = decodeUtf8(body.subarray(0, Math.min(body.length, 256)))
+        .trimStart()
+        .toLowerCase();
+    return head.startsWith("<!doctype") || head.startsWith("<html");
+}
+async function tryFetchViaJina(context, url, maxChars, signal) {
+    const client = createWebHttpClient({
+        webConfig: context.webConfig,
+        securityConfig: context.securityConfig,
+        workspaceDir: context.workspaceDir,
+        channelId: context.channelId,
+    });
+    const headers = { Accept: "application/json" };
+    if (context.webConfig.search.apiKey && context.webConfig.search.provider === "jina") {
+        headers.Authorization = `Bearer ${context.webConfig.search.apiKey}`;
+    }
+    const { response, data } = await client.requestJson({
+        url: `https://r.jina.ai/${url}`,
+        headers,
+        timeoutMs: context.webConfig.fetch.timeoutMs,
+        signal,
+    });
+    if (response.status < 200 || response.status >= 300 || !data.data?.content) {
+        return null;
+    }
+    const title = data.data.title?.trim();
+    const body = title ? `# ${title}\n\n${data.data.content}` : data.data.content;
+    const trimmed = trimToMaxChars(body, maxChars);
+    return {
+        content: buildFetchedTextContent(trimmed.text),
+        details: {
+            url,
+            finalUrl: data.data.url?.trim() || response.finalUrl,
+            status: response.status,
+            extractor: "jina",
+            truncated: trimmed.truncated,
+            length: trimmed.text.length,
+            untrusted: true,
+            contentType: "text/markdown",
+        },
+    };
+}
+async function fetchDirect(context, url, extractMode, maxChars, maxImageBytes, signal) {
+    const client = createWebHttpClient({
+        webConfig: context.webConfig,
+        securityConfig: context.securityConfig,
+        workspaceDir: context.workspaceDir,
+        channelId: context.channelId,
+    });
+    const response = await client.request({
+        url,
+        timeoutMs: context.webConfig.fetch.timeoutMs,
+        signal,
+    });
+    if (response.status < 200 || response.status >= 300) {
+        throw new Error(`Failed to fetch ${url}: HTTP ${response.status}`);
+    }
+    const contentType = response.headers["content-type"]?.toLowerCase() ?? "application/octet-stream";
+    if (contentType.startsWith("image/")) {
+        if (response.body.length > maxImageBytes) {
+            throw new Error(`Fetched image exceeds maxImageBytes (${maxImageBytes} bytes)`);
+        }
+        return {
+            content: buildFetchedImageContent(response.body.toString("base64"), contentType.split(";")[0], response.finalUrl),
+            details: {
+                url,
+                finalUrl: response.finalUrl,
+                status: response.status,
+                extractor: "direct-image",
+                truncated: false,
+                length: response.body.length,
+                untrusted: true,
+                contentType,
+            },
+        };
+    }
+    let text = "";
+    let extractor = "raw";
+    if (contentType.includes("application/json")) {
+        const parsed = JSON.parse(decodeUtf8(response.body));
+        text = JSON.stringify(parsed, null, 2);
+        extractor = "json";
+    }
+    else if (isHtmlContent(contentType, response.body)) {
+        const html = decodeUtf8(response.body);
+        const article = extractReadableContent(html, response.finalUrl, extractMode);
+        text = article.title ? `# ${article.title}\n\n${article.content}` : article.content;
+        extractor = article.extractor;
+    }
+    else {
+        text = decodeUtf8(response.body);
+        extractor = "text";
+    }
+    const trimmed = trimToMaxChars(text.trim(), maxChars);
+    return {
+        content: buildFetchedTextContent(trimmed.text),
+        details: {
+            url,
+            finalUrl: response.finalUrl,
+            status: response.status,
+            extractor,
+            truncated: trimmed.truncated,
+            length: trimmed.text.length,
+            untrusted: true,
+            contentType,
+        },
+    };
+}
+export async function runWebFetch(context, request, signal) {
+    if (request.preferJina) {
+        const jinaResult = await tryFetchViaJina(context, request.url, request.maxChars, signal);
+        if (jinaResult) {
+            return jinaResult;
+        }
+    }
+    try {
+        return await fetchDirect(context, request.url, request.extractMode, request.maxChars, request.maxImageBytes, signal);
+    }
+    catch (error) {
+        if (!request.enableJinaFallback) {
+            throw error;
+        }
+        const jinaResult = await tryFetchViaJina(context, request.url, request.maxChars, signal);
+        if (jinaResult) {
+            return jinaResult;
+        }
+        throw error;
+    }
+}