UNPKG

@bitkyc08/opencodex

Version:

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

755 lines (752 loc) • 37.4 kB
import * as z from "zod/v4"; import { compactionRecoverySchema } from "./compaction-recovery"; import { blockedModelRedirectsSchema } from "./blocked-model-redirects"; import { agentTaskRecoverySchema, catalogAutoRefreshSchema, clientConnectionSchema, CODEX_ACCOUNT_PIN_PATTERN, codexAccountPrioritiesSchema, salvageCodexAccountAutoSwitchThresholds, codexPoolSchema, codexQuotaAutoRefreshSchema, credentialGroupsSchema, hubConfigSchema, providerConfigSchema, quotaResetNotifySchema, remoteGuiConfigSchema, runtimeRoleSchema, spendSchema, skillsConfigSchema, configuredCodexPoolAccountIds, apiKeyEntrySchema, asideProfileSyncSchema, clientIntegrationsSchema, CODEX_ACCOUNT_NAMESPACE_ACCOUNT_ID_COLLISION_ERROR, codexAccountNamespacesSchema, modelPinnedEffortsSchema, compactionRoutingSchema, memoryModelSettingSchema, memoryModelsSchema, modelPreferHostedToolsConfigError, providerModelCostsConfigError, providerRelativeSendPathConfigError, } from "./leaf-validators"; import { isValidProviderName, hasOwnProvider } from "../provider-name"; import { apiKeyTransportConfigError, booleanRecordConfigError, modelAdapterRecordConfigError, modelDisplayNamesConfigError, nonBlankStringArrayConfigError, positiveIntegerConfigError, positiveIntegerRecordConfigError, providerBaseUrlConfigError, providerHeadersConfigError, reasoningSummaryDeliveryRecordConfigError, } from "../provider-validation"; import { CODEX_ACCOUNT_NAMESPACE_COMBO_ALIAS_COLLISION_ERROR, codexAccountNamespaceForModel, codexProviderNamespaceKey, MAIN_CODEX_ACCOUNT_NAMESPACE_TARGET, } from "../../codex/account-namespace-match"; import { UPSTREAM_HOST_CIRCUIT_MAX_THRESHOLD } from "../../codex/upstream-host-health"; import { MIN_USAGE_LEDGER_MAX_BYTES } from "../../usage/retention-contract"; import { COMBO_NAMESPACE, comboConfigIssues } from "../../combos/types"; import { routingProfileIssues } from "../../routing/profile"; import { POLICY_NAMESPACE } from "../../routing/profile-namespace"; import { providerDestinationConfigError } from "../../lib/destination-policy"; import { redactSecretString } from "../../lib/redact"; import { openRouterRoutingConfigError } from "../../providers/openrouter-routing"; import { vercelGatewayRoutingConfigError } from "../../providers/vercel-gateway-routing"; import { type OcxApiKeyEntry, type OcxProviderConfig } from "../../types"; import { OPENAI_CODEX_PROVIDER_ID } from "../../providers/openai-tiers"; import { modelAutoCompactTokenLimitsConfigError } from "../../providers/auto-compact-budget"; import { hasFastWireCapabilityConflict } from "../../providers/fastwire"; import { parseDesktopProfile } from "../../claude/desktop-profile"; import { isInterceptBindingId, isInterceptBindingRoute } from "../../claude/intercept/model-bindings"; import { DEFAULT_APP_OWNED_MEMORY_BUDGET_BYTES, MAX_APP_OWNED_MEMORY_BUDGET_MB, MIN_APP_OWNED_MEMORY_BUDGET_MB } from "../../lib/app-owned-memory"; export const configSchema = z.object({ codexNativeSteering: z.boolean().optional().catch(false), codexNativeInjection: z.boolean().optional().catch(false), port: z.number().int().min(0).max(65535).default(10100), // A malformed hand edit must disable only remote-role behavior, not discard // providers or data-plane keys. Live writes are rejected explicitly below. runtimeRole: runtimeRoleSchema.optional().catch(undefined), // Malformed optional remote blocks disable only remote GUI behavior. Live // candidates are rejected explicitly by remoteGuiConfigError below. hub: hubConfigSchema.optional().catch(undefined), remoteGui: remoteGuiConfigSchema.optional().catch(undefined), // A malformed privacy block must never be read as "unmask": .catch(undefined) drops it and // emailMaskingEnabled then falls back to masked, which is also what an absent block means. privacy: z.object({ maskEmails: z.boolean().optional() }).strict().optional().catch(undefined), skills: skillsConfigSchema.optional().catch(undefined), // Malformed hand edits disable this opt-in exporter. Live writes reject them in diagnostics.ts. metricsExport: z.object({ enabled: z.boolean().optional() }).strict().optional().catch(undefined), // Kept raw on purpose: `.catch(undefined)` would turn a mistyped `enabled` into "inherit", // which can reopen a surface the operator meant to close. src/protocols/settings.ts parses it // and fails closed instead. apiSurfaces: z.unknown().optional(), // Every protocol default is the conservative one (legacy policy, rollout off), so a malformed // block dropping to undefined cannot widen behavior. protocols: z.object({ unrepresentable: z.enum(["legacy", "reject"]).optional(), rollout: z.object({ nativeChatCombos: z.boolean().optional(), managedMessagesNative: z.boolean().optional(), managedMessagesNativeOAuth: z.boolean().optional(), directEncoders: z.boolean().optional(), shadowPlan: z.boolean().optional(), }).strict().optional(), }).strict().optional().catch(undefined), // A malformed present client block must remain diagnosable from raw config and // fail closed through src/client/state.ts; unrelated provider state still loads. client: clientConnectionSchema.optional().catch(undefined), managementUsageMaxReadBytes: z.number().int().positive().default(64 * 1024 * 1024).describe( "Deprecated compatibility limit for bounded legacy usage readers; GET /api/usage always aggregates the complete ledger", ), // Opt-in ledger ceiling. A hand edit below the floor, or a non-safe integer, disables only // this limit rather than failing the config: refusing to start because history retention was // mistyped would be a worse outcome than not trimming history. usageLedgerMaxBytes: z.number().int() .min(MIN_USAGE_LEDGER_MAX_BYTES) .max(Number.MAX_SAFE_INTEGER) .optional() .catch(undefined), // Invalid hand edits disable only this opt-in circuit. Live writes remain strict. upstreamHostCircuitThreshold: z.number().int() .min(0) .max(UPSTREAM_HOST_CIRCUIT_MAX_THRESHOLD) .optional() .catch(undefined), // Opt-in outbound body ceiling. An invalid hand edit disables only this guard, matching the // circuit threshold above: a malformed number must not make the proxy refuse traffic. maxUpstreamBodyBytes: z.number().int() .min(0) .optional() .catch(undefined), // Opt-in inbound body ceiling (#3573). An invalid hand edit degrades to the 256 MiB default // rather than failing the parse, matching the outbound guard above: a malformed number must // not change what the proxy admits. The hard ceiling is NOT enforced here — because of that // `.catch`, and because a config object can be built without this schema at all — but in // `resolveInboundBodyLimitBytes()`, which every reader goes through. maxInboundBodyBytes: z.number().int() .min(0) .optional() .catch(undefined), appOwnedMemoryBudgetMb: z.number().int() .min(MIN_APP_OWNED_MEMORY_BUDGET_MB) .max(MAX_APP_OWNED_MEMORY_BUDGET_MB) .default(DEFAULT_APP_OWNED_MEMORY_BUDGET_BYTES / (1024 * 1024)) .catch(DEFAULT_APP_OWNED_MEMORY_BUDGET_BYTES / (1024 * 1024)), // A blank hostname degrades to undefined rather than failing the parse. `getDefaultConfig()` // carries no `hostname` key, so the backup-and-defaults repair path below cannot merge one // away — a hand-edited `"hostname": ""` would fail twice and reset providers/apiKeys to // defaults, which is strictly worse than the bind bug this validation exists for. Degrading // is safe: startServer() already falls back to 127.0.0.1 for a missing hostname. Write-time // rejection lives in validateConfigCandidate() so bad values still surface to the caller. hostname: z.string().trim().min(1).optional().catch(undefined), // Discriminated on `enabled` so a disabled entry cannot be forced to carry a port (#1102). // An enabled one MAY omit it: that is the companion form, which binds 127.0.0.1 on the proxy // port and is legal only off a loopback/wildcard bind — a relationship between two fields, so // it is enforced in validateConfigCandidate() and again at startup, not here (#4236). // A malformed value degrades to undefined rather than failing the whole parse: this is an // opt-in convenience surface, and a hand-edit typo here must never reset providers/apiKeys // through the backup-and-defaults repair path. unauthenticatedLoopbackListener: z.union([ z.object({ enabled: z.literal(false) }), z.object({ enabled: z.literal(true), port: z.number().int().min(1).max(65535).optional() }), ]).optional().catch(undefined), providers: z.record(z.string(), providerConfigSchema), modelPinnedEfforts: modelPinnedEffortsSchema.optional(), compactionRouting: compactionRoutingSchema.optional().catch(undefined), compactionRecovery: compactionRecoverySchema.optional().catch(undefined), // A hand-edited malformed phase disables only that phase instead of rejecting // providers/apiKeys, matching the load-time degradation notice; the management write // boundary (validateConfigCandidate) still refuses the bad value through the shared, // catch-free memoryModelsSchema. memoryModels: z .object({ extract: memoryModelSettingSchema.optional().catch(undefined), consolidation: memoryModelSettingSchema.optional().catch(undefined), }) .optional() .catch(undefined), defaultProvider: z.string().min(1).default("openai"), defaultModelAliases: z.boolean().optional(), // Malformed hand edits disable this opt-in projection without rejecting providers. cursorEffortRows: z.boolean().optional().catch(false), // Fast selectors default on; malformed hand edits disable them without rejecting providers. fastRows: z.boolean().default(true).catch(false), // Ultra Fast is opt-in for the same reason and degrades the same way: a malformed hand // edit turns the tier off rather than rejecting the config that carries it. ultraFastTier: z.boolean().optional().catch(false), // Default-on policy (#5694): absence and malformed hand edits both mean "on", and only an // explicit `false` written by the settings PUT opts out. codexMainAccountHardLock: z.boolean().optional().catch(undefined), // Future versions remain opaque through passthrough-compatible whole-config saves. // Only version 1 grants deletion authority in the rebase path. configRebaseProvenance: z.unknown().optional(), // A retry can be billable, so absence and malformed hand edits both stay off. emptyCompletionRetry: z.boolean().optional().catch(false), // Header suppression changes what Codex sees, so absence and malformed edits stay off. dropCodexSafetyBuffering: z.boolean().optional().catch(false), // A malformed hand edit must not silently stop opening the browser: fall back // to undefined, which resolves to the historical auto-open behavior. oauthOpenBrowser: z.boolean().optional().catch(undefined), showCodexCredits: z.boolean().optional().catch(false), openaiProviderTierVersion: z.union([z.literal(1), z.literal(2)]).optional(), // Invalid hand edits must not discard an otherwise usable config. googleAntigravityStaticCatalogVersion: z.union([z.literal(1), z.literal(2)]).optional().catch(undefined), subagentModelsVersion: z.number().int().positive().optional().catch(undefined), subagentModels: z.array(z.string().min(1)).optional().catch(undefined), // A hand-edited advisory version must not cost the operator their providers; a bad // value degrades to undefined, which simply raises the notice again. multiAgentSurfaceAdvisoryVersion: z.number().int().nonnegative().optional().catch(undefined), clientIntegrations: clientIntegrationsSchema.optional().catch(undefined), // A malformed profile policy must not fall back to legacy all-profile activation. asideProfileSync: asideProfileSyncSchema.optional().catch({ allProfiles: false }), providerContextCaps: z.record(z.string(), z.number().int().positive()).optional(), providerContextCapValues: z.record(z.string(), z.number().int().positive()).optional(), contextCapValue: z.number().int().positive().optional(), multiAgentGuidanceEnabled: z.boolean().optional(), // Invalid optional recovery config must not discard unrelated provider/account state. plaintextV2AgentMessages: z.boolean().optional().catch(undefined), agentTaskRecovery: agentTaskRecoverySchema.optional().catch(undefined), // Same rationale: a bad notify section must not cost the operator their providers. quotaResetNotify: quotaResetNotifySchema.optional().catch(undefined), // Same rationale: a bad auto-refresh section must not cost the operator their providers. catalogAutoRefresh: catalogAutoRefreshSchema.optional().catch(undefined), // Same rationale again, with the failure direction stated: a malformed spend section // degrades to "no ceiling", which means observe-only accounting rather than an outage. That // is the safe degrade for traffic and the dangerous one for the operator, so the write path // rejects it and loadConfig warns -- the same pair codexPool uses below. spend: spendSchema.optional().catch(undefined), // These selections pre-date schema validation and used to pass through as // unknown fields. Invalid hand edits must disable only the optional // delegation/native-default feature, not reject the whole config and hide // otherwise valid providers, accounts, or the configured listen port. injectionModel: z.string().optional().catch(undefined), injectionEffort: z.string().optional().catch(undefined), syncCodexSubagentDefaults: z.boolean().optional().catch(undefined), // Per-primary-model fallback chains. Values must be non-empty string arrays; // malformed entries degrade to undefined rather than rejecting the whole config. subagentModelFallbackByModel: z.record( z.string(), z.array(z.string().trim().min(1)).min(1), ).optional().catch(undefined), codexShimAutoRestore: z.boolean().optional(), codexDesktopAuthless: z.boolean().optional().catch(undefined), codexClientCompaction: z.boolean().optional().catch(undefined), // Presentation-only label for the injected provider. A malformed value degrades to undefined // and the default label is emitted, rather than failing the parse or writing a config Codex // would refuse to load — the provider id routing depends on is never derived from it. codexProviderDisplayName: z.string().trim().min(1).max(128).optional().catch(undefined), pausedCodexAccountIds: z.array(z.string().regex(/^[a-zA-Z0-9._-]{1,64}$/)).optional(), // A malformed policy degrades to "no policy" rather than failing the parse, so a hand-edited // typo cannot trip the backup-and-defaults repair path and wipe providers or pool accounts. // Silently ignoring it would be its own trap, so the write path rejects it and loadConfig warns. codexPool: codexPoolSchema.optional().catch(undefined), codexQuotaAutoRefresh: codexQuotaAutoRefreshSchema.optional().catch(undefined), codexAccountNamespaces: codexAccountNamespacesSchema.optional(), // Selection order is a preference, not a safety control like pause: a malformed // map degrades to "no ordering" rather than failing the parse, so a hand-edited // typo cannot trip the backup-and-defaults repair path and wipe providers or // pool accounts. Warning emitted in loadConfig. codexAccountPriorities: codexAccountPrioritiesSchema.optional().catch(undefined), // A bad hand-edited entry must not retire valid overrides on the next unrelated save. codexAccountAutoSwitchThresholds: z.unknown().optional().transform(salvageCodexAccountAutoSwitchThresholds), // An invalid optional preference must not discard providers or credential rows. codexAccountPriorityFailback: z.boolean().optional().catch(false), activeCodexAccountPinned: z.string().regex(CODEX_ACCOUNT_PIN_PATTERN).optional().catch(undefined), // A malformed hand edit must degrade to false without discarding providers, accounts, // or the exact selector map. Live writes remain strict. codexAccountPickerEnabled: z.boolean().optional().catch(false), resetCreditAutoRedeem: z.object({ enabled: z.boolean().optional(), leadTimeMinutes: z.number().int().min(1).max(60).optional(), }).optional().catch(undefined), // Same degrade-to-off rule as the flags above: a hand-edited typo in an opt-in pool // feature must never cost the operator their providers. pool: z.object({ kernel: z.boolean().optional(), cacheAffinity: z.boolean().optional(), // The catch belongs on the list, not on `pool`. Left to the outer catch below, one // malformed group failed this nested object and dropped the whole `pool` -- taking // `kernel` and `cacheAffinity` with it, which is a live routing change the operator // never made. Scoped here, a malformed or ambiguous group costs only the declared // grouping: loadConfig warns, and the write path rejects it outright. credentialGroups: credentialGroupsSchema.optional().catch(undefined), }).optional().catch(undefined), // Model ids excluded from the Grok Build managed block (dashboard switches). grokExcludedModels: z.array(z.string()).optional(), // Invalid values degrade to undefined ("auto") instead of failing the whole // parse: a hand-edited typo must never trip the backup-and-defaults repair // path below and wipe providers/pool accounts. Warning emitted in loadConfig. streamMode: z.enum(["auto", "legacy-tee", "eager-relay"]).optional().catch(undefined), blockedModelRedirects: blockedModelRedirectsSchema.optional().catch(undefined), // Preserve malformed hand edits for a local routing error; candidate writes use the shared parser. anthropicAccountPool: z.unknown().optional(), // Same degrade-don't-reject rationale as the fields above: a hand-edited // non-string must not trip the backup-and-defaults repair path. Unset then // takes the canonical sideband path (src/server/live.ts normalizeSidebandRoot). experimentalRealtimeWsBaseUrl: z.string().optional().catch(undefined), // Salvage element by element, and never fail the parse. Two spellings were // measured on this zod version and both lose data: // `z.array(entry).catch(undefined)` -> one bad entry discards EVERY key // `z.array(z.unknown())` -> a non-array value still raises // invalid_type, reaching the // backup-and-defaults repair path // Starting from `unknown` is what makes both survivable. A key the user still // has deployed must not be collateral damage for one bad neighbour, and on a // remote bind an emptied array is worse than cosmetic: assertServerAuthConfig // refuses to start without a data credential. apiKeys: z.unknown().optional().transform(value => { if (value === undefined) return undefined; if (!Array.isArray(value)) return undefined; return value .filter(row => apiKeyEntrySchema.safeParse(row).success) .map(row => apiKeyEntrySchema.parse(row) as OcxApiKeyEntry); }), }).passthrough().superRefine((config, ctx) => { const claudeCode = (config as { claudeCode?: unknown }).claudeCode; if (claudeCode !== undefined && (!claudeCode || typeof claudeCode !== "object" || Array.isArray(claudeCode))) { ctx.addIssue({ code: "custom", path: ["claudeCode"], message: "claudeCode must be an object" }); } else if (claudeCode) { const claude = claudeCode as { desktopProfile?: unknown; desktopMode?: unknown; intercept?: unknown }; if (claude.desktopMode !== undefined && claude.desktopMode !== "first-party" && claude.desktopMode !== "gateway") { ctx.addIssue({ code: "custom", path: ["claudeCode", "desktopMode"], message: "desktopMode must be \"first-party\" or \"gateway\"" }); } if (claude.intercept !== undefined) { const intercept = claude.intercept; if (!intercept || typeof intercept !== "object" || Array.isArray(intercept)) { ctx.addIssue({ code: "custom", path: ["claudeCode", "intercept"], message: "intercept must be an object" }); } else { const { enabled, port, picker, modelMap } = intercept as { enabled?: unknown; port?: unknown; picker?: unknown; modelMap?: unknown }; if (enabled !== undefined && typeof enabled !== "boolean") { ctx.addIssue({ code: "custom", path: ["claudeCode", "intercept", "enabled"], message: "intercept.enabled must be a boolean" }); } if (picker !== undefined && typeof picker !== "boolean") { ctx.addIssue({ code: "custom", path: ["claudeCode", "intercept", "picker"], message: "intercept.picker must be a boolean" }); } if (port !== undefined && (typeof port !== "number" || !Number.isInteger(port) || port < 1 || port > 65535)) { ctx.addIssue({ code: "custom", path: ["claudeCode", "intercept", "port"], message: "intercept.port must be an integer between 1 and 65535" }); } if (modelMap !== undefined) { if (!modelMap || typeof modelMap !== "object" || Array.isArray(modelMap)) { ctx.addIssue({ code: "custom", path: ["claudeCode", "intercept", "modelMap"], message: "intercept.modelMap must be an object of picker id to route" }); } else { for (const [id, route] of Object.entries(modelMap as Record<string, unknown>)) { if (!isInterceptBindingId(id)) { ctx.addIssue({ code: "custom", path: ["claudeCode", "intercept", "modelMap", id], message: "intercept.modelMap keys must be claude- picker model ids" }); } else if (!isInterceptBindingRoute(route)) { ctx.addIssue({ code: "custom", path: ["claudeCode", "intercept", "modelMap", id], message: "intercept.modelMap values must be non-empty routes without whitespace" }); } } } } } } if (claude.desktopProfile !== undefined) { try { parseDesktopProfile(claude.desktopProfile); } catch (error) { ctx.addIssue({ code: "custom", path: ["claudeCode", "desktopProfile"], message: error instanceof Error ? error.message : String(error), }); } } } const accountNamespaces = config.codexAccountNamespaces; if (accountNamespaces) { const configuredAccountIds = configuredCodexPoolAccountIds(config.codexAccounts); const configuredProviderNamespaces = new Set([ COMBO_NAMESPACE, OPENAI_CODEX_PROVIDER_ID, POLICY_NAMESPACE, ...Object.keys(config.providers), ].map(codexProviderNamespaceKey)); const namespaceTargets = new Set( Object.values(accountNamespaces) .filter(accountId => accountId !== MAIN_CODEX_ACCOUNT_NAMESPACE_TARGET), ); for (const namespace of Object.keys(accountNamespaces)) { if (configuredProviderNamespaces.has(codexProviderNamespaceKey(namespace))) { ctx.addIssue({ code: "custom", path: ["codexAccountNamespaces", namespace], message: "account selectors must not collide with configured provider, combo, or routing policy namespaces", }); } if (configuredAccountIds.has(namespace) || namespaceTargets.has(namespace)) { ctx.addIssue({ code: "custom", path: ["codexAccountNamespaces", namespace], message: CODEX_ACCOUNT_NAMESPACE_ACCOUNT_ID_COLLISION_ERROR, }); } } } for (const name of Object.keys(config.providers)) { if (!isValidProviderName(name)) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name)], message: "provider names must use letters, numbers, dot, underscore, or hyphen and cannot be reserved JavaScript object keys or routing namespaces (policy)", }); } const provider = config.providers[name]; if (hasFastWireCapabilityConflict(provider)) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name), "fastWire"], message: "fastWire=null conflicts with supportsServiceTier=true", }); } const openRouterRoutingError = openRouterRoutingConfigError(provider); if (openRouterRoutingError) { ctx.addIssue({ code: "custom", path: [ "providers", redactSecretString(name), openRouterRoutingError.startsWith("modelOpenRouterRouting") ? "modelOpenRouterRouting" : "openRouterRouting", ], message: openRouterRoutingError, }); } const vercelRoutingError = vercelGatewayRoutingConfigError(provider); if (vercelRoutingError) { ctx.addIssue({ code: "custom", path: [ "providers", redactSecretString(name), vercelRoutingError.startsWith("modelVercelGatewayRouting") ? "modelVercelGatewayRouting" : "vercelGatewayRouting", ], message: vercelRoutingError, }); } if (Object.hasOwn(provider, "virtualModels")) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name), "virtualModels"], message: "virtualModels is registry-only and must not be persisted", }); } const baseUrlError = providerBaseUrlConfigError(provider.baseUrl); if (baseUrlError) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name), "baseUrl"], message: baseUrlError, }); } else { const destinationError = providerDestinationConfigError(name, provider); if (destinationError) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name), "baseUrl"], message: destinationError, }); } } for (const field of ["responsesPath", "chatCompletionsPath"] as const) { const sendPathError = providerRelativeSendPathConfigError(field, provider[field]); if (sendPathError) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name), field], message: sendPathError, }); } } const headersError = providerHeadersConfigError((provider as { headers?: unknown }).headers); if (headersError) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name), "headers"], message: headersError, }); } const modelCostsError = providerModelCostsConfigError((provider as { modelCosts?: unknown }).modelCosts); if (modelCostsError) { ctx.addIssue({ code: "custom", // The provider key is caller-controlled and can be token-shaped; redact it // before schemaDiagnosticsError serializes the path (ocx config validate/import). path: ["providers", redactSecretString(name), "modelCosts"], message: modelCostsError, }); } const modelDisplayNamesError = modelDisplayNamesConfigError( (provider as { modelDisplayNames?: unknown }).modelDisplayNames, ); if (modelDisplayNamesError) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name), "modelDisplayNames"], message: modelDisplayNamesError, }); } const apiKeyTransportError = apiKeyTransportConfigError(provider as OcxProviderConfig); if (apiKeyTransportError) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name), "apiKeyTransport"], message: apiKeyTransportError, }); } const modelAdaptersError = modelAdapterRecordConfigError( (provider as { modelAdapters?: unknown }).modelAdapters, "modelAdapters", name, provider, ); if (modelAdaptersError) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name), "modelAdapters"], message: modelAdaptersError, }); } const preferHostedToolsError = modelPreferHostedToolsConfigError( (provider as { modelPreferHostedTools?: unknown }).modelPreferHostedTools, "modelPreferHostedTools", name, provider, ); if (preferHostedToolsError) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name), "modelPreferHostedTools"], message: preferHostedToolsError, }); } const maxInputError = positiveIntegerRecordConfigError( (provider as { modelMaxInputTokens?: unknown }).modelMaxInputTokens, "modelMaxInputTokens", ); if (maxInputError) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name), "modelMaxInputTokens"], message: maxInputError, }); } const autoCompactError = modelAutoCompactTokenLimitsConfigError( (provider as { modelAutoCompactTokenLimits?: unknown }).modelAutoCompactTokenLimits, { requireNativeIds: name === OPENAI_CODEX_PROVIDER_ID }, ); if (autoCompactError) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name), "modelAutoCompactTokenLimits"], message: autoCompactError, }); } const reasoningSummariesError = booleanRecordConfigError( (provider as { modelSupportsReasoningSummaries?: unknown }).modelSupportsReasoningSummaries, "modelSupportsReasoningSummaries", ); if (reasoningSummariesError) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name), "modelSupportsReasoningSummaries"], message: reasoningSummariesError, }); } const suppressSyntheticMaxError = booleanRecordConfigError( (provider as { modelSuppressSyntheticMax?: unknown }).modelSuppressSyntheticMax, "modelSuppressSyntheticMax", ); if (suppressSyntheticMaxError) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name), "modelSuppressSyntheticMax"], message: suppressSyntheticMaxError, }); } const verbositySupportError = booleanRecordConfigError( (provider as { modelSupportsVerbosity?: unknown }).modelSupportsVerbosity, "modelSupportsVerbosity", ); if (verbositySupportError) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name), "modelSupportsVerbosity"], message: verbositySupportError, }); } const serviceTierModelsError = booleanRecordConfigError( (provider as { modelSupportsServiceTier?: unknown }).modelSupportsServiceTier, "modelSupportsServiceTier", ); if (serviceTierModelsError) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name), "modelSupportsServiceTier"], message: serviceTierModelsError, }); } const reasoningSummaryDeliveryError = reasoningSummaryDeliveryRecordConfigError( (provider as { modelReasoningSummaryDelivery?: unknown }).modelReasoningSummaryDelivery, (provider as { modelSupportsReasoningSummaries?: unknown }).modelSupportsReasoningSummaries, ); if (reasoningSummaryDeliveryError) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name), "modelReasoningSummaryDelivery"], message: reasoningSummaryDeliveryError, }); } const defaultMaxOutputError = positiveIntegerConfigError( (provider as { defaultMaxOutputTokens?: unknown }).defaultMaxOutputTokens, "defaultMaxOutputTokens", ); if (defaultMaxOutputError) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name), "defaultMaxOutputTokens"], message: defaultMaxOutputError, }); } const maxOutputError = positiveIntegerRecordConfigError( (provider as { modelMaxOutputTokens?: unknown }).modelMaxOutputTokens, "modelMaxOutputTokens", ); if (maxOutputError) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name), "modelMaxOutputTokens"], message: maxOutputError, }); } const structuredOutputOptOutError = nonBlankStringArrayConfigError( (provider as { noStructuredOutputModels?: unknown }).noStructuredOutputModels, "noStructuredOutputModels", ); if (structuredOutputOptOutError) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name), "noStructuredOutputModels"], message: structuredOutputOptOutError, }); } const jsonSchemaOptOutError = nonBlankStringArrayConfigError( (provider as { noJsonSchemaModels?: unknown }).noJsonSchemaModels, "noJsonSchemaModels", ); if (jsonSchemaOptOutError) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name), "noJsonSchemaModels"], message: jsonSchemaOptOutError, }); } const retainModelsError = nonBlankStringArrayConfigError( (provider as { retainModels?: unknown }).retainModels, "retainModels", ); if (retainModelsError) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name), "retainModels"], message: retainModelsError, }); } const toolReasoningOptOutError = nonBlankStringArrayConfigError( (provider as { omitReasoningEffortWithToolsModels?: unknown }).omitReasoningEffortWithToolsModels, "omitReasoningEffortWithToolsModels", ); if (toolReasoningOptOutError) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name), "omitReasoningEffortWithToolsModels"], message: toolReasoningOptOutError, }); } if (Object.hasOwn(provider, "codexAccountMode") && provider.codexAccountMode !== undefined) { // Persisted account mode is valid ONLY on the canonical built-in `openai` forward provider. // Old openai-multi rows stay parseable (they never carry a mode) so startup can migrate them. const canonicalOpenAiShape = name === "openai" && provider.adapter === "openai-responses" && (provider as { authMode?: unknown }).authMode === "forward" && typeof provider.baseUrl === "string" && provider.baseUrl.replace(/\/+$/, "") === "https://chatgpt.com/backend-api/codex"; if (!canonicalOpenAiShape) { ctx.addIssue({ code: "custom", path: ["providers", redactSecretString(name), "codexAccountMode"], message: "codexAccountMode is valid only on the canonical built-in openai provider", }); } } } if (!hasOwnProvider(config.providers, config.defaultProvider)) { ctx.addIssue({ code: "custom", path: ["defaultProvider"], message: "defaultProvider must exist in providers", }); } const combos = (config as { combos?: unknown }).combos; if (combos !== undefined) { if (!combos || typeof combos !== "object" || Array.isArray(combos)) { ctx.addIssue({ code: "custom", path: ["combos"], message: "combos must be an object" }); } else { for (const [id, raw] of Object.entries(combos as Record<string, unknown>)) { const alias = raw && typeof raw === "object" && !Array.isArray(raw) ? (raw as { alias?: unknown }).alias : undefined; if (typeof alias === "string" && codexAccountNamespaceForModel(accountNamespaces, alias.trim())) { ctx.addIssue({ code: "custom", path: ["combos", id, "alias"], message: CODEX_ACCOUNT_NAMESPACE_COMBO_ALIAS_COLLISION_ERROR, }); } // Pass the full map so cross-combo rules (alias uniqueness) apply at load time // too, not just via the management API; each combo is excluded from its own check. for (const issue of comboConfigIssues(id, raw, config.providers, { combos: combos as Record<string, import("../../types").OcxComboConfig>, excludeComboId: id, })) { ctx.addIssue({ code: "custom", path: ["combos", id, ...issue.path], message: issue.message, }); } } } } const routingProfiles = (config as { routingProfiles?: unknown }).routingProfiles; if (routingProfiles !== undefined) { if (!routingProfiles || typeof routingProfiles !== "object" || Array.isArray(routingProfiles)) { ctx.addIssue({ code: "custom", path: ["routingProfiles"], message: "routingProfiles must be an object" }); } else { for (const [id, raw] of Object.entries(routingProfiles as Record<string, unknown>)) { for (const issue of routingProfileIssues(id, raw, { providers: config.providers, combos: combos as Record<string, import("../../types").OcxComboConfig> | undefined, routingProfiles: routingProfiles as Record<string, import("../../types").OcxRoutingProfileConfig>, codexAccountNamespaces: accountNamespaces, }, { excludeProfileId: id })) { ctx.addIssue({ code: "custom", path: ["routingProfiles", id, ...issue.path], message: issue.message, }); } } } } });