@coseung2/opencodex 2.8.0-cs.15 → 2.8.0-cs.17

package/src/adapters/xai-web-search.ts

@@ -0,0 +1,138 @@
+import type { OcxProviderConfig } from "../types";
+import { isXaiResponsesDestination } from "../providers/xai-transport";
+
+const CODEX_WEB_SEARCH_TOOL = "web_search";
+const CODEX_WEB_SEARCH_PREVIEW_TOOL = "web_search_preview";
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function isCodexWebSearchToolType(value: unknown): boolean {
+  return value === CODEX_WEB_SEARCH_TOOL || value === CODEX_WEB_SEARCH_PREVIEW_TOOL;
+}
+
+type ToolGroupRewrite = { tools: unknown[]; changed: boolean };
+
+/**
+ * Translate Codex hosted-search fields to xAI's public Responses shape.
+ * `external_web_access:false` means cached/index-only search; xAI has no equivalent, so omit the
+ * whole tool rather than silently widening network access. Live search keeps supported fields and
+ * drops only the private fields the xAI endpoints reject.
+ */
+function normalizeToolGroup(tools: unknown[]): ToolGroupRewrite {
+  const normalized: unknown[] = [];
+  let changed = false;
+  for (const tool of tools) {
+    if (!isPlainObject(tool) || !isCodexWebSearchToolType(tool.type)) {
+      normalized.push(tool);
+      continue;
+    }
+    const hasExternalAccess = Object.hasOwn(tool, "external_web_access");
+    if (hasExternalAccess && tool.external_web_access !== true) {
+      changed = true;
+      continue;
+    }
+    const searchContentTypes = Array.isArray(tool.search_content_types) ? tool.search_content_types : undefined;
+    const enableImageSearch = searchContentTypes?.includes("image") === true;
+    const next: Record<string, unknown> = { ...tool, type: CODEX_WEB_SEARCH_TOOL };
+    delete next.external_web_access;
+    delete next.search_context_size;
+    if (enableImageSearch && !Object.hasOwn(next, "enable_image_search")) next.enable_image_search = true;
+    const toolChanged = Object.keys(next).length !== Object.keys(tool).length
+      || Object.entries(next).some(([key, value]) => tool[key] !== value);
+    changed ||= toolChanged;
+    normalized.push(toolChanged ? next : tool);
+  }
+  return { tools: changed ? normalized : tools, changed };
+}
+
+function hasWebSearchTool(body: Record<string, unknown>): boolean {
+  if (Array.isArray(body.tools) && body.tools.some(tool => isPlainObject(tool) && isCodexWebSearchToolType(tool.type))) return true;
+  return Array.isArray(body.input) && body.input.some(item =>
+    isPlainObject(item)
+    && item.type === "additional_tools"
+    && Array.isArray(item.tools)
+    && item.tools.some(tool => isPlainObject(tool) && isCodexWebSearchToolType(tool.type))
+  );
+}
+
+function hasAnyDeclaredTool(body: Record<string, unknown>): boolean {
+  if (Array.isArray(body.tools) && body.tools.length > 0) return true;
+  return Array.isArray(body.input) && body.input.some(item =>
+    isPlainObject(item)
+    && item.type === "additional_tools"
+    && Array.isArray(item.tools)
+    && item.tools.length > 0
+  );
+}
+
+function normalizeToolChoice(body: Record<string, unknown>): Record<string, unknown> {
+  const choice = body.tool_choice;
+  if (choice === undefined) return body;
+  const hasSearch = hasWebSearchTool(body);
+  if (isPlainObject(choice) && isCodexWebSearchToolType(choice.type)) {
+    if (!hasSearch) return { ...body, tool_choice: "none" };
+    return choice.type === CODEX_WEB_SEARCH_TOOL
+      ? body
+      : { ...body, tool_choice: { ...choice, type: CODEX_WEB_SEARCH_TOOL } };
+  }
+  if (isPlainObject(choice) && choice.type === "allowed_tools" && Array.isArray(choice.tools)) {
+    let changed = false;
+    const tools: unknown[] = [];
+    for (const tool of choice.tools) {
+      if (!isPlainObject(tool) || !isCodexWebSearchToolType(tool.type)) {
+        tools.push(tool);
+        continue;
+      }
+      if (!hasSearch) {
+        changed = true;
+        continue;
+      }
+      if (tool.type === CODEX_WEB_SEARCH_PREVIEW_TOOL) {
+        tools.push({ ...tool, type: CODEX_WEB_SEARCH_TOOL });
+        changed = true;
+      } else tools.push(tool);
+    }
+    if (!changed) return body;
+    return { ...body, tool_choice: tools.length > 0 ? { ...choice, tools } : "none" };
+  }
+  if (choice === "required" && !hasAnyDeclaredTool(body)) return { ...body, tool_choice: "none" };
+  return body;
+}
+
+/** Normalize both public xAI and Grok CLI Responses destinations; custom gateways are untouched. */
+export function normalizeXaiResponsesWebSearch(
+  body: unknown,
+  provider: Pick<OcxProviderConfig, "baseUrl">,
+): unknown {
+  if (!isXaiResponsesDestination(provider) || !isPlainObject(body)) return body;
+  let next: Record<string, unknown> = body;
+  if (Array.isArray(body.tools)) {
+    const rewritten = normalizeToolGroup(body.tools);
+    if (rewritten.changed) {
+      next = { ...next };
+      if (rewritten.tools.length > 0) next.tools = rewritten.tools;
+      else delete next.tools;
+    }
+  }
+  if (Array.isArray(next.input)) {
+    let inputChanged = false;
+    const input: unknown[] = [];
+    for (const item of next.input) {
+      if (!isPlainObject(item) || item.type !== "additional_tools" || !Array.isArray(item.tools)) {
+        input.push(item);
+        continue;
+      }
+      const rewritten = normalizeToolGroup(item.tools);
+      if (!rewritten.changed) {
+        input.push(item);
+        continue;
+      }
+      inputChanged = true;
+      if (rewritten.tools.length > 0) input.push({ ...item, tools: rewritten.tools });
+    }
+    if (inputChanged) next = { ...next, input };
+  }
+  return normalizeToolChoice(next);
+}

