UNPKG

@bitkyc08/opencodex

Version:

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

467 lines (462 loc) • 30.3 kB
import type { ModelCapabilities, OcxProviderConfig, ReasoningCapabilities } from "../types"; import { declaredModelCapabilities, mergeReasoningModelCapabilities, reasoningCapabilitiesFromConfig, REASONING_CAPABILITY_FIELDS } from "./reasoning-capabilities"; import { MODEL_ADAPTER_OVERRIDE_ALLOWED, modelInList, pinnedWireAdapter } from "../types"; import { isCanonicalOpenAiForwardProvider } from "./openai-tiers"; import { resolveProviderAuthTransport } from "./fastwire"; import { fastSwitchOff } from "./fast-opt-in"; import { registryEntrySupportsLiveModelDiscovery } from "./static-model-discovery"; import type { InboundWire, ProviderRegistryEntry, ResponsesTerminalRepairPolicy } from "./registry/types"; import { anthropicFamilyContextWindow, detachedClone, legacyModelValue, legacyModelSource, mapFill, nestedMapFill, positiveCapMap, recursivelyFreeze, resolvedBaseUrl, sameStringArray, scalar, stableUnion, staticHeaders, wireDefault, type StaticPolicySource, } from "./resolved-model-policy-merge"; export type { StaticPolicySource } from "./resolved-model-policy-merge"; export type StaticProviderPolicyField = | "adapter" | "baseUrl" | "apiKeyTransport" | "headers" | "authMode" | "codexAccountMode" | "responsesPath" | "chatCompletionsPath" | "keyOptional" | "freeTier" | "modelSuffixBracketStrip" | "defaultModel" | "models" | "liveModels" | "contextWindow" | "modelContextWindows" | "modelDisplayNames" | "modelInputModalities" | "modelMaxInputTokens" | "defaultMaxOutputTokens" | "modelMaxOutputTokens" | "reasoningEfforts" | "modelReasoningEfforts" | "modelReasoningEffortsAuthoritative" | "modelDefaultReasoningEfforts" | "reasoningEffortMap" | "modelReasoningEffortMap" | "reasoningWireFormat" | "noVisionModels" | "noReasoningModels" | "noTemperatureModels" | "noTopPModels" | "noStopModels" | "noPenaltyModels" | "noJsonSchemaModels" | "noStructuredOutputModels" | "parallelToolCalls" | "promptCacheKey" | "chatServiceTier" | "openaiChatEofTolerance" | "foldDeveloperRoleToSystem" | "singleLeadingSystemMessage" | "statelessResponses" | "requiresAdjacentResponsesToolResults" | "requiresPairedResponsesToolResults" | "annotateEmptyToolOutputs" | "fastWire" | "supportsServiceTier" | "modelSupportsServiceTier" | "supportsOpenAiWebSearchToolFields" | "supportsResponsesCustomTools" | "preserveResponsesReasoningContent" | "dropResponsesReasoningItems" | "modelSupportsReasoningSummaries" | "supportsVerbosity" | "modelSupportsVerbosity" | "responsesItemIdRepair" | "autoToolChoiceOnlyModels" | "preserveReasoningContentModels" | "requiresReasoningPlaceholderModels" | "reasoningSplitModels" | "inlineThinkTagModels" | "reasoningDetailsModels" | "thinkingToggleModels" | "thinkingBudgetModels" | "showThinkingSummary" | "escapeBuiltinToolNames" | "googleMode" | "project" | "location" | "modelCapabilities" | "modelAutoCompactTokenLimits" | "modelSuppressSyntheticMax" | "modelReasoningSummaryDelivery" | "thinkingDisplay" | "modelThinkingDisplay" | "codexToolMode" | "modelAdapters"; type StaticProviderPolicyShape = Pick<OcxProviderConfig, StaticProviderPolicyField>; export type ResolvedProviderStaticPolicy = Readonly<Partial<StaticProviderPolicyShape>> & Readonly<{ adapter: string; baseUrl: string; }>; export interface ResolvedPerModelStaticPolicy extends Readonly<ReasoningCapabilities> { readonly adapter: string; readonly contextWindow?: number; readonly inputModalities?: readonly string[]; readonly maxInputTokens?: number; readonly maxOutputTokens?: number; readonly reasoningEfforts?: readonly string[]; readonly defaultReasoningEffort?: string; readonly supportsReasoningSummaries?: boolean; readonly supportsVerbosity?: boolean; readonly supportsServiceTier?: boolean; readonly supportsResponsesCustomTools?: boolean; readonly fastTierDescription?: string; readonly directReasoningEffort?: boolean; readonly responsesUpstreamStreaming?: boolean; readonly responsesTerminalRepair?: Readonly<ResponsesTerminalRepairPolicy>; } export interface ResolvedModelPolicy { readonly version: 1; readonly providerName: string; readonly modelId: string; readonly transportMatchedRegistry: boolean; readonly effectiveAlias?: string | null; readonly provider: ResolvedProviderStaticPolicy; readonly model: Readonly<ResolvedPerModelStaticPolicy>; readonly provenance: Readonly<{ alias: StaticPolicySource; provider: Readonly<Partial<Record<StaticProviderPolicyField, StaticPolicySource>>>; model: Readonly<Partial<Record<keyof ResolvedPerModelStaticPolicy, StaticPolicySource>>>; }>; } export interface ResolveModelPolicyInput { readonly providerName: string; /** Final wire identity after resolveModelAlias and resolveOpenAiVirtualModel; public selection stays diagnostic-only. */ readonly modelId: string; readonly provider: Readonly<OcxProviderConfig>; readonly registryEntry?: Readonly<ProviderRegistryEntry>; readonly transportMatchedRegistry: boolean; readonly inboundWire?: InboundWire; /** Exact post-rewrite model capability declaration captured by the caller. */ readonly modelCapabilities?: Readonly<ModelCapabilities>; /** Credential-free live admission result: key only after a usable override, otherwise the registry mode. */ readonly effectiveAuth?: Readonly<{ authMode: NonNullable<OcxProviderConfig["authMode"]> }>; /** Capture-time collision-aware alias decision. Omit to use provider then registry fallback. */ readonly effectiveAlias?: string | null; readonly effectiveAliasSource?: Exclude<StaticPolicySource, "hard-pin" | "provider-default">; } export interface ObservedModelLimits { readonly contextWindow?: number; readonly maxInputTokens?: number; readonly maxOutputTokens?: number; } /** Call-local projection: observed values stay outside ResolvedModelPolicy and may only narrow caps. */ export function clampObservedModelLimits( policy: Readonly<Pick<ResolvedPerModelStaticPolicy, "contextWindow" | "maxInputTokens" | "maxOutputTokens">>, observed: Readonly<ObservedModelLimits>, ): Readonly<ObservedModelLimits> { const clamp = (staticCap: number | undefined, observedValue: number | undefined): number | undefined => { if (observedValue === undefined) return staticCap; return staticCap === undefined ? observedValue : Math.min(staticCap, observedValue); }; const contextWindow = clamp(policy.contextWindow, observed.contextWindow); const clampedMaxInputTokens = clamp(policy.maxInputTokens, observed.maxInputTokens); const maxInputTokens = clampedMaxInputTokens !== undefined && contextWindow !== undefined ? Math.min(clampedMaxInputTokens, contextWindow) : clampedMaxInputTokens; const maxOutputTokens = clamp(policy.maxOutputTokens, observed.maxOutputTokens); return Object.freeze({ ...(contextWindow !== undefined ? { contextWindow } : {}), ...(maxInputTokens !== undefined ? { maxInputTokens } : {}), ...(maxOutputTokens !== undefined ? { maxOutputTokens } : {}), }); } type PerModelPolicyInput = Pick<ResolveModelPolicyInput, "modelId" | "modelCapabilities" | "inboundWire" | "effectiveAlias" | "effectiveAliasSource">; type ProviderPolicyInput = Omit<ResolveModelPolicyInput, keyof PerModelPolicyInput>; export function resolveModelPolicy(input: ResolveModelPolicyInput): ResolvedModelPolicy { return prepareProviderPolicy(input)(input); } /** Batch projection for captured catalog providers; the capture already owns registry enrichment. */ export function prepareModelPolicy(input: Pick<ProviderPolicyInput, "providerName" | "provider" | "effectiveAuth" | "transportMatchedRegistry"> & { transportMatchedRegistry: false }) { return prepareProviderPolicy({ ...input, provider: recursivelyFreeze(detachedClone(input.provider)) }); } function prepareProviderPolicy(shared: ProviderPolicyInput): (modelInput: PerModelPolicyInput) => ResolvedModelPolicy { const entry = shared.transportMatchedRegistry ? shared.registryEntry : undefined; const provider = shared.provider; const providerPolicy: Partial<StaticProviderPolicyShape> = {}; const providerProvenance: Partial<Record<StaticProviderPolicyField, StaticPolicySource>> = {}; const [baseUrl, baseUrlSource] = resolvedBaseUrl(entry, provider); const put = <K extends StaticProviderPolicyField>(key: K, value: StaticProviderPolicyShape[K] | undefined, source: StaticPolicySource): void => { if (value !== undefined) providerPolicy[key] = detachedClone(value) as never; providerProvenance[key] = source; }; const putScalar = <K extends StaticProviderPolicyField>(key: K, registryValue: StaticProviderPolicyShape[K] | undefined): void => { const [value, source] = scalar(provider[key], registryValue); put(key, value, source); }; const putUnion = (key: StaticProviderPolicyField, registryValue: readonly string[] | undefined): void => { const [value, source] = stableUnion(registryValue, provider[key] as string[] | undefined); put(key, value as never, source); }; const putMergedMap = <K extends StaticProviderPolicyField, T>( key: K, registryValue: Readonly<Record<string, T>> | undefined, operatorValue: Readonly<Record<string, T>> | undefined, ): void => { const [value, source] = mapFill(registryValue, operatorValue); put(key, value as StaticProviderPolicyShape[K], source); }; put("adapter", entry?.adapter ?? provider.adapter, entry ? "registry" : "operator"); put("baseUrl", baseUrl, baseUrlSource); putScalar("apiKeyTransport", entry?.apiKeyTransport); const [headers, headersSource] = staticHeaders(entry?.staticHeaders, provider.headers); put("headers", headers, headersSource); const resolvedAuthMode = shared.effectiveAuth?.authMode ?? (entry?.authKind === "forward" || entry?.authKind === "oauth" ? entry.authKind : provider.authMode === "forward" ? undefined : provider.authMode ?? entry?.authKind); put("authMode", resolvedAuthMode, shared.effectiveAuth ? "captured-auth" : entry?.authKind === "forward" || entry?.authKind === "oauth" ? "registry" : provider.authMode !== undefined ? "operator" : entry ? "registry" : "unknown"); putScalar("codexAccountMode", entry?.codexAccountMode); const keyAuthDefaults = entry?.allowKeyAuthOverride === true && resolvedAuthMode === "key" && ["authorization_bearer", "x_api_key"].includes(resolveProviderAuthTransport( provider.adapter, resolvedAuthMode, provider.apiKeyTransport, )) ? entry.keyAuthServiceTier : undefined; for (const key of [ "responsesPath", "chatCompletionsPath", "keyOptional", "freeTier", "modelSuffixBracketStrip", "defaultModel", "models", "liveModels", "contextWindow", "defaultMaxOutputTokens", "reasoningWireFormat", "parallelToolCalls", "promptCacheKey", "openaiChatEofTolerance", "foldDeveloperRoleToSystem", "singleLeadingSystemMessage", "statelessResponses", "requiresAdjacentResponsesToolResults", "requiresPairedResponsesToolResults", "annotateEmptyToolOutputs", "fastWire", "supportsServiceTier", "supportsOpenAiWebSearchToolFields", "supportsResponsesCustomTools", "preserveResponsesReasoningContent", "dropResponsesReasoningItems", "supportsVerbosity", "responsesItemIdRepair", "showThinkingSummary", "escapeBuiltinToolNames", "googleMode", "project", "location", ] as const) putScalar(key, entry?.[key] as StaticProviderPolicyShape[typeof key] | undefined); // Operator-only display policy; no registry entry declares it (#8363). put("thinkingDisplay", provider.thinkingDisplay, provider.thinkingDisplay !== undefined ? "operator" : "unknown"); const legacyClinePassLadder = entry !== undefined && shared.providerName === "cline-pass" && provider.reasoningWireFormat === "gateway-object" && sameStringArray(provider.reasoningEfforts, ["low"]); put("reasoningEfforts", legacyClinePassLadder ? entry?.reasoningEfforts : provider.reasoningEfforts ?? entry?.reasoningEfforts, legacyClinePassLadder || provider.reasoningEfforts === undefined ? entry?.reasoningEfforts ? "registry" : "unknown" : "operator"); put("chatServiceTier", provider.chatServiceTier ?? keyAuthDefaults?.chatServiceTier ?? entry?.chatServiceTier, provider.chatServiceTier !== undefined ? "operator" : keyAuthDefaults?.chatServiceTier !== undefined ? "registry" : entry?.chatServiceTier !== undefined ? "registry" : "unknown"); // The Fast switch overrides every capability source; see providerFastSwitchOff. const fastOff = fastSwitchOff(provider, shared.registryEntry); if (fastOff) put("supportsServiceTier", false, provider.fastEnabled === false ? "operator" : "registry"); else put("supportsServiceTier", provider.supportsServiceTier ?? keyAuthDefaults?.supportsServiceTier ?? entry?.supportsServiceTier, provider.supportsServiceTier !== undefined ? "operator" : keyAuthDefaults?.supportsServiceTier !== undefined ? "registry" : entry?.supportsServiceTier !== undefined ? "registry" : "unknown"); if (entry && !registryEntrySupportsLiveModelDiscovery(entry)) put("liveModels", false, "registry"); putMergedMap("modelDisplayNames", entry?.modelDisplayNames, provider.modelDisplayNames); putMergedMap("modelInputModalities", entry?.modelInputModalities, provider.modelInputModalities); putMergedMap("modelMaxOutputTokens", entry?.modelMaxOutputTokens, provider.modelMaxOutputTokens); putMergedMap("modelReasoningEfforts", entry?.modelReasoningEfforts, provider.modelReasoningEfforts); // Operator-only: no registry entry declares it, and it decides whether the map above is the // wire contract or only the catalog's. A policy reader that omitted it would report the same // effective ladder for two providers that send different efforts. put("modelReasoningEffortsAuthoritative", provider.modelReasoningEffortsAuthoritative, provider.modelReasoningEffortsAuthoritative !== undefined ? "operator" : "unknown"); putMergedMap("modelDefaultReasoningEfforts", entry?.modelDefaultReasoningEfforts, provider.modelDefaultReasoningEfforts); const registryServiceTier = !entry?.modelServiceTierCapabilityBaseUrlGuard || entry.modelServiceTierCapabilityBaseUrlGuard(provider.baseUrl) ? entry?.modelSupportsServiceTier : undefined; const registryServiceTierDefaults = registryServiceTier || keyAuthDefaults?.modelSupportsServiceTier ? { ...(registryServiceTier ?? {}), ...(keyAuthDefaults?.modelSupportsServiceTier ?? {}) } : undefined; putMergedMap("modelSupportsServiceTier", registryServiceTierDefaults, provider.modelSupportsServiceTier); putMergedMap("modelSupportsReasoningSummaries", entry?.modelSupportsReasoningSummaries, provider.modelSupportsReasoningSummaries); putMergedMap("modelSupportsVerbosity", entry?.modelSupportsVerbosity, provider.modelSupportsVerbosity); for (const key of [ "modelAutoCompactTokenLimits", "modelSuppressSyntheticMax", "modelReasoningSummaryDelivery", "codexToolMode", "modelAdapters", "modelThinkingDisplay", ] as const) putScalar(key, undefined); put("modelCapabilities", mergeReasoningModelCapabilities(entry?.modelCapabilities, provider.modelCapabilities), provider.modelCapabilities !== undefined ? "operator-capability" : entry?.modelCapabilities !== undefined ? "registry" : "unknown"); for (const key of ["modelContextWindows", "modelMaxInputTokens"] as const) { const [value, source] = shared.providerName === "openai-apikey" ? positiveCapMap(entry?.[key], provider[key]) : mapFill(entry?.[key], provider[key]); put(key, value, source); } const [effortMap, effortMapSource] = mapFill(entry?.reasoningEffortMap, provider.reasoningEffortMap); put("reasoningEffortMap", effortMap, effortMapSource); const [modelEffortMap, modelEffortMapSource] = nestedMapFill(entry?.modelReasoningEffortMap, provider.modelReasoningEffortMap); put("modelReasoningEffortMap", modelEffortMap, modelEffortMapSource); for (const key of [ "noVisionModels", "noReasoningModels", "noTemperatureModels", "noTopPModels", "noStopModels", "noPenaltyModels", "noJsonSchemaModels", "noStructuredOutputModels", "autoToolChoiceOnlyModels", "preserveReasoningContentModels", "requiresReasoningPlaceholderModels", "reasoningSplitModels", "reasoningDetailsModels", "thinkingToggleModels", "thinkingBudgetModels", ] as const) putUnion(key, entry?.[key]); // This parser is opt-in: an explicit list, including [], overrides registry defaults. putScalar("inlineThinkTagModels", entry?.inlineThinkTagModels); for (const directModel of entry?.directReasoningEffortModels ?? []) { const staleBudget = [directModel, ...(entry?.thinkingBudgetModels ?? [])]; const routedStaleBudget = [...(entry?.thinkingBudgetModels ?? []), directModel]; if (sameStringArray(provider.thinkingBudgetModels, staleBudget) || sameStringArray(provider.thinkingBudgetModels, routedStaleBudget)) { providerPolicy.thinkingBudgetModels = [...(entry?.thinkingBudgetModels ?? [])]; providerProvenance.thinkingBudgetModels = "registry"; } const explicitEfforts = Object.entries(provider.modelReasoningEfforts ?? {}) .filter(([key]) => key.toLowerCase() === directModel.toLowerCase()); if (explicitEfforts.length > 0) { for (const key of Object.keys(providerPolicy.modelReasoningEfforts ?? {})) { if (key.toLowerCase() === directModel.toLowerCase()) delete providerPolicy.modelReasoningEfforts![key]; } for (const [key, value] of explicitEfforts) (providerPolicy.modelReasoningEfforts ??= {})[key] = [...value]; } else if (entry?.modelReasoningEfforts?.[directModel] !== undefined) { (providerPolicy.modelReasoningEfforts ??= {})[directModel] = [...entry.modelReasoningEfforts[directModel]!]; } const explicitDefault = Object.entries(provider.modelDefaultReasoningEfforts ?? {}) .filter(([key]) => key.toLowerCase() === directModel.toLowerCase()); if (explicitDefault.length > 0) { for (const key of Object.keys(providerPolicy.modelDefaultReasoningEfforts ?? {})) { if (key.toLowerCase() === directModel.toLowerCase()) delete providerPolicy.modelDefaultReasoningEfforts![key]; } for (const [key, value] of explicitDefault) (providerPolicy.modelDefaultReasoningEfforts ??= {})[key] = value; } else if (entry?.modelDefaultReasoningEfforts?.[directModel] !== undefined) { (providerPolicy.modelDefaultReasoningEfforts ??= {})[directModel] = entry.modelDefaultReasoningEfforts[directModel]!; } const explicitMap = Object.entries(provider.modelReasoningEffortMap ?? {}) .filter(([key]) => key.toLowerCase() === directModel.toLowerCase()); for (const key of Object.keys(providerPolicy.modelReasoningEffortMap ?? {})) { if (key.toLowerCase() === directModel.toLowerCase()) delete providerPolicy.modelReasoningEffortMap![key]; } if (explicitMap.length > 0) { for (const [key, value] of explicitMap) (providerPolicy.modelReasoningEffortMap ??= {})[key] = { ...value }; } else { (providerPolicy.modelReasoningEffortMap ??= {})[directModel] = {}; } } const frozenProvider = recursivelyFreeze(providerPolicy) as ResolvedProviderStaticPolicy; const frozenProviderProvenance = Object.freeze(providerProvenance); return modelInput => resolvePreparedModel({ ...shared, ...modelInput }); function resolvePreparedModel(input: ResolveModelPolicyInput): ResolvedModelPolicy { const modelValue = <T>(record: Readonly<Record<string, T>> | undefined): T | undefined => legacyModelValue(record, input.modelId); const modelSource = <T>(operator: Readonly<Record<string, T>> | undefined, registry: Readonly<Record<string, T>> | undefined): StaticPolicySource => legacyModelSource(operator, registry, input.modelId); const modelOrProviderSource = <T>( operatorMap: Readonly<Record<string, T>> | undefined, registryMap: Readonly<Record<string, T>> | undefined, operatorDefault: T | undefined, registryDefault: T | undefined, ): StaticPolicySource => { const exact = modelSource(operatorMap, registryMap); return exact !== "unknown" ? exact : operatorDefault !== undefined ? "operator" : registryDefault !== undefined ? "registry" : "unknown"; }; const configuredAdapter = provider.modelAdapters?.[input.modelId]; const pin = pinnedWireAdapter(input.providerName, input.modelId, provider); const normalizedModelId = input.modelId.trim().toLowerCase(); const registryWire = wireDefault(entry?.modelWireDefaults?.[normalizedModelId], provider, entry, input.inboundWire ?? "responses", resolvedAuthMode); const explicitWire = configuredAdapter && MODEL_ADAPTER_OVERRIDE_ALLOWED.has(configuredAdapter) ? configuredAdapter : undefined; const providerAdapter = providerPolicy.adapter ?? provider.adapter; const effectiveProviderForWire = resolvedAuthMode === provider.authMode ? provider : { ...provider, authMode: resolvedAuthMode }; const canonicalForward = isCanonicalOpenAiForwardProvider(effectiveProviderForWire); const adapter = pin ?? (!canonicalForward ? explicitWire ?? registryWire : undefined) ?? providerAdapter; const adapterSource: StaticPolicySource = pin ? "hard-pin" : explicitWire && !canonicalForward ? "operator" : registryWire && !canonicalForward ? "registry" : "provider-default"; const declaredModalities = input.modelCapabilities?.inputModalities; const capabilityModalities = Array.isArray(declaredModalities) && declaredModalities.length > 0 ? [...declaredModalities] : undefined; const exactContextWindow = modelValue(providerPolicy.modelContextWindows); const familyContextWindow = providerPolicy.adapter === "anthropic" ? anthropicFamilyContextWindow(providerPolicy.modelContextWindows, input.modelId) : undefined; const modelContextWindow = exactContextWindow ?? familyContextWindow ?? providerPolicy.contextWindow; const exactMaxInputTokens = modelValue(providerPolicy.modelMaxInputTokens); const modelMaxInputTokens = exactMaxInputTokens !== undefined && modelContextWindow !== undefined ? Math.min(exactMaxInputTokens, modelContextWindow) : exactMaxInputTokens; const exactMaxOutputTokens = modelValue(providerPolicy.modelMaxOutputTokens); const modelMaxOutputTokens = exactMaxOutputTokens ?? providerPolicy.defaultMaxOutputTokens; const reasoningCapabilities = reasoningCapabilitiesFromConfig({ ...providerPolicy, adapter: providerPolicy.adapter ?? provider.adapter, baseUrl: providerPolicy.baseUrl ?? provider.baseUrl, // Reasoning reads only this model's declaration; keep the other axes without cloning the roster. ...(input.modelCapabilities ? { modelCapabilities: { [input.modelId]: { ...declaredModelCapabilities(providerPolicy.modelCapabilities, input.modelId), ...input.modelCapabilities, } } } : {}), }, input.modelId); const modelReasoningEfforts = reasoningCapabilities.supportsReasoningEffort === false ? [] : modelValue(providerPolicy.modelReasoningEfforts) ?? providerPolicy.reasoningEfforts; const modelSupportsReasoningSummaries = modelValue(providerPolicy.modelSupportsReasoningSummaries) ?? (modelValue(providerPolicy.modelReasoningSummaryDelivery) !== undefined ? true : undefined); const modelSupportsVerbosity = modelValue(providerPolicy.modelSupportsVerbosity) ?? providerPolicy.supportsVerbosity; const modelSupportsServiceTier = fastOff ? false : modelValue(providerPolicy.modelSupportsServiceTier) ?? providerPolicy.supportsServiceTier; const modelSupportsResponsesCustomTools = input.modelCapabilities?.responsesCustomTools ?? providerPolicy.supportsResponsesCustomTools; const model: ResolvedPerModelStaticPolicy = { adapter, ...reasoningCapabilities, ...(modelContextWindow !== undefined ? { contextWindow: modelContextWindow } : {}), ...(capabilityModalities ?? modelValue(providerPolicy.modelInputModalities) !== undefined ? { inputModalities: capabilityModalities ?? modelValue(providerPolicy.modelInputModalities) } : {}), ...(modelMaxInputTokens !== undefined ? { maxInputTokens: modelMaxInputTokens } : {}), ...(modelMaxOutputTokens !== undefined ? { maxOutputTokens: modelMaxOutputTokens } : {}), ...(modelReasoningEfforts !== undefined ? { reasoningEfforts: modelReasoningEfforts } : {}), ...(reasoningCapabilities.supportsReasoningEffort !== false && modelValue(providerPolicy.modelDefaultReasoningEfforts) !== undefined ? { defaultReasoningEffort: modelValue(providerPolicy.modelDefaultReasoningEfforts) } : {}), ...(modelSupportsReasoningSummaries !== undefined ? { supportsReasoningSummaries: modelSupportsReasoningSummaries } : {}), ...(modelSupportsVerbosity !== undefined ? { supportsVerbosity: modelSupportsVerbosity } : {}), ...(modelSupportsServiceTier !== undefined ? { supportsServiceTier: modelSupportsServiceTier } : {}), ...(modelSupportsResponsesCustomTools !== undefined ? { supportsResponsesCustomTools: modelSupportsResponsesCustomTools } : {}), ...(modelSupportsServiceTier === true && entry?.fastTierDescription !== undefined ? { fastTierDescription: entry.fastTierDescription } : {}), ...(entry?.directReasoningEffortModels?.includes(input.modelId) ? { directReasoningEffort: true } : {}), ...(entry?.modelResponsesUpstreamStreaming?.[normalizedModelId] !== undefined ? { responsesUpstreamStreaming: entry.modelResponsesUpstreamStreaming[normalizedModelId] } : {}), ...(entry?.modelResponsesTerminalRepair?.[normalizedModelId] !== undefined ? { responsesTerminalRepair: entry.modelResponsesTerminalRepair[normalizedModelId] } : {}), }; const modelProvenance: Partial<Record<keyof ResolvedPerModelStaticPolicy, StaticPolicySource>> = { adapter: adapterSource, }; for (const field of REASONING_CAPABILITY_FIELDS) { modelProvenance[field] = reasoningCapabilities[field] === undefined ? "unknown" : modelInList(provider.noReasoningModels, input.modelId) ? "operator" : modelInList(entry?.noReasoningModels, input.modelId) ? "registry" : input.modelCapabilities?.[field] !== undefined || declaredModelCapabilities(provider.modelCapabilities, input.modelId)?.[field] !== undefined ? "operator-capability" : declaredModelCapabilities(entry?.modelCapabilities, input.modelId)?.[field] !== undefined ? "registry" : "operator"; } modelProvenance.contextWindow = modelOrProviderSource(provider.modelContextWindows, entry?.modelContextWindows, provider.contextWindow, entry?.contextWindow); if (modelProvenance.contextWindow === "unknown" && familyContextWindow !== undefined) { modelProvenance.contextWindow = anthropicFamilyContextWindow(provider.modelContextWindows, input.modelId) !== undefined ? "operator" : "registry"; } modelProvenance.inputModalities = capabilityModalities ? "operator-capability" : modelSource(provider.modelInputModalities, entry?.modelInputModalities); modelProvenance.maxInputTokens = modelSource(provider.modelMaxInputTokens, entry?.modelMaxInputTokens); modelProvenance.maxOutputTokens = modelOrProviderSource( provider.modelMaxOutputTokens, entry?.modelMaxOutputTokens, provider.defaultMaxOutputTokens, entry?.defaultMaxOutputTokens, ); modelProvenance.reasoningEfforts = modelOrProviderSource(provider.modelReasoningEfforts, entry?.modelReasoningEfforts, provider.reasoningEfforts, entry?.reasoningEfforts); modelProvenance.defaultReasoningEffort = modelSource( provider.modelDefaultReasoningEfforts, entry?.modelDefaultReasoningEfforts, ); modelProvenance.supportsReasoningSummaries = modelSource(provider.modelSupportsReasoningSummaries, entry?.modelSupportsReasoningSummaries); if (modelProvenance.supportsReasoningSummaries === "unknown" && modelValue(provider.modelReasoningSummaryDelivery) !== undefined) { modelProvenance.supportsReasoningSummaries = "operator"; } modelProvenance.supportsVerbosity = modelOrProviderSource(provider.modelSupportsVerbosity, entry?.modelSupportsVerbosity, provider.supportsVerbosity, entry?.supportsVerbosity); const exactServiceTierSource = modelSource(provider.modelSupportsServiceTier, registryServiceTierDefaults); modelProvenance.supportsServiceTier = !fastOff && exactServiceTierSource !== "unknown" ? exactServiceTierSource : providerProvenance.supportsServiceTier ?? "unknown"; modelProvenance.supportsResponsesCustomTools = input.modelCapabilities?.responsesCustomTools !== undefined ? "operator-capability" : providerProvenance.supportsResponsesCustomTools ?? "unknown"; modelProvenance.responsesUpstreamStreaming = model.responsesUpstreamStreaming === undefined ? "unknown" : "registry"; modelProvenance.responsesTerminalRepair = model.responsesTerminalRepair === undefined ? "unknown" : "registry"; modelProvenance.fastTierDescription = model.fastTierDescription === undefined ? "unknown" : "registry"; modelProvenance.directReasoningEffort = model.directReasoningEffort === undefined ? "unknown" : "registry"; const alias = input.effectiveAlias !== undefined ? input.effectiveAlias : provider.alias !== undefined ? provider.alias : entry?.alias; const aliasSource: StaticPolicySource = input.effectiveAlias !== undefined ? input.effectiveAliasSource ?? "operator" : provider.alias !== undefined ? "operator" : entry?.alias !== undefined ? "registry" : "unknown"; return Object.freeze({ version: 1 as const, providerName: input.providerName, modelId: input.modelId, transportMatchedRegistry: entry !== undefined, ...(alias !== undefined ? { effectiveAlias: alias } : {}), provider: frozenProvider, model: recursivelyFreeze(detachedClone(model)), provenance: Object.freeze({ alias: aliasSource, provider: frozenProviderProvenance, model: Object.freeze(modelProvenance) }), }); } }