@opengeni/config 2.0.0 → 2.1.0

package/dist/index.d.ts

@@ -190,6 +190,7 @@ declare const SettingsSchema: z.ZodObject<{
         computer_observe: "computer_observe";
         computer_open: "computer_open";
         computer_targets: "computer_targets";
+        connected_machine_enroll_token: "connected_machine_enroll_token";
         connected_machine_remove: "connected_machine_remove";
         editable_artifact_apply: "editable_artifact_apply";
         editable_artifact_create: "editable_artifact_create";
@@ -359,6 +360,7 @@ declare const SettingsSchema: z.ZodObject<{
         computer_observe: "computer_observe";
         computer_open: "computer_open";
         computer_targets: "computer_targets";
+        connected_machine_enroll_token: "connected_machine_enroll_token";
         connected_machine_remove: "connected_machine_remove";
         editable_artifact_apply: "editable_artifact_apply";
         editable_artifact_create: "editable_artifact_create";
@@ -504,6 +506,7 @@ declare const SettingsSchema: z.ZodObject<{
     environmentsEncryptionKey: z.ZodOptional<z.ZodString>;
     integrationsEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
     integrationsStateSecret: z.ZodOptional<z.ZodString>;
+    integrationsOauthShortStateEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
     integrationsAllowPrivateNetworkTargets: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
     integrationsOauthClientsJson: z.ZodDefault<z.ZodString>;
     slackClientId: z.ZodOptional<z.ZodString>;
@@ -605,6 +608,7 @@ declare const SettingsSchema: z.ZodObject<{
     openrouterApiKey: z.ZodOptional<z.ZodString>;
     resolvedGatewayModelsJson: z.ZodOptional<z.ZodString>;
     resolvedOpenRouterModelsJson: z.ZodOptional<z.ZodString>;
+    resolvedCodexModelsJson: z.ZodOptional<z.ZodString>;
     modelProvidersJson: z.ZodDefault<z.ZodString>;
     codexSubscriptionEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
     supergrokSubscriptionEnabled: z.ZodDefault<z.ZodPreprocess<z.ZodBoolean>>;
@@ -1970,6 +1974,166 @@ export declare const ModelCatalogDocument: z.ZodObject<{
         publicDefaultHeaderNames: z.ZodOptional<z.ZodNever>;
         publicDefaultQueryNames: z.ZodOptional<z.ZodNever>;
     }, z.core.$strict>>>;
+    codexModels: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        aliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        label: z.ZodOptional<z.ZodString>;
+        shortLabel: z.ZodOptional<z.ZodString>;
+        contextWindowTokens: z.ZodOptional<z.ZodNumber>;
+        effectiveContextWindowTokens: z.ZodOptional<z.ZodNumber>;
+        autoCompactTokenLimit: z.ZodOptional<z.ZodNumber>;
+        toolOutputTruncationTokens: z.ZodOptional<z.ZodNumber>;
+        reasoningEffort: z.ZodOptional<z.ZodBoolean>;
+        hostedWebSearch: z.ZodOptional<z.ZodBoolean>;
+        credentialSource: z.ZodOptional<z.ZodNever>;
+        billing: z.ZodOptional<z.ZodNever>;
+        retired: z.ZodOptional<z.ZodBoolean>;
+        id: z.ZodString;
+        upstreamModelId: z.ZodString;
+        capabilities: z.ZodObject<{
+            reasoning: z.ZodObject<{
+                upstream: z.ZodEnum<{
+                    supported: "supported";
+                    unknown: "unknown";
+                    unsupported: "unsupported";
+                }>;
+                runnable: z.ZodBoolean;
+                efforts: z.ZodArray<z.ZodEnum<{
+                    high: "high";
+                    low: "low";
+                    max: "max";
+                    medium: "medium";
+                    minimal: "minimal";
+                    none: "none";
+                    xhigh: "xhigh";
+                }>>;
+                defaultEffort: z.ZodNullable<z.ZodEnum<{
+                    high: "high";
+                    low: "low";
+                    max: "max";
+                    medium: "medium";
+                    minimal: "minimal";
+                    none: "none";
+                    xhigh: "xhigh";
+                }>>;
+                required: z.ZodBoolean;
+            }, z.core.$strip>;
+            functionCalling: z.ZodObject<{
+                upstream: z.ZodEnum<{
+                    supported: "supported";
+                    unknown: "unknown";
+                    unsupported: "unsupported";
+                }>;
+                runnable: z.ZodBoolean;
+            }, z.core.$strip>;
+            structuredOutput: z.ZodObject<{
+                upstream: z.ZodEnum<{
+                    supported: "supported";
+                    unknown: "unknown";
+                    unsupported: "unsupported";
+                }>;
+                runnable: z.ZodBoolean;
+            }, z.core.$strip>;
+            hostedTools: z.ZodObject<{
+                webSearch: z.ZodObject<{
+                    upstream: z.ZodEnum<{
+                        supported: "supported";
+                        unknown: "unknown";
+                        unsupported: "unsupported";
+                    }>;
+                    runnable: z.ZodBoolean;
+                }, z.core.$strip>;
+                xSearch: z.ZodObject<{
+                    upstream: z.ZodEnum<{
+                        supported: "supported";
+                        unknown: "unknown";
+                        unsupported: "unsupported";
+                    }>;
+                    runnable: z.ZodBoolean;
+                }, z.core.$strip>;
+                codeExecution: z.ZodObject<{
+                    upstream: z.ZodEnum<{
+                        supported: "supported";
+                        unknown: "unknown";
+                        unsupported: "unsupported";
+                    }>;
+                    runnable: z.ZodBoolean;
+                }, z.core.$strip>;
+                imageGeneration: z.ZodDefault<z.ZodObject<{
+                    upstream: z.ZodEnum<{
+                        supported: "supported";
+                        unknown: "unknown";
+                        unsupported: "unsupported";
+                    }>;
+                    runnable: z.ZodBoolean;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            inputModalities: z.ZodArray<z.ZodEnum<{
+                audio: "audio";
+                image: "image";
+                text: "text";
+            }>>;
+            inputFileMediaTypes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            outputModalities: z.ZodArray<z.ZodEnum<{
+                audio: "audio";
+                image: "image";
+                text: "text";
+            }>>;
+            transports: z.ZodObject<{
+                sse: z.ZodObject<{
+                    upstream: z.ZodEnum<{
+                        supported: "supported";
+                        unknown: "unknown";
+                        unsupported: "unsupported";
+                    }>;
+                    runnable: z.ZodBoolean;
+                }, z.core.$strip>;
+                responsesWebSocket: z.ZodObject<{
+                    upstream: z.ZodEnum<{
+                        supported: "supported";
+                        unknown: "unknown";
+                        unsupported: "unsupported";
+                    }>;
+                    runnable: z.ZodBoolean;
+                }, z.core.$strip>;
+                realtimeAudio: z.ZodObject<{
+                    upstream: z.ZodEnum<{
+                        supported: "supported";
+                        unknown: "unknown";
+                        unsupported: "unsupported";
+                    }>;
+                    runnable: z.ZodBoolean;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            promptCaching: z.ZodOptional<z.ZodObject<{
+                upstream: z.ZodEnum<{
+                    supported: "supported";
+                    unknown: "unknown";
+                    unsupported: "unsupported";
+                }>;
+                runnable: z.ZodBoolean;
+                mode: z.ZodEnum<{
+                    automatic: "automatic";
+                    implicit: "implicit";
+                    none: "none";
+                }>;
+            }, z.core.$strip>>;
+            latencyModes: z.ZodArray<z.ZodObject<{
+                id: z.ZodEnum<{
+                    fast: "fast";
+                    priority: "priority";
+                    standard: "standard";
+                }>;
+                upstream: z.ZodEnum<{
+                    supported: "supported";
+                    unknown: "unknown";
+                    unsupported: "unsupported";
+                }>;
+                runnable: z.ZodBoolean;
+                billingMultiplierBps: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        pricing: z.ZodOptional<z.ZodNever>;
+    }, z.core.$strict>>>;
     gatewayModels: z.ZodDefault<z.ZodArray<z.ZodObject<{
         productId: z.ZodString;
         workspaceProductId: z.ZodString;
@@ -2500,6 +2664,14 @@ export declare function canonicalizeConfiguredModelId(settings: Settings, modelI
  * openai allow-list, then registry ids.
  */
 export declare function configuredAllowedModels(settings: Settings): string[];
+/** Retirement is selection metadata, never provider authority or executable identity. */
+export declare function isModelAvailableForNewSelection(settings: Settings, modelId: string): boolean;
+/** Called only with the durable policy installed for a claimed accepted attempt. */
+export declare function settingsForAcceptedSubscriptionTurn(settings: Settings, policy: TurnExecutionPolicyV1, expected: {
+    modelId: string;
+    reasoningEffort: Settings["openaiReasoningEffort"];
+    latencyMode?: LatencyMode;
+}): Settings;
 /**
  * Resolve a model string to the provider that serves it and its configured
  * shape. Returns undefined when the id is not exposed (built-in allow-list nor

package/dist/index.js

@@ -311,6 +311,7 @@ var SettingsSchema = z.object({
   environmentsEncryptionKey: z.string().optional(),
   integrationsEnabled: EnvBoolean.default(false),
   integrationsStateSecret: z.string().optional(),
+  integrationsOauthShortStateEnabled: EnvBoolean.default(false),
   integrationsAllowPrivateNetworkTargets: EnvBoolean.default(false),
   integrationsOauthClientsJson: z.string().default("{}"),
   slackClientId: z.string().optional(),
@@ -436,8 +437,8 @@ var SettingsSchema = z.object({
   openaiProvider: z.enum(["openai", "azure"]).default("openai"),
   openaiApiKey: z.string().optional(),
   openaiBaseUrl: z.string().optional(),
-  openaiModel: z.string().default("gpt-5.6-sol"),
-  openaiAllowedModels: z.string().default("gpt-5.6-sol,gpt-5.6-terra,gpt-5.6-luna"),
+  openaiModel: z.string().default("gpt-6-astra"),
+  openaiAllowedModels: z.string().default("gpt-6-astra,gpt-6-sol,gpt-6-luna"),
   // OpenGeni-managed Vercel AI Gateway. When configured, the two reviewed
   // Gateway models below are added to the managed-credit catalog. Workspace
   // Gateway keys use the encrypted connection broker and never this secret.
@@ -514,6 +515,7 @@ var SettingsSchema = z.object({
   // binding so database mode cannot be bypassed with a second source.
   resolvedGatewayModelsJson: z.string().optional(),
   resolvedOpenRouterModelsJson: z.string().optional(),
+  resolvedCodexModelsJson: z.string().optional(),
   // Extra (non-built-in) model providers, declared by the host as a JSON
   // provider registry. Each entry carries its own base URL, API key, wire API
   // ("responses" | "chat") and the models it exposes. The models a client may
@@ -1255,6 +1257,9 @@ function personalGitHubOAuthCallbackUrl(publicBaseUrl) {
   const origin = canonicalPublicOrigin(publicBaseUrl);
   return origin ? `${origin}/v1/integrations/github-personal/oauth/callback` : null;
 }
+function usableDeploymentSecret(value) {
+  return isUsableVoiceInputSecret(value) ? value : void 0;
+}
 function isUsableVoiceInputSecret(value) {
   if (value == null) return false;
   const trimmed = value.trim();
@@ -1728,14 +1733,30 @@ var DeploymentRegistryProviderSchema = RegistryProviderSchema.safeExtend({
 var DeploymentGatewayCatalogModelSchema = GatewayCatalogModel.safeExtend({
   pricing: z.never().optional()
 }).strict();
+var CodexCatalogModelSchema = RegistryModelSchema.safeExtend({
+  retired: z.boolean().optional(),
+  id: z.string().regex(/^codex\/[a-zA-Z0-9][a-zA-Z0-9._-]*$/),
+  upstreamModelId: z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/),
+  capabilities: ModelCapabilitiesV1Schema,
+  pricing: z.never().optional()
+}).strict().superRefine((model, context) => {
+  if (model.id !== `${CODEX_MODEL_ID_PREFIX}${model.upstreamModelId}`) {
+    context.addIssue({
+      code: "custom",
+      path: ["id"],
+      message: "Codex product id must match its upstream model slug"
+    });
+  }
+});
 var ModelCatalogDocument = z.object({
   schemaVersion: z.literal(1),
   /** Canonical deployment default. Omission preserves the V1 first-built-in
    * fallback for existing documents; operators should set this explicitly
    * when cutting over a registry or connected-subscription default. */
   defaultModel: z.string().min(1).optional(),
-  builtInModels: z.array(z.string().min(1)).min(1),
+  builtInModels: z.array(z.string().min(1)),
   registryProviders: z.array(DeploymentRegistryProviderSchema).default([]),
+  codexModels: z.array(CodexCatalogModelSchema).optional(),
   gatewayModels: z.array(DeploymentGatewayCatalogModelSchema).default([]),
   openrouterModels: z.array(OpenRouterCatalogModel).default([]),
   modelNotes: z.record(z.string().min(1), ModelNote).default({}),
@@ -1744,6 +1765,13 @@ var ModelCatalogDocument = z.object({
   apiKey: z.never().optional(),
   bands: z.never().optional()
 }).strict().superRefine((document, context) => {
+  if (document.builtInModels.length === 0 && !document.defaultModel) {
+    context.addIssue({
+      code: "custom",
+      path: ["defaultModel"],
+      message: "catalogs without built-in models require an explicit default model"
+    });
+  }
   const productIds = /* @__PURE__ */ new Set();
   const providerIds = /* @__PURE__ */ new Set();
   const gatewayUpstreamIds = /* @__PURE__ */ new Set();
@@ -1765,6 +1793,14 @@ var ModelCatalogDocument = z.object({
     productIds.add(id);
   };
   document.builtInModels.forEach((id, index) => add(id, ["builtInModels", index]));
+  document.codexModels?.forEach((model, index) => add(model.id, ["codexModels", index, "id"]));
+  if (document.codexModels?.some((model) => model.retired && model.id === document.defaultModel)) {
+    context.addIssue({
+      code: "custom",
+      path: ["defaultModel"],
+      message: "a retired model cannot be the deployment default"
+    });
+  }
   document.registryProviders.forEach((provider, providerIndex) => {
     if (RESERVED_MODEL_PROVIDER_IDS.has(provider.id)) {
       context.addIssue({
@@ -1811,7 +1847,7 @@ var ModelCatalogDocument = z.object({
       message: "catalog default model must not contain newlines or the | field separator"
     });
   }
-  if (document.defaultModel && !productIds.has(document.defaultModel) && !document.defaultModel.startsWith(CODEX_MODEL_ID_PREFIX) && !document.defaultModel.startsWith(XAI_SUBSCRIPTION_MODEL_ID_PREFIX)) {
+  if (document.defaultModel && !productIds.has(document.defaultModel) && !(document.codexModels === void 0 && document.defaultModel.startsWith(CODEX_MODEL_ID_PREFIX)) && !document.defaultModel.startsWith(XAI_SUBSCRIPTION_MODEL_ID_PREFIX)) {
     context.addIssue({
       code: "custom",
       path: ["defaultModel"],
@@ -1881,6 +1917,7 @@ function applyModelCatalogDocument(settings, rawDocument) {
     ),
     resolvedGatewayModelsJson: JSON.stringify(document.gatewayModels),
     resolvedOpenRouterModelsJson: JSON.stringify(document.openrouterModels),
+    resolvedCodexModelsJson: document.codexModels === void 0 ? void 0 : JSON.stringify(document.codexModels),
     modelNotesJson: JSON.stringify(document.modelNotes)
   };
   return resolved;
@@ -2053,6 +2090,73 @@ function configuredOpenRouterOrganizationProductModelIds(settings) {
   return [];
 }
 var defaultModelPricing = {
+  "gpt-6-astra": {
+    default: {
+      // OpenAI list price: $10 / $1 cached / $12.50 cache write / $50 output.
+      inputMicrosPerMillionTokens: 1e7,
+      cachedInputMicrosPerMillionTokens: 1e6,
+      cacheWriteMicrosPerMillionTokens: 125e5,
+      outputMicrosPerMillionTokens: 5e7,
+      marginBps: 500
+    },
+    inputTokenTiers: [
+      {
+        // Prompts with more than 272K input tokens use 2x input and 1.5x output.
+        minimumInputTokens: 272001,
+        pricing: {
+          inputMicrosPerMillionTokens: 2e7,
+          cachedInputMicrosPerMillionTokens: 2e6,
+          cacheWriteMicrosPerMillionTokens: 25e6,
+          outputMicrosPerMillionTokens: 75e6,
+          marginBps: 500
+        }
+      }
+    ]
+  },
+  "gpt-6-sol": {
+    default: {
+      // OpenAI list price: $2 / $0.20 cached / $2.50 cache write / $10 output.
+      inputMicrosPerMillionTokens: 2e6,
+      cachedInputMicrosPerMillionTokens: 2e5,
+      cacheWriteMicrosPerMillionTokens: 25e5,
+      outputMicrosPerMillionTokens: 1e7,
+      marginBps: 500
+    },
+    inputTokenTiers: [
+      {
+        minimumInputTokens: 272001,
+        pricing: {
+          inputMicrosPerMillionTokens: 4e6,
+          cachedInputMicrosPerMillionTokens: 4e5,
+          cacheWriteMicrosPerMillionTokens: 5e6,
+          outputMicrosPerMillionTokens: 15e6,
+          marginBps: 500
+        }
+      }
+    ]
+  },
+  "gpt-6-luna": {
+    default: {
+      // OpenAI list price: $0.10 / $0.01 cached / $0.125 cache write / $0.50 output.
+      inputMicrosPerMillionTokens: 1e5,
+      cachedInputMicrosPerMillionTokens: 1e4,
+      cacheWriteMicrosPerMillionTokens: 125e3,
+      outputMicrosPerMillionTokens: 5e5,
+      marginBps: 500
+    },
+    inputTokenTiers: [
+      {
+        minimumInputTokens: 272001,
+        pricing: {
+          inputMicrosPerMillionTokens: 2e5,
+          cachedInputMicrosPerMillionTokens: 2e4,
+          cacheWriteMicrosPerMillionTokens: 25e4,
+          outputMicrosPerMillionTokens: 75e4,
+          marginBps: 500
+        }
+      }
+    ]
+  },
   "gpt-5.6-sol": {
     default: {
       // Promotional OpenAI pricing, guaranteed through at least 2026-11-21.
@@ -2293,6 +2397,7 @@ function getSettings(source = process.env) {
     environmentsEncryptionKey: optional("OPENGENI_ENVIRONMENTS_ENCRYPTION_KEY"),
     integrationsEnabled: optional("OPENGENI_INTEGRATIONS_ENABLED"),
     integrationsStateSecret: optional("OPENGENI_INTEGRATIONS_STATE_SECRET"),
+    integrationsOauthShortStateEnabled: optional("OPENGENI_INTEGRATIONS_OAUTH_SHORT_STATE_ENABLED"),
     integrationsAllowPrivateNetworkTargets: optional(
       "OPENGENI_INTEGRATIONS_ALLOW_PRIVATE_NETWORK_TARGETS"
     ),
@@ -3282,8 +3387,8 @@ function productLabelForModelId(modelId) {
 function productShortLabelForModelId(modelId) {
   const slug = modelId.startsWith(CODEX_MODEL_ID_PREFIX) ? modelId.slice(CODEX_MODEL_ID_PREFIX.length) : modelId;
   switch (slug) {
-    case "grok-4.6":
-      return "4.6";
+    case "grok-4.7":
+      return "4.7";
     case "gpt-5.6-sol":
       return "5.6 Sol";
     case "gpt-5.6-terra":
@@ -3292,6 +3397,10 @@ function productShortLabelForModelId(modelId) {
       return "5.6 Luna";
     case "gpt-6-astra":
       return "6 Astra";
+    case "gpt-6-sol":
+      return "6 Sol";
+    case "gpt-6-luna":
+      return "6 Luna";
     default:
       return null;
   }
@@ -3311,7 +3420,7 @@ function builtinContextLimitsForModel(settings, modelId) {
   return { contextWindowTokens: settings.contextWindowTokens };
 }
 function builtinLatencyModesForModel(modelId) {
-  if (isBuiltinGpt56ModelId(modelId) || modelId.startsWith("codex/gpt-5.6-") || modelId === "codex/gpt-6-astra") {
+  if (isBuiltinGpt56ModelId(modelId) || modelId.startsWith("gpt-6-") || modelId.startsWith("codex/gpt-5.6-") || modelId.startsWith("codex/gpt-6-")) {
     return [
       { id: "standard", upstream: "supported", runnable: true },
       {
@@ -3326,10 +3435,10 @@ function builtinLatencyModesForModel(modelId) {
 }
 function builtinPromptCachingForModel(modelId) {
   const slug = modelId.startsWith(CODEX_MODEL_ID_PREFIX) ? modelId.slice(CODEX_MODEL_ID_PREFIX.length) : modelId;
-  return slug.startsWith("gpt-5.6-") ? { upstream: "supported", runnable: true, mode: "implicit" } : void 0;
+  return slug.startsWith("gpt-5.6-") || slug.startsWith("gpt-6-") ? { upstream: "supported", runnable: true, mode: "implicit" } : void 0;
 }
 function builtinHostedImageGenerationForModel(settings, modelId) {
-  return settings.openaiProvider === "openai" && isDirectOpenAiApiBaseUrl(settings.openaiBaseUrl) && isBuiltinGpt56ModelId(modelId);
+  return settings.openaiProvider === "openai" && isDirectOpenAiApiBaseUrl(settings.openaiBaseUrl) && (isBuiltinGpt56ModelId(modelId) || modelId.startsWith("gpt-6-"));
 }
 function isDirectOpenAiApiBaseUrl(baseUrl) {
   if (baseUrl === void 0) return true;
@@ -3523,10 +3632,10 @@ function configuredProviders(settings, source = process.env) {
   if (settings.openaiProvider === "azure") {
     const baseUrl = settings.azureOpenaiBaseUrl ?? settings.azureOpenaiEndpoint;
     builtin.baseUrl = baseUrl ? normalizeRegistryBaseUrl(baseUrl, builtin.id) : void 0;
-    builtin.apiKey = settings.azureOpenaiApiKey ?? settings.azureOpenaiAdToken;
+    builtin.apiKey = usableDeploymentSecret(settings.azureOpenaiApiKey) ?? settings.azureOpenaiAdToken;
   } else {
     builtin.baseUrl = settings.openaiBaseUrl ? normalizeRegistryBaseUrl(settings.openaiBaseUrl, builtin.id) : void 0;
-    builtin.apiKey = settings.openaiApiKey;
+    builtin.apiKey = usableDeploymentSecret(settings.openaiApiKey);
   }
   const registry = configuredRegistryProviders(settings).map(
     (provider) => ({
@@ -3553,6 +3662,8 @@ function withCodexCatalogProvider(settings) {
   if (providers.some((provider2) => provider2.id === CODEX_PROVIDER_ID)) {
     return settings;
   }
+  const catalogModels = settings.resolvedCodexModelsJson === void 0 ? void 0 : z.array(CodexCatalogModelSchema).parse(JSON.parse(settings.resolvedCodexModelsJson)).filter((model) => !model.retired).map(({ retired: _retired, ...model }) => model);
+  if (catalogModels?.length === 0) return settings;
   const provider = {
     kind: "codex-subscription",
     id: CODEX_PROVIDER_ID,
@@ -3560,12 +3671,12 @@ function withCodexCatalogProvider(settings) {
     api: "responses",
     wireProfile: "openai",
     baseUrl: CODEX_PROVIDER_BASE_URL,
-    models: CODEX_FALLBACK_MODEL_SLUGS.map((slug) => {
+    models: catalogModels ?? CODEX_FALLBACK_MODEL_SLUGS.map((slug) => {
       const capabilities = {
         ...legacyModelCapabilities(settings, {
           reasoningEffort: true,
           hostedWebSearch: true,
-          vision: slug.startsWith("gpt-5.6-") || slug === "gpt-6-astra"
+          vision: slug.startsWith("gpt-5.6-") || slug.startsWith("gpt-6-")
         }),
         ...builtinPromptCachingForModel(`${CODEX_MODEL_ID_PREFIX}${slug}`) ? {
           promptCaching: builtinPromptCachingForModel(`${CODEX_MODEL_ID_PREFIX}${slug}`)
@@ -3748,7 +3859,7 @@ function configuredModels(settings, source = process.env) {
         reasoningEffort: true,
         hostedWebSearch: settings.webSearchEnabled,
         hostedImageGeneration: builtinHostedImageGenerationForModel(settings, id),
-        vision: id.startsWith("gpt-5.6-")
+        vision: id.startsWith("gpt-5.6-") || id.startsWith("gpt-6-")
       }),
       ...builtinPromptCachingForModel(id) ? { promptCaching: builtinPromptCachingForModel(id) } : {},
       latencyModes: builtinLatencyModesForModel(id)
@@ -3827,7 +3938,57 @@ function canonicalizeConfiguredModelId(settings, modelId) {
   return models.find((model) => model.aliases.includes(modelId))?.id ?? modelId;
 }
 function configuredAllowedModels(settings) {
-  return configuredModels(settings).map((model) => model.id);
+  return configuredModels(settings).filter((model) => isModelAvailableForNewSelection(settings, model.id)).map((model) => model.id);
+}
+function isModelAvailableForNewSelection(settings, modelId) {
+  if (!modelId.startsWith(CODEX_MODEL_ID_PREFIX) || settings.resolvedCodexModelsJson === void 0)
+    return true;
+  const models = z.array(CodexCatalogModelSchema).parse(JSON.parse(settings.resolvedCodexModelsJson));
+  return models.some((model) => model.id === modelId && !model.retired);
+}
+function settingsForAcceptedSubscriptionTurn(settings, policy, expected) {
+  const parsed = TurnExecutionPolicyV1.parse(policy);
+  if (!parsed.productModelId.startsWith(CODEX_MODEL_ID_PREFIX)) return settings;
+  if (!settings.codexSubscriptionEnabled) throw new Error("Codex subscription is disabled");
+  const models = settings.resolvedCodexModelsJson === void 0 ? [] : z.array(CodexCatalogModelSchema).parse(JSON.parse(settings.resolvedCodexModelsJson));
+  const retained = models.find((model2) => model2.id === parsed.productModelId && model2.retired);
+  if (!retained) {
+    assertTurnExecutionPolicyMatchesConfigV1(settings, parsed, expected);
+    return settings;
+  }
+  const { retired: _retired, ...model } = retained;
+  const withoutCodex = {
+    ...settings,
+    modelProvidersJson: JSON.stringify(
+      parseModelProvidersJson(settings.modelProvidersJson).filter(
+        (provider) => provider.id !== CODEX_PROVIDER_ID
+      )
+    )
+  };
+  const providerSettings = withCodexCatalogProvider({
+    ...withoutCodex,
+    resolvedCodexModelsJson: JSON.stringify([model])
+  });
+  const retainedProvider = parseModelProvidersJson(providerSettings.modelProvidersJson).find(
+    (provider) => provider.id === CODEX_PROVIDER_ID
+  );
+  const providers = parseModelProvidersJson(settings.modelProvidersJson);
+  const current = providers.find((provider) => provider.id === CODEX_PROVIDER_ID);
+  const restored = {
+    ...settings,
+    modelProvidersJson: JSON.stringify([
+      ...providers.filter((provider) => provider.id !== CODEX_PROVIDER_ID),
+      {
+        ...retainedProvider,
+        models: [
+          ...(current?.models ?? []).filter((candidate) => candidate.id !== model.id),
+          model
+        ]
+      }
+    ])
+  };
+  assertTurnExecutionPolicyMatchesConfigV1(restored, parsed, expected);
+  return restored;
 }
 function resolveModelProvider(settings, modelId) {
   const canonicalModelId = canonicalizeConfiguredModelId(settings, modelId);
@@ -3880,6 +4041,9 @@ function resolveModelProviderForTurn(settings, modelId) {
 function resolveTurnExecutionPolicyV1(settings, input) {
   const catalogSettings = settingsForTurnExecutionPolicy(settings, input.modelId);
   const productModelId = canonicalizeConfiguredModelId(catalogSettings, input.modelId);
+  if (!isModelAvailableForNewSelection(catalogSettings, productModelId)) {
+    throw new Error("Turn execution policy model is retired from new selection");
+  }
   const resolved = resolveModelProvider(catalogSettings, productModelId);
   if (!resolved) {
     throw new Error("Turn execution policy model is not present in the configured catalog");
@@ -5206,6 +5370,11 @@ function validateModelCatalogSettings(settings, source = process.env) {
     models.filter((model) => model.credentialSource.kind === "deployment").map((model) => model.id)
   );
   const noteProductIds = new Set(models.map((model) => model.id));
+  if (settings.resolvedCodexModelsJson !== void 0) {
+    for (const model of z.array(CodexCatalogModelSchema).parse(JSON.parse(settings.resolvedCodexModelsJson))) {
+      noteProductIds.add(model.id);
+    }
+  }
   for (const model of configuredGatewayCatalogModels(settings)) {
     deploymentProductIds.add(model.productId);
     noteProductIds.add(model.productId);
@@ -5490,6 +5659,7 @@ export {
   hasGitCredentialRepositorySelection,
   hasGitHubRepositorySelection,
   isDirectOpenAiApiBaseUrl,
+  isModelAvailableForNewSelection,
   isUsableVoiceInputSecret,
   modelCostClassForConfiguredModel,
   parseExposedPorts,
@@ -5533,6 +5703,7 @@ export {
   sandboxWarmRateMicrosPerSecond,
   selectModelPricing,
   serviceTierForLatencyMode,
+  settingsForAcceptedSubscriptionTurn,
   settingsWithResolvedModelContext,
   stableSandboxEnvironmentForRun,
   startupRetryOptions,