UNPKG

@bitkyc08/opencodex

Version:

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

230 lines (218 loc) • 11.8 kB
/** * Gemini Interactions API inbound: POST /v1beta/interactions and /v1/interactions. * * Same shape as the generateContent inbound (./gemini-inbound): the create body is translated into * an internal Chat Completions request handled by the ordinary Chat path, this handler owns the * final request-log row, and errors use the Google {error:{code,message,status}} body with a fixed * message chosen by status. Streams use the Interactions SSE vocabulary. */ import { InteractionsCodecError, chatCompletionAnswer, consumeInteractionsChatChunk, createInteractionsStreamState, disposeInteractionsStream, encodeInteractionsEvents, chainInput, interactionAssistantMessage, interactionResource, interactionTimestamp, interactionsStreamAnswer, interactionsStreamFailure, interactionsStreamTerminal, interactionsToChat, newInteractionId, type InteractionAnswer, type InteractionMeta, type InteractionsRequestPlan, } from "../protocols/codecs/gemini-interactions"; import { createTranslatorBudget, isTranslatorBudgetExceededError } from "../lib/translator-budget"; import type { OcxConfig } from "../types"; import { geminiError } from "./gemini-inbound"; import { commitCancelled, drainedInnerErrorMessage, handleNativeChat, streamNativeFromChat, type NativeLogIds } from "./native-chat-bridge"; import { createNativeFinalLog, type NativeFinalLog } from "./native-final-log"; import { forgetInteraction, interactionEntryBytes, MAX_INTERACTION_BYTES, recallInteraction, rememberInteraction } from "./gemini-interactions-store"; import { resolveContextPrincipal, type DataPlaneAdmission } from "./auth-cors"; import { preflightOllamaRoute } from "./ollama-route-policy"; import { DecompressedBodyTooLargeError, readJsonRequestBody, resolveInboundBodyLimitBytes } from "./request-decompress"; import { addFinalRequestLog, type RequestLogContext } from "./request-log"; function failBeforeInner(ids: NativeLogIds, logCtx: RequestLogContext, status: number, message: string): Response { addFinalRequestLog(ids.requestId, ids.start, logCtx, status, { closeReason: "non_stream" }); return geminiError(status, message); } function cancelledNonStream(finalLog: NativeFinalLog): Response { commitCancelled(finalLog); return geminiError(499, "request cancelled"); } /** Header telling a client whether a requested store was kept; a later chain on an unkept turn is 404. */ export const INTERACTION_STORED_HEADER = "x-opencodex-interaction-stored"; /** * Who owns a stored interaction: the salted principal of the data-plane key the caller presented * (also on a loopback bind, where admission itself reads no key), or one shared "loopback" owner for * a keyless loopback caller. Rotating a key mints a new principal, so its chains then answer 404. */ export function interactionOwner(req: Request, config: OcxConfig, admission: DataPlaneAdmission | undefined): string | undefined { return resolveContextPrincipal(req, config, admission) ?? (admission?.kind === "loopback" ? "loopback" : undefined); } /** POST /v1beta/interactions. `req` is the admitted, session-promoted request. */ export async function handleGeminiInteraction( req: Request, config: OcxConfig, logCtx: RequestLogContext, ids: NativeLogIds, ): Promise<Response> { const limit = resolveInboundBodyLimitBytes(config.maxInboundBodyBytes); const budget = createTranslatorBudget(); let originalBody: unknown; let plan: InteractionsRequestPlan; try { originalBody = await readJsonRequestBody(req, budget, limit); plan = interactionsToChat(originalBody); } catch (error) { if (req.signal.aborted) return failBeforeInner(ids, logCtx, 499, "request cancelled"); if (error instanceof DecompressedBodyTooLargeError) return failBeforeInner(ids, logCtx, 413, "request body too large"); if (isTranslatorBudgetExceededError(error)) return failBeforeInner(ids, logCtx, 502, "request translation buffer exceeded the safe limit"); return failBeforeInner(ids, logCtx, 400, error instanceof InteractionsCodecError ? error.message : "invalid JSON body"); } finally { budget.dispose(); } const owner = interactionOwner(req, config, ids.admission); let history: Record<string, unknown>[] = []; if (plan.previousInteractionId !== undefined) { const stored = recallInteraction(plan.previousInteractionId, owner); if (!stored) return failBeforeInner(ids, logCtx, 404, "interaction not found"); history = [...stored.history]; } // Google's chained tool flow sends only the results; their calls are the stored turn's pending calls. const input = chainInput(history, plan); if (!input) return failBeforeInner(ids, logCtx, 400, "unmatched function_result"); logCtx.requestedModel = plan.model; const preflight = preflightOllamaRoute(config, plan.model, req); if (!preflight.ok) { logCtx.errorCode = preflight.error.code; return failBeforeInner(ids, logCtx, preflight.error.status, preflight.error.message); } const chatJson = JSON.stringify({ ...plan.chat, messages: [...plan.systemMessages, ...history, ...input] }); if (Buffer.byteLength(chatJson) > limit) return failBeforeInner(ids, logCtx, 413, "request body too large"); const finalLog = createNativeFinalLog(ids.requestId, ids.start, logCtx); let inner: Response; try { inner = await handleNativeChat(req, originalBody, chatJson, config, logCtx, ids); } catch { await finalLog.waitForInner(); if (req.signal.aborted) return cancelledNonStream(finalLog); finalLog.commit({ status: 502, terminalStatus: "failed", closeReason: "non_stream" }); return geminiError(502, "request failed"); } if (!inner.ok || !inner.body) { const message = await drainedInnerErrorMessage(inner); await finalLog.waitForInner(); if (req.signal.aborted) return cancelledNonStream(finalLog); finalLog.commit({ status: inner.ok ? 502 : inner.status, terminalStatus: "failed", closeReason: "non_stream" }); return geminiError(inner.ok ? 502 : inner.status, message, inner.headers.get("retry-after")); } const meta: InteractionMeta = { id: newInteractionId(), model: plan.model, created: interactionTimestamp() }; // Interaction-scoped fields (system_instruction, tools, generation_config) are never stored. // A stored history larger than the inbound limit could never be chained, so it is not kept. const keep: Keep | undefined = plan.store ? { owner, history: [...history, ...input], inputSteps: plan.inputSteps, maxBytes: limit, ...(plan.previousInteractionId ? { previous: plan.previousInteractionId } : {}) } : undefined; if (plan.previousInteractionId) meta.previousInteractionId = plan.previousInteractionId; return plan.stream ? streamInteraction(meta, inner.body, finalLog, req.signal, keep) : bufferedInteraction(meta, inner, finalLog, req.signal, keep); } /** What a stored turn keeps: its owner, the history to continue from, and its input steps. */ interface Keep { owner: string | undefined; history: Record<string, unknown>[]; inputSteps: Record<string, unknown>[]; maxBytes: number; previous?: string } /** Store a settled turn. False when it has no owner, is too large to keep, or storing failed. */ function remember(keep: Keep, meta: InteractionMeta, answer: InteractionAnswer, resource: Record<string, unknown>): boolean { if (keep.owner === undefined) return false; const assistant = interactionAssistantMessage(answer); try { return rememberInteraction({ id: meta.id, owner: keep.owner, history: assistant ? [...keep.history, assistant] : keep.history, resource: { ...resource, steps: [...keep.inputSteps, ...(resource.steps as Record<string, unknown>[])] }, }, Date.now(), keep.maxBytes); } catch { // Storing is best effort; the settled answer still goes out. return false; } } async function bufferedInteraction(meta: InteractionMeta, inner: Response, finalLog: NativeFinalLog, signal: AbortSignal, keep?: Keep): Promise<Response> { let resource: Record<string, unknown>; let answer: InteractionAnswer; try { answer = chatCompletionAnswer(JSON.parse(await inner.text())); resource = interactionResource(meta, answer, interactionTimestamp()); } catch { await finalLog.waitForInner(); if (signal.aborted) return cancelledNonStream(finalLog); finalLog.commit({ status: 502, terminalStatus: "failed", closeReason: "non_stream" }); return geminiError(502, "invalid upstream response"); } const settled = await finalLog.waitForInner(); if (signal.aborted) return cancelledNonStream(finalLog); if (!settled) { finalLog.commit({ status: 502, terminalStatus: "failed", closeReason: "non_stream" }); return geminiError(502, "request did not complete"); } const stored = keep ? remember(keep, meta, answer, resource) : undefined; finalLog.commit({ status: 200, terminalStatus: "completed", closeReason: "non_stream" }); const response = Response.json(resource); if (stored !== undefined) { response.headers.set(INTERACTION_STORED_HEADER, stored ? "true" : "false"); response.headers.set("Access-Control-Expose-Headers", INTERACTION_STORED_HEADER); } return response; } function streamInteraction(meta: InteractionMeta, body: ReadableStream<Uint8Array>, finalLog: NativeFinalLog, signal: AbortSignal, keep?: Keep): Response { const budget = createTranslatorBudget(); const remainingEntryBytes = keep?.owner === undefined ? 0 : Math.min(keep.maxBytes, MAX_INTERACTION_BYTES) - interactionEntryBytes({ history: keep.history, resource: { ...interactionResource(meta, { content: "", reasoning: "", calls: [], status: "completed" }), steps: keep.inputSteps }, }); const state = createInteractionsStreamState(meta, budget, remainingEntryBytes); return streamNativeFromChat({ dispose: () => disposeInteractionsStream(state), contentType: "text/event-stream", chunk: parsed => encodeInteractionsEvents(consumeInteractionsChatChunk(state, parsed)), terminal() { const answer = interactionsStreamAnswer(state); if (!answer) return { ok: false, error: "request did not complete" }; const { status, usage } = answer; // frames() runs only after the inner path settled successfully. return { ok: true, frames: () => { const updated = interactionTimestamp(); if (keep && state.retained) { const retained = interactionsStreamAnswer(state)!; remember(keep, meta, retained, interactionResource(meta, retained, updated)); } return encodeInteractionsEvents(interactionsStreamTerminal(state, { status, usage }, updated)); } }; }, failure: message => encodeInteractionsEvents(interactionsStreamFailure(state, 502, message)), }, body, finalLog, signal); } /** * GET and DELETE /v1beta|v1/interactions/{id}, POST …/{id}/cancel. Owner-scoped (a foreign id is * indistinguishable from a missing one, cancel included); never forwarded upstream. */ export function handleGeminiInteractionResource( route: { kind: "interaction" | "interaction-cancel"; id: string }, req: Request, config: OcxConfig, admission: DataPlaneAdmission, ): Response { const owner = interactionOwner(req, config, admission); const method = req.method; if (route.kind === "interaction-cancel") { return recallInteraction(route.id, owner) ? geminiError(400, "only background interactions can be cancelled") : geminiError(404, "interaction not found"); } if (method === "DELETE") return forgetInteraction(route.id, owner) ? Response.json({}) : geminiError(404, "interaction not found"); const stored = recallInteraction(route.id, owner); return stored ? Response.json(stored.resource) : geminiError(404, "interaction not found"); }