@echofiles/echo-pdf 0.4.1 → 0.4.2

package/src/response-schema.ts

@@ -1,182 +0,0 @@
-import type { JsonObject } from "./types"
-
-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[]
-}
-
-const MAX_TEXT_STRING = 1200
-const MAX_TEXT_ARRAY = 40
-const MAX_TEXT_DEPTH = 8
-
-const asObj = (value: unknown): JsonObject =>
-  typeof value === "object" && value !== null && !Array.isArray(value)
-    ? (value as JsonObject)
-    : {}
-
-const inferKind = (mimeType?: string): ToolArtifact["kind"] => {
-  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: string, baseUrl: string): string => {
-  try {
-    return new URL(value, baseUrl).toString()
-  } catch {
-    return value
-  }
-}
-
-const addArtifact = (artifacts: ToolArtifact[], artifact: ToolArtifact): void => {
-  if (!artifact.id && !artifact.url && !artifact.filename) return
-  artifacts.push(artifact)
-}
-
-export const buildToolOutputEnvelope = (
-  result: unknown,
-  baseUrl: string
-): ToolOutputEnvelope => {
-  const root = asObj(result)
-  const artifacts: ToolArtifact[] = []
-
-  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: unknown): string => {
-  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: string): string => {
-  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: unknown, depth = 0): unknown => {
-  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: Record<string, unknown> = {}
-  for (const [key, nested] of Object.entries(value)) {
-    out[key] = sanitizeForText(nested, depth + 1)
-  }
-  return out
-}
-
-export const buildMcpContent = (envelope: ToolOutputEnvelope): Array<Record<string, unknown>> => {
-  const lines: string[] = [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: Array<Record<string, unknown>> = [{ 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/src/tool-registry.ts

@@ -1,203 +0,0 @@
-import { normalizeReturnMode } from "./file-utils"
-import { runFileOp } from "./file-ops"
-import { runPdfAgent } from "./pdf-agent"
-import type { EchoPdfConfig, PdfOperationRequest, ToolSchema } from "./pdf-types"
-import type { Env, FileStore, JsonObject } from "./types"
-
-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
-}
-
-interface ToolDefinition {
-  readonly schema: ToolSchema
-  run: (ctx: ToolRuntimeContext, args: JsonObject) => Promise<unknown>
-}
-
-const asNumberArray = (value: unknown): number[] =>
-  Array.isArray(value) ? value.map((item) => Number(item)).filter((item) => Number.isInteger(item) && item > 0) : []
-
-const asObject = (value: unknown): JsonObject =>
-  typeof value === "object" && value !== null && !Array.isArray(value)
-    ? (value as JsonObject)
-    : {}
-
-const readString = (obj: JsonObject, key: string): string | undefined => {
-  const value = obj[key]
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined
-}
-
-const toolDefinitions: ReadonlyArray<ToolDefinition> = [
-  {
-    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: PdfOperationRequest = {
-        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: PdfOperationRequest = {
-        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: PdfOperationRequest = {
-        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") as "list" | "read" | "delete" | "put") ?? "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 = (): ReadonlyArray<ToolSchema> => toolDefinitions.map((item) => item.schema)
-
-export const callTool = async (
-  name: string,
-  args: unknown,
-  ctx: ToolRuntimeContext
-): Promise<unknown> => {
-  const definition = toolDefinitions.find((item) => item.schema.name === name)
-  if (!definition) {
-    throw new Error(`Unknown tool: ${name}`)
-  }
-  return definition.run(ctx, asObject(args))
-}

package/src/types.ts

@@ -1,40 +0,0 @@
-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 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 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/src/wasm.d.ts

@@ -1,4 +0,0 @@
-declare module "*.wasm" {
-  const wasmModule: WebAssembly.Module
-  export default wasmModule
-}