From bd5693770484e59284b4317a36115326a7c4e5cb Mon Sep 17 00:00:00 2001 From: Xiangzhe Date: Fri, 14 Aug 2026 10:06:39 -0300 Subject: [PATCH] feat(sse): add Vertex AI DeepSeek OCR transformation to the registry Adds VERTEX_DEEPSEEK_TRANSFORMATION (request/response mapping for the Vertex AI DeepSeek OCR MaaS endpoint) and registers the "vertex-deepseek-ocr" provider in OCR_PROVIDERS, modeled on litellm's VertexAIDeepSeekOCRConfig. buildRequest treats the resolved baseUrl as the complete Vertex endpoint URL (project/location resolved upstream), matching the existing Mistral passthrough pattern. --- open-sse/config/ocrRegistry.ts | 82 +++++++++++++++++ .../unit/ocr-registry-transformations.test.ts | 92 +++++++++++++++++++ 2 files changed, 174 insertions(+) diff --git a/open-sse/config/ocrRegistry.ts b/open-sse/config/ocrRegistry.ts index 4bcc141d4c..ccda80ddfc 100644 --- a/open-sse/config/ocrRegistry.ts +++ b/open-sse/config/ocrRegistry.ts @@ -104,6 +104,80 @@ export const AZURE_DI_TRANSFORMATION: OcrTransformation = { }, }; +/** + * Vertex AI DeepSeek OCR (deepseek-ai/deepseek-ocr-maas), served through Vertex's generic + * OpenAI-compatible partner endpoint ("openapi/chat/completions"). Modeled on litellm's + * VertexAIDeepSeekOCRConfig (litellm/llms/vertex_ai/ocr/deepseek_transformation.py): + * - request: OpenAI chat-completions shape, model prefixed with "deepseek-ai/", the OCR + * document sent as a single image_url content part (document_url documents are mapped to + * the same image_url shape — Vertex accepts both gs:// and https:// URLs there). + * - response: an OpenAI chat-completions body whose choices[0].message.content is either a + * JSON string already in the canonical {pages,model,usage_info} shape, or plain markdown + * text — both are normalized into OcrResponseShape. + * + * The full project/location endpoint URL is resolved into credentials.baseUrl upstream (see + * resolveOcrCredentials in src/app/api/v1/ocr/route.ts, the same pattern Azure DI uses for its + * resource endpoint) — buildRequest treats baseUrl as the complete URL, exactly like Mistral. + */ +function vertexDeepseekOcrContent(document: Record | undefined): { + type: string; + image_url: string; +} { + const url = String(document?.document_url ?? document?.image_url ?? ""); + return { type: "image_url", image_url: url }; +} + +export const VERTEX_DEEPSEEK_TRANSFORMATION: OcrTransformation = { + buildRequest({ baseUrl, token, body, modelId }) { + return { + url: baseUrl, + init: { + method: "POST", + headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` }, + body: JSON.stringify({ + model: `deepseek-ai/${modelId}`, + messages: [ + { + role: "user", + content: [vertexDeepseekOcrContent(body.document as Record)], + }, + ], + }), + }, + }; + }, + parseResponse(raw) { + const r = raw as { + model?: string; + choices?: Array<{ message?: { content?: unknown } }>; + usage?: Record; + }; + const model = r.model ?? "deepseek-ocr-maas"; + const content = r.choices?.[0]?.message?.content; + + if (typeof content === "string") { + const trimmed = content.trim(); + if (trimmed.startsWith("{")) { + try { + const parsed = JSON.parse(trimmed) as Partial; + if (Array.isArray(parsed.pages)) { + return { + pages: parsed.pages, + model: parsed.model ?? model, + usage_info: parsed.usage_info ?? r.usage, + }; + } + } catch { + // Not JSON after all — fall through and treat it as plain markdown. + } + } + return { pages: [{ index: 0, markdown: content }], model, usage_info: r.usage }; + } + + return { pages: [{ index: 0, markdown: "" }], model, usage_info: r.usage }; + }, +}; + export const OCR_PROVIDERS: Record = { mistral: { id: "mistral", @@ -120,6 +194,14 @@ export const OCR_PROVIDERS: Record = { models: [{ id: "prebuilt-read", name: "Azure Document Intelligence (Read)" }], transformation: AZURE_DI_TRANSFORMATION, }, + "vertex-deepseek-ocr": { + id: "vertex-deepseek-ocr", + baseUrl: "", + authType: "apikey", + authHeader: "bearer", + models: [{ id: "deepseek-ocr-maas", name: "DeepSeek OCR (Vertex AI MaaS)" }], + transformation: VERTEX_DEEPSEEK_TRANSFORMATION, + }, }; /** diff --git a/tests/unit/ocr-registry-transformations.test.ts b/tests/unit/ocr-registry-transformations.test.ts index ce7454ac7d..b6b733bc22 100644 --- a/tests/unit/ocr-registry-transformations.test.ts +++ b/tests/unit/ocr-registry-transformations.test.ts @@ -4,6 +4,7 @@ import { OCR_PROVIDERS, getOcrTransformation, MISTRAL_PASSTHROUGH, + VERTEX_DEEPSEEK_TRANSFORMATION, } from "../../open-sse/config/ocrRegistry.ts"; test("mistral resolves the passthrough transformation by default", () => { @@ -72,3 +73,94 @@ test("azure DI maps base64/image_url documents to base64Source/urlSource", () => const sent = JSON.parse(String(init.body)); assert.equal(sent.base64Source, "AAAA"); }); + +// ── Vertex AI DeepSeek OCR ────────────────────────────────────────────────── +// URL/body/response shapes verified against the upstream reference +// (litellm/llms/vertex_ai/ocr/deepseek_transformation.py): the endpoint is the +// generic Vertex "openapi/chat/completions" partner endpoint, the model id is +// prefixed with "deepseek-ai/", and the OCR document is sent as an +// OpenAI-chat-shaped image_url content part. + +test("vertex-deepseek-ocr resolves its own transformation (not the passthrough)", () => { + const t = getOcrTransformation("vertex-deepseek-ocr"); + assert.equal(t, VERTEX_DEEPSEEK_TRANSFORMATION); +}); + +test("vertex-deepseek-ocr builds an OpenAI-chat-shaped request against the resolved endpoint", () => { + const t = getOcrTransformation("vertex-deepseek-ocr"); + const { url, init } = t.buildRequest({ + // resolveOcrCredentials (src/app/api/v1/ocr/route.ts) resolves the full + // project/location endpoint into credentials.baseUrl before this runs — + // buildRequest treats baseUrl as the complete URL, mirroring Mistral. + baseUrl: + "https://aiplatform.googleapis.com/v1/projects/proj-1/locations/us-central1/endpoints/openapi/chat/completions", + token: "ya29.mock", + body: { document: { type: "image_url", image_url: "https://x/y.png" } }, + modelId: "deepseek-ocr-maas", + }); + assert.equal( + url, + "https://aiplatform.googleapis.com/v1/projects/proj-1/locations/us-central1/endpoints/openapi/chat/completions" + ); + assert.equal(init.method, "POST"); + assert.equal((init.headers as Record).Authorization, "Bearer ya29.mock"); + const sent = JSON.parse(String(init.body)); + assert.equal(sent.model, "deepseek-ai/deepseek-ocr-maas"); + assert.deepEqual(sent.messages, [ + { role: "user", content: [{ type: "image_url", image_url: "https://x/y.png" }] }, + ]); +}); + +test("vertex-deepseek-ocr maps a document_url document to the same image_url content shape", () => { + const t = getOcrTransformation("vertex-deepseek-ocr"); + const { init } = t.buildRequest({ + baseUrl: + "https://aiplatform.googleapis.com/v1/projects/p/locations/us-central1/endpoints/openapi/chat/completions", + token: "t", + body: { document: { type: "document_url", document_url: "https://x/d.pdf" } }, + modelId: "deepseek-ocr-maas", + }); + const sent = JSON.parse(String(init.body)); + assert.deepEqual(sent.messages[0].content, [{ type: "image_url", image_url: "https://x/d.pdf" }]); +}); + +test("vertex-deepseek-ocr parseResponse extracts a JSON pages payload embedded in choices[0].message.content", () => { + const t = getOcrTransformation("vertex-deepseek-ocr"); + const raw = { + choices: [ + { + message: { + content: JSON.stringify({ + pages: [{ index: 0, markdown: "# hi" }], + model: "deepseek-ocr-maas", + usage_info: { pages_processed: 1 }, + }), + }, + }, + ], + }; + const parsed = t.parseResponse(raw); + assert.deepEqual(parsed.pages, [{ index: 0, markdown: "# hi" }]); + assert.equal(parsed.model, "deepseek-ocr-maas"); + assert.deepEqual(parsed.usage_info, { pages_processed: 1 }); +}); + +test("vertex-deepseek-ocr parseResponse wraps plain markdown content into a single page (Mistral shape)", () => { + const t = getOcrTransformation("vertex-deepseek-ocr"); + const raw = { + model: "deepseek-ocr-maas", + choices: [{ message: { content: "# just markdown, not JSON" } }], + usage: { total_tokens: 42 }, + }; + const parsed = t.parseResponse(raw); + assert.deepEqual(parsed.pages, [{ index: 0, markdown: "# just markdown, not JSON" }]); + assert.equal(parsed.model, "deepseek-ocr-maas"); + assert.deepEqual(parsed.usage_info, { total_tokens: 42 }); +}); + +test("vertex-deepseek-ocr parseResponse tolerates a missing/empty choices array", () => { + const t = getOcrTransformation("vertex-deepseek-ocr"); + const parsed = t.parseResponse({ model: "deepseek-ocr-maas", choices: [] }); + assert.deepEqual(parsed.pages, [{ index: 0, markdown: "" }]); + assert.equal(parsed.model, "deepseek-ocr-maas"); +});