@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
243 lines (230 loc) • 11.9 kB
text/typescript
import { CodexInstallationIdUnavailableError } from "../../codex/installation-id";
import type { ResponsesRequestContext } from "./core-options";
import type { PreparedResponsesRequest } from "./request-prepare";
import type { ResponsesTransport } from "./request-transport";
import type { OcxConfig, OcxParsedRequest } from "../../types";
import type { ComboTargetRoute } from "../../combos/request-capability";
import { ComboVisionDescriptionUnavailableError, policyCandidateRefusalResponse } from "./policy-request-scope";
import { intersectAdmissionModelScopes, resolveAdmissionModelScope } from "../admission-model-scope";
import { captureAdmissionPolicy } from "../capture-admission-policy";
import type { ResolvedOpenAiForwardSidecar } from "../../providers/openai-sidecar";
import { isCanonicalOpenAiForwardProvider, supportsNativeResponsesCompactionTrigger } from "../../providers/openai-tiers";
import { omitEarlierCompactionImages } from "../../responses/compaction-images";
import {
shouldResolveOpenAiVisionSidecar,
resolveOpenAiVisionModel,
planVisionSidecar,
describeImagesInPlace,
requiresVisionPreprocessing,
stripImagesInPlace,
} from "../../vision";
import { shouldResolveOpenAiWebSearchSidecar } from "../../web-search";
import { shouldResolveOpenAiPassthroughWebSearchBridge } from "../../web-search/passthrough-bridge";
import {
listOpenAiForwardSidecarCandidates,
captureExplicitOpenAiCallerAuth,
resolveFirstUsableOpenAiSidecar,
} from "../../providers/openai-sidecar";
import {
tryClaimNativeMainProfileForTurn as tryClaimStoredSidecarMainProfile,
} from "../../codex/native-main-admission";
import { codexAccountSelectionForTurn } from "../lifecycle";
import {
CodexPoolAuthenticationError,
CodexAuthContextError,
CodexAccountCooldownError,
CodexThreadAffinityExpiredError,
CodexMainProfileDrainingError,
} from "../../codex/auth-context";
type SidecarRequestContext = Pick<ResponsesRequestContext, "options" | "config" | "req">;
/** The config vision planning reads: a combo request plans with its request-start sidecar settings. */
export function responsesVisionConfig({ config, options }: Pick<SidecarRequestContext, "config" | "options">): OcxConfig {
const admitted = options.comboVisionSidecar;
return admitted ? { ...config, visionSidecar: admitted.settings } : config;
}
async function resolveResponsesOpenAiSidecar(
{ options, config, req }: SidecarRequestContext,
route: Pick<ComboTargetRoute, "codexAccountId">,
): Promise<ResolvedOpenAiForwardSidecar | undefined> {
try {
const candidates = listOpenAiForwardSidecarCandidates(config);
let sidecarAuth = options.openAiSidecarAuth;
if (!sidecarAuth && options.allowStoredOpenAiSidecarAuth === true
&& route.codexAccountId === undefined
&& candidates.some(candidate => candidate.accountMode === "direct")
&& tryClaimStoredSidecarMainProfile(options.turnAdmissionLease)) {
// Request-local helper authority only: never promote this pair to caller, primary,
// or retry credentials. Claim before reading so profile switches remain fenced.
try {
const { getMainAccountToken } = await import("../../codex/main-account");
const token = getMainAccountToken();
if (token) sidecarAuth = captureExplicitOpenAiCallerAuth(new Headers({
authorization: `Bearer ${token.accessToken}`, "chatgpt-account-id": token.chatgptAccountId,
}), config);
} catch { /* stored enrichment is optional */ }
}
// Preserve explicit OpenAI helper auth across route changes without returning it to
// primary-provider headers or alternate-main retry. The resolver revalidates scope.
const sidecarHeaders = new Headers(req.headers);
sidecarHeaders.delete("authorization");
sidecarHeaders.delete("chatgpt-account-id");
if (sidecarAuth) {
sidecarHeaders.set("authorization", sidecarAuth.authorization);
sidecarHeaders.set("chatgpt-account-id", sidecarAuth.chatgptAccountId);
}
return await resolveFirstUsableOpenAiSidecar(
candidates,
sidecarHeaders,
config,
{
admission: options.admission,
signal: options.abortSignal,
codexAuthPolicy: options.codexAuthPolicy,
// Account-qualified native routes are passthrough, so their in-turn helper is vision.
// Scope its cooldown and outcome to the helper model, not the routed text model.
...(route.codexAccountId !== undefined
? { exactAccount: { accountId: route.codexAccountId, modelId: resolveOpenAiVisionModel(responsesVisionConfig({ config, options })) } }
: {}),
beginCodexAccountSelection: codexAccountSelectionForTurn(options.turnAdmissionLease),
},
);
} catch (err) {
// Sidecars are optional helpers for an otherwise independent routed turn.
// An unavailable/cooling/expired Multi credential disables the helper; it
// must not turn a valid routed-provider request into a Codex-auth failure.
if (
!(err instanceof CodexInstallationIdUnavailableError)
&& !(err instanceof CodexPoolAuthenticationError)
&& !(err instanceof CodexAuthContextError)
&& !(err instanceof CodexAccountCooldownError)
&& !(err instanceof CodexThreadAffinityExpiredError)
&& !(err instanceof CodexMainProfileDrainingError)
) throw err;
}
}
function responsesVisionPlan(
{ config, options }: SidecarRequestContext,
{ provider, providerName, modelId }: ComboTargetRoute,
parsed: OcxParsedRequest,
openAiSidecar: ResolvedOpenAiForwardSidecar | undefined,
) {
const admissionScope = visionAdmissionScope(config, options);
const plan = planVisionSidecar(responsesVisionConfig({ config, options }), provider, modelId, parsed, openAiSidecar, {
admission: options.admission, codexAuthPolicy: options.codexAuthPolicy, providerName,
admissionScope,
});
if (plan?.backend === "routed") {
const callerPolicy = options.advisorAdmissionPolicy ?? captureAdmissionPolicy(config, options.admission, admissionScope);
plan.advisorAdmissionPolicy = { ...callerPolicy, modelScope: admissionScope ?? callerPolicy.modelScope };
}
return plan;
}
function visionAdmissionScope(config: SidecarRequestContext["config"], options: SidecarRequestContext["options"]) {
return intersectAdmissionModelScopes(
options.admissionScope ?? resolveAdmissionModelScope(config, options.admission),
options.advisorAdmissionPolicy?.modelScope,
);
}
/** Use the child's real planner and auth rules, then return any unused recovery probe. */
export async function canDescribeComboImages(
context: SidecarRequestContext,
route: ComboTargetRoute,
parsed: OcxParsedRequest,
): Promise<boolean> {
if (context.options.visionDescribeTerminal) return false;
const openAiSidecar = shouldResolveOpenAiVisionSidecar(responsesVisionConfig(context), route.provider, route.modelId, parsed, route.providerName,
visionAdmissionScope(context.config, context.options))
? await resolveResponsesOpenAiSidecar(context, route) : undefined;
try {
const plan = responsesVisionPlan(context, route, parsed, openAiSidecar);
return plan !== undefined && plan.maxDescriptionsPerTurn > 0;
} finally {
openAiSidecar?.releaseProbeLease?.();
}
}
/** One responsibility of the Responses request pipeline; state owners are explicit. */
export async function prepareResponsesSidecarAuth(
requestContext: SidecarRequestContext,
requestState: Pick<
PreparedResponsesRequest,
| "parsed"
| "route"
| "selectedForwardHeaders"
| "translatorBudget"
>,
transportState: Pick<ResponsesTransport, "adapter" | "isPassthrough">,
) {
const { options, config } = requestContext;
const { parsed, route, translatorBudget } = requestState;
const { isPassthrough } = transportState;
let openAiSidecar: ResolvedOpenAiForwardSidecar | undefined;
const visionDescribeTerminal = options.visionDescribeTerminal === true;
const skipVision = visionDescribeTerminal || options.comboOmitImages === true;
const routedCompaction = parsed._compactionRequest === true
&& (!supportsNativeResponsesCompactionTrigger(route.provider) || parsed._portableCompaction === true);
const preserveCompactionPrefix = routedCompaction && transportState.adapter.name === "anthropic";
if (routedCompaction) parsed.context.messages = omitEarlierCompactionImages(parsed.context.messages);
const needsOpenAiVision = !skipVision
&& shouldResolveOpenAiVisionSidecar(responsesVisionConfig(requestContext), route.provider, route.modelId, parsed, route.providerName,
visionAdmissionScope(config, options));
// LOCAL PATCH (runturn-websearch): runTurn adapters can run the web-search
// sidecar through src/web-search/run-turn-loop.ts, so resolve the helper
// credential for them too. The passthrough bridge stays fetch-only.
const needsOpenAiSearch = !routedCompaction
&& (transportState.adapter.runTurn
? shouldResolveOpenAiWebSearchSidecar(config, parsed, isPassthrough)
: (shouldResolveOpenAiWebSearchSidecar(config, parsed, isPassthrough)
|| shouldResolveOpenAiPassthroughWebSearchBridge(route.provider, parsed, isPassthrough)));
if (needsOpenAiVision || needsOpenAiSearch) {
openAiSidecar = await resolveResponsesOpenAiSidecar(requestContext, route);
}
// Vision sidecar: the routed model can't see images (provider.noVisionModels). Describe each
// attached image through the selected sidecar backend and replace it with text BEFORE the main
// call, so the text-only model can reason about it.
// Terminal describe fence (roadmap 180): the sidecar's OWN loopback describe
// call must never plan another describe. The flag arrives from the Chat
// surface (whose bridge rebuilds headers) or as the raw header for native
// Responses callers. Marked + text-only routed model → strip, depth cap 1.
const visionPlan = skipVision
? undefined
: responsesVisionPlan(requestContext, route, parsed, openAiSidecar);
const recordSidecarOutcome = openAiSidecar?.recordOutcome;
if (visionPlan && (!options.comboRequiresVisionPlan || visionPlan.maxDescriptionsPerTurn > 0)) {
try {
const complete = await describeImagesInPlace(
parsed,
visionPlan,
openAiSidecar?.headers ?? requestState.selectedForwardHeaders,
options.abortSignal,
recordSidecarOutcome,
translatorBudget,
options.comboRequiresVisionPlan,
);
if (!complete && options.comboRequiresVisionPlan) {
openAiSidecar?.releaseProbeLease?.();
openAiSidecar = undefined;
return policyCandidateRefusalResponse(new ComboVisionDescriptionUnavailableError())!;
}
} finally {
// Local validation can reject every image before the sidecar fetch records an outcome.
// Vision-only turns must hand that unused cooldown probe back; when a fetch did run the
// outcome already consumed it, so this generation-bound release is a safe no-op.
if (!needsOpenAiSearch) openAiSidecar?.releaseProbeLease?.();
}
} else if (requiresVisionPreprocessing(config, route.provider, route.modelId, route.providerName)) {
// Image capability is not positively proven but no sidecar plan is dispatchable: fail closed.
// Never forward raw image bytes to an unverified upstream.
if (options.comboRequiresVisionPlan) {
openAiSidecar?.releaseProbeLease?.();
return policyCandidateRefusalResponse(new ComboVisionDescriptionUnavailableError())!;
}
stripImagesInPlace(parsed, translatorBudget);
if (!needsOpenAiSearch) openAiSidecar?.releaseProbeLease?.();
}
return {
openAiSidecar,
routedCompaction,
preserveCompactionPrefix,
};
}
export type ResponsesSidecarAuth = Exclude<Awaited<ReturnType<typeof prepareResponsesSidecarAuth>>, Response>;