@echofiles/echo-pdf 0.4.1 → 0.4.2

package/dist/response-schema.js

@@ -0,0 +1,159 @@
+const MAX_TEXT_STRING = 1200;
+const MAX_TEXT_ARRAY = 40;
+const MAX_TEXT_DEPTH = 8;
+const asObj = (value) => typeof value === "object" && value !== null && !Array.isArray(value)
+    ? value
+    : {};
+const inferKind = (mimeType) => {
+    const mime = (mimeType || "").toLowerCase();
+    if (mime.startsWith("image/"))
+        return "image";
+    if (mime === "application/pdf")
+        return "pdf";
+    if (mime.includes("json"))
+        return "json";
+    if (mime.startsWith("text/"))
+        return "text";
+    return "file";
+};
+const toAbsoluteUrl = (value, baseUrl) => {
+    try {
+        return new URL(value, baseUrl).toString();
+    }
+    catch {
+        return value;
+    }
+};
+const addArtifact = (artifacts, artifact) => {
+    if (!artifact.id && !artifact.url && !artifact.filename)
+        return;
+    artifacts.push(artifact);
+};
+export const buildToolOutputEnvelope = (result, baseUrl) => {
+    const root = asObj(result);
+    const artifacts = [];
+    const fileMeta = asObj(root.file);
+    if (typeof fileMeta.id === "string") {
+        addArtifact(artifacts, {
+            id: fileMeta.id,
+            kind: inferKind(typeof fileMeta.mimeType === "string" ? fileMeta.mimeType : undefined),
+            mimeType: typeof fileMeta.mimeType === "string" ? fileMeta.mimeType : undefined,
+            filename: typeof fileMeta.filename === "string" ? fileMeta.filename : undefined,
+            sizeBytes: typeof fileMeta.sizeBytes === "number" ? fileMeta.sizeBytes : undefined,
+            url: typeof root.url === "string" ? toAbsoluteUrl(root.url, baseUrl) : undefined,
+        });
+    }
+    const images = Array.isArray(root.images) ? root.images : [];
+    for (const item of images) {
+        const image = asObj(item);
+        const fileId = typeof image.fileId === "string" ? image.fileId : undefined;
+        const rawUrl = typeof image.url === "string" ? image.url : undefined;
+        if (!fileId && !rawUrl)
+            continue;
+        addArtifact(artifacts, {
+            id: fileId,
+            kind: "image",
+            mimeType: typeof image.mimeType === "string" ? image.mimeType : "image/png",
+            filename: fileId ? `artifact-${fileId}.png` : undefined,
+            url: rawUrl ? toAbsoluteUrl(rawUrl, baseUrl) : undefined,
+        });
+    }
+    const files = Array.isArray(root.files) ? root.files : [];
+    for (const item of files) {
+        const meta = asObj(item);
+        if (typeof meta.id !== "string")
+            continue;
+        addArtifact(artifacts, {
+            id: meta.id,
+            kind: inferKind(typeof meta.mimeType === "string" ? meta.mimeType : undefined),
+            mimeType: typeof meta.mimeType === "string" ? meta.mimeType : undefined,
+            filename: typeof meta.filename === "string" ? meta.filename : undefined,
+            sizeBytes: typeof meta.sizeBytes === "number" ? meta.sizeBytes : undefined,
+        });
+    }
+    return {
+        ok: true,
+        data: result,
+        artifacts,
+    };
+};
+const summarizeData = (data) => {
+    const root = asObj(data);
+    if (typeof root.returnMode === "string" && Array.isArray(root.images)) {
+        return `Extracted ${root.images.length} page image(s) in returnMode=${root.returnMode}.`;
+    }
+    if (Array.isArray(root.pages)) {
+        return `Processed ${root.pages.length} page(s).`;
+    }
+    if (Array.isArray(root.files)) {
+        return `Listed ${root.files.length} file(s).`;
+    }
+    if (typeof root.deleted === "boolean") {
+        return root.deleted ? "File deleted." : "File not found.";
+    }
+    return "Tool executed successfully.";
+};
+const sanitizeString = (value) => {
+    if (value.startsWith("data:")) {
+        const [head] = value.split(",", 1);
+        return `${head},<omitted>`;
+    }
+    if (/^[A-Za-z0-9+/=]{300,}$/.test(value)) {
+        return `<base64 omitted len=${value.length}>`;
+    }
+    if (value.length > MAX_TEXT_STRING) {
+        return `${value.slice(0, MAX_TEXT_STRING)}...(truncated ${value.length - MAX_TEXT_STRING} chars)`;
+    }
+    return value;
+};
+const sanitizeForText = (value, depth = 0) => {
+    if (depth >= MAX_TEXT_DEPTH)
+        return "<max-depth>";
+    if (typeof value === "string")
+        return sanitizeString(value);
+    if (typeof value !== "object" || value === null)
+        return value;
+    if (Array.isArray(value)) {
+        const items = value.slice(0, MAX_TEXT_ARRAY).map((item) => sanitizeForText(item, depth + 1));
+        if (value.length > MAX_TEXT_ARRAY) {
+            items.push(`<truncated ${value.length - MAX_TEXT_ARRAY} items>`);
+        }
+        return items;
+    }
+    const out = {};
+    for (const [key, nested] of Object.entries(value)) {
+        out[key] = sanitizeForText(nested, depth + 1);
+    }
+    return out;
+};
+export const buildMcpContent = (envelope) => {
+    const lines = [summarizeData(envelope.data)];
+    if (envelope.artifacts.length > 0) {
+        lines.push("Artifacts:");
+        for (const artifact of envelope.artifacts) {
+            const descriptor = [
+                artifact.kind,
+                artifact.filename ?? artifact.id ?? "artifact",
+                artifact.mimeType ?? "",
+                artifact.url ?? "",
+            ]
+                .filter((v) => v.length > 0)
+                .join(" | ");
+            lines.push(`- ${descriptor}`);
+        }
+    }
+    lines.push("");
+    lines.push(JSON.stringify(sanitizeForText(envelope), null, 2));
+    const content = [{ type: "text", text: lines.join("\n") }];
+    for (const artifact of envelope.artifacts) {
+        if (!artifact.url)
+            continue;
+        content.push({
+            type: "resource_link",
+            name: artifact.filename ?? artifact.id ?? "artifact",
+            uri: artifact.url,
+            mimeType: artifact.mimeType ?? "application/octet-stream",
+        });
+    }
+    return content;
+};

