@echofiles/echo-pdf 0.4.1 → 0.4.3

package/dist/pdf-config.js

@@ -0,0 +1,140 @@
+import rawConfig from "../echo-pdf.config.json" with { type: "json" };
+const ENV_PATTERN = /\$\{([A-Z0-9_]+)\}/g;
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const interpolateEnv = (input, env) => input.replace(ENV_PATTERN, (_, name) => {
+    const value = env[name];
+    return typeof value === "string" ? value : `\${${name}}`;
+});
+const resolveEnvRefs = (value, env) => {
+    if (typeof value === "string")
+        return interpolateEnv(value, env);
+    if (Array.isArray(value))
+        return value.map((item) => resolveEnvRefs(item, env));
+    if (isObject(value)) {
+        const out = {};
+        for (const [key, nested] of Object.entries(value)) {
+            out[key] = resolveEnvRefs(nested, env);
+        }
+        return out;
+    }
+    return value;
+};
+const validateConfig = (config) => {
+    if (!config.service?.name)
+        throw new Error("service.name is required");
+    if (!config.pdfium?.wasmUrl)
+        throw new Error("pdfium.wasmUrl is required");
+    if (!config.service?.storage)
+        throw new Error("service.storage is required");
+    if (typeof config.service.publicBaseUrl === "string" &&
+        config.service.publicBaseUrl.length > 0 &&
+        !/^https?:\/\//.test(config.service.publicBaseUrl)) {
+        throw new Error("service.publicBaseUrl must start with http:// or https://");
+    }
+    if (typeof config.service.fileGet?.cacheTtlSeconds === "number" && config.service.fileGet.cacheTtlSeconds < 0) {
+        throw new Error("service.fileGet.cacheTtlSeconds must be >= 0");
+    }
+    if (!Number.isFinite(config.service.storage.maxFileBytes) || config.service.storage.maxFileBytes <= 0) {
+        throw new Error("service.storage.maxFileBytes must be positive");
+    }
+    if (config.service.storage.maxFileBytes < config.service.maxPdfBytes) {
+        throw new Error("service.storage.maxFileBytes must be >= service.maxPdfBytes");
+    }
+    if (!Number.isFinite(config.service.storage.maxTotalBytes) || config.service.storage.maxTotalBytes <= 0) {
+        throw new Error("service.storage.maxTotalBytes must be positive");
+    }
+    if (config.service.storage.maxTotalBytes < config.service.storage.maxFileBytes) {
+        throw new Error("service.storage.maxTotalBytes must be >= maxFileBytes");
+    }
+    if (!Number.isFinite(config.service.storage.ttlHours) || config.service.storage.ttlHours <= 0) {
+        throw new Error("service.storage.ttlHours must be positive");
+    }
+    if (!Number.isFinite(config.service.storage.cleanupBatchSize) || config.service.storage.cleanupBatchSize <= 0) {
+        throw new Error("service.storage.cleanupBatchSize must be positive");
+    }
+    if (!config.agent?.defaultProvider)
+        throw new Error("agent.defaultProvider is required");
+    if (!config.providers?.[config.agent.defaultProvider]) {
+        throw new Error(`default provider "${config.agent.defaultProvider}" missing`);
+    }
+    if (typeof config.agent.defaultModel !== "string") {
+        throw new Error("agent.defaultModel must be a string");
+    }
+    return config;
+};
+export const loadEchoPdfConfig = (env) => {
+    const fromEnv = env.ECHO_PDF_CONFIG_JSON?.trim();
+    const configJson = fromEnv ? JSON.parse(fromEnv) : rawConfig;
+    const resolved = resolveEnvRefs(configJson, env);
+    const providerOverride = env.ECHO_PDF_DEFAULT_PROVIDER;
+    const modelOverride = env.ECHO_PDF_DEFAULT_MODEL;
+    const publicBaseUrlOverride = env.ECHO_PDF_PUBLIC_BASE_URL;
+    const computeAuthHeaderOverride = env.ECHO_PDF_COMPUTE_AUTH_HEADER;
+    const computeAuthEnvOverride = env.ECHO_PDF_COMPUTE_AUTH_ENV;
+    const fileGetAuthHeaderOverride = env.ECHO_PDF_FILE_GET_AUTH_HEADER;
+    const fileGetAuthEnvOverride = env.ECHO_PDF_FILE_GET_AUTH_ENV;
+    const fileGetCacheTtlOverride = env.ECHO_PDF_FILE_GET_CACHE_TTL_SECONDS;
+    const withOverrides = {
+        ...resolved,
+        service: {
+            ...resolved.service,
+            publicBaseUrl: typeof publicBaseUrlOverride === "string" && publicBaseUrlOverride.trim().length > 0
+                ? publicBaseUrlOverride.trim()
+                : resolved.service.publicBaseUrl,
+            computeAuth: {
+                authHeader: typeof computeAuthHeaderOverride === "string" && computeAuthHeaderOverride.trim().length > 0
+                    ? computeAuthHeaderOverride.trim()
+                    : resolved.service.computeAuth?.authHeader,
+                authEnv: typeof computeAuthEnvOverride === "string" && computeAuthEnvOverride.trim().length > 0
+                    ? computeAuthEnvOverride.trim()
+                    : resolved.service.computeAuth?.authEnv,
+            },
+            fileGet: {
+                authHeader: typeof fileGetAuthHeaderOverride === "string" && fileGetAuthHeaderOverride.trim().length > 0
+                    ? fileGetAuthHeaderOverride.trim()
+                    : resolved.service.fileGet?.authHeader,
+                authEnv: typeof fileGetAuthEnvOverride === "string" && fileGetAuthEnvOverride.trim().length > 0
+                    ? fileGetAuthEnvOverride.trim()
+                    : resolved.service.fileGet?.authEnv,
+                cacheTtlSeconds: (() => {
+                    if (typeof fileGetCacheTtlOverride === "string" && fileGetCacheTtlOverride.trim().length > 0) {
+                        const value = Number(fileGetCacheTtlOverride);
+                        return Number.isFinite(value) && value >= 0 ? Math.floor(value) : resolved.service.fileGet?.cacheTtlSeconds;
+                    }
+                    return resolved.service.fileGet?.cacheTtlSeconds;
+                })(),
+            },
+        },
+        agent: {
+            ...resolved.agent,
+            defaultProvider: typeof providerOverride === "string" && providerOverride.trim().length > 0
+                ? providerOverride.trim()
+                : resolved.agent.defaultProvider,
+            defaultModel: typeof modelOverride === "string" && modelOverride.trim().length > 0
+                ? modelOverride.trim()
+                : resolved.agent.defaultModel,
+        },
+    };
+    return validateConfig(withOverrides);
+};
+export const readRequiredEnv = (env, key) => {
+    const read = (name) => {
+        const value = env[name];
+        return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+    };
+    const direct = read(key);
+    if (direct)
+        return direct;
+    // Backward compatibility: allow *_KEY and *_API_KEY aliases.
+    if (key.endsWith("_API_KEY")) {
+        const alt = read(key.replace(/_API_KEY$/, "_KEY"));
+        if (alt)
+            return alt;
+    }
+    if (key.endsWith("_KEY")) {
+        const alt = read(key.replace(/_KEY$/, "_API_KEY"));
+        if (alt)
+            return alt;
+    }
+    throw new Error(`Missing required env var "${key}"`);
+};

