UNPKG

@bitkyc08/opencodex

Version:

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

267 lines (253 loc) • 11.3 kB
import { usageFromGemini } from "../adapters/google-usage"; import type { OcxUsage } from "../types"; /** Gemini payloads remain source text: parsing is validation, never serialization. */ export const GEMINI_NATIVE_MAX_BYTES = 16 * 1024 * 1024; export const GEMINI_NATIVE_ERROR_CODE = "gemini_native_upstream_error"; const SAFE_UPSTREAM_ERROR = '{"error":{"code":502,"message":"Antigravity upstream rejected the request","status":"INTERNAL"}}'; function jsonObject(value: unknown): Record<string, unknown> | undefined { return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined; } export function validateGeminiObject(raw: string): Record<string, unknown> { const object = jsonObject(JSON.parse(raw)); if (!object) throw new Error("expected a JSON object"); return object; } const GEMINI_THINKING_LEVEL = /^(minimal|low|medium|high|xhigh)$/i; const ANTIGRAVITY_WIRE_EFFORT = /-(low|medium|high|xhigh)$/; /** Capture only reasoning values sent on the wire, without rewriting the request. */ export function geminiNativeReasoningFields(body: Record<string, unknown>, model: string) { const wireEffort = ANTIGRAVITY_WIRE_EFFORT.exec(model)?.[1]; const generation = jsonObject(body.generationConfig ?? body.generation_config); const thinking = jsonObject(generation?.thinkingConfig ?? generation?.thinking_config); const level = thinking?.thinkingLevel ?? thinking?.thinking_level; if (typeof level === "string" && GEMINI_THINKING_LEVEL.test(level)) { const requestedEffort = level.toLowerCase(); return { requestedEffort, effectiveEffort: wireEffort ?? requestedEffort, reasoningWireField: "thinkingLevel", reasoningWireValue: level, }; } const budget = thinking?.thinkingBudget ?? thinking?.thinking_budget; if (level === undefined && typeof budget === "number" && Number.isSafeInteger(budget) && budget >= -1) { return { requestedEffort: budget === -1 ? "auto" : budget === 0 ? "none" : String(budget), effectiveEffort: wireEffort, reasoningWireField: "thinkingBudget", reasoningWireValue: budget === -1 ? "-1" : budget, }; } return { effectiveEffort: wireEffort }; } /** Find a top-level member's original value, including exact numeric/string spelling. */ export function rawJsonMember(raw: string, member: string): string { validateGeminiObject(raw); let depth = 0, start = -1, key: string | undefined, found: string | undefined; for (let i = 0; i < raw.length; i++) { const ch = raw[i]; if (ch === '"') { const begin = i++; for (; i < raw.length; i++) { if (raw[i] === "\\") i++; else if (raw[i] === '"') break; } if (depth === 1 && start < 0) key = JSON.parse(raw.slice(begin, i + 1)) as string; continue; } if (ch === ":" && depth === 1 && start < 0) { start = i + 1; continue; } if ((ch === "," && depth === 1) || (ch === "}" && depth === 1)) { if (key === member) { if (found !== undefined) throw new Error("duplicate envelope member"); found = raw.slice(start, i).trim(); } key = undefined; start = -1; } if (ch === "{" || ch === "[") depth++; else if (ch === "}" || ch === "]") depth--; } if (found === undefined) throw new Error("missing envelope member"); return found; } export function unwrapGeminiResponse(raw: string): string { const response = rawJsonMember(raw, "response"); validateGeminiObject(response); return response; } /** Check validated JSON source, including escaped strings and duplicate members. */ export function containsGeminiCredential(raw: string, credentials: readonly string[]): boolean { if (!credentials.length) return false; const contains = (text: string) => credentials.some(value => text.includes(value)); if (contains(raw)) return true; if (!raw.includes("\\")) return false; const delimiters = /["\\]/g; let start = -1, escaped = false; for (let match = delimiters.exec(raw); match; match = delimiters.exec(raw)) { if (match[0] === "\\") { escaped = true; delimiters.lastIndex++; } else if (start < 0) { start = match.index; } else { if (escaped && contains(JSON.parse(raw.slice(start, delimiters.lastIndex)))) return true; start = -1; escaped = false; } } return false; } export function wrapGeminiRequest(raw: string, model: string, project: string): string { validateGeminiObject(raw); const envelope = JSON.stringify({ model, project, userAgent: "antigravity", requestType: "agent", requestId: `agent-${crypto.randomUUID()}` }); return `${envelope.slice(0, -1)},"request":${raw}}`; } interface GeminiStreamObservers { onNativeError?: () => void; onUsage?: (usage: OcxUsage) => void; onOutput?: (visible: boolean, thought: boolean) => void; } /** Decode bounded upstream SSE events and frame the unwrapped JSON for the client. */ export function geminiSseTransform( maxBytes = GEMINI_NATIVE_MAX_BYTES, observers?: GeminiStreamObservers, format: "sse" | "array" = "sse", credentials: readonly string[] = [], ): TransformStream<Uint8Array, Uint8Array> { const decoder = new TextDecoder("utf-8", { fatal: true }); const encoder = new TextEncoder(); let lineParts: string[] = [], data: string[] = [], eventBytes = 0, afterCR = false; const candidates = new Map<number, boolean>(); let terminal = false, blocked = false, arrayOpened = false; let usage: OcxUsage | undefined; const reportUsage = () => { if (!usage) return; try { observers?.onUsage?.(usage); } catch { /* Observational callbacks never change delivery. */ } }; const complete = () => candidates.size ? [...candidates.values()].every(Boolean) : blocked; const closeArray = (controller: TransformStreamDefaultController<Uint8Array>) => { if (format === "array") controller.enqueue(encoder.encode("\n]")); }; function observe(raw: string) { const value = JSON.parse(raw) as { candidates?: Array<{ index?: number; finishReason?: string; content?: { parts?: unknown } }>; promptFeedback?: { blockReason?: string }; usageMetadata?: unknown; }; if (Object.hasOwn(value, "error") || containsGeminiCredential(raw, credentials)) { terminal = true; try { observers?.onNativeError?.(); } catch { /* Observational callbacks never change delivery. */ } return SAFE_UPSTREAM_ERROR; } blocked ||= !!value.promptFeedback?.blockReason; if (value.candidates !== undefined && !Array.isArray(value.candidates)) throw new Error("invalid Gemini candidates"); let visible = false, thought = false; for (const [position, candidate] of (value.candidates ?? []).entries()) { if (!candidate || typeof candidate !== "object") throw new Error("invalid Gemini candidate"); const index = candidate.index ?? position; if (!Number.isSafeInteger(index) || index < 0 || candidates.size >= 1024 && !candidates.has(index)) throw new Error("invalid Gemini candidate index"); candidates.set(index, candidates.get(index) === true || typeof candidate.finishReason === "string" && candidate.finishReason.length > 0); if (observers?.onOutput && Array.isArray(candidate.content?.parts)) { for (const rawPart of candidate.content.parts) { const part = jsonObject(rawPart); if (!part || !(typeof part.text === "string" && part.text.length > 0) && !jsonObject(part.functionCall ?? part.function_call)) continue; if (part.thought === true) thought = true; else visible = true; } } } if (visible || thought) { try { observers?.onOutput?.(visible, thought); } catch { /* Observational callbacks never change delivery. */ } } if (observers?.onUsage) usage = usageFromGemini(value.usageMetadata) ?? usage; return raw; } function emit(controller: TransformStreamDefaultController<Uint8Array>) { if (data.length) { const payload = data.join("\n"); if (payload.trim() === "[DONE]") { if (!complete()) throw new Error("premature Gemini stream terminator"); reportUsage(); terminal = true; } else { const response = observe(unwrapGeminiResponse(payload)); if (format === "sse") { controller.enqueue(encoder.encode(`data: ${response.replaceAll("\n", "\ndata: ")}\n\n`)); } else { controller.enqueue(encoder.encode((arrayOpened ? ",\n" : "[\n") + response)); arrayOpened = true; } } } data = []; eventBytes = 0; if (terminal) { closeArray(controller); controller.terminate(); } } function appendLineBytes(bytes: Uint8Array) { if (!bytes.byteLength) return; eventBytes += bytes.byteLength; if (eventBytes > maxBytes) throw new Error("Gemini SSE event too large"); const text = decoder.decode(bytes, { stream: true }); if (text) lineParts.push(text); } function endLine(controller: TransformStreamDefaultController<Uint8Array>) { const tail = decoder.decode(); if (tail) lineParts.push(tail); const line = lineParts.join(""); lineParts = []; if (!line) emit(controller); else if (line.startsWith("data:")) data.push(line.slice(5).replace(/^ /, "")); } return new TransformStream({ transform(chunk, controller) { let start = 0; // Scan only new bytes; CR/LF cannot occur inside a UTF-8 continuation sequence. for (let i = 0; i < chunk.byteLength; i++) { const byte = chunk[i]; if (afterCR) { afterCR = false; if (byte === 10) { start = i + 1; continue; } } if (byte !== 10 && byte !== 13) continue; appendLineBytes(chunk.subarray(start, i)); endLine(controller); if (terminal) return; afterCR = byte === 13; start = i + 1; } appendLineBytes(chunk.subarray(start)); }, flush(controller) { const tail = decoder.decode(); if (tail) lineParts.push(tail); if (lineParts.join("").trim() || data.length) throw new Error("truncated Gemini SSE event"); if (!complete()) throw new Error("incomplete Gemini generation"); reportUsage(); closeArray(controller); }, }); } /** Read source text with a byte cap and cancellation, without parsing or re-encoding it. */ export async function readGeminiText(body: ReadableStream<Uint8Array> | null, limit: number, signal: AbortSignal): Promise<string | null> { signal.throwIfAborted(); if (!body) return ""; const reader = body.getReader(); const onAbort = () => { void reader.cancel(signal.reason).catch(() => {}); }; signal.addEventListener("abort", onAbort, { once: true }); const decoder = new TextDecoder("utf-8", { fatal: true }); let total = 0; const parts: string[] = []; try { for (;;) { const next = await reader.read(); signal.throwIfAborted(); if (next.done) break; total += next.value.byteLength; if (total > limit) return null; parts.push(decoder.decode(next.value, { stream: true })); } parts.push(decoder.decode()); return parts.join(""); } finally { signal.removeEventListener("abort", onAbort); void reader.cancel().catch(() => {}); } }