agents 0.14.1 → 0.14.2

package/dist/{agent-tool-types-BAJWu8s4.d.ts → agent-tool-types-V25Z_HcX.d.ts}

@@ -4,7 +4,7 @@ import {
   n as Observability,
   r as ObservabilityEvent,
   s as MCPObservabilityEvent
-} from "./index-RJ4OxMOe.js";
+} from "./index-CPe1OtI0.js";
 import { t as AgentMcpOAuthProvider } from "./do-oauth-client-provider-D4ZwyBDu.js";
 import {
   _ as WorkflowPage,
@@ -2277,6 +2277,26 @@ declare const DEFAULT_AGENT_STATIC_OPTIONS: {
    * throwing so a poison row cannot re-trigger forever across boots.
    */
   fiberRecoveryMaxAgeMs: number;
+  /**
+   * No-progress budget (ms) for re-attaching to a still-running agent-tool
+   * child after a deploy / parent recovery (#1630). Bounds how long the parent
+   * waits with NO forward progress from the child; it resets on every forwarded
+   * chunk, so a child that keeps streaming is never abandoned mid-flight. Only a
+   * genuinely silent/hung child seals `interrupted` after a full window. Raise
+   * for children with long quiet stretches between outputs.
+   */
+  agentToolReattachNoProgressTimeoutMs: number;
+  /**
+   * Optional hard wall-clock ceiling (ms) on a single agent-tool re-attach
+   * (#1630). Caps the total wait even as the no-progress budget re-arms across
+   * stream-closes. Defaults to `Infinity` (no implicit cap), mirroring
+   * chat-recovery's `maxRecoveryWork` (#1672): a healthy, still-advancing child
+   * is followed for as long as it makes progress — a hung child is bounded by
+   * the no-progress budget, and a content-runaway by the child's own
+   * `maxRecoveryWork` / `shouldKeepRecovering`. Set a finite value to impose a
+   * wall-clock cap (which also tears the child down on `window-exceeded`).
+   */
+  agentToolReattachMaxWindowMs: number;
 };
 /**
  * Configuration options for the Agent.
@@ -2309,6 +2329,29 @@ interface AgentStaticOptions {
    * and discards the row. Set to `0` to retain rows indefinitely.
    */
   fiberRecoveryMaxAgeMs?: number;
+  /**
+   * No-progress budget in milliseconds for re-attaching to a still-running
+   * agent-tool child after a deploy / parent recovery (#1630). Resets on every
+   * forwarded chunk, so a steadily-streaming child is never abandoned; only a
+   * genuinely silent child seals `interrupted` after a full window.
+   * Default: 120000 (2 minutes). Set to `0` to skip waiting (collect only an
+   * already-terminal child). Set to `Infinity` to never seal on no-progress —
+   * a silent-but-alive child is then followed until its stream closes (or the
+   * `agentToolReattachMaxWindowMs` ceiling fires), mirroring that knob's
+   * "Infinity = off" convention.
+   */
+  agentToolReattachNoProgressTimeoutMs?: number;
+  /**
+   * Optional hard wall-clock ceiling in milliseconds on a single agent-tool
+   * re-attach (#1630). Caps the total wait even as the no-progress budget
+   * re-arms across stream-closes. Default: `Infinity` (no implicit cap),
+   * mirroring chat-recovery's `maxRecoveryWork` (#1672) — a healthy,
+   * still-advancing child is followed for as long as it makes progress, exactly
+   * as on the live (never-evicted) path. Set a finite value to impose a
+   * wall-clock cap (which also tears the child down on `window-exceeded`); `0`
+   * also disables the ceiling.
+   */
+  agentToolReattachMaxWindowMs?: number;
 }
 declare function getCurrentAgent<
   T extends Agent<Cloudflare.Env> = Agent<Cloudflare.Env>
@@ -2359,13 +2402,6 @@ declare class Agent<
   private _persistenceHookMode;
   /** True when this agent runs as a facet (sub-agent) inside a parent. */
   private _isFacet;
