@bitkyc08/opencodex 2.90.0 → 2.91.0

package/src/link/peer-report.ts

@@ -0,0 +1,100 @@
+/**
+ * What a Remote Link Child tells its Home about itself, and what the Home remembers of it.
+ *
+ * A Child sends its release version and its peer feature ids (`src/remote/features.ts`) as two
+ * headers on the credential-free relay-auth challenge it already sends before every relayed
+ * request (`src/client/link-relay-transport.ts`). The Home records them only after the caller
+ * proof verifies, so an observation is bound to the link key; it is still the Child's own claim
+ * and is used for display and compatibility verdicts, never for admission.
+ *
+ * A Home older than this report ignores the headers, and a Child older than it sends none: the
+ * Home then knows only the relay-auth version the challenge itself names. Observations live in
+ * the Home's memory and start empty after a restart; the next relayed request refills them.
+ */
+export const LINK_PEER_REPORT_VERSION = "1";
+export const LINK_PEER_VERSION_HEADER = "x-opencodex-link-peer-version";
+export const LINK_PEER_FEATURES_HEADER = "x-opencodex-link-peer-features";
+
+const RELEASE_VERSION = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.+-]{1,128})?$/;
+const FEATURE_ID = /^[A-Za-z0-9][A-Za-z0-9._/-]{0,79}$/;
+const MAX_FEATURES = 64;
+const MAX_LINKS = 256;
+
+export interface LinkPeerReport {
+  /** True when the challenge carried either report header, valid or not; false for a pre-report Child. */
+  reported: boolean;
+  version: string | null;
+  features: string[] | null;
+}
+
+/** Header values a Child sends. Invalid input yields no header rather than a malformed one. */
+export function linkPeerReportHeaders(version: string, features: readonly string[]): Record<string, string> {
+  const headers: Record<string, string> = {};
+  if (RELEASE_VERSION.test(version)) headers[LINK_PEER_VERSION_HEADER] = version;
+  const ids = parseFeatureList(features.join(","));
+  if (ids) headers[LINK_PEER_FEATURES_HEADER] = ids.join(",");
+  return headers;
+}
+
+function parseFeatureList(value: string | null): string[] | null {
+  if (value === null || value === "") return null;
+  const ids = value.split(",");
+  if (ids.length > MAX_FEATURES || new Set(ids).size !== ids.length || ids.some(id => !FEATURE_ID.test(id))) return null;
+  return ids;
+}
+
+/** Home side: read a report from challenge headers. Each field is dropped on its own when invalid. */
+export function parseLinkPeerReport(headers: Headers): LinkPeerReport {
+  const version = headers.get(LINK_PEER_VERSION_HEADER);
+  const features = headers.get(LINK_PEER_FEATURES_HEADER);
+  return {
+    reported: version !== null || features !== null,
+    version: version !== null && RELEASE_VERSION.test(version) ? version : null,
+    features: parseFeatureList(features),
+  };
+}
+
+export interface LinkPeerObservation extends LinkPeerReport {
+  /** The relay-auth version of the verified challenge. */
+  relayAuth: string;
+  observedAt: string;
+}
+
+/** A challenge for a known link and key that named a relay-auth version this Home does not speak. */
+export interface LinkPeerRefusal {
+  relayAuth: string;
+  refusedAt: string;
+}
+
+export interface LinkPeerEntry {
+  observed: LinkPeerObservation | null;
+  refused: LinkPeerRefusal | null;
+}
+
+export interface LinkPeerObservations {
+  observe(linkId: string, relayAuth: string, report: LinkPeerReport): void;
+  refuse(linkId: string, relayAuth: string): void;
+  get(linkId: string): LinkPeerEntry;
+}
+
+export function createLinkPeerObservations(now: () => Date = () => new Date()): LinkPeerObservations {
+  const entries = new Map<string, LinkPeerEntry>();
+  const update = (linkId: string, change: Partial<LinkPeerEntry>) => {
+    const current = entries.get(linkId) ?? { observed: null, refused: null };
+    entries.delete(linkId);
+    entries.set(linkId, { ...current, ...change });
+    // Only known link ids reach here; the cap bounds memory if the store churns for a long time.
+    if (entries.size > MAX_LINKS) entries.delete(entries.keys().next().value!);
+  };
+  return {
+    observe(linkId, relayAuth, report) {
+      update(linkId, { observed: { relayAuth, ...report, observedAt: now().toISOString() }, refused: null });
+    },
+    refuse(linkId, relayAuth) {
+      update(linkId, { refused: { relayAuth, refusedAt: now().toISOString() } });
+    },
+    get(linkId) {
+      return entries.get(linkId) ?? { observed: null, refused: null };
+    },
+  };
+}

