@echofiles/echo-pdf 0.2.0

package/src/file-utils.ts

@@ -0,0 +1,43 @@
+import type { ReturnMode, StoredFileRecord } from "./types"
+
+export const fromBase64 = (value: string): Uint8Array => {
+  const raw = atob(value.replace(/^data:.*;base64,/, ""))
+  const out = new Uint8Array(raw.length)
+  for (let i = 0; i < raw.length; i++) {
+    out[i] = raw.charCodeAt(i)
+  }
+  return out
+}
+
+export const toBase64 = (bytes: Uint8Array): string => {
+  let binary = ""
+  const chunkSize = 0x8000
+  for (let i = 0; i < bytes.length; i += chunkSize) {
+    const chunk = bytes.subarray(i, i + chunkSize)
+    binary += String.fromCharCode(...chunk)
+  }
+  return btoa(binary)
+}
+
+export const toDataUrl = (bytes: Uint8Array, mimeType: string): string =>
+  `data:${mimeType};base64,${toBase64(bytes)}`
+
+export const normalizeReturnMode = (value: unknown): ReturnMode => {
+  if (value === "file_id" || value === "url" || value === "inline") {
+    return value
+  }
+  return "inline"
+}
+
+export const toInlineFilePayload = (file: StoredFileRecord, includeBase64: boolean): Record<string, unknown> => ({
+  file: {
+    id: file.id,
+    filename: file.filename,
+    mimeType: file.mimeType,
+    sizeBytes: file.sizeBytes,
+    createdAt: file.createdAt,
+  },
+  dataUrl: file.mimeType.startsWith("image/") ? toDataUrl(file.bytes, file.mimeType) : undefined,
+  base64: includeBase64 ? toBase64(file.bytes) : undefined,
+  text: file.mimeType.startsWith("text/") ? new TextDecoder().decode(file.bytes) : undefined,
+})

package/src/index.ts