package/dist/pdf-storage.d.ts

@@ -0,0 +1,8 @@
+import type { EchoPdfConfig } from "./pdf-types.js";
+import type { Env, FileStore } from "./types.js";
+export interface RuntimeFileStoreBundle {
+    readonly store: FileStore;
+    stats: () => Promise<unknown>;
+    cleanup: () => Promise<unknown>;
+}
+export declare const getRuntimeFileStore: (env: Env, config: EchoPdfConfig) => RuntimeFileStoreBundle;

package/dist/pdf-storage.js

@@ -0,0 +1,86 @@
+import { DurableObjectFileStore } from "./file-store-do.js";
+import { R2FileStore } from "./r2-file-store.js";
+class InMemoryFileStore {
+    store = new Map();
+    async put(input) {
+        const id = crypto.randomUUID();
+        const record = {
+            id,
+            filename: input.filename,
+            mimeType: input.mimeType,
+            sizeBytes: input.bytes.byteLength,
+            createdAt: new Date().toISOString(),
+            bytes: input.bytes,
+        };
+        this.store.set(id, record);
+        return this.toMeta(record);
+    }
+    async get(fileId) {
+        return this.store.get(fileId) ?? null;
+    }
+    async list() {
+        return [...this.store.values()].map((record) => this.toMeta(record));
+    }
+    async delete(fileId) {
+        return this.store.delete(fileId);
+    }
+    toMeta(record) {
+        return {
+            id: record.id,
+            filename: record.filename,
+            mimeType: record.mimeType,
+            sizeBytes: record.sizeBytes,
+            createdAt: record.createdAt,
+        };
+    }
+}
+const fallbackStore = new InMemoryFileStore();
+const DO_SAFE_MAX_FILE_BYTES = 1_200_000;
+export const getRuntimeFileStore = (env, config) => {
+    if (env.FILE_STORE_BUCKET) {
+        const store = new R2FileStore(env.FILE_STORE_BUCKET, config.service.storage);
+        return {
+            store,
+            stats: async () => store.stats(),
+            cleanup: async () => store.cleanup(),
+        };
+    }
+    if (env.FILE_STORE_DO) {
+        if (config.service.storage.maxFileBytes > DO_SAFE_MAX_FILE_BYTES) {
+            throw new Error(`service.storage.maxFileBytes=${config.service.storage.maxFileBytes} exceeds DO backend limit ${DO_SAFE_MAX_FILE_BYTES}; bind FILE_STORE_BUCKET (R2) or reduce maxFileBytes`);
+        }
+        const store = new DurableObjectFileStore(env.FILE_STORE_DO, config.service.storage);
+        return {
+            store,
+            stats: async () => store.stats(),
+            cleanup: async () => store.cleanup(),
+        };
+    }
+    return {
+        store: fallbackStore,
+        stats: async () => {
+            const files = await fallbackStore.list();
+            const totalBytes = files.reduce((sum, file) => sum + file.sizeBytes, 0);
+            return {
+                backend: "memory",
+                policy: config.service.storage,
+                stats: {
+                    fileCount: files.length,
+                    totalBytes,
+                },
+            };
+        },
+        cleanup: async () => ({
+            backend: "memory",
+            deletedExpired: 0,
+            deletedEvicted: 0,
+            stats: await (async () => {
+                const files = await fallbackStore.list();
+                return {
+                    fileCount: files.length,
+                    totalBytes: files.reduce((sum, file) => sum + file.sizeBytes, 0),
+                };
+            })(),
+        }),
+    };
+};