package/dist/tool-registry.d.ts

@@ -0,0 +1,16 @@
+import type { EchoPdfConfig, ToolSchema } from "./pdf-types.js";
+import type { Env, FileStore } from "./types.js";
+export interface ToolRuntimeContext {
+    readonly config: EchoPdfConfig;
+    readonly env: Env;
+    readonly fileStore: FileStore;
+    readonly providerApiKeys?: Record<string, string>;
+    readonly trace?: (event: {
+        kind: "step";
+        phase: "start" | "end" | "log";
+        name: string;
+        payload?: unknown;
+    }) => void;
+}
+export declare const listToolSchemas: () => ReadonlyArray<ToolSchema>;
+export declare const callTool: (name: string, args: unknown, ctx: ToolRuntimeContext) => Promise<unknown>;

package/dist/tool-registry.js

@@ -0,0 +1,175 @@
+import { normalizeReturnMode } from "./file-utils.js";
+import { runFileOp } from "./file-ops.js";
+import { runPdfAgent } from "./pdf-agent.js";
+const asNumberArray = (value) => Array.isArray(value) ? value.map((item) => Number(item)).filter((item) => Number.isInteger(item) && item > 0) : [];
+const asObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value)
+    ? value
+    : {};
+const readString = (obj, key) => {
+    const value = obj[key];
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+};
+const toolDefinitions = [
+    {
+        schema: {
+            name: "pdf_extract_pages",
+            description: "Render specific PDF pages to image and return inline/file_id/url mode.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    fileId: { type: "string" },
+                    url: { type: "string" },
+                    base64: { type: "string" },
+                    filename: { type: "string" },
+                    pages: { type: "array", items: { type: "integer" } },
+                    renderScale: { type: "number" },
+                    returnMode: { type: "string", enum: ["inline", "file_id", "url"] },
+                },
+                required: ["pages"],
+            },
+            source: { kind: "local", toolName: "pdf.extract_pages" },
+        },
+        run: async (ctx, args) => {
+            const req = {
+                operation: "extract_pages",
+                fileId: readString(args, "fileId"),
+                url: readString(args, "url"),
+                base64: readString(args, "base64"),
+                filename: readString(args, "filename"),
+                pages: asNumberArray(args.pages),
+                renderScale: typeof args.renderScale === "number" ? args.renderScale : undefined,
+                provider: undefined,
+                model: "not-required",
+                providerApiKeys: ctx.providerApiKeys,
+                returnMode: normalizeReturnMode(args.returnMode),
+            };
+            return runPdfAgent(ctx.config, ctx.env, req, {
+                fileStore: ctx.fileStore,
+                trace: ctx.trace,
+            });
+        },
+    },
+    {
+        schema: {
+            name: "pdf_ocr_pages",
+            description: "OCR specific PDF pages using configured multimodal model.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    fileId: { type: "string" },
+                    url: { type: "string" },
+                    base64: { type: "string" },
+                    filename: { type: "string" },
+                    pages: { type: "array", items: { type: "integer" } },
+                    renderScale: { type: "number" },
+                    provider: { type: "string" },
+                    model: { type: "string" },
+                    prompt: { type: "string" },
+                },
+                required: ["pages"],
+            },
+            source: { kind: "local", toolName: "pdf.ocr_pages" },
+        },
+        run: async (ctx, args) => {
+            const req = {
+                operation: "ocr_pages",
+                fileId: readString(args, "fileId"),
+                url: readString(args, "url"),
+                base64: readString(args, "base64"),
+                filename: readString(args, "filename"),
+                pages: asNumberArray(args.pages),
+                renderScale: typeof args.renderScale === "number" ? args.renderScale : undefined,
+                provider: readString(args, "provider"),
+                model: readString(args, "model") ?? "",
+                prompt: readString(args, "prompt"),
+                providerApiKeys: ctx.providerApiKeys,
+                returnMode: "inline",
+            };
+            return runPdfAgent(ctx.config, ctx.env, req, {
+                fileStore: ctx.fileStore,
+                trace: ctx.trace,
+            });
+        },
+    },
+    {
+        schema: {
+            name: "pdf_tables_to_latex",
+            description: "Recognize tables from pages and return LaTeX tabular output.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    fileId: { type: "string" },
+                    url: { type: "string" },
+                    base64: { type: "string" },
+                    filename: { type: "string" },
+                    pages: { type: "array", items: { type: "integer" } },
+                    renderScale: { type: "number" },
+                    provider: { type: "string" },
+                    model: { type: "string" },
+                    prompt: { type: "string" },
+                },
+                required: ["pages"],
+            },
+            source: { kind: "local", toolName: "pdf.tables_to_latex" },
+        },
+        run: async (ctx, args) => {
+            const req = {
+                operation: "tables_to_latex",
+                fileId: readString(args, "fileId"),
+                url: readString(args, "url"),
+                base64: readString(args, "base64"),
+                filename: readString(args, "filename"),
+                pages: asNumberArray(args.pages),
+                renderScale: typeof args.renderScale === "number" ? args.renderScale : undefined,
+                provider: readString(args, "provider"),
+                model: readString(args, "model") ?? "",
+                prompt: readString(args, "prompt"),
+                providerApiKeys: ctx.providerApiKeys,
+                returnMode: "inline",
+            };
+            return runPdfAgent(ctx.config, ctx.env, req, {
+                fileStore: ctx.fileStore,
+                trace: ctx.trace,
+            });
+        },
+    },
+    {
+        schema: {
+            name: "file_ops",
+            description: "Basic file operations: list/read/delete/put for runtime file store.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    op: { type: "string", enum: ["list", "read", "delete", "put"] },
+                    fileId: { type: "string" },
+                    includeBase64: { type: "boolean" },
+                    text: { type: "string" },
+                    filename: { type: "string" },
+                    mimeType: { type: "string" },
+                    base64: { type: "string" },
+                    returnMode: { type: "string", enum: ["inline", "file_id", "url"] },
+                },
+                required: ["op"],
+            },
+            source: { kind: "local", toolName: "file.ops" },
+        },
+        run: async (ctx, args) => runFileOp(ctx.fileStore, {
+            op: readString(args, "op") ?? "list",
+            fileId: readString(args, "fileId"),
+            includeBase64: Boolean(args.includeBase64),
+            text: readString(args, "text"),
+            filename: readString(args, "filename"),
+            mimeType: readString(args, "mimeType"),
+            base64: readString(args, "base64"),
+            returnMode: normalizeReturnMode(args.returnMode),
+        }),
+    },
+];
+export const listToolSchemas = () => toolDefinitions.map((item) => item.schema);
+export const callTool = async (name, args, ctx) => {
+    const definition = toolDefinitions.find((item) => item.schema.name === name);
+    if (!definition) {
+        throw new Error(`Unknown tool: ${name}`);
+    }
+    return definition.run(ctx, asObject(args));
+};

