@echofiles/echo-pdf 0.4.0 → 0.4.2

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,12 @@
+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>;

package/dist/provider-client.js

@@ -0,0 +1,134 @@
+import { resolveProviderApiKey } from "./provider-keys.js";
+const defaultBaseUrl = (provider) => {
+    if (provider.baseUrl)
+        return provider.baseUrl;
+    switch (provider.type) {
+        case "openrouter":
+            return "https://openrouter.ai/api/v1";
+        case "vercel-ai-gateway":
+            return "https://ai-gateway.vercel.sh/v1";
+        case "openai":
+        default:
+            return "https://api.openai.com/v1";
+    }
+};
+const noTrailingSlash = (url) => url.replace(/\/+$/, "");
+const resolveEndpoint = (provider, kind) => {
+    const configured = provider.endpoints?.[kind];
+    if (configured?.startsWith("http://") || configured?.startsWith("https://")) {
+        return configured;
+    }
+    const fallback = kind === "chatCompletionsPath" ? "/chat/completions" : "/models";
+    const path = configured && configured.length > 0 ? configured : fallback;
+    return `${noTrailingSlash(defaultBaseUrl(provider))}${path.startsWith("/") ? path : `/${path}`}`;
+};
+const toAuthHeader = (config, providerAlias, provider, env, runtimeApiKeys) => {
+    const token = resolveProviderApiKey({
+        config,
+        env,
+        providerAlias,
+        provider,
+        runtimeApiKeys,
+    });
+    return { Authorization: `Bearer ${token}` };
+};
+const withTimeout = async (url, init, timeoutMs) => {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort("timeout"), timeoutMs);
+    try {
+        return await fetch(url, { ...init, signal: ctrl.signal });
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+            throw new Error(`Request timeout after ${timeoutMs}ms for ${url}`);
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+};
+const responseDetail = async (response) => {
+    const contentType = response.headers.get("content-type") ?? "";
+    try {
+        if (contentType.includes("application/json")) {
+            return JSON.stringify(await response.json()).slice(0, 800);
+        }
+        return (await response.text()).slice(0, 800);
+    }
+    catch {
+        return "<unable to parse response payload>";
+    }
+};
+const getProvider = (config, alias) => {
+    const provider = config.providers[alias];
+    if (!provider) {
+        throw new Error(`Provider "${alias}" not configured`);
+    }
+    return provider;
+};
+export const listProviderModels = async (config, env, alias, runtimeApiKeys) => {
+    const provider = getProvider(config, alias);
+    const url = resolveEndpoint(provider, "modelsPath");
+    const response = await withTimeout(url, {
+        method: "GET",
+        headers: {
+            Accept: "application/json",
+            ...toAuthHeader(config, alias, provider, env, runtimeApiKeys),
+            ...(provider.headers ?? {}),
+        },
+    }, provider.timeoutMs ?? 30000);
+    if (!response.ok) {
+        throw new Error(`Model list request failed: HTTP ${response.status} url=${url} detail=${await responseDetail(response)}`);
+    }
+    const payload = await response.json();
+    const data = payload.data;
+    if (!Array.isArray(data))
+        return [];
+    return data
+        .map((item) => item)
+        .map((item) => (typeof item.id === "string" ? item.id : ""))
+        .filter((id) => id.length > 0);
+};
+export const visionRecognize = async (input) => {
+    const provider = getProvider(input.config, input.providerAlias);
+    const url = resolveEndpoint(provider, "chatCompletionsPath");
+    const response = await withTimeout(url, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            ...toAuthHeader(input.config, input.providerAlias, provider, input.env, input.runtimeApiKeys),
+            ...(provider.headers ?? {}),
+        },
+        body: JSON.stringify({
+            model: input.model,
+            messages: [
+                {
+                    role: "user",
+                    content: [
+                        { type: "text", text: input.prompt },
+                        { type: "image_url", image_url: { url: input.imageDataUrl } },
+                    ],
+                },
+            ],
+        }),
+    }, provider.timeoutMs ?? 30000);
+    if (!response.ok) {
+        throw new Error(`Vision request failed: HTTP ${response.status} url=${url} detail=${await responseDetail(response)}`);
+    }
+    const payload = await response.json();
+    const message = payload.choices?.[0]?.message;
+    if (!message)
+        return "";
+    const content = message.content;
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => part)
+            .filter((part) => part.type === "text" && typeof part.text === "string")
+            .map((part) => part.text ?? "")
+            .join("");
+    }
+    return "";
+};

package/dist/provider-keys.d.ts

@@ -0,0 +1,10 @@
+import type { EchoPdfConfig, EchoPdfProviderConfig } from "./pdf-types.js";
+import type { Env } from "./types.js";
+export declare const runtimeProviderKeyCandidates: (_config: EchoPdfConfig, providerAlias: string, provider: EchoPdfProviderConfig) => string[];
+export declare const resolveProviderApiKey: (input: {
+    config: EchoPdfConfig;
+    env: Env;
+    providerAlias: string;
+    provider: EchoPdfProviderConfig;
+    runtimeApiKeys?: Record<string, string>;
+}) => string;

