@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
156 lines (143 loc) • 7.33 kB
text/typescript
import { errorDestinationText, providerErrorDestinationLabel } from "../lib/error-destination";
import type { OcxComboDefaultEffort, OcxComboDefaultEffortMode, OcxComboReasoningEffortMode, OcxComboTarget, OcxConfig } from "../types";
import { isCodexReasoningEffort, isDeclaredReasoningEffort, resolveEffortAtOrBelow } from "../reasoning-effort";
import { resolveComboId } from "./types";
const warnedUnsupportedDefaults = new Set<string>();
let lastWarningReconciledGeneration = 0;
export function reconcileComboWarningMemos(generation: number): number {
if (generation <= lastWarningReconciledGeneration) return 0;
const removed = warnedUnsupportedDefaults.size;
warnedUnsupportedDefaults.clear();
lastWarningReconciledGeneration = generation;
return removed;
}
export function resetComboEffortWarningStateForTests(): void {
warnedUnsupportedDefaults.clear();
}
export function comboIdFromRawBody(body: unknown, config: OcxConfig): string | null {
if (!body || typeof body !== "object" || Array.isArray(body)) return null;
const model = (body as { model?: unknown }).model;
if (typeof model !== "string") return null;
return resolveComboId(config, model);
}
/**
* Detect image-bearing Responses *input* only.
*
* Must not walk the full request body: tool JSON schemas, metadata, or extension
* payloads can legally contain `{ "type": "input_image" }` without any image
* being dispatched. After previous_response_id expansion, scan the materialised
* `input` tree (message content and function_call_output.output).
*/
export function comboRequestHasImageInput(body: unknown): boolean {
return comboRequestHasMediaInput(body, "input_image");
}
export function comboRequestHasAudioInput(body: unknown): boolean {
return comboRequestHasMediaInput(body, "input_audio");
}
function comboRequestHasMediaInput(body: unknown, type: "input_image" | "input_audio"): boolean {
if (!body || typeof body !== "object" || Array.isArray(body)) return false;
const { input } = body as { input?: unknown };
return Array.isArray(input) && input.some(node => responsesInputNodeHasMedia(node, type));
}
function responsesInputNodeHasMedia(value: unknown, type: "input_image" | "input_audio"): boolean {
if (!value || typeof value !== "object") return false;
if (Array.isArray(value)) return value.some(node => responsesInputNodeHasMedia(node, type));
const record = value as Record<string, unknown>;
if (record.type === type) return true;
// Message content parts and nested function_call_output content/output arrays.
return responsesInputNodeHasMedia(record.content, type) || responsesInputNodeHasMedia(record.output, type);
}
/**
* Clone a logical combo request for one concrete target and apply the combo's reasoning policy.
* Force mode overrides every valid declared caller effort only when the target ladder proves the
* configured default is representable; unknown capabilities stay conservative.
*/
export function concreteComboRequestBody(
body: unknown,
target: Pick<OcxComboTarget, "provider" | "model">,
defaultEffort: OcxComboDefaultEffort | null,
targetReasoningEfforts: readonly string[] | undefined,
reasoningEffortMode: OcxComboReasoningEffortMode = "strict",
defaultEffortMode: OcxComboDefaultEffortMode = "fallback",
): Record<string, unknown> {
const clone = structuredClone(body) as Record<string, unknown>;
clone.model = `${target.provider}/${target.model}`;
if (defaultEffortMode === "force" && (!defaultEffort || !isCodexReasoningEffort(defaultEffort))) {
throw new Error("force combo default effort requires a valid defaultEffort");
}
if (comboStripsReasoningControls(targetReasoningEfforts, reasoningEffortMode)) {
stripUnsupportedReasoningControls(clone);
}
if (!defaultEffort || !isCodexReasoningEffort(defaultEffort)) return clone;
const reasoning = clone.reasoning;
const reasoningRecord = reasoning && typeof reasoning === "object" && !Array.isArray(reasoning)
? reasoning as Record<string, unknown>
: undefined;
const hasEffort = reasoningRecord !== undefined
&& Object.prototype.hasOwnProperty.call(reasoningRecord, "effort");
const callerEffort = reasoningRecord?.effort;
const declaredCallerEffort = typeof callerEffort === "string" && isDeclaredReasoningEffort(callerEffort);
const needsDefault = reasoning === undefined || (reasoningRecord !== undefined && !hasEffort);
// `none` and `minimal` are valid request sentinels even though they are outside the ranked
// low..ultra Codex ladder. Force mode means the combo policy wins over any valid declared
// caller effort, including those sentinels.
const shouldForce = defaultEffortMode === "force" && declaredCallerEffort;
if (!needsDefault && !shouldForce) return clone;
// Picker availability treats an unknown ladder as a wildcard, but runtime
// injection stays fail-closed until this concrete target advertises support.
//
// Support is not literal membership. The catalog advertises the combo's default
// through effectiveComboDefault, which keeps the highest supported rung at or
// below the request rather than dropping it. Testing membership here meant a
// combo configured for `max` against a target topping out at `high` sent no
// effort at all, so the provider default applied and the turn ran at `none`
// while the catalog still advertised `max` (#3108). Resolve the same way the
// catalog did.
const resolvedEffort = targetReasoningEfforts === undefined
? undefined
: resolveEffortAtOrBelow(defaultEffort, targetReasoningEfforts);
if (!resolvedEffort) {
const key = `${target.provider}/${target.model}:${defaultEffort}`;
if (!warnedUnsupportedDefaults.has(key)) {
warnedUnsupportedDefaults.add(key);
console.debug("[opencodex] combo default effort omitted", {
provider: errorDestinationText(providerErrorDestinationLabel(target.provider)),
requestedEffort: defaultEffort,
capability: targetReasoningEfforts === undefined ? "unknown" : "unsupported",
});
}
return clone;
}
if (defaultEffortMode === "force") stripAlternativeReasoningControls(clone);
if (reasoning === undefined) {
clone.reasoning = { effort: resolvedEffort, summary: "auto" };
} else {
clone.reasoning = {
...(reasoning as Record<string, unknown>),
effort: resolvedEffort,
...((reasoning as Record<string, unknown>).summary === undefined ? { summary: "auto" } : {}),
};
}
return clone;
}
export function comboStripsReasoningControls(
ladder: readonly string[] | undefined,
mode: OcxComboReasoningEffortMode,
): boolean {
return ladder?.length === 0 || (mode === "adaptive" && ladder === undefined);
}
export function stripUnsupportedReasoningControls(body: Record<string, unknown>): void {
const reasoning = body.reasoning;
if (reasoning && typeof reasoning === "object" && !Array.isArray(reasoning)) {
const next = { ...(reasoning as Record<string, unknown>) };
delete next.effort;
if (Object.keys(next).length > 0) body.reasoning = next;
else delete body.reasoning;
}
stripAlternativeReasoningControls(body);
}
function stripAlternativeReasoningControls(body: Record<string, unknown>): void {
delete body.reasoning_effort;
delete body.thinking_budget;
delete body.thinking;
}