package/src/bridge.ts

@@ -258,11 +258,11 @@ export function bridgeToResponsesSSE(
     terminalReported = true;
     try { options?.onTerminal?.(status); } catch { /* terminal metrics must not break the stream */ }
   };
-  // RC3 keep-alive: Codex's idle timer is timeout(idle_timeout, stream.next()) over an
-  // eventsource_stream; ANY received event re-arms it, while an unknown type is ignored
-  // (responses.rs `_ => Ok(None)`). Emit a parser-ignored `response.heartbeat` whenever the
-  // *wire* has been silent, even if invisible adapter heartbeats are still flowing (web-search
-  // buffering + raw-byte progress). Upstream activity only resets the stall watchdog.
+  // RC3 keep-alive: keep the event-stream transport active without inventing a Responses event
+  // variant. Strict clients such as Grok Build deserialize every typed event and reject unknown
+  // `response.heartbeat` frames, while an SSE comment is transport-only and still keeps the
+  // connection alive. Emit it whenever the *wire* has been silent, even if invisible adapter
+  // heartbeats are still flowing (web-search buffering + raw-byte progress).
   let upstreamActivity = false;
   let wireActivity = false;
   let beat: unknown;
@@ -328,7 +328,7 @@ export function bridgeToResponsesSSE(
         ...(endTurn !== undefined ? { end_turn: endTurn } : {}),
       });
 
-      const heartbeatFrame = encoder.encode('event: response.heartbeat\ndata: {"type":"response.heartbeat"}\n\n');
+      const heartbeatFrame = encoder.encode(": opencodex heartbeat\n\n");
       let stallTicks = 0;
       const stallSec = resolveStallTimeoutSec(options?.stallTimeoutSec);
       const maxStallTicks = Math.ceil((stallSec * 1000) / heartbeatMs);
@@ -400,6 +400,29 @@ export function bridgeToResponsesSSE(
         retainFinishedItem(item as OutputItem, bytesOf(encrypted), "reasoning");
         outputIndex++;
       };
+      // Kiro reasoning round-trip. Kiro sends its encrypted blob at the END of a turn, while the
+      // assistant message is still open, so this CANNOT emit on arrival: the open message still
+      // owns `outputIndex` (it only advances on close), and an item emitted here would both reuse
+      // that index and land BEFORE the message — where the parser's backwards pairing drops it as
+      // orphaned. Stash it and flush after `done` has closed every open item instead.
+      let pendingKiroRedacted: string | undefined;
+      let pendingKiroRedactedBytes = 0;
+      const flushKiroRedactedReasoning = () => {
+        if (!pendingKiroRedacted) return;
+        const previousBytes = pendingKiroRedactedBytes;
+        const encrypted = encodeReasoningEnvelope({ krc: pendingKiroRedacted });
+        const reservation = budget?.reserveTransient(bytesOf(encrypted), { kind: "reasoning" });
+        pendingKiroRedacted = undefined;
+        pendingKiroRedactedBytes = 0;
+        reservation?.commitRetained();
+        budget?.releaseRetained(previousBytes, { kind: "reasoning" });
+        const itemId = `rs_${uuid()}`;
+        const item = { type: "reasoning", id: itemId, summary: [] as never[], encrypted_content: encrypted };
+        emit("response.output_item.added", { output_index: outputIndex, item });
+        emit("response.output_item.done", { output_index: outputIndex, item });
+        retainFinishedItem(item as OutputItem, bytesOf(encrypted), "reasoning");
+        outputIndex++;
+      };
       // Full assistant text of a compaction turn (across message boundaries) — becomes the
       // synthetic compaction item's payload on done.
       let compactionText = "";
