@omnicross/core 0.4.1 → 0.4.3

package/dist/{chunk-5TEWZN5J.js → chunk-SWY2LTMR.js}

@@ -1,14 +1,20 @@
 import {
-  DEFAULT_SEARCH_FRONTEND_MODES,
-  SEARCH_UNSUPPORTED_CAPABILITY_CODE,
-  normalizeSearchFrontendModes,
-  searchErrorHttpStatus,
-  searchRuntimeAsWebSearchBackend,
-  validateSearchFrontendModes
-} from "./chunk-MZEGQSKQ.js";
+  OpenAIResponseTransformer
+} from "./chunk-V53ZEFXC.js";
 import {
-  streamSSEResponse
-} from "./chunk-VVEHS2LI.js";
+  AnthropicTransformer,
+  resolveAnthropicMaxTokens
+} from "./chunk-TKZ3DZS5.js";
+import {
+  setAnthropicPingHeartbeatMs
+} from "./chunk-IDPMD4B7.js";
+import {
+  fetchWithAntigravityFailover,
+  maybeAntigravityFailoverUrl
+} from "./chunk-K6J2RIEX.js";
+import {
+  GeminiTransformer
+} from "./chunk-OXBGNEYR.js";
 import {
   TransformerChainExecutor
 } from "./chunk-EYGBM2VC.js";
@@ -16,26 +22,28 @@ import {
   injectExtendedContextBeta
 } from "./chunk-MZNPGW5Q.js";
 import {
-  GeminiTransformer
-} from "./chunk-HN74IGEO.js";
-import {
-  OpenAIResponseTransformer
-} from "./chunk-V53ZEFXC.js";
+  MATCH_TEXT_PER_MESSAGE_CAP,
+  collectMatchText,
+  deriveGatewaySessionKey,
+  deriveSubscriptionSessionKey,
+  flattenMatchText
+} from "./chunk-GFIZ6LQI.js";
 import {
-  AnthropicTransformer,
-  resolveAnthropicMaxTokens
-} from "./chunk-EUZRH544.js";
+  DEFAULT_SEARCH_FRONTEND_MODES,
+  SEARCH_UNSUPPORTED_CAPABILITY_CODE,
+  normalizeSearchFrontendModes,
+  searchErrorHttpStatus,
+  searchRuntimeAsWebSearchBackend,
+  validateSearchFrontendModes
+} from "./chunk-MZEGQSKQ.js";
 import {
-  setAnthropicPingHeartbeatMs
-} from "./chunk-LFEH7CEO.js";
+  streamSSEResponse
+} from "./chunk-VVEHS2LI.js";
 import {
   DEFAULT_CODEX_CLI_HEADERS,
-  NEVER_FORWARD_HEADERS,
   codexAcceptHeader,
-  extractCodexClientHeaders,
-  fillMissingHeaders,
-  flattenHeaderValue
-} from "./chunk-ECZ3ZE2C.js";
+  extractCodexClientHeaders
+} from "./chunk-M6PKXP6T.js";
 import {
   getSharedIdentityStore
 } from "./chunk-XTEI64OU.js";
@@ -44,12 +52,13 @@ import {
   captureCallerIdentity
 } from "./chunk-XX6NQJMA.js";
 import {
-  MATCH_TEXT_PER_MESSAGE_CAP,
-  collectMatchText,
-  deriveGatewaySessionKey,
-  deriveSubscriptionSessionKey,
-  flattenMatchText
-} from "./chunk-GFIZ6LQI.js";
+  extractOpenCodeSessionHeader
+} from "./chunk-HRBXQ5AC.js";
+import {
+  NEVER_FORWARD_HEADERS,
+  fillMissingHeaders,
+  flattenHeaderValue
+} from "./chunk-ONTTXSRL.js";
 import {
   emitWebhookEvent
 } from "./chunk-OE6TDIWW.js";
@@ -78,17 +87,17 @@ import {
 } from "./chunk-V2UKUTJ3.js";
 import {
   SubscriptionAuthSource
-} from "./chunk-HDXSPXIN.js";
+} from "./chunk-ZBDDPWVQ.js";
 import {
   serializeError
 } from "./chunk-AVYJ4YBN.js";