package/dist/pdf-types.d.ts

@@ -0,0 +1,83 @@
+import type { ProviderType, ReturnMode } from "./types.js";
+export interface EchoPdfProviderConfig {
+    readonly type: ProviderType;
+    readonly apiKeyEnv: string;
+    readonly baseUrl?: string;
+    readonly headers?: Record<string, string>;
+    readonly timeoutMs?: number;
+    readonly endpoints?: {
+        readonly chatCompletionsPath?: string;
+        readonly modelsPath?: string;
+    };
+}
+export interface StoragePolicy {
+    readonly maxFileBytes: number;
+    readonly maxTotalBytes: number;
+    readonly ttlHours: number;
+    readonly cleanupBatchSize: number;
+}
+export interface EchoPdfConfig {
+    readonly service: {
+        readonly name: string;
+        readonly publicBaseUrl?: string;
+        readonly computeAuth?: {
+            readonly authHeader?: string;
+            readonly authEnv?: string;
+        };
+        readonly fileGet?: {
+            readonly authHeader?: string;
+            readonly authEnv?: string;
+            readonly cacheTtlSeconds?: number;
+        };
+        readonly maxPdfBytes: number;
+        readonly maxPagesPerRequest: number;
+        readonly defaultRenderScale: number;
+        readonly storage: StoragePolicy;
+    };
+    readonly pdfium: {
+        readonly wasmUrl: string;
+    };
+    readonly agent: {
+        readonly defaultProvider: string;
+        readonly defaultModel: string;
+        readonly ocrPrompt: string;
+        readonly tablePrompt: string;
+    };
+    readonly providers: Record<string, EchoPdfProviderConfig>;
+    readonly mcp: {
+        readonly serverName: string;
+        readonly version: string;
+        readonly authHeader?: string;
+        readonly authEnv?: string;
+    };
+}
+export interface AgentTraceEvent {
+    readonly kind: "step";
+    readonly phase: "start" | "end" | "log";
+    readonly name: string;
+    readonly level?: "info" | "error";
+    readonly payload?: unknown;
+}
+export interface PdfOperationRequest {
+    readonly operation: "extract_pages" | "ocr_pages" | "tables_to_latex";
+    readonly fileId?: string;
+    readonly url?: string;
+    readonly base64?: string;
+    readonly filename?: string;
+    readonly pages: ReadonlyArray<number>;
+    readonly renderScale?: number;
+    readonly provider?: string;
+    readonly model: string;
+    readonly providerApiKeys?: Record<string, string>;
+    readonly returnMode?: ReturnMode;
+    readonly prompt?: string;
+}
+export interface ToolSchema {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: Record<string, unknown>;
+    readonly source: {
+        readonly kind: "local";
+        readonly toolName: string;
+    };
+}

package/dist/pdf-types.js

@@ -0,0 +1 @@
+export {};

package/dist/pdfium-engine.d.ts

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

