@bitkyc08/opencodex 2.57.0 → 2.59.0

package/src/adapters/physical-send.ts

@@ -0,0 +1,50 @@
+import type { AdapterFetchContext } from "./base";
+import type { SendClass } from "../lib/request-execution-budget";
+import type { AttemptRecoveryKind } from "../usage/log";
+import { abortError, SendBudgetExhaustedError } from "../lib/upstream-retry";
+
+type PacedFetch = typeof globalThis.fetch & {
+  waitForPacing?: (signal?: AbortSignal) => Promise<void>;
+  unpacedFetch?: typeof globalThis.fetch;
+};
+
+/** One ordinal sequence per adapter fetchResponse call, across all of its inference retries.
+ * Consumption starts at underlying executor invocation; its own later preflight may still fail. */
+export function createAdapterPhysicalSend(ctx: AdapterFetchContext = {}, fallback = globalThis.fetch) {
+  const executor = (ctx.executor ?? fallback) as PacedFetch;
+  let ordinal = 0;
+  return async (options: {
+    url: string;
+    sendClass?: SendClass;
+    recovery?: AttemptRecoveryKind;
+    /** Runs only after admission, e.g. backoff and cancellation of a superseded response. */
+    beforeDispatch?: () => void | Promise<void>;
+    dispatch: (executor: typeof globalThis.fetch) => Promise<Response>;
+  }): Promise<Response> => {
+    if (ctx.abortSignal?.aborted) throw abortError(ctx.abortSignal);
+    const decision = ctx.sendBudget?.reserveDispatch({
+      sendClass: options.sendClass ?? "transient", targetKey: options.url,
+    });
+    if (decision && !decision.allowed) throw new SendBudgetExhaustedError(options.url);
+    const permit = decision?.allowed ? decision.permit : undefined;
+    let dispatched = false;
+    const physicalExecutor = (async (input, init) => {
+      if (ctx.abortSignal?.aborted) throw abortError(ctx.abortSignal);
+      if (init?.signal?.aborted) throw abortError(init.signal);
+      if (dispatched || (permit && !permit.use())) throw new SendBudgetExhaustedError(options.url);
+      dispatched = true;
+      ordinal += 1;
+      ctx.onPhysicalSend?.({ ordinal, ...(options.recovery ? { recovery: options.recovery } : {}) });
+      return (executor.unpacedFetch ?? executor)(input, init);
+    }) as typeof globalThis.fetch;
+    try {
+      await executor.waitForPacing?.(ctx.abortSignal);
+      if (ctx.abortSignal?.aborted) throw abortError(ctx.abortSignal);
+      await options.beforeDispatch?.();
+      if (ctx.abortSignal?.aborted) throw abortError(ctx.abortSignal);
+      return await options.dispatch(physicalExecutor);
+    } finally {
+      permit?.release();
+    }
+  };
+}

package/src/adapters/responses-tool-schema.ts

