@cydm/pie 2.7.1 → 2.7.2

package/dist/builtin/skills/computer-use-axi/computer-use-axi-runtime.js

@@ -84,7 +84,7 @@ function computerUseOwnerFromEnv(env = process.env) {
 
 // vendor/computer-use-axi/src/broker-protocol.ts
 var BROKER_PROTOCOL_VERSION = 1;
-var BROKER_ENGINE_VERSION = 1;
+var BROKER_ENGINE_VERSION = 2;
 var BROKER_PACKAGE_VERSION = "0.5.1-pie.1";
 var BROKER_MAX_FRAME_BYTES = 4 * 1024 * 1024;
 var BROKER_MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
@@ -352,6 +352,7 @@ async function callBroker(options) {
         type: "request",
         protocolVersion: brokerProtocol,
         requestId: options.requestId,
+        generation: options.generation,
         ownerId: options.ownerId,
         executionId: options.executionId,
         command: options.command,
@@ -417,12 +418,14 @@ Commands:
   browser launch [--url U]
   browser navigate --state S --url U
   browser eval --state S --expr '<JavaScript>'
+  permissions setup|recheck  macOS: register/open Settings, or restart helper and check
   status  Show the local broker status (never starts one)
   stop    Stop the local broker and release processes it owns
 
 Options:
   --json          Print { content, details, isError } as JSON
-  --request-id ID Reuse an id to retrieve the same result (at-most-once)
+  --request-id ID Retrieve the same result within its original broker generation
+  --generation G Pin request/result retrieval to a broker generation (use with reused IDs)
   --owner ID      Opaque session identity (defaults to the standalone namespace)
   --help, -h      Show this help
 
@@ -526,6 +529,11 @@ function buildCommand(args) {
     usageError(`unknown browser subcommand '${sub}' (expected launch | navigate | eval)`);
   }
   switch (args.command) {
+    case "permissions": {
+      const mode = args.rest[0];
+      if (mode !== "setup" && mode !== "recheck") usageError("permissions requires setup | recheck");
+      return { command: "permissions", params: { mode } };
+    }
     case "status":
       return { command: "status", params: {} };
     case "stop":
@@ -655,6 +663,7 @@ async function main() {
       ownerId: ownerId === COMPUTER_USE_STANDALONE_OWNER ? ownerId : ownerId,
       executionId,
       requestId,
+      generation: optionalFlag(args, "--generation"),
       cwd: process.cwd(),
       budgetMs,
       spawnIfMissing: !control

package/dist/chunks/{chunk-M44CWVDZ.js → chunk-65B6P5J5.js}

@@ -2,7 +2,7 @@ import { createRequire as __createRequire } from "node:module"; const require =
 import {
   Agent,
   getToolCallerIdentity
-} from "./chunk-NJFPBU36.js";
+} from "./chunk-GZDAIW6F.js";
 import {
   AssistantMessageEventStream,
   FileSystemGateway,
@@ -12,7 +12,7 @@ import {
   getPlatformConfig,
   hashText,
   streamSimple
-} from "./chunk-XUROMYTT.js";
+} from "./chunk-BRFP5WZ6.js";
 import {
   Type
 } from "./chunk-XXGYUYXI.js";
@@ -978,6 +978,39 @@ var SIMPLE_READ_COMMANDS = /* @__PURE__ */ new Set(["pwd", "ls", "cat", "head",
 var GIT_READ_SUBCOMMANDS = /* @__PURE__ */ new Set(["status", "log", "diff", "show", "rev-parse", "ls-files", "ls-tree", "blame", "describe", "shortlog", "merge-base"]);
 var UNSAFE_GIT_FLAGS = /^(?:-c|--config-env|--exec|--output|--ext-diff|--textconv)(?:=|$)/;
 var UNSAFE_RG_FLAGS = /^(?:--pre|--pre-glob)(?:=|$)/;
+function longOptionUnsafe(arg, dangerous, benign) {
+  const name = arg.slice(2).split("=", 1)[0];
+  if (!name) return true;
+  if (dangerous.some((option) => option.startsWith(name))) return true;
+  return !benign.some((option) => option.startsWith(name));
+}
+function isReadOnlyUniq(args) {
+  let operands = 0;
+  let endOptions = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!endOptions && arg === "--") {
+      endOptions = true;
+      continue;
+    }
+    if (!endOptions && arg.startsWith("--")) {
+      if (/^--(?:skip-fields|skip-chars|check-chars)(?:=\d+)?$/.test(arg)) {
+        if (!arg.includes("=") && !/^\d+$/.test(args[++i] ?? "")) return false;
+      } else if (longOptionUnsafe(arg, [], ["count", "repeated", "unique", "all-repeated", "group", "ignore-case", "zero-terminated", "help", "version"])) {
+        return false;
+      }
+      continue;
+    }
+    if (!endOptions && arg.startsWith("-") && arg !== "-") {
+      const match2 = /^-[cdDuiz]*(?:([fsw])(\d*))?$/.exec(arg);
+      if (!match2) return false;
+      if (match2[1] && !match2[2] && !/^\d+$/.test(args[++i] ?? "")) return false;
+      continue;
+    }
+    if (++operands > 1) return false;
+  }
+  return true;
+}
 function isReadOnlySegment(words) {
   if (words.length === 0) return false;
   const [program, ...args] = words;
@@ -991,11 +1024,72 @@ function isReadOnlySegment(words) {
     return !args.some((arg) => /^-(?:exec|execdir|ok|okdir|delete|fprint|fls|fprintf)/.test(arg));
   }
   if (program === "tree") {
-    return !args.some((arg) => /^-o./.test(arg) || arg === "-o" || arg === "--output" || arg.startsWith("--output="));
+    return !args.some((arg) => /^-[^-]*o/.test(arg) || arg.startsWith("--") && arg !== "--" && longOptionUnsafe(arg, ["output"], [
+      "ascii",
+      "charset",
+      "color",
+      "dirsfirst",
+      "du",
+      "filelimit",
+      "hardlinks",
+      "help",
+      "ignore-case",
+      "inode",
+      "links",
+      "metafirst",
+      "noreport",
+      "nolinks",
+      "outdent",
+      "quote",
+      "sort",
+      "timefmt",
+      "version",
+      "pattern",
+      "matchdirs",
+      "prune"
+    ]));
   }
   if (program === "sort") {
-    return !args.some((arg) => /^-o./.test(arg) || arg === "-o" || arg === "--output" || arg.startsWith("--output=") || arg === "--compress-program" || arg.startsWith("--compress-program="));
+    return !args.some((arg) => {
+      if (arg === "--") return false;
+      if (arg.startsWith("--")) {
+        return longOptionUnsafe(arg, ["output", "compress-program"], [
+          "numeric-sort",
+          "general-numeric-sort",
+          "human-numeric-sort",
+          "month-sort",
+          "version-sort",
+          "random-sort",
+          "random-source",
+          "reverse",
+          "unique",
+          "check",
+          "check-silent",
+          "ignore-case",
+          "ignore-leading-blanks",
+          "ignore-nonprinting",
+          "ignore-blanks",
+          "dictionary-order",
+          "merge",
+          "stable",
+          "batch-size",
+          "buffer-size",
+          "pipe-size",
+          "parallel",
+          "temporary-directory",
+          "field-separator",
+          "zero-terminated",
+          "help",
+          "version",
+          "debug",
+          "sort"
+        ]);
+      }
+      if (arg.startsWith("-") && arg !== "-") return arg.slice(1).includes("o");
+      return false;
+    });
   }
+  if (program === "uniq") return isReadOnlyUniq(args);
   if (program === "date") {
     return args.every((arg) => arg.startsWith("-") || arg.startsWith("+"));
   }
@@ -1059,6 +1153,7 @@ ${inlineMatch[1]}`;
 function isPlanModeSafeCommand(command) {
   const trimmed = command.trim();
   if (!trimmed || /[$`\n\r\0]/.test(trimmed)) return false;
+  if (/\{[^{}]*\}/.test(trimmed) || /\{\s*,/.test(trimmed)) return false;
   let tokens;
   try {
     tokens = (0, import_shell_quote.parse)(trimmed);
@@ -3193,6 +3288,9 @@ function isTransientCompactionFailure(error) {
   if (status !== void 0) return status === 429 || status >= 500 && status <= 599;
   return /\b(?:429|5\d\d|ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|ECONNREFUSED|EPIPE)\b|fetch failed|network error|request timeout|socket hang up|connection error|sse stream (?:aborted|closed before end|ended before response completed)|rate.?limit|too many requests|overloaded|service unavailable/i.test(text);
 }
+function explicitlyNonRetryable(error) {
+  return Boolean(error && typeof error === "object" && error.retryable === false);
+}
 function waitForCompactionRetry(delayMs, signal) {
   return new Promise((resolve2, reject) => {
     const abort = () => {
@@ -3245,11 +3343,14 @@ Return a text-only successor handoff. Do not call any tools.` }],
       ).result();
       throwIfAborted();
       if (response.stopReason === "error" && !response.content.some((block) => block.type === "toolCall")) {
-        throw new Error(response.errorMessage || "Compaction provider error");
+        const providerError = new Error(response.errorMessage || "Compaction provider error");
+        const explicitRetryable = response.retryable;
+        if (typeof explicitRetryable === "boolean") providerError.retryable = explicitRetryable;
+        throw providerError;
       }
     } catch (error) {
       throwIfAborted();
-      if (attempt >= 2 || !isTransientCompactionFailure(error)) throw error;
+      if (attempt >= 2 || explicitlyNonRetryable(error) || !isTransientCompactionFailure(error)) throw error;
       await waitForCompactionRetry(250 * 2 ** attempt, signal);
       continue;
     }
@@ -3680,6 +3781,10 @@ var LruCache = class {
   weigh;
   maxWeight;
   map = /* @__PURE__ */ new Map();
+  total = 0;
+  weightOf(value) {
+    return this.weigh ? this.weigh(value) : 1;
+  }
   get(key) {
     const value = this.map.get(key);
     if (value !== void 0) {
@@ -3690,34 +3795,36 @@ var LruCache = class {
   }
   /** Insert a value, evicting until the entry and total weight fit. */
   set(key, value) {
-    this.map.delete(key);
-    const weight = this.weigh ? this.weigh(value) : 1;
+    const existing = this.map.get(key);
+    if (existing !== void 0) {
+      this.total -= this.weightOf(existing);
+      this.map.delete(key);
+    }
+    const weight = this.weightOf(value);
     if (weight > this.maxWeight) {
       return;
     }
-    let total = this.totalWeight() + weight;
-    while ((this.map.size >= this.limit || total > this.maxWeight) && this.map.size > 0) {
+    this.total += weight;
+    while ((this.map.size >= this.limit || this.total > this.maxWeight) && this.map.size > 0) {
       const oldest = this.map.keys().next().value;
-      const evicted = this.map.get(oldest);
-      total -= this.weigh ? this.weigh(evicted) : 1;
+      this.total -= this.weightOf(this.map.get(oldest));
       this.map.delete(oldest);
     }
     this.map.set(key, value);
   }
   delete(key) {
-    this.map.delete(key);
+    const existing = this.map.get(key);
+    if (existing !== void 0) {
+      this.total -= this.weightOf(existing);
+      this.map.delete(key);
+    }
   }
   clear() {
     this.map.clear();
+    this.total = 0;
   }
   get weight() {
-    return this.totalWeight();
-  }
-  totalWeight() {
-    if (!this.weigh) return this.map.size;
-    let total = 0;
-    for (const value of this.map.values()) total += this.weigh(value);
-    return total;
+    return this.total;
   }
 };
 function isRecord(value) {
@@ -6855,6 +6962,17 @@ function isAssistantTerminalCompletion(message) {
 }
 function createFailureClassification(context, retry, classifyFailure) {
   if (context.message?.role === "assistant" && context.message.retryable === false) {
+    if (context.message.replayEligible === true) {
+      return {
+        kind: "provider_transient",
+        retryable: true,
+        compactable: false,
+        userAbort: context.message.stopReason === "aborted",
+        terminal: false,
+        message: context.errorMessage,
+        replayExempt: true
+      };
+    }
     return { kind: "unknown", retryable: false, compactable: false, userAbort: context.message.stopReason === "aborted", terminal: true, message: context.errorMessage };
   }
   const hostClassification = classifyFailure?.(context);
@@ -6873,13 +6991,7 @@ function createFailureClassification(context, retry, classifyFailure) {
   };
 }
 function asTerminalFailure(failure, message = failure.message) {
-  return {
-    ...failure,
-    retryable: false,
-    compactable: false,
-    terminal: true,
-    message
-  };
+  return { ...failure, retryable: false, compactable: false, terminal: true, message };
 }
 function emitTurnEndPolicyFailure(emit, error) {
   const message = error instanceof Error ? error.message : String(error);
@@ -6907,6 +7019,36 @@ function handleTurnEndPolicyThrow(emit, error, context) {
   emit({ type: "turn_policy_error", message: `Turn-end policy failed after settle: ${message}` });
 }
 
+// ../../packages/agent-framework/src/session/controller/replay-stall-circuit.ts
+var ReplayStallCircuit = class {
+  constructor(limit) {
+    this.limit = limit;
+  }
+  limit;
+  consecutiveStalls = 0;
+  open = false;
+  get isOpen() {
+    return this.open;
+  }
+  get consecutiveTurnStalls() {
+    return this.consecutiveStalls;
+  }
+  /** A replay-exempt retry budget was exhausted for this turn. */
+  recordReplayExhaustion() {
+    this.consecutiveStalls += 1;
+    if (this.limit !== void 0 && this.consecutiveStalls >= this.limit && !this.open) {
+      this.open = true;
+      return { opened: true, consecutive: this.consecutiveStalls };
+    }
+    return { opened: false, consecutive: this.consecutiveStalls };
+  }
+  /** A turn succeeded, or failed in a way the endpoint actively answered. */
+  recordHealthyTurn() {
+    this.consecutiveStalls = 0;
+    this.open = false;
+  }
+};
+
 // ../../packages/agent-framework/src/session/controller/retry-policy.ts
 function defaultSetTimeout4(callback, delay) {
   return setTimeout(callback, delay);
@@ -6921,6 +7063,7 @@ var AgentSessionRetryController = class {
     this.removeTrailingAssistantError = removeTrailingAssistantError2;
     this.continueTurn = continueTurn;
     this.setRecoveryState = setRecoveryState;
+    this.replayCircuit = new ReplayStallCircuit(retry?.systemicReplayStallLimit);
   }
   retry;
   emit;
@@ -6933,6 +7076,8 @@ var AgentSessionRetryController = class {
   retryAttempts = /* @__PURE__ */ new Map();
   /** Total attempts across kinds in this recovery episode, for reporting. */
   totalRetryAttempts = 0;
+  /** L2 systemic-stall circuit (see replay-stall-circuit.ts). */
+  replayCircuit;
   retryTimer;
   retryEpoch = 0;
   pendingRetry;
@@ -6946,12 +7091,17 @@ var AgentSessionRetryController = class {
   waitForRetry() {
     return this.pendingRetry ?? Promise.resolve();
   }
+  /** L2 circuit: healthy turn (success or an actively-answered failure). */
+  noteEndpointHealthy() {
+    this.replayCircuit.recordHealthyTurn();
+  }
   async handleTurnEnd(message, failure) {
     if (!this.retry || !message || message.role !== "assistant") {
       this.settleStrandedRetry(failure);
       return;
     }
     if (!failure) {
+      this.noteEndpointHealthy();
       if (this.totalRetryAttempts > 0) {
         this.emit({ type: "retry_succeeded", attempts: this.totalRetryAttempts });
         this.emit({ type: "turn_retry_succeeded", attempts: this.totalRetryAttempts });
@@ -6962,6 +7112,9 @@ var AgentSessionRetryController = class {
       return;
     }
     if (!failure.retryable) {
+      if (failure.kind !== "unknown" && failure.kind !== "internal_error") {
+        this.noteEndpointHealthy();
+      }
       if (this.totalRetryAttempts > 0) {
         this.resetAttempts();
         this.setRecoveryState("none");
@@ -6969,6 +7122,16 @@ var AgentSessionRetryController = class {
       }
       return;
     }
+    if (failure.replayExempt === true && this.replayCircuit.isOpen) {
+      const openFailure = asTerminalFailure(failure, `${failure.message} (replay circuit open: ${this.replayCircuit.consecutiveTurnStalls} consecutive turns ended by timeout-replay exhaustion)`);
+      this.emit({ type: "retry_exhausted", errorMessage: openFailure.message, maxRetries: 0 });
+      this.emit({ type: "turn_failed_terminal", failure: openFailure, message });
+      this.emit({ type: "turn_settled" });
+      this.resetAttempts();
+      this.setRecoveryState("terminal");
+      this.resolvePending();
+      return;
+    }
     const maxRetries = this.retry.maxRetriesForFailure?.(failure) ?? this.retry.maxRetries ?? 3;
     const kindAttempts = (this.retryAttempts.get(failure.kind) ?? 0) + 1;
     this.retryAttempts.set(failure.kind, kindAttempts);
@@ -6978,6 +7141,12 @@ var AgentSessionRetryController = class {
     const totalExhausted = totalBudget !== void 0 && this.totalRetryAttempts > totalBudget;
     if (kindExhausted || totalExhausted) {
       const terminalFailure = asTerminalFailure(failure);
+      if (failure.replayExempt === true) {
+        const outcome = this.replayCircuit.recordReplayExhaustion();
+        if (outcome.opened) {
+          this.emit({ type: "retry_exhausted", errorMessage: `systemic timeout-stall: ${outcome.consecutive} consecutive turns ended by timeout-replay exhaustion`, maxRetries: totalExhausted ? totalBudget : maxRetries });
+        }
+      }
       this.emit({ type: "retry_exhausted", errorMessage: failure.message, maxRetries: totalExhausted ? totalBudget : maxRetries });
       this.emit({ type: "turn_failed_terminal", failure: terminalFailure, message });
       this.emit({ type: "turn_settled" });
@@ -7012,11 +7181,7 @@ var AgentSessionRetryController = class {
         if (epoch !== this.retryEpoch || pending !== this.pendingRetry) return;
         const errorMessage = error instanceof Error ? error.message : String(error);
         const terminalFailure = asTerminalFailure(failure, errorMessage);
-        this.emit({
-          type: "retry_exhausted",
-          errorMessage,
-          maxRetries
-        });
+        this.emit({ type: "retry_exhausted", errorMessage, maxRetries });
         this.emit({ type: "turn_failed_terminal", failure: terminalFailure, message });
         this.emit({ type: "turn_settled" });
         this.resetAttempts();
@@ -7071,9 +7236,7 @@ var AgentSessionRetryController = class {
     this.retryTimer = void 0;
   }
   ensurePending() {
-    if (this.pendingRetry) {
-      return;
-    }
+    if (this.pendingRetry) return;
     this.pendingRetry = new Promise((resolve2) => {
       this.resolvePendingRetry = resolve2;
     });

package/dist/chunks/{chunk-XUROMYTT.js → chunk-BRFP5WZ6.js}

@@ -1890,6 +1890,10 @@ var NodeHttpClient = class {
     let tieredBodyByteSeen = false;
     let tierMarkBodyByte = null;
     let requestTimeoutError;
+    const setTimeoutKind = (error, kind) => {
+      if (!error) return;
+      error.timeoutKind = kind;
+    };
     const clearTieredFirstByteTimer = () => {
       if (tieredFirstByteTimer !== void 0) {
         clearTimeout(tieredFirstByteTimer);
@@ -1933,6 +1937,7 @@ var NodeHttpClient = class {
               res.on("timeout", () => {
                 if (res.readableEnded || res.complete) return;
                 requestTimeoutError = new Error(`Request timeout (stream idle) after ${tieredStreamIdleTimeoutMs}ms`);
+                setTimeoutKind(requestTimeoutError, "stream_idle");
                 logHttp("WARN", `Request [${reqTag}] stream idle timeout`, { idleTimeoutMs: tieredStreamIdleTimeoutMs });
                 req.destroy(requestTimeoutError);
               });
@@ -2178,6 +2183,7 @@ var NodeHttpClient = class {
       if (!tieredStreamTimeout) {
         req.on("timeout", () => {
           requestTimeoutError = new Error("Request timeout");
+          setTimeoutKind(requestTimeoutError, "total");
           logHttp("ERROR", `Request [${reqTag}] timeout`);
           req.destroy(requestTimeoutError);
         });
@@ -2186,6 +2192,7 @@ var NodeHttpClient = class {
         tieredFirstByteTimer = setTimeout(() => {
           tieredFirstByteTimer = void 0;
           requestTimeoutError = new Error(`Request timeout (first byte) after ${tieredFirstByteTimeoutMs}ms`);
+          setTimeoutKind(requestTimeoutError, "first_byte");
           logHttp("WARN", `Request [${reqTag}] first byte timeout`, { firstByteTimeoutMs: tieredFirstByteTimeoutMs });
           req.destroy(requestTimeoutError);
         }, tieredFirstByteTimeoutMs);
@@ -3368,6 +3375,10 @@ function buildBaseOptions(model, options, apiKey) {
     sessionId: options?.sessionId,
     headers: options?.headers,
     timeoutMs: options?.timeoutMs,
+    firstResponseTimeoutMs: options?.firstResponseTimeoutMs,
+    streamIdleTimeoutMs: options?.streamIdleTimeoutMs,
+    requestTimeoutMs: options?.requestTimeoutMs,
+    connectionIdleTimeoutMs: options?.connectionIdleTimeoutMs,
     onPayload: options?.onPayload,
     onTransportDiagnostic: options?.onTransportDiagnostic,
     onTransportLifecycle: options?.onTransportLifecycle,
@@ -4887,7 +4898,10 @@ function getResponsesCompat(model) {
     supportsStore: compat.supportsStore ?? true,
     supportsReasoningEffort: compat.supportsReasoningEffort ?? true,
     supportsEncryptedReasoning: compat.supportsEncryptedReasoning ?? true,
-    responsesContinuation: compat.responsesContinuation ?? false
+    responsesContinuation: compat.responsesContinuation ?? false,
+    supportsReasoningSummary: compat.supportsReasoningSummary ?? false,
+    reasoningSummary: compat.reasoningSummary ?? "auto",
+    timeoutReplay: compat.timeoutReplay ?? false
   };
 }
 
@@ -5074,6 +5088,10 @@ function buildResponsesRequest(model, context, options, compat = getResponsesCom
   if (options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) {
     params.reasoning = { effort: options.reasoningEffort };
   }
+  if (model.reasoning && compat.supportsReasoningSummary && compat.reasoningSummary !== "none") {
+    params.reasoning = params.reasoning ?? {};
+    params.reasoning.summary = compat.reasoningSummary;
+  }
   if (compat.supportsEncryptedReasoning && model.reasoning) {
     params.include = ["reasoning.encrypted_content"];
   }
@@ -5606,6 +5624,8 @@ function monotonicNow() {
 // ../../packages/ai/src/providers/responses/responses-sse.ts
 var DEFAULT_RESPONSES_STREAM_IDLE_TIMEOUT_MS = 2 * 60 * 1e3;
 var DEFAULT_RESPONSES_FIRST_BYTE_TIMEOUT_MS = 3 * 60 * 1e3;
+var REASONING_STREAM_IDLE_TIMEOUT_MS = 5 * 60 * 1e3;
+var REASONING_FIRST_BYTE_TIMEOUT_MS = 5 * 60 * 1e3;
 function parseSSEDataLine2(line) {
   const trimmed = line.trim();
   if (!trimmed || trimmed.startsWith(":")) return null;
@@ -5635,16 +5655,19 @@ function explicitBudget(value, field) {
   }
   return value;
 }
-function resolveSSEBudgets(options) {
+function resolveSSEBudgets(options, model) {
   const firstResponse = explicitBudget(options?.firstResponseTimeoutMs, "firstResponseTimeoutMs");
   const streamIdle = explicitBudget(options?.streamIdleTimeoutMs, "streamIdleTimeoutMs");
   const requestTimeoutMs = explicitBudget(options?.requestTimeoutMs, "requestTimeoutMs");
   explicitBudget(options?.connectionIdleTimeoutMs, "connectionIdleTimeoutMs");
+  const reasoning = model.reasoning === true;
+  const defaultFirstByte = reasoning ? REASONING_FIRST_BYTE_TIMEOUT_MS : DEFAULT_RESPONSES_FIRST_BYTE_TIMEOUT_MS;
+  const defaultIdle = reasoning ? REASONING_STREAM_IDLE_TIMEOUT_MS : DEFAULT_RESPONSES_STREAM_IDLE_TIMEOUT_MS;
   if (firstResponse !== void 0 || streamIdle !== void 0) {
     return {
       http: {
-        firstByteTimeoutMs: firstResponse ?? DEFAULT_RESPONSES_FIRST_BYTE_TIMEOUT_MS,
-        streamIdleTimeoutMs: streamIdle ?? DEFAULT_RESPONSES_STREAM_IDLE_TIMEOUT_MS
+        firstByteTimeoutMs: firstResponse ?? defaultFirstByte,
+        streamIdleTimeoutMs: streamIdle ?? defaultIdle
       },
       requestTimeoutMs
     };
@@ -5652,8 +5675,8 @@ function resolveSSEBudgets(options) {
   if (options?.timeoutMs !== void 0) return { http: { timeoutMs: options.timeoutMs }, requestTimeoutMs };
   return {
     http: {
-      firstByteTimeoutMs: DEFAULT_RESPONSES_FIRST_BYTE_TIMEOUT_MS,
-      streamIdleTimeoutMs: DEFAULT_RESPONSES_STREAM_IDLE_TIMEOUT_MS
+      firstByteTimeoutMs: defaultFirstByte,
+      streamIdleTimeoutMs: defaultIdle
     },
     requestTimeoutMs
   };
@@ -5701,7 +5724,7 @@ function streamResponsesSSE(model, context, options) {
     try {
       let resolved;
       try {
-        resolved = resolveSSEBudgets(options);
+        resolved = resolveSSEBudgets(options, model);
       } catch (error) {
         localFailure = true;
         throw error;
@@ -5824,7 +5847,15 @@ function streamResponsesSSE(model, context, options) {
       const message = reducer.message;
       const userAborted = options?.signal?.aborted === true;
       message.stopReason = userAborted ? "aborted" : "error";
+      const adapterTimeoutKind = error instanceof Error ? error.timeoutKind : void 0;
+      if (!internalTimeout && (adapterTimeoutKind === "first_byte" || adapterTimeoutKind === "stream_idle")) {
+        internalTimeout = adapterTimeoutKind === "first_byte" ? "first_response" : "stream_idle";
+      }
       message.errorMessage = internalTimeout ? `Responses request timeout (${internalTimeout}) after ${Math.round(monotonicNow() - startedAt)}ms` : error instanceof Error ? error.message : JSON.stringify(error);
+      if (internalTimeout && getResponsesCompat(model).timeoutReplay) {
+        message.replayEligible = true;
+        message.replayClass = internalTimeout;
+      }
       if (submitted || localFailure) message.retryable = false;
       phase = "cleanup";
       lifecycle({
@@ -5851,6 +5882,8 @@ var DEFAULT_CONNECT_TIMEOUT_MS = 3e4;
 var DEFAULT_FIRST_RESPONSE_TIMEOUT_MS = 2 * 60 * 1e3;
 var DEFAULT_STREAM_IDLE_TIMEOUT_MS = 2 * 60 * 1e3;
 var DEFAULT_CONNECTION_IDLE_TIMEOUT_MS = 2 * 60 * 1e3;
+var REASONING_FIRST_RESPONSE_TIMEOUT_MS = 5 * 60 * 1e3;
+var REASONING_STREAM_IDLE_TIMEOUT_MS2 = 5 * 60 * 1e3;
 var ITERATOR_CLEANUP_TIMEOUT_MS = 1e3;
 function explicitBudget2(value, field) {
   if (value === void 0) return void 0;
@@ -5859,16 +5892,17 @@ function explicitBudget2(value, field) {
   }
   return value;
 }
-function resolveBudgets(options) {
+function resolveBudgets(options, model) {
   const firstResponse = explicitBudget2(options?.firstResponseTimeoutMs, "firstResponseTimeoutMs");
   const streamIdle = explicitBudget2(options?.streamIdleTimeoutMs, "streamIdleTimeoutMs");
   const requestTimeout = explicitBudget2(options?.requestTimeoutMs, "requestTimeoutMs");
   const connectionIdle = explicitBudget2(options?.connectionIdleTimeoutMs, "connectionIdleTimeoutMs");
   const legacy = options?.timeoutMs !== void 0 && Number.isFinite(options.timeoutMs) && options.timeoutMs > 0 ? options.timeoutMs : void 0;
+  const reasoning = model.reasoning === true;
   return {
     connectTimeoutMs: legacy ?? DEFAULT_CONNECT_TIMEOUT_MS,
-    firstResponseTimeoutMs: firstResponse ?? legacy ?? DEFAULT_FIRST_RESPONSE_TIMEOUT_MS,
-    streamIdleTimeoutMs: streamIdle ?? legacy ?? DEFAULT_STREAM_IDLE_TIMEOUT_MS,
+    firstResponseTimeoutMs: firstResponse ?? legacy ?? (reasoning ? REASONING_FIRST_RESPONSE_TIMEOUT_MS : DEFAULT_FIRST_RESPONSE_TIMEOUT_MS),
+    streamIdleTimeoutMs: streamIdle ?? legacy ?? (reasoning ? REASONING_STREAM_IDLE_TIMEOUT_MS2 : DEFAULT_STREAM_IDLE_TIMEOUT_MS),
     requestTimeoutMs: requestTimeout,
     connectionIdleTimeoutMs: connectionIdle ?? DEFAULT_CONNECTION_IDLE_TIMEOUT_MS
   };
@@ -5937,7 +5971,7 @@ function streamResponsesWS(model, context, options) {
   }
   let budgets;
   try {
-    budgets = resolveBudgets(options);
+    budgets = resolveBudgets(options, model);
   } catch (error) {
     reducer.message.stopReason = "error";
     reducer.message.errorMessage = error instanceof Error ? error.message : String(error);
@@ -5966,6 +6000,7 @@ function streamResponsesWS(model, context, options) {
     let requestTimer;
     let totalTimer;
     let receiveCleanupFailed = false;
+    const compat = getResponsesCompat(model);
     let cleanupCancelSource;
     const requestAbort = new AbortController();
     const publish = (event) => {
@@ -6081,7 +6116,9 @@ function streamResponsesWS(model, context, options) {
           cancelSource: "internal_timeout",
           retryAllowed: !sent,
           retryDecision,
-          submissionAttempted: sent
+          submissionAttempted: sent,
+          // L2 diagnostic surface: this timeout qualifies for bounded replay.
+          ...compat.timeoutReplay && sent ? { replayExempt: true } : {}
         });
         requestAbort.abort();
       }, timeoutMs);
@@ -6273,6 +6310,10 @@ function streamResponsesWS(model, context, options) {
         message.stopReason = userAborted || ownerDisposed ? "aborted" : "error";
         const cause = timedOut ? `Responses request timeout (${timedOut}) after ${ageMs()}ms` : error instanceof Error ? error.message : String(error);
         message.errorMessage = cause;
+        if (timedOut && compat.timeoutReplay) {
+          message.replayEligible = true;
+          message.replayClass = timedOut;
+        }
         if (sent) {
           message.retryable = false;
           retryDecision = "not_retryable_after_submission";

package/dist/chunks/{chunk-W74NRSRV.js → chunk-GECAIKZL.js}

@@ -6,10 +6,10 @@ import {
   createSharedWebSearchTool,
   interpretShellExit,
   requestInteraction
-} from "./chunk-M44CWVDZ.js";
+} from "./chunk-65B6P5J5.js";
 import {
   getLogger
-} from "./chunk-XUROMYTT.js";
+} from "./chunk-BRFP5WZ6.js";
 import {
   Type
 } from "./chunk-XXGYUYXI.js";
@@ -153,6 +153,7 @@ function formatTransportLifecycle(event) {
   if (event.terminalAccepted !== void 0) parts.push(`terminal=${event.terminalAccepted ? "yes" : "no"}`);
   if (event.retryAllowed !== void 0) parts.push(`retryAllowed=${event.retryAllowed ? "yes" : "no"}`);
   if (event.retryDecision) parts.push(`retryDecision=${event.retryDecision}`);
+  if (event.replayExempt === true) parts.push("replayExempt=yes");
   if (event.cancelSource) parts.push(`cancelSource=${event.cancelSource}`);
   if (event.cleanupOutcome) parts.push(`cleanup=${event.cleanupOutcome}`);
   if (event.singleAttempt) parts.push(`singleAttempt=${event.singleAttempt}`);

package/dist/chunks/{chunk-NJFPBU36.js → chunk-GZDAIW6F.js}

@@ -4,7 +4,7 @@ import {
   disposeModelTransports,
   streamSimple,
   validateToolArguments
-} from "./chunk-XUROMYTT.js";
+} from "./chunk-BRFP5WZ6.js";
 
 // ../../packages/agent-core/src/agent-loop.ts
 function createLoopErrorMessage(error, config, signal) {