@echofiles/echo-pdf 0.4.1 → 0.4.3

package/dist/mcp-server.js

@@ -0,0 +1,124 @@
+import { checkHeaderAuth } from "./auth.js";
+import { buildMcpContent, buildToolOutputEnvelope } from "./response-schema.js";
+import { callTool, listToolSchemas } from "./tool-registry.js";
+const ok = (id, result) => new Response(JSON.stringify({
+    jsonrpc: "2.0",
+    id: id ?? null,
+    result,
+}), { headers: { "Content-Type": "application/json" } });
+const err = (id, code, message, data, httpStatus = 400) => new Response(JSON.stringify({
+    jsonrpc: "2.0",
+    id: id ?? null,
+    error: data ? { code, message, data } : { code, message },
+}), { status: httpStatus, headers: { "Content-Type": "application/json" } });
+const asObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : {};
+const resolvePublicBaseUrl = (request, configured) => typeof configured === "string" && configured.length > 0 ? configured : request.url;
+const prepareMcpToolArgs = (toolName, args) => {
+    if (toolName === "pdf_extract_pages") {
+        const mode = typeof args.returnMode === "string" ? args.returnMode : "";
+        if (!mode) {
+            return { ...args, returnMode: "url" };
+        }
+    }
+    return args;
+};
+export const handleMcpRequest = async (request, env, config, fileStore) => {
+    const auth = checkHeaderAuth(request, env, {
+        authHeader: config.mcp.authHeader,
+        authEnv: config.mcp.authEnv,
+        allowMissingSecret: env.ECHO_PDF_ALLOW_MISSING_AUTH_SECRET === "1",
+        misconfiguredCode: "AUTH_MISCONFIGURED",
+        unauthorizedCode: "UNAUTHORIZED",
+        contextName: "MCP",
+    });
+    if (!auth.ok) {
+        return err(null, -32001, auth.message, { status: auth.status, code: auth.code }, 200);
+    }
+    let body;
+    try {
+        body = (await request.json());
+    }
+    catch {
+        return err(null, -32700, "Parse error");
+    }
+    if (typeof body !== "object" || body === null) {
+        return err(null, -32600, "Invalid Request");
+    }
+    if (body.jsonrpc !== "2.0") {
+        return err(body.id ?? null, -32600, "Invalid Request: jsonrpc must be '2.0'");
+    }
+    const method = body.method ?? "";
+    const id = body.id ?? null;
+    if (typeof method !== "string" || method.length === 0) {
+        return err(id, -32600, "Invalid Request: method is required");
+    }
+    if (method.startsWith("notifications/")) {
+        return new Response(null, { status: 204 });
+    }
+    const params = asObj(body.params);
+    if (method === "initialize") {
+        return ok(id, {
+            protocolVersion: "2024-11-05",
+            serverInfo: {
+                name: config.mcp.serverName,
+                version: config.mcp.version,
+            },
+            capabilities: {
+                tools: {},
+            },
+        });
+    }
+    if (method === "tools/list") {
+        return ok(id, { tools: listToolSchemas().map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                inputSchema: tool.inputSchema,
+            })) });
+    }
+    if (method !== "tools/call") {
+        return err(id, -32601, `Unsupported method: ${method}`);
+    }
+    const toolName = typeof params.name === "string" ? params.name : "";
+    const args = prepareMcpToolArgs(toolName, asObj(params.arguments));
+    if (!toolName) {
+        return err(id, -32602, "Invalid params: name is required", {
+            code: "INVALID_PARAMS",
+            status: 400,
+        });
+    }
+    try {
+        const result = await callTool(toolName, args, {
+            config,
+            env,
+            fileStore,
+        });
+        const envelope = buildToolOutputEnvelope(result, resolvePublicBaseUrl(request, config.service.publicBaseUrl));
+        return ok(id, { content: buildMcpContent(envelope) });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const status = error?.status;
+        const stableStatus = typeof status === "number" && Number.isFinite(status) ? status : 500;
+        const code = error?.code;
+        const details = error?.details;
+        if (message.startsWith("Unknown tool:")) {
+            return err(id, -32601, message, {
+                code: typeof code === "string" ? code : "TOOL_NOT_FOUND",
+                status: 404,
+                details,
+            });
+        }
+        if (stableStatus >= 400 && stableStatus < 500) {
+            return err(id, -32602, message, {
+                code: typeof code === "string" ? code : "INVALID_PARAMS",
+                status: stableStatus,
+                details,
+            });
+        }
+        return err(id, -32000, message, {
+            code: typeof code === "string" ? code : "INTERNAL_ERROR",
+            status: stableStatus,
+            details,
+        });
+    }
+};

