UNPKG

@bitkyc08/opencodex

Version:

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

324 lines (309 loc) • 14.7 kB
/** * Native Chat candidates inside the combo loop (PF-07). * * The Chat ingress hands the combo a `ComboProtocolSource` only for a combo route with * `protocols.rollout.nativeChatCombos` on; without one nothing here runs. For the candidate the * combo is about to dispatch, the concrete route is settled the way the Chat ingress settles a * single route, and the native Chat lane's own eligibility rule decides whether the child goes * native. A native child runs `runNativeChatAttempt` (through the source) on the attempt the combo * already opened, with the combo's per-target budget, the client's abort signal and the turn * lease, built from a fresh copy of the source body; every other candidate keeps the bridge. * Under `unrepresentable: "reject"` a candidate whose path would drop a requested feature is never * picked, and a combo whose every enabled candidate is skipped answers the ingress refusal. * * No `./` sibling import on purpose: `core-options.ts` names this module's types, so an edge back * into the owner graph would close a cycle. */ import type { OcxConfig } from "../../types"; import type { RouteResult } from "../../router"; import type { DataPlaneAdmission } from "../auth-cors"; import type { AdmissionLease } from "../../lib/admission"; import type { RequestExecutionBudget } from "../../lib/request-execution-budget"; import type { TransientSendBudget } from "../../lib/upstream-retry"; import type { ResponsesTerminalStatus } from "../../bridge"; import type { NativeChatFinishLog } from "../chat-native"; import type { InferenceAttempt } from "../inference/attempt"; import type { ProtocolEnvelope } from "../../protocols/envelope"; import type { ProtocolFeature } from "../../protocols/features"; import type { PersistedUsageAttempt } from "../../usage/log"; import { finishRequestAttempt, sealRequestAttemptIdentity, type RequestLogContext, } from "../request-log"; import { captureRouteStaticPolicy, routeConcreteModel } from "../../router"; import { comboDefaultEffort, concreteComboRequestBody, getCombo } from "../../combos"; import { supportedLadderFor } from "../effort-policy"; import { resolveWireProtocolOverride } from "../adapter-resolve"; import { resolveOpenCodeGoTransport } from "../../providers/opencode-go-transport"; import { getOrAllocateRequestSessionLane } from "../request-log-conversation"; import { assertRouteAllowedByScope, resolveAdmissionModelScope } from "../admission-model-scope"; import { isNativeChatRouteEligible } from "../chat-native-eligibility"; import { chatCompletionsErrorResponse } from "../../chat/outbound"; import { isRequestExecutionBudget } from "../../lib/request-execution-budget"; import { markResponseNonReplayable } from "../../lib/upstream-retry"; import { redactSecretString } from "../../lib/redact"; import { upstreamWireForAdapter } from "../../protocols/contract"; import { checkRepresentable, unrepresentableMessage } from "../../protocols/guard"; import { deliveryModeForLane, requestPathForLane } from "../../protocols/path"; import { resolveProtocolSettings } from "../../protocols/settings"; import { addProtocolEntryReason, markAttemptProtocolPath, markProtocolBlocked } from "../../protocols/trace"; import { markClientWire } from "../inference/client-wire"; type Rec = Record<string, unknown>; type ComboTarget = { provider: string; model: string }; /** What the source needs to run one native child on the combo's open attempt. */ export interface NativeComboChildRun { route: RouteResult; /** A fresh copy of the source Chat body, never another candidate's rewritten one. */ body: Rec; childLog: RequestLogContext; attemptHandle: InferenceAttempt; sendBudget: RequestExecutionBudget; turnAdmissionLease?: AdmissionLease; onFirstOutput: () => void; /** Reports to the combo's child callbacks; it never writes the parent's final row itself. */ finishLog: NativeChatFinishLog; } /** Supplied by the Chat ingress for a combo route when `nativeChatCombos` is on. */ export interface ComboProtocolSource { readonly inbound: "chat"; readonly envelope: ProtocolEnvelope; /** Runs `runNativeChatAttempt`; the response it returns is in the Chat wire. */ dispatchNativeChild(input: NativeComboChildRun): Promise<Response>; } /** The native plan for one dispatch: the settled route and its own fresh body. */ export interface NativeComboChildPlan { route: RouteResult; body: Rec; sendBudget: RequestExecutionBudget; } export interface ComboProtocolLanes { /** Pick predicate. False only for a candidate the `reject` policy skips. */ pickable(target: ComboTarget): boolean; /** The ingress refusal when every enabled candidate was skipped; otherwise undefined. */ refusal(): Response | undefined; /** The native plan for the candidate about to dispatch, or undefined to keep the bridge. */ nativeChild( target: ComboTarget, targetRoute: RouteResult, targetSendBudget: TransientSendBudget | undefined, ): NativeComboChildPlan | undefined; } interface CandidateVerdict { skip?: ProtocolFeature[]; } export function createComboProtocolLanes(input: { source: ComboProtocolSource | undefined; req: Request; config: OcxConfig; logCtx: RequestLogContext; admission: DataPlaneAdmission | undefined; comboId: string; targets: readonly ComboTarget[]; }): ComboProtocolLanes | undefined { const { source, req, config, logCtx, admission, comboId, targets } = input; if (!source) return undefined; const envelope = source.envelope; const reject = resolveProtocolSettings(config).unrepresentable === "reject"; const selector = (target: ComboTarget): string => `${target.provider}/${target.model}`; // The Chat ingress's own settlement of a single route, applied to the concrete target: the // key's model scope, the static policy captured for a Chat inbound, the wire override and the // OpenCode Go transport. A refusal here keeps the bridge, which reports it in its own shape. const settle = (target: ComboTarget, targetRoute: RouteResult): RouteResult | undefined => { try { const route: RouteResult = { ...targetRoute }; assertRouteAllowedByScope(resolveAdmissionModelScope(config, admission), selector(target), route); const routedProvider = route.provider; route.staticPolicy = captureRouteStaticPolicy( route.providerName, route.modelId, routedProvider, route.staticPolicy.effectiveAlias, "chat", ); const wireProvider = resolveWireProtocolOverride(route.providerName, route.modelId, routedProvider, "chat", route.staticPolicy); route.provider = resolveOpenCodeGoTransport(wireProvider, getOrAllocateRequestSessionLane(req), routedProvider); return route; } catch { return undefined; } }; // Eligibility reads a body, and a body is a charged copy, so the adapter is checked first: // a candidate that can never go native costs no copy at all. const nativeBody = (target: ComboTarget, route: RouteResult | undefined): Rec | undefined => { if (!route || route.provider.adapter !== "openai-chat") return undefined; const body = envelope.freshBody(); // The concrete selector, as the bridge child's body carries it; the wire model comes from // the route either way, and the pinned-effort lookup reads this. body.model = selector(target); return isNativeChatRouteEligible(route, body, config) ? body : undefined; }; const verdicts = new Map<string, CandidateVerdict>(); let skipRecorded = false; const judge = (target: ComboTarget): CandidateVerdict => { const key = selector(target); const cached = verdicts.get(key); if (cached) return cached; let verdict: CandidateVerdict = {}; let targetRoute: RouteResult | undefined; try { targetRoute = routeConcreteModel(config, key); } catch { // Not evidence about the path; dispatch keeps the existing routing failure surface. targetRoute = undefined; } if (targetRoute) { const settled = settle(target, targetRoute); const native = nativeBody(target, settled) !== undefined; const upstream = native ? "chat" : upstreamWireForAdapter((settled ?? targetRoute).provider.adapter); const checked = checkRepresentable({ inbound: "chat", requestPath: requestPathForLane("chat", native ? "native" : "bridge", upstream), features: envelope.features(), policy: "reject", }); if (!checked.ok) { verdict = { skip: checked.features }; if (!skipRecorded) { skipRecorded = true; addProtocolEntryReason(logCtx, "feature-unrepresentable"); } } } verdicts.set(key, verdict); return verdict; }; return { pickable: target => !reject || judge(target).skip === undefined, refusal: () => { if (!reject) return undefined; const enabled = targets.filter(target => { const provider = config.providers[target.provider]; return provider !== undefined && provider.disabled !== true; }); if (enabled.length === 0) return undefined; const skipped = enabled.map(judge); if (skipped.some(verdict => verdict.skip === undefined)) return undefined; const features = [...new Set(skipped.flatMap(verdict => verdict.skip ?? []))]; // The same refusal the ingress gives a single route: 400 in the Chat shape, feature keys // only, a blocked trace, and no upstream send. markProtocolBlocked(logCtx, { inbound: "chat", reasonCodes: ["feature-unrepresentable"], features }); logCtx.errorCode = "unsupported_feature"; return markClientWire(chatCompletionsErrorResponse( 400, unrepresentableMessage(features), "invalid_request_error", "unsupported_feature", ), "chat"); }, nativeChild: (target, targetRoute, targetSendBudget) => { // Without the request's execution budget a native child could not share its sends, so it // keeps the bridge rather than opening a tracker of its own. if (!isRequestExecutionBudget(targetSendBudget)) return undefined; const route = settle(target, targetRoute); const body = nativeBody(target, route); if (!route || !body) return undefined; applyComboEffort(body, config, comboId, target, targetRoute); return { route, body, sendBudget: targetSendBudget }; }, }; } /** * The combo's reasoning-effort policy, applied to the Chat spelling of the same field. * * The bridge child gets it from `concreteComboRequestBody` on the Responses body; a native child * must not lose a forced or default effort just because it skipped that body. The same function * decides, through a one-field Responses view, so the two lanes cannot disagree. */ function applyComboEffort( body: Rec, config: OcxConfig, comboId: string, target: ComboTarget, targetRoute: RouteResult, ): void { const combo = getCombo(config, comboId); if (!combo) return; const hadEffort = Object.hasOwn(body, "reasoning_effort"); const shaped = concreteComboRequestBody( hadEffort ? { reasoning: { effort: body.reasoning_effort } } : {}, target, comboDefaultEffort(config, comboId), supportedLadderFor({ provider: targetRoute.provider, modelId: targetRoute.modelId }), combo.reasoningEffortMode, combo.defaultEffortMode, ); const reasoning = shaped.reasoning; if (reasoning === undefined) { if (hadEffort) delete body.reasoning_effort; return; } const effort = (reasoning as { effort?: unknown }).effort; if (typeof effort === "string") body.reasoning_effort = effort; } /** The combo's child callbacks, gated so a discarded attempt never reaches the parent. */ export interface ComboChildCallbacks { onTerminal(status: ResponsesTerminalStatus): void; onCancel(): void; onResponseComplete(model: string): void; } /** * Run one native child on the attempt the combo opened, and mark its answer as Chat wire. * * The child's outcomes map onto the combo's existing child callbacks: a terminal or cancellation * after the response was handed over publishes through the gate (and so reaches the parent's * final-row owner only once the combo commits), while a failure answered before that is left to * the combo's ordinary failure path. A non-OK answer produced after output was observed is marked * non-replayable, so the combo stops instead of re-running a turn that already ran upstream. */ export async function dispatchNativeComboChild(input: { source: ComboProtocolSource; plan: NativeComboChildPlan; logCtx: RequestLogContext; childLog: RequestLogContext; attempt: PersistedUsageAttempt; startedAt: number; turnAdmissionLease?: AdmissionLease; onFirstOutput: () => void; callbacks: ComboChildCallbacks; }): Promise<Response> { const { plan, logCtx, childLog, attempt, startedAt, callbacks } = input; childLog.providerAdapter = plan.route.provider.adapter; markAttemptProtocolPath(attempt, { mode: deliveryModeForLane("chat", "native", "chat"), requestPath: requestPathForLane("chat", "native", "chat"), }); let outputSeen = false; const finishLog: NativeChatFinishLog = (status, message, closeReason = "non_stream") => { if (message) childLog.upstreamError = redactSecretString(message).slice(0, 500); if (closeReason !== "non_stream") { // A streamed body ends after the combo merged this child into the parent row, so what the // stream learned last is carried across here before the parent's row is written. if (childLog.usage !== undefined) logCtx.usage = childLog.usage; if (closeReason === "client_cancel") return callbacks.onCancel(); } if (status < 400) { callbacks.onTerminal("completed"); callbacks.onResponseComplete(plan.route.modelId); return; } if (closeReason === "terminal") { childLog.terminalHttpStatus = status; callbacks.onTerminal("failed"); } }; const attemptHandle: InferenceAttempt = { attempt, startedAt, seal: label => sealRequestAttemptIdentity(attempt, childLog.provider, childLog.providerAdapter ?? attempt.adapter, label), finish: (status, usage) => finishRequestAttempt(attempt, status, Date.now() - startedAt, usage), }; const response = await input.source.dispatchNativeChild({ route: plan.route, body: plan.body, childLog, attemptHandle, sendBudget: plan.sendBudget, ...(input.turnAdmissionLease ? { turnAdmissionLease: input.turnAdmissionLease } : {}), onFirstOutput: () => { outputSeen = true; input.onFirstOutput(); }, finishLog, }); if (!response.ok && outputSeen) markResponseNonReplayable(response); return markClientWire(response, "chat"); }