UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

152 lines (144 loc) • 7.22 kB
/** * Inbound Chat Completions image parts, recognized once for every consumer. * * Two call sites used to answer "does this body carry an image?" independently and * gave different answers: the translated path understood Pi/MCP and Anthropic-shaped * parts, while the native fast path's route-eligibility predicate matched only * `image_url`. A text-only routed model therefore kept an image-bearing body and * forwarded a non-OpenAI part verbatim to an OpenAI-compatible upstream. * * Normalization runs before route selection so the diversion decision and the * forwarded wire see the same parts. This module deliberately imports nothing: it is * shared by `src/chat/` and `src/server/` and must not create an edge between them. */ type Rec = Record<string, unknown>; function isRec(v: unknown): v is Rec { return !!v && typeof v === "object" && !Array.isArray(v); } /** * The image reference a Chat content part carries, as a URL or data URI. * * Accepts OpenAI `image_url` (string or `{url}`), Pi/MCP-style * `{type:"image", data, mimeType}` (Aside read_file tool results), and * Anthropic-shaped `{type:"image", source:{...}}` in both base64 and url form. * Returns null for anything else — including a part with no usable reference, which * must be left alone rather than turned into a claim of an attachment. */ export function chatImageUrlFromPart(part: Rec): string | null { if (part.type === "image_url") { const imageUrl = part.image_url; if (typeof imageUrl === "string" && imageUrl.length > 0) return imageUrl; if (isRec(imageUrl) && typeof imageUrl.url === "string" && imageUrl.url.length > 0) return imageUrl.url; return null; } if (part.type === "image") { const data = part.data; if (typeof data === "string" && data.length > 0) { if (data.startsWith("data:")) return data; const media = typeof part.mimeType === "string" && part.mimeType.length > 0 ? part.mimeType : typeof part.mediaType === "string" && part.mediaType.length > 0 ? part.mediaType : "image/png"; return "data:" + media + ";base64," + data; } const source = part.source; if (isRec(source)) { if (source.type === "base64" && typeof source.data === "string" && source.data.length > 0) { const media = typeof source.media_type === "string" && source.media_type.length > 0 ? source.media_type : "image/png"; return "data:" + media + ";base64," + source.data; } if (source.type === "url" && typeof source.url === "string" && source.url.length > 0) return source.url; } } return null; } /** The fidelity hint a recognized part carries, when it is one the wire accepts. */ export function chatImageDetailFromPart(part: Rec): "auto" | "low" | "high" | undefined { const raw = isRec(part.image_url) ? part.image_url.detail : part.detail; return raw === "auto" || raw === "low" || raw === "high" ? raw : undefined; } /** * True when any `messages[].content[]` part carries a recognized image, in any of * the accepted shapes. This is the predicate native-route eligibility depends on, so * widening `chatImageUrlFromPart` widens the text-only diversion with it. */ export function chatBodyCarriesImage(rawBody: Rec): boolean { const messages = rawBody.messages; if (!Array.isArray(messages)) return false; for (const message of messages) { if (!isRec(message) || !Array.isArray(message.content)) continue; for (const part of message.content) { if (isRec(part) && chatImageUrlFromPart(part) !== null) return true; } } return false; } /** * Rewrite every recognized non-OpenAI image part into `image_url` form. * * Copy-on-write, and genuinely lazy: replacement arrays are allocated only after a * part actually needs rewriting. An ordinary text or native-Chat request walks the * messages and allocates nothing, and the original object reference is returned. * An earlier revision mapped every message and content array eagerly and only then * compared — identity was preserved, but the transient arrays were not, so the * "only rewritten paths are rebuilt" claim was false for the common path. * * Every sibling part, every other message field and every top-level body field keep * their exact value: the native path is a whitelist passthrough, so an incidental * deep clone would itself be a behavior change. * * Each rewritten Pi/Anthropic base64 part costs one copy of its payload string, * bounded by the inbound body limit `readChatBody` already enforces. */ export function normalizeChatImageParts(rawBody: Rec): Rec { const messages = rawBody.messages; if (!Array.isArray(messages)) return rawBody; let nextMessages: unknown[] | undefined; for (let messageIndex = 0; messageIndex < messages.length; messageIndex++) { const message = messages[messageIndex]; if (!isRec(message) || !Array.isArray(message.content)) continue; const content = message.content; let nextContent: unknown[] | undefined; for (let partIndex = 0; partIndex < content.length; partIndex++) { const part = content[partIndex]; // Already-OpenAI parts are left byte-identical; only foreign shapes are rewritten. if (!isRec(part) || part.type === "image_url") continue; const url = chatImageUrlFromPart(part); if (url === null) continue; const detail = chatImageDetailFromPart(part); nextContent ??= content.slice(); nextContent[partIndex] = { type: "image_url", image_url: { url, ...(detail ? { detail } : {}) } }; } if (!nextContent) continue; nextMessages ??= messages.slice(); nextMessages[messageIndex] = { ...message, content: nextContent }; } return nextMessages ? { ...rawBody, messages: nextMessages } : rawBody; } /** * True when a `role: "tool"` message carries a recognized image, in any accepted shape. * * Shape normalization alone does NOT make such a request safe on the native fast path. * A standard Chat tool message accepts a string or text parts only — not `image_url` — * so rewriting a Pi/Anthropic tool image into `image_url` still leaves an image part * inside a tool message, which a standard-enforcing endpoint rejects. * * The translated openai-chat adapter already solves placement: it collects tool-result * images and flushes them into a following `user` carrier after the complete paired * tool-result batch. Diverting these requests there is narrower than reimplementing * that carrier on the native path, and it leaves ordinary user images and text-only * tool results on the native fast path untouched. */ export function chatBodyCarriesToolResultImage(rawBody: Rec): boolean { const messages = rawBody.messages; if (!Array.isArray(messages)) return false; for (const message of messages) { // The legacy `function` role carries a tool result under the same schema constraint, // so it needs the same diversion. if (!isRec(message) || (message.role !== "tool" && message.role !== "function")) continue; if (!Array.isArray(message.content)) continue; for (const part of message.content) { if (isRec(part) && chatImageUrlFromPart(part) !== null) return true; } } return false; }