@yansigit/opencodex 2.31.3 → 2.33.0

package/src/lib/provider-outbound.ts

@@ -7,12 +7,14 @@ import {
   resolvePublicAddresses,
 } from "./destination-policy";
 import { pinnedHttpGet, pinnedHttpPost } from "./pinned-http";
-import { outboundProxyConfigured } from "./proxy-env";
+import { noProxyMatches, outboundProxyConfigured, proxyForUrl } from "./proxy-env";
 import { publicProviderBaseUrl } from "./provider-url";
+import { antigravityOAuthDestinationConfigError, isCanonicalAntigravityUrl, providerTlsFetch } from "./provider-tls-profile";
+import { waitForProviderRequestSlot } from "../providers/request-pacing";
 
 type ProviderGetInit = Omit<RequestInit, "body" | "method" | "redirect">;
 type ProviderPostInit = ProviderGetInit & { body: string };
-type ProviderOutboundConfig = Pick<OcxProviderConfig, "baseUrl" | "allowPrivateNetwork"> & {
+type ProviderOutboundConfig = Pick<OcxProviderConfig, "baseUrl" | "allowPrivateNetwork"> & Partial<Pick<OcxProviderConfig, "adapter" | "authMode" | "googleMode" | "tlsProfile">> & {
   fetch?: typeof globalThis.fetch;
 };
 export interface ProviderOutboundDependencies {
@@ -40,36 +42,26 @@ function normalizeProxyHostname(hostname: string): string {
     : normalized;
 }
 
-function noProxyMatches(url: URL): boolean {
-  const raw = process.env.NO_PROXY ?? process.env.no_proxy ?? "";
-  const hostname = normalizeProxyHostname(url.hostname);
-  const port = url.port || (url.protocol === "https:" ? "443" : "80");
-  for (const rawEntry of raw.split(",")) {
-    let entry = rawEntry.trim().toLowerCase();
-    if (!entry) continue;
-    if (entry === "*") return true;
-    entry = entry.replace(/^https?:\/\//, "").split("/", 1)[0]!;
-
-    let entryHost = entry;
-    let entryPort = "";
-    const bracketed = /^\[([^\]]+)](?::(\d+))?$/.exec(entry);
-    if (bracketed) {
-      entryHost = bracketed[1]!;
-      entryPort = bracketed[2] ?? "";
-    } else if ((entry.match(/:/g)?.length ?? 0) === 1) {
-      const separator = entry.lastIndexOf(":");
-      const possiblePort = entry.slice(separator + 1);
-      if (/^\d+$/.test(possiblePort)) {
-        entryHost = entry.slice(0, separator);
-        entryPort = possiblePort;
-      }
-    }
-    if (entryPort && entryPort !== port) continue;
-    entryHost = normalizeProxyHostname(entryHost.replace(/^\*?\./, ""));
-    if (!entryHost) continue;
-    if (hostname === entryHost || hostname.endsWith(`.${entryHost}`)) return true;
+function antigravityProfileFetch(
+  name: string,
+  provider: ProviderOutboundConfig,
+  url: string,
+): typeof globalThis.fetch | undefined {
+  if (name !== "google-antigravity"
+    || provider.fetch
+    || provider.tlsProfile !== "antigravity-browser"
+    || provider.adapter !== "google"
+    || provider.authMode !== "oauth"
+    || provider.googleMode !== "cloud-code-assist"
+    || !isCanonicalAntigravityUrl(provider.baseUrl)
+    || !isCanonicalAntigravityUrl(url)) {
+    return undefined;
   }
-  return false;
+  const nativeFetch = providerTlsFetch(name, provider as Parameters<typeof providerTlsFetch>[1], globalThis.fetch);
+  return (async (input: Parameters<typeof globalThis.fetch>[0], init?: RequestInit): Promise<Response> => {
+    await waitForProviderRequestSlot(name, provider as OcxProviderConfig, undefined, init?.signal ?? undefined);
+    return nativeFetch(input, init);
+  }) as typeof globalThis.fetch;
 }
 
 let proxyBoundaryWarned = false;
@@ -112,11 +104,31 @@ async function providerOutboundRequest(
   init: ProviderGetInit | ProviderPostInit,
   dependencies: ProviderOutboundDependencies = {},
 ): Promise<Response> {
+  const antigravityBaseError = antigravityOAuthDestinationConfigError(name, provider);
+  if (antigravityBaseError) throw new ProviderOutboundPolicyError(`provider ${name} ${antigravityBaseError}`);
+  if (name === "google-antigravity" && !isCanonicalAntigravityUrl(url)) {
+    throw new ProviderOutboundPolicyError("provider google-antigravity requires a canonical Antigravity HTTPS destination for OAuth");
+  }
   const postUrl = method === "POST" ? new URL(url) : undefined;
   if (postUrl?.protocol !== undefined && postUrl.protocol !== "https:") {
     throw new ProviderOutboundPolicyError("provider POST URL must use HTTPS");
   }
-  if (provider.fetch) {
+  const profiledFetch = antigravityProfileFetch(name, provider, url);
+  const fetchOverride = provider.fetch ?? profiledFetch;
+  if (profiledFetch) {
+    // Keep the profiled executor behind the same pre-dispatch DNS boundary as
+    // the pinned path. A proxy owns peer selection, so match the existing
+    // providerOutbound proxy boundary and deliberately skip local resolution.
+    if (!proxyForUrl(url)) {
+      const resolveAddresses = dependencies.resolveAddresses ?? resolvePublicAddresses;
+      await resolveAddresses(url, {
+        context: "provider URL",
+        allowPrivateNetwork: false,
+      });
+    }
+    return fetchOverride!(url, { ...init, method, redirect: "manual" });
+  }
+  if (fetchOverride) {
     // A caller-owned executor cannot be peer-pinned here. This branch keeps literal/config
     // checks and redirect blocking, but does not provide the resolved-address guarantees of
     // the built-in transport. Main-request migration must define that executor contract first.
@@ -135,7 +147,7 @@ async function providerOutboundRequest(
       });
       if (destinationError) throw new ProviderOutboundPolicyError(destinationError);
     }
-    return provider.fetch(url, { ...init, method, redirect: "manual" });
+    return fetchOverride(url, { ...init, method, redirect: "manual" });
   }
   const parsed = postUrl ?? new URL(url);
   const proxyConfigured = configuredProxyFor();

package/src/lib/provider-tls-profile.ts

@@ -0,0 +1,309 @@
+import { createHash } from "node:crypto";
+import type { OcxProviderConfig, ProviderTlsProfile } from "../types";
+import { resolvePublicAddresses } from "./destination-policy";
+import { registerOptionalShutdownHook } from "./optional-shutdown-hooks";
+import { proxyForUrl } from "./proxy-env";
+import { redactErrorMessage } from "./redact";
+
+export const ANTIGRAVITY_TLS_HOSTS = new Set([
+  "daily-cloudcode-pa.googleapis.com",
+  "cloudcode-pa.googleapis.com",
+]);
+
+export type ProviderTlsProfileStatus = "disabled" | "active" | "fallback";
+
+interface WreqTransport {
+  close(): Promise<void>;
+}
+
+interface WreqModule {
+  createTransport(options: {
+    browser: "chrome_142";
+    os: "windows" | "macos" | "linux";
+    proxy?: string;
+  }): Promise<WreqTransport>;
+  fetch(input: string | URL | Request, init?: Record<string, unknown>): Promise<unknown>;
+}
+
+interface InitializedTransport {
+  module: WreqModule;
+  transport: WreqTransport;
+}
+
+type ProviderTlsContract = Pick<OcxProviderConfig, "adapter" | "authMode" | "googleMode" | "baseUrl" | "tlsProfile">;
+
+type AntigravityOAuthDestinationContract = Pick<OcxProviderConfig, "baseUrl"> & Partial<Pick<OcxProviderConfig, "adapter" | "authMode" | "googleMode">>;
+
+export interface ProviderTlsRuntimeForTest {
+  importWreq: () => Promise<WreqModule>;
+  resolveDestination?: typeof resolvePublicAddresses;
+}
+
+const defaultRuntime: ProviderTlsRuntimeForTest = {
+  importWreq: async () => await import("wreq-js") as unknown as WreqModule,
+};
+
+let runtime = defaultRuntime;
+const statusByProvider = new Map<string, { status: ProviderTlsProfileStatus; fingerprint: string }>();
+const transports = new Map<string, Promise<InitializedTransport | undefined>>();
+let shutdownDetach: (() => void) | undefined;
+let fallbackWarned = false;
+
+function providerTlsContractFingerprint(providerName: string, provider: ProviderTlsContract): string {
+  return createHash("sha256").update(JSON.stringify([
+    providerName,
+    provider.adapter,
+    provider.authMode,
+    provider.googleMode,
+    provider.baseUrl,
+    provider.tlsProfile,
+  ])).digest("hex");
+}
+
+function setStatus(providerName: string, provider: ProviderTlsContract, status: ProviderTlsProfileStatus): void {
+  statusByProvider.set(providerName, { status, fingerprint: providerTlsContractFingerprint(providerName, provider) });
+}
+
+const SAFE_NATIVE_ERROR_NAMES = new Set(["AbortError", "TimeoutError"]);
+const SAFE_NATIVE_ERROR_CODES = new Set([
+  "ABORT_ERR", "ECONNREFUSED", "ECONNRESET", "EAI_AGAIN", "ENETUNREACH", "ENOTFOUND",
+  "ETIMEDOUT", "UND_ERR_CONNECT_TIMEOUT", "UND_ERR_SOCKET",
+]);
+
+function safeProviderTlsError(error: unknown): Error {
+  const raw = error instanceof Error ? error.message : String(error);
+  const safe = new Error(redactErrorMessage(raw));
+  if (!error || typeof error !== "object") return safe;
+  const native = error as { name?: unknown; code?: unknown };
+  if (typeof native.name === "string" && SAFE_NATIVE_ERROR_NAMES.has(native.name)) {
+    safe.name = native.name;
+  }
+  if (typeof native.code === "string" && SAFE_NATIVE_ERROR_CODES.has(native.code)) {
+    Object.defineProperty(safe, "code", {
+      configurable: true,
+      enumerable: false,
+      value: native.code,
+      writable: false,
+    });
+  }
+  return safe;
+}
+
+function warnFallbackOnce(): void {
+  if (fallbackWarned) return;
+  fallbackWarned = true;
+  console.warn("[opencodex] Antigravity TLS profile requested → fallback to Bun fetch; native transport initialization failed");
+}
+
+function emulationOs(): "windows" | "macos" | "linux" {
+  if (process.platform === "win32") return "windows";
+  if (process.platform === "darwin") return "macos";
+  if (process.platform === "linux") return "linux";
+  throw new Error("unsupported host operating system for Antigravity TLS profile");
+}
+
+function profileIsSupported(providerName: string, provider: Pick<OcxProviderConfig, "adapter" | "authMode" | "googleMode" | "baseUrl" | "tlsProfile">): boolean {
+  return providerName === "google-antigravity"
+    && provider.adapter === "google"
+    && provider.authMode === "oauth"
+    && provider.googleMode === "cloud-code-assist"
+    && isCanonicalAntigravityUrl(provider.baseUrl)
+    && provider.tlsProfile === "antigravity-browser";
+}
+
+export function providerTlsProfileConfigError(
+  providerName: string,
+  provider: Pick<OcxProviderConfig, "adapter" | "authMode" | "googleMode" | "baseUrl" | "tlsProfile">,
+): string | null {
+  if (provider.tlsProfile === undefined) return null;
+  if (provider.tlsProfile !== "antigravity-browser") {
+    return "tlsProfile must be antigravity-browser";
+  }
+  if (providerName !== "google-antigravity") return "tlsProfile antigravity-browser is valid only for google-antigravity";
+  if (provider.adapter !== "google" || provider.authMode !== "oauth") {
+    return "tlsProfile antigravity-browser requires Google OAuth authentication";
+  }
+  if (provider.googleMode !== "cloud-code-assist") {
+    return "tlsProfile antigravity-browser requires Google Cloud Code Assist mode";
+  }
+  if (!isCanonicalAntigravityUrl(provider.baseUrl)) {
+    return "tlsProfile antigravity-browser requires a canonical Antigravity HTTPS destination";
+  }
+  return null;
+}
+
+export function isCanonicalAntigravityUrl(input: string | URL): boolean {
+  try {
+    const url = new URL(input);
+    return url.protocol === "https:"
+      && (url.port === "" || url.port === "443")
+      && url.username === ""
+      && url.password === ""
+      && ANTIGRAVITY_TLS_HOSTS.has(url.hostname.toLowerCase());
+  } catch {
+    return false;
+  }
+}
+
+export function isAntigravityOAuthProvider(
+  providerName: string,
+  provider: Pick<OcxProviderConfig, "authMode">,
+): boolean {
+  return providerName === "google-antigravity"
+    && (provider.authMode === undefined || provider.authMode === "oauth");
+}
+
+/** Same-name Antigravity rows are OAuth destinations even when legacy config omitted authMode. */
+export function antigravityOAuthDestinationConfigError(
+  providerName: string,
+  provider: AntigravityOAuthDestinationContract,
+): string | null {
+  if (providerName !== "google-antigravity") return null;
+  if (provider.googleMode !== undefined && provider.googleMode !== "cloud-code-assist") {
+    return "requires Google Cloud Code Assist mode for OAuth";
+  }
+  if (!isCanonicalAntigravityUrl(provider.baseUrl)) {
+    return "requires a canonical Antigravity HTTPS destination for OAuth";
+  }
+  return null;
+}
+
+export function getProviderTlsProfileStatus(providerName: string, provider: ProviderTlsContract): ProviderTlsProfileStatus {
+  const current = statusByProvider.get(providerName);
+  return current?.fingerprint === providerTlsContractFingerprint(providerName, provider)
+    ? current.status
+    : "disabled";
+}
+
+export function clearProviderTlsProfileStatus(providerName: string): void {
+  statusByProvider.delete(providerName);
+}
+
+function registerShutdownHook(): void {
+  if (shutdownDetach) return;
+  shutdownDetach = registerOptionalShutdownHook("provider-tls-profile", () => {
+    const pending = [...transports.values()];
+    transports.clear();
+    shutdownDetach = undefined;
+    for (const transport of pending) {
+      void transport.then(value => value?.transport.close()).catch(() => undefined);
+    }
+  });
+}
+
+function transportKey(proxy: string | undefined): string {
+  return `${process.platform}:${proxy ?? "direct"}`;
+}
+
+async function getTransport(proxy: string | undefined): Promise<InitializedTransport | undefined> {
+  const key = transportKey(proxy);
+  const existing = transports.get(key);
+  if (existing) return existing;
+  const pending = (async () => {
+    let transport: WreqTransport | undefined;
+    try {
+      const module = await runtime.importWreq();
+      transport = await module.createTransport({
+        browser: "chrome_142",
+        os: emulationOs(),
+        ...(proxy ? { proxy } : {}),
+      });
+      registerShutdownHook();
+      return { module, transport };
+    } catch {
+      if (transport) await transport.close().catch(() => undefined);
+      return undefined;
+    }
+  })();
+  transports.set(key, pending);
+  return pending;
+}
+
+export function providerTlsFetch(
+  providerName: string,
+  provider: Pick<OcxProviderConfig, "adapter" | "authMode" | "googleMode" | "baseUrl" | "tlsProfile">,
+  bunFetch: typeof globalThis.fetch,
+): typeof globalThis.fetch {
+  const antigravityError = antigravityOAuthDestinationConfigError(providerName, provider);
+  if (antigravityError) {
+    return (async () => {
+      throw new Error(`provider ${providerName} ${antigravityError}`);
+    }) as unknown as typeof globalThis.fetch;
+  }
+  if (provider.tlsProfile === undefined) {
+    setStatus(providerName, provider, "disabled");
+    return bunFetch;
+  }
+  if (!profileIsSupported(providerName, provider)) {
+    setStatus(providerName, provider, "fallback");
+    warnFallbackOnce();
+    return bunFetch;
+  }
+  return (async (input: string | URL | Request, init?: RequestInit): Promise<Response> => {
+    const url = typeof input === "string" || input instanceof URL ? input : input.url;
+    if (!isCanonicalAntigravityUrl(url)) return bunFetch(input, init);
+    const proxy = proxyForUrl(url);
+    // A direct profiled request must pass the same public-destination gate as the
+    // ordinary provider executor before wreq can send its bearer-bearing request.
+    // Proxied requests deliberately leave peer selection to the configured proxy,
+    // matching providerOutbound's proxy boundary (and its inability to pin a peer).
+    if (!proxy) {
+      await (runtime.resolveDestination ?? resolvePublicAddresses)(String(url), {
+        context: "Antigravity profile URL",
+        allowPrivateNetwork: false,
+      });
+    }
+    const initialized = await getTransport(proxy);
+    if (!initialized) {
+      setStatus(providerName, provider, "fallback");
+      warnFallbackOnce();
+      return bunFetch(input, { ...init, redirect: "manual" });
+    }
+    setStatus(providerName, provider, "active");
+    const wreqInit = {
+      ...init,
+      transport: initialized.transport,
+      disableDefaultHeaders: true,
+      cookieMode: "ephemeral" as const,
+      redirect: "manual" as const,
+    };
+    try {
+      return await initialized.module.fetch(input, wreqInit) as Response;
+    } catch (error) {
+      // Native errors are post-dispatch failures. Redact at this boundary and
+      // never replay through Bun, since generation may already have started.
+      throw safeProviderTlsError(error);
+    }
+  }) as typeof globalThis.fetch;
+}
+
+export function setProviderTlsRuntimeForTest(next: ProviderTlsRuntimeForTest | undefined): void {
+  if (next === undefined) {
+    runtime = defaultRuntime;
+    return;
+  }
+  // Test callers normally replace only the native module. Keep those tests
+  // deterministic in offline sandboxes while allowing explicit DNS policy
+  // regressions to inject a rejecting resolver.
+  runtime = {
+    ...defaultRuntime,
+    resolveDestination: async (url: string) => ({
+      hostname: new URL(url).hostname,
+      addresses: [{ address: "142.250.1.1", family: 4 }],
+      privateNetwork: false,
+    }),
+    ...next,
+  };
+}
+
+export function resetProviderTlsProfileForTests(): void {
+  for (const pending of transports.values()) void pending.then(value => value?.transport.close()).catch(() => undefined);
+  transports.clear();
+  shutdownDetach?.();
+  shutdownDetach = undefined;
+  statusByProvider.clear();
+  fallbackWarned = false;
+  runtime = defaultRuntime;
+}
+
+export type { ProviderTlsProfile };

package/src/lib/proxy-env.ts

@@ -16,3 +16,52 @@ export function outboundProxyConfigured(
 ): boolean {
   return OUTBOUND_PROXY_ENV_KEYS.some(key => proxyEnvPresent(key, env));
 }
+
+function proxyValue(key: ProxyEnvKey, env: ProxyEnvMap): string | undefined {
+  const value = env[key]?.trim() || env[key.toLowerCase()]?.trim();
+  return value || undefined;
+}
+
+export function noProxyMatches(url: URL, env: ProxyEnvMap = process.env): boolean {
+  const raw = (env.NO_PROXY ?? env.no_proxy ?? "").trim();
+  const hostname = url.hostname.trim().toLowerCase().replace(/^\[|\]$/g, "").replace(/\.+$/, "");
+  const port = url.port || (url.protocol === "https:" ? "443" : "80");
+  for (const value of raw.split(",")) {
+    let entry = value.trim().toLowerCase();
+    if (!entry) continue;
+    if (entry === "*") return true;
+    entry = entry.replace(/^https?:\/\//, "").split("/", 1)[0]!;
+    let entryHost = entry;
+    let entryPort = "";
+    const bracketed = /^\[([^\]]+)](?::(\d+))?$/.exec(entry);
+    if (bracketed) {
+      entryHost = bracketed[1]!;
+      entryPort = bracketed[2] ?? "";
+    } else if ((entry.match(/:/g)?.length ?? 0) === 1) {
+      const separator = entry.lastIndexOf(":");
+      const possiblePort = entry.slice(separator + 1);
+      if (/^\d+$/.test(possiblePort)) {
+        entryHost = entry.slice(0, separator);
+        entryPort = possiblePort;
+      }
+    }
+    if (entryPort && entryPort !== port) continue;
+    entryHost = entryHost.replace(/^\*?\./, "").replace(/^\[|\]$/g, "").replace(/\.+$/, "");
+    if (entryHost && (hostname === entryHost || hostname.endsWith(`.${entryHost}`))) return true;
+  }
+  return false;
+}
+
+/** Select the standard proxy for a URL without exposing its credentials. */
+export function proxyForUrl(url: string | URL, env: ProxyEnvMap = process.env): string | undefined {
+  let parsed: URL;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return undefined;
+  }
+  if (noProxyMatches(parsed, env)) return undefined;
+  if (parsed.protocol === "https:") return proxyValue("HTTPS_PROXY", env) ?? proxyValue("ALL_PROXY", env);
+  if (parsed.protocol === "http:") return proxyValue("HTTP_PROXY", env) ?? proxyValue("ALL_PROXY", env);
+  return undefined;
+}

package/src/lib/redact.ts

@@ -490,10 +490,19 @@ export function redactUrlForLog(url: string): string {
     parsed.hash = "";
     return parsed.toString();
   } catch {
-    return redactSecretString(url.split("?")[0] ?? url);
+    const stripped = (url.split(/[?#]/)[0] ?? url).replace(/:\/\/[^@\s]+@/g, "://");
+    return redactSecretString(stripped);
   }
 }
 
+/** Redact credentials and userinfo from arbitrary diagnostic text. */
+export function redactErrorMessage(value: string): string {
+  return redactSecretString(value).replace(
+    /[a-z][a-z0-9+.-]*:\/\/[^\s"'<>]+/gi,
+    match => redactUrlForLog(match),
+  );
+}
+
 const USER_HOME_PATH_PATTERNS: Array<[RegExp, string]> = [
   // Windows: C:\Users\<name>\...  ->  C:\Users\[USER]\...
   [/([A-Za-z]:\\Users\\)[^\\/]+/gi, "$1[USER]"],

package/src/lib/state-store-registrations.ts

@@ -6,6 +6,7 @@ import {
 import { reconcileCodexReauthState } from "../codex/account-runtime-state";
 import { reconcileCatalogWarningMemos } from "../codex/catalog/aggregation";
 import { reconcileProviderFetchWarnings } from "../codex/catalog/provider-fetch";
+import { reconcileModelMetadataSnapshot } from "../codex/catalog/model-metadata";
 import { reconcileModelCacheGeneration } from "../codex/model-cache";
 import { reconcilePoolRotationState } from "../codex/pool-rotation";
 import { reconcileCodexQuotaAccounts } from "../codex/quota";
@@ -103,6 +104,7 @@ export const STATE_STORE_REGISTRATIONS = [
   { name: "provider-quota-history", reconcileGeneration: reconcileProviderAccountQuotaRows },
   { name: "codex-routing-health", reconcileGeneration: reconcileCodexRoutingHealth },
   { name: "model-cache-history", reconcileGeneration: reconcileModelCacheGeneration },
+  { name: "model-metadata-snapshot", reconcileGeneration: reconcileModelMetadataSnapshot },
   { name: "pool-rotation", reconcileGeneration: reconcilePoolRotationState },
   { name: "combo-rotation", reconcileGeneration: reconcileComboRotationState },
   { name: "guardian-backoff", reconcileGeneration: reconcileGuardianBackoff },

package/src/lib/tool-argument-integers.ts

@@ -59,6 +59,35 @@ function declaresString(schema: SchemaNode): boolean {
   return Array.isArray(type) && type.includes("string");
 }
 
+// Issue #2316: Codex advertises `multi_agent_v1__wait_agent`'s `timeout_ms` as a JSON
+// Schema `number`, but its Rust runtime deserializes the field as `u64` and rejects
+// `120000.0` with "invalid type: floating point `120000.0`, expected u64" before the
+// tool ever runs. The schema lookup is not the problem — the error text comes from
+// Codex's own deserializer, so the call reached it — the problem is that `number`
+// alone never authorizes the integral-float repair below.
+//
+// This allowlist is deliberately one field wide. It names only what has a live
+// reproduction against a real `u64`, because the repair is only unambiguous for a
+// field that cannot legitimately hold a fraction. Generic names (`start`, `end`,
+// `priority`, `port`) would silently rewrite a third-party tool's fractional value,
+// so a new entry needs its own evidence, not a plausible-sounding name.
+//
+// Cursor's sibling `yield_time_ms` (src/adapters/cursor/tool-definitions.ts) is also
+// declared `number`; it is NOT included here because no rejection has been captured
+// against it. It gets its own change when it gets its own reproduction.
+const U64_NUMBER_FIELDS = new Set(["timeout_ms"]);
+
+// Issue #2443 / #2451: Codex Desktop's bare `wait` tool has the same schema/runtime
+// split for `yield_time_ms` and `max_tokens`. Scope these names to that bare tool so a
+// third-party or namespaced tool can still use fractional values legitimately.
+// #2448 allowlisted the hyphenated `yield-time_ms`; live Grok 4.6 calls and the
+// advertised wait schema both use the underscore form, so that name is the one
+// with a captured u64 rejection. Cursor still uses the same underscore name on a
+// namespaced tool; the wait-only map keeps that path byte-identical.
+const U64_NUMBER_FIELDS_BY_TOOL = new Map<string, ReadonlySet<string>>([
+  ["wait", new Set(["yield_time_ms", "max_tokens"])],
+]);
+
 /** True when the node accepts a JSON number (`integer` or `number`), so a numeric
  * value is already schema-valid and must not be rewritten into a string. */
 function declaresNumeric(schema: SchemaNode): boolean {
@@ -118,7 +147,14 @@ interface CoerceResult {
   changed: boolean;
 }
 
-function coerceValue(value: unknown, schema: SchemaNode | undefined, root: SchemaNode, depth: number): CoerceResult {
+function coerceValue(
+  value: unknown,
+  schema: SchemaNode | undefined,
+  root: SchemaNode,
+  depth: number,
+  toolName?: string,
+  propertyName?: string,
+): CoerceResult {
   // A hostile or deeply nested schema must not blow the stack.
   if (depth > 64) return { value, changed: false };
   const resolved = schema ? resolveRef(schema, root, new Set()) : undefined;
@@ -126,7 +162,19 @@ function coerceValue(value: unknown, schema: SchemaNode | undefined, root: Schem
   if (typeof value === "number") {
     if (!resolved) return { value, changed: false };
     const branches = compositionBranches(resolved);
-    const integerDeclared = declaresInteger(resolved) || branches.some(declaresInteger);
+    // #2316: a known Codex-native u64 field counts as integer-declared even when the
+    // advertised schema says `number`, but only when the field really is numeric —
+    // an allowlisted name over a string-typed field is a disagreement, not a repair.
+    const nativeU64Field = propertyName !== undefined
+      && (
+        U64_NUMBER_FIELDS.has(propertyName)
+        || U64_NUMBER_FIELDS_BY_TOOL.get(toolName ?? "")?.has(propertyName) === true
+      );
+    const nativeU64Declared = nativeU64Field
+      && (declaresNumeric(resolved) || branches.some(declaresNumeric));
+    const integerDeclared = declaresInteger(resolved)
+      || branches.some(declaresInteger)
+      || nativeU64Declared;
     if (!integerDeclared && safelyIntegral(value)) {
       // Issue #1938: a bare integer in a string-only field has exactly one faithful
       // string reading. A field that also accepts a numeric type keeps the number.
@@ -148,7 +196,9 @@ function coerceValue(value: unknown, schema: SchemaNode | undefined, root: Schem
     const itemSchema = resolved ? asSchema(resolved.items) : undefined;
     let changed = false;
     const next = value.map(entry => {
-      const result = coerceValue(entry, itemSchema, root, depth + 1);
+      // Array items have no property name of their own; passing the array's key would
+      // let `timeout_ms: [1.5]` inherit the allowlist. Items are judged by schema only.
+      const result = coerceValue(entry, itemSchema, root, depth + 1, toolName);
       if (result.changed) changed = true;
       return result.value;
     });
@@ -164,7 +214,7 @@ function coerceValue(value: unknown, schema: SchemaNode | undefined, root: Schem
   const next: Record<string, unknown> = {};
   for (const [key, entry] of Object.entries(object)) {
     const childSchema = asSchema(properties?.[key]) ?? additional;
-    const result = coerceValue(entry, childSchema, root, depth + 1);
+    const result = coerceValue(entry, childSchema, root, depth + 1, toolName, key);
     if (result.changed) changed = true;
     next[key] = result.value;
   }
@@ -182,6 +232,7 @@ function coerceValue(value: unknown, schema: SchemaNode | undefined, root: Schem
 export function coerceIntegerToolArguments(
   args: string,
   parameters: Record<string, unknown> | undefined,
+  toolName?: string,
 ): string {
   if (!parameters || !args) return args;
   // Cheap reject: a payload with no digit cannot need either repair (integral-float
@@ -196,7 +247,7 @@ export function coerceIntegerToolArguments(
     return args;
   }
   const root = parameters as SchemaNode;
-  const result = coerceValue(parsed, root, root, 0);
+  const result = coerceValue(parsed, root, root, 0, toolName);
   if (!result.changed) return args;
   return JSON.stringify(result.value);
 }