UNPKG

@bitkyc08/opencodex

Version:

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

304 lines (298 loc) • 14.4 kB
import type { ResponsesRequestContext } from "./core-options"; import type { PreparedResponsesRequest } from "./request-prepare"; import type { ResponsesTransport } from "./request-transport"; import type { ResponsesSidecarAuth } from "./request-sidecar-auth"; import type { ResponsesEffects } from "./response-effects"; import type { ResponsesCompletionPolicy } from "./completion-policy"; import type { AdapterExchange } from "./adapter-dispatch"; import type { AdapterContinuations } from "./adapter-continuation"; import { guardTerminalEventStream } from "./terminal-guard"; import { guardEmptyCompletionEventStream } from "./empty-completion-guard"; import { bridgeToResponsesSSE, buildResponseJSON, formatErrorResponse } from "../../bridge"; import type { OcxProviderContinuationState, AdapterEvent } from "../../types"; import { rememberResponseState } from "../../responses/state"; import { trackStreamLifetime } from "../lifecycle"; import { awaitThoughtSignatureDurability } from "../../responses/thought-signature-replay"; import { adapterResponseReachedServingTerminal } from "./core-replay"; import { readResponseBodyWithInactivity, readResponseStreamWithInactivity, ResponseBodyInactivityError, } from "../../lib/response-body-inactivity"; import { resolveStallTimeoutMs } from "../../stall-timeout"; import { clientEncoderForDelivery, deliverClientEncodedResponse } from "../inference/client-encoder-delivery"; import { noteKiroServedSuccess } from "../../providers/kiro-usage"; import { persistKiroAccountState } from "../../providers/kiro-account-state-disk"; import { isCanonicalOpenAiForwardProvider } from "../../providers/openai-tiers"; /** One responsibility of the Responses request pipeline; state owners are explicit. */ export async function deliverAdapterResponse( requestContext: Pick<ResponsesRequestContext, "logCtx" | "options" | "config">, requestState: Pick< PreparedResponsesRequest, | "parsed" | "route" | "translatorBudget" | "toolBridgeMaps" | "rememberKiroDeliveredFinalAnswer" | "responseStateOptions" >, transportState: Pick<ResponsesTransport, "activeAdapter" | "bindKeyUsageFromBridge" | "sentOAuthSnapshot">, sidecarState: Pick<ResponsesSidecarAuth, "routedCompaction">, responseEffects: Pick< ResponsesEffects, | "cancelResponseCompletion" | "commitReasoningReplayServingRoute" | "continuationStateForResponse" | "notifyResponseComplete" >, completionPolicy: Pick<ResponsesCompletionPolicy, "emptyCompletionGuardEnabled">, adapterExchange: Pick<AdapterExchange, "upstreamResponse" | "upstream" | "cleanupUpstreamAbort" | "localUpstream">, continuationState: Pick<AdapterContinuations, "terminalGuardEnabled" | "fetchTerminalGuardContinuation" | "fetchGuardedEmptyCompletionRetry">, ): Promise<Response> { const { logCtx, options, config } = requestContext; const { parsed, route, translatorBudget, toolBridgeMaps, rememberKiroDeliveredFinalAnswer, responseStateOptions, } = requestState; const { upstreamResponse, upstream, cleanupUpstreamAbort, localUpstream } = adapterExchange; const { terminalGuardEnabled, fetchTerminalGuardContinuation, fetchGuardedEmptyCompletionRetry, } = continuationState; const { emptyCompletionGuardEnabled } = completionPolicy; const { cancelResponseCompletion, commitReasoningReplayServingRoute, continuationStateForResponse, notifyResponseComplete, } = responseEffects; const { routedCompaction } = sidecarState; const bodyInactivityMs = resolveStallTimeoutMs(config.stallTimeoutSec, { localUpstream }); const upstreamRequestsStream = parsed.stream || isCanonicalOpenAiForwardProvider(route.provider); if (parsed.stream) { // The continuation legs classify a stalled body themselves; the initial stream needs the // same mapping or the bridge catch reports this upstream timeout as a 500 proxy_error. const initialEventStream = (async function* (): AsyncGenerator<AdapterEvent> { try { for await (const event of readResponseStreamWithInactivity( upstreamResponse, upstream.signal, bodyInactivityMs, response => transportState.activeAdapter.parseStream(response, translatorBudget, logCtx.activeTierMetadata), )) { options.onCompactionRecoveryAdapterEvent?.(event); yield event; } } catch (error) { if (error instanceof ResponseBodyInactivityError) { yield { type: "error", message: "Upstream response body stalled before completing", status: 504, errorType: "upstream_error", }; return; } throw error; } })(); const eventStream = terminalGuardEnabled ? guardTerminalEventStream({ parsed, firstEvents: initialEventStream, adapterName: transportState.activeAdapter.name, maxAutoContinuations: 1, continuation: next => fetchTerminalGuardContinuation(next, undefined, !parsed.stream), }) : initialEventStream; // The empty-completion guard sits OUTSIDE the terminal guard: a completed // turn with no text and no tool call is retried with the IDENTICAL request // (fetchTerminalGuardContinuation(parsed) replays the cached byte-identical // request — same body, same headers, same signal). const guardedEventStream = emptyCompletionGuardEnabled ? guardEmptyCompletionEventStream({ firstEvents: eventStream, continuation: fetchGuardedEmptyCompletionRetry, }) : eventStream; const { toolNsMap, declaredToolNames, toolParameterSchemas, freeformToolNames, bareCustomToolNames, toolSearchToolNames } = toolBridgeMaps; // One completion owner for both deliveries: the bridge calls it from its terminal, the // direct client encoder from the fold of the same events. const onCompletedResponse = (response: Record<string, unknown>, providerState?: OcxProviderContinuationState) => { const served = transportState.sentOAuthSnapshot; if (transportState.activeAdapter.name === "kiro" && response.status === "completed" && served && noteKiroServedSuccess(served.accountId, served.generation)) persistKiroAccountState(); commitReasoningReplayServingRoute(); rememberKiroDeliveredFinalAnswer(transportState.activeAdapter.name, response); // Compaction turns must NOT enter the continuation cache: _rawBody still holds the full // PRE-compaction history, and a later previous_response_id expansion would rehydrate the // giant stale chain Codex just replaced. if (!routedCompaction) { rememberResponseState( parsed._rawBody, response, continuationStateForResponse(providerState), responseStateOptions(transportState.activeAdapter.name === "kiro"), ); } notifyResponseComplete(response); }; const clientEncoder = clientEncoderForDelivery(options, logCtx, !!routedCompaction, transportState.activeAdapter.name); if (clientEncoder) { return deliverClientEncodedResponse({ encoder: clientEncoder, events: guardedEventStream, logCtx, translatorBudget, responseModelId: parsed._responseModelId ?? parsed.modelId, adapterName: transportState.activeAdapter.name, fold: { replayCacheScope: parsed._reasoningReplayScope, hideThinkingSummary: parsed.options.hideThinkingSummary, hideRawReasoning: parsed.options.hideRawReasoning, toolNsMap, declaredToolNames, toolParameterSchemas, freeformToolNames, bareCustomToolNames, toolSearchToolNames, }, stallTimeoutSec: config.stallTimeoutSec, localUpstream, turnAdmissionLease: options.turnAdmissionLease, ...(options.onFirstOutput ? { onFirstOutput: options.onFirstOutput } : {}), stopUpstream: () => { cancelResponseCompletion(); upstream.abort(); }, onStreamDone: cleanupUpstreamAbort, onCompletedResponse, bindUsage: usage => transportState.bindKeyUsageFromBridge(usage), }); } const sseStream = bridgeToResponsesSSE( guardedEventStream, parsed._responseModelId ?? parsed.modelId, toolNsMap, freeformToolNames, toolSearchToolNames, () => { cancelResponseCompletion(); upstream.abort(); }, 2_000, { translatorBudget, replayCacheScope: parsed._reasoningReplayScope, ...(options.forceEmptyResponseId ? { responseId: "" } : {}), stallTimeoutSec: config.stallTimeoutSec, localUpstream, hideThinkingSummary: parsed.options.hideThinkingSummary, hideRawReasoning: parsed.options.hideRawReasoning, declaredToolNames, bareCustomToolNames, enforceDeclaredToolNames: options.inboundWire !== "chat" && options.inboundWire !== "anthropic", toolParameterSchemas, ...(options.onFirstOutput ? { onFirstOutput: options.onFirstOutput } : {}), ...(routedCompaction ? { compaction: true } : {}), // Same grok-surface split as the runTurn branch above. ...(logCtx.surface === "grok" ? { heartbeatStyle: "comment" as const } : {}), onUsage: usage => { // Raw adapter usage, pre wire-normalization (see the runTurn branch above). transportState.bindKeyUsageFromBridge(usage); }, onCompletedResponse, }, ); const bridgeTurnAc = new AbortController(); const trackedSse = trackStreamLifetime(sseStream, bridgeTurnAc, cleanupUpstreamAbort, options.turnAdmissionLease); return new Response(trackedSse, { headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", "Connection": "keep-alive", "X-Accel-Buffering": "no" }, }); } if (transportState.activeAdapter.parseResponse || (upstreamRequestsStream && transportState.activeAdapter.parseStream)) { let events: AdapterEvent[]; try { const initialEvents: AdapterEvent[] = []; if (upstreamRequestsStream && transportState.activeAdapter.parseStream) { // The canonical ChatGPT adapter coerces its actual upstream request to SSE even for a // JSON client. Routed compaction still owns the non-streaming client response, so fold // that SSE through the adapter instead of handing it to parseResponse as JSON. for await (const event of readResponseStreamWithInactivity( upstreamResponse, upstream.signal, bodyInactivityMs, response => transportState.activeAdapter.parseStream(response, translatorBudget, logCtx.activeTierMetadata), )) initialEvents.push(event); } else { initialEvents.push(...await readResponseBodyWithInactivity( upstreamResponse, upstream.signal, bodyInactivityMs, response => transportState.activeAdapter.parseResponse!(response, translatorBudget, logCtx.activeTierMetadata), )); } for (const event of initialEvents) options.onCompactionRecoveryAdapterEvent?.(event); let guardedEvents: AdapterEvent[]; if (terminalGuardEnabled) { guardedEvents = []; for await (const event of guardTerminalEventStream({ parsed, firstEvents: (async function* () { yield* initialEvents; })(), adapterName: transportState.activeAdapter.name, maxAutoContinuations: 1, continuation: next => fetchTerminalGuardContinuation(next, undefined, !parsed.stream), })) guardedEvents.push(event); } else { guardedEvents = initialEvents; } if (emptyCompletionGuardEnabled) { events = []; for await (const event of guardEmptyCompletionEventStream({ firstEvents: (async function* () { yield* guardedEvents; })(), continuation: fetchGuardedEmptyCompletionRetry, })) events.push(event); } else { events = guardedEvents; } } catch (error) { if (error instanceof ResponseBodyInactivityError) { return formatErrorResponse(504, "upstream_error", "Upstream response body stalled before completing"); } throw error; } finally { cleanupUpstreamAbort(); } const { toolNsMap, declaredToolNames, toolParameterSchemas, freeformToolNames, bareCustomToolNames, toolSearchToolNames } = toolBridgeMaps; let providerState: OcxProviderContinuationState | undefined; const json = buildResponseJSON(events, parsed._responseModelId ?? parsed.modelId, { translatorBudget, replayCacheScope: parsed._reasoningReplayScope, hideThinkingSummary: parsed.options.hideThinkingSummary, hideRawReasoning: parsed.options.hideRawReasoning, toolNsMap, declaredToolNames, bareCustomToolNames, enforceDeclaredToolNames: options.inboundWire !== "chat" && options.inboundWire !== "anthropic", toolParameterSchemas, freeformToolNames, toolSearchToolNames, ...(routedCompaction ? { compaction: true } : {}), onProviderState: state => { providerState = state; }, onUsage: usage => { transportState.bindKeyUsageFromBridge(usage); }, }); // See the streaming branch: compaction turns skip the continuation cache. if (!routedCompaction) { rememberKiroDeliveredFinalAnswer(transportState.activeAdapter.name, json); rememberResponseState( parsed._rawBody, json, continuationStateForResponse(providerState), responseStateOptions(transportState.activeAdapter.name === "kiro"), ); } // #1926 gap 2: same buffered-path durability bound as the primary branch. await awaitThoughtSignatureDurability(); if (adapterResponseReachedServingTerminal(events, json)) { const served = transportState.sentOAuthSnapshot; if (transportState.activeAdapter.name === "kiro" && json.status === "completed" && served && noteKiroServedSuccess(served.accountId, served.generation)) persistKiroAccountState(); commitReasoningReplayServingRoute(); } notifyResponseComplete(json); return new Response(JSON.stringify(json), { headers: { "Content-Type": "application/json" } }); } return formatErrorResponse(400, "invalid_request_error", "Non-streaming not supported by this adapter"); }