@@ -817,6 +840,12 @@ export function bridgeToResponsesSSE(
               pendingRedacted.push(event.data);
               break;
             }
+            case "kiro_redacted_reasoning": {
+              // Stash only — see flushKiroRedactedReasoning. One blob per turn, so last wins.
+              pendingKiroRedactedBytes = replaceRetainedString(pendingKiroRedactedBytes, event.data, "reasoning");
+              pendingKiroRedacted = event.data;
+              break;
+            }
             case "reasoning_raw_delta": {
               if (options?.hideThinkingSummary) {
                 ({ value: hiddenRawReasoningText, bytes: hiddenRawReasoningBytes } = appendString(
@@ -987,6 +1016,9 @@ export function bridgeToResponsesSSE(
               // Redacted-only turns (or hidden thinking without a trailing signature event) still
               // need their envelope-only reasoning item so the blocks replay next turn.
               flushHiddenReasoningEnvelope();
+              // After every close above, so the blob lands AFTER the assistant message it belongs
+              // to and the parser's backwards pairing finds it.
+              flushKiroRedactedReasoning();
               if (options?.compaction) {
                 // Exactly one compaction item per turn; codex-rs takes the first and fatals on 0.
                 const item = {
@@ -1288,6 +1320,10 @@ export function buildResponseJSON(
   let batchSignatureBytes = 0;
   let batchRedacted: string[] = [];
   let batchRedactedBytes = 0;
+  // Kiro reasoning blob, held until after the trailing flushes so it lands AFTER the assistant
+  // message (see the streaming path). Retained because it outlives releaseTranslatedEvent.
+  let batchKiroRedacted: string | undefined;
+  let batchKiroRedactedBytes = 0;
   let currentToolCallId = "";
   let currentToolCallName = "";
   let currentToolCallArgs = "";
@@ -1455,6 +1491,16 @@ export function buildResponseJSON(
         }
         batchRedacted.push(e.data);
         break;
+      case "kiro_redacted_reasoning":
+        // Stash only — pushed after the trailing flushes. One blob per turn, so last wins.
+        {
+          const dataBytes = bytesOf(e.data);
+          budget?.chargeRetained(dataBytes, { kind: "reasoning" });
+          if (batchKiroRedactedBytes > 0) budget?.releaseRetained(batchKiroRedactedBytes, { kind: "reasoning" });
+          batchKiroRedactedBytes = dataBytes;
+        }
+        batchKiroRedacted = e.data;
+        break;
       case "reasoning_raw_delta":
         if (currentText) flushText("commentary");
         if (currentSummaryReasoning) flushSummaryReasoning();
@@ -1553,6 +1599,15 @@ export function buildResponseJSON(
   flushRawReasoning();
   // Open tool call on a failed/incomplete turn must not land as status:"completed".
   if (currentToolCallId) flushToolCall(errorEvent || incompleteEvent ? "incomplete" : "completed");
+  if (batchKiroRedacted) {
+    // pushOutput reserves the item itself and releases the retained raw blob it replaces.
+    pushOutput({
+      type: "reasoning", id: `rs_${uuid()}`, summary: [],
+      encrypted_content: encodeReasoningEnvelope({ krc: batchKiroRedacted }),
+    }, batchKiroRedactedBytes, "reasoning");
+    batchKiroRedacted = undefined;
+    batchKiroRedactedBytes = 0;
+  }
   // A truncated turn must never be installed as replacement history: emit the
   // compaction item only when the turn actually completed (#422).
   if (

package/src/cli/observe.ts

@@ -21,7 +21,16 @@ const USAGE = `Usage:
   ocx observe claude-inbound [--limit <n>] [--json]
   ocx observe injection [--limit <n>] [--json]`;
 
-type LogEntry = Record<string, unknown> & { id?: string | number; timestamp?: string; provider?: string; model?: string; status?: number };
+type LogEntry = Record<string, unknown> & {
+  id?: string | number;
+  timestamp?: string;
+  provider?: string;
+  model?: string;
+  status?: number;
+  displayMetrics?: {
+    tokPerSecond?: { kind?: string; value?: number; estimated?: boolean };
+  };
+};
 
 function query(params: Record<string, string | number | undefined>): string {
   const search = new URLSearchParams();
@@ -43,8 +52,14 @@ function formatLog(row: LogEntry): string {
   const time = String(row.timestamp ?? row.createdAt ?? "");
   const route = [row.provider, row.model].filter(Boolean).join("/");
   const status = row.status ?? row.statusCode ?? "?";
-  const duration = row.durationMs !== undefined ? `${String(row.durationMs)}ms` : "";
-  return [time, String(status), route, duration].filter(Boolean).join("  ");
+  const metric = row.displayMetrics?.tokPerSecond;
+  const rate = metric?.kind === "value"
+    && typeof metric.value === "number"
+    && Number.isFinite(metric.value)
+    && metric.value > 0
+    ? `${metric.estimated ? "~" : ""}${metric.value.toLocaleString("en-US", { maximumFractionDigits: 1 })} tok/s`
+    : "— tok/s";
+  return [time, String(status), route, rate].filter(Boolean).join("  ");
 }
 
 async function logs(argv: string[], deps: RuntimeApiDeps): Promise<void> {

package/src/codex/app-server-processes.ts

@@ -329,11 +329,9 @@ export function listWindowsSnapshots(): ProcessSnapshot[] {
   const psCommand = [
     "$ErrorActionPreference='SilentlyContinue'",
     "$me=[System.Security.Principal.WindowsIdentity]::GetCurrent().Name",
-    "Get-CimInstance Win32_Process | Where-Object {",
-    "  -not [string]::IsNullOrWhiteSpace($_.CommandLine) -and (",
-    `    $_.CommandLine -match ${basenameMatch} -or`,
-    `    $_.CommandLine -match ${codeModeMatch}`,
-    "  )",
+    "Get-CimInstance Win32_Process -Filter \"CommandLine LIKE '%codex%' OR CommandLine LIKE '%code-mode-host%'\" -Property Handle,ProcessId,CommandLine | Where-Object {",
+    `  $_.CommandLine -match ${basenameMatch} -or`,
+    `  $_.CommandLine -match ${codeModeMatch}`,
     "} | ForEach-Object {",
     "  try {",
     "    $o=Invoke-CimMethod -InputObject $_ -MethodName GetOwner -ErrorAction Stop",

package/src/codex/catalog/effort.ts

@@ -33,7 +33,7 @@ import upstreamModelsSnapshot from "../data/upstream-models.json";
 
 import { readCatalog, readCodexCatalogPath } from "./parsing";
 import type { CatalogModel, RawEntry } from "./parsing";
-import { UPSTREAM_NATIVE_ENTRIES } from "./metadata";
+import { NATIVE_GPT6_ASTRA_MODEL, UPSTREAM_NATIVE_ENTRIES } from "./metadata";
 import { loadBundledCodexCatalog } from "./bundled";
 import type { BundledCatalogDeps } from "./bundled";
 import { deriveEntry } from "./sync";
@@ -181,7 +181,9 @@ export function applyReasoningLevels(
 }
 
 export function isGpt56NativeSlug(slug: string): boolean {
-  return !slug.includes("/") && slug.startsWith("gpt-5.6-");
+  // Historical name: this predicate protects the full native ladder/Responses Lite,
+  // not the context-window family. Astra uses its own pinned metadata and ceiling.
+  return !slug.includes("/") && (slug.startsWith("gpt-5.6-") || slug === NATIVE_GPT6_ASTRA_MODEL);
 }
 
 export function ensureGpt56ReasoningLevels(entry: RawEntry): void {

package/src/codex/catalog/metadata.ts

@@ -36,17 +36,20 @@ import type { RawEntry } from "./parsing";
 import { readCurrentCatalogOrCache, unique } from "./bundled";
 
 export const NATIVE_DAYBREAK_BLUE_MODEL = "gpt-daybreak-blue-latest";
+export const NATIVE_GPT6_ASTRA_MODEL = "gpt-6-astra";
 
 export const NATIVE_OPENAI_MODELS = [
   "gpt-5.5", "gpt-5.4", "gpt-5.4-mini", "gpt-5.3-codex-spark",
   "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna",
   NATIVE_DAYBREAK_BLUE_MODEL,
+  NATIVE_GPT6_ASTRA_MODEL,
 ];
 
 export const DOCUMENTED_NATIVE_OPENAI_ADDITIONS = [
   "gpt-5.3-codex-spark",
   "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna",
   NATIVE_DAYBREAK_BLUE_MODEL,
+  NATIVE_GPT6_ASTRA_MODEL,
 ];
 
 export const SUPPORTED_NATIVE_OPENAI_SLUGS = new Set(NATIVE_OPENAI_MODELS);
@@ -69,17 +72,35 @@ export const NATIVE_OPENAI_CONTEXT_OVERRIDES: Record<string, { contextWindow?: n
   "gpt-5.6-terra": { contextWindow: NATIVE_GPT56_CONTEXT_WINDOW, maxContextWindow: NATIVE_GPT56_CONTEXT_WINDOW, maxInputTokens: NATIVE_GPT56_MAX_INPUT_TOKENS },
   "gpt-5.6-luna": { contextWindow: NATIVE_GPT56_CONTEXT_WINDOW, maxContextWindow: NATIVE_GPT56_CONTEXT_WINDOW, maxInputTokens: NATIVE_GPT56_MAX_INPUT_TOKENS },
   [NATIVE_DAYBREAK_BLUE_MODEL]: { contextWindow: NATIVE_GPT56_CONTEXT_WINDOW, maxContextWindow: NATIVE_GPT56_CONTEXT_WINDOW, maxInputTokens: NATIVE_GPT56_MAX_INPUT_TOKENS },
+  [NATIVE_GPT6_ASTRA_MODEL]: { contextWindow: 272_000, maxContextWindow: 872_000, maxInputTokens: 872_000 },
 };
 
-export function nativeOpenAiContextWindow(slug: string): number | undefined {
-  return NATIVE_OPENAI_CONTEXT_OVERRIDES[slug]?.contextWindow
+export type NativeModelConfig = Partial<Pick<OcxConfig, "providers" | "providerContextCaps">>;
+
+function positiveNativeWindow(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
+}
+
+/** Astra has its own opt-in ceiling; do not change the fork's existing GPT-5.6 policy. */
+export function nativeOpenAiContextWindow(slug: string, config?: NativeModelConfig): number | undefined {
+  const raw = NATIVE_OPENAI_CONTEXT_OVERRIDES[slug]?.contextWindow
     ?? (typeof UPSTREAM_NATIVE_ENTRIES.get(slug)?.context_window === "number"
       ? UPSTREAM_NATIVE_ENTRIES.get(slug)!.context_window as number
       : undefined);
+  if (slug !== NATIVE_GPT6_ASTRA_MODEL || raw === undefined) return raw;
+  const provider = config?.providers?.openai;
+  const canonical = provider && isCanonicalOpenAiForwardProvider(provider) ? provider : undefined;
+  const overlay = positiveNativeWindow(canonical?.modelContextWindows?.[slug])
+    ?? positiveNativeWindow(canonical?.contextWindow);
+  const cap = positiveNativeWindow(config?.providerContextCaps?.openai);
+  return Math.min(overlay ?? cap ?? raw, 872_000, cap ?? Number.POSITIVE_INFINITY);
 }
 
-export function nativeOpenAiMaxInputTokens(slug: string): number | undefined {
-  return NATIVE_OPENAI_CONTEXT_OVERRIDES[slug]?.maxInputTokens;
+export function nativeOpenAiMaxInputTokens(slug: string, config?: NativeModelConfig): number | undefined {
+  const maximum = NATIVE_OPENAI_CONTEXT_OVERRIDES[slug]?.maxInputTokens;
+  return slug === NATIVE_GPT6_ASTRA_MODEL && maximum !== undefined
+    ? Math.min(maximum, nativeOpenAiContextWindow(slug, config) ?? maximum)
+    : maximum;
 }
 
 export function nativeInputModalities(slug: string): string[] {
@@ -138,10 +159,10 @@ export function desktopVisibleNativeSlugs(config: Pick<OcxConfig, "claudeCode" |
   return visibleNativeSlugs(config);
 }
 
-export function nativeModelRows(config: Pick<OcxConfig, "disabledModels">): Array<{ slug: string; disabled: boolean; contextWindow?: number }> {
+export function nativeModelRows(config: Pick<OcxConfig, "disabledModels"> & NativeModelConfig): Array<{ slug: string; disabled: boolean; contextWindow?: number }> {
   const disabled = disabledNativeSlugs(config);
   return NATIVE_OPENAI_MODELS.map(slug => {
-    const contextWindow = nativeOpenAiContextWindow(slug);
+    const contextWindow = nativeOpenAiContextWindow(slug, config);
     return { slug, disabled: disabled.has(slug), ...(contextWindow !== undefined ? { contextWindow } : {}) };
   });
 }
@@ -160,8 +181,19 @@ export const UPSTREAM_NATIVE_ENTRIES: Map<string, RawEntry> = (() => {
     ((upstreamModelsSnapshot as unknown as { models?: RawEntry[] }).models ?? [])
       .filter(m => typeof m.slug === "string"
         && SUPPORTED_NATIVE_OPENAI_SLUGS.has(m.slug as string)
-        && (m.slug as string).startsWith("gpt-5.6-"))
-      .map(m => [m.slug as string, m] as const),
+        && ((m.slug as string).startsWith("gpt-5.6-") || m.slug === NATIVE_GPT6_ASTRA_MODEL))
+      .map(m => {
+        // Astra ships the instructions template without base_instructions. Derive the
+        // catalog projection without changing the pinned prompt or widening replacement
+        // authority to older native models.
+        const messages = m.model_messages;
+        const template = messages && typeof messages === "object" && !Array.isArray(messages)
+          ? (messages as Record<string, unknown>).instructions_template : undefined;
+        const hasBase = typeof m.base_instructions === "string" && m.base_instructions.length > 0;
+        const projected = m.slug === NATIVE_GPT6_ASTRA_MODEL && !hasBase
+          && typeof template === "string" && template.length > 0 ? { ...m, base_instructions: template } : m;
+        return [m.slug as string, projected] as const;
+      }),
   );
   const sol = entries.get("gpt-5.6-sol");
   if (sol) {
@@ -185,7 +217,8 @@ export function upstreamNativeEntry(slug: string): RawEntry | null {
 export function shouldUpgradeToUpstreamEntry(entry: RawEntry): boolean {
   return typeof entry.slug === "string"
     && UPSTREAM_NATIVE_ENTRIES.has(entry.slug)
-    && entry.display_name === entry.slug;
+    && (entry.display_name === entry.slug
+      || (entry.slug === NATIVE_GPT6_ASTRA_MODEL && entry.display_name === "GPT-6 Astra"));
 }
 
 export function nativeOpenAiSlugs(): string[] {

package/src/codex/catalog/parsing.ts

@@ -31,7 +31,7 @@ import { redactSecretString } from "../../lib/redact";
 import upstreamModelsSnapshot from "../data/upstream-models.json";
 
 
-import { NATIVE_OPENAI_CONTEXT_OVERRIDES, SUPPORTED_NATIVE_OPENAI_SLUGS, UPSTREAM_NATIVE_ENTRIES } from "./metadata";
+import { NATIVE_GPT6_ASTRA_MODEL, NATIVE_OPENAI_CONTEXT_OVERRIDES, SUPPORTED_NATIVE_OPENAI_SLUGS, UPSTREAM_NATIVE_ENTRIES, nativeOpenAiContextWindow, nativeOpenAiMaxInputTokens, type NativeModelConfig } from "./metadata";
 
 export function legacyCatalogBackupPath(): string {
   return join(getConfigDir(), "catalog-backup.json");
@@ -206,6 +206,11 @@ const NO_FAST_TIER_NATIVE_SLUGS = new Set([
 ]);
 
 export function normalizeServiceTiers(entry: RawEntry): RawEntry {
+  if (entry.slug === NATIVE_GPT6_ASTRA_MODEL && Array.isArray(entry.service_tiers)) {
+    entry.service_tiers = entry.service_tiers.map(tier =>
+      tier?.id === "priority" && tier.description === "1.5x speed, increased usage"
+        ? { ...tier, description: "2x speed, increased usage" } : tier);
+  }
   // Strip service tiers for models that do not actually support the Fast tier.
   if (typeof entry.slug === "string" && NO_FAST_TIER_NATIVE_SLUGS.has(entry.slug)) {
     delete entry.service_tier;
@@ -250,10 +255,19 @@ function nativeAutoCompactLimit(contextWindow: number, maxInputTokens?: number):
     : ninetyPercent;
 }
 
-export function applyNativeOpenAiContextOverride(entry: RawEntry): void {
+export function applyNativeOpenAiContextOverride(entry: RawEntry, config?: NativeModelConfig): void {
   if (!isNativeOpenAiEntry(entry)) return;
   const override = NATIVE_OPENAI_CONTEXT_OVERRIDES[entry.slug as string];
   if (!override) return;
+  if (entry.slug === NATIVE_GPT6_ASTRA_MODEL) {
+    const window = nativeOpenAiContextWindow(entry.slug, config)!;
+    entry.context_window = window;
+    const cap = config?.providerContextCaps?.openai;
+    const ceiling = typeof cap === "number" && Number.isSafeInteger(cap) && cap > 0 ? Math.min(872_000, cap) : 872_000;
+    entry.max_context_window = Math.max(window, ceiling);
+    entry.auto_compact_token_limit = nativeAutoCompactLimit(window, nativeOpenAiMaxInputTokens(entry.slug, config));
+    return;
+  }
   if (typeof override.contextWindow === "number") {
     entry.context_window = override.contextWindow;
     entry.auto_compact_token_limit = nativeAutoCompactLimit(override.contextWindow, override.maxInputTokens);
@@ -346,6 +360,7 @@ export function normalizeRoutedCatalogEntry(entry: RawEntry, parallelToolCalls =
   delete entry.model_messages;
   delete entry.tool_mode;
   delete entry.multi_agent_version;
+  delete entry.multi_agent_reasoning_effort;
   delete entry.use_responses_lite;
   delete entry.supports_websockets;
   delete entry.additional_speed_tiers;

package/src/codex/catalog/provider-fetch.ts

@@ -767,14 +767,14 @@ async function gatherRoutedModelsUncached(
     const disabled = disabledNativeSlugs(config);
     for (const slug of nativeOpenAiSlugs()) {
       if (disabled.has(slug)) continue;
-      const contextWindow = nativeOpenAiContextWindow(slug);
+      const contextWindow = nativeOpenAiContextWindow(slug, config);
       if (contextWindow === undefined) continue;
       const synthetic: CatalogModel = {
         provider: "openai",
         id: slug,
         owned_by: "openai",
         contextWindow,
-        maxInputTokens: nativeOpenAiMaxInputTokens(slug) ?? contextWindow,
+        maxInputTokens: nativeOpenAiMaxInputTokens(slug, config) ?? contextWindow,
         inputModalities: nativeInputModalities(slug),
         reasoningEfforts: nativeReasoningEfforts(slug),
         ...(nativeParallelToolCalls(slug) ? { parallelToolCalls: true } : {}),
@@ -854,7 +854,11 @@ export function augmentRoutedModelsWithRegistryOpenAiApiRows(
       ? Math.min(officialContext, userContext ?? officialContext, providerCap ?? officialContext)
       : undefined;
     const maxInputTokens = typeof officialMaxInput === "number"
-      ? Math.min(officialMaxInput, userMaxInput ?? officialMaxInput)
+      ? Math.min(officialMaxInput, userMaxInput ?? officialMaxInput, contextWindow ?? officialMaxInput)
+      : undefined;
+    const officialMaxOutput = entry.modelMaxOutputTokens?.[id];
+    const maxOutputTokens = typeof officialMaxOutput === "number"
+      ? Math.min(officialMaxOutput, configured.modelMaxOutputTokens?.[id] ?? officialMaxOutput, contextWindow ?? officialMaxOutput)
       : undefined;
     return {
       provider: OPENAI_API_PROVIDER_ID,
@@ -862,6 +866,8 @@ export function augmentRoutedModelsWithRegistryOpenAiApiRows(
       owned_by: OPENAI_API_PROVIDER_ID,
       ...(contextWindow ? { contextWindow } : {}),
       ...(maxInputTokens ? { maxInputTokens } : {}),
+      ...(maxOutputTokens ? { maxOutputTokens } : {}),
+      ...(entry.modelDefaultReasoningEfforts?.[id] ? { defaultReasoningEffort: entry.modelDefaultReasoningEfforts[id] } : {}),
       ...(entry.modelInputModalities?.[id] ? { inputModalities: [...entry.modelInputModalities[id]!] } : {}),
       ...(entry.modelReasoningEfforts?.[id] ? { reasoningEfforts: [...entry.modelReasoningEfforts[id]!] } : {}),
     };

package/src/codex/catalog/sync.ts

@@ -14,7 +14,7 @@ import { enrichProviderFromRegistry, shouldCaseFoldMetadataModelId } from "../..
 import { getProviderRegistryEntry } from "../../providers/registry";
 import { applyProviderContextCap, providerContextCap } from "../../providers/context-cap";
 import { routedSlug, slugEquals, slugsEquivalent } from "../../providers/slug-codec";
-import { CODEX_GPT5_IDENTITY_LINE } from "../../adapters/identity";
+import { CODEX_GPT5_IDENTITY_LINE, neutralizeIdentity } from "../../adapters/identity";
 import { filterCursorConfiguredModelsByLiveDiscovery } from "../../adapters/cursor/discovery";
 import { fetchCursorUsableModels } from "../../adapters/cursor/live-models";
 import { isCanonicalOpenAiForwardProvider, OPENAI_API_PROVIDER_ID, OPENAI_CODEX_PROVIDER_ID } from "../../providers/openai-tiers";
@@ -194,10 +194,10 @@ export function deriveEntry(
       if (typeof e.base_instructions === "string") {
         // Proxy-neutral: keep the GPT-5/OpenAI disclaimer but never advertise the opencodex proxy
         // (leaking that into base_instructions is a non-first-party signature → ToS risk).
-        e.base_instructions = e.base_instructions.replace(
+        e.base_instructions = neutralizeIdentity(e.base_instructions.replace(
           CODEX_GPT5_IDENTITY_LINE,
           `You are a coding agent powered by the ${modelName} model. Do not claim to be GPT-5 or made by OpenAI.`,
-        );
+        ));
       }
       applyReasoningLevels(e, model?.reasoningEfforts, model?.defaultReasoningEffort, preserveExact);
       normalizeRoutedCatalogEntry(e, model?.parallelToolCalls === true);
@@ -233,6 +233,9 @@ export function deriveEntry(
   };
   if (isRouted) {
     applyReasoningLevels(entry, model?.reasoningEfforts, model?.defaultReasoningEffort, preserveExact);
+    // The no-template fallback does not pass through normalizeRoutedCatalogEntry, so pin the
+    // capability before strict defaults would otherwise advertise parallel calls unconditionally.
+    entry.supports_parallel_tool_calls = model?.provider === "cursor" || model?.parallelToolCalls === true;
   }
   else {
     applyReasoningLevels(entry, isGpt56NativeSlug(slug) ? undefined : ["low", "medium", "high", "xhigh"]);
@@ -255,6 +258,7 @@ export function buildCatalogEntries(
   wsEnabled = false,
   multiAgentMode: MultiAgentMode = "default",
   exactComboSlugs: ReadonlySet<string> = new Set(),
+  config?: OcxConfig,
 ): RawEntry[] {
   // Codex's models-manager sorts by `priority` ASC and advertises the first 5 picker-visible
   // models to spawn_agent (sort_by_key(priority) + MAX_MODEL_OVERRIDES_IN_SPAWN_AGENT=5). Catalog
@@ -268,6 +272,7 @@ export function buildCatalogEntries(
     .map(catalogModelSlug));
   for (const slug of gptSlugs) {
     const e = deriveEntry(template, slug, "OpenAI native model (Codex OAuth passthrough).", 9);
+    applyNativeOpenAiContextOverride(e, config);
     if (rank.has(slug)) e.priority = rank.get(slug)!;
     out.push(e);
   }
@@ -367,6 +372,7 @@ export function mergeCatalogEntriesForSync(
   exactComboSlugs: ReadonlySet<string> = new Set(),
   hasPhysicalComboProvider = false,
   includeNativeOpenAi = true,
+  config?: OcxConfig,
 ): RawEntry[] {
   const rank = new Map(featured.map((slug, i) => [slug, i] as const));
   const native = includeNativeOpenAi
@@ -475,7 +481,7 @@ export function mergeCatalogEntriesForSync(
 
   const mergedEntries = [...native, ...finalRoutedEntries].map(m => {
     const normalized = normalizeServiceTiers(m);
-    applyNativeOpenAiContextOverride(normalized);
+    applyNativeOpenAiContextOverride(normalized, config);
     const exactCombo = typeof m.slug === "string" && exactComboSlugs.has(m.slug);
     const e = ensureStrictCatalogFields(normalized, {
       preserveExactInputModalities: exactCombo,
@@ -565,7 +571,7 @@ export async function syncCatalogModels(config: OcxConfig): Promise<{
   // bare gpt-* rows that hard-404 via NoEnabledOpenAiProviderError. Keep natives when no
   // providers are configured yet (fresh install / catalog bootstrap tests).
   const includeNativeOpenAi = enabledProviders.length === 0 || hasCanonicalOpenai;
-  catalog.models = mergeCatalogEntriesForSync(catalogModelsForMerge, goEntries, baseline, featured, wsEnabled, goIds, template, disabledNativeSlugs(config), gatheredProviderNames, multiAgentMode, exactComboSlugs, hasPhysicalComboProvider, includeNativeOpenAi);
+  catalog.models = mergeCatalogEntriesForSync(catalogModelsForMerge, goEntries, baseline, featured, wsEnabled, goIds, template, disabledNativeSlugs(config), gatheredProviderNames, multiAgentMode, exactComboSlugs, hasPhysicalComboProvider, includeNativeOpenAi, config);
   clampCatalogModelsToCodexSupport(catalog.models);
 
   atomicWriteFile(catalogPath, JSON.stringify(catalog, null, 2) + "\n");