@echofiles/echo-pdf 0.4.1 → 0.4.3

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 };

package/dist/worker.js

@@ -0,0 +1,386 @@
+import { normalizeReturnMode } from "./file-utils.js";
+import { FileStoreDO } from "./file-store-do.js";
+import { resolveModelForProvider, resolveProviderAlias } from "./agent-defaults.js";
+import { checkHeaderAuth } from "./auth.js";
+import { handleMcpRequest } from "./mcp-server.js";
+import { loadEchoPdfConfig } from "./pdf-config.js";
+import { getRuntimeFileStore } from "./pdf-storage.js";
+import { listProviderModels } from "./provider-client.js";
+import { buildToolOutputEnvelope } from "./response-schema.js";
+import { callTool, listToolSchemas } from "./tool-registry.js";
+const json = (data, status = 200) => new Response(JSON.stringify(data), {
+    status,
+    headers: {
+        "Content-Type": "application/json; charset=utf-8",
+        "Cache-Control": "no-store",
+    },
+});
+const toError = (error) => error instanceof Error ? error.message : String(error);
+const errorStatus = (error) => {
+    const status = error?.status;
+    return typeof status === "number" && Number.isFinite(status) ? status : null;
+};
+const errorCode = (error) => {
+    const code = error?.code;
+    return typeof code === "string" && code.length > 0 ? code : null;
+};
+const errorDetails = (error) => error?.details;
+const jsonError = (error, fallbackStatus = 500) => {
+    const status = errorStatus(error) ?? fallbackStatus;
+    const code = errorCode(error);
+    const details = errorDetails(error);
+    return json({ error: toError(error), code, details }, status);
+};
+const readJson = async (request) => {
+    try {
+        const body = await request.json();
+        if (typeof body === "object" && body !== null && !Array.isArray(body)) {
+            return body;
+        }
+        return {};
+    }
+    catch {
+        return {};
+    }
+};
+const asObj = (value) => typeof value === "object" && value !== null && !Array.isArray(value)
+    ? value
+    : {};
+const resolvePublicBaseUrl = (request, configured) => typeof configured === "string" && configured.length > 0 ? configured : request.url;
+const sanitizeDownloadFilename = (filename) => {
+    const cleaned = filename
+        .replace(/[\r\n"]/g, "")
+        .replace(/[^\x20-\x7E]+/g, "")
+        .trim();
+    return cleaned.length > 0 ? cleaned : "download.bin";
+};
+const sseResponse = (stream) => new Response(stream, {
+    headers: {
+        "Content-Type": "text/event-stream; charset=utf-8",
+        "Cache-Control": "no-store",
+        Connection: "keep-alive",
+    },
+});
+const encodeSse = (event, data) => {
+    const encoder = new TextEncoder();
+    return encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+};
+const isValidOperation = (value) => value === "extract_pages" || value === "ocr_pages" || value === "tables_to_latex";
+const toPdfOperation = (input, defaultProvider) => ({
+    operation: isValidOperation(input.operation) ? input.operation : "extract_pages",
+    fileId: typeof input.fileId === "string" ? input.fileId : undefined,
+    url: typeof input.url === "string" ? input.url : undefined,
+    base64: typeof input.base64 === "string" ? input.base64 : undefined,
+    filename: typeof input.filename === "string" ? input.filename : undefined,
+    pages: Array.isArray(input.pages) ? input.pages.map((v) => Number(v)) : [],
+    renderScale: typeof input.renderScale === "number" ? input.renderScale : undefined,
+    provider: typeof input.provider === "string" ? input.provider : defaultProvider,
+    model: typeof input.model === "string" ? input.model : "",
+    providerApiKeys: typeof input.providerApiKeys === "object" && input.providerApiKeys !== null
+        ? input.providerApiKeys
+        : undefined,
+    returnMode: normalizeReturnMode(input.returnMode),
+    prompt: typeof input.prompt === "string" ? input.prompt : undefined,
+});
+const toolNameByOperation = {
+    extract_pages: "pdf_extract_pages",
+    ocr_pages: "pdf_ocr_pages",
+    tables_to_latex: "pdf_tables_to_latex",
+};
+const operationArgsFromRequest = (request) => {
+    const args = {
+        pages: request.pages,
+    };
+    if (request.fileId)
+        args.fileId = request.fileId;
+    if (request.url)
+        args.url = request.url;
+    if (request.base64)
+        args.base64 = request.base64;
+    if (request.filename)
+        args.filename = request.filename;
+    if (typeof request.renderScale === "number")
+        args.renderScale = request.renderScale;
+    if (request.returnMode)
+        args.returnMode = request.returnMode;
+    if (request.provider)
+        args.provider = request.provider;
+    if (request.model)
+        args.model = request.model;
+    if (request.prompt)
+        args.prompt = request.prompt;
+    return args;
+};
+const checkComputeAuth = (request, env, config) => checkHeaderAuth(request, env, {
+    authHeader: config.service.computeAuth?.authHeader,
+    authEnv: config.service.computeAuth?.authEnv,
+    allowMissingSecret: false,
+    misconfiguredCode: "COMPUTE_AUTH_MISCONFIGURED",
+    unauthorizedCode: "UNAUTHORIZED",
+    contextName: "compute endpoint",
+});
+export default {
+    async fetch(request, env, ctx) {
+        const url = new URL(request.url);
+        const config = loadEchoPdfConfig(env);
+        const runtimeStore = getRuntimeFileStore(env, config);
+        const fileStore = runtimeStore.store;
+        if (request.method === "GET" && url.pathname === "/health") {
+            return json({ ok: true, service: config.service.name, now: new Date().toISOString() });
+        }
+        if (request.method === "GET" && url.pathname === "/config") {
+            return json({
+                service: config.service,
+                agent: config.agent,
+                providers: Object.entries(config.providers).map(([alias, provider]) => ({ alias, type: provider.type })),
+                capabilities: {
+                    toolCatalogEndpoint: "/tools/catalog",
+                    toolCallEndpoint: "/tools/call",
+                    fileOpsEndpoint: "/api/files/op",
+                    fileUploadEndpoint: "/api/files/upload",
+                    fileStatsEndpoint: "/api/files/stats",
+                    fileCleanupEndpoint: "/api/files/cleanup",
+                    supportedReturnModes: ["inline", "file_id", "url"],
+                },
+                mcp: {
+                    serverName: config.mcp.serverName,
+                    version: config.mcp.version,
+                    authHeader: config.mcp.authHeader ?? null,
+                },
+                fileGet: {
+                    authHeader: config.service.fileGet?.authHeader ?? null,
+                    cacheTtlSeconds: config.service.fileGet?.cacheTtlSeconds ?? 300,
+                },
+            });
+        }
+        if (request.method === "GET" && url.pathname === "/tools/catalog") {
+            return json({ tools: listToolSchemas() });
+        }
+        if (request.method === "POST" && url.pathname === "/tools/call") {
+            const auth = checkComputeAuth(request, env, config);
+            if (!auth.ok)
+                return json({ error: auth.message, code: auth.code }, auth.status);
+            const body = await readJson(request);
+            const name = typeof body.name === "string" ? body.name : "";
+            if (!name)
+                return json({ error: "Missing required field: name" }, 400);
+            try {
+                const args = asObj(body.arguments);
+                const preferredProvider = resolveProviderAlias(config, typeof body.provider === "string" ? body.provider : undefined);
+                const preferredModel = resolveModelForProvider(config, preferredProvider, typeof body.model === "string" ? body.model : undefined);
+                if (name === "pdf_ocr_pages" || name === "pdf_tables_to_latex") {
+                    if (typeof args.provider !== "string" || args.provider.length === 0) {
+                        args.provider = preferredProvider;
+                    }
+                    if (typeof args.model !== "string" || args.model.length === 0) {
+                        args.model = preferredModel;
+                    }
+                }
+                const result = await callTool(name, args, {
+                    config,
+                    env,
+                    fileStore,
+                    providerApiKeys: typeof body.providerApiKeys === "object" && body.providerApiKeys !== null
+                        ? body.providerApiKeys
+                        : undefined,
+                });
+                return json(buildToolOutputEnvelope(result, resolvePublicBaseUrl(request, config.service.publicBaseUrl)));
+            }
+            catch (error) {
+                return jsonError(error, 500);
+            }
+        }
+        if (request.method === "POST" && url.pathname === "/providers/models") {
+            const auth = checkComputeAuth(request, env, config);
+            if (!auth.ok)
+                return json({ error: auth.message, code: auth.code }, auth.status);
+            const body = await readJson(request);
+            const provider = resolveProviderAlias(config, typeof body.provider === "string" ? body.provider : undefined);
+            const runtimeKeys = typeof body.providerApiKeys === "object" && body.providerApiKeys !== null
+                ? body.providerApiKeys
+                : undefined;
+            try {
+                const models = await listProviderModels(config, env, provider, runtimeKeys);
+                return json({ provider, models });
+            }
+            catch (error) {
+                return jsonError(error, 500);
+            }
+        }
+        if (request.method === "POST" && url.pathname === "/api/agent/run") {
+            const auth = checkComputeAuth(request, env, config);
+            if (!auth.ok)
+                return json({ error: auth.message, code: auth.code }, auth.status);
+            const body = await readJson(request);
+            if (Object.hasOwn(body, "operation") && !isValidOperation(body.operation)) {
+                return json({ error: "Invalid operation. Must be one of: extract_pages, ocr_pages, tables_to_latex" }, 400);
+            }
+            const requestPayload = toPdfOperation(body, config.agent.defaultProvider);
+            try {
+                const result = await callTool(toolNameByOperation[requestPayload.operation], operationArgsFromRequest(requestPayload), {
+                    config,
+                    env,
+                    fileStore,
+                    providerApiKeys: requestPayload.providerApiKeys,
+                });
+                return json(result);
+            }
+            catch (error) {
+                return jsonError(error, 500);
+            }
+        }
+        if (request.method === "POST" && url.pathname === "/api/agent/stream") {
+            const auth = checkComputeAuth(request, env, config);
+            if (!auth.ok)
+                return json({ error: auth.message, code: auth.code }, auth.status);
+            const body = await readJson(request);
+            if (Object.hasOwn(body, "operation") && !isValidOperation(body.operation)) {
+                return json({ error: "Invalid operation. Must be one of: extract_pages, ocr_pages, tables_to_latex" }, 400);
+            }
+            const requestPayload = toPdfOperation(body, config.agent.defaultProvider);
+            const stream = new TransformStream();
+            const writer = stream.writable.getWriter();
+            let queue = Promise.resolve();
+            const send = (event, data) => {
+                queue = queue.then(() => writer.write(encodeSse(event, data))).catch(() => undefined);
+            };
+            const run = async () => {
+                try {
+                    send("meta", { kind: "meta", startedAt: new Date().toISOString(), streaming: true });
+                    send("io", { kind: "io", direction: "input", content: requestPayload });
+                    const result = await callTool(toolNameByOperation[requestPayload.operation], operationArgsFromRequest(requestPayload), {
+                        config,
+                        env,
+                        fileStore,
+                        providerApiKeys: requestPayload.providerApiKeys,
+                        trace: (event) => send("step", event),
+                    });
+                    send("io", { kind: "io", direction: "output", content: "operation completed" });
+                    send("result", { kind: "result", output: result });
+                    send("done", { ok: true });
+                }
+                catch (error) {
+                    send("error", { kind: "error", message: toError(error) });
+                    send("done", { ok: false });
+                }
+                finally {
+                    await queue;
+                    await writer.close();
+                }
+            };
+            ctx.waitUntil(run());
+            return sseResponse(stream.readable);
+        }
+        if (request.method === "POST" && url.pathname === "/api/files/op") {
+            const body = await readJson(request);
+            try {
+                const result = await callTool("file_ops", asObj(body), {
+                    config,
+                    env,
+                    fileStore,
+                });
+                return json(result);
+            }
+            catch (error) {
+                return jsonError(error, 500);
+            }
+        }
+        if (request.method === "POST" && url.pathname === "/api/files/upload") {
+            try {
+                const formData = await request.formData();
+                const file = formData.get("file");
+                if (!file || typeof file.arrayBuffer !== "function") {
+                    return json({ error: "Missing file field: file" }, 400);
+                }
+                const bytes = new Uint8Array(await file.arrayBuffer());
+                const stored = await fileStore.put({
+                    filename: file.name || `upload-${Date.now()}.pdf`,
+                    mimeType: file.type || "application/pdf",
+                    bytes,
+                });
+                return json({ file: stored }, 200);
+            }
+            catch (error) {
+                return jsonError(error, 500);
+            }
+        }
+        if (request.method === "GET" && url.pathname === "/api/files/get") {
+            const fileGetConfig = config.service.fileGet ?? {};
+            const auth = checkHeaderAuth(request, env, {
+                authHeader: fileGetConfig.authHeader,
+                authEnv: fileGetConfig.authEnv,
+                allowMissingSecret: env.ECHO_PDF_ALLOW_MISSING_AUTH_SECRET === "1",
+                misconfiguredCode: "AUTH_MISCONFIGURED",
+                unauthorizedCode: "UNAUTHORIZED",
+                contextName: "file get",
+            });
+            if (!auth.ok) {
+                return json({ error: auth.message, code: auth.code }, auth.status);
+            }
+            const fileId = url.searchParams.get("fileId") || "";
+            if (!fileId)
+                return json({ error: "Missing fileId" }, 400);
+            const file = await fileStore.get(fileId);
+            if (!file)
+                return json({ error: "File not found" }, 404);
+            const download = url.searchParams.get("download") === "1";
+            const headers = new Headers();
+            headers.set("Content-Type", file.mimeType);
+            const cacheTtl = Number(fileGetConfig.cacheTtlSeconds ?? 300);
+            const cacheControl = cacheTtl > 0
+                ? `public, max-age=${Math.floor(cacheTtl)}, s-maxage=${Math.floor(cacheTtl)}`
+                : "no-store";
+            headers.set("Cache-Control", cacheControl);
+            if (download) {
+                headers.set("Content-Disposition", `attachment; filename=\"${sanitizeDownloadFilename(file.filename)}\"`);
+            }
+            return new Response(file.bytes, { status: 200, headers });
+        }
+        if (request.method === "GET" && url.pathname === "/api/files/stats") {
+            try {
+                return json(await runtimeStore.stats(), 200);
+            }
+            catch (error) {
+                return json({ error: toError(error) }, 500);
+            }
+        }
+        if (request.method === "POST" && url.pathname === "/api/files/cleanup") {
+            try {
+                return json(await runtimeStore.cleanup(), 200);
+            }
+            catch (error) {
+                return json({ error: toError(error) }, 500);
+            }
+        }
+        if (request.method === "POST" && url.pathname === "/mcp") {
+            return await handleMcpRequest(request, env, config, fileStore);
+        }
+        if (request.method === "GET" && env.ASSETS) {
+            const assetReq = url.pathname === "/"
+                ? new Request(new URL("/index.html", url), request)
+                : request;
+            const asset = await env.ASSETS.fetch(assetReq);
+            if (asset.status !== 404)
+                return asset;
+        }
+        return json({
+            error: "Not found",
+            routes: {
+                health: "GET /health",
+                config: "GET /config",
+                toolsCatalog: "GET /tools/catalog",
+                toolCall: "POST /tools/call",
+                models: "POST /providers/models",
+                run: "POST /api/agent/run",
+                stream: "POST /api/agent/stream",
+                files: "POST /api/files/op",
+                fileUpload: "POST /api/files/upload",
+                fileGet: "GET /api/files/get?fileId=<id>",
+                fileStats: "GET /api/files/stats",
+                fileCleanup: "POST /api/files/cleanup",
+                mcp: "POST /mcp",
+            },
+        }, 404);
+    },
+};
+export { FileStoreDO };