package/dist/node/pdfium-local.d.ts

@@ -0,0 +1,8 @@
+import type { EchoPdfConfig } from "../pdf-types.js";
+export declare const getLocalPdfPageCount: (config: EchoPdfConfig, bytes: Uint8Array) => Promise<number>;
+export declare const renderLocalPdfPageToPng: (config: EchoPdfConfig, bytes: Uint8Array, pageIndex: number, scale?: number) => Promise<{
+    width: number;
+    height: number;
+    png: Uint8Array;
+}>;
+export declare const extractLocalPdfPageText: (config: EchoPdfConfig, bytes: Uint8Array, pageIndex: number) => Promise<string>;

package/dist/node/pdfium-local.js

@@ -0,0 +1,147 @@
+/// <reference path="./compat.d.ts" />
+import { encode as encodePng } from "@cf-wasm/png";
+import { init } from "@embedpdf/pdfium";
+let moduleInstance = null;
+let libraryInitialized = false;
+const isNodeRuntime = () => typeof process !== "undefined" && Boolean(process.versions?.node);
+const ensureWasmFunctionShim = () => {
+    const wasmApi = WebAssembly;
+    if (typeof wasmApi.Function === "function")
+        return;
+    wasmApi.Function = (_sig, fn) => fn;
+};
+const readLocalPdfiumWasm = async () => {
+    const [{ readFile }, { createRequire }] = await Promise.all([
+        import("node:fs/promises"),
+        import("node:module"),
+    ]);
+    const require = createRequire(import.meta.url);
+    const bytes = await readFile(require.resolve("@embedpdf/pdfium/pdfium.wasm"));
+    return new Uint8Array(bytes).slice().buffer;
+};
+const ensureLocalPdfium = async (_config) => {
+    if (!isNodeRuntime()) {
+        throw new Error("local document APIs require a Node-compatible runtime");
+    }
+    ensureWasmFunctionShim();
+    if (!moduleInstance) {
+        moduleInstance = await init({ wasmBinary: await readLocalPdfiumWasm() });
+    }
+    if (!libraryInitialized) {
+        moduleInstance.FPDF_InitLibrary();
+        libraryInitialized = true;
+    }
+    return moduleInstance;
+};
+const makeDoc = (pdfium, bytes) => {
+    const memPtr = pdfium.pdfium.wasmExports.malloc(bytes.length);
+    pdfium.pdfium.HEAPU8.set(bytes, memPtr);
+    const doc = pdfium.FPDF_LoadMemDocument(memPtr, bytes.length, "");
+    if (!doc) {
+        pdfium.pdfium.wasmExports.free(memPtr);
+        throw new Error("Failed to load PDF document");
+    }
+    return { doc, memPtr };
+};
+const closeDoc = (pdfium, doc, memPtr) => {
+    pdfium.FPDF_CloseDocument(doc);
+    pdfium.pdfium.wasmExports.free(memPtr);
+};
+const decodeUtf16Le = (buf) => {
+    const view = new Uint16Array(buf.buffer, buf.byteOffset, Math.floor(buf.byteLength / 2));
+    const chars = [];
+    for (const code of view) {
+        if (code === 0)
+            break;
+        chars.push(code);
+    }
+    return String.fromCharCode(...chars);
+};
+const bgraToRgba = (bgra) => {
+    const rgba = new Uint8Array(bgra.length);
+    for (let i = 0; i < bgra.length; i += 4) {
+        rgba[i] = bgra[i + 2] ?? 0;
+        rgba[i + 1] = bgra[i + 1] ?? 0;
+        rgba[i + 2] = bgra[i] ?? 0;
+        rgba[i + 3] = bgra[i + 3] ?? 255;
+    }
+    return rgba;
+};
+export const getLocalPdfPageCount = async (config, bytes) => {
+    const pdfium = await ensureLocalPdfium(config);
+    const { doc, memPtr } = makeDoc(pdfium, bytes);
+    try {
+        return pdfium.FPDF_GetPageCount(doc);
+    }
+    finally {
+        closeDoc(pdfium, doc, memPtr);
+    }
+};
+export const renderLocalPdfPageToPng = async (config, bytes, pageIndex, scale = config.service.defaultRenderScale) => {
+    const pdfium = await ensureLocalPdfium(config);
+    const { doc, memPtr } = makeDoc(pdfium, bytes);
+    let page = 0;
+    let bitmap = 0;
+    try {
+        page = pdfium.FPDF_LoadPage(doc, pageIndex);
+        if (!page) {
+            throw new Error(`Failed to load page ${pageIndex}`);
+        }
+        const width = Math.max(1, Math.round(pdfium.FPDF_GetPageWidthF(page) * scale));
+        const height = Math.max(1, Math.round(pdfium.FPDF_GetPageHeightF(page) * scale));
+        bitmap = pdfium.FPDFBitmap_Create(width, height, 1);
+        if (!bitmap) {
+            throw new Error("Failed to create bitmap");
+        }
+        pdfium.FPDFBitmap_FillRect(bitmap, 0, 0, width, height, 0xffffffff);
+        pdfium.FPDF_RenderPageBitmap(bitmap, page, 0, 0, width, height, 0, 0);
+        const stride = pdfium.FPDFBitmap_GetStride(bitmap);
+        const bufferPtr = pdfium.FPDFBitmap_GetBuffer(bitmap);
+        const heap = pdfium.pdfium.HEAPU8;
+        const bgra = heap.slice(bufferPtr, bufferPtr + stride * height);
+        const rgba = bgraToRgba(bgra);
+        const png = encodePng(rgba, width, height);
+        return { width, height, png };
+    }
+    finally {
+        if (bitmap)
+            pdfium.FPDFBitmap_Destroy(bitmap);
+        if (page)
+            pdfium.FPDF_ClosePage(page);
+        closeDoc(pdfium, doc, memPtr);
+    }
+};
+export const extractLocalPdfPageText = async (config, bytes, pageIndex) => {
+    const pdfium = await ensureLocalPdfium(config);
+    const { doc, memPtr } = makeDoc(pdfium, bytes);
+    let page = 0;
+    let textPage = 0;
+    let outPtr = 0;
+    try {
+        page = pdfium.FPDF_LoadPage(doc, pageIndex);
+        if (!page) {
+            throw new Error(`Failed to load page ${pageIndex}`);
+        }
+        textPage = pdfium.FPDFText_LoadPage(page);
+        if (!textPage)
+            return "";
+        const chars = pdfium.FPDFText_CountChars(textPage);
+        if (chars <= 0)
+            return "";
+        const bytesLen = (chars + 1) * 2;
+        outPtr = pdfium.pdfium.wasmExports.malloc(bytesLen);
+        pdfium.FPDFText_GetText(textPage, 0, chars, outPtr);
+        const heap = pdfium.pdfium.HEAPU8;
+        const raw = heap.slice(outPtr, outPtr + bytesLen);
+        return decodeUtf16Le(raw).trim();
+    }
+    finally {
+        if (outPtr)
+            pdfium.pdfium.wasmExports.free(outPtr);
+        if (textPage)
+            pdfium.FPDFText_ClosePage(textPage);
+        if (page)
+            pdfium.FPDF_ClosePage(page);
+        closeDoc(pdfium, doc, memPtr);
+    }
+};

