@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
416 lines (415 loc) • 26.1 kB
text/typescript
import type { ModelCapabilities, OcxProviderConfig } from "../types";
import { MODEL_ADAPTER_OVERRIDE_ALLOWED, 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" | "parallelToolCalls"
| "promptCacheKey" | "chatServiceTier" | "openaiChatEofTolerance" | "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"
| "codexToolMode" | "modelAdapters";
type StaticProviderPolicyShape = Pick<OcxProviderConfig, StaticProviderPolicyField>;
export type ResolvedProviderStaticPolicy = Readonly<Partial<StaticProviderPolicyShape>> & Readonly<{
adapter: string;
baseUrl: string;
}>;
export interface ResolvedPerModelStaticPolicy {
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 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 } : {}),
});
}
export function resolveModelPolicy(input: ResolveModelPolicyInput): ResolvedModelPolicy {
const entry = input.transportMatchedRegistry ? input.registryEntry : undefined;
const provider = input.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 = input.effectiveAuth?.authMode
?? (entry?.authKind === "forward" || entry?.authKind === "oauth"
? entry.authKind
: provider.authMode === "forward" ? undefined : provider.authMode ?? entry?.authKind);
put("authMode", resolvedAuthMode, input.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", "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);
const legacyClinePassLadder = entry !== undefined && input.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, input.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 [
"modelCapabilities", "modelAutoCompactTokenLimits", "modelSuppressSyntheticMax",
"modelReasoningSummaryDelivery", "codexToolMode", "modelAdapters",
] as const) putScalar(key, undefined);
for (const key of ["modelContextWindows", "modelMaxInputTokens"] as const) {
const [value, source] = input.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", "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 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 modelReasoningEfforts = 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 model: ResolvedPerModelStaticPolicy = {
adapter,
...(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 } : {}),
...(modelValue(providerPolicy.modelDefaultReasoningEfforts) !== undefined ? { defaultReasoningEffort: modelValue(providerPolicy.modelDefaultReasoningEfforts) } : {}),
...(modelSupportsReasoningSummaries !== undefined ? { supportsReasoningSummaries: modelSupportsReasoningSummaries } : {}),
...(modelSupportsVerbosity !== undefined ? { supportsVerbosity: modelSupportsVerbosity } : {}),
...(modelSupportsServiceTier !== undefined ? { supportsServiceTier: modelSupportsServiceTier } : {}),
...(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,
};
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.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 recursivelyFreeze(detachedClone({
version: 1 as const,
providerName: input.providerName,
modelId: input.modelId,
transportMatchedRegistry: entry !== undefined,
...(alias !== undefined ? { effectiveAlias: alias } : {}),
provider: providerPolicy as ResolvedProviderStaticPolicy,
model,
provenance: { alias: aliasSource, provider: providerProvenance, model: modelProvenance },
}));
}