webcrawl 1.2.4 → 1.2.7

package/dist/core/local-engine.js

@@ -0,0 +1,367 @@
+/**
+ * Zero-key Local Execution Engine for Webcrawl Anything.
+ *
+ * Implements the exact same method surface as `WebcrawlClient` (`search`, `scrape`,
+ * `parse`, `map`, `crawl`, `extract`, `rerank`, `categories`, `targets`) in-process
+ * using the shared `src/engine/`, `src/search/`, `src/parse/`, `src/extract/`,
+ * `src/ranker/`, and `src/targets/` pipeline.
+ *
+ * Every community improvement to extractors, parsers, or targets in `src/` immediately
+ * powers both this local engine (`npx webcrawl`) and the hosted `webcrawl.app` API.
+ */
+import { extractWebsiteData, fastHtmlToMarkdown, fetchWithTlsImpersonation, getCachedPageAsync, mapWebsiteUrls, setCachedPage, sha256, } from "./engine.js";
+import { fetchResource } from "./engine/fetcher.js";
+import { parseFile, publicParseMeta } from "./parse/index.js";
+import { isBinaryContentType, looksLikeBinaryUrl } from "./parse/fetch.js";
+import { maxDownloadBytes } from "./parse/limits.js";
+import { parseYouTubeCached, youtubeVideoId } from "./parse/youtube.js";
+import { rankDocuments } from "./ranker.js";
+import { getSearchCategoriesCatalog, searchWeb } from "./search.js";
+import { inspectTarget, listTargets, resolveTarget } from "./targets.js";
+export function createLocalEngineClient() {
+    return {
+        baseUrl: "local://engine",
+        async search(p) {
+            const query = String(p.query ?? "").trim();
+            const category = typeof p.category === "string" ? p.category : undefined;
+            const subcategory = typeof p.subcategory === "string" ? p.subcategory : undefined;
+            const limit = typeof p.limit === "number" ? p.limit : 5;
+            const country = typeof p.country === "string" ? p.country : undefined;
+            const city = typeof p.city === "string" ? p.city : undefined;
+            const sites = Array.isArray(p.sites) ? p.sites.map(String) : undefined;
+            const scrapeContent = Boolean(p.scrapeContent);
+            const res = await searchWeb({
+                query,
+                category: category,
+                subcategory,
+                limit,
+                country,
+                city,
+                filters: sites?.length ? { sites } : undefined,
+                scrapeOptions: scrapeContent ? { formats: ["markdown"] } : undefined,
+            });
+            const resolved = resolveTarget({ query, category });
+            return {
+                ...res,
+                success: true,
+                mode: "local",
+                target: {
+                    id: resolved.plugin.id,
+                    name: resolved.plugin.name,
+                    confidence: resolved.match.confidence,
+                },
+            };
+        },
+        async scrape(p) {
+            const targetUrl = /^https?:\/\//i.test(p.url) ? p.url : `https://${p.url}`;
+            const start = Date.now();
+            // 1. Check if YouTube URL
+            if (youtubeVideoId(targetUrl)) {
+                const yt = await parseYouTubeCached(targetUrl, { bypassCache: p.noCache });
+                return {
+                    success: true,
+                    mode: "local",
+                    url: targetUrl,
+                    title: yt.title,
+                    markdown: yt.markdown,
+                    data: {
+                        url: targetUrl,
+                        title: yt.title,
+                        markdown: yt.markdown,
+                        metadata: { parse: publicParseMeta(yt) },
+                    },
+                    evidence: {
+                        targetId: "youtube-media",
+                        tier: "native-parser",
+                        contentHash: yt.contentHash,
+                        latencyMs: Date.now() - start,
+                        sourceUrl: targetUrl,
+                        matchedSignals: ["youtube:captions"],
+                        limitations: yt.meta.warnings,
+                    },
+                };
+            }
+            // 2. Check if binary document URL (PDF, DOCX, XLSX, PPTX)
+            if (looksLikeBinaryUrl(targetUrl)) {
+                const fetched = await fetchResource(targetUrl, { maxBytes: maxDownloadBytes() });
+                if (isBinaryContentType(fetched.contentType) || looksLikeBinaryUrl(fetched.url)) {
+                    const parsed = await parseFile({ bytes: fetched.body, contentType: fetched.contentType, fileName: fetched.url }, { bypassCache: p.noCache });
+                    return {
+                        success: true,
+                        mode: "local",
+                        url: fetched.url,
+                        title: parsed.title,
+                        markdown: parsed.markdown,
+                        data: {
+                            url: fetched.url,
+                            title: parsed.title,
+                            markdown: parsed.markdown,
+                            metadata: { parse: publicParseMeta(parsed) },
+                        },
+                        evidence: {
+                            targetId: "pdf-office",
+                            tier: parsed.meta.method === "ocr" ? "ocr" : "native-parser",
+                            contentHash: parsed.contentHash,
+                            latencyMs: Date.now() - start,
+                            sourceUrl: fetched.url,
+                            matchedSignals: [`parse:${parsed.meta.kind}:${parsed.meta.method}`],
+                            limitations: parsed.meta.warnings,
+                        },
+                    };
+                }
+            }
+            // 3. Check local cache first
+            if (!p.noCache) {
+                const cached = await getCachedPageAsync(targetUrl, "none");
+                if (cached) {
+                    const targetInspection = await inspectTarget({
+                        url: targetUrl,
+                        markdown: cached.markdown,
+                    });
+                    return {
+                        success: true,
+                        mode: "local",
+                        url: targetUrl,
+                        title: cached.title,
+                        markdown: cached.markdown,
+                        links: cached.links,
+                        cached: true,
+                        data: {
+                            url: targetUrl,
+                            title: cached.title,
+                            markdown: cached.markdown,
+                            links: cached.links,
+                            structured: targetInspection.structured,
+                        },
+                        evidence: {
+                            ...targetInspection.evidence,
+                            tier: "cache",
+                            contentHash: cached.contentHash,
+                            latencyMs: Date.now() - start,
+                        },
+                    };
+                }
+            }
+            // 4. Fetch with TLS impersonation (impit) + target-aware extraction
+            const fetched = await fetchWithTlsImpersonation(targetUrl);
+            const { title, markdown, links } = fastHtmlToMarkdown(fetched.html, targetUrl);
+            const contentHash = sha256(markdown || fetched.html);
+            setCachedPage(targetUrl, "none", {
+                title,
+                markdown,
+                links,
+                statusCode: fetched.status,
+                contentHash,
+            });
+            const targetInspection = await inspectTarget({
+                url: targetUrl,
+                html: fetched.html,
+                markdown,
+            });
+            return {
+                success: true,
+                mode: "local",
+                url: targetUrl,
+                title: title || targetInspection.title || targetUrl,
+                markdown: targetInspection.markdown || markdown,
+                links,
+                data: {
+                    url: targetUrl,
+                    title: title || targetInspection.title || targetUrl,
+                    markdown: targetInspection.markdown || markdown,
+                    links,
+                    structured: targetInspection.structured,
+                },
+                evidence: {
+                    ...targetInspection.evidence,
+                    tier: "impit-tls",
+                    contentHash,
+                    latencyMs: Date.now() - start,
+                },
+            };
+        },
+        async parse(p) {
+            const url = typeof p.url === "string" ? p.url : undefined;
+            if (url && youtubeVideoId(url)) {
+                const yt = await parseYouTubeCached(url, {
+                    language: typeof p.language === "string" ? p.language : undefined,
+                    bypassCache: Boolean(p.noCache),
+                });
+                return {
+                    success: true,
+                    mode: "local",
+                    title: yt.title,
+                    markdown: yt.markdown,
+                    metadata: { parse: publicParseMeta(yt) },
+                };
+            }
+            let bytes = p.bytes instanceof Uint8Array ? p.bytes : undefined;
+            let contentType = typeof p.contentType === "string" ? p.contentType : undefined;
+            let fileName = typeof p.fileName === "string" ? p.fileName : url;
+            if (!bytes && typeof p.base64 === "string") {
+                bytes = new Uint8Array(Buffer.from(p.base64, "base64"));
+            }
+            if (!bytes && url) {
+                const fetched = await fetchResource(url, { maxBytes: maxDownloadBytes() });
+                bytes = fetched.body;
+                contentType = contentType ?? fetched.contentType;
+                fileName = fileName ?? fetched.url;
+            }
+            if (!bytes) {
+                throw new Error("parse requires `url`, `bytes`, or `base64`");
+            }
+            const parsed = await parseFile({ bytes, contentType, fileName }, {
+                ocr: p.ocr ?? "auto",
+                pages: Array.isArray(p.pages) ? p.pages.map(Number) : undefined,
+                language: typeof p.language === "string" ? p.language : undefined,
+                bypassCache: Boolean(p.noCache),
+            });
+            return {
+                success: true,
+                mode: "local",
+                title: parsed.title,
+                markdown: parsed.markdown,
+                metadata: { parse: publicParseMeta(parsed) },
+            };
+        },
+        async run(id) {
+            return {
+                success: false,
+                mode: "local",
+                id,
+                status: "not_found",
+                error: "Background runs require cloud mode (`webcrawl login` or WEBCRAWL_API_KEY).",
+            };
+        },
+        async map(p) {
+            const targetUrl = /^https?:\/\//i.test(p.url) ? p.url : `https://${p.url}`;
+            const mapped = await mapWebsiteUrls(targetUrl, {
+                limit: p.limit ?? 100,
+            });
+            const needle = p.search?.trim().toLowerCase();
+            const links = needle
+                ? mapped.links.filter((l) => l.toLowerCase().includes(needle))
+                : mapped.links;
+            return {
+                success: true,
+                mode: "local",
+                url: targetUrl,
+                links,
+                source: mapped.source,
+                total: links.length,
+            };
+        },
+        async crawl(p) {
+            const targetUrl = /^https?:\/\//i.test(p.url) ? p.url : `https://${p.url}`;
+            const maxPages = Math.min(25, Math.max(1, p.maxPages ?? 5));
+            const mapped = await mapWebsiteUrls(targetUrl, { limit: maxPages * 3 });
+            const urls = Array.from(new Set([targetUrl, ...mapped.links])).slice(0, maxPages);
+            const pages = [];
+            for (const u of urls) {
+                try {
+                    const scraped = await this.scrape({ url: u });
+                    pages.push({
+                        url: scraped.url ?? u,
+                        title: scraped.title ?? u,
+                        markdown: scraped.markdown ?? "",
+                        evidence: scraped.evidence,
+                    });
+                }
+                catch {
+                    // continue crawling remaining pages
+                }
+            }
+            return {
+                success: true,
+                mode: "local",
+                url: targetUrl,
+                total: pages.length,
+                data: pages,
+                pages,
+            };
+        },
+        async extract(p) {
+            const targetUrl = /^https?:\/\//i.test(p.url) ? p.url : `https://${p.url}`;
+            const fetched = await fetchWithTlsImpersonation(targetUrl);
+            const targetInspection = await inspectTarget({
+                url: targetUrl,
+                html: fetched.html,
+            });
+            const siteData = await extractWebsiteData(targetUrl);
+            return {
+                success: true,
+                mode: "local",
+                url: targetUrl,
+                data: {
+                    ...siteData,
+                    ...(targetInspection.structured ? { target: targetInspection.structured } : {}),
+                },
+                evidence: targetInspection.evidence,
+            };
+        },
+        async rerank(p) {
+            const candidates = p.documents.map((doc, idx) => {
+                if (typeof doc === "string") {
+                    return {
+                        url: `doc://${idx + 1}`,
+                        title: doc.slice(0, 80),
+                        description: doc,
+                        markdown: doc,
+                        sourceEngine: "direct",
+                    };
+                }
+                const text = String(doc.text ?? doc.description ?? doc.markdown ?? doc.title ?? "");
+                return {
+                    url: String(doc.url ?? `doc://${idx + 1}`),
+                    title: String(doc.title ?? text.slice(0, 80)),
+                    description: text,
+                    markdown: text,
+                    sourceEngine: "direct",
+                };
+            });
+            const ranked = await rankDocuments(p.query, candidates, {
+                topK: p.topK ?? candidates.length,
+            });
+            return {
+                success: true,
+                mode: "local",
+                results: ranked.results.map((r) => ({
+                    url: r.url,
+                    title: r.title,
+                    description: r.description,
+                    score: r.score,
+                    scoreBreakdown: r.scoreBreakdown,
+                })),
+            };
+        },
+        async categories() {
+            return {
+                success: true,
+                mode: "local",
+                ...getSearchCategoriesCatalog(),
+            };
+        },
+        async targets() {
+            return {
+                success: true,
+                mode: "local",
+                targets: listTargets().map((t) => ({
+                    id: t.id,
+                    name: t.name,
+                    category: t.category,
+                    returns: t.returns,
+                    requirements: t.requirements,
+                    examples: t.examples,
+                })),
+            };
+        },
+        async usage() {
+            return {
+                success: true,
+                mode: "local",
+                plan: "open-source-local",
+                note: "Running locally with zero API key. Set WEBCRAWL_API_KEY or run `webcrawl login` to use webcrawl.app cloud stealth browsers and global cache.",
+            };
+        },
+    };
+}

