agents 0.23.0 → 0.25.0

package/dist/{agent-routing-DE5zmCQ8.d.ts → agent-routing-0DR0Tk2v.d.ts}

@@ -1,20 +1,20 @@
 import {
-  _ as LifecycleJobOutcome,
-  b as Connection,
-  g as LifecycleJobContext,
+  S as ConnectionContext,
+  T as WSMessage,
+  _ as LifecycleJobContext,
   o as MemoryLimitContext,
   s as LifecycleCapability,
   t as CapabilityRequestContext,
   u as LifecycleRouteAddress,
-  w as WSMessage,
-  x as ConnectionContext
-} from "./capability-runner-Be_-PLR1.js";
-import { t as RetryOptions } from "./retries-D9Ds-1lz.js";
+  v as LifecycleJobOutcome,
+  x as Connection
+} from "./capability-runner-DBAnGr6L.js";
+import { t as RetryOptions } from "./retries-CV6AkXmQ.js";
 import {
-  c as LifecycleRouteEnvelope,
-  n as CurrentAgentContext,
-  o as Lifecycle
-} from "./current-agent-Da_C9a3b.js";
+  r as LifecycleRouteEnvelope,
+  t as Lifecycle
+} from "./durable-object-lifecycle-HhgOMWq9.js";
+import { n as CurrentAgentContext } from "./current-agent-vAk_5JMt.js";
 import { t as AgentEmail } from "./internal_context-BlxFEWfn.js";
 import { r as EmailResolver, s as SendEmailOptions } from "./email-7TatiTnl.js";
 import {
@@ -41,8 +41,10 @@ import {
   i as Schedule,
   o as ScheduleOptions,
   t as Scheduler
-} from "./scheduler-Dwh85ZGl.js";
-import { l as TaskHandlers, r as Tasks } from "./tasks-BRJ5zgya.js";
+} from "./scheduler-RdACNXDP.js";
+import { i as QueueItem } from "./types-BA4anrjI.js";
+import { l as TaskHandlers, r as Tasks } from "./tasks-9YxYtByh.js";
+import { t as State } from "./index-BreL0YrQ.js";
 import { t as CallableMetadata } from "./callable-decorator-DP__HhBA.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 import {
@@ -405,6 +407,11 @@ type RootFacetRpcSurface = {
     connectionId: string,
     state: unknown
   ): Promise<unknown>;
+  _cf_closeSubAgentConnectionsForPrefix(
+    prefix: ReadonlyArray<AgentPathStep>,
+    code: number,
+    reason: string
+  ): Promise<void>;
 };
 //#endregion
 //#region src/dynamic-agents/bridges.d.ts
@@ -547,9 +554,6 @@ interface DynamicAgentHostPort {
   ): boolean;
   hasSubAgent(className: string, name: string): boolean;
   _cf_resolveSubAgent(className: string, name: string): Promise<unknown>;