package/src/link/remote-platform.ts

@@ -0,0 +1,78 @@
+/**
+ * Windows recognition for Remote Link Children.
+ *
+ * Remote Link drives its Child through a POSIX `sh` prelude, so a Windows Child is refused
+ * before any link key is issued or tunnel started. A Windows OpenSSH server shows up in one of
+ * three ways, depending on its default shell:
+ * - Git Bash, MSYS2 or Cygwin: `uname -s` reports MINGW*, MSYS*, CYGWIN* (or Windows*), and the
+ *   ocx prelude exits with REMOTE_PLATFORM_UNSUPPORTED.
+ * - cmd.exe: a POSIX command such as `true` or `sh` is "not recognized as an internal or
+ *   external command".
+ * - PowerShell: the same command "is not recognized as the name of a cmdlet".
+ *
+ * Hub mode (`ocx hub invite` on a Hub, `ocx connect` on the client) supports Windows clients, so
+ * every refusal points there.
+ */
+import { buildWindowsProbeArgv, REMOTE_COMMAND_NOT_FOUND, REMOTE_PLATFORM_UNSUPPORTED } from "./ssh-argv";
+import type { SshRunner, SshRunResult } from "./ssh-runner";
+
+export type RemotePlatform = "windows" | "posix" | "unknown";
+
+const WINDOWS_UNAME = /^(?:Windows|MSYS|MINGW|CYGWIN)/i;
+const POSIX_UNAME = /^[A-Za-z][A-Za-z0-9_.-]{0,63}$/;
+// Windows PowerShell says "the name of a cmdlet", PowerShell 7 "a name of a cmdlet". Localized
+// installs say neither, which is what confirmWindowsShell is for.
+const WINDOWS_SHELL_REFUSAL = /is not recognized as (?:an internal or external command|(?:the|a) name of a cmdlet)/i;
+/** ssh's own failure status: the remote shell never ran, so there is nothing to ask. */
+const SSH_TRANSPORT_FAILURE = 255;
+
+/** Remote argv that prints the kernel name; under cmd or PowerShell, `sh` itself is refused. */
+export const REMOTE_UNAME_ARGV: readonly string[] = ["sh", "-c", "uname -s 2>/dev/null", "ocx-platform"];
+
+/** Server-side refusal text, shared by the dashboard and the CLI's JSON consumers. */
+export const WINDOWS_CHILD_REFUSAL = "Remote Link Children require macOS or Linux; Windows is unsupported. Connect a Windows computer in Hub mode: run ocx hub invite on a Hub, then the printed ocx connect command on the Windows computer.";
+
+/** Does this output come from cmd.exe or PowerShell refusing a POSIX command? */
+export function isWindowsShellRefusal(output: string): boolean {
+  return WINDOWS_SHELL_REFUSAL.test(output);
+}
+
+/** Classify one remote command result. Transport failures and odd output stay unknown. */
+export function classifyRemotePlatform(result: SshRunResult): RemotePlatform {
+  if (result.code === REMOTE_PLATFORM_UNSUPPORTED) return "windows";
+  if (isWindowsShellRefusal(result.stderr) || isWindowsShellRefusal(result.stdout)) return "windows";
+  if (result.code !== 0) return "unknown";
+  const name = result.stdout.trim().split(/\r?\n/)[0] ?? "";
+  if (WINDOWS_UNAME.test(name)) return "windows";
+  return POSIX_UNAME.test(name) ? "posix" : "unknown";
+}
+
+/**
+ * Could this failure be a Windows shell whose refusal text is localized? Success, the prelude's own
+ * 125/127 answers and ssh transport failures are already explained, so they never cost another call.
+ */
+export function mayBeWindowsShell(result: SshRunResult): boolean {
+  return result.code !== 0 && result.code !== REMOTE_PLATFORM_UNSUPPORTED
+    && result.code !== REMOTE_COMMAND_NOT_FOUND && result.code !== SSH_TRANSPORT_FAILURE;
+}
+
+/** Ask the host the fixed, locale-independent WINDOWS_OS_PROBE. Any failure answers false. */
+export async function confirmWindowsShell(runner: SshRunner, alias: string, knownHostsFile: string, timeoutMs = 30_000): Promise<boolean> {
+  try {
+    const result = await runner.run(buildWindowsProbeArgv({ alias, knownHostsFile }), { timeoutMs });
+    return result.code === 0 && result.stdout.trim().split(/\r?\n/)[0]?.trim() === "Windows_NT";
+  } catch { return false; }
+}
+
+/** classifyRemotePlatform, plus the locale-independent follow-up when the answer could be Windows. */
+export async function detectRemotePlatform(runner: SshRunner, alias: string, knownHostsFile: string, result: SshRunResult): Promise<RemotePlatform> {
+  const platform = classifyRemotePlatform(result);
+  if (platform !== "unknown" || !mayBeWindowsShell(result)) return platform;
+  return await confirmWindowsShell(runner, alias, knownHostsFile) ? "windows" : "unknown";
+}
+
+/** The CLI sentence for a refused Windows Child. */
+export function windowsChildRefusal(alias: string): string {
+  return `${alias} is a Windows computer. Remote Link Children require macOS or Linux, so no link key was issued and no tunnel was started. `
+    + `Connect it in Hub mode instead: run 'ocx hub invite' on a Hub, then run the printed 'ocx connect' command on ${alias}.`;
+}