@@ -0,0 +1,334 @@
+import { normalizeReturnMode } from "./file-utils"
+import { FileStoreDO } from "./file-store-do"
+import { resolveModelForProvider, resolveProviderAlias } from "./agent-defaults"
+import { handleMcpRequest } from "./mcp-server"
+import { loadEchoPdfConfig } from "./pdf-config"
+import { getRuntimeFileStore } from "./pdf-storage"
+import { listProviderModels } from "./provider-client"
+import { callTool, listToolSchemas } from "./tool-registry"
+import type { AgentTraceEvent, PdfOperationRequest } from "./pdf-types"
+import type { Env, JsonObject } from "./types"
+
+const json = (data: unknown, status = 200): Response =>
+  new Response(JSON.stringify(data), {
+    status,
+    headers: {
+      "Content-Type": "application/json; charset=utf-8",
+      "Cache-Control": "no-store",
+    },
+  })
+
+const toError = (error: unknown): string =>
+  error instanceof Error ? error.message : String(error)
+
+const readJson = async (request: Request): Promise<Record<string, unknown>> => {
+  try {
+    const body = await request.json()
+    if (typeof body === "object" && body !== null && !Array.isArray(body)) {
+      return body as Record<string, unknown>
+    }
+    return {}
+  } catch {
+    return {}
+  }
+}
+
+const asObj = (value: unknown): JsonObject =>
+  typeof value === "object" && value !== null && !Array.isArray(value)
+    ? (value as JsonObject)
+    : {}
+
+const sseResponse = (stream: ReadableStream<Uint8Array>): Response =>
+  new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream; charset=utf-8",
+      "Cache-Control": "no-store",
+      Connection: "keep-alive",
+    },
+  })
+
+const encodeSse = (event: string, data: unknown): Uint8Array => {
+  const encoder = new TextEncoder()
+  return encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`)
+}
+
+const isValidOperation = (value: unknown): value is PdfOperationRequest["operation"] =>
+  value === "extract_pages" || value === "ocr_pages" || value === "tables_to_latex"
+
+const toPdfOperation = (input: Record<string, unknown>, defaultProvider: string): PdfOperationRequest => ({
+  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 as Record<string, string>)
+    : undefined,
+  returnMode: normalizeReturnMode(input.returnMode),
+  prompt: typeof input.prompt === "string" ? input.prompt : undefined,
+})
+
+const toolNameByOperation: Record<PdfOperationRequest["operation"], string> = {
+  extract_pages: "pdf_extract_pages",
+  ocr_pages: "pdf_ocr_pages",
+  tables_to_latex: "pdf_tables_to_latex",
+}
+
+const operationArgsFromRequest = (request: PdfOperationRequest): JsonObject => {
+  const args: JsonObject = {
+    pages: request.pages as unknown as JsonObject["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
+}
+
+export default {
+  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
+    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"],
+        },
+        mcp: {
+          serverName: config.mcp.serverName,
+          version: config.mcp.version,
+          authHeader: config.mcp.authHeader ?? null,
+        },
+      })
+    }
+
+    if (request.method === "GET" && url.pathname === "/tools/catalog") {
+      return json({ tools: listToolSchemas() })
+    }
+
+    if (request.method === "POST" && url.pathname === "/tools/call") {
+      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.startsWith("pdf_")) {
+          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 as Record<string, string>)
+            : undefined,
+        })
+        return json({ name, output: result })
+      } catch (error) {
+        return json({ error: toError(error) }, 500)
+      }
+    }
+
+    if (request.method === "POST" && url.pathname === "/providers/models") {
+      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 as Record<string, string>)
+        : undefined
+      try {
+        const models = await listProviderModels(config, env, provider, runtimeKeys)
+        return json({ provider, models })
+      } catch (error) {
+        return json({ error: toError(error) }, 500)
+      }
+    }
+
+    if (request.method === "POST" && url.pathname === "/api/agent/run") {
+      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 json({ error: toError(error) }, 500)
+      }
+    }
+
+    if (request.method === "POST" && url.pathname === "/api/agent/stream") {
+      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<Uint8Array, Uint8Array>()
+      const writer = stream.writable.getWriter()
+      let queue: Promise<void> = Promise.resolve()
+      const send = (event: string, data: unknown): void => {
+        queue = queue.then(() => writer.write(encodeSse(event, data))).catch(() => undefined)
+      }
+
+      const run = async (): Promise<void> => {
+        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: AgentTraceEvent) => 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 json({ error: toError(error) }, 500)
+      }
+    }
+
+    if (request.method === "POST" && url.pathname === "/api/files/upload") {
+      try {
+        const formData = await request.formData()
+        const file = formData.get("file") as {
+          readonly name?: string
+          readonly type?: string
+          arrayBuffer?: () => Promise<ArrayBuffer>
+        } | null
+        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 json({ error: toError(error) }, 500)
+      }
+    }
+
+    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",
+          fileStats: "GET /api/files/stats",
+          fileCleanup: "POST /api/files/cleanup",
+          mcp: "POST /mcp",
+        },
+      },
+      404
+    )
+  },
+}
+
+export { FileStoreDO }

package/src/mcp-server.ts

@@ -0,0 +1,109 @@
+import type { Env, FileStore } from "./types"
+import type { EchoPdfConfig } from "./pdf-types"
+import { callTool, listToolSchemas } from "./tool-registry"
+
+interface JsonRpcRequest {
+  readonly jsonrpc?: string
+  readonly id?: string | number | null
+  readonly method?: string
+  readonly params?: unknown
+}
+
+const ok = (id: JsonRpcRequest["id"], result: unknown): Response =>
+  new Response(
+    JSON.stringify({
+      jsonrpc: "2.0",
+      id: id ?? null,
+      result,
+    }),
+    { headers: { "Content-Type": "application/json" } }
+  )
+
+const err = (id: JsonRpcRequest["id"], code: number, message: string): Response =>
+  new Response(
+    JSON.stringify({
+      jsonrpc: "2.0",
+      id: id ?? null,
+      error: { code, message },
+    }),
+    { status: 400, headers: { "Content-Type": "application/json" } }
+  )
+
+const asObj = (v: unknown): Record<string, unknown> =>
+  typeof v === "object" && v !== null && !Array.isArray(v) ? (v as Record<string, unknown>) : {}
+
+const maybeAuthorized = (request: Request, env: Env, config: EchoPdfConfig): boolean => {
+  if (!config.mcp.authHeader || !config.mcp.authEnv) return true
+  const required = env[config.mcp.authEnv]
+  if (typeof required !== "string" || required.length === 0) return true
+  return request.headers.get(config.mcp.authHeader) === required
+}
+
+export const handleMcpRequest = async (
+  request: Request,
+  env: Env,
+  config: EchoPdfConfig,
+  fileStore: FileStore
+): Promise<Response> => {
+  if (!maybeAuthorized(request, env, config)) {
+    return new Response("Unauthorized", { status: 401 })
+  }
+
+  let body: JsonRpcRequest
+  try {
+    body = (await request.json()) as JsonRpcRequest
+  } catch {
+    return err(null, -32700, "Parse error")
+  }
+  if (typeof body !== "object" || body === null) {
+    return err(null, -32600, "Invalid Request")
+  }
+  if (body.jsonrpc !== "2.0") {
+    return err(body.id ?? null, -32600, "Invalid Request: jsonrpc must be '2.0'")
+  }
+  const method = body.method ?? ""
+  const id = body.id ?? null
+  if (typeof method !== "string" || method.length === 0) {
+    return err(id, -32600, "Invalid Request: method is required")
+  }
+  const params = asObj(body.params)
+
+  if (method === "initialize") {
+    return ok(id, {
+      protocolVersion: "2024-11-05",
+      serverInfo: {
+        name: config.mcp.serverName,
+        version: config.mcp.version,
+      },
+      capabilities: {
+        tools: {},
+      },
+    })
+  }
+
+  if (method === "tools/list") {
+    return ok(id, { tools: listToolSchemas().map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema,
+    })) })
+  }
+
+  if (method !== "tools/call") {
+    return err(id, -32601, `Unsupported method: ${method}`)
+  }
+
+  const toolName = typeof params.name === "string" ? params.name : ""
+  const args = asObj(params.arguments)
+
+  try {
+    const result = await callTool(toolName, args, {
+      config,
+      env,
+      fileStore,
+    })
+    return ok(id, { content: [{ type: "text", text: JSON.stringify(result) }] })
+  } catch (error) {
+    return err(id, -32000, error instanceof Error ? error.message : String(error))
+  }
+}