-  _cf_cleanupFacetPrefix(
-    ownerPath: ReadonlyArray<AgentPathStep>
-  ): Promise<void>;
   _cf_routeLifecycle(
     target: LifecycleRouteAddress | undefined,
     envelope: LifecycleRouteEnvelope
@@ -561,6 +565,9 @@ interface DynamicAgentHostPort {
   readonly tasks: {
     __DO_NOT_USE_WILL_BREAK__cleanupRoutePrefix(prefix: string): Promise<void>;
   };
+  readonly _queue: {
+    __DO_NOT_USE_WILL_BREAK__cleanupRoutePrefix(prefix: string): Promise<void>;
+  };
   /** Local (non-facet-index) durable fiber recovery pass. */
   _checkRunFibers(): Promise<void>;
   /** Overridable RPC entry points — call via the host so subclass overrides intercept. */
@@ -586,20 +593,12 @@ interface DynamicAgentHostPort {
       tag?: string
     ): Iterable<Connection<TState>>;
   };
-  _ensureConnectionWrapped(connection: Connection): void;
   _unsafe_getConnectionFlag(connection: Connection, key: string): unknown;
   _unsafe_setConnectionFlag(
     connection: Connection,
     key: string,
     value: unknown
   ): void;
-  readonly _rawStateAccessors: {
-    get(connection: Connection):
-      | {
-          getRaw(): unknown;
-        }
-      | undefined;
-  };
   shouldConnectionBeReadonly(
     connection: Connection,
     context: {
@@ -613,7 +612,6 @@ interface DynamicAgentHostPort {
       request: Request;
     }
   ): boolean;
-  _setConnectionNoProtocol(connection: Connection): void;
   getConnectionTags(
     connection: Connection,
     context: {
@@ -692,8 +690,9 @@ declare class DynamicAgentsInternal extends LifecycleCapability {
   rootResolvesToSelf(): boolean;
   /**
    * Clean root-owned bookkeeping for a sub-tree of facets: bulk-cancel
-   * schedules and routed Task wake mirrors under the owner-path prefix,
-   * and delete root-side facet fiber recovery leases for the same sub-tree.
+   * schedules, queue items, and routed Task wake mirrors under the
+   * owner-path prefix, and delete root-side facet fiber recovery leases for
+   * the same sub-tree.
    */
   cleanupPrefix(ownerPath: ReadonlyArray<AgentPathStep>): Promise<void>;
   /**
@@ -764,6 +763,12 @@ declare class DynamicAgentsInternal extends LifecycleCapability {
    * storage. Transitively deletes the child's own children.
    */
   delete(className: string, name: string): Promise<void>;
+  /** Root-side: close sockets whose `/sub/...` target is under `prefix`. */
+  closeConnectionsForPrefix(
+    prefix: ReadonlyArray<AgentPathStep>,
+    code: number,
+    reason: string
+  ): void;
   /** Drop all facet-side virtual connections (test/rehydration hook). */
   clearVirtualConnections(): void;
   /** Facet-side lookup of a virtual connection by id. */
@@ -3688,6 +3693,20 @@ declare const AGENT_TOOL_PROGRESS_PART = "data-agent-progress";
  * re-resolves milestone waiters. See `design/rfc-detached-agent-tools.md`.
  */
 declare const AGENT_TOOL_MILESTONE_PART = "data-agent-milestone";
+/**
+ * Whether a chunk body is a progress or milestone frame. These are broadcast
+ * but never written to the child's chunk store, so they have no stored-chunk
+ * position and must not take part in stored-position numbering or dedupe.
+ */
+declare function isAgentToolLifecycleChunk(body: string): boolean;
+/**
+ * Whether a forwarded chunk has no stored-chunk position: a progress or
+ * milestone frame, or a chunk too large to store. Such chunks carry the next
+ * stored position without consuming it.
+ */
+declare function isPositionlessAgentToolChunk(
+  chunk: AgentToolStoredChunk
+): boolean;
 /**
  * Ephemeral progress signal a running sub-agent emits with `reportProgress`. The
  * well-known fields drive generic UI (a bar + status line) with no per-app
@@ -3854,7 +3873,17 @@ type RunAgentToolOptions<Input = unknown, Self = Record<string, unknown>> = {
    * must outlive the spawning turn; cancel it explicitly via `cancelAgentTool`.
    */
   detached?: boolean | DetachedAgentToolConfig<Self>;
+  /**
+   * Which child events reach the parent's clients. `"full"` (default) forwards
+   * every streamed chunk. `"terminal"` forwards only lifecycle events: started,
+   * progress and milestone frames, and the terminal event. The child still
+   * persists its whole stream, and the parent still tails it for completion,
+   * cancellation, progress and recovery. Use it for a headless parent with no
+   * client watching the child. Not supported with `detached`.
+   */
+  eventDelivery?: AgentToolEventDelivery;
 };
+type AgentToolEventDelivery = "full" | "terminal";
 /**
  * Result of dispatching a detached run. Returns immediately after dispatch
  * rather than after completion.
@@ -3918,6 +3947,12 @@ type AgentToolRunInspection<Output = unknown> = {
 type AgentToolStoredChunk = {
   sequence: number;
   body: string;
+  /**
+   * Set when the child broadcast this chunk but could not store it (it exceeds
+   * the stored-chunk size limit). The chunk is never replayed, so it carries
+   * the next stored position without consuming it and dedupes on this id.
+   */
+  unstoredId?: string;
 };
 type AgentToolChildAdapter<Input = unknown, Output = unknown> = {
   startAgentToolRun(
@@ -3925,11 +3960,23 @@ type AgentToolChildAdapter<Input = unknown, Output = unknown> = {
     options: {
       runId: string;
       signal?: AbortSignal;
+      /**
+       * `"terminal"` means no client is watching this run's chunks, so the
+       * child can skip broadcasting them.
+       */
+      eventDelivery?: AgentToolEventDelivery;
     }
   ): Promise<AgentToolRunInspection<Output>>;
   cancelAgentToolRun(runId: string, reason?: unknown): Promise<void>;
   inspectAgentToolRun(
-    runId: string
+    runId: string,
+    options?: {
+      /**
+       * `false` reports the stored row as-is instead of first reconciling
+       * (and possibly sealing) a stale run. Defaults to `true`.
+       */
+      reconcile?: boolean;
+    }
   ): Promise<AgentToolRunInspection<Output> | null>;
   getAgentToolChunks(
     runId: string,
@@ -3957,7 +4004,8 @@ type AgentToolEvent =
   | {
       kind: "chunk";
       runId: string;
-      body: string;
+      body: string /** See {@link AgentToolStoredChunk.unstoredId}. */;
+      unstoredId?: string;
     }
   | {
       kind: "finished";
@@ -4083,13 +4131,6 @@ type RPCResponse = {
       error: string;
     }
 );
-type QueueItem<T = string> = {
-  id: string;
-  payload: T;
-  callback: keyof Agent<Cloudflare.Env>;
-  created_at: number;
-  retry?: RetryOptions;
-};
 type DetachedReconcilePayload = {
   cadenceIndex?: number;
 };
@@ -4327,9 +4368,9 @@ declare const DEFAULT_AGENT_STATIC_OPTIONS: {
   /**
    * 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
+   * stream-closes. Defaults to `Infinity` (no implicit cap, #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`).
@@ -4399,9 +4440,9 @@ interface AgentStaticOptions {
   /**
    * 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
+   * re-arms across stream-closes. Default: `Infinity` (no implicit cap,
+   * #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.
@@ -4466,12 +4507,12 @@ type WorkflowName<E> = WorkflowBinding<E> | (string & {});
 /**
  * Base class for creating Agent implementations
  * @template Env Environment type containing bindings
- * @template State State type to store within the Agent
+ * @template TState State type to store within the Agent
  */
 declare class Agent<
   Env extends Cloudflare.Env = Cloudflare.Env,
-  State = unknown,
-  Props extends Record<string, unknown> = Record<string, unknown>
+  TState = unknown,
+  Props extends object = object
 > extends DurableObject<Env> {
   /**
    * Runtime lifecycle and reusable durable capabilities for this Agent.
@@ -4489,6 +4530,16 @@ declare class Agent<
    * from paths that do not pass through the capability (facet bridging,
    * direct calls).
    */
+  /**
+   * Durable state: the `cf_agents_state` row, lazy load, validated persistence.
+   * `initialState` stays on Agent (a subclass field, initialized after this
+   * one) and is seeded by the `state` getter. Typed `<unknown>` rather than
+   * `<TState>` because `TState` appears in both `get()` and `set()` positions,
+   * which would make `Agent`'s own `TState` parameter invariant and break
+   * `Subclass -> Agent<Env, unknown>` assignability; the typed boundary is
+   * re-established in `state` / `setState`.
+   */
+  readonly _state: State<unknown>;
   private readonly _webSockets;
   /** Run user initialization after lifecycle components have started. */
   onStart(_props?: Props): void | Promise<void>;
@@ -4515,7 +4566,6 @@ declare class Agent<
   ): string[] | Promise<string[]>;
   /** @internal Ensure lifecycle startup before a native RPC implementation. */
   __unsafe_ensureInitialized(props?: Props): Promise<void>;
-  private _state;
   private _disposables;
   private _destroyed;
   /**
@@ -4523,7 +4573,6 @@ declare class Agent<
    * Used by internal flag methods (readonly, no-protocol) to read/write
    * _cf_-prefixed keys without going through the user-facing state/setState.
    */
-  private _rawStateAccessors;
   /**
    * Cached persistence-hook dispatch mode, computed once in the constructor.
    * - "new"  → call onStateChanged
@@ -4616,6 +4665,12 @@ declare class Agent<
    * cancelSchedule() methods are the stable surface.
    */
   readonly scheduler: Scheduler;
+  /**
+   * Durable background-work capability installed into this Agent's
+   * Lifecycle. Agent's queue()/dequeue()/dequeueAll()/dequeueAllByCallback()/
+   * getQueue()/getQueues() methods are its surface.
+   */
+  private readonly _queue;
   /**
    * Durable replayable execution capability installed into this Agent's
    * Lifecycle. Declare definitions on the overridable
@@ -4647,7 +4702,7 @@ declare class Agent<
    * Initial state for the Agent
    * Override to provide default state values
    */
-  initialState: State;
+  initialState: TState;
   /**
    * Stable key for Workers AI session affinity (prefix-cache optimization).
    *
@@ -4667,9 +4722,12 @@ declare class Agent<
    */
   get sessionAffinity(): string;
   /**
-   * Current state of the Agent
+   * Current state of the Agent.
+   *
+   * Delegates to the State capability, which owns lazy load and the
+   * in-memory cache; Agent seeds `initialState` on first access.
    */
-  get state(): State;
+  get state(): TState;
   /**
    * Agent configuration options.
    * Override in subclasses - only specify what you want to change.
@@ -4722,6 +4780,14 @@ declare class Agent<
    * local dev and the constructor only runs once per DO instance).
    */
   protected _ensureSchema(): void;
+  /**
+   * Read the Agent's schema version from its KV key. A DO created before the
+   * State capability owned `cf_agents_state` has the version as a row in that
+   * table instead: read it once, move it to the key, and delete the row so the
+   * table is left with a single owner. Synchronous (`storage.kv`) because the
+   * constructor gates DDL on it.
+   */
+  private _readSchemaVersion;
   constructor(ctx: AgentContext, env: Env);
   private _restoreAgentFacetContext;
   /**
@@ -4736,26 +4802,20 @@ declare class Agent<
    * @param excludeIds Additional connection IDs to exclude (e.g. the source)
    */
   private _broadcastProtocol;
-  private _setStateInternal;
+  /**
+   * React to a persisted state change from the State capability.
+   *
+   * Reproduces the pre-migration steps 3-4: broadcast the new state to
+   * protocol-enabled connections (excluding the originating connection) and
+   * run the notification hook off the invocation tail.
+   */
+  private _handleStateChanged;
   /**
    * Update the Agent's state
    * @param state New state to set
    * @throws Error if called from a readonly connection context
    */
-  setState(state: State): void;
-  /**
-   * Wraps connection.state and connection.setState so that internal
-   * _cf_-prefixed flags (readonly, no-protocol) are hidden from user code
-   * and cannot be accidentally overwritten.
-   *
-   * Idempotent — safe to call multiple times on the same connection.
-   * After hibernation, the _rawStateAccessors WeakMap is empty but the
-   * connection's state getter still reads from the persisted WebSocket
-   * attachment. Calling this method re-captures the raw getter so that
-   * predicate methods (isConnectionReadonly, isConnectionProtocolEnabled)
-   * work correctly post-hibernation.
-   */
-  private _ensureConnectionWrapped;
+  setState(state: TState): void;
   /**
    * Mark a connection as readonly or readwrite
    * @param connection The connection to mark
@@ -4789,8 +4849,8 @@ declare class Agent<
    *
    * Write an internal `_cf_`-prefixed flag to the raw connection state,
    * bypassing the user-facing state wrapper. The key must be registered
-   * in `CF_INTERNAL_KEYS` so it is preserved across user `setState` calls
-   * and hidden from `connection.state`.
+   * with `registerInternalConnectionKeys` so it is preserved across user
+   * `setState` calls and hidden from `connection.state`.
    *
    * @internal
    */
@@ -4840,18 +4900,13 @@ declare class Agent<
    * @returns True if the connection receives protocol messages
    */
   isConnectionProtocolEnabled(connection: Connection): boolean;
-  /**
-   * Mark a connection as having protocol messages disabled.
-   * Called internally when shouldSendProtocolMessages returns false.
-   */
-  private _setConnectionNoProtocol;
   /**
    * Called before the Agent's state is persisted and broadcast.
    * Override to validate or reject an update by throwing an error.
    *
    * IMPORTANT: This hook must be synchronous.
    */
-  validateStateChange(_nextState: State, _source: Connection | "server"): void;
+  validateStateChange(_nextState: TState, _source: Connection | "server"): void;
   /**
    * Called after the Agent's state has been persisted and broadcast to all clients.
    * This is a notification hook — errors here are routed to onError and do not
@@ -4861,7 +4916,7 @@ declare class Agent<
    * @param source Source of the state update ("server" or a client connection)
    */
   onStateChanged(
-    _state: State | undefined,
+    _state: TState | undefined,
     _source: Connection | "server"
   ): void;
   /**
@@ -4876,7 +4931,7 @@ declare class Agent<
    * @param source Source of the state update ("server" or a client connection)
    */
   onStateUpdate(
-    _state: State | undefined,
+    _state: TState | undefined,
     _source: Connection | "server"
   ): void;
   /**
@@ -4974,11 +5029,16 @@ declare class Agent<
     }
   ): Promise<T>;
   /**
-   * Queue a task to be executed in the future
+   * Queue a task to run in the background.
+   *
+   * The item is durable: it runs from the Lifecycle alarm event loop after
+   * this call returns, in push order, one at a time, with retries per
+   * `options.retry`, and survives the Durable Object leaving memory.
    * @param callback Name of the method to call
    * @param payload Payload to pass to the callback
    * @param options Options for the queued task
    * @param options.retry Retry options for the callback execution
+   * @param options.id Stable id; a push with an existing id replaces that item
    * @returns The ID of the queued task
    */
   queue<T = unknown>(
@@ -4986,37 +5046,36 @@ declare class Agent<
     payload: T,
     options?: {
       retry?: RetryOptions;
+      id?: string;
     }
   ): Promise<string>;
-  private _flushingQueue;
-  private _flushQueue;
   /**
    * Dequeue a task by ID
    * @param id ID of the task to dequeue
    */
-  dequeue(id: string): void;
+  dequeue(id: string): Promise<boolean>;
   /**
    * Dequeue all tasks
    */
-  dequeueAll(): void;
+  dequeueAll(): Promise<number>;
   /**
    * Dequeue all tasks by callback
    * @param callback Name of the callback to dequeue
    */
-  dequeueAllByCallback(callback: string): void;
+  dequeueAllByCallback(callback: string): Promise<number>;
   /**
    * Get a queued task by ID
    * @param id ID of the task to get
    * @returns The task or undefined if not found
    */
-  getQueue(id: string): QueueItem<string> | undefined;
+  getQueue<T = unknown>(id: string): Promise<QueueItem<T> | undefined>;
   /**
-   * Get all queues by key and value
+   * Get all queued tasks whose payload has `key` equal to `value`
    * @param key Key to filter by
    * @param value Value to filter by
    * @returns Array of matching QueueItem objects
    */
-  getQueues(key: string, value: string): QueueItem<string>[];
+  getQueues<T = unknown>(key: string, value: string): Promise<QueueItem<T>[]>;
   private _lifecycleRouteAddress;
   private _routeLifecycleToRoot;
   private _routeLifecycleToTarget;
@@ -5493,6 +5552,11 @@ declare class Agent<
     code?: number,
     reason?: string
   ): Promise<void>;
+  _cf_closeSubAgentConnectionsForPrefix(
+    prefix: ReadonlyArray<AgentPathStep>,
+    code: number,
+    reason: string
+  ): Promise<void>;
   _cf_setSubAgentConnectionState(
     connectionId: string,
     state: unknown
@@ -5916,8 +5980,23 @@ declare class Agent<
   private _stringifyAgentToolOutput;
   private _broadcastAgentToolEvent;
   private _broadcastAgentToolChunks;
+  private _isTerminalOnlyAgentToolRun;
   private _broadcastAgentToolStoredChunks;
+  /**
+   * One budget shared by every step of a bounded recovery read, so a run's
+   * total time stays within `timeoutMs`. Returns the remaining milliseconds,
+   * never below 1 because a non-positive timeout means "unbounded".
+   */
+  private _agentToolRecoveryDeadline;
   private _broadcastAgentToolStoredChunksFromAdapter;
+  /**
+   * Milestones are persisted on the child run rather than in its chunk log, so
+   * replay re-emits them from the child's inspection. The client dedupes them
+   * on the milestone's own sequence, so a milestone already seen live is a no-op.
+   * They carry the next stored-chunk sequence without consuming it, matching
+   * the live path.
+   */
+  private _broadcastAgentToolMilestones;
   private _forwardAgentToolStream;
   /**
    * Hook invoked by `_forwardAgentToolStream` after a child produces output that
@@ -6011,9 +6090,9 @@ declare class Agent<
    * 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.
+   * wall-clock ceiling (default `Infinity` — uncapped, #1672); 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, plus the advanced broadcast `sequence`. Returns
@@ -6029,6 +6108,8 @@ declare class Agent<
   private _scheduleAgentToolRunRecovery;
   private _agentToolRunRecoveryRunIds;
   private _getAgentToolChunksForRecovery;
+  /** Resolve to `undefined` when `promise` rejects or outlasts `timeoutMs`. */
+  private _settleWithinRecoveryTimeout;
   /**
    * Shared facet resolution — takes a CamelCase class name string
    * (matching `ctx.exports`) rather than a class reference. Both
@@ -6731,7 +6812,7 @@ interface AgentRouteMatch<Env = Cloudflare.Env> {
 }
 interface AgentRouteOptions<
   Env = Cloudflare.Env,
-  Props extends Record<string, unknown> = Record<string, unknown>
+  Props extends object = object
 > {
   /** URL prefix before the binding and instance name. Default: `agents`. */
   prefix?: string;
@@ -6774,10 +6855,7 @@ interface AgentRouteOptions<
 /** Configuration options for {@link routeAgentRequest}. */
 type AgentOptions<Env> = AgentRouteOptions<Env>;
 /** Options for resolving and starting a named Agent. */
-type AgentGetOptions<
-  Env,
-  Props extends Record<string, unknown> = Record<string, unknown>
-> = Pick<
+type AgentGetOptions<Env, Props extends object = object> = Pick<
   AgentRouteOptions<Env, Props>,
   "jurisdiction" | "locationHint" | "props" | "routingRetry"
 >;
@@ -6807,7 +6885,7 @@ declare function routeAgentRequest<Env>(
 declare function getAgentByName<
   Env extends Cloudflare.Env = Cloudflare.Env,
   T extends Agent<Env> = Agent<Env>,
-  Props extends Record<string, unknown> = Record<string, unknown>
+  Props extends object = object
 >(
   namespace: DurableObjectNamespace<T>,
   name: string,
@@ -6816,143 +6894,145 @@ declare function getAgentByName<
 //#endregion
 export {
   ChatCapableAgentClass as $,
-  RPC_DO_PREFIX as $t,
-  StreamingResponse as A,
-  routeSubAgentRequest as An,
-  MCPAITool as At,
+  RPCServerTransport as $t,
+  getCurrentAgent as A,
+  getSubAgentByName as An,
+  ElicitRequest$1 as At,
   AgentToolFailure as B,
-  MCPOAuthCallbackResult as Bt,
+  MCPConnectionResult as Bt,
   MCPServersState as C,
-  SubAgentPathMatch as Cn,
-  WorkflowProgressCallback as Ct,
-  StartFiberOptions as D,
-  buildSubAgentPathUnchecked as Dn,
-  WorkflowTrackingRow as Dt,
-  RPCResponse as E,
-  buildSubAgentPath as En,
-  WorkflowStatus as Et,
-  AgentToolChildAdapter as F,
-  MCPClientManagerOptions as Ft,
+  BuildAgentPathOptions as Cn,
+  WorkflowInfo as Ct,
+  StartFiberResult as D,
+  buildAgentUrl as Dn,
+  WorkflowRejectedError as Dt,
+  StartFiberOptions as E,
+  buildAgentPath as En,
+  WorkflowQueryCriteria as Et,
+  AgentToolDisplayMetadata as F,
+  MCPClientElicitationHandlers as Ft,
   AgentToolProgressSnapshot as G,
-  getNamespacedData as Gt,
+  MCP_SERVER_ID_MAX_LENGTH as Gt,
   AgentToolLifecycleResult as H,
-  MCPServerOptions as Ht,
-  AgentToolDisplayMetadata as I,
-  MCPClientOAuthCallbackConfig as It,
+  MCPOAuthCallbackResult as Ht,
+  AgentToolEvent as I,
+  MCPClientManager as It,
   AgentToolRunPart as J,
-  MCPElicitationHandlers as Jt,
+  normalizeServerId as Jt,
   AgentToolRunInfo as K,
-  normalizeServerId as Kt,
-  AgentToolEvent as L,
-  MCPClientOAuthResult as Lt,
-  routeAgentEmail as M,
-  MCPClientElicitationHandler as Mt,
-  AGENT_TOOL_MILESTONE_PART as N,
-  MCPClientElicitationHandlers as Nt,
-  StartFiberResult as O,
-  getSubAgentByName as On,
-  ElicitRequest$1 as Ot,
-  AGENT_TOOL_PROGRESS_PART as P,
-  MCPClientManager as Pt,
+  RegisterServerOptions as Kt,
+  AgentToolEventDelivery as L,
+  MCPClientManagerOptions as Lt,
+  AGENT_TOOL_MILESTONE_PART as M,
+  routeSubAgentRequest as Mn,
+  MCPAITool as Mt,
+  AGENT_TOOL_PROGRESS_PART as N,
+  withInvocationScope as Nn,
+  MCPAIToolSet as Nt,
+  StateUpdateMessage as O,
+  buildSubAgentPath as On,
+  WorkflowStatus as Ot,
+  AgentToolChildAdapter as P,
+  MCPClientElicitationHandler as Pt,
   AgentToolTerminalStatus as Q,
-  RPCServerTransportOptions as Qt,
+  RPCClientTransportOptions as Qt,
   AgentToolEventMessage as R,
-  MCPConnectionResult as Rt,
+  MCPClientOAuthCallbackConfig as Rt,
   MCPServerMessage as S,
-  SUB_PREFIX as Sn,
-  WorkflowPage as St,
-  RPCRequest as T,
-  buildAgentUrl as Tn,
-  WorkflowRejectedError as Tt,
+  AgentPathStep as Sn,
+  WorkflowEventPayload as St,
+  RPCResponse as T,
+  SubAgentPathMatch as Tn,
+  WorkflowProgressCallback as Tt,
   AgentToolMilestone as U,
-  MCP_SERVER_ID_MAX_LENGTH as Ut,
+  MCPServerFilter as Ut,
   AgentToolInterruptedReason as V,
-  MCPServerFilter as Vt,
+  MCPDiscoverResult as Vt,
   AgentToolProgress as W,
-  RegisterServerOptions as Wt,
+  MCPServerOptions as Wt,
   AgentToolRunStatus as X,
-  RPCClientTransportOptions as Xt,
+  MCPElicitationHandlers as Xt,
   AgentToolRunState as Y,
-  RPCClientTransport as Yt,
+  MCPElicitationHandler as Yt,
   AgentToolStoredChunk as Z,
-  RPCServerTransport as Zt,
+  RPCClientTransport as Zt,
   FiberRecoveryContext as _,
-  StreamableHTTPEdgeClientTransport as _n,
-  WorkflowCompleteCallback as _t,
+  WorkerTransportOptions as _n,
+  WorkflowCallbackBase as _t,
   routeAgentRequest as a,
-  DurableObjectEventStore as an,
-  AgentWorkflowInternalParams as at,
+  McpAgent as an,
+  isPositionlessAgentToolChunk as at,
   ListFibersOptions as b,
-  AgentPathStep as bn,
-  WorkflowEventPayload as bt,
+  DynamicAgentClass as bn,
+  WorkflowErrorCallback as bt,
   Agent as c,
-  CreateLegacyMcpHandlerOptions as cn,
-  AgentWorkflowPathStep as ct,
+  createMcpHandler$1 as cn,
+  AgentWorkflowOrigin as ct,
   AgentStaticOptions as d,
-  createLegacyMcpHandler as dn,
-  DefaultProgress as dt,
-  ElicitRequest$2 as en,
+  CreateMcpHandlerOptions$1 as dn,
+  AgentWorkflowStep as dt,
+  RPCServerTransportOptions as en,
   DetachedAgentToolConfig as et,
   DEFAULT_AGENT_STATIC_OPTIONS as f,
-  MCPStorageApi as fn,
-  RunWorkflowOptions as ft,
+  LegacyMcpHandler as fn,
+  ApprovalEventPayload as ft,
   FiberInspection as g,
-  SSEEdgeClientTransport as gn,
-  WorkflowCallbackType as gt,
+  WorkerTransport as gn,
+  WorkflowCallback as gt,
   FiberContext as h,
-  WorkerTransportOptions as hn,
-  WorkflowCallbackBase as ht,
+  TransportState as hn,
+  WaitForApprovalOptions as ht,
   getAgentByName as i,
-  ClearableEventStore as in,
-  AgentWorkflowEvent as it,
-  getCurrentAgent as j,
-  withInvocationScope as jn,
-  MCPAIToolSet as jt,
-  StateUpdateMessage as k,
-  parseSubAgentPath as kn,
-  ElicitResult$2 as kt,
+  ElicitResult$3 as in,
+  isAgentToolLifecycleChunk as it,
+  routeAgentEmail as j,
+  parseSubAgentPath as jn,
+  ElicitResult$2 as jt,
+  StreamingResponse as k,
+  buildSubAgentPathUnchecked as kn,
+  WorkflowTrackingRow as kt,
   AgentContext as l,
-  CreateMcpHandlerOptions$1 as ln,
-  AgentWorkflowStep as lt,
+  experimental_createMcpHandler as ln,
+  AgentWorkflowParams as lt,
   EmailRoutingOptions as m,
-  WorkerTransport as mn,
-  WorkflowCallback as mt,
+  MCPStorageApi as mn,
+  RunWorkflowOptions as mt,
   AgentOptions as n,
-  ElicitResult$3 as nn,
+  ElicitRequest$2 as nn,
   RunAgentToolOptions as nt,
   AddMcpServerOptions as o,
-  createMcpHandler$1 as on,
-  AgentWorkflowOrigin as ot,
+  ClearableEventStore as on,
+  AgentWorkflowEvent as ot,
   DeleteFibersOptions as p,
-  TransportState as pn,
-  WaitForApprovalOptions as pt,
+  createLegacyMcpHandler as pn,
+  DefaultProgress as pt,
   AgentToolRunInspection as q,
-  MCPElicitationHandler as qt,
+  getNamespacedData as qt,
   RoutingRetryOptions as r,
-  McpAgent as rn,
+  ElicitRequestSchema as rn,
   RunAgentToolResult as rt,
   AddRpcMcpServerOptions as s,
-  experimental_createMcpHandler as sn,
-  AgentWorkflowParams as st,
+  DurableObjectEventStore as sn,
+  AgentWorkflowInternalParams as st,
   AgentGetOptions as t,
-  ElicitRequestSchema as tn,
+  RPC_DO_PREFIX as tn,
   DetachedRunAgentToolResult as tt,
   AgentNamespace as u,
-  LegacyMcpHandler as un,
-  ApprovalEventPayload as ut,
+  CreateLegacyMcpHandlerOptions as un,
+  AgentWorkflowPathStep as ut,
   FiberRecoveryResult as v,
-  DynamicAgentClass as vn,
-  WorkflowErrorCallback as vt,
-  QueueItem as w,
-  buildAgentPath as wn,
-  WorkflowQueryCriteria as wt,
+  SSEEdgeClientTransport as vn,
+  WorkflowCallbackType as vt,
+  RPCRequest as w,
+  SUB_PREFIX as wn,
+  WorkflowPage as wt,
   MCPServer as x,
-  BuildAgentPathOptions as xn,
-  WorkflowInfo as xt,
+  DynamicAgentStub as xn,
+  WorkflowEventCallback as xt,
   FiberStatus as y,
-  DynamicAgentStub as yn,
-  WorkflowEventCallback as yt,
+  StreamableHTTPEdgeClientTransport as yn,
+  WorkflowCompleteCallback as yt,
   AgentToolEventState as z,
-  MCPDiscoverResult as zt
+  MCPClientOAuthResult as zt
 };
-//# sourceMappingURL=agent-routing-DE5zmCQ8.d.ts.map
+//# sourceMappingURL=agent-routing-0DR0Tk2v.d.ts.map