-import {
-  isAccountAllowanceExhaustedError
-} from "./chunk-C3NPMQTK.js";
 import {
   boundAccountSelectionMessage,
   isBoundAccountSelectionError
 } from "./chunk-2JYRIADS.js";
+import {
+  isAccountAllowanceExhaustedError
+} from "./chunk-JHJRZ75C.js";
 import {
   beginAuditCapture
 } from "./chunk-6OKXH2TW.js";
@@ -109,10 +118,14 @@ import {
   parseModelRef,
   resolvePrefixTarget,
   resolveRoute
-} from "./chunk-QRXOLINS.js";
+} from "./chunk-ZMERU7D3.js";
 import {
   getSubscriptionRegistryForOutbound
 } from "./chunk-AQ5TNQB7.js";
+import {
+  DEFAULT_IMAGE_MODEL_ROUTES,
+  IMAGE_PROVIDER_IDS
+} from "./chunk-6I4SAWCN.js";
 import {
   applyAugmentation
 } from "./chunk-Y7FO65VT.js";
@@ -132,15 +145,18 @@ import {
   convertAnthropicToOpenAI,
   convertOpenAIToAnthropic
 } from "./chunk-5NJLQ6T6.js";
+import {
+  getAntigravityProjectResolver
+} from "./chunk-EE7VP4O3.js";
 import {
   resolveReasoningPlan
 } from "./chunk-ZLNHPUFA.js";
 import {
   fetchUpstream
-} from "./chunk-5DJSOFEP.js";
+} from "./chunk-NTF7TLT7.js";
 import {
   getSharedAccountAllowanceStore
-} from "./chunk-PF7YQBKX.js";
+} from "./chunk-FYPKKMB3.js";
 import {
   getSharedAccountRouteActivity
 } from "./chunk-GL6XM527.js";
@@ -150,7 +166,7 @@ import {
   imageGenerationErrorFromPublic,
   isImageGenerationError,
   normalizeImageGenerationError
-} from "./chunk-LQYS2N47.js";
+} from "./chunk-4RM22ETG.js";
 import {
   OpenAIOperationError,
   classifyOpenAIOperation,
@@ -1535,14 +1551,14 @@ async function buildSubscriptionPlan(res, route, deps, anthropicBody, routeModel
     scenario = mapped.scenario;
   }
   const sessionKey = deriveSubscriptionSessionKey(anthropicBody);
-  const plan = buildSubscriptionIterationPlan(profile, route, deps, resolvedModel, isStream, scenario, sessionKey);
+  const plan = await buildSubscriptionIterationPlan(profile, route, deps, resolvedModel, isStream, scenario, sessionKey);
   if (!plan) {
     writeError(res, 502, "Subscription profile is missing resolveUpstreamUrl");
     return null;
   }
   return plan;
 }