package/dist/core/parse/detect.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Works out what kind of file a response or upload is, from magic bytes first,
+ * then the declared content type, then the file extension.
+ */
+export type FileKind = "pdf" | "docx" | "xlsx" | "pptx" | "image" | "audio" | "video" | "html" | "text";
+/** Kinds that go through the file parser instead of the HTML pipeline. */
+export declare const BINARY_KINDS: ReadonlySet<FileKind>;
+/** Content type to send to providers when the declared one is missing or generic. */
+export declare const KIND_DEFAULT_MIME: Partial<Record<FileKind, string>>;
+/** Returns the kind and a concrete mime from the first bytes, or null when unknown. */
+export declare function sniffMagic(bytes: Uint8Array): {
+    kind: FileKind;
+    mime: string;
+} | null;
+export interface DetectInput {
+    bytes?: Uint8Array;
+    contentType?: string;
+    fileName?: string;
+}
+export interface DetectedFile {
+    kind: FileKind;
+    /** Best concrete mime for the bytes (used when calling providers). */
+    mime: string;
+}
+/**
+ * Magic bytes win over the declared type (servers often send PDFs as
+ * octet-stream or text/html); then the declared type; then the extension.
+ */
+export declare function detectFileKind({ bytes, contentType, fileName }: DetectInput): DetectedFile;

