@bitkyc08/opencodex 2.13.0 → 2.14.0

package/src/server/live.ts

@@ -19,6 +19,12 @@
  * - `GET /v1/live/{callId}` — Frameless
  * - `GET /v1/realtime/calls/{callId}` — path-form join
  * - `GET /v1/realtime?call_id=` — Realtime v1/v2 join
+ *
+ * Inbound standalone session WebSocket (no call-create; codex-rs `thread/realtime/start`
+ * with the standalone WebSocket transport — the desktop voice path since 0.147.x):
+ * - `GET /v1/realtime?intent=quicksilver&model=` — Realtime v1 standalone
+ * - `GET /v1/realtime?model=` — RealtimeV2 standalone (no intent)
+ * - `GET /v1/live?model=` — Frameless standalone
  */
 import { appendFileSync } from "node:fs";
 import { formatErrorResponse } from "../bridge";
@@ -32,7 +38,7 @@ import {
   CodexThreadAffinityExpiredError,
 } from "../codex/auth-context";
 import { formatCodexProviderForLog } from "../codex/routing";
-import { signalWithTimeout } from "../lib/abort";
+import { cancelBodyOnAbort, signalWithTimeout } from "../lib/abort";
 import { sidecarEnter } from "../lib/sidecar-tracker";
 import type { OcxConfig } from "../types";
 import { resolveFirstUsableOpenAiSidecar, selectOpenAiImagesProvider } from "../providers/openai-sidecar";
