@bitkyc08/opencodex 2.63.0 → 2.64.0-preview.20260923

package/src/providers/command-code-efforts.ts

@@ -1,41 +1,58 @@
 import { readBoundedResponseBody } from "../lib/bounded-body";
 
+/*
+ * Keys must match the EXACT upstream /provider/v1/models ids (GLM ships as `zai-org/GLM-5.3`, not
+ * `zai-org/glm-5.3`). The table doubles as the router's known-ids decode source (via
+ * `knownModelIdsForProvider`), so a case mismatch makes a Codex-facing slug such as
+ * `commandcode/zai-org-GLM-5.3` pass through undecoded and upstream rejects it with
+ * `unsupported_model`.
+ *
+ * PROVENANCE. commandcode.ai renders each /models/<slug> profile client-side, but the delivered HTML
+ * carries the loader data as a React Router payload: one `streamController.enqueue("<json>")` call
+ * whose JSON is an indexed value table. A model record's `reasoningEfforts` field points at an array
+ * of indices that resolve to effort names (for example the 2026-08-29 glm-5-3-flash page resolved
+ * 224=low, 225=medium, 226=high, 227=xhigh, 569=max, cross-checked six for six against committed
+ * rows). Rows marked "captured 2026-09-23" were read from that payload. On the same date a live
+ * `refreshCommandCodeReasoningEfforts` pass reproduced every other row except GLM-5, GLM-5.1 and
+ * GLM-5.2-Fast (their payload ladders are empty, so the static rows stay) and the Muse 1.x rows.
+ *
+ * The profile is Command Code's per-model statement, but /alpha/generate validates effort against
+ * one global enum (low..max) and accepts rungs a profile omits: `max` on muse-spark-1.2 and
+ * 1.3-contributor, and `high` and `max` on Qwen3.8-Flash, all returned 200 on 2026-09-23 while
+ * `ultra` returned 400. A correction therefore adds the rungs a profile newly lists and keeps the
+ * rungs the upstream measurably accepts; dropping them would strip an effort that works today,
+ * including Codex's default `high`. The refresh path decodes the same payload, so it narrows a row
+ * only after the upstream actually rejects a rung.
+ */
 const COMMAND_CODE_MODEL_EFFORTS = {
+  // Captured profile payload 2026-09-23: claude-fable-5-1.html.
+  "claude-fable-5-1": {
+    efforts: ["low", "medium", "high", "xhigh", "max"],
+    profileUrl: "https://commandcode.ai/models/claude-fable-5-1",
+  },
+  // Captured profile payload 2026-09-23: claude-opus-5-5.html.
+  "claude-opus-5-5": {
+    efforts: ["low", "medium", "high", "xhigh", "max"],
+    profileUrl: "https://commandcode.ai/models/claude-opus-5-5",
+  },
   "deepseek/deepseek-v4-flash": {
     efforts: ["high", "max"],
     profileUrl: "https://commandcode.ai/models/deepseek-v4-flash",
   },
-  /*
-   * Three live routes that reached the catalog without an effort ladder (#2647).
-   * Without a row here the model advertises no efforts at all, so a client that
-   * sends one gets it stripped or rejected rather than honored.
-   *
-   * PROVENANCE, stated plainly: these three ladders are the reporter's
-   * (darwintree, #2647), recorded as reported and NOT independently verified.
-   * All three profileUrls return HTTP 200, but commandcode.ai renders these
-   * pages client-side and ships the ladder inside a serialized React payload
-   * whose `reasoningEfforts` array is EMPTY in the delivered HTML. There is no
-   * fetchable statement of these ladders to check them against.
-   *
-   * Do not assume the refresh path launders this. It does not:
-   * `parsedProfileEfforts` below matches prose of the form
-   * "Reasoning efforts ... are supported;", and `grep -c -i 'reasoning efforts'`
-   * against the live pages returns 0 — for these three AND for the older rows
-   * (deepseek-v4-pro, GLM-5.3, muse-spark-1.2 all measured 0 on 2026-08-27).
-   * So `refreshCommandCodeReasoningEfforts` returns undefined and the caller
-   * keeps whatever is written here, indefinitely. The self-correction mechanism
-   * is currently dead for EVERY row in this table, which is a pre-existing
-   * defect worth its own fix (teach the parser to read the embedded payload),
-   * not something these three rows introduced.
-   *
-   * The practical consequence: a wrong ladder here stays wrong until a human
-   * changes it. It degrades safely — an effort the upstream rejects surfaces as
-   * an error rather than silent corruption — but it does not self-heal.
-   */
   "deepseek/deepseek-v4-flash-vision-exp": {
     efforts: ["high", "max"],
     profileUrl: "https://commandcode.ai/models/deepseek-v4-flash-vision-exp",
   },
+  // Captured profile payload 2026-09-23: deepseek-v4-flash-fast.html.
+  "deepseek/deepseek-v4-flash-fast": {
+    efforts: ["low", "high", "max"],
+    profileUrl: "https://commandcode.ai/models/deepseek-v4-flash-fast",
+  },
+  // Captured profile payload 2026-09-23: deepseek-v4-1-flash.html.
+  "deepseek/deepseek-v4.1-flash": {
+    efforts: ["low", "high", "max"],
+    profileUrl: "https://commandcode.ai/models/deepseek-v4-1-flash",
+  },
   "gpt-5.6-luna": {
     efforts: ["low", "medium", "high", "xhigh", "max"],
     profileUrl: "https://commandcode.ai/models/gpt-5-6-luna",
@@ -44,11 +61,11 @@ const COMMAND_CODE_MODEL_EFFORTS = {
     efforts: ["low", "medium", "high"],
     profileUrl: "https://commandcode.ai/models/gemini-3-7-flash",
   },
-  // Keys must match the EXACT upstream /provider/v1/models ids (GLM ships as
-  // `zai-org/GLM-5.3`, not `zai-org/glm-5.3`). The table doubles as the router's
-  // known-ids decode source (via `knownModelIdsForProvider`), so a case mismatch
-  // makes the Codex-facing slug `commandcode/zai-org-GLM-5.3` pass through
-  // undecoded and upstream rejects it with `unsupported_model`.
+  // Captured profile payload 2026-09-23: gemini-3-8-flash.html.
+  "google/gemini-3.8-flash": {
+    efforts: ["low", "medium", "high"],
+    profileUrl: "https://commandcode.ai/models/gemini-3-8-flash",
+  },
   "zai-org/GLM-5": {
     efforts: ["high", "max"],
     profileUrl: "https://commandcode.ai/models/glm-5",
@@ -69,86 +86,71 @@ const COMMAND_CODE_MODEL_EFFORTS = {
     efforts: ["low", "high", "max"],
     profileUrl: "https://commandcode.ai/models/glm-5-3",
   },
-  /*
-   * GLM-5.3-Flash (#2883). Reported as advertising NO efforts at all: the live
-   * route is `z-ai/glm-5.3-flash`, which shares neither vendor prefix nor model
-   * id with `zai-org/GLM-5.3` above, so `modelRecordValue` cannot bridge them
-   * (exact / colon-family / case-folded only — by design; a substring match here
-   * would merge two genuinely different models across two vendor namespaces).
-   *
-   * PROVENANCE: unlike the #2647 rows above, this ladder is MEASURED, not
-   * reported. commandcode.ai renders the profile client-side, but the delivered
-   * HTML ships a serialized React payload whose string table can be read
-   * directly: in the 2026-08-29 fetch of /models/glm-5-3-flash (HTTP 200,
-   * 228749 bytes) the indices resolve as 224=low, 225=medium, 226=high,
-   * 227=xhigh, 569=max, and this model's array is [224,226,569].
-   *
-   * The index map was cross-validated against every row in this table that the
-   * same page carries: deepseek-v4-pro and -flash [226,569], gpt-5.6-luna
-   * [224,225,226,227,569], gemini-3.7-flash [224,225,226], GLM-5.2 [226,569],
-   * GLM-5.3 [224,226,569] — six for six against the values already committed
-   * here. No authenticated upstream generate probe was performed.
-   */
   "z-ai/glm-5.3-flash": {
     efforts: ["low", "high", "max"],
     profileUrl: "https://commandcode.ai/models/glm-5-3-flash",
   },
-  // Muse Spark: CLI currently prints "has no adjustable reasoning effort" and
-  // blocks --effort locally, but the upstream /alpha/generate endpoint accepts
-  // reasoning_effort low..max for meta/muse-spark-1.2-contributor (verified
-  // 2026-08-13: direct upstream POST with low/medium/high/xhigh/max all 200,
-  // ultra 400; reasoningTokens differentiated 114..253; proxy previously stripped
-  // the field so effort changes had no effect).
-  //
-  // 1.3 shipped 2026-09-02 as the same-shaped successor to 1.2 (Command Code
-  // publishes meta/muse-spark-1.3 and meta/muse-spark-1.3-contributor alongside
-  // the 1.2 pair, and Zen serves muse-spark-1.3-contributor over the same
-  // /responses wire). It carries the 1.2 ladder because it IS the 1.2 spec: the
-  // upstream ladder statement is per-family, and a narrower guess here would
-  // strip an effort the gateway accepts. Additive — 1.2 and 1.1 stay live.
+  // Captured profile payload 2026-09-23: glm-5-3-flashx.html.
+  "z-ai/glm-5.3-flashx": {
+    efforts: ["low", "high", "max"],
+    profileUrl: "https://commandcode.ai/models/glm-5-3-flashx",
+  },
+  // Captured profile payload 2026-09-23: muse-spark-1-3.html.
+  // Muse Spark: the Command Code CLI prints "has no adjustable reasoning effort", but /alpha/generate
+  // accepts reasoning_effort for these routes (verified 2026-08-13 on 1.2-contributor: low..max 200,
+  // ultra 400), so the table, not the CLI, is the ladder authority.
   "meta/muse-spark-1.3": {
     efforts: ["low", "medium", "high", "xhigh", "max"],
-    profileUrl: "https://commandcode.ai/models/meta-muse-spark-1.3",
+    profileUrl: "https://commandcode.ai/models/muse-spark-1-3",
   },
+  // Captured profile payload 2026-09-23 lists low..xhigh; max stays because /alpha/generate accepts it.
   "meta/muse-spark-1.3-contributor": {
     efforts: ["low", "medium", "high", "xhigh", "max"],
-    profileUrl: "https://commandcode.ai/models/meta-muse-spark-1.3-contributor",
+    profileUrl: "https://commandcode.ai/models/muse-spark-1-3-contributor",
   },
   "meta/muse-spark-1.2": {
     efforts: ["low", "medium", "high", "xhigh", "max"],
-    profileUrl: "https://commandcode.ai/models/meta-muse-spark-1.2",
+    profileUrl: "https://commandcode.ai/models/muse-spark-1-2",
   },
   "meta/muse-spark-1.2-contributor": {
     efforts: ["low", "medium", "high", "xhigh", "max"],
-    profileUrl: "https://commandcode.ai/models/meta-muse-spark-1.2-contributor",
+    profileUrl: "https://commandcode.ai/models/muse-spark-1-2-contributor",
   },
   "meta/muse-spark-1.1": {
     efforts: ["low", "medium", "high", "xhigh", "max"],
-    profileUrl: "https://commandcode.ai/models/meta-muse-spark-1.1",
-  },
-  /*
-   * Two live routes that never gained a row here, so the adapter dropped every
-   * requested effort (a client's `max` left the wire as no reasoning parameter
-   * at all) and the preset advertised no effort control for them.
-   *
-   * PROVENANCE, stated plainly: both ladders are inferred from the same-family
-   * rows above — deepseek v4: high..max; the Qwen 3.8 family: low..max — NOT
-   * read from the profile pages. commandcode.ai renders those client-side and
-   * ships an empty reasoning payload, so the self-refresh below is as dead for
-   * these rows as the #2647 block above already documents. Measured live
-   * 2026-09-11: /alpha/generate accepts `reasoning_effort: "max"` on both
-   * routes (HTTP 200). `ultra` is deliberately not offered: the adapter would
-   * strip it, and no profile evidence backs an ultra→max alias the way it does
-   * for v4-pro/v4-flash above.
-   */
-  "deepseek/deepseek-v4.1-flash": {
-    efforts: ["high", "max"],
-    profileUrl: "https://commandcode.ai/models/deepseek-v4-1-flash",
+    profileUrl: "https://commandcode.ai/models/muse-spark-1-1",
   },
+  // Captured profile payload 2026-09-23 lists low, medium, xhigh; high and max stay because
+  // /alpha/generate accepts both (measured 2026-09-11 and 2026-09-23).
   "Qwen/Qwen3.8-Flash": {
-    efforts: ["low", "medium", "high", "max"],
+    efforts: ["low", "medium", "high", "xhigh", "max"],
     profileUrl: "https://commandcode.ai/models/qwen3-8-flash",
   },
+  // Captured profile payload 2026-09-23: qwen3-8-omni-flash.html.
+  "Qwen/Qwen3.8-Omni-Flash": {
+    efforts: ["low", "medium", "xhigh"],
+    profileUrl: "https://commandcode.ai/models/qwen3-8-omni-flash",
+  },
+  // Captured profile payload 2026-09-23: qwen3-8-max-0902.html.
+  "Qwen/Qwen3.8-Max-0902": {
+    efforts: ["low", "medium", "xhigh"],
+    profileUrl: "https://commandcode.ai/models/qwen3-8-max-0902",
+  },
+  // Captured profile payload 2026-09-23: step-5-preview.html.
+  "stepfun/Step-5-Preview": {
+    efforts: ["low", "medium", "high"],
+    profileUrl: "https://commandcode.ai/models/step-5-preview",
+  },
+  // Captured profile payload 2026-09-23: hy4-preview.html.
+  "tencent/hy4-preview": {
+    efforts: ["low", "medium", "high"],
+    profileUrl: "https://commandcode.ai/models/hy4-preview",
+  },
+  // Captured profile payload 2026-09-23: grok-4-7.html.
+  "xai/grok-4.7": {
+    efforts: ["low", "medium", "high", "xhigh"],
+    profileUrl: "https://commandcode.ai/models/grok-4-7",
+  },
 } as const;
 
 /**
@@ -160,24 +162,91 @@ export const COMMAND_CODE_MODEL_REASONING_EFFORTS: Record<string, string[]> = Ob
 );
 
 const refreshedEfforts = new Map<string, string[]>();
+const rejectedEfforts = new Map<string, Set<string>>();
+const DEFAULT_EFFORT_DESTINATION = "https://api.commandcode.ai";
 
 function keyFor(modelId: string): string {
   return modelId.trim().toLowerCase();
 }
 
-export function commandCodeReasoningEfforts(modelId: string): readonly string[] | undefined {
-  const key = keyFor(modelId);
+function cacheKey(modelId: string, destination: string): string {
+  let normalized = destination.trim().replace(/\/+$/, "");
+  try {
+    const url = new URL(destination);
+    normalized = `${url.origin}${url.pathname.replace(/\/+$/, "")}`;
+  } catch { /* Config validation owns malformed destinations. */ }
+  return JSON.stringify([normalized, keyFor(modelId)]);
+}
+
+export function commandCodeReasoningEfforts(
+  modelId: string,
+  destination = DEFAULT_EFFORT_DESTINATION,
+): readonly string[] | undefined {
+  const key = cacheKey(modelId, destination);
+  const rejected = rejectedEfforts.get(key);
   const refreshed = refreshedEfforts.get(key);
-  if (refreshed !== undefined) return refreshed;
+  if (refreshed !== undefined) return rejected ? refreshed.filter(effort => !rejected.has(effort)) : refreshed;
   // Case-insensitive: the table keys match the EXACT upstream ids (e.g. `zai-org/GLM-5.3`),
   // but callers may pass either case.
   for (const [id, efforts] of Object.entries(COMMAND_CODE_MODEL_REASONING_EFFORTS)) {
-    if (keyFor(id) === key) return efforts;
+    if (keyFor(id) === keyFor(modelId)) return rejected ? efforts.filter(effort => !rejected.has(effort)) : efforts;
   }
   return undefined;
 }
 
