UNPKG

@bitkyc08/opencodex

Version:

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

314 lines (310 loc) • 19.8 kB
import type { OcxConfig, OcxUsage } from "../types"; import { markNativeGeminiProtocol } from "../protocols/trace"; import { getValidAccessSnapshotForAccount, forceRefreshOAuthAccessSnapshot, OAuthLoginRequiredError, OAuthAccountPausedError, OAuthTokenRefreshBusyError, OAuthTokenRefreshStaleError, type OAuthAccessSnapshot } from "../oauth"; import { getAccountSet, getAccountCredentialWithStatus } from "../oauth/store"; import { antigravityModelRefusal, isProactivePreferenceEnabled, noteGenericPoolSelection, preferredInitialAccount, routeAntigravityModel, } from "../oauth/generic-account-failover"; import { stampOAuthAccountLabel } from "../providers/label"; import { getProviderRegistryEntry } from "../providers/registry"; import { sendTrackingRequestSlot, waitForProviderRequestSlot, RequestPacingQueueOverloadError, RequestPacingProviderRemovedError } from "../providers/request-pacing"; import { usageFromGemini } from "../adapters/google-usage"; import { antigravityUserAgentForWireModel } from "../adapters/google-antigravity-wire"; import { fetchWithAttemptDeadline, releaseResponseBodyBestEffort } from "../lib/upstream-retry"; import { reserveWorkflowSend } from "../lib/workflow-budget"; import { currentWorkflowBudgetPolicy } from "../lib/workflow-budget-config"; import { spendPolicyFromConfig } from "../lib/spend-reservation-ledger"; import { carryWorkflowRefusal, workflowRefusalResponse } from "./workflow-refusal"; import { geminiErrorBody, toGeminiRefusal } from "./gemini-inbound"; import { estimateTokens } from "../lib/token-estimate"; import { createPhysicalSendReporter } from "../lib/request-execution-budget"; import { createInferenceSendBudget } from "./inference/context"; import { attachRequestSpendTracker } from "./responses/request-spend"; import { markLocalRequestLogRefusal, type RequestLogContext } from "./request-log"; import { recordGenerationOutput } from "./request-log-generation-window"; import { noteCredentialAttemptSend, sealCredentialRefusal } from "./credential-recovery-attempt"; import { DEFAULT_STALL_TIMEOUT_SEC, resolveStallTimeoutMs } from "../stall-timeout"; import { isLocalUpstream } from "../lib/local-upstream"; import { assertProviderDestinationAllowed } from "../lib/destination-policy"; import { clientFacingModelLabel, type ClientFacingModelLabel } from "../lib/error-destination"; import { registerTurn, unregisterTurn, type ActiveTurnLease } from "./lifecycle"; import { containsGeminiCredential, geminiNativeReasoningFields, geminiSseTransform, readGeminiText, validateGeminiObject, GEMINI_NATIVE_MAX_BYTES, GEMINI_NATIVE_ERROR_CODE, unwrapGeminiResponse, wrapGeminiRequest } from "./gemini-native-wire"; export const GEMINI_NATIVE_PROVIDER = "google-antigravity"; class NativeWorkflowSendDenied extends Error {} class NativeRequestBodyTimeout extends Error {} class NativeConfigurationInvalid extends Error {} class NativeModelUnavailable extends Error {} export function geminiNativeError(status: number, message: string, reason?: string): Response { const { error } = geminiErrorBody(status, message); return Response.json({ error: { ...error, ...(reason ? { details: [{ reason }] } : {}) } }, { status }); } export interface GeminiNativeDeps { access: (config: OcxConfig, model: string, clientModel: ClientFacingModelLabel) => Promise<OAuthAccessSnapshot>; refresh: (snapshot: OAuthAccessSnapshot) => Promise<OAuthAccessSnapshot>; fetch: typeof globalThis.fetch; } const defaults: Omit<GeminiNativeDeps, "fetch"> = { access: async (config, model, clientModel) => { const set = getAccountSet(GEMINI_NATIVE_PROVIDER); if (!set) throw new OAuthLoginRequiredError(GEMINI_NATIVE_PROVIDER); const now = Date.now(); const planned = preferredInitialAccount(config, GEMINI_NATIVE_PROVIDER, now, model) ?? set.activeAccountId; const route = routeAntigravityModel(config, GEMINI_NATIVE_PROVIDER, planned, model, now, clientModel); if (route.kind === "refuse") throw new NativeModelUnavailable(route.message); const accountId = route.kind === "reroute" ? route.accountId : planned; return getValidAccessSnapshotForAccount(GEMINI_NATIVE_PROVIDER, accountId, { requireUsableAccount: true }); }, refresh: forceRefreshOAuthAccessSnapshot, }; /** Native leg using an account-scoped Antigravity token and project. */ export async function handleGeminiNative( req: Request, config: OcxConfig, model: string, streamFormat: "sse" | "array" | undefined, lease: ActiveTurnLease, deps: GeminiNativeDeps = { ...defaults, fetch: globalThis.fetch }, logCtx?: RequestLogContext, start?: number, ): Promise<Response> { const rootId = req.headers.get("x-codex-parent-thread-id")?.trim() || undefined; if (!logCtx) { const policy = spendPolicyFromConfig(config.spend); if (policy.identity.maxTokens !== undefined || policy.pool.maxTokens !== undefined || (rootId !== undefined && policy.root.maxTokens !== undefined)) { return geminiNativeError(503, "Token budget accounting is unavailable for this request"); } } const provider = config.providers[GEMINI_NATIVE_PROVIDER]; if (!provider || provider.disabled === true) return geminiNativeError(503, "Enable google-antigravity and sign in before using Gemini native requests"); if (provider.adapter !== "google" || (provider.authMode && provider.authMode !== "oauth") || (provider.googleMode && provider.googleMode !== "cloud-code-assist")) { return geminiNativeError(503, "Gemini native requests require a Google Antigravity OAuth provider"); } if (req.headers.get("content-encoding") && req.headers.get("content-encoding") !== "identity") return geminiNativeError(415, "Gemini native requests require identity content encoding"); // Native admission accepts the canonical provider's implicit OAuth mode. Account helpers // require an explicit mode, so give them the same default without changing saved settings. const accountConfig: OcxConfig = provider.authMode === undefined ? { ...config, providers: { ...config.providers, [GEMINI_NATIVE_PROVIDER]: { ...provider, authMode: "oauth" } }, } : config; const ac = new AbortController(); const onAbort = () => ac.abort(req.signal.reason); req.signal.addEventListener("abort", onAbort, { once: true }); if (req.signal.aborted) onAbort(); registerTurn(ac, lease); const baseUrl = provider.baseUrl || getProviderRegistryEntry(GEMINI_NATIVE_PROVIDER)!.baseUrl; let timer: ReturnType<typeof setTimeout> | undefined; let bodyReadTimer: ReturnType<typeof setTimeout> | undefined; let finished = false; let onUpstreamAbort: (() => void) | undefined; const finish = () => { if (finished) return; finished = true; clearTimeout(timer); clearTimeout(bodyReadTimer); if (onUpstreamAbort) ac.signal.removeEventListener("abort", onUpstreamAbort); req.signal.removeEventListener("abort", onAbort); unregisterTurn(ac); }; const armStall = () => { clearTimeout(timer); const stallMs = resolveStallTimeoutMs(config.stallTimeoutSec, { localUpstream: isLocalUpstream(baseUrl) }); if (stallMs > 0) timer = setTimeout(() => ac.abort(new Error("Gemini upstream stalled")), stallMs); }; const noteNativeError = () => { if (logCtx) { logCtx.errorCode = GEMINI_NATIVE_ERROR_CODE; logCtx.terminalSource = "upstream"; } }; let sawThoughtOutput = false; const noteUsage = logCtx ? (usage: OcxUsage) => { logCtx.usage = usage; // Reported thought tokens count in the numerator. Their generation must also be observed. if (usage.reasoningOutputTokens && !sawThoughtOutput) { delete logCtx.generationStartedAt; delete logCtx.lastOutputAt; } } : undefined; const noteOutput = logCtx && start !== undefined ? (visible: boolean, thought: boolean) => { const now = Date.now(); sawThoughtOutput ||= thought; recordGenerationOutput(logCtx, now); if (visible) logCtx.firstOutputMs ??= Math.max(0, now - start); } : undefined; const spendTracker = logCtx ? attachRequestSpendTracker(req, logCtx) : undefined; const physicalBudget = logCtx ? createInferenceSendBudget(req, logCtx) : undefined; let upstream: Response | undefined; try { const maxBytes = Math.min(GEMINI_NATIVE_MAX_BYTES, config.maxInboundBodyBytes ?? GEMINI_NATIVE_MAX_BYTES); // Upload protection is independent of upstream silence: disabling model stalls must not // let an authenticated client hold an admission lease with an unfinished JSON upload. const bodyIdleMs = resolveStallTimeoutMs(config.stallTimeoutSec) || DEFAULT_STALL_TIMEOUT_SEC * 1000; const armBodyRead = () => { clearTimeout(bodyReadTimer); bodyReadTimer = setTimeout(() => ac.abort(new NativeRequestBodyTimeout()), bodyIdleMs); }; const input = req.body?.pipeThrough(new TransformStream<Uint8Array, Uint8Array>({ transform(chunk, controller) { if (chunk.byteLength) armBodyRead(); controller.enqueue(chunk); }, })) ?? null; let raw: string | null; armBodyRead(); try { raw = await readGeminiText(input, maxBytes, ac.signal); } catch (error) { if (ac.signal.aborted) throw error; finish(); return geminiNativeError(400, "Gemini request body must be readable UTF-8 JSON"); } finally { clearTimeout(bodyReadTimer); bodyReadTimer = undefined; } if (raw === null) { finish(); return geminiNativeError(413, "Gemini native request exceeds the body limit"); } let reasoning: ReturnType<typeof geminiNativeReasoningFields> | undefined; try { const payload = validateGeminiObject(raw); if (logCtx) { reasoning = geminiNativeReasoningFields(payload, model); const generation = (payload.generationConfig ?? payload.generation_config) as Record<string, unknown> | undefined; const maxOutput = generation?.maxOutputTokens ?? generation?.max_output_tokens; const candidates = generation?.candidateCount ?? generation?.candidate_count; const candidateCount = typeof candidates === "number" && Number.isSafeInteger(candidates) && candidates > 0 ? candidates : 1; // Measure the native JSON for reservation only. Usage comes from the upstream response. logCtx.spendInputEstimateTokens = estimateTokens(raw, model); if (typeof maxOutput === "number" && Number.isSafeInteger(maxOutput) && maxOutput > 0) { logCtx.spendOutputCeilingTokens = Math.min(Number.MAX_SAFE_INTEGER, maxOutput * candidateCount); } } } catch { finish(); return geminiNativeError(400, "Expected a Gemini JSON object"); } ac.signal.throwIfAborted(); const clientModel = clientFacingModelLabel(logCtx?.requestedModel ?? model); let access = await deps.access(accountConfig, model, clientModel); const boundCredentials = new Set<string>(); for (let attempt = 0; attempt < 2; attempt++) { ac.signal.throwIfAborted(); if (!access.projectId) { finish(); return geminiNativeError(503, "Antigravity project missing; sign in again"); } try { assertProviderDestinationAllowed(GEMINI_NATIVE_PROVIDER, { ...provider, baseUrl }); const base = new URL(baseUrl); if (base.username || base.password || base.search || base.hash) throw new NativeConfigurationInvalid(); } catch { throw new NativeConfigurationInvalid(); } const method = streamFormat ? "streamGenerateContent?alt=sse" : "generateContent"; const slot = await waitForProviderRequestSlot(GEMINI_NATIVE_PROVIDER, provider, model, ac.signal); upstream = await sendTrackingRequestSlot(slot, async () => { ac.signal.throwIfAborted(); // A pacing wait must not outlive an operator pause, reauth mark or account removal. const account = getAccountCredentialWithStatus(GEMINI_NATIVE_PROVIDER, access.accountId); if (!account) throw new OAuthLoginRequiredError(GEMINI_NATIVE_PROVIDER); if (account.paused) throw new OAuthAccountPausedError(); if (account.needsReauth) throw new OAuthLoginRequiredError(GEMINI_NATIVE_PROVIDER); const refusal = antigravityModelRefusal(accountConfig, GEMINI_NATIVE_PROVIDER, access.accountId, model, undefined, clientModel); if (refusal) throw new NativeModelUnavailable(refusal); const { credential } = account; // Keep both generations across a 401 recovery. The store can also rotate during pacing. for (const value of [access.accessToken, access.projectId, access.accountId, credential.access, credential.refresh, credential.projectId, credential.accountId, credential.email]) { if (value) boundCredentials.add(value); } const body = wrapGeminiRequest(raw, model, access.projectId!); if (logCtx) stampOAuthAccountLabel(logCtx, GEMINI_NATIVE_PROVIDER, { authMode: "oauth" }, access.accountId); const report = physicalBudget && createPhysicalSendReporter(physicalBudget, () => ({ poolId: GEMINI_NATIVE_PROVIDER, identityId: logCtx?.accountLogLabel, })); let dispatched = false; try { if (report ? !report.beforeSend?.(attempt > 0) : !reserveWorkflowSend(rootId, currentWorkflowBudgetPolicy())) { throw new NativeWorkflowSendDenied(); } if (attempt === 0 && isProactivePreferenceEnabled(accountConfig, GEMINI_NATIVE_PROVIDER, Date.now())) { noteGenericPoolSelection(accountConfig, GEMINI_NATIVE_PROVIDER, access.accountId, model); } if (logCtx) { Object.assign(logCtx, reasoning); markNativeGeminiProtocol(logCtx); noteCredentialAttemptSend(logCtx, { providerName: GEMINI_NATIVE_PROVIDER, modelId: model }, provider, attempt === 0 ? undefined : "oauth-401"); Object.assign(logCtx.activeAttempt!, reasoning); } dispatched = true; return await fetchWithAttemptDeadline(`${baseUrl.replace(/\/$/, "")}/v1internal:${method}`, { method: "POST", headers: { "Content-Type": "application/json", Authorization: `Bearer ${access.accessToken}`, "User-Agent": antigravityUserAgentForWireModel(model) }, body, }, config.connectTimeoutMs ?? 200_000, ac.signal, true, deps.fetch); } finally { try { if (dispatched) report?.(1); } finally { report?.close?.(); } } }); if (upstream.status !== 401 || attempt === 1) break; if (logCtx) sealCredentialRefusal(logCtx, 401, "oauth-401"); await releaseResponseBodyBestEffort(upstream.body, ac.signal); ac.signal.throwIfAborted(); access = await deps.refresh(access); } if (!upstream) throw new Error("missing upstream response"); if (!upstream.ok) { if (logCtx) logCtx.terminalSource = "upstream"; void upstream.body?.cancel().catch(() => {}); finish(); const response = geminiNativeError(upstream.status >= 400 ? upstream.status : 502, "Antigravity upstream rejected the request"); const retryAfter = upstream.headers.get("retry-after"); if (retryAfter && /^\d{1,6}$/.test(retryAfter)) response.headers.set("Retry-After", retryAfter); return response; } if (!upstream.body) throw new Error("missing upstream response body"); const reader = upstream.body.getReader(); const cancel = onUpstreamAbort = () => { void reader.cancel(ac.signal.reason).catch(() => {}); }; ac.signal.addEventListener("abort", cancel, { once: true }); armStall(); const body = new ReadableStream<Uint8Array>({ async pull(controller) { try { ac.signal.throwIfAborted(); armStall(); const next = await reader.read(); ac.signal.throwIfAborted(); armStall(); if (next.done) { controller.close(); finish(); ac.signal.removeEventListener("abort", cancel); } else controller.enqueue(next.value); } catch (error) { controller.error(error); ac.abort(error); finish(); } }, cancel(reason) { ac.abort(reason); finish(); return reader.cancel(reason); }, }); const credentials = [...boundCredentials]; if (streamFormat) { const headers = { "Content-Type": streamFormat === "sse" ? "text/event-stream" : "application/json", "Cache-Control": "no-cache" }; return new Response(body.pipeThrough(geminiSseTransform( GEMINI_NATIVE_MAX_BYTES, { onNativeError: noteNativeError, onUsage: noteUsage, onOutput: noteOutput }, streamFormat, credentials, )), { headers }); } const text = await readGeminiText(body, GEMINI_NATIVE_MAX_BYTES, ac.signal); if (text === null) return geminiNativeError(502, "Gemini upstream response exceeds the body limit"); const response = unwrapGeminiResponse(text); const payload = JSON.parse(response) as { usageMetadata?: unknown }; if (Object.hasOwn(payload, "error") || containsGeminiCredential(response, credentials)) { noteNativeError(); return geminiNativeError(502, "Antigravity upstream rejected the request"); } const usage = usageFromGemini(payload.usageMetadata); if (usage) noteUsage?.(usage); return new Response(response, { headers: { "Content-Type": "application/json" } }); } catch (error) { ac.abort(); finish(); void upstream?.body?.cancel().catch(() => {}); if (req.signal.aborted) return geminiNativeError(499, "Request cancelled"); if (error instanceof NativeRequestBodyTimeout) return geminiNativeError(408, "Gemini request body upload stalled; send a complete JSON body and retry"); if (error instanceof OAuthLoginRequiredError) return geminiNativeError(503, "Antigravity sign-in required; run ocx login google-antigravity"); if (error instanceof OAuthAccountPausedError) return geminiNativeError(503, "Antigravity account is paused; resume it in OC account settings and retry"); if (error instanceof OAuthTokenRefreshBusyError || error instanceof OAuthTokenRefreshStaleError) { const response = geminiNativeError(503, "Antigravity credential refresh is temporarily busy; retry shortly"); response.headers.set("Retry-After", "1"); return response; } if (error instanceof RequestPacingQueueOverloadError) { const response = geminiNativeError(429, "Antigravity request queue is temporarily full; retry after the indicated delay"); const seconds = Number.isFinite(error.retryAfterSeconds) ? Math.max(1, Math.ceil(error.retryAfterSeconds)) : 5; response.headers.set("Retry-After", String(seconds)); return response; } if (error instanceof RequestPacingProviderRemovedError || error instanceof NativeConfigurationInvalid) { return geminiNativeError(503, "Antigravity provider configuration is unavailable or invalid; check its baseUrl and destination policy in OC settings"); } if (error instanceof NativeModelUnavailable) { if (logCtx) { logCtx.errorCode = "gemini_native_model_unlisted"; markLocalRequestLogRefusal(logCtx, "gemini_native_model_unlisted"); } return geminiNativeError(403, error.message, "gemini_native_model_unlisted"); } if (error instanceof NativeWorkflowSendDenied) { const denial = spendTracker?.lastRefusal; if (denial) { const refusal = workflowRefusalResponse(denial.reason, logCtx, undefined, undefined, denial.spend); return carryWorkflowRefusal(refusal, toGeminiRefusal(refusal)); } const refusal = workflowRefusalResponse("workflow-sends-exhausted", logCtx, undefined, rootId); return carryWorkflowRefusal(refusal, geminiNativeError(429, "OpenCodex workflow physical-send budget exhausted")); } return geminiNativeError(req.signal.aborted ? 499 : 502, req.signal.aborted ? "Request cancelled" : "Gemini native upstream request failed"); } }