@@ -141,10 +147,59 @@ function clientProtocolHeaders(reqHeaders: Headers): Record<string, string> {
 
 const LIVE_CALL_ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
 
+/**
+ * Credential-shaped query keys never forwarded upstream on a standalone realtime
+ * relay. Auth on the upstream socket is proxy-owned (headers resolved by
+ * `resolveLiveRelay`); a caller that puts `access_token=`/`api_key=`/... in the
+ * URL must not get it relayed to the configured upstream. Compared case-folded on
+ * both the raw and percent-decoded key. Everything else — `intent`, `model`,
+ * duplicates, protocol extensions — passes through verbatim, matching codex-rs
+ * client behavior of constructing those fields itself.
+ */
+const STANDALONE_QUERY_DENYLIST = new Set([
+  "access_token",
+  "api_key",
+  "apikey",
+  "token",
+  "key",
+  "authorization",
+  "auth",
+  "signature",
+  "sig",
+]);
+
+/**
+ * Filter a raw query string (no leading `?`) for standalone upstream relay: drop
+ * denylisted credential-shaped pairs, preserve the rest byte-for-byte (including
+ * ordering, duplicates, noncanonical encodings, and bare keys).
+ */
+export function sanitizeStandaloneRealtimeQuery(rawQuery: string): string {
+  if (!rawQuery) return "";
+  const kept: string[] = [];
+  for (const pair of rawQuery.split("&")) {
+    const eq = pair.indexOf("=");
+    const rawKey = eq === -1 ? pair : pair.slice(0, eq);
+    let decodedKey = rawKey;
+    try {
+      decodedKey = decodeURIComponent(rawKey);
+    } catch {
+      // Leave undecodable keys as-is; the raw comparison still applies.
+    }
+    if (STANDALONE_QUERY_DENYLIST.has(rawKey.toLowerCase()) || STANDALONE_QUERY_DENYLIST.has(decodedKey.toLowerCase())) {
+      console.warn(`[live] standalone realtime relay dropping credential-shaped query param: ${decodedKey}`);
+      continue;
+    }
+    kept.push(pair);
+  }
+  return kept.join("&");
+}
+
 export type LiveSidebandTarget =
   | { style: "frameless-path"; callId: string }
   | { style: "realtime-calls-path"; callId: string }
-  | { style: "realtime-query"; callId: string };
+  | { style: "realtime-query"; callId: string }
+  | { style: "realtime-standalone"; query: string }
+  | { style: "frameless-standalone"; query: string };
 
 export type LiveRelayTarget = {
   headers: Record<string, string>;
@@ -168,7 +223,7 @@ export function keyedLiveUrl(baseUrl: string): string {
 }
 
 export function forwardLiveUrl(baseUrl: string, usesBackendShape: boolean): string {
-  const root = baseUrl.replace(/\/$/, "");
+  const root = baseUrl.replace(/\/+$/, "");
   if (usesBackendShape) return withAvasQuery(`${root}/realtime/calls`);
   // Frameless API shape posts to /live without the AVAS query (codex RealtimeCallClient).
   return `${root}/live`;
@@ -180,13 +235,17 @@ function httpsToWss(httpUrl: string): string {
   return httpUrl;
 }
 
-export function parseLiveSidebandTarget(pathname: string, searchParams: URLSearchParams): LiveSidebandTarget | null {
+export function parseLiveSidebandTarget(pathname: string, searchParams: URLSearchParams, rawQuery = ""): LiveSidebandTarget | null {
   const liveMatch = pathname.match(/^\/v1\/live\/([^/]+)\/?$/);
   if (liveMatch) {
     const callId = decodeURIComponent(liveMatch[1]!);
     if (!LIVE_CALL_ID_RE.test(callId)) return null;
     return { style: "frameless-path", callId };
   }
+  // Standalone Frameless session (no call-create): `GET /v1/live?model=`.
+  if (pathname === "/v1/live" || pathname === "/v1/live/") {
+    return { style: "frameless-standalone", query: sanitizeStandaloneRealtimeQuery(rawQuery) };
+  }
   const callsMatch = pathname.match(/^\/v1\/realtime\/calls\/([^/]+)\/?$/);
   if (callsMatch) {
     const callId = decodeURIComponent(callsMatch[1]!);
@@ -194,9 +253,17 @@ export function parseLiveSidebandTarget(pathname: string, searchParams: URLSearc
     return { style: "realtime-calls-path", callId };
   }
   if (pathname === "/v1/realtime" || pathname === "/v1/realtime/") {
-    const callId = searchParams.get("call_id")?.trim() ?? "";
-    if (!LIVE_CALL_ID_RE.test(callId)) return null;
-    return { style: "realtime-query", callId };
+    // A present-but-invalid `call_id` is a malformed join, not a standalone
+    // session — keep rejecting it instead of silently changing the request's
+    // meaning.
+    if (searchParams.has("call_id")) {
+      const callId = searchParams.get("call_id")?.trim() ?? "";
+      if (!LIVE_CALL_ID_RE.test(callId)) return null;
+      return { style: "realtime-query", callId };
+    }
+    // Standalone Realtime session (codex-rs thread/realtime/start, WebSocket
+    // transport): v1 sends `intent=quicksilver&model=`, v2 sends `model=` only.
+    return { style: "realtime-standalone", query: sanitizeStandaloneRealtimeQuery(rawQuery) };
   }
   return null;
 }
@@ -286,6 +353,12 @@ export function buildLiveSidebandUpstreamWsUrl(
   if (target.style === "frameless-path") {
     return httpsToWss(`${sidebandRoot}/live/${target.callId}`);
   }
+  if (target.style === "frameless-standalone") {
+    return httpsToWss(`${sidebandRoot}/live${target.query ? `?${target.query}` : ""}`);
+  }
+  if (target.style === "realtime-standalone") {
+    return httpsToWss(`${sidebandRoot}/realtime${target.query ? `?${target.query}` : ""}`);
+  }
   if (target.style === "realtime-calls-path") {
     return httpsToWss(`${sidebandRoot}/realtime/calls/${target.callId}`);
   }
@@ -364,8 +437,18 @@ export async function readBodyCapped(
       }
       chunks.push(value);
     }
+  } catch (err) {
+    // A read that throws leaves the stream neither drained nor cancelled, and releasing the
+    // lock alone hands back an unsettled body. Cancel first, then rethrow so the caller's
+    // existing classification (client abort / timeout / connect error) is unchanged. The
+    // cancel itself can reject with the stream's stored error — that is expected and must not
+    // mask the original failure, so it is swallowed here.
+    await reader.cancel(err).catch(() => {});
+    throw err;
   } finally {
     try {
+      // Always release: `reader.cancel()` does NOT drop the lock, and holding it would leave
+      // the stream permanently locked for any later consumer (audit R-WP5-2).
       reader.releaseLock();
     } catch {
       // already released / cancelled
@@ -546,7 +629,12 @@ export async function handleLive(
       outboundContentType = rewritten.contentType;
     }
   } else {
-    url = keyedLiveUrl(relay.providerBaseUrl);
+    // Frameless API-shape call-create posts to `{base}/live` without the AVAS
+    // query (openai/codex RealtimeCallClient, realtime_call.rs); only the
+    // realtime/calls inbound shape keeps the legacy keyed AVAS endpoint.
+    url = new URL(req.url).pathname === "/v1/live"
+      ? forwardLiveUrl(relay.providerBaseUrl, /* usesBackendShape */ false)
+      : keyedLiveUrl(relay.providerBaseUrl);
   }
 
   headers["content-type"] = outboundContentType;
@@ -559,15 +647,31 @@ export async function handleLive(
       headers,
       body: outboundBody,
       signal: linkedSignal.signal,
+      // Credential-bearing: do not follow a cross-origin 3xx. Bun strips `Authorization`
+      // across origins but forwards nonstandard headers such as `chatgpt-account-id`,
+      // `session_id`, and `x-codex-turn-metadata` to the redirect target.
+      redirect: "manual",
     });
     // Record every completed upstream response before body size handling so account health /
     // cooldown still updates when we reject an oversized payload.
     relay.recordOutcome?.(upstreamResponse.status);
-    const payload = await readBodyCapped(
-      upstreamResponse.body,
-      LIVE_RESPONSE_MAX_BYTES,
-      total => `live response too large (${total} bytes)`,
-    );
+    // Settle the body on abort before the reader attaches. Without this, a client cancel or the
+    // linked timeout landing between fetch resolution and `readBodyCapped`'s `getReader()`
+    // leaves Bun's internal read rejection orphaned off the awaited path, where no caller
+    // try/catch can intercept it (src/lib/abort.ts). The guard covers the window BEFORE the
+    // reader exists; once a reader holds the lock only the reader can cancel, which is why
+    // readBodyCapped also cancels on a failed read. Found while investigating #1419.
+    const detachBodyGuard = cancelBodyOnAbort(upstreamResponse.body, linkedSignal.signal);
+    let payload: ArrayBuffer | Response;
+    try {
+      payload = await readBodyCapped(
+        upstreamResponse.body,
+        LIVE_RESPONSE_MAX_BYTES,
+        total => `live response too large (${total} bytes)`,
+      );
+    } finally {
+      detachBodyGuard();
+    }
     if (payload instanceof Response) return payload;
     const relayHeaders: Record<string, string> = {};
     for (const name of LIVE_RELAY_HEADERS) {

package/src/server/local-provider-reload-client.ts

@@ -0,0 +1,137 @@
+import { readRuntimePort, type RuntimePortState } from "../config";
+import {
+  LOCAL_ATTESTATION_CHALLENGE_HEADER,
+  LOCAL_ATTESTATION_PROOF_HEADER,
+  createLocalAttestationChallenge,
+  verifyLocalAttestationProof,
+} from "../lib/local-management-attestation";
+import {
+  LOCAL_PROVIDER_RELOAD_CAPABILITY_HEADER,
+  LOCAL_PROVIDER_RELOAD_CAPABILITY_TTL_MS,
+  LOCAL_PROVIDER_RELOAD_CAPABILITY_VERSION,
+  LOCAL_PROVIDER_RELOAD_EXPECTED_PID_HEADER,
+  LOCAL_PROVIDER_RELOAD_EXPIRES_AT_HEADER,
+  LOCAL_PROVIDER_RELOAD_METHOD,
+  LOCAL_PROVIDER_RELOAD_NAME_HEADER,
+  LOCAL_PROVIDER_RELOAD_NONCE_HEADER,
+  LOCAL_PROVIDER_RELOAD_PATH,
+  createLocalProviderReloadCapability,
+  isLocalProviderReloadName,
+} from "../lib/local-provider-reload-contract";
+import { directLocalHttpFetch } from "./direct-local-http";
+import { isOpencodexHealthz, probeHostname, type HealthzIdentity, type LiveProxy } from "./proxy-liveness";
+
+export type LocalProviderReloadResult =
+  | { kind: "reloaded" }
+  | { kind: "unavailable"; reason: "invalid-name" | "unattested-target" | "runtime-mismatch" | "attestation" | "capability" | "transport" | "rejected" };
+
+export interface LocalProviderReloadDeps {
+  fetchImpl?: typeof fetch;
+  readRuntime?: (pid: number) => RuntimePortState | null;
+  createNonce?: () => string;
+  now?: () => number;
+  timeoutMs?: number;
+}
+
+const LOCAL_PROVIDER_RELOAD_TIMEOUT_MS = 10_000;
+
+/**
+ * Ask the exact runtime proxy to reload one already-persisted provider.
+ *
+ * No provider object, API key, OAuth token, custom header, or reusable management
+ * credential crosses the socket. The request is bodyless and its one-shot capability
+ * binds the provider name to the attested process, method, path, PID, port, and expiry.
+ */
+export async function requestBoundLocalProviderReload(
+  target: LiveProxy,
+  name: string,
+  deps: LocalProviderReloadDeps = {},
+): Promise<LocalProviderReloadResult> {
+  if (!isLocalProviderReloadName(name)) return { kind: "unavailable", reason: "invalid-name" };
+  if (target.source !== "runtime" || target.pid === null || target.pid <= 0) {
+    return { kind: "unavailable", reason: "unattested-target" };
+  }
+  const readRuntime = deps.readRuntime ?? readRuntimePort;
+  const runtime = readRuntime(target.pid);
+  if (
+    !runtime?.attestationSecret
+    || runtime.pid !== target.pid
+    || runtime.port !== target.port
+  ) {
+    return { kind: "unavailable", reason: "runtime-mismatch" };
+  }
+
+  const fetchImpl = deps.fetchImpl ?? directLocalHttpFetch;
+  const timeoutMs = deps.timeoutMs ?? LOCAL_PROVIDER_RELOAD_TIMEOUT_MS;
+  const nonce = (deps.createNonce ?? createLocalAttestationChallenge)();
+  const baseUrl = `http://${probeHostname(target.hostname)}:${target.port}`;
+  let proofResponse: Response;
+  try {
+    proofResponse = await fetchImpl(`${baseUrl}/healthz`, {
+      headers: { [LOCAL_ATTESTATION_CHALLENGE_HEADER]: nonce },
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+  } catch {
+    return { kind: "unavailable", reason: "transport" };
+  }
+  const body = await proofResponse.json().catch(() => null) as HealthzIdentity | null;
+  if (
+    !proofResponse.ok
+    || !isOpencodexHealthz(body)
+    || body?.pid !== target.pid
+    || body?.port !== target.port
+    || body?.providerReloadCapability !== LOCAL_PROVIDER_RELOAD_CAPABILITY_VERSION
+    || !verifyLocalAttestationProof(
+      runtime.attestationSecret,
+      nonce,
+      target.pid,
+      target.port,
+      proofResponse.headers.get(LOCAL_ATTESTATION_PROOF_HEADER),
+    )
+  ) {
+    return { kind: "unavailable", reason: "attestation" };
+  }
+
+  const currentRuntime = readRuntime(target.pid);
+  if (
+    !currentRuntime?.attestationSecret
+    || currentRuntime.pid !== runtime.pid
+    || currentRuntime.port !== runtime.port
+    || currentRuntime.hostname !== runtime.hostname
+    || currentRuntime.attestationSecret !== runtime.attestationSecret
+  ) {
+    return { kind: "unavailable", reason: "runtime-mismatch" };
+  }
+
+  const expiresAt = (deps.now ?? Date.now)() + LOCAL_PROVIDER_RELOAD_CAPABILITY_TTL_MS;
+  const capability = createLocalProviderReloadCapability(
+    runtime.attestationSecret,
+    nonce,
+    LOCAL_PROVIDER_RELOAD_METHOD,
+    LOCAL_PROVIDER_RELOAD_PATH,
+    name,
+    target.pid,
+    target.port,
+    expiresAt,
+  );
+  if (!capability) return { kind: "unavailable", reason: "capability" };
+
+  try {
+    const response = await fetchImpl(`${baseUrl}${LOCAL_PROVIDER_RELOAD_PATH}`, {
+      method: LOCAL_PROVIDER_RELOAD_METHOD,
+      headers: {
+        [LOCAL_PROVIDER_RELOAD_EXPECTED_PID_HEADER]: String(target.pid),
+        [LOCAL_PROVIDER_RELOAD_NONCE_HEADER]: nonce,
+        [LOCAL_PROVIDER_RELOAD_EXPIRES_AT_HEADER]: String(expiresAt),
+        [LOCAL_PROVIDER_RELOAD_NAME_HEADER]: name,
+        [LOCAL_PROVIDER_RELOAD_CAPABILITY_HEADER]: capability,
+      },
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    return response.ok
+      ? { kind: "reloaded" }
+      : { kind: "unavailable", reason: "rejected" };
+  } catch {
+    return { kind: "unavailable", reason: "transport" };
+  }
+}

package/src/server/management/config-routes.ts

@@ -410,7 +410,11 @@ export async function handleConfigRoutes(ctx: ManagementContext): Promise<Respon
     const vs = config.visionSidecar ?? {};
     const vision = await sidecarVisionResponseSettings(config);
     return jsonResponse({
-      webSearch: { model: ws.model ?? "gpt-5.6-luna", backend: ws.backend },
+      webSearch: {
+        model: ws.model ?? "gpt-5.6-luna",
+        backend: ws.backend,
+        streamRoutedModelOutput: ws.streamRoutedModelOutput === true,
+      },
       vision: {
         model: vision.model,
         backend: vs.backend,
@@ -430,13 +434,17 @@ export async function handleConfigRoutes(ctx: ManagementContext): Promise<Respon
     if (raw.webSearch !== undefined && !isPlainRecord(raw.webSearch)) return jsonResponse({ error: "webSearch must be an object" }, 400);
     if (raw.vision !== undefined && !isPlainRecord(raw.vision)) return jsonResponse({ error: "vision must be an object" }, 400);
     const body = raw as {
-      webSearch?: { model?: unknown; backend?: unknown; reasoning?: unknown };
+      webSearch?: { model?: unknown; backend?: unknown; reasoning?: unknown; streamRoutedModelOutput?: unknown };
       vision?: { model?: unknown; backend?: unknown; reasoning?: unknown; maxDescriptionsPerTurn?: unknown };
     };
     if (body.webSearch && body.webSearch.backend !== undefined && body.webSearch.backend !== null
       && body.webSearch.backend !== "openai" && body.webSearch.backend !== "anthropic") {
       return jsonResponse({ error: "webSearch.backend must be openai, anthropic, or null" }, 400);
     }
+    if (body.webSearch && body.webSearch.streamRoutedModelOutput !== undefined
+      && typeof body.webSearch.streamRoutedModelOutput !== "boolean") {
+      return jsonResponse({ error: "webSearch.streamRoutedModelOutput must be a boolean" }, 400);
+    }
     if (body.vision && body.vision.backend !== undefined
       && body.vision.backend !== null && body.vision.backend !== "openai" && body.vision.backend !== "anthropic") {
       return jsonResponse({ error: "vision.backend must be openai, anthropic, or null" }, 400);
@@ -490,6 +498,11 @@ export async function handleConfigRoutes(ctx: ManagementContext): Promise<Respon
         config.webSearchSidecar.backend = body.webSearch.backend;
       }
       if (typeof body.webSearch.reasoning === "string") config.webSearchSidecar.reasoning = body.webSearch.reasoning;
+      if (typeof body.webSearch.streamRoutedModelOutput === "boolean") {
+        // `false` is the default — drop the key so config files stay minimal.
+        if (body.webSearch.streamRoutedModelOutput) config.webSearchSidecar.streamRoutedModelOutput = true;
+        else delete config.webSearchSidecar.streamRoutedModelOutput;
+      }
     }
     if (body.vision) {
       config.visionSidecar = { ...config.visionSidecar };
@@ -515,7 +528,11 @@ export async function handleConfigRoutes(ctx: ManagementContext): Promise<Respon
     const vision = await sidecarVisionResponseSettings(config);
     return jsonResponse({
       ok: true,
-      webSearch: { model: ws.model ?? "gpt-5.6-luna", backend: ws.backend },
+      webSearch: {
+        model: ws.model ?? "gpt-5.6-luna",
+        backend: ws.backend,
+        streamRoutedModelOutput: ws.streamRoutedModelOutput === true,
+      },
       vision: {
         model: vision.model,
         backend: vs.backend,

package/src/server/management/logs-usage-routes.ts

@@ -121,6 +121,29 @@ function refreshedUsageSummary<T extends UsageSummary & { historyTruncated: bool
   return { ...summary, since, generatedAt: now };
 }
 
+/**
+ * Timestamp bounds of the rows the bounded reader actually loaded.
+ *
+ * Deliberately computed over the whole snapshot, BEFORE `summarizeUsage` applies the range
+ * and surface predicates: truncation is a property of the read, not of the query, so the
+ * window that matters to a client is the one the reader could see. It is not a completeness
+ * claim and must never be presented as one. `usage.jsonl` is appended when a request
+ * COMPLETES while each row carries the request START time, so a long-running request can be
+ * appended after shorter ones that started later — meaning the oldest loaded timestamp does
+ * not bound what the dropped prefix contains (#1497).
+ */
+function snapshotWindow(entries: PersistedUsageEntry[]): { start: number | null; end: number | null } {
+  let start: number | null = null;
+  let end: number | null = null;
+  for (const entry of entries) {
+    const at = entry.timestamp;
+    if (typeof at !== "number" || !Number.isFinite(at)) continue;
+    if (start === null || at < start) start = at;
+    if (end === null || at > end) end = at;
+  }
+  return { start, end };
+}
+
 export async function handleLogsUsageRoutes(ctx: ManagementContext): Promise<Response | null> {
   const { req, url, config, deps, syncClaudeAgentDefsBestEffort } = ctx;
 
@@ -209,12 +232,15 @@ export async function handleLogsUsageRoutes(ctx: ManagementContext): Promise<Res
       const overlayVersion = userCostOverlayVersion();
       const snapshot = await readUsageSnapshotForManagement(effectiveReadLimit);
       const revisionReadAt = Date.now();
+      const window = snapshotWindow(snapshot.entries);
       const summary = {
         ...summarizeUsage(snapshot.entries, range, now, surface),
         historyTruncated: snapshot.truncatedPrefixBytes > 0 || snapshot.entriesTruncated,
         truncatedPrefixBytes: snapshot.truncatedPrefixBytes,
         entriesTruncated: snapshot.entriesTruncated,
         entriesDropped: snapshot.entriesDropped,
+        snapshotWindowStart: window.start,
+        snapshotWindowEnd: window.end,
       };
       if (userCostOverlayVersion() !== overlayVersion) {
         // The overlay changed while the summary was being computed, so this
@@ -266,6 +292,8 @@ export async function handleLogsUsageRoutes(ctx: ManagementContext): Promise<Res
         truncatedPrefixBytes: 0,
         entriesTruncated: false,
         entriesDropped: 0,
+        snapshotWindowStart: null,
+        snapshotWindowEnd: null,
         error: "read_failed",
       });
     }

package/src/server/management/model-routes.ts

@@ -30,7 +30,7 @@ function readInputModalities(raw: unknown): { values?: string[]; error?: string
   return { values: raw as string[] };
 }
 import type { CatalogModel } from "../../codex/catalog";
-import { catalogModelSlug, configuredNativeAliasSlugs, disabledNativeSlugs, invalidateCodexModelsCache, nativeModelRows, uniqueCatalogModelsForPublicList } from "../../codex/catalog";
+import { accountBoundNativeOpenAiSlugsBySelector, catalogModelSlug, configuredNativeAliasSlugs, disabledNativeSlugs, invalidateCodexModelsCache, nativeModelRows, shouldIncludeAccountBoundNativeOpenAi, uniqueCatalogModelsForPublicList } from "../../codex/catalog";
 import { CatalogGatherBusyError } from "../../codex/catalog/provider-fetch";
 import { getProviderLiveModelCount } from "../../codex/model-cache";
 import {
@@ -234,7 +234,14 @@ export async function handleModelRoutes(ctx: ManagementContext): Promise<Respons
     if (!providerConfig && provider !== "openai" && !isVirtualComboNamespace) {
       return jsonResponse({ error: "unknown model visibility provider" }, 400);
     }
-    const supportedNative = new Set(nativeModelRows(config).map(row => row.slug));
+    const accountNativeQualified = shouldIncludeAccountBoundNativeOpenAi(config)
+      ? [...accountBoundNativeOpenAiSlugsBySelector(config).entries()].flatMap(([selector, slugs]) =>
+        slugs.filter(slug => !nativeModelRows(config).some(row => row.slug === slug)).map(slug => `${selector}/${slug}`))
+      : [];
+    const supportedNative = new Set([
+      ...nativeModelRows(config).map(row => row.slug),
+      ...accountNativeQualified,
+    ]);
     const targets: Array<{ id: string; native: boolean }> = [];
     const seen = new Set<string>();
     for (const value of body.targets) {
@@ -283,13 +290,14 @@ export async function handleModelRoutes(ctx: ManagementContext): Promise<Respons
           const nativeIds = provider === "openai"
             ? disabledNativeSlugs({ disabledModels: disabled })
             : new Set<string>();
+          const accountNativeIds = provider === "openai" ? new Set(accountNativeQualified) : new Set<string>();
           const nativeAliasSlugs = provider === "openai"
             ? configuredNativeAliasSlugs(config)
             : new Set<string>();
           disabled = disabled.filter(stored => (
             knownComboSelectors.has(stored)
             || nativeAliasSlugs.has(stored)
-            || (!stored.startsWith(`${provider}/`) && !nativeIds.has(stored))
+            || (!stored.startsWith(`${provider}/`) && !nativeIds.has(stored) && !accountNativeIds.has(stored))
           ));
         }
       } else {

package/src/server/management/model-rows.ts

@@ -11,11 +11,14 @@
 import type { CatalogModel } from "../../codex/catalog";
 import {
   catalogModelSlug,
+  accountBoundNativeOpenAiSlugsBySelector,
   nativeDefaultReasoningEffort,
+  NATIVE_OPENAI_MODELS,
   nativeInputModalities,
   nativeModelRows,
   nativeReasoningEfforts,
   uniqueCatalogModelsForPublicList,
+  shouldIncludeAccountBoundNativeOpenAi,
 } from "../../codex/catalog";
 import type { ExportModel } from "../../clients/config-export";
 import { providerContextCap } from "../../providers/context-cap";
@@ -49,9 +52,21 @@ export async function listManagementModelRows(config: OcxConfig): Promise<Manage
   const disabled = new Set(config.disabledModels ?? []);
   // Native GPT passthrough rows lead (provider "openai", bare-slug namespaced ids): sourced
   // from the static supported set so a disabled model stays listed and re-enableable.
-  const native: ManagementModelRow[] = nativeModelRows(config).map(row => {
-    const reasoningEfforts = nativeReasoningEfforts(row.slug).filter(isVisionReasoningEffort);
-    const defaultReasoningEffort = nativeDefaultReasoningEffort(row.slug);
+  const nativeRows = nativeModelRows(config).map(row => ({ ...row, metadataSlug: row.slug }));
+  const accountNativeRows = shouldIncludeAccountBoundNativeOpenAi(config)
+    ? [...accountBoundNativeOpenAiSlugsBySelector(config).entries()].flatMap(([selector, slugs]) =>
+      slugs
+        .filter(slug => !NATIVE_OPENAI_MODELS.includes(slug))
+        .map(slug => ({
+          slug: `${selector}/${slug}`,
+          metadataSlug: slug,
+          disabled: disabled.has(`${selector}/${slug}`) || disabled.has(slug),
+          contextWindow: undefined,
+        })))
+    : [];
+  const native: ManagementModelRow[] = [...nativeRows, ...accountNativeRows].map(row => {
+    const reasoningEfforts = nativeReasoningEfforts(row.metadataSlug).filter(isVisionReasoningEffort);
+    const defaultReasoningEffort = nativeDefaultReasoningEffort(row.metadataSlug);
     return {
       provider: "openai",
       id: row.slug,