-function parsedProfileEfforts(page: string): string[] | undefined {
+/** Upper bound for one fetched profile page. */
+export const PROFILE_PAGE_MAX_BYTES = 512 * 1024;
+
+const PROFILE_EFFORTS = new Set(["low", "medium", "high", "xhigh", "max"]);
+
+function parsedRouterEfforts(page: string, modelId: string): string[] | undefined {
+  // React Router serializes the loader as a JSON string of an indexed value table.
+  // Object keys such as _125 and array elements are references into that table.
+  const flights = [...page.matchAll(/window\.__reactRouterContext\.streamController\.enqueue\(("(?:\\.|[^"\\])*")\);/g)];
+  if (flights.length !== 1) return undefined;
+  let values: unknown;
+  try {
+    values = JSON.parse(JSON.parse(flights[0]![1]!));
+  } catch {
+    return undefined;
+  }
+  if (!Array.isArray(values)) return undefined;
+  const table: unknown[] = values;
+  const dereference = (ref: unknown): unknown =>
+    Number.isInteger(ref) && (ref as number) >= 0 && (ref as number) < table.length
+      ? table[ref as number] : undefined;
+  let matched: string[] | undefined;
+  for (const value of table) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    const fields = new Map<string, unknown>();
+    let conflicting = false;
+    for (const [key, ref] of Object.entries(value)) {
+      if (!/^_\d+$/.test(key)) continue;
+      const name = dereference(Number(key.slice(1)));
+      if (typeof name !== "string") continue;
+      // Two keys decoding to one field name is not a record this parser understands.
+      if (fields.has(name)) conflicting = true;
+      fields.set(name, ref);
+    }
+    if (conflicting && (fields.has("id") || fields.has("reasoningEfforts"))) return undefined;
+    const id = dereference(fields.get("id"));
+    if (typeof id !== "string" || keyFor(id) !== keyFor(modelId)) continue;
+    const refs = dereference(fields.get("reasoningEfforts"));
+    if (!Array.isArray(refs) || refs.length === 0) return undefined;
+    const efforts = refs.map(dereference);
+    if (efforts.some(effort => typeof effort !== "string" || !PROFILE_EFFORTS.has(effort)) ||
+        new Set(efforts).size !== efforts.length) return undefined;
+    const complete = efforts as string[];
+    if (matched && JSON.stringify(matched) !== JSON.stringify(complete)) return undefined;
+    matched = complete;
+  }
+  return matched;
+}
+
+function parsedProfileEfforts(page: string, modelId: string): string[] | undefined {
+  if (page.includes("window.__reactRouterContext.streamController.enqueue(")) {
+    return parsedRouterEfforts(page, modelId);
+  }
   const match = page.match(/Reasoning efforts\s+([^.;]+?)\s+are supported;\s*([^.]*)/i);
   if (!match) return undefined;
   const listed = match[1]!.toLowerCase().match(/\b(?:low|medium|high|xhigh|max)\b/g) ?? [];
@@ -200,16 +269,23 @@ function parsedProfileEfforts(page: string): string[] | undefined {
 export async function refreshCommandCodeReasoningEfforts(
   modelId: string,
   fetchFn: typeof globalThis.fetch = globalThis.fetch,
+  rejectedEffort?: string,
+  destination = DEFAULT_EFFORT_DESTINATION,
 ): Promise<readonly string[] | undefined> {
-  const key = keyFor(modelId);
+  const key = cacheKey(modelId, destination);
   let profile: { efforts: readonly string[]; profileUrl: string } | undefined;
   for (const [id, row] of Object.entries(COMMAND_CODE_MODEL_EFFORTS)) {
-    if (keyFor(id) === key) {
+    if (keyFor(id) === keyFor(modelId)) {
       profile = row;
       break;
     }
   }
   if (!profile) return undefined;
+  if (rejectedEffort) {
+    const rejected = rejectedEfforts.get(key) ?? new Set<string>();
+    rejected.add(rejectedEffort);
+    rejectedEfforts.set(key, rejected);
+  }
   try {
     const response = await fetchFn(profile.profileUrl, {
       headers: { Accept: "text/html" },
@@ -217,13 +293,18 @@ export async function refreshCommandCodeReasoningEfforts(
     });
     if (!response.ok) return undefined;
     // Bound the profile page before parsing: a large or malformed page must not
-    // allocate unbounded memory on the request path.
-    const observed = await readBoundedResponseBody(response, { maxBytes: 256 * 1024 });
+    // allocate unbounded memory on the request path. Live profiles measured 240-259 KB on
+    // 2026-09-23, so the cap leaves room for growth; a truncated page fails to parse and keeps
+    // the static row.
+    const observed = await readBoundedResponseBody(response, { maxBytes: PROFILE_PAGE_MAX_BYTES });
     if (!observed.displaySafe) return undefined;
-    const efforts = parsedProfileEfforts(observed.text);
+    const efforts = parsedProfileEfforts(observed.text, modelId);
     if (efforts === undefined) return undefined;
-    refreshedEfforts.set(key, efforts);
-    return efforts;
+    const accepted = commandCodeReasoningEfforts(modelId, destination) ?? [];
+    const merged = [...new Set([...accepted, ...efforts])]
+      .filter(effort => !rejectedEfforts.get(key)?.has(effort));
+    refreshedEfforts.set(key, merged);
+    return merged;
   } catch {
     return undefined;
   }
@@ -231,4 +312,5 @@ export async function refreshCommandCodeReasoningEfforts(
 
 export function resetCommandCodeReasoningEffortsForTest(): void {
   refreshedEfforts.clear();
+  rejectedEfforts.clear();
 }

package/src/providers/derive.ts

@@ -47,6 +47,7 @@ export interface DerivedKeyLoginProvider {
   requiresReasoningPlaceholderModels?: string[];
   showThinkingSummary?: boolean;
   reasoningSplitModels?: string[];
+  inlineThinkTagModels?: string[];
   reasoningDetailsModels?: string[];
   thinkingToggleModels?: string[];
   thinkingBudgetModels?: string[];
@@ -113,13 +114,17 @@ function cloneRecordOfArrays(input: Record<string, string[]>): Record<string, st
  * is how a partially customized `modelInputModalities` could leave a
  * vision-capable model advertising no image support, which in turn collapses any
  * combo containing it to text-only. Routing already merges these maps per key
- * (`mergeRecordFill` in src/router.ts); catalog enrichment now matches.
+ * (`mapFill` in src/providers/resolved-model-policy-merge.ts); catalog enrichment now matches.
  */
 function fillRecordOfArrays(
   seed: Record<string, string[]>,
   user: Record<string, string[]> | undefined,
 ): Record<string, string[]> {
-  return { ...cloneRecordOfArrays(seed), ...(user ? cloneRecordOfArrays(user) : {}) };
+  const userKeys = new Set(Object.keys(user ?? {}).map(key => key.toLowerCase()));
+  const defaults = Object.fromEntries(
+    Object.entries(seed).filter(([key]) => !userKeys.has(key.toLowerCase())),
+  );
+  return { ...cloneRecordOfArrays(defaults), ...(user ? cloneRecordOfArrays(user) : {}) };
 }
 
 function cloneNestedRecord(input: Record<string, Record<string, string>>): Record<string, Record<string, string>> {
@@ -286,6 +291,7 @@ export function providerConfigSeed(entry: ProviderRegistryEntry): OcxProviderCon
     ...(entry.requiresReasoningPlaceholderModels ? { requiresReasoningPlaceholderModels: [...entry.requiresReasoningPlaceholderModels] } : {}),
     ...(entry.showThinkingSummary !== undefined ? { showThinkingSummary: entry.showThinkingSummary } : {}),
     ...(entry.reasoningSplitModels ? { reasoningSplitModels: [...entry.reasoningSplitModels] } : {}),
+    ...(entry.inlineThinkTagModels ? { inlineThinkTagModels: [...entry.inlineThinkTagModels] } : {}),
     ...(entry.reasoningDetailsModels ? { reasoningDetailsModels: [...entry.reasoningDetailsModels] } : {}),
     ...(entry.thinkingToggleModels ? { thinkingToggleModels: [...entry.thinkingToggleModels] } : {}),
     ...(entry.thinkingBudgetModels ? { thinkingBudgetModels: [...entry.thinkingBudgetModels] } : {}),
@@ -336,6 +342,7 @@ export function deriveKeyLoginMap(): Record<string, DerivedKeyLoginProvider> {
       ...(entry.requiresReasoningPlaceholderModels ? { requiresReasoningPlaceholderModels: [...entry.requiresReasoningPlaceholderModels] } : {}),
       ...(entry.showThinkingSummary !== undefined ? { showThinkingSummary: entry.showThinkingSummary } : {}),
       ...(entry.reasoningSplitModels ? { reasoningSplitModels: [...entry.reasoningSplitModels] } : {}),
+      ...(entry.inlineThinkTagModels ? { inlineThinkTagModels: [...entry.inlineThinkTagModels] } : {}),
       ...(entry.reasoningDetailsModels ? { reasoningDetailsModels: [...entry.reasoningDetailsModels] } : {}),
       ...(entry.thinkingToggleModels ? { thinkingToggleModels: [...entry.thinkingToggleModels] } : {}),
       ...(entry.thinkingBudgetModels ? { thinkingBudgetModels: [...entry.thinkingBudgetModels] } : {}),
@@ -534,7 +541,7 @@ export function enrichProviderFromRegistry(name: string, prov: OcxProviderConfig
   // Per-model fill for the same reason as modelInputModalities above: an all-or-nothing
   // copy let ONE customized model hide the registry's ladder for every other model on the
   // provider. That split the two planes apart — routing merges these maps per key
-  // (mergeRecordFill in src/router.ts), so the wire honored the effort while /v1/models and
+  // (mapFill in src/providers/resolved-model-policy-merge.ts), so the wire honored the effort while /v1/models and
   // every client export showed no effort control at all.
   if (resolvedStatic.modelReasoningEfforts) prov.modelReasoningEfforts = cloneRecordOfArrays(resolvedStatic.modelReasoningEfforts);
   if (!prov.modelDefaultReasoningEfforts && seed.modelDefaultReasoningEfforts) prov.modelDefaultReasoningEfforts = { ...seed.modelDefaultReasoningEfforts };
@@ -602,6 +609,7 @@ export function enrichProviderFromRegistry(name: string, prov: OcxProviderConfig
   if (!prov.preserveReasoningContentModels && seed.preserveReasoningContentModels) prov.preserveReasoningContentModels = [...seed.preserveReasoningContentModels];
   if (!prov.requiresReasoningPlaceholderModels && seed.requiresReasoningPlaceholderModels) prov.requiresReasoningPlaceholderModels = [...seed.requiresReasoningPlaceholderModels];
   if (!prov.reasoningSplitModels && seed.reasoningSplitModels) prov.reasoningSplitModels = [...seed.reasoningSplitModels];
+  if (!prov.inlineThinkTagModels && seed.inlineThinkTagModels) prov.inlineThinkTagModels = [...seed.inlineThinkTagModels];
   if (!prov.reasoningDetailsModels && seed.reasoningDetailsModels) prov.reasoningDetailsModels = [...seed.reasoningDetailsModels];
   if (!prov.thinkingToggleModels && seed.thinkingToggleModels) prov.thinkingToggleModels = [...seed.thinkingToggleModels];
   if (!prov.thinkingBudgetModels && seed.thinkingBudgetModels) prov.thinkingBudgetModels = [...seed.thinkingBudgetModels];

package/src/providers/fastwire.ts

@@ -12,8 +12,9 @@ import type { InboundWire, ModelWireDefault, ProviderAuthKind } from "./registry
 const SERVICE_TIER_ADAPTERS = new Set(["openai-chat", "openai-responses"]);
 const FAST_WIRE_ADAPTERS: Readonly<Record<FastWire["kind"], ReadonlySet<string>>> = {
   "service-tier": SERVICE_TIER_ADAPTERS,
-  // A1 deliberately has no adapter implementation for Anthropic speed.
-  "anthropic-speed": new Set(),
+  // Anthropic fast mode: top-level `speed: "fast"` plus the declared beta, serialized and
+  // observed (`usage.speed`) by the Anthropic adapter itself.
+  "anthropic-speed": new Set(["anthropic"]),
   // Cursor expresses Fast as a variant dimension of the picked model, resolved in the
   // request builder, so the adapter set is exactly the cursor adapter.
   "cursor-variant": new Set(["cursor"]),
@@ -46,6 +47,7 @@ export interface FastPolicyAuthority {
   };
   readonly modelAdapters: Readonly<Record<string, string>>;
   readonly hardPins: Readonly<Record<string, string>>;
+  readonly hardPinPrefixes?: Readonly<Record<string, string>>;
   readonly registryWireDefaults: Readonly<Record<string, ModelWireDefault>>;
 }
 
@@ -153,6 +155,12 @@ function resolvePolicyAdapter(
     ? authority.hardPins[modelId]
     : undefined;
   if (typeof hardPin === "string") return { adapter: hardPin, hardPinned: true };
+  const foldedModelId = modelId.toLowerCase();
+  for (const [prefix, adapter] of Object.entries(authority.hardPinPrefixes ?? {})) {
+    if (foldedModelId.startsWith(prefix.toLowerCase())) {
+      return { adapter, hardPinned: true };
+    }
+  }
   if (authority.modelWireOverrideAllowed) {
     const registryDefault = MODEL_ADAPTER_OVERRIDE_ALLOWED.has(authority.providerAdapter)
       ? registryDefaultForModel(
@@ -368,7 +376,12 @@ export function createAdapterTierMetadata(
     outcome.fastOutcome = "not-requested";
   } else if (!effectiveFastRequested || context.eligibility !== "eligible" || wireValue === null) {
     outcome.fastOutcome = "downgraded";
-    outcome.fastDowngradeReason = downgradeReasonForUnavailable(context);
+    // An upstream that refused the fast wire earlier in this request is a decline, not a
+    // missing wire: the route is eligible and was asked, and the standard resend that follows
+    // must not read as if the proxy never tried.
+    outcome.fastDowngradeReason = context.upstreamDeclinedFast === true
+      ? "response-declined"
+      : downgradeReasonForUnavailable(context);
     outcome.confirmation = "downgraded";
   } else if (canonicalFromWire(context.fastWire, wireValue) === "priority") {
     outcome.canonical = "priority";

package/src/providers/label.ts

@@ -5,6 +5,8 @@ export function canonicalUsageProviderLabel(provider: string): string {
   return provider === "chatgpt" || provider === "openai-multi" ? "openai" : provider;
 }
 
+const LEGACY_MAIN_ACCOUNT_PROVIDER_LABELS = new Set(["openai-main", "chatgpt-main", "openai-multi-main"]);
+
 export function usesApiKeyAccount(provider: Pick<OcxProviderConfig, "authMode" | "_apiKeyAttempt">): boolean {
   return provider.authMode === "key"
     || (provider.authMode === undefined && !!provider._apiKeyAttempt?.reference);
@@ -29,11 +31,14 @@ export function baseProviderLabel(provider: string): string {
   const cut = provider.lastIndexOf("-");
   if (cut <= 0) return canonicalUsageProviderLabel(provider);
   const suffix = provider.slice(cut + 1);
-  // `-main` is the legacy log label for the main Codex account (MAIN_CODEX_ACCOUNT_ID). New entries
-  // log under the base provider name, but historical `<provider>-main` entries must still collapse.
+  // `-main` was the legacy log label for the main Codex account (MAIN_CODEX_ACCOUNT_ID). Restrict
+  // that compatibility mapping to the known Codex provider labels so configured providers whose
+  // names naturally end in `-main` remain distinct.
   // ChatGPT auth-pool and OpenAI passthrough are the same Codex/OpenAI usage surface, so display
   // summaries normalize them to one `openai` row after recognized main/pool suffixes are removed.
-  if (suffix === "main") return canonicalUsageProviderLabel(provider.slice(0, cut));
+  if (LEGACY_MAIN_ACCOUNT_PROVIDER_LABELS.has(provider)) {
+    return canonicalUsageProviderLabel(provider.slice(0, cut));
+  }
   return CODEX_ACCOUNT_LOG_LABEL_RE.test(suffix) ? canonicalUsageProviderLabel(provider.slice(0, cut)) : provider;
 }
 

package/src/providers/model-rename-fields.ts

@@ -121,6 +121,7 @@ export const PROVIDER_MODEL_RENAME_ROLES = {
   transientRetryOn5xx: "none",
   retryOnReset: "none",
   reasoningSplitModels: "list",
+  inlineThinkTagModels: "list",
   reasoningDetailsModels: "list",
   thinkingToggleModels: "list",
   thinkingBudgetModels: "list",

package/src/providers/openai-virtual-models.ts

@@ -99,6 +99,7 @@ export function applyOpenAiVirtualModel(
 
   logCtx.model = resolution.selectedModelId;
   logCtx.resolvedModel = resolution.wireModelId;
+  logCtx.wireModel = resolution.wireModelId;
   route.modelId = resolution.wireModelId;
   captureOpenAiVirtualWirePolicy(route, resolution, inboundWire);
   parsed.modelId = resolution.wireModelId;

package/src/providers/quota/vendor-probes-oauth.ts

@@ -3,6 +3,7 @@ import { MAIN_CODEX_ACCOUNT_ID } from "../../codex/main-account";
 import { getValidAccessToken } from "../../oauth";
 import { getAccountCredential, getAccountSet } from "../../oauth/store";
 import { fetchMuseKeyQuotaSnapshot } from "../muse-key-quota";
+import { CLAUDE_CLI_USER_AGENT } from "../claude-cli-identity";
 import { XAI_GROK_CLIENT_VERSION, XAI_GROK_COMPATIBILITY } from "../xai-transport";
 import {
   commitKiroAccountUsageState,
@@ -276,7 +277,7 @@ export async function fetchAnthropicUsageQuota(accessToken: string): Promise<Pro
       headers: {
         Accept: "application/json, text/plain, */*",
         "Content-Type": "application/json",
-        "User-Agent": "claude-cli/2.1.63 (external, cli)",
+        "User-Agent": CLAUDE_CLI_USER_AGENT,
         "anthropic-beta": "claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,context-management-2025-06-27,prompt-caching-scope-2026-01-05",
         Authorization: `Bearer ${accessToken}`,
       },