package/dist/provider-keys.js

@@ -0,0 +1,27 @@
+import { readRequiredEnv } from "./pdf-config.js";
+const normalizeKey = (value) => value.trim();
+const keyVariants = (value) => {
+    const raw = normalizeKey(value);
+    if (raw.length === 0)
+        return [];
+    return Array.from(new Set([
+        raw,
+        raw.replace(/-/g, "_"),
+        raw.replace(/_/g, "-"),
+    ]));
+};
+export const runtimeProviderKeyCandidates = (_config, providerAlias, provider) => {
+    const aliases = keyVariants(providerAlias);
+    const types = keyVariants(provider.type);
+    return Array.from(new Set([...aliases, ...types]));
+};
+export const resolveProviderApiKey = (input) => {
+    const candidates = runtimeProviderKeyCandidates(input.config, input.providerAlias, input.provider);
+    for (const candidate of candidates) {
+        const value = input.runtimeApiKeys?.[candidate];
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value.trim();
+        }
+    }
+    return readRequiredEnv(input.env, input.provider.apiKeyEnv);
+};

package/dist/r2-file-store.d.ts

@@ -0,0 +1,20 @@
+import type { StoragePolicy } from "./pdf-types.js";
+import type { FileStore, R2Bucket, StoredFileMeta, StoredFileRecord } from "./types.js";
+export declare class R2FileStore implements FileStore {
+    private readonly bucket;
+    private readonly policy;
+    constructor(bucket: R2Bucket, policy: StoragePolicy);
+    put(input: {
+        readonly filename: string;
+        readonly mimeType: string;
+        readonly bytes: Uint8Array;
+    }): Promise<StoredFileMeta>;
+    get(fileId: string): Promise<StoredFileRecord | null>;
+    list(): Promise<ReadonlyArray<StoredFileMeta>>;
+    delete(fileId: string): Promise<boolean>;
+    stats(): Promise<unknown>;
+    cleanup(): Promise<unknown>;
+    private cleanupInternal;
+    private pickEvictions;
+    private listAllFiles;
+}

package/dist/r2-file-store.js

