@iislee/opencodex 2.11.0 → 2.31.0

package/src/combos/types.ts

@@ -1,4 +1,5 @@
 import { isCodexReasoningEffort } from "../reasoning-effort";
+import { SUPPORTED_NATIVE_OPENAI_SLUGS } from "../codex/catalog/native-models";
 import type {
   OcxComboConfig,
   OcxComboDefaultEffort,
@@ -24,11 +25,7 @@ const COMBO_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
  * `combo/` prefix. Codex-facing slugs tolerate at most one "/", so deeper paths reject.
  */
 const COMBO_ALIAS_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}(?:\/[A-Za-z0-9][A-Za-z0-9._-]{0,63})?$/;
-/**
- * Bare aliases in the OpenAI native family (gpt-*, o1-*, o3-*, o4-*, codex-*) are
- * rejected: they collide with native catalog rows and the canonical-OpenAI routing
- * branch, which cannot be shadowed honestly.
- */
+/** Bare aliases in this family require the explicit `nativeAlias` opt-in below. */
 const NATIVE_OPENAI_FAMILY_PATTERN = /^(?:gpt-|o1-|o3-|o4-|codex-)/;
 
 export interface ComboValidationIssue {
@@ -40,11 +37,26 @@ export interface NormalizedComboConfig {
   strategy: OcxComboStrategy;
   stickyLimit: number;
   defaultEffort: OcxComboDefaultEffort | null;
+  /** Disable image input; `auto` preserves the intersection derived from all targets. */
+  imageInput: "auto" | "disabled";
   /** Trimmed public alias, or null when the combo keeps the default `combo/<id>` slug. */
   alias: string | null;
+  /** Explicit native-family alias opt-in. */
+  nativeAlias: boolean;
+  /** Display-only label for the catalog row, or null when unset. */
+  displayName: string | null;
   targets: Array<Required<OcxComboTarget>>;
 }
 
+/** True only for an explicitly opted-in bare native-family alias. */
+export function isNativeAliasCombo(
+  combo: { alias?: string | null; nativeAlias?: boolean },
+): boolean {
+  const alias = typeof combo.alias === "string" ? combo.alias.trim() : "";
+  return combo.nativeAlias === true
+    && SUPPORTED_NATIVE_OPENAI_SLUGS.has(alias);
+}
+
 export function targetKey(target: Pick<OcxComboTarget, "provider" | "model">): string {
   return `${target.provider}/${target.model}`;
 }
@@ -66,6 +78,27 @@ export function comboPublicModelId(id: string, combo: { alias?: string | null })
   return alias || comboModelId(id);
 }
 