@@ -107,66 +107,96 @@ function usesUnicodePropertyEscape(pattern: string): boolean {
  * preserved: loosening a nested constraint can instead reject an input in those contexts.
  * Unsupported patterns there remain the destination's validation responsibility.
  *
- * Returns `node` itself when nothing was dropped. Uses an explicit stack for caller-controlled
- * nesting depth; the separate Responses-only encrypted-marker normalization is unchanged.
+ * Returns `node` itself when nothing was dropped. Traversal keeps only the active path and clones
+ * only ancestors of a removed constraint, so a broad no-op schema does not create an output tree
+ * or one pending closure per sibling. The explicit stack still handles caller-controlled nesting
+ * depth; the separate Responses-only encrypted-marker normalization is unchanged.
  */
 export function stripUnicodePropertyPatterns(node: unknown, inNameBag = false): unknown {
-  type Assign = (value: unknown) => void;
-  interface Frame { node: unknown; inNameBag: boolean; assign: Assign }
-
-  let result: unknown;
-  let dropped = 0;
-  const stack: Frame[] = [{ node, inNameBag, assign: value => { result = value; } }];
+  interface Frame {
+    node: unknown[] | Record<string, unknown>;
+    inNameBag: boolean;
+    parent?: Frame;
+    parentKey?: string | number;
+    output?: unknown[] | Record<string, unknown>;
+    index?: number;
+    entries?: IterableIterator<[string, unknown]>;
+  }
 
-  while (stack.length > 0) {
-    const frame = stack.pop()!;
-    const current = frame.node;
+  function * ownEntries(value: Record<string, unknown>): IterableIterator<[string, unknown]> {
+    // Unlike Object.entries(), this does not materialize every key/value pair before traversal.
+    for (const key in value) {
+      if (Object.prototype.hasOwnProperty.call(value, key)) yield [key, value[key]];
+    }
+  }
 
-    if (Array.isArray(current)) {
-      const out: unknown[] = new Array(current.length);
-      frame.assign(out);
-      // Array items are schemas in their own right, never a name bag.
-      for (let i = current.length - 1; i >= 0; i--) {
-        stack.push({ node: current[i], inNameBag: false, assign: value => { out[i] = value; } });
-      }
-      continue;
+  function cloneContainer(frame: Frame): unknown[] | Record<string, unknown> {
+    if (frame.output) return frame.output;
+    if (Array.isArray(frame.node)) {
+      frame.output = frame.node.slice();
+      return frame.output;
     }
-    if (!current || typeof current !== "object") {
-      frame.assign(current);
-      continue;
+    const output: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
+    for (const key in frame.node) {
+      if (Object.prototype.hasOwnProperty.call(frame.node, key)) output[key] = frame.node[key];
     }
+    frame.output = output;
+    return output;
+  }
 
-    // A schema name may be `__proto__`; a null-prototype record keeps it as data.
-    const out: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
-    frame.assign(out);
+  function finish(frame: Frame): void {
+    if (!frame.output || !frame.parent) return;
+    const parent = cloneContainer(frame.parent);
+    if (Array.isArray(parent)) parent[frame.parentKey as number] = frame.output;
+    else parent[frame.parentKey as string] = frame.output;
+  }
 
-    for (const [key, value] of Object.entries(current as Record<string, unknown>)) {
-      if (frame.inNameBag) {
-        // Inside a name bag every key is a caller-chosen name, so `pattern` here is a property
-        // name; its value is still a schema and is walked as one.
-        stack.push({ node: value, inNameBag: false, assign: v => { out[key] = v; } });
-        continue;
-      }
-      if (PRESERVED_PATTERN_SUBTREES.has(key)) {
-        out[key] = value;
-        continue;
-      }
-      if (key === "pattern" && typeof value === "string" && usesUnicodePropertyEscape(value)) {
-        dropped++;
+  if (!node || typeof node !== "object") return node;
+  const root: Frame = { node: node as unknown[] | Record<string, unknown>, inNameBag };
+  const stack: Frame[] = [root];
+
+  while (stack.length > 0) {
+    const frame = stack[stack.length - 1]!;
+
+    if (Array.isArray(frame.node)) {
+      const index = frame.index ?? 0;
+      if (index >= frame.node.length) {
+        stack.pop();
+        finish(frame);
         continue;
       }
-      if (SCHEMA_LITERAL_VALUE_KEYS.has(key)) {
-        // Literal payloads are values, not schemas: a `pattern` key inside them is data.
-        out[key] = value;
-        continue;
+      frame.index = index + 1;
+      const child = frame.node[index];
+      if (child && typeof child === "object") {
+        stack.push({ node: child as unknown[] | Record<string, unknown>, inNameBag: false, parent: frame, parentKey: index });
       }
+      continue;
+    }
+
+    frame.entries ??= ownEntries(frame.node);
+    const next = frame.entries.next();
+    if (next.done) {
+      stack.pop();
+      finish(frame);
+      continue;
+    }
+    const [key, value] = next.value;
+    if (!frame.inNameBag && key === "pattern" && typeof value === "string" && usesUnicodePropertyEscape(value)) {
+      delete (cloneContainer(frame) as Record<string, unknown>)[key];
+      continue;
+    }
+    if (!frame.inNameBag && (PRESERVED_PATTERN_SUBTREES.has(key) || SCHEMA_LITERAL_VALUE_KEYS.has(key))) {
+      continue;
+    }
+    if (value && typeof value === "object") {
       stack.push({
-        node: value,
-        inNameBag: SCHEMA_NAME_BAG_KEYS.has(key),
-        assign: v => { out[key] = v; },
+        node: value as unknown[] | Record<string, unknown>,
+        inNameBag: !frame.inNameBag && SCHEMA_NAME_BAG_KEYS.has(key),
+        parent: frame,
+        parentKey: key,
       });
     }
   }
 
-  return dropped === 0 ? node : result;
+  return root.output ?? node;
 }

package/src/adapters/run-turn-queue.ts

@@ -28,6 +28,7 @@ export interface AdapterEventPreflight {
   stream: AsyncIterable<AdapterEvent>;
   error?: Extract<AdapterEvent, { type: "error" }>;
   empty: boolean;
+  replayUnsafe: boolean;
 }
 
 async function* replay(
@@ -51,10 +52,12 @@ export async function preflightAdapterEvents(
 ): Promise<AdapterEventPreflight> {
   const iterator = source[Symbol.asyncIterator]();
   const buffered: AdapterEvent[] = [];
+  let replayUnsafe = false;
   while (true) {
     const next = await iterator.next();
-    if (next.done) return { stream: replay(buffered, iterator), empty: true };
+    if (next.done) return { stream: replay(buffered, iterator), empty: true, replayUnsafe };
     if (next.value.type === "heartbeat") {
+      replayUnsafe ||= next.value.replayUnsafe === true;
       buffered.push(next.value);
       if (buffered.length > PREFLIGHT_HEARTBEAT_RETAIN_LIMIT) buffered.shift();
       continue;
@@ -62,9 +65,9 @@ export async function preflightAdapterEvents(
     buffered.push(next.value);
     if (next.value.type === "error") {
       await iterator.return?.();
-      return { stream: replay(buffered, iterator), error: next.value, empty: false };
+      return { stream: replay(buffered, iterator), error: next.value, empty: false, replayUnsafe };
     }
-    return { stream: replay(buffered, iterator), empty: false };
+    return { stream: replay(buffered, iterator), empty: false, replayUnsafe };
   }
 }
 
@@ -90,7 +93,17 @@ export function createAdapterEventQueue(opts?: {
   const coalesceIntoTail = (event: AdapterEvent): boolean => {
     const tail = queued[queued.length - 1];
     if (!tail) return false;
-    if (event.type === "heartbeat") return tail.type === "heartbeat";
+    if (event.type === "heartbeat") {
+      if (tail.type !== "heartbeat") return false;
+      // Heartbeats carry no ordering between themselves, but the replay-unsafe
+      // marker is not ordering — it is a latch. Dropping the incoming event
+      // would discard the only record that Cursor already performed a local
+      // side effect, and preflight would then permit an OAuth replay of it.
+      if (event.replayUnsafe === true && tail.replayUnsafe !== true) {
+        queued[queued.length - 1] = { type: "heartbeat", replayUnsafe: true };
+      }
+      return true;
+    }
     if (event.type === "text_delta" && tail.type === "text_delta" && tail.phase === event.phase) {
       if (tail.text.length + event.text.length > COALESCE_MAX_CHUNK_LENGTH) return false;
       queued[queued.length - 1] = { type: "text_delta", text: tail.text + event.text, phase: tail.phase };

package/src/bridge/response-json.ts

@@ -203,7 +203,7 @@ function buildResponseJSONWithBudget(
   ): string => {
     const helper = resolveCodeModeHelperName(codeModeHelperName, toolName, args, namespace, options?.declaredToolNames);
     return helper
-      ? compileCodeModeHelperInput(args, helper)
+      ? compileCodeModeHelperInput(args, helper, codeModeHelperName ?? toolName)
       : repairFreeformToolInput(args, toolName, namespace);
   };
   const parseArgsObj = (args: string): Record<string, unknown> => {
@@ -527,7 +527,7 @@ function buildResponseJSONWithBudget(
         compactionEncryptedContent = e.compactionEncryptedContent;
         sawTerminal = true;
         endTurn = e.endTurn;
-        cleanDone = e.stopReason === undefined;
+        cleanDone = !isTruncatedStopReason(e.stopReason);
         rawStopReason = e.stopReason;
         if (e.providerState) options?.onProviderState?.(e.providerState);
         // Match streaming: max_tokens and content_filter both terminate as incomplete.

package/src/bridge/sse.ts

@@ -16,7 +16,12 @@ import {
   type OcxErrorPayload,
 } from "../lib/errors";
 import { redactSecretString } from "../lib/redact";
-import { mayBecomePatchEnvelope, repairFreeformToolInput } from "../responses/apply-patch-envelope";
+import {
+  freeformFallbackKeys,
+  mayBecomePatchEnvelope,
+  repairFreeformToolInput,
+  unwrapFreeformToolInput,
+} from "../responses/apply-patch-envelope";
 import { encodeCompactionSummary } from "../responses/compaction";
 import { compileCodeModeHelperInput, resolveCodeModeHelperName } from "../responses/code-mode-helper-compat";
 import { isTruncatedStopReason, truncationReasonFor } from "../responses/truncated-stop-reason";
@@ -145,37 +150,156 @@ export function bridgeToResponsesSSE(
   ): string => {
     const helper = resolveCodeModeHelperName(codeModeHelperName, toolName, args, namespace, options?.declaredToolNames);
     return helper
-      ? compileCodeModeHelperInput(args, helper)
+      ? compileCodeModeHelperInput(args, helper, codeModeHelperName ?? toolName)
       : repairFreeformToolInput(args, toolName, namespace);
   };
   // Best-effort unwrap of a PARTIAL freeform arg buffer for live input streaming
   // (`response.custom_tool_call_input.delta` — codex-rs uses it for UI preview only;
   // the completed custom_tool_call item stays authoritative). Compact `{"input":"...`
   // buffers get their string value progressively unescaped; anything else streams raw.
-  const FREEFORM_WRAP_PREFIX = '{"input":"';
-  const freeformPartialInput = (args: string): string => {
-    if (!args.startsWith(FREEFORM_WRAP_PREFIX)) return args;
-    const body = args.slice(FREEFORM_WRAP_PREFIX.length);
+  const JSON_WHITESPACE = new Set([" ", "\t", "\n", "\r"]);
+  type WrapperOpening =
+    | { state: "none" }
+    | { state: "prefix" }
+    | { state: "open"; valueStart: number };
+  /**
+   * Where the string value of `{"<key>":"` begins, tolerating the insignificant whitespace
+   * `JSON.parse` accepts.
+   *
+   * The earlier form of this compared the buffer against the compact literal `{"key":"`, so a
+   * wrapper written with spaces or newlines matched no prefix at all, streamed as raw JSON
+   * deltas and then completed as the unwrapped body. That is the same delta/completion
+   * disagreement #5047 closed for compact wrappers, reached through a different spelling:
+   * `unwrapFreeformToolInput` reads the completed text with `JSON.parse`, which does not care
+   * how the object is laid out, so neither can the streaming side.
+   */
+  const wrapperOpening = (args: string, key: string): WrapperOpening => {
+    let index = 0;
+    for (const token of ["{", `"${key}"`, ":", '"']) {
+      while (index < args.length && JSON_WHITESPACE.has(args[index]!)) index++;
+      if (index >= args.length) return { state: "prefix" };
+      for (const expected of token) {
+        if (index >= args.length) return { state: "prefix" };
+        if (args[index] !== expected) return { state: "none" };
+        index++;
+      }
+    }
+    return { state: "open", valueStart: index };
+  };
+  /**
+   * Whether a body could still grow into one complete outer Markdown fence.
+   *
+   * `stripMarkdownCodeFence` removes such a fence at completion for exactly the two tools that
+   * own the grammar, so a fenced body's streamed bytes and its completed input disagree unless
+   * the stream holds. A buffer that does not open with a fence can never acquire one, so
+   * ordinary bodies are unaffected; a buffer that does keeps its preview suppressed for the
+   * whole call, because a closing fence can still be followed by more text that withdraws it.
+   */
+  const mayBecomeFencedBody = (text: string, toolName: string): boolean => {
+    if (toolName !== "exec" && toolName !== "apply_patch") return false;
+    const head = text.trimStart();
+    if (head === "") return true;
+    return head.startsWith("```") || "```".startsWith(head);
+  };
+  /** The two-character escapes JSON defines, and nothing else. */
+  const JSON_ESCAPES = new Map<string, string>([
+    ['"', '"'], ["\\", "\\"], ["/", "/"],
+    ["b", "\b"], ["f", "\f"], ["n", "\n"], ["r", "\r"], ["t", "\t"],
+  ]);
+  const LOW_SURROGATE_ESCAPE = /^\\u[dD][c-fC-F][0-9a-fA-F]{2}$/;
+  /**
+   * The decoded prefix of a JSON string body, stopping at the first byte it cannot resolve.
+   *
+   * Every stop is a hold rather than a guess, because `JSON.parse` decides the completed value
+   * and anything invented here would be retracted. Three of them are not obvious:
+   *
+   * An escape JSON does not define makes the whole wrapper unparseable no matter what arrives
+   * next, so completion falls back to the raw text. Returning `null` for that case stops the
+   * preview rather than continuing to decode a value the completed item will never carry.
+   * `\\b` and `\\f` are defined, and were previously decoded to the letters b and f.
+   *
+   * A lone high surrogate is not a character. Emitting one alone puts an unpaired code unit in a
+   * delta the client has to decode by itself, so the pair is emitted together or not at all.
+   */
+  const decodeJsonStringPrefix = (body: string): string | null => {
     let out = "";
     for (let i = 0; i < body.length; i++) {
       const c = body[i];
       if (c === '"') break; // unescaped closing quote: value complete
-      if (c === "\\") {
-        const n = body[i + 1];
-        if (n === undefined) break; // escape split across chunks: wait for more
-        i++;
-        if (n === "n") out += "\n";
-        else if (n === "t") out += "\t";
-        else if (n === "r") out += "\r";
-        else if (n === "u") {
-          const hex = body.slice(i + 1, i + 5);
-          if (hex.length === 4 && /^[0-9a-fA-F]{4}$/.test(hex)) { out += String.fromCharCode(parseInt(hex, 16)); i += 4; }
-          else break; // incomplete \uXXXX: wait for more
-        } else out += n; // \" \\ \/ etc.
-      } else out += c;
+      if (c !== "\\") { out += c; continue; }
+      const n = body[i + 1];
+      if (n === undefined) break; // escape split across chunks: wait for more
+      if (n === "u") {
+        const hex = body.slice(i + 2, i + 6);
+        if (hex.length < 4) break; // split across chunks: wait for more
+        if (!/^[0-9a-fA-F]{4}$/.test(hex)) return null; // never parses
+        const code = parseInt(hex, 16);
+        if (code >= 0xd800 && code <= 0xdbff) {
+          const low = body.slice(i + 6, i + 12);
+          if (!LOW_SURROGATE_ESCAPE.test(low)) break;
+          out += String.fromCharCode(code, parseInt(low.slice(2), 16));
+          i += 11;
+          continue;
+        }
+        out += String.fromCharCode(code);
+        i += 5;
+        continue;
+      }
+      const escaped = JSON_ESCAPES.get(n);
+      if (escaped === undefined) return null; // never parses
+      out += escaped;
+      i += 1;
     }
     return out;
   };
+  /**
+   * The value to stream so far, or `null` to HOLD because nothing can be decided yet.
+   *
+   * `input` is decidable from its prefix: `unwrapFreeformToolInput` returns it whenever the
+   * key is present, whatever else the object carries, so its value can be unescaped
+   * progressively and never retracted.
+   *
+   * One case escapes that claim and is accepted rather than fixed: a duplicate `input` key.
+   * `JSON.parse` keeps the last one, so `{"input":"a","input":"b"}` streams a and completes with
+   * b. Closing it means holding every canonical wrapper until its object parses, which is the
+   * progressive streaming this path exists to provide. The completed item stays authoritative,
+   * and no model emits a duplicate key in practice.
+   *
+   * A wrapper that turns invalid AFTER streaming has committed has the same shape and the same
+   * answer. `{"input":"a` followed by `\\qb"}` has already published a when the undefined escape
+   * arrives, and completion returns the raw text because nothing parses. The preview stops
+   * there: no rewind, and no decoded text the completed item does not contain. Bounding the
+   * damage is what is available without giving up progressive streaming, and the args are
+   * unusable in that case whichever representation wins.
+   *
+   * A fallback key is not. It only unwraps when it is the SINGLE string field, and a second
+   * key can still arrive — so a value emitted early would have to be taken back. That is the
+   * rewind this holds instead: stream nothing until the object closes, then publish the one
+   * repaired body. The routed passthrough in `responses-custom-tool-repair.ts` already holds
+   * any object prefix for the same reason (#5047).
+   */
+  const freeformPartialInput = (args: string, toolName: string): string | null => {
+    const openings = ["input", ...freeformFallbackKeys(toolName)]
+      .map(key => ({ key, opening: wrapperOpening(args, key) }));
+    const canonical = openings[0]!.opening;
+    if (canonical.state === "open") {
+      const decoded = decodeJsonStringPrefix(args.slice(canonical.valueStart));
+      if (decoded === null) return null;
+      return mayBecomeFencedBody(decoded, toolName) ? null : decoded;
+    }
+    if (openings.some(entry => entry.opening.state === "open")) {
+      // Committed to a fallback wrapper. Undecidable until the object is complete.
+      try {
+        JSON.parse(args);
+      } catch {
+        return null;
+      }
+      return unwrapFreeformToolInput(args, toolName);
+    }
+    // Still an ambiguous prefix of some wrapper: which wrapper, if any, is not known yet.
+    if (openings.some(entry => entry.opening.state === "prefix")) return null;
+    return mayBecomeFencedBody(args, toolName) ? null : args;
+  };
   // tool_search_call carries arguments as a JSON object ({query, limit}); parse the model's arg string.
   const parseArgsObj = (args: string): Record<string, unknown> => {
     try { const o = JSON.parse(args); return o && typeof o === "object" ? o : {}; } catch { return {}; }
@@ -1075,10 +1199,21 @@ export function bridgeToResponsesSSE(
                   });
                 }
                 if (currentToolCall.freeform && !currentToolCall.codeModeHelperName) {
-                  // Hold while the buffer is still an ambiguous prefix of the JSON wrapper,
-                  // then stream only the unwrapped input suffix (never rewind on mode flips).
-                  if (!FREEFORM_WRAP_PREFIX.startsWith(currentToolCall.args)) {
-                    const full = freeformPartialInput(currentToolCall.args);
+                  // `freeformPartialInput` holds while the buffer is still an ambiguous prefix
+                  // of a JSON wrapper; otherwise stream only the unwrapped input suffix, never
+                  // rewinding on a mode flip.
+                  //
+                  // The name is dropped for a namespaced tool that does not own the apply-patch
+                  // grammar, because `repairFreeformToolInput` drops it at completion for the
+                  // same reason. Streaming under a vocabulary the completed item does not use
+                  // is the same disagreement in the other direction.
+                  const ownsFreeformGrammar = currentToolCall.namespace === undefined
+                    || currentToolCall.namespace === "functions";
+                  const full = freeformPartialInput(
+                    currentToolCall.args,
+                    ownsFreeformGrammar ? currentToolCall.name : "",
+                  );
+                  if (full !== null) {
                     const emitted = currentToolCall.inputEmitted ?? "";
                     // Also hold a buffer that could still become a complete patch envelope:
                     // at completion such a body is recompiled into an apply_patch helper call,
@@ -1086,7 +1221,13 @@ export function bridgeToResponsesSSE(
                     const mayCompile = declaresCodeModeExec(options?.declaredToolNames)
                       && !currentToolCall.namespace
                       && currentToolCall.name === "exec";
-                    if (!(mayCompile && mayBecomePatchEnvelope(full)) && full.startsWith(emitted) && full.length > emitted.length) {
+                    // `apply_patch` holds for a different reason with the same shape:
+                    // `normalizeApplyPatchDelimiters` rewrites a decorated `*** Begin Patch ***`
+                    // envelope at completion, so streaming the decorated markers would be
+                    // replaced by the normalized ones.
+                    const mayNormalize = ownsFreeformGrammar && currentToolCall.name === "apply_patch";
+                    if (!((mayCompile || mayNormalize) && mayBecomePatchEnvelope(full))
+                      && full.startsWith(emitted) && full.length > emitted.length) {
                       emit("response.custom_tool_call_input.delta", {
                         item_id: currentToolCall.itemId, output_index: currentToolCall.outputIndex,
                         delta: full.slice(emitted.length),
@@ -1171,7 +1312,7 @@ export function bridgeToResponsesSSE(
               break;
             }
             case "done": {
-              if (currentMsg) closeCurrentMessage(event.stopReason ? undefined : "final_answer");
+              if (currentMsg) closeCurrentMessage(isTruncatedStopReason(event.stopReason) ? undefined : "final_answer");
               if (currentReasoning) closeCurrentReasoning();
               if (currentRawReasoning) closeCurrentRawReasoning();
               flushHiddenRawReasoning();

package/src/claude/context-windows.ts

@@ -86,6 +86,28 @@ export function resolveAutoContext(claudeCode: AutoContextConfigSlice | undefine
   return { enabled: true, compactWindow };
 }
 
+/**
+ * Config value -> ENABLE_TOOL_SEARCH wire value (#4838).
+ *
+ * Claude Code parses this variable itself and accepts more than a boolean:
+ * "true", "auto", "auto:N" (N is a percentage floor for non-deferred tools; its
+ * parser rejects anything under 100) and "force", which also overrides an
+ * OS-level managed-settings suppression. Passing a string through verbatim keeps
+ * that whole vocabulary reachable instead of flattening it to a boolean that
+ * would have to be re-expanded here later.
+ *
+ * `false`, absent and blank inject nothing rather than injecting "false". Every
+ * caller injects with user-wins semantics, so an operator's own export survives
+ * either way, and writing "false" would be the one path that could quietly
+ * disagree with it.
+ */
+export function claudeToolSearchEnv(value: boolean | string | undefined): string | undefined {
+  if (value === true) return "true";
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
 /**
  * [1m]-marking predicate. Windows >= 1M always mark (CLI accounts exactly 1M).
  * Auto-context additionally marks windows > 200k that can safely host the compact

package/src/claude/outbound.ts

@@ -189,7 +189,27 @@ function webSearchPairFromItem(item: Rec): { id: string; input: Rec; resultConte
   return { id, input, resultContent, completed };
 }
 
-function messageSnapshot(model: string): Rec {
+/**
+ * `inputTokenFloor` is this proxy's own count of the prompt it forwarded, used only when the
+ * upstream sent no confirmed usage before the first frame.
+ *
+ * Real Anthropic fills `message_start.message.usage.input_tokens` with the turn's prompt size,
+ * and third-party clients read it there — Paseo's context meter takes input from this frame and
+ * output from `message_delta`, so a hardcoded zero showed a nearly-empty ring for a turn whose
+ * `/context` reported ~97k (#4857). #4891 fixed the destinations that report usage up front;
+ * the internal bridge attaches `usage: null` to its lifecycle frames, so those paths had
+ * nothing to report and kept sending zero.
+ *
+ * A floor is a measurement, which is what makes it publishable here: it counts the prompt this
+ * proxy actually sent, the same estimate `claude-messages.ts` already trusts as a log floor. It
+ * is not a claim about upstream's tokenizer, and it is not final — `message_delta` carries the
+ * authoritative count for every reader that waits for it, exactly as before.
+ */
+function messageSnapshot(model: string, confirmedUsage?: Rec, inputTokenFloor?: number): Rec {
+  const usage = confirmedUsage
+    ?? (typeof inputTokenFloor === "number" && Number.isFinite(inputTokenFloor) && inputTokenFloor > 0
+      ? { input_tokens: Math.trunc(inputTokenFloor), output_tokens: 0 }
+      : { input_tokens: 0, output_tokens: 0 });
   return {
     id: `msg_${uuid()}`,
     type: "message",
@@ -198,7 +218,7 @@ function messageSnapshot(model: string): Rec {
     model,
     stop_reason: null,
     stop_sequence: null,
-    usage: { input_tokens: 0, output_tokens: 0 },
+    usage,
   };
 }
 
@@ -228,7 +248,15 @@ interface OpenBlock {
 export function responsesSseToAnthropicSse(
   upstream: ReadableStream<Uint8Array>,
   model: string,
-  opts: { pingIntervalMs?: number; translatorBudget: TranslatorBudget },
+  opts: {
+    pingIntervalMs?: number;
+    translatorBudget: TranslatorBudget;
+    /**
+     * This proxy's count of the prompt it forwarded, published on `message_start` only when the
+     * upstream sent no confirmed usage before the first frame. See `messageSnapshot` (#4857).
+     */
+    inputTokenFloor?: number;
+  },
 ): ReadableStream<Uint8Array> {
   const translatorBudget = opts.translatorBudget;
   const pingIntervalMs = opts?.pingIntervalMs ?? 20_000;
@@ -246,6 +274,7 @@ export function responsesSseToAnthropicSse(
   let open: OpenBlock | null = null;
   let sawToolUse = false;
   let webSearchRequests = 0;
+  let earlyAnthropicUsage: Rec | undefined;
   let pingTimer: ReturnType<typeof setInterval> | undefined;
   let reader: ReadableStreamDefaultReader<Uint8Array> | undefined;
   const utf8SliceBytes = (value: string, start: number, end: number): number => {
@@ -282,7 +311,10 @@ export function responsesSseToAnthropicSse(
       const ensureStarted = () => {
         if (started) return;
         started = true;
-        emit("message_start", { type: "message_start", message: messageSnapshot(model) });
+        emit("message_start", {
+          type: "message_start",
+          message: messageSnapshot(model, earlyAnthropicUsage, opts.inputTokenFloor),
+        });
         emit("ping", { type: "ping" });
       };
       // Keepalive pings protect remote deployments behind LB/NAT idle timeouts even
@@ -405,8 +437,17 @@ export function responsesSseToAnthropicSse(
       const handleFrame = (eventName: string, data: Rec) => {
         switch (eventName) {
           case "response.created":
-            // Transport prelude only. Start Anthropic framing on semantic output or completion.
+          case "response.in_progress": {
+            // Lifecycle preludes do not start Anthropic framing, but some upstreams attach
+            // confirmed input usage before semantic output. Retain only its bounded Anthropic
+            // projection so message_start can report measurements that already arrived.
+            const response = isRec(data.response) ? data.response : {};
+            const usage = isRec(response.usage) ? response.usage : undefined;
+            if (!started && usage && typeof usage.input_tokens === "number") {
+              earlyAnthropicUsage = anthropicUsage(usage);
+            }
             break;
+          }
           case "response.heartbeat":
             if ((controller.desiredSize ?? 0) > 0) emit("ping", { type: "ping" });
             break;

package/src/cli/account-api.ts

@@ -370,9 +370,10 @@ async function fetchOAuthRows(
     email: a.email,
     active: a.active ?? a.id === activeId,
     needsReauth: a.needsReauth,
-    // Forward the server's answer verbatim, including `null`. Collapsing null to "absent" here
-    // would destroy the one distinction this field exists to make.
-    plan: a.plan ?? null,
+    // Forward the server's answer verbatim. An absent key means the proxy predates tier
+    // reporting while `null` means it checked and found no tier — collapsing either
+    // direction would destroy the one distinction this field exists to make.
+    ...(Object.hasOwn(a, "plan") ? { plan: a.plan } : {}),
     ...(a.quota !== undefined ? { quota: a.quota } : {}),
     ...(a.quotaUnavailable !== undefined ? { quotaUnavailable: a.quotaUnavailable } : {}),
     ...(a.quotaUnavailable === true && parseQuotaFailureCode(a.quotaFailure)