@echofiles/echo-pdf 0.4.3 → 0.6.0

package/dist/r2-file-store.js

@@ -1,176 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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>>;

package/dist/response-schema.js

@@ -1,159 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,175 +0,0 @@
-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/worker.d.ts

@@ -1,7 +0,0 @@
-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 };