-  /**
-   * True only while the internal facet bootstrap RPC runs startup.
-   * Startup may happen while the parent is handling a WebSocket
-   * message, so protocol broadcasts must not touch any ambient
-   * parent-owned WebSocket handles during this window.
-   */
-  private _suppressProtocolBroadcasts;
   private _protocolBroadcastExcludeIds;
   private _cf_currentSubAgentBridge?;
   private _cf_virtualSubAgentConnections;
@@ -2387,6 +2423,8 @@ declare class Agent<
   private _insideOnStart;
   /** Tracks callbacks already warned about during this onStart() to avoid log spam. */
   private _warnedScheduleInOnStart;
+  /** Warn-once guard: `chatRecovery` reassigned during onStart() (too late for wake recovery). */
+  private _warnedChatRecoveryInOnStart;
   /**
    * Number of active keepAlive() callers. When > 0, `_scheduleNextAlarm()`
    * caps the next alarm at `keepAliveIntervalMs` so the DO stays alive.
@@ -3601,6 +3639,14 @@ declare class Agent<
   private _activeAgentToolRunCount;
   private _defaultAgentToolPreview;
   private _readAgentToolRun;
+  /**
+   * Reconstruct the typed interrupted cause (`reason` / `childStillRunning`,
+   * #1630 follow-up) from a stored row so a row→result/event rebuild — e.g. a
+   * reconnect replay — carries the same fields a live client saw. Only
+   * `interrupted` rows store a cause; everything else yields `{}` (the columns
+   * are cleared whenever a row settles to a hard terminal).
+   */
+  private _agentToolInterruptedExtrasFromRow;
   private _resultFromAgentToolRow;
   private _agentToolRunInfoFromRow;
   private _terminalResultFromInspection;
@@ -3640,6 +3686,27 @@ declare class Agent<
   private _asAgentToolChildAdapter;
   private _agentToolClassByName;
   private _replayAndInterruptAgentToolRun;
+  /**
+   * Human-readable prose for an `interrupted` seal. Kept in sync with
+   * {@link AgentToolInterruptedReason}; callers branch on the typed `reason`
+   * field, not this string.
+   */
+  private _interruptedMessageForReason;
+  /**
+   * Tear down a child agent-tool run the parent has genuinely given up on
+   * (#1630 follow-up). Teardown is scoped to `window-exceeded` ONLY — the hard
+   * ceiling, where the child has had its full recovery window and is therefore
+   * truly exhausted, so cancelling it reclaims its fiber / keep-alive. Every
+   * other give-up is deliberately left repairable: `no-progress` seals stay
+   * SOFT (`interrupted`, `childStillRunning: true`) so a re-issue can still
+   * re-attach and collect the child if it self-heals — tearing those down would
+   * defeat the repair-on-re-issue path and convert a retryable interrupt into a
+   * non-retryable `aborted`. Reasons where the child's state is unknown
+   * (`inspect-*`, `recovery-deadline`, `not-tailable`) are also left alone.
+   * Returns whether the child was torn down (so the caller reports
+   * `childStillRunning: false`).
+   */
+  private _teardownGivenUpAgentToolChild;
   /**
    * Re-attach to a still-running child agent-tool run and tail it to its real
    * terminal result, instead of abandoning it as `interrupted` (#1630). The
@@ -3648,15 +3715,26 @@ declare class Agent<
    * its live stream (forwarding chunks to the parent's connections) until it
    * reaches terminal, then inspect for the collected result.
    *
-   * Bounded by {@link DEFAULT_AGENT_TOOL_REATTACH_TIMEOUT_MS}: a child that keeps
-   * advancing toward terminal within the window is collected; a genuinely hung
-   * child returns `{ result: undefined }` once the budget elapses so the caller
-   * falls back to `interrupted` and recovery can never block forever.
+   * The wait is PROGRESS-KEYED, not a flat wall clock (which previously abandoned
+   * healthy, still-advancing children whose recovery simply outran a fixed
+   * budget). `noProgressTimeoutMs` bounds how long the parent waits with NO
+   * forward progress; it is reset on every forwarded chunk. As long as the child
+   * keeps streaming it is followed through to terminal. The loop also RE-ARMS
+   * across stream-closes (a child re-evicted mid-recovery, or a tail that ends
+   * before terminal) as long as the prior attempt made progress, so a child that
+   * dies and recovers again during deploy churn is still collected. A genuinely
+   * silent/hung child can never block recovery forever: it seals `interrupted`
+   * after one `noProgressTimeoutMs` window. `maxWindowMs` is an OPTIONAL hard
+   * wall-clock ceiling (default `Infinity` — uncapped, mirroring #1672's
+   * `maxRecoveryWork`); set it finite to also bound a child that keeps
+   * progressing, which seals `window-exceeded` and tears the child down.
    *
    * Returns the terminal `result` (and `completedAt`) when the child reaches a
-   * terminal status within the budget, plus the advanced broadcast `sequence`.
-   * Returns `{ result: undefined }` when there is no `tailAgentToolRun` adapter,
-   * the budget is exhausted, or the child is still non-terminal.
+   * terminal status, plus the advanced broadcast `sequence`. Returns
+   * `{ result: undefined }` when there is no `tailAgentToolRun` adapter, the
+   * child makes no progress within a full no-progress window, or the ceiling is
+   * reached while the child is still non-terminal — the caller then seals
+   * `interrupted`.
    */
   private _reattachAgentToolRunToTerminal;
   private _replayAgentToolRuns;
