@echofiles/echo-pdf 0.4.0 → 0.4.2

package/src/index.ts

@@ -1,400 +0,0 @@
-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 { buildToolOutputEnvelope } from "./response-schema"
-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 errorStatus = (error: unknown): number | null => {
-  const status = (error as { status?: unknown })?.status
-  return typeof status === "number" && Number.isFinite(status) ? status : null
-}
-
-const errorCode = (error: unknown): string | null => {
-  const code = (error as { code?: unknown })?.code
-  return typeof code === "string" && code.length > 0 ? code : null
-}
-
-const errorDetails = (error: unknown): unknown => (error as { details?: unknown })?.details
-
-const jsonError = (error: unknown, fallbackStatus = 500): Response => {
-  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: 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 resolvePublicBaseUrl = (request: Request, configured?: string): string =>
-  typeof configured === "string" && configured.length > 0 ? configured : request.url
-
-const sanitizeDownloadFilename = (filename: string): string => {
-  const cleaned = filename
-    .replace(/[\r\n"]/g, "")
-    .replace(/[^\x20-\x7E]+/g, "")
-    .trim()
-  return cleaned.length > 0 ? cleaned : "download.bin"
-}
-
-const isFileGetAuthorized = (request: Request, env: Env, config: { authHeader?: string; authEnv?: string }): boolean => {
-  if (!config.authHeader || !config.authEnv) return true
-  const required = env[config.authEnv]
-  if (typeof required !== "string" || required.length === 0) return true
-  return request.headers.get(config.authHeader) === required
-}
-
-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", "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 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(buildToolOutputEnvelope(result, resolvePublicBaseUrl(request, config.service.publicBaseUrl)))
-      } catch (error) {
-        return jsonError(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 jsonError(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 jsonError(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 jsonError(error, 500)
-      }
-    }
-
-    if (request.method === "GET" && url.pathname === "/api/files/get") {
-      const fileGetConfig = config.service.fileGet ?? {}
-      if (!isFileGetAuthorized(request, env, fileGetConfig)) {
-        return json({ error: "Unauthorized", code: "UNAUTHORIZED" }, 401)
-      }
-      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 }

package/src/mcp-server.ts

@@ -1,158 +0,0 @@
-import type { Env, FileStore } from "./types"
-import type { EchoPdfConfig } from "./pdf-types"
-import { buildMcpContent, buildToolOutputEnvelope } from "./response-schema"
-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,
-  data?: Record<string, unknown>
-): Response =>
-  new Response(
-    JSON.stringify({
-      jsonrpc: "2.0",
-      id: id ?? null,
-      error: data ? { code, message, data } : { 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
-}
-
-const resolvePublicBaseUrl = (request: Request, configured?: string): string =>
-  typeof configured === "string" && configured.length > 0 ? configured : request.url
-
-const prepareMcpToolArgs = (toolName: string, args: Record<string, unknown>): Record<string, unknown> => {
-  if (toolName === "pdf_extract_pages") {
-    const mode = typeof args.returnMode === "string" ? args.returnMode : ""
-    if (!mode) {
-      return { ...args, returnMode: "url" }
-    }
-  }
-  return args
-}
-
-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 = prepareMcpToolArgs(toolName, asObj(params.arguments))
-  if (!toolName) {
-    return err(id, -32602, "Invalid params: name is required", {
-      code: "INVALID_PARAMS",
-      status: 400,
-    })
-  }
-
-  try {
-    const result = await callTool(toolName, args, {
-      config,
-      env,
-      fileStore,
-    })
-    const envelope = buildToolOutputEnvelope(result, resolvePublicBaseUrl(request, config.service.publicBaseUrl))
-    return ok(id, { content: buildMcpContent(envelope) })
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error)
-    const status = (error as { status?: unknown })?.status
-    const stableStatus = typeof status === "number" && Number.isFinite(status) ? status : 500
-    const code = (error as { code?: unknown })?.code
-    const details = (error as { details?: unknown })?.details
-    if (message.startsWith("Unknown tool:")) {
-      return err(id, -32601, message, {
-        code: typeof code === "string" ? code : "TOOL_NOT_FOUND",
-        status: 404,
-        details,
-      })
-    }
-    if (stableStatus >= 400 && stableStatus < 500) {
-      return err(id, -32602, message, {
-        code: typeof code === "string" ? code : "INVALID_PARAMS",
-        status: stableStatus,
-        details,
-      })
-    }
-    return err(id, -32000, message, {
-      code: typeof code === "string" ? code : "INTERNAL_ERROR",
-      status: stableStatus,
-      details,
-    })
-  }
-}