package/dist/types.d.ts

@@ -0,0 +1,91 @@
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+export type JsonArray = JsonValue[];
+export interface JsonObject {
+    [key: string]: JsonValue;
+}
+export type ProviderType = "openai" | "openrouter" | "vercel-ai-gateway";
+export type ReturnMode = "inline" | "file_id" | "url";
+export interface Fetcher {
+    fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+}
+export interface DurableObjectStub {
+    fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+}
+export interface DurableObjectId {
+}
+export interface DurableObjectNamespace {
+    idFromName(name: string): DurableObjectId;
+    get(id: DurableObjectId): DurableObjectStub;
+}
+export interface DurableObjectStorage {
+    get<T>(key: string): Promise<T | undefined>;
+    put<T>(key: string, value: T): Promise<void>;
+    list<T>(options?: {
+        prefix?: string;
+    }): Promise<Map<string, T>>;
+    delete(key: string): Promise<boolean>;
+}
+export interface DurableObjectState {
+    storage: DurableObjectStorage;
+}
+export interface R2ObjectBody {
+    key: string;
+    size: number;
+    uploaded: Date;
+    httpMetadata?: {
+        contentType?: string;
+    };
+    customMetadata?: Record<string, string>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+}
+export interface R2Bucket {
+    put(key: string, value: ArrayBuffer | ArrayBufferView, options?: {
+        httpMetadata?: {
+            contentType?: string;
+        };
+        customMetadata?: Record<string, string>;
+    }): Promise<unknown>;
+    get(key: string): Promise<R2ObjectBody | null>;
+    delete(key: string | string[]): Promise<void>;
+    list(options?: {
+        prefix?: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<{
+        objects: R2ObjectBody[];
+        truncated: boolean;
+        cursor?: string;
+    }>;
+}
+export interface Env {
+    readonly ECHO_PDF_CONFIG_JSON?: string;
+    readonly ASSETS?: Fetcher;
+    readonly FILE_STORE_BUCKET?: R2Bucket;
+    readonly FILE_STORE_DO?: DurableObjectNamespace;
+    readonly [key: string]: string | Fetcher | DurableObjectNamespace | R2Bucket | undefined;
+}
+export interface WorkerExecutionContext {
+    waitUntil(promise: Promise<unknown>): void;
+    passThroughOnException?(): void;
+}
+export interface StoredFileMeta {
+    readonly id: string;
+    readonly filename: string;
+    readonly mimeType: string;
+    readonly sizeBytes: number;
+    readonly createdAt: string;
+}
+export interface StoredFileRecord extends StoredFileMeta {
+    readonly bytes: Uint8Array;
+}
+export interface FileStore {
+    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>;
+}

package/dist/types.js

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

package/dist/worker.d.ts

@@ -0,0 +1,7 @@
+import { FileStoreDO } from "./file-store-do.js";
+import type { Env, WorkerExecutionContext } from "./types.js";
+declare const _default: {
+    fetch(request: Request, env: Env, ctx: WorkerExecutionContext): Promise<Response>;
+};
+export default _default;
+export { FileStoreDO };