@@ -4368,6 +4446,30 @@ type AgentToolTerminalStatus = Extract<
   AgentToolRunStatus,
   "completed" | "error" | "aborted" | "interrupted"
 >;
+/**
+ * Machine-readable cause of an `interrupted` seal (#1630 follow-up). Lets a
+ * caller branch on WHY a run was abandoned without parsing the human-readable
+ * `error` prose, which is not a stable contract.
+ *
+ * - `no-progress` — the child went silent for a full no-progress window while
+ *   the parent was tailing it (genuinely stalled / hung).
+ * - `window-exceeded` — a finite `agentToolReattachMaxWindowMs` ceiling elapsed
+ *   while the child was still non-terminal. Only fires when an integrator opts
+ *   into a hard wall-clock cap (the default ceiling is `Infinity`).
+ * - `not-tailable` — the child runtime cannot live-tail, so the parent could
+ *   not re-attach to its stream to follow it to terminal.
+ * - `inspect-timeout` — inspecting the child timed out during parent recovery.
+ * - `inspect-failed` — inspecting the child failed during parent recovery.
+ * - `recovery-deadline` — the overall parent-recovery deadline elapsed before
+ *   this run could be reconciled.
+ */
+type AgentToolInterruptedReason =
+  | "no-progress"
+  | "window-exceeded"
+  | "not-tailable"
+  | "inspect-timeout"
+  | "inspect-failed"
+  | "recovery-deadline";
 /**
  * Structured failure envelope an `agentTool()` returns when a sub-agent run
  * does not complete. Instead of an opaque error string the parent model would
@@ -4386,7 +4488,15 @@ type AgentToolFailure = {
   ok: false;
   status: Exclude<AgentToolTerminalStatus, "completed">;
   error: string;
-  retryable: boolean;
+  retryable: boolean /** Present only when `status` is `interrupted` — machine-readable cause. */;
+  reason?: AgentToolInterruptedReason;
+  /**
+   * Present only when `status` is `interrupted`. `true` when the child facet was
+   * still non-terminal (running / advancing) at the moment the parent stopped
+   * waiting; `false` once the parent has torn the child down so it is no longer
+   * doing work. Lets a caller decide between re-dispatching vs. reconnecting.
+   */
+  childStillRunning?: boolean;
 };
 type AgentToolDisplayMetadata = {
   name?: string;
@@ -4406,7 +4516,13 @@ type AgentToolRunInfo = {
 type AgentToolLifecycleResult = {
   status: AgentToolTerminalStatus;
   summary?: string;
-  error?: string;
+  error?: string /** Present only when `status` is `interrupted` — machine-readable cause. */;
+  reason?: AgentToolInterruptedReason;
+  /**
+   * Present only when `status` is `interrupted`. Whether the child facet was
+   * still non-terminal when the parent stopped waiting (before any teardown).
+   */
+  childStillRunning?: boolean;
 };
 type RunAgentToolOptions<Input = unknown> = {
   input: Input;
@@ -4424,6 +4540,18 @@ type RunAgentToolResult<Output = unknown> = {
   output?: Output;
   summary?: string;
   error?: string;
+  /**
+   * Present only when `status` is `interrupted` — a machine-readable cause so
+   * callers don't pattern-match the `error` prose (#1630 follow-up).
+   */
+  reason?: AgentToolInterruptedReason;
+  /**
+   * Present only when `status` is `interrupted`. `true` when the child facet was
+   * still non-terminal (running / advancing) at the moment the parent stopped
+   * waiting and before any teardown; `false` once the parent has torn the child
+   * down so it is no longer doing work.
+   */
+  childStillRunning?: boolean;
 };
 type ChatCapableAgentClass<T extends Agent = Agent> = SubAgentClass<T>;
 type AgentToolRunInspection<Output = unknown> = {
@@ -4499,7 +4627,14 @@ type AgentToolEvent =
   | {
       kind: "interrupted";
       runId: string;
-      error: string;
+      error: string /** Machine-readable cause of the interrupt (#1630 follow-up). */;
+      reason?: AgentToolInterruptedReason;
+      /**
+       * Whether the child facet was still non-terminal when the parent stopped
+       * waiting (before any teardown). Lets a UI distinguish a still-running
+       * child from one the parent has torn down.
+       */
+      childStillRunning?: boolean;
     };
 type AgentToolEventMessage = {
   type: "agent-tool-event";
@@ -4519,6 +4654,13 @@ type AgentToolRunState = {
   parts: UIMessage["parts"];
   summary?: string;
   error?: string;
+  /**
+   * Present only when `status` is `interrupted` — machine-readable cause and
+   * whether the child is still running, mirrored from the wire event so a UI
+   * can render the reason without parsing `error` (#1630 follow-up).
+   */
+  reason?: AgentToolInterruptedReason;
+  childStillRunning?: boolean;
   subAgent: {
     agent: string;
     name: string;
@@ -4531,107 +4673,108 @@ type AgentToolEventState = {
 };
 //#endregion
 export {
-  SubAgentClass as $,
-  EmailRoutingOptions as A,
-  ClearableEventStore as At,
-  MCPServersState as B,
-  SSEEdgeClientTransport as Bt,
-  AgentOptions as C,
-  RPCServerTransport as Ct,
-  ConnectionContext$1 as D,
-  ElicitRequestSchema$1 as Dt,
-  Connection$1 as E,
-  ElicitRequest$1 as Et,
-  FiberRecoveryResult as F,
-  McpAuthContext as Ft,
-  Schedule as G,
-  SubAgentPathMatch as Gt,
-  RPCRequest as H,
-  McpClientOptions as Ht,
-  FiberStatus as I,
-  getMcpAuthContext as It,
-  SqlError as J,
-  routeSubAgentRequest as Jt,
-  ScheduleCriteria as K,
-  getSubAgentByName as Kt,
-  ListFibersOptions as L,
-  TransportState as Lt,
-  FiberContext as M,
-  CreateMcpHandlerOptions as Mt,
-  FiberInspection as N,
-  createMcpHandler as Nt,
-  DEFAULT_AGENT_STATIC_OPTIONS as O,
-  ElicitResult$1 as Ot,
-  FiberRecoveryContext as P,
-  experimental_createMcpHandler as Pt,
-  StreamingResponse as Q,
-  MCPServer as R,
-  WorkerTransport as Rt,
-  AgentNamespace as S,
-  RPCClientTransportOptions as St,
-  CallableMetadata as T,
-  RPC_DO_PREFIX as Tt,
-  RPCResponse as U,
-  TransportType as Ut,
-  QueueItem as V,
-  StreamableHTTPEdgeClientTransport as Vt,
-  RoutingRetryOptions as W,
-  SUB_PREFIX as Wt,
-  StartFiberResult as X,
-  StartFiberOptions as Y,
-  StateUpdateMessage as Z,
-  AddMcpServerOptions as _,
-  MCP_SERVER_ID_MAX_LENGTH as _t,
+  StreamingResponse as $,
+  DeleteFibersOptions as A,
+  McpAgent as At,
+  MCPServerMessage as B,
+  WorkerTransportOptions as Bt,
+  AgentNamespace as C,
+  RPCClientTransportOptions as Ct,
+  Connection$1 as D,
+  ElicitRequest$1 as Dt,
+  CallableMetadata as E,
+  RPC_DO_PREFIX as Et,
+  FiberRecoveryContext as F,
+  experimental_createMcpHandler as Ft,
+  RoutingRetryOptions as G,
+  SUB_PREFIX as Gt,
+  QueueItem as H,
+  StreamableHTTPEdgeClientTransport as Ht,
+  FiberRecoveryResult as I,
+  McpAuthContext as It,
+  SendEmailOptions as J,
+  parseSubAgentPath as Jt,
+  Schedule as K,
+  SubAgentPathMatch as Kt,
+  FiberStatus as L,
+  getMcpAuthContext as Lt,
+  EmailSendBinding as M,
+  DurableObjectEventStore as Mt,
+  FiberContext as N,
+  CreateMcpHandlerOptions as Nt,
+  ConnectionContext$1 as O,
+  ElicitRequestSchema$1 as Ot,
+  FiberInspection as P,
+  createMcpHandler as Pt,
+  StateUpdateMessage as Q,
+  ListFibersOptions as R,
+  TransportState as Rt,
+  AgentGetOptions as S,
+  RPCClientTransport as St,
+  AgentStaticOptions as T,
+  RPCServerTransportOptions as Tt,
+  RPCRequest as U,
+  McpClientOptions as Ut,
+  MCPServersState as V,
+  SSEEdgeClientTransport as Vt,
+  RPCResponse as W,
+  TransportType as Wt,
+  StartFiberOptions as X,
+  SqlError as Y,
+  routeSubAgentRequest as Yt,
+  StartFiberResult as Z,
+  RunAgentToolResult as _,
+  MCPServerOptions as _t,
   AgentToolEventState as a,
-  routeAgentEmail as at,
-  AgentContext as b,
-  normalizeServerId as bt,
-  AgentToolRunInfo as c,
-  MCPClientManager as ct,
-  AgentToolRunStatus as d,
-  MCPClientOAuthResult as dt,
-  SubAgentStub as et,
-  AgentToolStoredChunk as f,
-  MCPConnectionResult as ft,
-  RunAgentToolResult as g,
-  MCPServerOptions as gt,
-  RunAgentToolOptions as h,
-  MCPServerFilter as ht,
+  getCurrentAgent as at,
+  Agent as b,
+  getNamespacedData as bt,
+  AgentToolLifecycleResult as c,
+  unstable_callable as ct,
+  AgentToolRunState as d,
+  MCPClientOAuthCallbackConfig as dt,
+  SubAgentClass as et,
+  AgentToolRunStatus as f,
+  MCPClientOAuthResult as ft,
+  RunAgentToolOptions as g,
+  MCPServerFilter as gt,
+  ChatCapableAgentClass as h,
+  MCPOAuthCallbackResult as ht,
   AgentToolEventMessage as i,
-  getCurrentAgent as it,
-  EmailSendBinding as j,
-  DurableObjectEventStore as jt,
-  DeleteFibersOptions as k,
-  McpAgent as kt,
-  AgentToolRunInspection as l,
-  MCPClientManagerOptions as lt,
-  ChatCapableAgentClass as m,
-  MCPOAuthCallbackResult as mt,
+  getAgentByName as it,
+  EmailRoutingOptions as j,
+  ClearableEventStore as jt,
+  DEFAULT_AGENT_STATIC_OPTIONS as k,
+  ElicitResult$1 as kt,
+  AgentToolRunInfo as l,
+  MCPClientManager as lt,
+  AgentToolTerminalStatus as m,
+  MCPDiscoverResult as mt,
   AgentToolDisplayMetadata as n,
-  callable as nt,
+  WSMessage$1 as nt,
   AgentToolFailure as o,
-  routeAgentRequest as ot,
-  AgentToolTerminalStatus as p,
-  MCPDiscoverResult as pt,
-  SendEmailOptions as q,
-  parseSubAgentPath as qt,
+  routeAgentEmail as ot,
+  AgentToolStoredChunk as p,
+  MCPConnectionResult as pt,
+  ScheduleCriteria as q,
+  getSubAgentByName as qt,
   AgentToolEvent as r,
-  getAgentByName as rt,
-  AgentToolLifecycleResult as s,
-  unstable_callable as st,
+  callable as rt,
+  AgentToolInterruptedReason as s,
+  routeAgentRequest as st,
   AgentToolChildAdapter as t,
-  WSMessage$1 as tt,
-  AgentToolRunState as u,
-  MCPClientOAuthCallbackConfig as ut,
-  AddRpcMcpServerOptions as v,
-  RegisterServerOptions as vt,
-  AgentStaticOptions as w,
-  RPCServerTransportOptions as wt,
-  AgentGetOptions as x,
-  RPCClientTransport as xt,
-  Agent as y,
-  getNamespacedData as yt,
-  MCPServerMessage as z,
-  WorkerTransportOptions as zt
+  SubAgentStub as tt,
+  AgentToolRunInspection as u,
+  MCPClientManagerOptions as ut,
+  AddMcpServerOptions as v,
+  MCP_SERVER_ID_MAX_LENGTH as vt,
+  AgentOptions as w,
+  RPCServerTransport as wt,
+  AgentContext as x,
+  normalizeServerId as xt,
+  AddRpcMcpServerOptions as y,
+  RegisterServerOptions as yt,
+  MCPServer as z,
+  WorkerTransport as zt
 };
-//# sourceMappingURL=agent-tool-types-BAJWu8s4.d.ts.map
+//# sourceMappingURL=agent-tool-types-V25Z_HcX.d.ts.map

package/dist/agent-tool-types.d.ts

@@ -1,21 +1,22 @@
 import {
+  _ as RunAgentToolResult,
   a as AgentToolEventState,
-  c as AgentToolRunInfo,
-  d as AgentToolRunStatus,
-  f as AgentToolStoredChunk,
-  g as RunAgentToolResult,
-  h as RunAgentToolOptions,
+  c as AgentToolLifecycleResult,
+  d as AgentToolRunState,
+  f as AgentToolRunStatus,
+  g as RunAgentToolOptions,
+  h as ChatCapableAgentClass,
   i as AgentToolEventMessage,
-  l as AgentToolRunInspection,
-  m as ChatCapableAgentClass,
+  l as AgentToolRunInfo,
+  m as AgentToolTerminalStatus,
   n as AgentToolDisplayMetadata,
   o as AgentToolFailure,
-  p as AgentToolTerminalStatus,
+  p as AgentToolStoredChunk,
   r as AgentToolEvent,
-  s as AgentToolLifecycleResult,
+  s as AgentToolInterruptedReason,
   t as AgentToolChildAdapter,
-  u as AgentToolRunState
-} from "./agent-tool-types-BAJWu8s4.js";
+  u as AgentToolRunInspection
+} from "./agent-tool-types-V25Z_HcX.js";
 export {
   AgentToolChildAdapter,
   AgentToolDisplayMetadata,
@@ -23,6 +24,7 @@ export {
   AgentToolEventMessage,
   AgentToolEventState,
   AgentToolFailure,
+  AgentToolInterruptedReason,
   AgentToolLifecycleResult,
   AgentToolRunInfo,
   AgentToolRunInspection,

package/dist/{agent-tools-DYrkT-Kx.js → agent-tools-3zLG7MgA.js}

@@ -434,7 +434,9 @@ function applyToRun(prev, message) {
 			return {
 				...seeded,
 				status: "interrupted",
-				error: event.error
+				error: event.error,
+				reason: event.reason,
+				childStillRunning: event.childStillRunning
 			};
 	}
 }
@@ -462,4 +464,4 @@ function applyAgentToolEvent(state, message) {
 //#endregion
 export { normalizeToolInput as a, isReplayChunk as i, createAgentToolEventState as n, applyChunkToParts as r, applyAgentToolEvent as t };
 
-//# sourceMappingURL=agent-tools-DYrkT-Kx.js.map
+//# sourceMappingURL=agent-tools-3zLG7MgA.js.map