package/dist/core/parse/detect.js

@@ -0,0 +1,152 @@
+/**
+ * Works out what kind of file a response or upload is, from magic bytes first,
+ * then the declared content type, then the file extension.
+ */
+/** Kinds that go through the file parser instead of the HTML pipeline. */
+export const BINARY_KINDS = new Set(["pdf", "docx", "xlsx", "pptx", "image", "audio", "video"]);
+const MIME_KINDS = [
+    [/^application\/pdf$/, "pdf"],
+    [/^application\/vnd\.openxmlformats-officedocument\.wordprocessingml/, "docx"],
+    [/^application\/vnd\.openxmlformats-officedocument\.spreadsheetml/, "xlsx"],
+    [/^application\/vnd\.openxmlformats-officedocument\.presentationml/, "pptx"],
+    [/^image\/svg\+xml$/, "text"],
+    [/^image\//, "image"],
+    [/^audio\//, "audio"],
+    [/^video\//, "video"],
+    [/^(text\/html|application\/xhtml\+xml)$/, "html"],
+    [/^(text\/|application\/(json|xml|csv|x-ndjson|ld\+json|rss\+xml|atom\+xml|javascript))/, "text"],
+];
+const EXT_KINDS = {
+    pdf: "pdf",
+    docx: "docx",
+    xlsx: "xlsx",
+    pptx: "pptx",
+    png: "image",
+    jpg: "image",
+    jpeg: "image",
+    webp: "image",
+    gif: "image",
+    heic: "image",
+    mp3: "audio",
+    wav: "audio",
+    m4a: "audio",
+    ogg: "audio",
+    oga: "audio",
+    flac: "audio",
+    opus: "audio",
+    aac: "audio",
+    mp4: "video",
+    m4v: "video",
+    mov: "video",
+    webm: "video",
+    mkv: "video",
+    html: "html",
+    htm: "html",
+    txt: "text",
+    md: "text",
+    csv: "text",
+    json: "text",
+    xml: "text",
+};
+/** Content type to send to providers when the declared one is missing or generic. */
+export const KIND_DEFAULT_MIME = {
+    pdf: "application/pdf",
+    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+};
+function ascii(bytes, start, length) {
+    let s = "";
+    for (let i = start; i < Math.min(bytes.length, start + length); i++)
+        s += String.fromCharCode(bytes[i]);
+    return s;
+}
+/** Finds which OOXML package a ZIP is by the part names in its local file headers. */
+function sniffOoxml(bytes) {
+    const head = ascii(bytes, 0, Math.min(bytes.length, 64 * 1024));
+    if (head.includes("word/"))
+        return "docx";
+    if (head.includes("xl/"))
+        return "xlsx";
+    if (head.includes("ppt/"))
+        return "pptx";
+    return null;
+}
+/** Returns the kind and a concrete mime from the first bytes, or null when unknown. */
+export function sniffMagic(bytes) {
+    if (bytes.length < 4)
+        return null;
+    const b = bytes;
+    if (ascii(b, 0, 5) === "%PDF-")
+        return { kind: "pdf", mime: "application/pdf" };
+    if (b[0] === 0x50 && b[1] === 0x4b && b[2] === 0x03 && b[3] === 0x04) {
+        const kind = sniffOoxml(b);
+        return kind ? { kind, mime: KIND_DEFAULT_MIME[kind] } : null;
+    }
+    if (b[0] === 0x89 && ascii(b, 1, 3) === "PNG")
+        return { kind: "image", mime: "image/png" };
+    if (b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff)
+        return { kind: "image", mime: "image/jpeg" };
+    if (ascii(b, 0, 4) === "GIF8")
+        return { kind: "image", mime: "image/gif" };
+    if (ascii(b, 0, 4) === "RIFF" && ascii(b, 8, 4) === "WEBP")
+        return { kind: "image", mime: "image/webp" };
+    if (ascii(b, 0, 4) === "RIFF" && ascii(b, 8, 4) === "WAVE")
+        return { kind: "audio", mime: "audio/wav" };
+    if (ascii(b, 0, 3) === "ID3" || (b[0] === 0xff && (b[1] & 0xe0) === 0xe0 && (b[1] & 0x06) !== 0)) {
+        return { kind: "audio", mime: "audio/mpeg" };
+    }
+    if (ascii(b, 0, 4) === "fLaC")
+        return { kind: "audio", mime: "audio/flac" };
+    if (ascii(b, 0, 4) === "OggS")
+        return { kind: "audio", mime: "audio/ogg" };
+    if (b[0] === 0x1a && b[1] === 0x45 && b[2] === 0xdf && b[3] === 0xa3)
+        return { kind: "video", mime: "video/webm" };
+    if (ascii(b, 4, 4) === "ftyp") {
+        const brand = ascii(b, 8, 4);
+        if (/^(heic|heix|mif1|avif)/.test(brand))
+            return { kind: "image", mime: brand === "avif" ? "image/avif" : "image/heic" };
+        if (/^(M4A |M4B )/.test(brand))
+            return { kind: "audio", mime: "audio/mp4" };
+        if (/^qt/.test(brand))
+            return { kind: "video", mime: "video/quicktime" };
+        return { kind: "video", mime: "video/mp4" };
+    }
+    return null;
+}
+function extensionOf(name) {
+    if (!name)
+        return "";
+    const clean = name.split(/[?#]/)[0];
+    const dot = clean.lastIndexOf(".");
+    return dot >= 0 ? clean.slice(dot + 1).toLowerCase() : "";
+}
+/**
+ * Magic bytes win over the declared type (servers often send PDFs as
+ * octet-stream or text/html); then the declared type; then the extension.
+ */
+export function detectFileKind({ bytes, contentType, fileName }) {
+    const declared = (contentType || "").split(";")[0].trim().toLowerCase();
+    const magic = bytes ? sniffMagic(bytes) : null;
+    if (magic)
+        return magic;
+    const generic = !declared || /^(application\/octet-stream|binary\/octet-stream|application\/zip|application\/x-zip-compressed)$/.test(declared);
+    if (!generic) {
+        for (const [re, kind] of MIME_KINDS)
+            if (re.test(declared))
+                return { kind, mime: declared };
+    }
+    const ext = extensionOf(fileName);
+    const byExt = EXT_KINDS[ext];
+    if (byExt) {
+        const media = byExt === "image" || byExt === "audio" || byExt === "video";
+        const sub = { mp3: "mpeg", jpg: "jpeg", mov: "quicktime", m4a: "mp4", m4v: "mp4", oga: "ogg" }[ext] || ext;
+        return { kind: byExt, mime: KIND_DEFAULT_MIME[byExt] || (media ? `${byExt}/${sub}` : declared || "text/plain") };
+    }
+    if (bytes) {
+        const head = ascii(bytes, 0, 512).toLowerCase();
+        if (/<!doctype html|<html[\s>]|<head[\s>]|<body[\s>]/.test(head))
+            return { kind: "html", mime: "text/html" };
+    }
+    return { kind: "text", mime: declared || "text/plain" };
+}

package/dist/core/parse/fetch.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Fetch a URL as bytes and parse it if it is a binary file (PDF, Office, image, media).
+ * Returns null when the URL is HTML/text so callers fall back to the HTML pipeline.
+ */
+import { type FetchedResource } from "../engine/fetcher.js";
+import { type FileKind } from "./detect.js";
+import { type ParseFileOptions, type ParseFileResult } from "./index.js";
+/** Cheap check before any network: does the URL path end in a binary file extension? */
+export declare function looksLikeBinaryUrl(url: string): boolean;
+/** Does a response content type mean we should take the binary path? */
+export declare function isBinaryContentType(contentType: string | undefined): boolean;
+export interface FetchedParse {
+    resource: FetchedResource;
+    kind: FileKind;
+    result: ParseFileResult;
+}
+export declare function fetchAndParse(url: string, options?: ParseFileOptions & {
+    timeoutMs?: number;
+    resource?: FetchedResource;
+}): Promise<FetchedParse | null>;

package/dist/core/parse/fetch.js

@@ -0,0 +1,39 @@
+/**
+ * Fetch a URL as bytes and parse it if it is a binary file (PDF, Office, image, media).
+ * Returns null when the URL is HTML/text so callers fall back to the HTML pipeline.
+ */
+import { fetchResource } from "../engine/fetcher.js";
+import { detectFileKind } from "./detect.js";
+import { maxDownloadBytes } from "./limits.js";
+import { isBinaryKind, parseFile } from "./index.js";
+const BINARY_EXT = /\.(pdf|docx|xlsx|pptx|png|jpe?g|webp|gif|heic|avif|mp3|wav|m4a|ogg|oga|flac|opus|aac|mp4|m4v|mov|webm|mkv)$/i;
+/** Cheap check before any network: does the URL path end in a binary file extension? */
+export function looksLikeBinaryUrl(url) {
+    try {
+        return BINARY_EXT.test(new URL(url).pathname);
+    }
+    catch {
+        return BINARY_EXT.test(url.split(/[?#]/)[0]);
+    }
+}
+/** Does a response content type mean we should take the binary path? */
+export function isBinaryContentType(contentType) {
+    const ct = (contentType || "").split(";")[0].trim().toLowerCase();
+    if (!ct)
+        return false;
+    const { kind } = detectFileKind({ contentType: ct });
+    return isBinaryKind(kind) || ct === "application/octet-stream";
+}
+export async function fetchAndParse(url, options = {}) {
+    const resource = options.resource ??
+        (await fetchResource(url, { timeoutMs: options.timeoutMs ?? 30_000, maxBytes: maxDownloadBytes() }));
+    const fileName = new URL(resource.url || url).pathname.split("/").pop() || undefined;
+    const { kind } = detectFileKind({ bytes: resource.body, contentType: resource.contentType, fileName });
+    if (!isBinaryKind(kind))
+        return null;
+    if (resource.status >= 400) {
+        throw new Error(`File request failed with HTTP ${resource.status}`);
+    }
+    const result = await parseFile({ bytes: resource.body, contentType: resource.contentType, fileName }, options);
+    return { resource, kind, result };
+}

package/dist/core/parse/image.d.ts

@@ -0,0 +1,13 @@
+import type { ParsedFile } from "./types.js";
+export declare const VISION_PROVIDER = "gemini-flash-lite";
+export declare function visionAvailable(): boolean;
+/** Splits the model reply into description and text. Tolerates a missing TEXT marker. */
+export declare function splitVisionReply(reply: string): {
+    description: string;
+    text: string;
+};
+export declare function imageMarkdown(description: string, text: string): string;
+export declare function parseImage(bytes: Uint8Array, mime: string, options?: {
+    fileName?: string;
+    signal?: AbortSignal;
+}): Promise<ParsedFile>;