+/**
+ * Persisted selector that hides a combo from discovery. Native aliases keep the canonical
+ * `combo/<id>` selector because their bare public id remains the native OpenAI disable key.
+ */
+export function comboDisabledModelId(
+  id: string,
+  combo: { alias?: string | null; nativeAlias?: boolean },
+): string {
+  return isNativeAliasCombo(combo) ? comboModelId(id) : comboPublicModelId(id, combo);
+}
+
+/** Every persisted selector that can refer to this combo in `disabledModels`. */
+export function comboDisabledModelSelectors(
+  id: string,
+  combo: { alias?: string | null; nativeAlias?: boolean },
+): string[] {
+  const canonical = comboModelId(id);
+  const preferred = comboDisabledModelId(id, combo);
+  return preferred === canonical ? [canonical] : [canonical, preferred];
+}
+
 /**
  * Resolve a client-requested model id to a combo config key. The canonical `combo/<id>`
  * form wins first (back-compat); otherwise an exact alias match across configured combos.
@@ -94,7 +127,7 @@ export function comboAliasIssues(
   id: string,
   alias: string,
   combos: Record<string, OcxComboConfig> | undefined,
-  options: { excludeComboId?: string } = {},
+  options: { excludeComboId?: string; allowNativeAlias?: boolean } = {},
 ): ComboValidationIssue[] {
   const issues: ComboValidationIssue[] = [];
   if (!COMBO_ALIAS_PATTERN.test(alias)) {
@@ -110,10 +143,12 @@ export function comboAliasIssues(
       message: `alias must not use the reserved "${COMBO_NAMESPACE}/" namespace`,
     });
   }
-  if (!alias.includes("/") && NATIVE_OPENAI_FAMILY_PATTERN.test(alias)) {
+  if (!alias.includes("/")
+    && NATIVE_OPENAI_FAMILY_PATTERN.test(alias)
+    && options.allowNativeAlias !== true) {
     issues.push({
       path: ["alias"],
-      message: "bare aliases in the OpenAI native family (gpt-*, o1-*, o3-*, o4-*, codex-*) are not allowed",
+      message: "bare aliases in the OpenAI native family require nativeAlias=true",
     });
   }
   for (const [otherId, other] of Object.entries(combos ?? {})) {
@@ -187,16 +222,49 @@ export function comboConfigIssues(
       message: "defaultEffort must be one of: low, medium, high, xhigh, max, ultra",
     });
   }
+  if (body.imageInput !== undefined && body.imageInput !== "auto" && body.imageInput !== "disabled") {
+    issues.push({ path: ["imageInput"], message: 'imageInput must be "auto" or "disabled"' });
+  }
 
   if (body.alias !== undefined) {
     if (typeof body.alias !== "string") {
       issues.push({ path: ["alias"], message: "alias must be a string" });
     } else {
       const alias = body.alias.trim();
-      if (alias) issues.push(...comboAliasIssues(id, alias, options.combos, options));
+      if (alias) {
+        issues.push(...comboAliasIssues(id, alias, options.combos, {
+          ...options,
+          allowNativeAlias: body.nativeAlias === true,
+        }));
+      }
     }
   }
 
+  if (body.nativeAlias !== undefined && typeof body.nativeAlias !== "boolean") {
+    issues.push({ path: ["nativeAlias"], message: "nativeAlias must be a boolean" });
+  }
+  if (body.displayName !== undefined) {
+    if (typeof body.displayName !== "string") {
+      issues.push({ path: ["displayName"], message: "displayName must be a string" });
+    } else if (body.displayName.trim().length > 128 || /[\u0000-\u001f\u007f]/.test(body.displayName)) {
+      issues.push({
+        path: ["displayName"],
+        message: "displayName must be at most 128 characters and contain no control characters",
+      });
+    }
+  }
+  const alias = typeof body.alias === "string" ? body.alias.trim() : "";
+  const nativeAlias = body.nativeAlias === true;
+  if (nativeAlias && !SUPPORTED_NATIVE_OPENAI_SLUGS.has(alias)) {
+    issues.push({
+      path: ["nativeAlias"],
+      message: "nativeAlias requires a currently supported bare OpenAI-native model alias",
+    });
+  }
+  if (nativeAlias && (typeof body.displayName !== "string" || body.displayName.trim().length === 0)) {
+    issues.push({ path: ["displayName"], message: "displayName is required for native aliases" });
+  }
+
   if (!Array.isArray(body.targets) || body.targets.length === 0) {
     issues.push({ path: ["targets"], message: "targets must be a non-empty array" });
     return issues;
@@ -271,11 +339,15 @@ export function comboConfigError(
 
 export function normalizeComboConfig(raw: OcxComboConfig): NormalizedComboConfig {
   const alias = typeof raw.alias === "string" ? raw.alias.trim() : "";
+  const displayName = typeof raw.displayName === "string" ? raw.displayName.trim() : "";
   return {
     strategy: raw.strategy ?? "failover",
     stickyLimit: raw.stickyLimit ?? 1,
     defaultEffort: raw.defaultEffort ?? null,
+    imageInput: raw.imageInput === "disabled" ? "disabled" : "auto",
     alias: alias || null,
+    nativeAlias: raw.nativeAlias === true,
+    displayName: displayName || null,
     targets: raw.targets.map(target => ({
       provider: target.provider.trim(),
       model: target.model.trim(),

package/src/config/provider-name.ts

@@ -0,0 +1,24 @@
+const RESERVED_PROVIDER_NAMES = new Set([
+  // JavaScript prototype-pollution guards.
+  "__proto__",
+  "prototype",
+  "constructor",
+  // System-reserved routing namespace (resolved before provider/account
+  // namespaces in routeModelInternal). "combo" is intentionally NOT reserved:
+  // a physical provider named `combo` is a supported pattern (combo aliases
+  // hosted on the combo provider), and the combo selector only wins when an
+  // actual combo id matches.
+  "policy",
+]);
+const PROVIDER_NAME_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9._-]{0,62}[A-Za-z0-9])?$/;
+
+export function isValidProviderName(name: string): boolean {
+  const trimmed = name.trim();
+  return trimmed === name
+    && PROVIDER_NAME_PATTERN.test(name)
+    && !RESERVED_PROVIDER_NAMES.has(name.toLowerCase());
+}
+
+export function hasOwnProvider(providers: Record<string, unknown>, name: string): boolean {
+  return Object.prototype.hasOwnProperty.call(providers, name);
+}