package/dist/node/semantic-local.d.ts

@@ -0,0 +1,16 @@
+export interface SemanticPageInput {
+    readonly pageNumber: number;
+    readonly text: string;
+    readonly artifactPath: string;
+}
+export interface SemanticSectionNode {
+    readonly id: string;
+    readonly type: "section";
+    readonly title: string;
+    readonly level: number;
+    readonly pageNumber: number;
+    readonly pageArtifactPath: string;
+    readonly excerpt: string;
+    readonly children: ReadonlyArray<SemanticSectionNode>;
+}
+export declare const buildSemanticSectionTree: (pages: ReadonlyArray<SemanticPageInput>) => ReadonlyArray<SemanticSectionNode>;

package/dist/node/semantic-local.js

@@ -0,0 +1,113 @@
+const normalizeLine = (value) => value.replace(/\s+/g, " ").trim();
+const excerptFor = (value) => normalizeLine(value).slice(0, 160);
+const hasTocSuffix = (value) => /(?:\.{2,}|\s{2,}|\t)\d+$/.test(value);
+const hasTrailingPageNumber = (value) => /\s\d+$/.test(value);
+const isContentsHeading = (value) => {
+    const normalized = normalizeLine(value).toLowerCase();
+    return normalized === "contents" || normalized === "table of contents" || normalized === "目录";
+};
+const detectHeading = (line) => {
+    const normalized = normalizeLine(line);
+    if (!normalized || normalized.length > 120)
+        return null;
+    if (hasTocSuffix(normalized))
+        return null;
+    const numbered = normalized.match(/^(\d+(?:\.\d+){0,3})\s+(.+)$/);
+    if (numbered) {
+        const numberPath = numbered[1] || "";
+        const topLevelNumber = Number.parseInt(numberPath.split(".")[0] || "", 10);
+        const title = normalizeLine(numbered[2] || "");
+        const level = numberPath.split(".").length;
+        if (!title)
+            return null;
+        if (title.length < 2)
+            return null;
+        if (hasTrailingPageNumber(normalized))
+            return null;
+        if (!/^[A-Za-z\u4E00-\u9FFF第（(]/.test(title))
+            return null;
+        if (/^(GHz|MHz|Kbps|Mbps|Hz|kHz|mA|V|W)\b/i.test(title))
+            return null;
+        if (/[。；;：:]$/.test(title))
+            return null;
+        if (Number.isFinite(topLevelNumber) && topLevelNumber > 20)
+            return null;
+        if (/^[A-Z]+\d+$/.test(title))
+            return null;
+        if (level === 1 && title.length > 40)
+            return null;
+        if (level === 1 && /[，,×—]/.test(title))
+            return null;
+        return {
+            title: `${numberPath} ${title}`.trim(),
+            level,
+        };
+    }
+    const chinese = normalized.match(/^(第[0-9一二三四五六七八九十百]+)(章|节|部分)\s+(.+)$/);
+    if (chinese) {
+        const suffix = chinese[2] || "";
+        return {
+            title: normalized,
+            level: suffix === "节" ? 2 : 1,
+        };
+    }
+    const english = normalized.match(/^(Chapter|Section|Part|Appendix)\b[:\s-]*(.+)?$/i);
+    if (english) {
+        return {
+            title: normalized,
+            level: /section/i.test(english[1] || "") ? 2 : 1,
+        };
+    }
+    return null;
+};
+const toReadonlyTree = (node) => ({
+    ...node,
+    children: node.children.map(toReadonlyTree),
+});
+export const buildSemanticSectionTree = (pages) => {
+    const rootChildren = [];
+    const stack = [];
+    const emittedKeys = new Set();
+    let nextId = 1;
+    for (const page of pages) {
+        const lines = page.text
+            .split(/\r?\n/)
+            .map(normalizeLine)
+            .filter(Boolean);
+        if (lines.length === 0)
+            continue;
+        const contentsPage = isContentsHeading(lines[0] || "");
+        for (const line of lines) {
+            const heading = detectHeading(line);
+            if (!heading || contentsPage)
+                continue;
+            const emittedKey = `${heading.level}:${heading.title}`;
+            if (emittedKeys.has(emittedKey))
+                continue;
+            const node = {
+                id: `section-${nextId}`,
+                type: "section",
+                title: heading.title,
+                level: heading.level,
+                pageNumber: page.pageNumber,
+                pageArtifactPath: page.artifactPath,
+                excerpt: excerptFor(line),
+                children: [],
+            };
+            nextId += 1;
+            emittedKeys.add(emittedKey);
+            while (stack.length > 0 && (stack[stack.length - 1]?.level || 0) >= heading.level) {
+                stack.pop();
+            }
+            const parent = stack[stack.length - 1];
+            if (parent) {
+                parent.children.push(node);
+            }
+            else {
+                rootChildren.push(node);
+            }
+            stack.push(node);
+        }
+    }
+    return rootChildren.map(toReadonlyTree);
+};

package/dist/pdf-agent.d.ts

@@ -0,0 +1,18 @@
+import type { Env, FileStore } from "./types.js";
+import type { AgentTraceEvent, EchoPdfConfig, PdfOperationRequest } from "./pdf-types.js";
+interface RuntimeOptions {
+    readonly trace?: (event: AgentTraceEvent) => void;
+    readonly fileStore: FileStore;
+}
+export declare const ingestPdfFromPayload: (config: EchoPdfConfig, input: {
+    readonly fileId?: string;
+    readonly url?: string;
+    readonly base64?: string;
+    readonly filename?: string;
+}, opts: RuntimeOptions) => Promise<{
+    id: string;
+    filename: string;
+    bytes: Uint8Array;
+}>;
+export declare const runPdfAgent: (config: EchoPdfConfig, env: Env, request: PdfOperationRequest, opts: RuntimeOptions) => Promise<unknown>;
+export {};

package/dist/pdf-agent.js

@@ -0,0 +1,217 @@
+import { resolveModelForProvider, resolveProviderAlias } from "./agent-defaults.js";
+import { fromBase64, normalizeReturnMode, toDataUrl } from "./file-utils.js";
+import { badRequest, notFound, unprocessable } from "./http-error.js";
+import { extractPdfPageText, getPdfPageCount, renderPdfPageToPng, toBytes } from "./pdfium-engine.js";
+import { visionRecognize } from "./provider-client.js";
+const traceStep = (opts, phase, name, payload, level) => {
+    if (!opts.trace)
+        return;
+    opts.trace({ kind: "step", phase, name, payload, level });
+};
+const ensurePages = (pages, pageCount, maxPages) => {
+    if (pages.length === 0)
+        throw badRequest("PAGES_REQUIRED", "At least one page is required");
+    if (pages.length > maxPages) {
+        throw badRequest("TOO_MANY_PAGES", `Page count exceeds maxPagesPerRequest (${maxPages})`, {
+            maxPagesPerRequest: maxPages,
+            providedPages: pages.length,
+        });
+    }
+    for (const page of pages) {
+        if (!Number.isInteger(page) || page < 1 || page > pageCount) {
+            throw badRequest("PAGE_OUT_OF_RANGE", `Page ${page} out of range 1..${pageCount}`, {
+                page,
+                min: 1,
+                max: pageCount,
+            });
+        }
+    }
+    return [...new Set(pages)].sort((a, b) => a - b);
+};
+export const ingestPdfFromPayload = async (config, input, opts) => {
+    if (input.fileId) {
+        const existing = await opts.fileStore.get(input.fileId);
+        if (!existing) {
+            throw notFound("FILE_NOT_FOUND", `File not found: ${input.fileId}`, { fileId: input.fileId });
+        }
+        return {
+            id: existing.id,
+            filename: existing.filename,
+            bytes: existing.bytes,
+        };
+    }
+    let bytes = null;
+    let filename = input.filename ?? "document.pdf";
+    if (input.url) {
+        traceStep(opts, "start", "file.fetch.url", { url: input.url });
+        try {
+            bytes = await toBytes(input.url);
+        }
+        catch (error) {
+            throw badRequest("URL_FETCH_FAILED", `Unable to fetch PDF from url: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        try {
+            const u = new URL(input.url);
+            filename = decodeURIComponent(u.pathname.split("/").pop() || filename);
+        }
+        catch {
+            // ignore URL parse failure
+        }
+        traceStep(opts, "end", "file.fetch.url", { sizeBytes: bytes.byteLength });
+    }
+    else if (input.base64) {
+        traceStep(opts, "start", "file.decode.base64");
+        bytes = fromBase64(input.base64);
+        traceStep(opts, "end", "file.decode.base64", { sizeBytes: bytes.byteLength });
+    }
+    if (!bytes) {
+        throw badRequest("MISSING_FILE_INPUT", "Missing file input. Provide fileId, url or base64");
+    }
+    if (bytes.byteLength > config.service.maxPdfBytes) {
+        throw badRequest("PDF_TOO_LARGE", `PDF exceeds max size (${config.service.maxPdfBytes} bytes)`, {
+            maxPdfBytes: config.service.maxPdfBytes,
+            sizeBytes: bytes.byteLength,
+        });
+    }
+    const meta = await opts.fileStore.put({
+        filename,
+        mimeType: "application/pdf",
+        bytes,
+    });
+    traceStep(opts, "end", "file.stored", { fileId: meta.id, sizeBytes: meta.sizeBytes });
+    return {
+        id: meta.id,
+        filename: meta.filename,
+        bytes,
+    };
+};
+const resolveReturnMode = (value) => normalizeReturnMode(value);
+const stripCodeFences = (value) => {
+    const text = value.trim();
+    const fenced = text.match(/^```[a-zA-Z0-9_-]*\n([\s\S]*?)\n```$/);
+    return typeof fenced?.[1] === "string" ? fenced[1].trim() : text;
+};
+const extractTabularLatex = (value) => {
+    const text = stripCodeFences(value);
+    const blocks = text.match(/\\begin\{tabular\}[\s\S]*?\\end\{tabular\}/g);
+    if (!blocks || blocks.length === 0)
+        return "";
+    return blocks.map((b) => b.trim()).join("\n\n");
+};
+export const runPdfAgent = async (config, env, request, opts) => {
+    traceStep(opts, "start", "pdf.operation", { operation: request.operation });
+    const file = await ingestPdfFromPayload(config, request, opts);
+    const pageCount = await getPdfPageCount(config, file.bytes);
+    traceStep(opts, "log", "pdf.meta", { fileId: file.id, pageCount });
+    const pages = ensurePages(request.pages, pageCount, config.service.maxPagesPerRequest);
+    const scale = request.renderScale ?? config.service.defaultRenderScale;
+    const returnMode = resolveReturnMode(request.returnMode);
+    if (request.operation === "extract_pages") {
+        const images = [];
+        for (const page of pages) {
+            traceStep(opts, "start", "render.page", { page });
+            const rendered = await renderPdfPageToPng(config, file.bytes, page - 1, scale);
+            if (returnMode === "file_id") {
+                const stored = await opts.fileStore.put({
+                    filename: `${file.filename}-p${page}.png`,
+                    mimeType: "image/png",
+                    bytes: rendered.png,
+                });
+                images.push({ page, mimeType: "image/png", fileId: stored.id });
+            }
+            else if (returnMode === "url") {
+                const stored = await opts.fileStore.put({
+                    filename: `${file.filename}-p${page}.png`,
+                    mimeType: "image/png",
+                    bytes: rendered.png,
+                });
+                images.push({
+                    page,
+                    mimeType: "image/png",
+                    fileId: stored.id,
+                    url: `/api/files/get?fileId=${encodeURIComponent(stored.id)}`,
+                });
+            }
+            else {
+                images.push({
+                    page,
+                    mimeType: "image/png",
+                    data: toDataUrl(rendered.png, "image/png"),
+                });
+            }
+            traceStep(opts, "end", "render.page", { page, width: rendered.width, height: rendered.height });
+        }
+        const result = { fileId: file.id, pageCount, returnMode, images };
+        traceStep(opts, "end", "pdf.operation", { operation: request.operation });
+        return result;
+    }
+    const providerAlias = resolveProviderAlias(config, request.provider);
+    const model = resolveModelForProvider(config, providerAlias, request.model);
+    if (!model) {
+        throw badRequest("MODEL_REQUIRED", "model is required for OCR or table extraction; set agent.defaultModel");
+    }
+    if (request.operation === "ocr_pages") {
+        const results = [];
+        for (const page of pages) {
+            traceStep(opts, "start", "ocr.page", { page });
+            const rendered = await renderPdfPageToPng(config, file.bytes, page - 1, scale);
+            const imageDataUrl = toDataUrl(rendered.png, "image/png");
+            const fallbackText = await extractPdfPageText(config, file.bytes, page - 1);
+            const prompt = request.prompt?.trim() || config.agent.ocrPrompt;
+            const llmText = await visionRecognize({
+                config,
+                env,
+                providerAlias,
+                model,
+                prompt,
+                imageDataUrl,
+                runtimeApiKeys: request.providerApiKeys,
+            });
+            const text = stripCodeFences(llmText || fallbackText || "");
+            results.push({ page, text });
+            traceStep(opts, "end", "ocr.page", { page, chars: text.length });
+        }
+        const result = {
+            fileId: file.id,
+            pageCount,
+            provider: providerAlias,
+            model,
+            pages: results,
+        };
+        traceStep(opts, "end", "pdf.operation", { operation: request.operation });
+        return result;
+    }
+    const tables = [];
+    for (const page of pages) {
+        traceStep(opts, "start", "table.page", { page });
+        const rendered = await renderPdfPageToPng(config, file.bytes, page - 1, scale);
+        const imageDataUrl = toDataUrl(rendered.png, "image/png");
+        const prompt = request.prompt?.trim() || config.agent.tablePrompt;
+        const rawLatex = await visionRecognize({
+            config,
+            env,
+            providerAlias,
+            model,
+            prompt,
+            imageDataUrl,
+            runtimeApiKeys: request.providerApiKeys,
+        });
+        const latex = extractTabularLatex(rawLatex);
+        if (!latex) {
+            throw unprocessable("TABLE_LATEX_MISSING", `table extraction did not return valid LaTeX tabular for page ${page}`, {
+                page,
+            });
+        }
+        tables.push({ page, latex });
+        traceStep(opts, "end", "table.page", { page, chars: latex.length });
+    }
+    const result = {
+        fileId: file.id,
+        pageCount,
+        provider: providerAlias,
+        model,
+        pages: tables,
+    };
+    traceStep(opts, "end", "pdf.operation", { operation: request.operation });
+    return result;
+};

package/dist/pdf-config.d.ts

@@ -0,0 +1,4 @@
+import type { Env } from "./types.js";
+import type { EchoPdfConfig } from "./pdf-types.js";
+export declare const loadEchoPdfConfig: (env: Env) => EchoPdfConfig;
+export declare const readRequiredEnv: (env: Env, key: string) => string;