@@ -0,0 +1,176 @@
+const PREFIX = "file/";
+const toId = (key) => key.startsWith(PREFIX) ? key.slice(PREFIX.length) : key;
+const toKey = (id) => `${PREFIX}${id}`;
+const parseCreatedAt = (value, fallback) => {
+    if (typeof value === "string" && value.trim().length > 0) {
+        const ms = Date.parse(value);
+        if (Number.isFinite(ms))
+            return new Date(ms).toISOString();
+    }
+    return fallback.toISOString();
+};
+const isExpired = (createdAtIso, ttlHours) => {
+    const ms = Date.parse(createdAtIso);
+    if (!Number.isFinite(ms))
+        return false;
+    return Date.now() - ms > ttlHours * 60 * 60 * 1000;
+};
+export class R2FileStore {
+    bucket;
+    policy;
+    constructor(bucket, policy) {
+        this.bucket = bucket;
+        this.policy = policy;
+    }
+    async put(input) {
+        const sizeBytes = input.bytes.byteLength;
+        if (sizeBytes > this.policy.maxFileBytes) {
+            const err = new Error(`file too large: ${sizeBytes} bytes exceeds maxFileBytes ${this.policy.maxFileBytes}`);
+            err.status = 413;
+            err.code = "FILE_TOO_LARGE";
+            err.details = { policy: this.policy, sizeBytes };
+            throw err;
+        }
+        await this.cleanupInternal(sizeBytes);
+        const id = crypto.randomUUID();
+        const createdAt = new Date().toISOString();
+        await this.bucket.put(toKey(id), input.bytes, {
+            httpMetadata: {
+                contentType: input.mimeType,
+            },
+            customMetadata: {
+                filename: input.filename,
+                mimeType: input.mimeType,
+                createdAt,
+            },
+        });
+        return { id, filename: input.filename, mimeType: input.mimeType, sizeBytes, createdAt };
+    }
+    async get(fileId) {
+        const obj = await this.bucket.get(toKey(fileId));
+        if (!obj)
+            return null;
+        const meta = (obj.customMetadata ?? {});
+        const createdAt = parseCreatedAt(meta.createdAt, obj.uploaded);
+        const filename = meta.filename ?? fileId;
+        const mimeType = meta.mimeType ?? obj.httpMetadata?.contentType ?? "application/octet-stream";
+        const bytes = new Uint8Array(await obj.arrayBuffer());
+        return {
+            id: fileId,
+            filename,
+            mimeType,
+            sizeBytes: bytes.byteLength,
+            createdAt,
+            bytes,
+        };
+    }
+    async list() {
+        return await this.listAllFiles();
+    }
+    async delete(fileId) {
+        await this.bucket.delete(toKey(fileId));
+        return true;
+    }
+    async stats() {
+        const files = await this.listAllFiles();
+        const totalBytes = files.reduce((sum, file) => sum + file.sizeBytes, 0);
+        return {
+            backend: "r2",
+            policy: this.policy,
+            stats: {
+                fileCount: files.length,
+                totalBytes,
+            },
+        };
+    }
+    async cleanup() {
+        const files = await this.listAllFiles();
+        const expired = files.filter((f) => isExpired(f.createdAt, this.policy.ttlHours));
+        const active = files.filter((f) => !isExpired(f.createdAt, this.policy.ttlHours));
+        if (expired.length > 0) {
+            await this.bucket.delete(expired.map((f) => toKey(f.id)));
+        }
+        const evict = this.pickEvictions(active, 0);
+        if (evict.length > 0) {
+            await this.bucket.delete(evict.map((f) => toKey(f.id)));
+        }
+        const evictIds = new Set(evict.map((f) => f.id));
+        const after = active.filter((f) => !evictIds.has(f.id));
+        const totalBytes = after.reduce((sum, file) => sum + file.sizeBytes, 0);
+        return {
+            backend: "r2",
+            policy: this.policy,
+            deletedExpired: expired.length,
+            deletedEvicted: evict.length,
+            stats: {
+                fileCount: after.length,
+                totalBytes,
+            },
+        };
+    }
+    async cleanupInternal(incomingBytes) {
+        const files = await this.listAllFiles();
+        const expired = files.filter((f) => isExpired(f.createdAt, this.policy.ttlHours));
+        const active = files.filter((f) => !isExpired(f.createdAt, this.policy.ttlHours));
+        if (expired.length > 0) {
+            await this.bucket.delete(expired.map((f) => toKey(f.id)));
+        }
+        const evict = this.pickEvictions(active, incomingBytes);
+        if (evict.length > 0) {
+            await this.bucket.delete(evict.map((f) => toKey(f.id)));
+        }
+        const evictIds = new Set(evict.map((f) => f.id));
+        const remaining = active.filter((f) => !evictIds.has(f.id));
+        const finalTotal = remaining.reduce((sum, file) => sum + file.sizeBytes, 0);
+        if (finalTotal + incomingBytes > this.policy.maxTotalBytes) {
+            const err = new Error(`storage quota exceeded: total ${finalTotal} + incoming ${incomingBytes} > maxTotalBytes ${this.policy.maxTotalBytes}`);
+            err.status = 507;
+            err.code = "STORAGE_QUOTA_EXCEEDED";
+            err.details = { policy: this.policy, totalBytes: finalTotal, incomingBytes };
+            throw err;
+        }
+    }
+    pickEvictions(files, incomingBytes) {
+        const totalBytes = files.reduce((sum, f) => sum + f.sizeBytes, 0);
+        const projected = totalBytes + incomingBytes;
+        if (projected <= this.policy.maxTotalBytes)
+            return [];
+        const needFree = projected - this.policy.maxTotalBytes;
+        const candidates = [...files].sort((a, b) => Date.parse(a.createdAt) - Date.parse(b.createdAt));
+        const evict = [];
+        let freed = 0;
+        for (const file of candidates) {
+            evict.push(file);
+            freed += file.sizeBytes;
+            if (freed >= needFree)
+                break;
+            if (evict.length >= this.policy.cleanupBatchSize)
+                break;
+        }
+        return evict;
+    }
+    async listAllFiles() {
+        const files = [];
+        let cursor;
+        while (true) {
+            const listed = await this.bucket.list({ prefix: PREFIX, limit: 1000, cursor });
+            for (const obj of listed.objects) {
+                const meta = (obj.customMetadata ?? {});
+                const createdAt = parseCreatedAt(meta.createdAt, obj.uploaded);
+                const filename = meta.filename ?? toId(obj.key);
+                const mimeType = meta.mimeType ?? obj.httpMetadata?.contentType ?? "application/octet-stream";
+                files.push({
+                    id: toId(obj.key),
+                    filename,
+                    mimeType,
+                    sizeBytes: obj.size,
+                    createdAt,
+                });
+            }
+            if (listed.truncated !== true || !listed.cursor)
+                break;
+            cursor = listed.cursor;
+        }
+        return files;
+    }
+}

package/dist/response-schema.d.ts

@@ -0,0 +1,15 @@
+export interface ToolArtifact {
+    readonly id?: string;
+    readonly kind: "image" | "pdf" | "file" | "json" | "text";
+    readonly mimeType?: string;
+    readonly filename?: string;
+    readonly sizeBytes?: number;
+    readonly url?: string;
+}
+export interface ToolOutputEnvelope {
+    readonly ok: true;
+    readonly data: unknown;
+    readonly artifacts: ToolArtifact[];
+}
+export declare const buildToolOutputEnvelope: (result: unknown, baseUrl: string) => ToolOutputEnvelope;
+export declare const buildMcpContent: (envelope: ToolOutputEnvelope) => Array<Record<string, unknown>>;