@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
751 lines (737 loc) • 45.5 kB
text/typescript
import { truncationReasonFor } from "../../responses/truncated-stop-reason";
import { normalizeRoutedAgentMessages } from "../routed-agent-messages";
import { frameCompactionHistory } from "../../responses/compaction-history-framing";
import { nameRoutedIdentity, repairIdentityInResponsesBody, stripRoutedIdentity } from "../identity";
import { stripBracketedModelSuffix } from "../openai-chat";
import { isOpenCodeGoResponsesUrl, isXaiResponsesUrl, promoteResponsesAdditionalTools } from "../opencode-go-additional-tools";
import { isXaiResponsesDestination } from "../../providers/xai-transport";
import { applyGithubCopilotContextTier } from "../../providers/github-copilot-context";
import { Buffer } from "node:buffer";
import type { AdapterRequest, IncomingMeta, ProviderAdapter } from "../base";
import { namespacedToolName, type AdapterEvent, type OcxParsedRequest, type OcxProviderConfig, type OcxUsage, type TierDecision } from "../../types";
import { applyCodexRoutingHint, CODEX_RESPONSES_LITE_HEADER, CODEX_RESPONSES_LITE_METADATA_KEY, CODEX_ROUTING_HINT_HEADER, isolateCodexPoolClientMetadata } from "../../codex/forward-transport-headers";
import { COMPACT_PROMPT, compactionItemToText, decodeCompactionSummary, isCompactionItemType, transferCompactionCiphertextLease } from "../../responses/compaction";
import { decodeServerSentEvents } from "../../lib/sse-decoder";
import {
CODEX_FORWARD_BASE_URL,
destinationDecodesNativeCompactionBlob,
isCanonicalOpenAiForwardProvider,
isOpenAiOperatedResponsesDestination,
supportsNativeResponsesCompactionTrigger,
} from "../../providers/openai-tiers";
import type { TranslatorBudget } from "../../lib/translator-budget";
import { rewriteRoutedCustomToolsForUpstream, validateFinalCustomToolCompatibility } from "../../responses/custom-tool-compat";
import { rewriteRoutedToolSearchForUpstream } from "../../responses/tool-search-compat";
import { rewriteRoutedNamespaceToolsForUpstream } from "../../responses/namespace-tool-compat";
import { repairLegacyDottedToolCallNames } from "../../responses/legacy-dotted-tool-name-repair";
import { preparePlaintextV2AgentMessages } from "../../responses/plaintext-v2-agent-messages";
import { isMetaAiResponsesDestination, rewriteMuseToolNamesForUpstream } from "../../responses/muse-tool-name-alias";
import { NATIVE_GPT62_ASTRA_MODEL, NATIVE_GPT62_SOL_MODEL } from "../../codex/catalog/native-models";
import { buildResponsesTransport } from "./transport";
export { FORWARD_HEADERS } from "./transport";
import { normalizeResponsesCodeMode } from "../responses-code-mode";
import { injectXaiResponsesXSearch, normalizeXaiResponsesWebSearch } from "../xai-web-search";
import {
isXaiSchemaTarget,
normalizeXaiToolParameters,
XaiToolSchemaCompatibilityError,
} from "../xai-tool-schema";
import {
createAdapterTierMetadata,
emittedFastWire,
} from "../../providers/fastwire";
import { dropResponsesReasoningInputItems, mapRoutedResponsesReasoningEffort, normalizeConfiguredReasoningSummaryDelivery, sanitizeReasoningInputContent, stripDisabledReasoningSummaries, stripDisabledVerbosity, stripInternalReasoningEnabled, stripNoneReasoningSummary, stripUnsupportedReasoningSummaryDelivery } from "./reasoning";
import { repairUrlCitationAnnotations, scrubOcxCompactionItems, stripUnsupportedOutputInclude, stripArkKimiOrphanCipher, stripCanonicalOnlyInputItems, stripCanonicalOnlyToolFields, stripCanonicalOnlyTopLevelFields, stripInternalChatMessageMetadataPassthrough, stripInvalidItemIds, stripItemIdsWhenUnstored, stripProviderInputItemMetadata, stripRejectedSamplingParams } from "./request-strips";
import { notePlaintextReasoningDropped } from "./plaintext-reasoning-notice";
import { stripCanonicalForwardPromptCacheOptions, stripDeprecatedPromptCacheRetention } from "./prompt-cache";
import { isPlainObject } from "./internal";
import { usageFromResponsesPayload } from "./usage";
import { normalizeToolSchemas, promoteClientLoadedTools, stripUnsupportedHostedTools } from "./tool-schema";
import { annotateEmptyResponsesToolOutputs, backfillWebSearchQueries, normalizeResponsesToolResultAdjacency, repairOrphanedInputItems, repairOversizedReplayCallIds, repairUnidentifiedToolOutputItems, restoreBridgedWebSearchCalls } from "./tool-output-recovery";
import { bridgeSearchReplayScope } from "../../responses/bridge-search-replay-cache";
import { tagHistoricalInputItems } from "../../responses/item-provenance";
import { applyTierDecisionToResponsesBody, normalizeCanonicalForwardContinuationEnvelope, normalizeCanonicalForwardPromptEnvelope, stripCanonicalForwardSamplingParams, stripPreviousResponseId, stripStatefulResponsesParams, stripUnsupportedForwardParams } from "./canonical-forward";
import { normalizeImageGenClientTools, preferConfiguredHostedTools } from "./image-gen";
import { stripMuseSparkUnsupportedWebSearchFields, stripOpenAiOnlyWebSearchFields } from "./web-search";
import { observeOutbound } from "../../usage/cache-diagnostic";
import { normalizeMuseToolCatalog } from "./muse-tool-catalog";
import { normalizeMuseToolChoice } from "./muse-tool-choice";
import { declaresHostedWebSearch, projectHostedSearchHistory, renderCompactionSearchHistoryItems } from "./compaction-search-history";
import { isKimiCodingResponsesHttpsUrl, stripKimiEmptyAssistantMessages } from "./empty-assistant";
import { normalizeOpenGatewayResponsesInput } from "./opengateway-input";
/**
* Identifies DeepSeek's strict Responses replay contract: tool-bearing continuations need
* plaintext reasoning and cannot consume opaque reasoning state. The two existing flags are
* current evidence for that one provider contract, not equivalent capabilities: preservation
* keeps plaintext reasoning on the wire, while adjacency marks its strict tool-history shape.
* The moment a second provider needs this behavior, replace this derivation with an explicit
* registry capability rather than extending the inference.
*/
export function requiresPlaintextReasoningReplay(provider: OcxProviderConfig): boolean {
return provider.preserveResponsesReasoningContent === true
&& provider.requiresAdjacentResponsesToolResults === true;
}
/** Replace every `input_image` part under a routed-compaction body with a short marker. */
function stripInputImagesDeep(value: unknown): unknown {
if (Array.isArray(value)) return value.map(stripInputImagesDeep);
if (!isPlainObject(value)) return value;
if (value.type === "input_image") {
return { type: "input_text", text: "[image omitted for compaction]" };
}
const out: Record<string, unknown> = {};
for (const [key, entry] of Object.entries(value)) out[key] = stripInputImagesDeep(entry);
return out;
}
function codexResponsesLiteSelected(headers: Record<string, string>, body: unknown): boolean {
const lite = new Headers(headers).get(CODEX_RESPONSES_LITE_HEADER);
if (lite === "true" || lite === "false") return lite === "true";
// Match existing canonical WS preparation: explicit HTTP intent wins, otherwise native
// string-map frame metadata survives. This reads intent without rewriting the transport.
if (!isPlainObject(body) || !isPlainObject(body.client_metadata)) return false;
return Object.values(body.client_metadata).every(value => typeof value === "string")
&& body.client_metadata[CODEX_RESPONSES_LITE_METADATA_KEY] === "true";
}
/**
* Rewrite a compaction turn without native v2 capability, or a forced portable
* handoff: drop the trigger and the whole tool surface, and ask for the handoff
* summary in plain terms instead (#422). Native v1 capability is independent.
*
* The adapter builds from `parsed._rawBody`, so the summarizer prompt that
* handleResponses() pushed onto `parsed.context` never reaches the wire — it has to
* be applied here. Images go too: a summary needs no pixels, and a text-only
* gateway would reject them.
*/
function buildRoutedCompactionBody(body: unknown, responsesLite: boolean): unknown {
if (!isPlainObject(body)) return body;
// `text` goes with the tool fields: the summary must be prose, not schema-constrained JSON.
const { tools: _tools, tool_choice: _toolChoice, parallel_tool_calls: _parallel, text: _text, ...rest } = body;
const input = Array.isArray(body.input) ? body.input : [];
// Bridge restoration has already recovered any available real call/result pairs. Remaining
// hosted cells require tools, so they become bounded assistant reference notes.
const kept = renderCompactionSearchHistoryItems(input.filter(item => !isPlainObject(item)
// `additional_tools` is how Codex Desktop's responses-lite shape carries tools;
// leaving it in would break the no-tools invariant even with `tools` removed.
|| (item.type !== "compaction_trigger" && item.type !== "additional_tools")));
return {
...rest,
// Lite validates this flag even when the summarizer has no callable tools.
...(responsesLite ? { parallel_tool_calls: false } : {}),
input: [
...(stripInputImagesDeep(kept) as unknown[]),
{ type: "message", role: "user", content: [{ type: "input_text", text: COMPACT_PROMPT }] },
],
};
}
function responsesPayloadText(response: unknown): string {
if (!isPlainObject(response) || !Array.isArray(response.output)) return "";
return response.output
.filter(item => isPlainObject(item) && item.type === "message")
.flatMap(item => (Array.isArray((item as Record<string, unknown>).content)
? (item as { content: unknown[] }).content
: []))
.filter(part => isPlainObject(part) && part.type === "output_text")
.map(part => String((part as { text?: unknown }).text ?? ""))
.join("");
}
function responsesErrorMessage(payload: unknown): string {
if (!isPlainObject(payload)) return "upstream compaction failed";
const err = payload.error;
if (typeof err === "string") return err;
if (isPlainObject(err) && typeof err.message === "string") return err.message;
const incomplete = payload.incomplete_details;
if (isPlainObject(incomplete) && typeof incomplete.reason === "string") return incomplete.reason;
return "upstream compaction failed";
}
/** Count an append without rescanning accumulated text, including split surrogate pairs. */
function appendedUtf8Bytes(previousBytes: number, lastCodeUnit: number, fragment: string): number {
const first = fragment.charCodeAt(0);
// Separate lone surrogates each count as a three-byte replacement character; together
// they encode as one four-byte scalar. Empty fragments produce NaN and never pair.
const joinsSurrogatePair = lastCodeUnit >= 0xd800 && lastCodeUnit <= 0xdbff && first >= 0xdc00 && first <= 0xdfff;
return previousBytes + Buffer.byteLength(fragment, "utf8") - (joinsSurrogatePair ? 2 : 0);
}
export function createResponsesPassthroughAdapter(provider: OcxProviderConfig): ProviderAdapter & { passthrough: true } {
return {
name: "openai-responses",
passthrough: true as const,
buildRequest(parsed: OcxParsedRequest, incoming: IncomingMeta) {
const translatorBudget = incoming.translatorBudget;
const { url, headers } = buildResponsesTransport(provider, incoming);
const forward = provider.authMode === "forward";
let convertedRoutedCustomToolNames: Set<string> | undefined;
let routedCustomToolRepairNames: Set<string> | undefined;
let convertedRoutedToolSearchNames: Set<string> | undefined;
let convertedRoutedNamespaceToolAliases: Map<string, { namespace: string; name: string; kind: "function" | "custom" }> | undefined;
let plaintextV2AgentMessageToolNames: ReadonlySet<string> | undefined;
let plaintextV2AgentMessageAliasedToolNames: ReadonlySet<string> | undefined;
let convertedMuseToolNameAliases: Map<string, string> | undefined;
const unexpandedMiss = !!parsed.previousResponseId && parsed._previousResponseInputExpanded !== true;
const replayPrefixLen = parsed._replayPrefixLen;
let outBody = parsed._rawBody;
// Clone and tag before any input rewrite can remove, replace, or reorder replay items.
if (
typeof replayPrefixLen === "number"
&& replayPrefixLen > 0
&& isPlainObject(outBody)
&& Array.isArray(outBody.input)
) {
outBody = {
...outBody,
input: tagHistoricalInputItems(outBody.input, replayPrefixLen),
};
}
outBody = stripPreviousResponseId(
outBody,
forward || parsed._previousResponseInputExpanded === true,
);
if (isMetaAiResponsesDestination(url)) {
outBody = normalizeMuseToolCatalog(outBody, parsed._replayPrefixLen, provider.supportsResponsesCustomTools);
}
if (!forward) outBody = normalizeRoutedAgentMessages(outBody, {
allowStringContent: isXaiResponsesDestination(provider),
});
// #5217: a sub-agent inherits the parent session's instruction block, so the identity
// sentence this proxy generated for the PARENT's model rides along to a worker running a
// different one. On a routed destination it is renamed to that destination — including the
// model-neutral catalog sentence, which this adapter never names itself; on a native/forward
// destination our sentence is dropped, because Codex's own identity wording (sent in the
// client's model_switch block) is the correct one there. Text the proxy did not generate —
// user turns, tool output, fenced code, provider-native blocks — is untouched.
outBody = repairIdentityInResponsesBody(
outBody,
forward ? stripRoutedIdentity : (text: string) => nameRoutedIdentity(text, parsed.modelId),
);
outBody = mapRoutedResponsesReasoningEffort(outBody, provider, parsed.modelId);
// stripPreviousResponseId() intentionally returns its input on a no-op. Detach before the
// tier write so a force-fast/default decision can never mutate parsed._rawBody.
outBody = applyTierDecisionToResponsesBody(outBody, parsed.options?.tierDecision);
const stateless = provider.statelessResponses === true;
const adjacentToolResults = provider.requiresAdjacentResponsesToolResults === true;
// Adjacency reorders items the upstream would accept in some order. Pairing synthesizes an
// item the client never sent, which is a larger claim about the conversation, so it is its
// own capability: Kimi carries the adjacency flag but accepts a dangling call (#4726) and
// must not start receiving placeholders it never needed.
const pairedToolResults = provider.requiresPairedResponsesToolResults === true;
if (stateless) outBody = stripStatefulResponsesParams(outBody);
// A replay miss can leave a function_call_output whose paired function_call sat
// in the prefix that was never expanded. A stateless upstream cannot resolve the
// pair from its own storage either, so it needs the same repair the forward
// backend gets — dropping previous_response_id is not much use if the body that
// reaches the wire is unparseable.
// A parser can also 400 on a function_call with no matching output at all. DeepSeek gets
// that repair through statelessResponses. xAI cannot be marked stateless: its Responses API
// stores conversations for 30 days and documents previous_response_id. So it carries the
// pairing capability instead, which reuses the orphan-call placeholder without touching
// store or previous_response_id.
if (provider.annotateEmptyToolOutputs === true) {
outBody = annotateEmptyResponsesToolOutputs(outBody, true);
}
const synthesizeMissingCallOutputs = !forward && (stateless || pairedToolResults);
if (forward || stateless || pairedToolResults) {
// A stateful destination can resolve an output-only delta against the call stored behind
// an unexpanded previous_response_id. All other shapes have no hidden call to preserve.
const repairOrphanOutputs = forward || stateless || !unexpandedMiss;
outBody = repairOrphanedInputItems(
outBody,
unexpandedMiss,
synthesizeMissingCallOutputs,
repairOrphanOutputs,
);
}
if (provider.dropResponsesReasoningItems === true) {
outBody = dropResponsesReasoningInputItems(outBody);
}
if (adjacentToolResults) {
outBody = normalizeResponsesToolResultAdjacency(outBody);
}
const hostedToolSubstitutions: NonNullable<AdapterRequest["hostedToolSubstitutions"]>[number][] = [];
if (forward) {
// `metadata` is stripped on every forward route for compatibility with the canonical backend.
// `max_output_tokens` is stripped only when this provider is the canonical backend.
outBody = stripUnsupportedForwardParams(outBody, isCanonicalOpenAiForwardProvider(provider));
// Only the canonical ChatGPT backend rejects the canonical-only fields below; a self-hosted
// or third-party forward gateway may accept them, so this guard must not be widened.
if (isCanonicalOpenAiForwardProvider(provider)) {
outBody = stripCanonicalForwardSamplingParams(outBody);
outBody = stripDeprecatedPromptCacheRetention(outBody, parsed.modelId);
outBody = stripCanonicalForwardPromptCacheOptions(outBody);
outBody = normalizeCanonicalForwardPromptEnvelope(outBody);
outBody = normalizeCanonicalForwardContinuationEnvelope(outBody);
}
} else {
outBody = stripRejectedSamplingParams(outBody, provider, parsed.modelId);
outBody = preferConfiguredHostedTools(
outBody,
provider,
parsed.modelId,
parsed._openAiVirtualSelectedModelId,
hostedToolSubstitutions,
);
outBody = normalizeImageGenClientTools(outBody);
}
if (forward || parsed._previousResponseInputExpanded === true) {
outBody = repairOversizedReplayCallIds(outBody);
}
outBody = stripUnsupportedReasoningSummaryDelivery(outBody, parsed.modelId);
outBody = stripNoneReasoningSummary(outBody);
// #4587: on a bridged provider, hand the destination back the search call and result the
// proxy executed on its behalf, in place of the hosted cell the caller replays. Scoped to
// its exact conversation and serving identity and recorded by the bridge itself, so a
// provider without the opt-in computes no identity and keeps the body reference it already
// had. This runs before query backfill because a restored cell is no longer one to repair.
if (provider.webSearchBridge?.enabled === true) {
outBody = restoreBridgedWebSearchCalls(outBody, bridgeSearchReplayScope(parsed._reasoningReplayScope));
}
// Repair stored history from before the bridge emitted both keys, in either
// direction: a conversation that already recorded a web_search_call replays it
// every turn, and a strict parser rejects the whole request over the missing key —
// `queries` for DeepSeek (#930), `query` for Console Go (#3071).
outBody = backfillWebSearchQueries(outBody);
// #5095: a conversation that already contains a `default.`-prefixed call name is refused by
// the upstream `^[a-zA-Z0-9_-]+$` name pattern on every later turn that replays it, so the
// task cannot be compacted or continued at all. Repair the replayed item here, before the
// canonical-destination split below, because the reported failure was a side chat on a plain
// OpenAI model inheriting history a routed provider had damaged.
outBody = repairLegacyDottedToolCallNames(outBody);
// Shared HTTP/WS outbound projection, including concrete combo/fallback destinations.
if (isOpenAiOperatedResponsesDestination(provider)) {
outBody = repairUrlCitationAnnotations(stripProviderInputItemMetadata(outBody));
}
if (!isCanonicalOpenAiForwardProvider(provider)) {
if (provider.preserveResponsesMessageMetadata !== true) {
outBody = stripInternalChatMessageMetadataPassthrough(outBody);
}
// The same class of private field, one level up, but keyed on the DESTINATION rather than
// on the canonical surface alone. `src/server/responses/compact.ts` spreads the caller's
// raw body into native `/responses/compact` without this adapter, and applies the same
// destination boundary for opted-in custom gateways. Native endpoint capability does not
// grant OpenAI-private fields. Stripping on the canonical predicate here would make the
// two paths disagree for `openai-apikey`; stripping on the destination keeps every
// OpenAI-operated route byte-identical and removes the field exactly where it is known
// to break, which is a gateway this proxy does not operate.
//
// Placed before the routed compaction body is built and before serialization, so the HTTP,
// routed-compaction and WebSocket outbounds are all covered by this one call.
if (!isOpenAiOperatedResponsesDestination(provider)) {
if (parsed._compactionRequest !== true && isPlainObject(outBody)) outBody = frameCompactionHistory(outBody);
outBody = stripCanonicalOnlyTopLevelFields(outBody);
outBody = stripCanonicalOnlyInputItems(outBody);
}
// Meta already captured discoveries from the original current-turn slice.
if (!isMetaAiResponsesDestination(url)) outBody = promoteClientLoadedTools(outBody);
}
if (!isCanonicalOpenAiForwardProvider(provider)) {
const rewritten = rewriteRoutedCustomToolsForUpstream(
outBody,
provider.supportsResponsesCustomTools,
);
outBody = rewritten.body;
convertedRoutedCustomToolNames = rewritten.names;
routedCustomToolRepairNames = rewritten.repairNames;
}
if (!isCanonicalOpenAiForwardProvider(provider)) {
// Run after custom-tool lowering so the search compatibility layer can choose a
// collision-free public function name against the final routed function catalog.
const rewritten = rewriteRoutedToolSearchForUpstream(outBody);
outBody = rewritten.body;
convertedRoutedToolSearchNames = rewritten.names;
}
if (!isCanonicalOpenAiForwardProvider(provider)) {
// Codex 0.147 emits private namespace tool groups, while public/third-party Responses
// gateways accept only flat tool variants. Run after custom/tool-search lowering so
// namespace children already carry their final public kind before they are promoted.
const rewritten = rewriteRoutedNamespaceToolsForUpstream(outBody, convertedRoutedCustomToolNames);
outBody = rewritten.body;
convertedRoutedNamespaceToolAliases = rewritten.aliases;
// Preserve xAI's cached-only fail-closed semantics and image-search mapping before the
// generic capability fallback removes the private OpenAI fields. Grok relayed through
// OpenCode Go speaks the same dialect, which the final model id and URL identify.
outBody = normalizeXaiResponsesWebSearch(outBody, provider, { modelId: parsed.modelId, responseUrl: url });
outBody = injectXaiResponsesXSearch(outBody, provider, parsed._replayPrefixLen);
// xAI, Meta, Azure and Kimi Code (#8075) answer 400 for `output.encrypted_content`
// instead of ignoring it; Codex Desktop asks for it on every turn (#7878).
// Go multiplexes backends with different include support (#8702). Use its exact
// destination's common compatibility policy rather than a model-name allowlist.
// Azure also rejects this exact include entry, including on plain Responses routes.
const isAzureResponses = provider.adapter === "azure" || provider.adapter === "azure-openai"
|| new URL(url).hostname.toLowerCase().endsWith(".openai.azure.com");
const arkKimi = !forward && provider.arkKimiResponsesModels?.includes(parsed.modelId);
if (arkKimi) outBody = stripArkKimiOrphanCipher(outBody);
if (isXaiResponsesDestination(provider) || isMetaAiResponsesDestination(url) || isAzureResponses
|| isKimiCodingResponsesHttpsUrl(url) || arkKimi || isOpenCodeGoResponsesUrl(url)) {
outBody = stripUnsupportedOutputInclude(outBody);
}
// xAI and explicitly classified compatible gateways reject these OpenAI web_search
// extensions. Keep them for OpenAI API-key traffic and unclassified gateways.
if (provider.supportsOpenAiWebSearchToolFields === false) {
outBody = stripOpenAiOnlyWebSearchFields(outBody);
}
outBody = stripMuseSparkUnsupportedWebSearchFields(outBody, parsed.modelId, url);
// Host-only: api.meta.ai rejects function names over 64 chars on every Muse model,
// including default muse-spark-1.3. Do not reuse the contributor/Zen web_search
// predicates. Namespace flattening has already produced the public wire names.
if (isMetaAiResponsesDestination(url)) {
const rewritten = rewriteMuseToolNamesForUpstream(outBody);
outBody = rewritten.body;
convertedMuseToolNameAliases = rewritten.aliases;
}
// Last, so promoted namespace children are also cleared of Codex-private fields.
outBody = stripCanonicalOnlyToolFields(outBody, provider.supportsOpenAiWebSearchToolFields === false);
}
if (
provider.promoteAdditionalTools === true
|| (!forward && (
isOpenCodeGoResponsesUrl(url)
|| isXaiResponsesDestination(provider)
|| isXaiResponsesUrl(url)
))
) {
outBody = promoteResponsesAdditionalTools(outBody);
}
// Same native-v2/portable predicate as the routedCompaction gate in handleResponses():
// neither forward auth nor native v1 endpoint support implies trigger support. The
// compaction body build removes the tool surface and must
// therefore be the last routed transform that may depend on those declarations. Structural
// sanitizers below can still run after it.
outBody = normalizeResponsesCodeMode(outBody, parsed, provider);
if (parsed._compactionRequest === true && (!supportsNativeResponsesCompactionTrigger(provider) || parsed._portableCompaction === true)) {
outBody = buildRoutedCompactionBody(outBody, new Headers(headers).get(CODEX_RESPONSES_LITE_HEADER) === "true");
}
// Run after routed compaction so nested input_image parts are replaced before a malformed
// tool output is flattened to text and can no longer be inspected structurally.
outBody = repairUnidentifiedToolOutputItems(outBody);
outBody = stripKimiEmptyAssistantMessages(outBody, url);
if (parsed._plaintextV2AgentMessages === true && isCanonicalOpenAiForwardProvider(provider)) {
const prepared = preparePlaintextV2AgentMessages(outBody);
outBody = prepared.body;
if (prepared.namespaceAliased) {
plaintextV2AgentMessageToolNames = prepared.toolNames;
plaintextV2AgentMessageAliasedToolNames = prepared.aliasedAgentMessageToolNames;
}
}
const threadServingIdentityChanged = parsed._stripReasoningEncryptedContent === true;
const stripNativeCompaction = parsed._stripNativeCompactionEncryptedContent === true
|| threadServingIdentityChanged;
// Providers with the strict plaintext tool-continuation contract cannot consume any
// encrypted reasoning blob, including one whose provenance is unknown. Combo routing
// separately refuses a proven cross-route replay when no plaintext exists; this final
// serializer guard ensures the foreign opaque state is never forwarded regardless.
const sanitizedBody = normalizeToolSchemas(
stripItemIdsWhenUnstored(
stripInvalidItemIds(
stripUnsupportedHostedTools(
sanitizeReasoningInputContent(
scrubOcxCompactionItems(
outBody,
destinationDecodesNativeCompactionBlob(provider),
stripNativeCompaction,
parsed._compactionRequest !== true,
),
{
preserveRawReasoningContent: provider.preserveResponsesReasoningContent === true,
translatorBudget,
dropNullContentChannel: !isOpenAiOperatedResponsesDestination(provider),
stripEncryptedContent: threadServingIdentityChanged || requiresPlaintextReasoningReplay(provider),
dropForeignItemId: parsed._dropForeignReasoningItemIds === true,
requirePlaintextReasoning: requiresPlaintextReasoningReplay(provider),
onPlaintextReasoningBlanked: () => notePlaintextReasoningDropped(provider),
},
),
provider,
),
),
isXaiResponsesDestination(provider),
provider.preserveResponsesInputItemIds === true,
),
isXaiSchemaTarget(provider),
parsed._chatCompletionsInput === true && isOpenAiOperatedResponsesDestination(provider),
);
const unnormalizedBody = stripDisabledVerbosity(
stripDisabledReasoningSummaries(
normalizeConfiguredReasoningSummaryDelivery(sanitizedBody, provider, parsed.modelId),
provider,
parsed.modelId,
),
provider,
parsed.modelId,
);
// Normalize the wire model before deriving model-dependent transport metadata.
let finalBody =
provider.modelSuffixBracketStrip
&& unnormalizedBody !== null
&& typeof unnormalizedBody === "object"
&& !Array.isArray(unnormalizedBody)
&& typeof (unnormalizedBody as { model?: unknown }).model === "string"
? { ...(unnormalizedBody as Record<string, unknown>), model: stripBracketedModelSuffix((unnormalizedBody as { model: string }).model) }
: unnormalizedBody;
if (isMetaAiResponsesDestination(url)) {
const originalChoice = isPlainObject(parsed._rawBody) ? parsed._rawBody.tool_choice : undefined;
finalBody = normalizeMuseToolChoice(finalBody, originalChoice);
}
// The canonical ChatGPT Codex endpoint is SSE-only even though the public Responses surface
// permits an omitted/false `stream`. Keep the client's delivery preference on `parsed.stream`
// and coerce only this final upstream copy; passthrough delivery folds the terminal stream
// back into JSON for that client. `store` is intentionally untouched here because explicit
// caller storage semantics are independent of the transport required by the destination.
if (isCanonicalOpenAiForwardProvider(provider)
&& isPlainObject(finalBody)
&& finalBody.stream !== true) {
finalBody = { ...finalBody, stream: true };
}
if (isCanonicalOpenAiForwardProvider(provider)) {
if (parsed._anthropicInbound === true && !parsed._compactionRequest && isPlainObject(finalBody)
&& (finalBody.model === NATIVE_GPT62_SOL_MODEL || finalBody.model === NATIVE_GPT62_ASTRA_MODEL)
&& typeof finalBody.instructions === "string" && finalBody.instructions.length > 0
&& Array.isArray(finalBody.input)) {
// GPT-6.2 can reuse the Claude system prompt when it is part of the input prefix.
const { instructions, input, ...rest } = finalBody;
finalBody = {
...rest,
input: [{ type: "message", role: "developer", content: [{ type: "input_text", text: instructions }] }, ...input],
};
}
const override = (provider as { _codexAccountOverride?: { chatgptAccountId: string; kind?: string } })._codexAccountOverride;
if (override && override.kind !== "main-pool") {
finalBody = isolateCodexPoolClientMetadata(finalBody, override.chatgptAccountId);
}
const routingHeaders = new Headers(headers);
applyCodexRoutingHint(routingHeaders, finalBody);
// Static headers may use mixed casing. Remove every stale spelling
// without normalizing unrelated headers returned by this adapter.
for (const name of Object.keys(headers)) {
if (name.toLowerCase() === CODEX_ROUTING_HINT_HEADER) delete headers[name];
}
const hint = routingHeaders.get(CODEX_ROUTING_HINT_HEADER);
if (hint !== null) headers[CODEX_ROUTING_HINT_HEADER] = hint;
}
const tierLog = createAdapterTierMetadata(
parsed.options?.tierObservation,
parsed.options?.tierDecision,
...emittedFastWire(parsed, finalBody),
);
// The Responses adapter is passthrough: it forwards `parsed._rawBody` rather than
// rebuilding the body from `parsed.modelId`, and the router writes the routed id into
// that raw body. So a provider whose upstream rejects bracketed ids has to be honoured
// here, on the serialized body, not on the parsed selector. One place covers both the
// HTTP and the WebSocket outbound, because the WS path transports this same request
// instead of rebuilding it.
// Hosted-search history projection, after bridge restoration and tool validation. Two
// triggers share one bounded renderer, and tool declarations and other input stay intact:
// 1. The opt-in Codex Lite policy covers ordinary turns and native v2 compaction triggers
// (#7268). Portable compaction was already projected by the summary builder above.
// 2. Any request whose final tool surface declares no hosted search. Native Sol answers a
// replayed web_search_call without a matching declaration with a generic server_error
// (#7250), so the cells become untrusted reference notes instead of a doomed request.
if (isPlainObject(finalBody)
&& ((provider.projectResponsesLiteHostedSearchHistory === true && url === `${CODEX_FORWARD_BASE_URL}/responses`
&& !parsed._portableCompaction && codexResponsesLiteSelected(headers, finalBody))
|| !declaresHostedWebSearch(finalBody))) {
finalBody = projectHostedSearchHistory(finalBody);
}
finalBody = normalizeOpenGatewayResponsesInput(finalBody, url);
observeOutbound(parsed._rawBody, finalBody, headers);
if (!isCanonicalOpenAiForwardProvider(provider)) {
validateFinalCustomToolCompatibility(finalBody, provider.supportsResponsesCustomTools);
}
let wireBody = applyGithubCopilotContextTier(finalBody, provider, parsed.modelId, incoming.providerName);
if (isOpenAiOperatedResponsesDestination(provider) || provider.reasoningWireFormat !== "gateway-object") {
wireBody = stripInternalReasoningEnabled(wireBody);
}
const body = JSON.stringify(wireBody);
const releaseBodyObservation = translatorBudget.observeExternallyCapped(
"passthrough_serialization",
Buffer.byteLength(body, "utf8"),
);
return {
url,
method: "POST",
headers,
body,
hostedToolSubstitutions,
...(isPlainObject(wireBody) && typeof wireBody.model === "string" ? { outboundModelId: wireBody.model } : {}),
releaseBodyObservation,
...(convertedRoutedCustomToolNames ? { convertedRoutedCustomToolNames } : {}),
...(routedCustomToolRepairNames ? { routedCustomToolRepairNames } : {}),
...(convertedRoutedToolSearchNames ? { convertedRoutedToolSearchNames } : {}),
...(convertedRoutedNamespaceToolAliases ? { convertedRoutedNamespaceToolAliases } : {}),
...(plaintextV2AgentMessageToolNames ? { plaintextV2AgentMessageToolNames } : {}),
...(plaintextV2AgentMessageAliasedToolNames ? { plaintextV2AgentMessageAliasedToolNames } : {}),
...(convertedMuseToolNameAliases ? { convertedMuseToolNameAliases } : {}),
...(tierLog ? { tierLog } : {}),
};
},
// The passthrough normally relays the upstream stream verbatim and never parses.
// The exception is a routed compaction turn: the server drives this adapter like
// an ordinary one so the bridge can build the single compaction item (#422).
async *parseStream(response: Response, budget: TranslatorBudget): AsyncGenerator<AdapterEvent> {
if (!response.body) {
yield { type: "error", message: "passthrough adapter received no response body" };
return;
}
let deltas = "";
let deltasBytes = 0;
let deltasLastCodeUnit = 0;
let doneText = "";
let doneTextBytes = 0;
let doneTextLastCodeUnit = 0;
let snapshot = "";
let snapshotBytes = 0;
let usage: OcxUsage | undefined;
let usageRawBytes = 0;
let compactionEncryptedContent: string | undefined;
let compactionEncryptedContentBytes = 0;
let completedSeen = false;
let ciphertextTransferred = false;
try {
for await (const event of decodeServerSentEvents(response.body, { translatorBudget: budget })) {
let payload: unknown;
try { payload = JSON.parse(event.data); } catch { continue; }
if (!isPlainObject(payload)) continue;
switch (payload.type) {
case "response.output_text.delta":
if (typeof payload.delta === "string") {
const next = deltas + payload.delta;
const nextBytes = appendedUtf8Bytes(deltasBytes, deltasLastCodeUnit, payload.delta);
const reservation = budget.reserveTransient(nextBytes, { kind: "retained_collectors" });
deltas = next;
reservation.commitRetained();
budget.releaseRetained(deltasBytes, { kind: "retained_collectors" });
deltasBytes = nextBytes;
if (payload.delta.length > 0) deltasLastCodeUnit = payload.delta.charCodeAt(payload.delta.length - 1);
}
break;
case "response.output_text.done":
if (typeof payload.text === "string") {
const next = doneText + payload.text;
const nextBytes = appendedUtf8Bytes(doneTextBytes, doneTextLastCodeUnit, payload.text);
const reservation = budget.reserveTransient(nextBytes, { kind: "retained_collectors" });
doneText = next;
reservation.commitRetained();
budget.releaseRetained(doneTextBytes, { kind: "retained_collectors" });
doneTextBytes = nextBytes;
if (payload.text.length > 0) doneTextLastCodeUnit = payload.text.charCodeAt(payload.text.length - 1);
}
break;
case "response.failed":
case "error":
yield { type: "error", message: responsesErrorMessage(payload.response ?? payload) };
return;
case "response.incomplete": {
const reason = responsesErrorMessage(payload.response ?? payload);
yield { type: "incomplete", reason: truncationReasonFor(reason) ?? reason };
return;
}
case "response.completed":
{
completedSeen = true;
const responsePayload = isPlainObject(payload.response) ? payload.response : undefined;
const output = Array.isArray(responsePayload?.output) ? responsePayload.output : [];
const compaction = output.find(item => isPlainObject(item) && item.type === "compaction");
if (isPlainObject(compaction) && typeof compaction.encrypted_content === "string") {
const nextEncryptedContent = compaction.encrypted_content;
const nextEncryptedContentBytes = Buffer.byteLength(nextEncryptedContent, "utf8");
const reservation = budget.reserveTransient(nextEncryptedContentBytes, { kind: "retained_collectors" });
compactionEncryptedContent = nextEncryptedContent;
reservation.commitRetained();
budget.releaseRetained(compactionEncryptedContentBytes, { kind: "retained_collectors" });
compactionEncryptedContentBytes = nextEncryptedContentBytes;
}
const next = responsesPayloadText(payload.response);
const nextBytes = Buffer.byteLength(next, "utf8");
const reservation = budget.reserveTransient(nextBytes, { kind: "retained_collectors" });
snapshot = next;
reservation.commitRetained();
budget.releaseRetained(snapshotBytes, { kind: "retained_collectors" });
snapshotBytes = nextBytes;
}
{
const nextUsage = usageFromResponsesPayload(payload.response);
// The attached raw usage object can be event-sized (unknown keys carry arbitrary
// values); it stays reachable until the terminal yields, so charge it like the
// adjacent retained collectors or it would defeat the per-request memory cap.
const nextRawBytes = nextUsage?.rawUsage === undefined ? 0
: Buffer.byteLength(JSON.stringify(nextUsage.rawUsage), "utf8");
if (nextRawBytes > 0) {
const reservation = budget.reserveTransient(nextRawBytes, { kind: "retained_collectors" });
usage = nextUsage;
reservation.commitRetained();
} else {
usage = nextUsage;
}
if (usageRawBytes > 0) {
budget.releaseRetained(usageRawBytes, { kind: "retained_collectors" });
}
usageRawBytes = nextRawBytes;
}
break;
}
// Buffered text is still upstream progress, but gateway keepalives are not.
// Yield after accounting, directly to the consumer: no progress queue or content leak.
if (
!completedSeen
&& (payload.type === "response.output_text.delta"
|| payload.type === "response.reasoning_summary_text.delta"
|| payload.type === "response.reasoning_text.delta")
&& typeof payload.delta === "string"
&& payload.delta.length > 0
) {
yield { type: "heartbeat" };
}
}
// Gateways differ in which of these they emit; prefer the authoritative
// completed snapshot so text is never double-counted.
const text = snapshot || doneText || deltas;
if (text) yield { type: "text_delta", text };
const done: AdapterEvent = {
type: "done",
...(usage ? { usage } : {}),
...(compactionEncryptedContent ? { compactionEncryptedContent } : {}),
};
// Exact event ownership survives buffered collection without charging a second copy.
transferCompactionCiphertextLease(done, budget, compactionEncryptedContentBytes);
ciphertextTransferred = true;
yield done;
} finally {
budget.releaseRetained(
deltasBytes + doneTextBytes + snapshotBytes + usageRawBytes
+ (ciphertextTransferred ? 0 : compactionEncryptedContentBytes),
{ kind: "retained_collectors" },
);
}
},
async parseResponse(response: Response, budget: TranslatorBudget): Promise<AdapterEvent[]> {
let payload: unknown;
try { payload = await response.json(); } catch {
return [{ type: "error", message: "malformed upstream compaction response" }];
}
budget.chargeRetained(Buffer.byteLength(JSON.stringify(payload), "utf8"), { kind: "retained_collectors" });
if (!isPlainObject(payload)) {
return [{ type: "error", message: "malformed upstream compaction response" }];
}
if (payload.error || payload.status === "failed") {
return [{ type: "error", message: responsesErrorMessage(payload) }];
}
if (payload.status === "incomplete") {
const reason = responsesErrorMessage(payload);
return [{ type: "incomplete", reason: truncationReasonFor(reason) ?? reason }];
}
const usage = usageFromResponsesPayload(payload);
const output = Array.isArray(payload.output) ? payload.output : [];
const compaction = output.find(item => isPlainObject(item) && item.type === "compaction");
const compactionEncryptedContent = isPlainObject(compaction) && typeof compaction.encrypted_content === "string"
? compaction.encrypted_content
: undefined;
const text = responsesPayloadText(payload);
if (!text && !compactionEncryptedContent) {
// A completed turn with neither text nor a native compaction blob cannot become a
// replacement-history item. A ciphertext-only native completion is valid, though.
return [{ type: "error", message: "upstream compaction returned no summary text" }];
}
return [...(text ? [{ type: "text_delta" as const, text }] : []), {
type: "done",
...(usage ? { usage } : {}),
...(compactionEncryptedContent ? { compactionEncryptedContent } : {}),
}];
},
};
}