package/src/link/ssh-argv.ts

@@ -191,6 +191,25 @@ export function buildProbeArgv(options: ProbeArgvOptions): string[] {
   ];
 }
 
+/**
+ * Locale-independent Windows check for a host whose SSH shell is cmd.exe or PowerShell. Both run
+ * `cmd /c echo %OS%`, and cmd expands it to `Windows_NT` regardless of display language. The
+ * command is a fixed literal; a POSIX shell answers "command not found" and nothing else.
+ */
+export const WINDOWS_OS_PROBE = "cmd /c echo %OS%";
+
+/** Run WINDOWS_OS_PROBE against an already trusted (pinned or just-probed) host key only. */
+export function buildWindowsProbeArgv(options: { alias: string; knownHostsFile: string }): string[] {
+  const alias = assertSshAlias(options.alias);
+  return [
+    "ssh", "-T",
+    ...commonOptions(alias, options.knownHostsFile, "yes"),
+    "-o", "ClearAllForwardings=yes",
+    "--", alias,
+    WINDOWS_OS_PROBE,
+  ];
+}
+
 /** Read the fingerprint of the host key recorded by a probe. */
 export function buildFingerprintArgv(tempKnownHostsFile: string): string[] {
   return ["ssh-keygen", "-l", "-f", assertKnownHostsPath(tempKnownHostsFile)];

package/src/link/status-projection.ts

@@ -2,6 +2,9 @@ import type { LinkStore } from "./store";
 import type { LinkTunnelStatus } from "./supervisor";
 import type { TunnelState } from "./tunnel-state";
 import { readCompensation, type CompensationStore } from "./compensation";
+import { EMPTY_LINK_CHILD_PARITY, type LinkChildParity } from "./child-parity";
+import { linkPeerStatus, type LinkLocalPeer, type LinkPeerStatus } from "./compatibility";
+import type { LinkPeerEntry } from "./peer-report";
 import type { OcxClientConnectionConfig } from "../types";
 
 export type LinkWireState = "connecting" | "connected" | "reconnecting" | "failed" | "idle";
@@ -9,7 +12,7 @@ export type LinkWireState = "connecting" | "connected" | "reconnecting" | "faile
 export interface LinkStatusDto {
   role: "standalone" | "home" | "child";
   listener: { state: "off" | "listening" | "failed"; port: number | null };
-  links: Array<{
+  links: Array<LinkChildParity & {
     id: string;
     alias: string;
     direction: "hub-initiated" | "client-initiated";
@@ -17,6 +20,8 @@ export interface LinkStatusDto {
     since: string;
     reason: string | null;
     tunnelPort: number;
+    /** Home only: what the link carried from this Child, and the compatibility verdict. */
+    peer?: LinkPeerStatus;
   }>;
   child: null | {
     alias: string;
@@ -24,6 +29,17 @@ export interface LinkStatusDto {
     since: string;
     reason: string | null;
   };
+  /** This build's version and link protocol, the side every `peer` verdict compares against. */
+  local?: LinkLocalPeer;
+}
+
+/** Add this build's identity and, on a Home, each Child's observed peer status. */
+export function attachLinkPeers(dto: LinkStatusDto, local: LinkLocalPeer, observation: (linkId: string) => LinkPeerEntry): LinkStatusDto {
+  if (dto.role === "home") {
+    for (const link of dto.links) link.peer = linkPeerStatus(local, observation(link.id));
+  }
+  dto.local = local;
+  return dto;
 }
 
 export interface ClientLinkIdentity { direction: "hub-initiated" | "client-initiated"; alias?: string }
@@ -75,6 +91,8 @@ export function projectLinkStatus(
   compensation: CompensationStore = readCompensation(),
   clientChild: LinkStatusDto["child"] = null,
   identity: ClientLinkIdentity | null = null,
+  /** The Home's view of each Child's last apply (OCX-6); every field is null without a report. */
+  parity: (linkId: string) => LinkChildParity = () => EMPTY_LINK_CHILD_PARITY,
 ): LinkStatusDto {
   const byId = new Map(supervisorStates.map(status => [status.linkId, status]));
   const links = store.links.map(record => ({
@@ -83,6 +101,7 @@ export function projectLinkStatus(
     direction: record.direction,
     ...stateDetails(record, byId.get(record.id), compensation),
     tunnelPort: record.tunnelPort,
+    ...parity(record.id),
   }));
   const childRecord = config.runtimeRole === "client"
     ? (config.client?.transport === "link" ? store.links.find(record => record.id === config.client?.link?.linkId) : store.links[0])
@@ -101,7 +120,10 @@ export function projectLinkStatus(
     : client?.link ? { alias: identity?.alias ?? client.serverUrl, state: "idle" as const, since: client.connectedAt, reason: null } : null);
   if (client?.link && child && identity) {
     const active = links.find(link => link.id === client.link!.linkId);
-    const projected = { id: client.link.linkId, direction: identity.direction, tunnelPort: client.link.tunnelPort, ...child, alias: identity.alias ?? child.alias };
+    const projected = {
+      id: client.link.linkId, direction: identity.direction, tunnelPort: client.link.tunnelPort, ...child, alias: identity.alias ?? child.alias,
+      ...parity(client.link.linkId),
+    };
     if (active) Object.assign(active, projected, compensation.entries[active.id] && childRecord ? stateDetails(childRecord, byId.get(active.id), compensation) : {});
     else links.push(projected);
   }

package/src/oauth/index.ts

@@ -1672,7 +1672,7 @@ export async function runLogin(
         : existing.accountId && cred.accountId
           ? existing.accountId === cred.accountId
           : existing.email && cred.email
-            ? existing.email.toLowerCase() === cred.email.toLowerCase()
+            ? existing.email.trim().toLowerCase() === cred.email.trim().toLowerCase()
             : false;
       if (!identityMatches) {
         throw new OAuthReauthIdentityMismatchError();

package/src/oauth/kimi.ts

@@ -4,6 +4,7 @@ import * as os from "node:os";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { recordOwnedConfigPath } from "../lib/config-ownership";
+import { assertNotRealHomeUnderTest } from "../lib/test-home-guard";
 import { getConfigDir } from "../config";
 import type { OAuthController, OAuthCredentials } from "./types";
 
@@ -107,6 +108,7 @@ function getDeviceId(): string {
     if ((e as { code?: string })?.code !== "ENOENT") throw e;
   }
   const id = randomUUID().replace(/-/g, "");
+  assertNotRealHomeUnderTest(getConfigDir());
   recordOwnedConfigPath(getConfigDir(), p);
   if (!existsSync(getConfigDir())) mkdirSync(getConfigDir(), { recursive: true });
   writeFileSync(p, id + "\n", { mode: 0o600 });

package/src/oauth/nous.ts

@@ -35,10 +35,11 @@
  */
 import { createHash } from "node:crypto";
 import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import type { OAuthController, OAuthCredentials } from "./types";
 import { getAuthStorePath } from "./store";
 import { atomicWriteFile, hardenConfigDir, hardenExistingSecret } from "../config";
+import { assertNotRealHomeUnderTest } from "../lib/test-home-guard";
 import { BOUNDED_BODY_MAX_BYTES, readBoundedResponseBytes } from "../lib/bounded-body";
 
 export const NOUS_PORTAL_BASE_URL = "https://portal.nousresearch.com";
@@ -220,6 +221,8 @@ function readRefreshIntent(refreshToken: string): RefreshIntent | undefined {
 }
 
 function writeRefreshIntent(refreshToken: string, status: RefreshIntentStatus): void {
+  // Before the mkdir/chmod below, which would otherwise touch the real home first.
+  assertNotRealHomeUnderTest(dirname(getAuthStorePath()));
   const dir = refreshIntentDir();
   // Hardened, owner-only directory + atomic (temp+rename) write. Throws on
   // failure so the caller can fail closed instead of refreshing blind.

package/src/oauth/store.ts

@@ -203,6 +203,7 @@ export function peekOAuthRefreshIntent(provider: string, accountId: string): OAu
 }
 export function writeOAuthRefreshIntent(provider: string, accountId: string, generation: string, createdAt = Date.now(), flightId?: string): OAuthRefreshIntent {
   const dir = getConfigDir();
+  assertNotRealHomeUnderTest(dir);
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 0o700 });
   hardenConfigDir();
   const intent: OAuthRefreshIntent = {
@@ -1152,7 +1153,7 @@ export async function upsertCredentialByIdentity(
       return Boolean(
         safe.email
         && account.credential.email
-        && account.credential.email.toLowerCase() === safe.email.toLowerCase(),
+        && account.credential.email.trim().toLowerCase() === safe.email.trim().toLowerCase(),
       );
     };
     const existing = safe.accountId

package/src/protocols/codecs/chat.ts

@@ -6,12 +6,12 @@
  * (`src/chat/inbound.ts`), including its validation and the fields it drops, which
  * `src/protocols/features.ts` declares.
  */
-import { chatCompletionsToResponsesBody, chatSettingsToResponsesBody } from "../../chat/inbound";
+import { chatCompletionsToResponsesBody, chatSettingsToResponsesBody, type ChatResponsesProjectionOptions } from "../../chat/inbound";
 import { featuresFromChatBody } from "../features";
 
 /** Project a Chat Completions body onto the internal Responses bridge body. */
-export function chatToResponsesBody(body: unknown): Record<string, unknown> {
-  return chatCompletionsToResponsesBody(body);
+export function chatToResponsesBody(body: unknown, options?: ChatResponsesProjectionOptions): Record<string, unknown> {
+  return chatCompletionsToResponsesBody(body, options);
 }
 
 /**

package/src/protocols/encoders/adapter-events.ts

@@ -109,7 +109,13 @@ export interface ClientWireWriter {
   text(delta: string): void;
   messageDone(): void;
   reasoning(delta: string, itemId: string, channel: "summary" | "raw"): void;
-  reasoningDone(item: { itemId: string; signature?: string; redacted?: string[] }): void;
+  /** `hidden`: the signature covers thinking text the client was not shown (the bridge's `txt`). */
+  reasoningDone(item: { itemId: string; signature?: string; redacted?: string[]; hidden?: true }): void;
+  /**
+   * An Anthropic progress update: `text` is shown as content and is also the signed thinking
+   * block's text. Optional — a writer without it renders the update as ordinary text.
+   */
+  progressThinking?(text: string, signature: string): void;
   toolStart(call: ClientToolCall): void;
   toolArgsDelta(itemId: string, delta: string): void;
   toolArgsDone(itemId: string, args: string): void;
@@ -331,6 +337,8 @@ export function encodeAdapterEventStream(
   let currentRawReasoning: { itemId: string } | null = null;
   let pendingSignature: string | undefined;
   let pendingRedacted: string[] = [];
+  // The bridge's hiddenThinking: non-empty thinking text suppressed by hideThinkingSummary.
+  let hiddenThinkingSeen = false;
   let hiddenRawBytes = 0;
   let pendingKiroRedacted: string | undefined;
   let currentToolCall: OpenToolCall | null = null;
@@ -367,9 +375,11 @@ export function encodeAdapterEventStream(
   };
   // hideThinkingSummary: a signed or redacted block still round-trips as an envelope-only item.
   const flushHiddenReasoningEnvelope = () => {
+    const hidden = hiddenThinkingSeen;
+    hiddenThinkingSeen = false;
     const envelope = takeReasoningEnvelope();
     if (!envelope) return;
-    writer.reasoningDone({ itemId: `rs_${uuid()}`, ...envelope });
+    writer.reasoningDone({ itemId: `rs_${uuid()}`, ...envelope, ...(hidden ? { hidden: true as const } : {}) });
   };
   const flushHiddenRawReasoning = () => {
     if (hiddenRawBytes === 0) return;
@@ -570,6 +580,19 @@ export function encodeAdapterEventStream(
             break;
           }
           case "text_delta": {
+            if (event.anthropicThinkingSignature && writer.progressThinking) {
+              // The bridge's progress items: close everything, the carrier, then the visible copy.
+              if (currentMsg) closeCurrentMessage();
+              if (currentReasoning) closeCurrentReasoning();
+              if (currentRawReasoning) closeCurrentRawReasoning();
+              flushHiddenRawReasoning();
+              flushHiddenReasoningEnvelope();
+              if (currentToolCall) closeCurrentToolCall();
+              writer.progressThinking(event.text, event.anthropicThinkingSignature);
+              writer.text(event.text);
+              writer.messageDone();
+              break;
+            }
             if (currentReasoning) closeCurrentReasoning();
             if (currentRawReasoning) closeCurrentRawReasoning();
             flushHiddenRawReasoning();
@@ -585,6 +608,7 @@ export function encodeAdapterEventStream(
           }
           case "thinking_delta": {
             if (options.hideThinkingSummary) {
+              if (event.thinking.length > 0) hiddenThinkingSeen = true;
               flushHiddenRawReasoning();
               break;
             }

package/src/protocols/encoders/chat.ts

@@ -13,6 +13,7 @@ import type { AdapterEvent } from "../../types";
 import type { TranslatorBudget } from "../../lib/translator-budget";
 import { responsesUsage } from "../../bridge/internal";
 import {
+  appendedUtf8Bytes,
   chatCompletionsErrorResponse,
   chatCompletionsFailedResponse,
   chatCompletionsIncompleteOutcome,
@@ -32,6 +33,7 @@ import {
   type ClientWireWriter,
 } from "./adapter-events";
 import type { RelayedEventObservation } from "../../usage/attempt-delivery";
+import { reasoningDetailEntries } from "../../chat/reasoning-details";
 
 type Rec = Record<string, unknown>;
 
@@ -54,6 +56,41 @@ function createChatCompletionWriter(sink: ClientFrameSink, model: string): Clien
   const emittedToolIndexes = new Set<number>();
   let nextToolIndex = 0;
   let staged: { text: string; observation?: RelayedEventObservation }[] | undefined;
+  // #7429: the shown thinking text of the open reasoning item, which its signature pairs with.
+  const budget = sink.budget;
+  let reasoningItemId: string | undefined;
+  let reasoningText = "";
+  let reasoningTextBytes = 0;
+  let nextReasoningDetailIndex = 0;
+  const releaseReasoningText = () => {
+    budget.releaseRetained(reasoningTextBytes, { kind: "reasoning" });
+    reasoningItemId = undefined;
+    reasoningText = "";
+    reasoningTextBytes = 0;
+  };
+  const retainReasoningText = (itemId: string, delta: string) => {
+    if (reasoningItemId !== itemId) releaseReasoningText();
+    reasoningItemId = itemId;
+    const nextBytes = appendedUtf8Bytes(reasoningText, reasoningTextBytes, delta);
+    const reservation = budget.reserveTransient(nextBytes, { kind: "reasoning" });
+    try {
+      reasoningText += delta;
+      reservation.commitRetained();
+      budget.releaseRetained(reasoningTextBytes, { kind: "reasoning" });
+      reasoningTextBytes = nextBytes;
+    } catch (error) {
+      reservation.release();
+      throw error;
+    }
+  };
+  const emitReasoningDetails = (entries: Rec[]) => {
+    if (entries.length === 0) return;
+    nextReasoningDetailIndex += entries.length;
+    ensureRole();
+    const frame = chunkBase(id, model, created);
+    frame.choices = [{ index: 0, delta: { reasoning_details: entries }, finish_reason: null }];
+    emit(frame);
+  };
 
   const emit = (payload: Rec | "[DONE]", observation?: RelayedEventObservation) => {
     if (failed) return;
@@ -138,15 +175,30 @@ function createChatCompletionWriter(sink: ClientFrameSink, model: string): Clien
       emit(frame, { semanticBytes: Buffer.byteLength(delta) });
     },
     messageDone() { /* the converter reads nothing from a finished message */ },
-    reasoning(delta) {
+    reasoning(delta, itemId, channel) {
       if (!delta) return;
       ensureRole();
       // Many OpenAI-compatible clients accept reasoning_content; harmless if ignored.
       const frame = chunkBase(id, model, created);
       frame.choices = [{ index: 0, delta: { reasoning_content: delta }, finish_reason: null }];
       emit(frame, { semanticBytes: Buffer.byteLength(delta) });
+      // Only summary-channel thinking can carry a signature; raw reasoning never does.
+      if (channel === "summary") retainReasoningText(itemId, delta);
+    },
+    reasoningDone({ itemId, signature, redacted, hidden }) {
+      // The bridge converter's output_item.done for a reasoning item (#7429), entry for entry.
+      const entries = reasoningDetailEntries({
+        text: reasoningItemId === itemId ? reasoningText : "",
+        ...(signature ? { signature } : {}),
+        ...(redacted ? { redacted } : {}),
+        ...(hidden ? { hidden } : {}),
+      }, nextReasoningDetailIndex);
+      releaseReasoningText();
+      emitReasoningDetails(entries);
+    },
+    progressThinking(text, signature) {
+      emitReasoningDetails(reasoningDetailEntries({ text, signature }, nextReasoningDetailIndex));
     },
-    reasoningDone() { /* reasoning items carry nothing a Chat client reads */ },
     toolStart(call) {
       // Custom and tool-search calls have no Chat representation; the converter skips them.
       if (call.kind !== "function") return;
@@ -198,7 +250,7 @@ function createChatCompletionWriter(sink: ClientFrameSink, model: string): Clien
         type: "upstream_error",
       });
     },
-    dispose() { /* nothing retained beyond the driver's frames */ },
+    dispose() { releaseReasoningText(); },
   };
 }
 

package/src/providers/mistral-transport.ts

@@ -8,6 +8,14 @@ import { RequestPacingQueueOverloadError } from "./request-pacing";
 import type { OcxProviderTransport } from "./xai-transport";
 
 const MAX_IDENTITIES = 128;
+/** Queued waiters per credential+model identity; one hot identity never refuses another. */
+const MAX_WAITERS_PER_IDENTITY = 128;
+/**
+ * Process-wide waiter bound. Model strings come from clients, so identities are not bounded by
+ * configuration; this keeps memory and pending requests finite. It is a multiple of the
+ * per-identity cap, so no single identity can fill it alone.
+ */
+const MAX_WAITERS_TOTAL = 4 * MAX_WAITERS_PER_IDENTITY;
 const DEFAULT_MAX_WAIT_MS = 60_000; // Existing retry wait budget, not an inferred rate window.
 const MINUTE_MS = 60 * 1000; // Unit named by the observed headers, never an account quota.
 type RecoveryState = { generation: number; probe?: { done: Promise<void>; finish(): void } };
@@ -61,7 +69,14 @@ export class MistralBudgetPacer {
   private readonly recoveries = new Map<string, RecoveryState>();
   /** Latest live deadline evicted at capacity; unknown identities wait it out instead of sending early. */
   private evictedUntil = 0;
-  private waiting = 0;
+  /**
+   * Parked waiters keyed by identity. A request counts only once it is about to wait, so a held
+   * credential or model fills only its own queue and a request that can send now is never answered
+   * queue_full (HTTP 429). The map holds identities with live waiters only; the total is capped by
+   * MAX_WAITERS_TOTAL.
+   */
+  private readonly waiting = new Map<string, number>();
+  private waitingTotal = 0;
 
   constructor(
     private readonly now: () => number = Date.now,
@@ -103,9 +118,18 @@ export class MistralBudgetPacer {
   /** Wait within the admission budget and return a release callback for one recovery probe. */
   async acquire(identity: string, signal?: AbortSignal, maxWaitMs = DEFAULT_MAX_WAIT_MS): Promise<(success?: boolean) => void> {
     signal?.throwIfAborted();
-    if (this.waiting >= MAX_IDENTITIES) throw new RequestPacingQueueOverloadError("mistral", "queue_full", 60);
-    this.waiting++;
     const deadline = this.now() + maxWaitMs;
+    let parked = false;
+    const park = (): void => {
+      if (parked) return;
+      const queued = this.waiting.get(identity) ?? 0;
+      if (queued >= MAX_WAITERS_PER_IDENTITY || this.waitingTotal >= MAX_WAITERS_TOTAL) {
+        throw new RequestPacingQueueOverloadError("mistral", "queue_full", 60);
+      }
+      this.waiting.set(identity, queued + 1);
+      this.waitingTotal++;
+      parked = true;
+    };
     try {
       for (;;) {
         signal?.throwIfAborted();
@@ -118,6 +142,7 @@ export class MistralBudgetPacer {
           throw new RequestPacingQueueOverloadError("mistral", "queue_expired", Math.ceil(delay / 1000));
         }
         if (readyAt !== undefined && readyAt > this.now()) {
+          park();
           await this.sleep(readyAt - this.now(), signal);
           continue;
         }
@@ -126,6 +151,7 @@ export class MistralBudgetPacer {
         if (state.probe) {
           const remaining = deadline - this.now();
           if (remaining <= 0) throw new RequestPacingQueueOverloadError("mistral", "queue_expired", 1);
+          park();
           const local = new AbortController();
           try {
             await Promise.race([state.probe.done, this.sleep(remaining, AbortSignal.any([local.signal, ...(signal ? [signal] : [])]))]);
@@ -150,7 +176,14 @@ export class MistralBudgetPacer {
           probe.finish();
         };
       }
-    } finally { this.waiting--; }
+    } finally {
+      if (parked) {
+        this.waitingTotal--;
+        const left = (this.waiting.get(identity) ?? 1) - 1;
+        if (left > 0) this.waiting.set(identity, left);
+        else this.waiting.delete(identity);
+      }
+    }
   }
 }
 

package/src/providers/quota/antigravity.ts

@@ -8,6 +8,7 @@ import { asRecord, normalizePercent, normalizeResetAt, readQuotaJson, REQUEST_TI
 import { report, type ProviderQuotaReport } from "./report-cache";
 import { quotaCredentialIdentity } from "./account-cache";
 import type { ProviderQuota, ProviderQuotaWindow, QuotaFailureCode } from "../quota-types";
+import { httpQuotaFailure } from "./failure-codes";
 
 export function antigravityQuotaDiagnosticIdentity(accountId: string, credential = getAccountCredential("google-antigravity", accountId)): string | undefined {
   return credential ? quotaCredentialIdentity("google-antigravity", accountId, credential, {
@@ -275,13 +276,6 @@ function quotaTransportFailure(error: unknown): QuotaFailureCode {
   return "transport_error";
 }
 
-function quotaHttpFailure(status: number): QuotaFailureCode {
-  if (status >= 300 && status < 400) return "redirect_blocked";
-  if (status === 401 || status === 403) return "access_denied";
-  if (status === 429) return "rate_limited";
-  return "upstream_error";
-}
-
 function unavailableAntigravityQuota(failure: QuotaFailureCode): AntigravityQuotaProbeResult {
   return { kind: "unavailable", failure, legacy: { kind: "null" } };
 }
@@ -342,7 +336,7 @@ export async function probeAntigravityUsageQuota(accessToken: string, projectId:
       return unavailableAntigravityQuota(antigravityUnavailableFailure(summaryFailure, "redirect_blocked"));
     }
     if (!response.ok) {
-      return unavailableAntigravityQuota(antigravityUnavailableFailure(summaryFailure, quotaHttpFailure(response.status)));
+      return unavailableAntigravityQuota(antigravityUnavailableFailure(summaryFailure, httpQuotaFailure(response.status)));
     }
     const customWindows = antigravityWindowsFromModels(asRecord(await readQuotaJson(response)));
     if (!customWindows.length) {