@bitkyc08/opencodex 2.7.1 → 2.7.2

package/src/codex/catalog.ts

@@ -6,7 +6,6 @@ import { atomicWriteFile, expandUserPath, getConfigDir, websocketsEnabled } from
 import { CODEX_CONFIG_PATH, CODEX_MODELS_CACHE_PATH, DEFAULT_CATALOG_PATH, readRootTomlString, resolveCodexConfigPath } from "./paths";
 import { DEFAULT_MODEL_CACHE_TTL_MS, getFreshCached, getStaleCached, isModelsFetchCoolingDown, markModelsFetchFailure, setCached } from "./model-cache";
 import { buildModelsRequest, resolveModelsAuthToken } from "../oauth";
-import { effectiveGoogleMode } from "../providers/registry";
 import type { OcxConfig, OcxProviderConfig } from "../types";
 import { modelInList } from "../types";
 import { CODEX_REASONING_LEVELS, configuredReasoningEfforts, modelRecordValue, sanitizeCodexReasoningEfforts } from "../reasoning-effort";
@@ -254,6 +253,30 @@ function shouldUpgradeToUpstreamEntry(entry: RawEntry): boolean {
     && entry.display_name === entry.slug;
 }
 
+/**
+ * Reasoning efforts each requested slug advertises in the INJECTED on-disk catalog —
+ * the exact list codex-rs validates spawn_agent `reasoning_effort` arguments against
+ * (unsupported rungs are then clamped on the wire, nativeEffortClamp/adapters).
+ * Slugs missing from the catalog are omitted from the result. Used by the delegation
+ * prompt to advertise the featured sub-agent roster with honest effort ladders.
+ */
+export function catalogModelEfforts(slugs: readonly string[]): Map<string, string[]> {
+  const out = new Map<string, string[]>();
+  if (slugs.length === 0) return out;
+  const catalog = readCatalog(readCodexCatalogPath());
+  if (!catalog) return out;
+  const wanted = new Set(slugs);
+  for (const entry of catalog.models ?? []) {
+    if (typeof entry.slug !== "string" || !wanted.has(entry.slug)) continue;
+    const levels = Array.isArray(entry.supported_reasoning_levels)
+      ? entry.supported_reasoning_levels as Array<{ effort?: string }>
+      : [];
+    const efforts = levels.flatMap(l => typeof l.effort === "string" ? [l.effort] : []);
+    if (efforts.length > 0) out.set(entry.slug, efforts);
+  }
+  return out;
+}
+
 /**
  * The native (passthrough) OpenAI slugs to advertise — the LIVE Codex catalog's own bare slugs when
  * available, with documented Codex-native additions layered in, else the static fallback above.
@@ -937,23 +960,14 @@ type ProviderModelsApiItem = {
   };
 };
 
-/** Generative Language API `models.list` item (`{ models: [...] }`, not OpenAI's `{ data }`). */
-type GoogleModelsApiModel = {
-  name?: string;
-  inputTokenLimit?: number;
-  supportedGenerationMethods?: string[];
-};
-
-function googleModelsToApiItems(models: GoogleModelsApiModel[]): ProviderModelsApiItem[] {
-  return models
-    // Keep chat-capable models only; a model missing the field stays (defensive).
-    .filter(m => m.supportedGenerationMethods?.includes("generateContent") ?? true)
-    .map(m => ({
-      id: (m.name ?? "").replace(/^models\//, ""),
-      owned_by: "google",
-      ...(typeof m.inputTokenLimit === "number" && m.inputTokenLimit > 0 ? { context_length: m.inputTokenLimit } : {}),
-    }))
-    .filter(m => m.id.length > 0);
+function isProviderModelsApiItems(value: unknown): value is ProviderModelsApiItem[] {
+  return Array.isArray(value) && value.every(item =>
+    item !== null
+    && typeof item === "object"
+    && !Array.isArray(item)
+    && typeof (item as { id?: unknown }).id === "string"
+    && (item as { id: string }).id.trim().length > 0
+  );
 }
 
 function configuredContextWindow(prov: OcxProviderConfig, id: string): number | undefined {
@@ -1045,9 +1059,10 @@ function catalogHintsFromModelsApiItem(providerName: string, item: ProviderModel
 
 /**
  * Fetch a provider's `/models` (openai-chat style) with a TTL cache + stale fallback. Skips
- * forward-auth providers. Fresh cache → no network; live fetch → cache the merged result;
- * fetch failure → last-known-good cache (so a provider blip doesn't drop its models), else the
- * static config list. This is the per-provider half of jawcode's "always latest" resolver.
+ * forward-auth providers. Fresh cache → no network; schema-valid live fetch → cache the
+ * authoritative result; fetch failure or malformed data → last-known-good cache (so a provider
+ * blip doesn't drop its models), else the static config list. This is the per-provider half of
+ * jawcode's "always latest" resolver.
  */
 async function fetchProviderModels(name: string, prov: OcxProviderConfig, ttlMs: number, contextCap?: number): Promise<CatalogModel[]> {
   if (prov.authMode === "forward") return []; // ChatGPT backend has no /models
@@ -1065,13 +1080,16 @@ async function fetchProviderModels(name: string, prov: OcxProviderConfig, ttlMs:
     // plan (e.g. claude-fable-5) drop out instead of failing ERROR_BAD_MODEL_NAME. Fall back to the seed.
     const cachedCursor = getFreshCached(name, ttlMs);
     if (cachedCursor) return applyConfigHintsToCachedModels(name, prov, cachedCursor);
-    const liveIds = await fetchCursorUsableModels({ apiKey, baseUrl: prov.baseUrl });
-    if (liveIds) {
-      const available = filterCursorConfiguredModelsByLiveDiscovery(configured, liveIds);
+    const liveResult = await fetchCursorUsableModels({ apiKey, baseUrl: prov.baseUrl });
+    if (liveResult.ok) {
+      const available = filterCursorConfiguredModelsByLiveDiscovery(configured, liveResult.models);
       const result = available.length > 0 ? available : configured;
       setCached(name, result);
       return result;
     }
+    console.warn(
+      `[opencodex] Cursor model discovery for "${name}" failed [${liveResult.error}]${liveResult.detail ? `: ${liveResult.detail}` : ""}; using stale/static catalog degradation.`,
+    );
     const staleCursor = getStaleCached(name);
     return staleCursor ? applyConfigHintsToCachedModels(name, prov, staleCursor) : configured;
   }
@@ -1095,10 +1113,19 @@ async function fetchProviderModels(name: string, prov: OcxProviderConfig, ttlMs:
       const stale = getStaleCached(name);
       return stale ? applyConfigHintsToCachedModels(name, prov, stale, contextCap) : configured;
     }
-    const json = await res.json() as { data?: ProviderModelsApiItem[]; models?: GoogleModelsApiModel[] };
-    const items: ProviderModelsApiItem[] = effectiveGoogleMode(name, prov) === "ai-studio" && Array.isArray(json.models)
-      ? googleModelsToApiItems(json.models)
-      : (json.data ?? []);
+    const json = await res.json() as unknown;
+    const data = json !== null && typeof json === "object" && !Array.isArray(json)
+      ? (json as { data?: unknown }).data
+      : undefined;
+    if (!isProviderModelsApiItems(data)) {
+      markModelsFetchFailure(name);
+      console.warn(
+        `[opencodex] Provider model discovery for "${name}" returned malformed 2xx data; using stale/static catalog degradation.`,
+      );
+      const stale = getStaleCached(name);
+      return stale ? applyConfigHintsToCachedModels(name, prov, stale, contextCap) : configured;
+    }
+    const items = data;
     const live = items.map(m => applyProviderConfigHints(name, prov, {
       id: m.id,
       provider: name,
@@ -1106,10 +1133,18 @@ async function fetchProviderModels(name: string, prov: OcxProviderConfig, ttlMs:
       ...catalogHintsFromModelsApiItem(name, m),
     }, contextCap));
     const liveIds = new Set(live.map(m => m.id));
-    // Merge explicit config additions (e.g. a model not in the provider's /models, like a new endpoint).
-    const merged = [...live, ...configured.filter(m => !liveIds.has(m.id))];
-    setCached(name, merged);
-    return merged;
+    const droppedConfiguredIds = configured.filter(m => !liveIds.has(m.id)).map(m => m.id);
+    if (live.length === 0) {
+      console.warn(
+        `[opencodex] Provider model discovery for "${name}" returned an authoritative empty catalog; ${droppedConfiguredIds.length > 0 ? `dropping configured model ids: ${droppedConfiguredIds.join(", ")}` : "no models will be exposed"}.`,
+      );
+    } else if (droppedConfiguredIds.length > 0) {
+      console.warn(
+        `[opencodex] Provider model discovery for "${name}" omitted configured model ids; dropping them from the authoritative live catalog: ${droppedConfiguredIds.join(", ")}.`,
+      );
+    }
+    setCached(name, live);
+    return live;
   } catch {
     markModelsFetchFailure(name);
     const stale = getStaleCached(name);

package/src/config.ts

@@ -228,8 +228,31 @@ export type ConfigDiagnostics = {
   config: OcxConfig;
   source: "default" | "file" | "fallback";
   error: string | null;
+  /** Non-fatal config concerns; absent when there are no warnings. */
+  warnings?: string[];
 };
 
+function configPlaceholderWarnings(config: OcxConfig): string[] {
+  const warnings: string[] = [];
+  for (const [name, provider] of Object.entries(config.providers)) {
+    const placeholder = provider.baseUrl.match(/\{[^}]*\}/)?.[0];
+    if (placeholder) {
+      warnings.push(`providers.${name}.baseUrl contains unresolved ${placeholder}; set the real provider URL`);
+    }
+  }
+  return warnings;
+}
+
+function validFileConfigDiagnostics(config: OcxConfig): ConfigDiagnostics {
+  const warnings = configPlaceholderWarnings(config);
+  return {
+    config,
+    source: "file",
+    error: null,
+    ...(warnings.length > 0 ? { warnings } : {}),
+  };
+}
+
 function mergeConfigDefaults(parsed: unknown): unknown {
   if (!parsed || typeof parsed !== "object") return parsed;
   const defaults = getDefaultConfig();
@@ -261,12 +284,12 @@ export function readConfigDiagnostics(): ConfigDiagnostics {
     const parsed = JSON.parse(raw);
     const result = configSchema.safeParse(parsed);
     if (result.success) {
-      return { config: result.data as OcxConfig, source: "file", error: null };
+      return validFileConfigDiagnostics(result.data as OcxConfig);
     }
 
     const retryResult = configSchema.safeParse(mergeConfigDefaults(parsed));
     if (retryResult.success) {
-      return { config: retryResult.data as OcxConfig, source: "file", error: null };
+      return validFileConfigDiagnostics(retryResult.data as OcxConfig);
     }
 
     return { config: getDefaultConfig(), source: "fallback", error: schemaDiagnosticsError(result.error) };

package/src/oauth/index.ts

@@ -248,9 +248,10 @@ export async function resolveModelsAuthToken(name: string, prov: OcxProviderConf
  * LIVE catalog correctly per adapter. Anthropic is the special case: its endpoint is `/v1/models`
  * (not `/models`), it needs `anthropic-version`, and it authenticates with `x-api-key` (key) or
  * `Authorization: Bearer` + the OAuth beta (oauth) — not a bare Bearer. Google (ai-studio mode)
- * is the other special case: `x-goog-api-key` + `/v1beta/models`, returning `{ models: [...] }`
- * (parsed by the caller). Everyone else uses the OpenAI-style `/models` + Bearer with a
- * `{ data: [{ id, owned_by? }] }` response.
+ * is the other special case: `x-goog-api-key` + `/v1beta/models`, returning `{ models: [...] }`.
+ * The catalog authority gate intentionally degrades that non-OpenAI shape to stale/static data.
+ * Everyone else uses the OpenAI-style `/models` + Bearer with a `{ data: [{ id, owned_by? }] }`
+ * response.
  */
 export function buildModelsRequest(prov: OcxProviderConfig, apiKey: string | undefined, providerName = ""): { url: string; headers: Record<string, string> } {
   const headers: Record<string, string> = { ...(prov.headers ?? {}) };

package/src/oauth/key-providers.ts

@@ -72,7 +72,7 @@ export async function validateApiKey(provider: KeyLoginProvider, key: string): P
           "x-api-key": key,
         },
         body: JSON.stringify({
-          model: provider.defaultModel ?? "claude-sonnet-4-6",
+          model: provider.defaultModel ?? "claude-haiku-4-5",
           max_tokens: 1,
           messages: [{ role: "user", content: "ping" }],
         }),

package/src/oauth/kiro-credentials.ts

@@ -57,12 +57,20 @@ function stringField(data: JsonObject, ...keys: string[]): string | undefined {
   return undefined;
 }
 
-function parseExpires(value: unknown): number {
+function parseExpires(value: unknown, present: boolean, hasRefreshToken: boolean): number {
   if (typeof value === "number" && Number.isFinite(value)) return value < 10_000_000_000 ? value * 1000 : value;
   if (typeof value === "string" && value.length > 0) {
     const parsed = Date.parse(value);
     if (Number.isFinite(parsed)) return parsed;
   }
+  if (present) {
+    console.warn(
+      `[ocx:kiro:credentials] credential expiry is present but unparseable; ${
+        hasRefreshToken ? "treating credential as expired" : "using the default TTL because no refresh token is available"
+      }`,
+    );
+    if (hasRefreshToken) return 0;
+  }
   return Date.now() + DEFAULT_EXPIRES_MS;
 }
 
@@ -110,10 +118,12 @@ function credentialFromJson(data: JsonObject, source: KiroCredentialSource): Imp
   const apiRegion = stringField(data, "apiRegion", "api_region") || inferRegionFromProfileArn(profileArn) || ssoRegion;
   const clientId = stringField(data, "clientId", "client_id");
   const clientSecret = stringField(data, "clientSecret", "client_secret");
+  const refresh = stringField(data, "refreshToken", "refresh_token") || "";
+  const expiryPresent = Object.hasOwn(data, "expiresAt") || Object.hasOwn(data, "expires_at");
   return {
     access,
-    refresh: stringField(data, "refreshToken", "refresh_token") || "",
-    expires: parseExpires(data.expiresAt ?? data.expires_at),
+    refresh,
+    expires: parseExpires(data.expiresAt ?? data.expires_at, expiryPresent, refresh.length > 0),
     source,
     authType: clientId && clientSecret ? "aws_sso_oidc" : "kiro_desktop",
     ...(profileArn ? { profileArn } : {}),

package/src/providers/derive.ts

@@ -67,6 +67,8 @@ export function providerConfigSeed(entry: ProviderRegistryEntry): OcxProviderCon
     adapter: entry.adapter,
     baseUrl: entry.baseUrl,
     authMode: entry.authKind === "local" ? undefined : entry.authKind,
+    ...(entry.keyOptional !== undefined ? { keyOptional: entry.keyOptional } : {}),
+    ...(entry.modelSuffixBracketStrip !== undefined ? { modelSuffixBracketStrip: entry.modelSuffixBracketStrip } : {}),
     ...(entry.defaultModel ? { defaultModel: entry.defaultModel } : {}),
     ...(entry.models ? { models: [...entry.models] } : {}),
     ...(entry.liveModels !== undefined ? { liveModels: entry.liveModels } : {}),
@@ -189,6 +191,8 @@ export function enrichProviderFromRegistry(name: string, prov: OcxProviderConfig
   if (!prov.thinkingToggleModels && seed.thinkingToggleModels) prov.thinkingToggleModels = [...seed.thinkingToggleModels];
   if (!prov.thinkingBudgetModels && seed.thinkingBudgetModels) prov.thinkingBudgetModels = [...seed.thinkingBudgetModels];
   if (prov.escapeBuiltinToolNames === undefined && seed.escapeBuiltinToolNames !== undefined) prov.escapeBuiltinToolNames = seed.escapeBuiltinToolNames;
+  if (prov.keyOptional === undefined && seed.keyOptional !== undefined) prov.keyOptional = seed.keyOptional;
+  if (prov.modelSuffixBracketStrip === undefined && seed.modelSuffixBracketStrip !== undefined) prov.modelSuffixBracketStrip = seed.modelSuffixBracketStrip;
 }
 
 export function deriveFeaturedProviderIds(): string[] {

package/src/providers/kiro-models.ts

@@ -49,7 +49,7 @@ export const KIRO_MODEL_REASONING_EFFORTS: Record<string, string[]> = Object.fro
 export function normalizeKiroModelId(id: string): string {
   let model = id.trim().toLowerCase();
   model = model.replace(/^kiro\//, "").replace(/^kiro-/, "");
-  if (model === "auto" || model === "kiro-auto") return "auto";
+  if (model === "auto") return "auto";
 
   model = model.replace(/-\d{8}$/, "");
   model = model.replace(/-(low|medium|high|xhigh|max)$/, "");