UNPKG

@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
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; }