package/dist/pdfium-engine.js

@@ -0,0 +1,180 @@
+import { init } from "@embedpdf/pdfium";
+import { encode as encodePng } from "@cf-wasm/png";
+let moduleInstance = null;
+let libraryInitialized = false;
+const toUint8 = (value) => new Uint8Array(value);
+const textDecoder = new TextDecoder();
+const isWorkerdRuntime = () => typeof globalThis.WebSocketPair === "function";
+const ensureWasmFunctionShim = () => {
+    const wasmApi = WebAssembly;
+    if (typeof wasmApi.Function === "function")
+        return;
+    wasmApi.Function = (_sig, fn) => fn;
+};
+const ensurePdfium = async (config) => {
+    ensureWasmFunctionShim();
+    if (!moduleInstance) {
+        if (isWorkerdRuntime()) {
+            const wasmModuleImport = await import("@embedpdf/pdfium/pdfium.wasm");
+            const maybeModule = wasmModuleImport.default ?? wasmModuleImport;
+            if (maybeModule instanceof WebAssembly.Module) {
+                moduleInstance = await init({
+                    instantiateWasm: (imports, successCallback) => {
+                        const instance = new WebAssembly.Instance(maybeModule, imports);
+                        successCallback(instance, maybeModule);
+                        return instance.exports;
+                    },
+                });
+            }
+        }
+        if (!moduleInstance) {
+            const wasmBinary = await fetch(config.pdfium.wasmUrl).then((res) => res.arrayBuffer());
+            moduleInstance = await init({ wasmBinary });
+        }
+    }
+    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 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;
+};
+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);
+};
+export const getPdfPageCount = async (config, bytes) => {
+    const pdfium = await ensurePdfium(config);
+    const { doc, memPtr } = makeDoc(pdfium, bytes);
+    try {
+        return pdfium.FPDF_GetPageCount(doc);
+    }
+    finally {
+        closeDoc(pdfium, doc, memPtr);
+    }
+};
+export const renderPdfPageToPng = async (config, bytes, pageIndex, scale = config.service.defaultRenderScale) => {
+    const pdfium = await ensurePdfium(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 extractPdfPageText = async (config, bytes, pageIndex) => {
+    const pdfium = await ensurePdfium(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);
+    }
+};
+export const toBytes = async (value) => {
+    const response = await fetch(value);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch source: HTTP ${response.status}`);
+    }
+    const contentType = (response.headers.get("content-type") ?? "").toLowerCase();
+    const bytes = toUint8(await response.arrayBuffer());
+    const signature = textDecoder.decode(bytes.subarray(0, Math.min(8, bytes.length)));
+    if (contentType.includes("application/pdf") || signature.startsWith("%PDF-")) {
+        return bytes;
+    }
+    const html = textDecoder.decode(bytes);
+    const pdfMatch = html.match(/https?:\/\/[^"' )]+\.pdf[^"' )]*/i);
+    if (!pdfMatch || pdfMatch.length === 0) {
+        throw new Error("URL does not point to a PDF and no PDF link was found in the page");
+    }
+    const resolvedUrl = pdfMatch[0].replace(/&amp;/g, "&");
+    const pdfResponse = await fetch(resolvedUrl);
+    if (!pdfResponse.ok) {
+        throw new Error(`Failed to fetch resolved PDF url: HTTP ${pdfResponse.status}`);
+    }
+    const pdfBytes = toUint8(await pdfResponse.arrayBuffer());
+    const pdfSignature = textDecoder.decode(pdfBytes.subarray(0, Math.min(8, pdfBytes.length)));
+    if (!pdfSignature.startsWith("%PDF-")) {
+        throw new Error("Resolved file is not a valid PDF");
+    }
+    return pdfBytes;
+};

package/dist/provider-client.d.ts

@@ -0,0 +1,20 @@
+import type { Env } from "./types.js";
+import type { EchoPdfConfig } from "./pdf-types.js";
+export declare const listProviderModels: (config: EchoPdfConfig, env: Env, alias: string, runtimeApiKeys?: Record<string, string>) => Promise<ReadonlyArray<string>>;
+export declare const visionRecognize: (input: {
+    config: EchoPdfConfig;
+    env: Env;
+    providerAlias: string;
+    model: string;
+    prompt: string;
+    imageDataUrl: string;
+    runtimeApiKeys?: Record<string, string>;
+}) => Promise<string>;
+export declare const generateText: (input: {
+    config: EchoPdfConfig;
+    env: Env;
+    providerAlias: string;
+    model: string;
+    prompt: string;
+    runtimeApiKeys?: Record<string, string>;
+}) => Promise<string>;