-function buildSubscriptionIterationPlan(profile, route, deps, resolvedModel, isStream, scenario, sessionKey) {
+async function buildSubscriptionIterationPlan(profile, route, deps, resolvedModel, isStream, scenario, sessionKey) {
   const upstreamUrl = profile.resolveUpstreamUrl?.(resolvedModel, route.subscriptionConfig);
   if (!upstreamUrl) return null;
   const auth = route.auth ?? new SubscriptionAuthSource(profile);
@@ -1563,11 +1579,30 @@ function buildSubscriptionIterationPlan(profile, route, deps, resolvedModel, isS
     apiKey: "",
     models: [resolvedModel]
   };
+  let antigravityAccountId;
+  if (profile.authStrategy.providerId === "antigravity") {
+    const headers = {};
+    await auth.applyHeaders(headers, {
+      upstreamUrl,
+      model: resolvedModel,
+      sessionKey,
+      preferredAccountId: route.preferredAccountId,
+      preferredAccountGroup: route.preferredAccountGroup,
+      boundAccountFallbackPolicy: route.boundAccountFallbackPolicy,
+      reportSelection: (accountId) => {
+        antigravityAccountId = accountId;
+      }
+    });
+    const bearer = (headers.Authorization ?? headers.authorization ?? "").replace(/^Bearer\s+/i, "").trim();
+    if (bearer) {
+      transformerProvider.geminiProject = await getAntigravityProjectResolver().resolveProject(bearer);
+    }
+  }
   return {
     auth,
-    preferredAccountId: route.preferredAccountId,
-    preferredAccountGroup: route.preferredAccountGroup,
-    boundAccountFallbackPolicy: route.boundAccountFallbackPolicy,
+    preferredAccountId: antigravityAccountId ?? route.preferredAccountId,
+    preferredAccountGroup: antigravityAccountId ? void 0 : route.preferredAccountGroup,
+    boundAccountFallbackPolicy: antigravityAccountId ? "strict" : route.boundAccountFallbackPolicy,
     chain,
     transformerProvider,
     resolvedModel,
@@ -1631,7 +1666,7 @@ function collectText(value) {
 function proxyProviderId(plan) {
   return plan.isSubscription ? plan.transformerProvider.name : "byo";
 }
-async function runPipeline(anthropicBody, plan, reportSelection, signal) {
+async function runPipeline(anthropicBody, plan, reportSelection, signal, callerOpenCodeSession) {
   const executor = getSharedExecutor();
   const endpointTransformer = getAnthropicEndpointTransformer();
   const { auth, chain, transformerProvider, resolvedModel, isStream, resolveUrl, upstreamUrl } = plan;
@@ -1641,6 +1676,7 @@ async function runPipeline(anthropicBody, plan, reportSelection, signal) {
     upstreamUrl,
     model: resolvedModel,
     sessionKey: plan.sessionKey,
+    callerOpenCodeSession,
     preferredAccountId: plan.preferredAccountId,
     preferredAccountGroup: plan.preferredAccountGroup,
     boundAccountFallbackPolicy: plan.boundAccountFallbackPolicy,
@@ -1649,6 +1685,10 @@ async function runPipeline(anthropicBody, plan, reportSelection, signal) {
       reportSelection?.(accountId, isActive);
     }
   });
+  if (plan.transformerProvider.name === "antigravity") {
+    const bearer = (authHeaders.Authorization ?? authHeaders.authorization ?? "").replace(/^Bearer\s+/i, "").trim();
+    if (bearer) transformerProvider.geminiProject = await getAntigravityProjectResolver().resolveProject(bearer);
+  }
   let rawStatus = null;
   let activityRecordId;
   const { response } = await executeProviderCall({
@@ -1702,6 +1742,7 @@ async function runSubscriptionSameFormatFetch(rawBody, plan, reportSelection, op
     upstreamUrl: plan.upstreamUrl,
     model: plan.resolvedModel,
     sessionKey: plan.sessionKey,
+    callerOpenCodeSession: options.callerOpenCodeSession ?? void 0,
     preferredAccountId: plan.preferredAccountId,
     preferredAccountGroup: plan.preferredAccountGroup,
     boundAccountFallbackPolicy: plan.boundAccountFallbackPolicy,
@@ -1782,7 +1823,13 @@ async function runSubscriptionAttemptWith401Retry(anthropicBody, relayBody, plan
   const reportSelection = (accountId) => {
     selectedAccountId = accountId;
   };
-  const runOnce = () => plan.sameFormat ? runSubscriptionSameFormatFetch(relayBody, plan, reportSelection, options) : runPipeline(anthropicBody, plan, reportSelection, options.signal);
+  const runOnce = () => plan.sameFormat ? runSubscriptionSameFormatFetch(relayBody, plan, reportSelection, options) : runPipeline(
+    anthropicBody,
+    plan,
+    reportSelection,
+    options.signal,
+    options.callerOpenCodeSession ?? void 0
+  );
   const first = await runOnce();
   let result = first;
   if (first.rawStatus === 401) {
@@ -1870,8 +1917,27 @@ async function runPipelineWithSubscriptionRetry(anthropicBody, rawBody, initialP
   };
   if (!profile?.nextFallback || scenario === void 0) {
     const loneBody = initialPlan.sameFormat ? anthropicBody : await prepareTranslateAttempt(anthropicBody);
-    const loneOutcome = await runSubscriptionAttemptOutcome(loneBody, rawBody, initialPlan, options);
+    let loneOutcome = await runSubscriptionAttemptOutcome(loneBody, rawBody, initialPlan, options);
     if (!clientGone()) recordBreakerOutcome(profile, initialPlan.resolvedModel, outcomeStatus(loneOutcome));
+    if (initialPlan.transformerProvider.name === "antigravity" && !clientGone() && outcomeStatus(loneOutcome) !== null && !is2xxStatus(outcomeStatus(loneOutcome))) {
+      const bodyText = loneOutcome.kind === "result" ? await readBoundedBody(loneOutcome.result.response) : void 0;
+      const failoverUrl = maybeAntigravityFailoverUrl(
+        initialPlan.upstreamUrl,
+        outcomeStatus(loneOutcome),
+        bodyText
+      );
+      if (failoverUrl) {
+        console.warn(
+          `[ProviderProxy:anthropic] antigravity endpoint failover -> ${failoverUrl} after ${outcomeStatus(loneOutcome)}`
+        );
+        if (loneOutcome.kind === "result") await cancelDiscardedResponse(loneOutcome.result.response);
+        const failoverPlan = withUpstreamUrl(initialPlan, failoverUrl);
+        loneOutcome = await runSubscriptionAttemptOutcome(loneBody, rawBody, failoverPlan, options);
+        if (!clientGone()) {
+          recordBreakerOutcome(profile, failoverPlan.resolvedModel, outcomeStatus(loneOutcome));
+        }
+      }
+    }
     return settleOutcome(loneOutcome);
   }
   const attempted = [];
@@ -1881,7 +1947,7 @@ async function runPipelineWithSubscriptionRetry(anthropicBody, rawBody, initialP
   if (profile.allowModel && !profile.allowModel(initialPlan.resolvedModel)) {
     attempted.push(initialPlan.resolvedModel);
     const firstAdmitting = profile.nextFallback(scenario, attempted, route.subscriptionConfig);
-    const gatedPlan = firstAdmitting ? buildSubscriptionIterationPlan(profile, route, deps, firstAdmitting.modelId, initialPlan.isStream, scenario, initialPlan.sessionKey) : null;
+    const gatedPlan = firstAdmitting ? await buildSubscriptionIterationPlan(profile, route, deps, firstAdmitting.modelId, initialPlan.isStream, scenario, initialPlan.sessionKey) : null;
     if (firstAdmitting && gatedPlan) {
       console.warn(
         `[ProviderProxy:anthropic] subscription primary ${initialPlan.resolvedModel} circuit open -> first admitting fallback ${firstAdmitting.modelId}`
@@ -1907,7 +1973,7 @@ async function runPipelineWithSubscriptionRetry(anthropicBody, rawBody, initialP
     if (!isFallbackEligibleStatus(outcomeStatus(outcome))) return settleOutcome(outcome);
     const next = profile.nextFallback(scenario, attempted, route.subscriptionConfig);
     if (!next) return settleOutcome(outcome);
-    const nextPlan = buildSubscriptionIterationPlan(
+    const nextPlan = await buildSubscriptionIterationPlan(
       profile,
       route,
       deps,
@@ -1931,6 +1997,28 @@ async function runPipelineWithSubscriptionRetry(anthropicBody, rawBody, initialP
   }
   return settleOutcome(outcome);
 }
+function is2xxStatus(status) {
+  return status !== null && status >= 200 && status < 300;
+}
+function withUpstreamUrl(plan, url) {
+  return {
+    ...plan,
+    upstreamUrl: url,
+    resolveUrl: (config) => {
+      const resolved = plan.resolveUrl(config);
+      if (typeof resolved === "string" && resolved.includes("googleapis.com")) {
+        try {
+          const original = new URL(resolved);
+          const target = new URL(url);
+          return `${target.origin}${original.pathname}${original.search}`;
+        } catch {
+          return url;
+        }
+      }
+      return resolved || url;
+    }
+  };
+}
 var MAX_FALLBACK_ATTEMPTS = 3;
 
 // src/provider-proxy/ingress/anthropicPdfText.ts
@@ -2822,14 +2910,27 @@ async function buildSubscriptionPlan2(route, deps, resolved, resolvedModel, isSt
       boundAccountFallbackPolicy: affinity ? "strict" : route.boundAccountFallbackPolicy
     });
   }
+  let antigravityAccountId;
+  if (profile.authStrategy.providerId === "antigravity") {
+    transformerProvider.geminiProject = await resolveAntigravityProjectThreaded(profile, {
+      sessionKey,
+      resolvedModel,
+      reportSelection: (accountId) => {
+        antigravityAccountId = accountId;
+      },
+      preferredAccountId: affinityAccountId ?? route.preferredAccountId,
+      preferredAccountGroup: affinity ? void 0 : route.preferredAccountGroup,
+      boundAccountFallbackPolicy: affinity ? "strict" : route.boundAccountFallbackPolicy
+    });
+  }
   return {
     profile: resolved.profile,
     auth,
     sessionKey,
     sessionSource,
-    preferredAccountId: affinityAccountId ?? route.preferredAccountId,
-    preferredAccountGroup: affinity ? void 0 : route.preferredAccountGroup,
-    boundAccountFallbackPolicy: affinity ? "strict" : route.boundAccountFallbackPolicy,
+    preferredAccountId: antigravityAccountId ?? affinityAccountId ?? route.preferredAccountId,
+    preferredAccountGroup: antigravityAccountId || affinity ? void 0 : route.preferredAccountGroup,
+    boundAccountFallbackPolicy: antigravityAccountId || affinity ? "strict" : route.boundAccountFallbackPolicy,
     chain,
     transformerProvider,
     resolvedModel,
@@ -2839,6 +2940,9 @@ async function buildSubscriptionPlan2(route, deps, resolved, resolvedModel, isSt
     proxyProviderId: profile.authStrategy.providerId,
     providerIdentity: resolved.providerIdentity,
     callerClientHeaders: profile.authStrategy.providerId === "codex" ? extractCodexClientHeaders(requestHeaders) : void 0,
+    // opencodego-egress-identity: the caller's own session id, forwarded
+    // verbatim to opencode.ai (the codex callerClientHeaders precedent).
+    callerOpenCodeSession: profile.authStrategy.providerId === "opencodego" ? extractOpenCodeSessionHeader(requestHeaders) : void 0,
     statefulContinuation: !!affinity,
     credential: affinityAccountId ? { kind: "subscription-account", id: affinityAccountId } : { kind: "subscription-account", id: "pending-selection" }
   };
@@ -2850,6 +2954,13 @@ async function resolveGeminiProject(profile, hints) {
   if (!accessToken) return void 0;
   return getGeminiCodeAssistResolver()?.resolveProject(accessToken);
 }
+async function resolveAntigravityProjectThreaded(profile, hints) {
+  const headers = {};
+  await profile.authStrategy.applyHeaders(headers, hints);
+  const accessToken = (headers.Authorization ?? headers.authorization ?? "").replace(/^Bearer\s+/i, "").trim();
+  if (!accessToken) return void 0;
+  return getAntigravityProjectResolver().resolveProject(accessToken);
+}
 async function executeResponsesUpstream(body, plan, operation, signal) {
   const run = () => plan.profile === "native" ? runNative(body, plan, operation, signal) : runReduced(body, plan, signal);
   let result = await run();
@@ -2882,6 +2993,7 @@ async function applyPlanAuth(body, plan) {
     upstreamUrl: plan.upstreamUrl,
     model: plan.resolvedModel,
     sessionKey: plan.sessionKey,
+    callerOpenCodeSession: plan.callerOpenCodeSession,
     preferredAccountId: plan.preferredAccountId,
     preferredAccountGroup: plan.preferredAccountGroup,
     boundAccountFallbackPolicy: plan.boundAccountFallbackPolicy,
@@ -2936,6 +3048,10 @@ async function runNative(body, plan, operation, signal) {
 async function runReduced(body, plan, signal) {
   throwIfResponsesAborted(signal);
   const { headers: authHeaders, accountId, actualModel } = await applyPlanAuth(body, plan);
+  if (plan.proxyProviderId === "antigravity") {
+    const bearer = (authHeaders.Authorization ?? authHeaders.authorization ?? "").replace(/^Bearer\s+/i, "").trim();
+    if (bearer) plan.transformerProvider.geminiProject = await getAntigravityProjectResolver().resolveProject(bearer);
+  }
   let rawStatus = null;
   let activityRecordId;
   const { response } = await executeProviderCall({
@@ -2955,26 +3071,28 @@ async function runReduced(body, plan, signal) {
       decorateCodexHeaders(headers, plan);
       return headers;
     },
-    fetchFn: (url, headers, requestBody) => fetchUpstream(
-      url,
-      { method: "POST", headers, body: JSON.stringify(requestBody), signal },
-      {
-        providerId: plan.proxyProviderId,
-        accountId,
-        routeActivity: plan.proxyProviderId === "byo" ? void 0 : {
-          endpoint: "responses",
-          sessionKey: plan.sessionKey,
-          sessionSource: plan.sessionSource ?? "none",
-          model: actualModel,
-          onRecorded: (record5) => {
-            activityRecordId = record5.id;
+    fetchFn: async (url, headers, requestBody) => {
+      const send = (target) => fetchUpstream(
+        target,
+        { method: "POST", headers, body: JSON.stringify(requestBody), signal },
+        {
+          providerId: plan.proxyProviderId,
+          accountId,
+          routeActivity: plan.proxyProviderId === "byo" ? void 0 : {
+            endpoint: "responses",
+            sessionKey: plan.sessionKey,
+            sessionSource: plan.sessionSource ?? "none",
+            model: actualModel,
+            onRecorded: (record5) => {
+              activityRecordId = record5.id;
+            }
           }
         }
-      }
-    ).then((upstream) => {
+      );
+      const upstream = plan.proxyProviderId === "antigravity" ? await fetchWithAntigravityFailover(url, send, signal) : await send(url);
       rawStatus = upstream.status;
       return upstream;
-    }),
+    },
     runResponseChain: true,
     preserveEndpointRequestForResponseChain: true
   });
@@ -4491,11 +4609,13 @@ async function handleAnthropicMessagesRequest(req, res, route, deps) {
       const callerAnthropicVersion = Array.isArray(callerVersionRaw) ? callerVersionRaw.join(",") : callerVersionRaw;
       const callerIdentity = captureCallerIdentity(getSharedIdentityStore(), request.headers);
       const callerClientHeaders = extractClaudeClientHeaders(request.headers);
+      const callerOpenCodeSession = extractOpenCodeSessionHeader(request.headers);
       await handleAnthropicCountTokens(res, rawBody, route, deps, {
         callerAnthropicBeta,
         callerAnthropicVersion,
         callerIdentity,
         callerClientHeaders,
+        callerOpenCodeSession,
         signal: scope.signal
       });
     } catch (error) {
@@ -4534,11 +4654,13 @@ async function handleAnthropicMessagesRequest(req, res, route, deps) {
       const callerAnthropicVersion = Array.isArray(callerVersionRaw) ? callerVersionRaw.join(",") : callerVersionRaw;
       const callerIdentity = captureCallerIdentity(getSharedIdentityStore(), request.headers);
       const callerClientHeaders = extractClaudeClientHeaders(request.headers);
+      const callerOpenCodeSession = extractOpenCodeSessionHeader(request.headers);
       await handleAnthropicMessagesByo(res, rawBody, route, deps, {
         callerAnthropicBeta,
         callerAnthropicVersion,
         callerIdentity,
         callerClientHeaders,
+        callerOpenCodeSession,
         signal: scope.signal
       });
     } catch (error) {
@@ -7264,6 +7386,8 @@ import {
 } from "@omnicross/contracts/webhook-types";
 
 // src/outbound-api/imagesServerConfig.ts
+var DEFAULT_CODEX_IMAGE_MODEL = "gpt-image-2";
+var DEFAULT_CODEX_CARRIER_MODEL = "gpt-5.6-luna";
 var MIB = 1024 * 1024;
 var GIB = 1024 * MIB;
 var IMAGE_SERVER_HARD_CEILINGS = Object.freeze({
@@ -7318,9 +7442,13 @@ var IMAGE_SERVER_HARD_CEILINGS = Object.freeze({
 });
 var DEFAULT_IMAGES_SERVER_CONFIG = Object.freeze({
   enabled: false,
-  provider: "codex-subscription",
+  models: Object.freeze({ ...DEFAULT_IMAGE_MODEL_ROUTES }),
   defaultModel: "gpt-image-2",
-  modelAliases: Object.freeze({}),
+  aliases: Object.freeze({}),
+  codex: Object.freeze({
+    imageModel: DEFAULT_CODEX_IMAGE_MODEL,
+    carrierModel: DEFAULT_CODEX_CARRIER_MODEL
+  }),
   account: Object.freeze({ fallback: "strict" }),
   queue: Object.freeze({
     maxConcurrentJobsPerAccount: 1,
@@ -7365,17 +7493,48 @@ function safeIdentifier(value) {
   const trimmed = value.trim();
   return trimmed && trimmed.length <= 256 && !/[\u0000-\u001f\u007f]/u.test(trimmed) ? trimmed : void 0;
 }
-function normalizedAliases(value) {
+function normalizedAliases(value, routedModels) {
   const aliases = {};
   const raw = record3(value);
   if (!raw) return aliases;
   for (const [alias, target] of Object.entries(raw)) {
     if (SAFE_OBJECT_KEYS.has(alias) || !MODEL_ID.test(alias)) continue;
     if (typeof target !== "string" || !MODEL_ID.test(target)) continue;
+    if (!routedModels.has(target)) continue;
     aliases[alias] = target;
   }
   return aliases;
 }
+function normalizedRoutes(raw) {
+  const registered = new Set(IMAGE_PROVIDER_IDS);
+  const routes = {};
+  const modelsRaw = record3(raw["models"]);
+  if (modelsRaw) {
+    for (const [model, provider] of Object.entries(modelsRaw)) {
+      if (SAFE_OBJECT_KEYS.has(model) || !MODEL_ID.test(model)) continue;
+      if (typeof provider !== "string" || !registered.has(provider)) continue;
+      routes[model] = provider;
+    }
+  }
+  const legacyProvider = raw["provider"];
+  const legacyValid = legacyProvider === "codex-subscription" || legacyProvider === void 0;
+  if (!legacyValid) return { ...DEFAULT_IMAGE_MODEL_ROUTES };
+  if (Object.keys(routes).length > 0) return routes;
+  const defaultModel = typeof raw["defaultModel"] === "string" && MODEL_ID.test(raw["defaultModel"]) ? raw["defaultModel"] : "gpt-image-2";
+  const migrated = { [defaultModel]: "codex-subscription" };
+  const legacyAliases = record3(raw["modelAliases"]);
+  if (legacyAliases) {
+    for (const [alias, target] of Object.entries(legacyAliases)) {
+      if (typeof target === "string" && MODEL_ID.test(target) && !SAFE_OBJECT_KEYS.has(alias) && MODEL_ID.test(alias)) {
+        migrated[target] = "codex-subscription";
+      }
+    }
+  }
+  if (legacyProvider !== void 0 || raw["modelAliases"] !== void 0 || raw["defaultModel"] !== void 0) {
+    return migrated;
+  }
+  return { ...DEFAULT_IMAGE_MODEL_ROUTES };
+}
 function normalizeImagesServerConfig(value) {
   const raw = record3(value) ?? {};
   const accountRaw = record3(raw["account"]) ?? {};
@@ -7528,16 +7687,20 @@ function normalizeImagesServerConfig(value) {
   if (typeof referencesRaw["storageRoot"] === "string" && referencesRaw["storageRoot"].trim()) {
     references.storageRoot = referencesRaw["storageRoot"].trim();
   }
-  const defaultModel = typeof raw["defaultModel"] === "string" && MODEL_ID.test(raw["defaultModel"]) ? raw["defaultModel"] : DEFAULT_IMAGES_SERVER_CONFIG.defaultModel;
-  const aliases = normalizedAliases(raw["modelAliases"]);
-  for (const alias of Object.keys(aliases)) {
-    if (aliases[alias] !== defaultModel) delete aliases[alias];
-  }
+  const models = normalizedRoutes(raw);
+  const defaultModel = typeof raw["defaultModel"] === "string" && MODEL_ID.test(raw["defaultModel"]) && (raw["provider"] !== void 0 || Object.keys(models).includes(raw["defaultModel"])) ? raw["defaultModel"] : DEFAULT_IMAGES_SERVER_CONFIG.defaultModel;
+  const aliases = normalizedAliases(raw["aliases"] ?? raw["modelAliases"], new Set(Object.keys(models)));
+  const codexRaw = record3(raw["codex"]) ?? {};
+  const codex = {
+    imageModel: typeof codexRaw["imageModel"] === "string" && MODEL_ID.test(codexRaw["imageModel"]) ? codexRaw["imageModel"] : DEFAULT_IMAGES_SERVER_CONFIG.codex.imageModel,
+    carrierModel: typeof codexRaw["carrierModel"] === "string" && MODEL_ID.test(codexRaw["carrierModel"]) ? codexRaw["carrierModel"] : DEFAULT_IMAGES_SERVER_CONFIG.codex.carrierModel
+  };
   return {
     enabled: raw["enabled"] === true,
-    provider: "codex-subscription",
+    models,
     defaultModel,
-    modelAliases: aliases,
+    aliases,
+    codex,
     account,
     queue,
     temporary,
@@ -7553,9 +7716,10 @@ function normalizeImagesServerConfig(value) {
 }
 var TOP_LEVEL_KEYS = [
   "enabled",
-  "provider",
+  "models",
   "defaultModel",
-  "modelAliases",
+  "aliases",
+  "codex",
   "account",
   "queue",
   "temporary",
@@ -7614,20 +7778,45 @@ function validateImagesServerConfig(value) {
   if (!raw) return errors;
   rejectUnknown(raw, TOP_LEVEL_KEYS, "images", errors);
   if (typeof raw["enabled"] !== "boolean") errors.push("images.enabled must be a boolean");
-  if (raw["provider"] !== "codex-subscription") {
-    errors.push("images.provider must be 'codex-subscription'");
+  const models = requireRecord(raw["models"], "images.models", errors);
+  let modelKeys = /* @__PURE__ */ new Set();
+  if (models) {
+    if (Object.keys(models).length === 0) {
+      errors.push("images.models must route at least one model");
+    }
+    for (const [model, provider] of Object.entries(models)) {
+      if (SAFE_OBJECT_KEYS.has(model) || !MODEL_ID.test(model)) {
+        errors.push("images.models contains an invalid model id");
+        continue;
+      }
+      modelKeys.add(model);
+      if (!IMAGE_PROVIDER_IDS.includes(provider)) {
+        errors.push(`images.models.${model} must target one of: ${IMAGE_PROVIDER_IDS.join(", ")}`);
+      }
+    }
   }
-  if (raw["defaultModel"] !== "gpt-image-2") {
-    errors.push("images.defaultModel must be 'gpt-image-2'");
+  if (typeof raw["defaultModel"] !== "string" || !MODEL_ID.test(raw["defaultModel"])) {
+    errors.push("images.defaultModel must be a valid model id");
+  } else if (models && !modelKeys.has(raw["defaultModel"])) {
+    errors.push("images.defaultModel must be a key of images.models");
   }
-  const aliases = requireRecord(raw["modelAliases"], "images.modelAliases", errors);
+  const aliases = requireRecord(raw["aliases"], "images.aliases", errors);
   if (aliases) {
     for (const [alias, target] of Object.entries(aliases)) {
       if (SAFE_OBJECT_KEYS.has(alias) || !MODEL_ID.test(alias)) {
-        errors.push("images.modelAliases contains an invalid alias");
+        errors.push("images.aliases contains an invalid alias");
       }
-      if (target !== raw["defaultModel"]) {
-        errors.push(`images.modelAliases.${alias} must target the configured default model`);
+      if (typeof target !== "string" || !MODEL_ID.test(target) || models && !modelKeys.has(target)) {
+        errors.push(`images.aliases.${alias} must target a key of images.models`);
+      }
+    }
+  }
+  const codex = requireRecord(raw["codex"], "images.codex", errors);
+  if (codex) {
+    rejectUnknown(codex, ["imageModel", "carrierModel"], "images.codex", errors);
+    for (const key of ["imageModel", "carrierModel"]) {
+      if (typeof codex[key] !== "string" || !MODEL_ID.test(codex[key])) {
+        errors.push(`images.codex.${key} must be a valid model id`);
       }
     }
   }
@@ -9846,7 +10035,7 @@ async function writeModelsList(res, llmConfig, config, apiKeyId, allowedEndpoint
       );
     }
   }
-  modelIds.push(...imageModels.filter((modelId) => modelId === "gpt-image-2"));
+  modelIds.push(...imageModels);
   const seen = /* @__PURE__ */ new Set();
   const data = modelIds.filter((modelId) => {
     if (seen.has(modelId)) return false;