agents 0.20.0 → 0.21.0

package/dist/{agent-tool-types-Btk9ETS-.d.ts → agent-tool-types-CzGGB-20.d.ts}

@@ -18,17 +18,14 @@ import {
   u as McpClientOptions
 } from "./handler-stateless-C_bo-Ytq.js";
 import { n as LegacyCallToolResultSchema } from "./client-invoker-BNSZxAkv.js";
-import {
-  _ as WorkflowEventPayload,
-  d as WorkflowCallback,
-  l as RunWorkflowOptions,
-  v as WorkflowInfo,
-  x as WorkflowQueryCriteria,
-  y as WorkflowPage
-} from "./workflow-types-Baz_PO5v.js";
 import { t as MessageType } from "./types-6Zo2zfoO.js";
 import { r as EmailResolver } from "./email-CL27preh.js";
-import { RpcTarget } from "cloudflare:workers";
+import {
+  RpcTarget,
+  WorkflowEvent,
+  WorkflowSleepDuration,
+  WorkflowStep
+} from "cloudflare:workers";
 import {
   Connection,
   Connection as Connection$1,
@@ -100,6 +97,33 @@ import {
 } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { AuthInfo } from "@modelcontextprotocol/sdk/server/auth/types.js";
 
+//#region src/observability/tracing/tracer.d.ts
+type InvocationScopeOptions = {
+  /**
+   * Open a scope even inside a live one, for work deliberately detached from
+   * the handler that started it — `ctx.waitUntil` bodies, queue drains — which
+   * runs on past that handler and must not be cut off with it.
+   */
+  readonly detached?: boolean;
+};
+/**
+ * Runs `body` as one traced invocation.
+ *
+ * Work that escapes its native invocation cannot be traced from the context it
+ * started in: the still-open span is force-closed against the invocation that
+ * owned that context, which reports a negative duration or `span_not_ended`.
+ * Spans opened with {@link SpanLifetime.boundToInvocation} inside this scope
+ * are therefore closed before `body` settles — but not one moment earlier, so
+ * everything that completes during the invocation (the normal case: a chat
+ * turn is awaited by the handler that received it) still records its finish
+ * attributes. A span truncated this way is marked
+ * `cloudflare.agents.span.truncated` rather than passing as complete.
+ */
+declare function withInvocationScope<T>(
+  body: () => T,
+  options?: InvocationScopeOptions
+): T;
+//#endregion
 //#region src/sub-routing.d.ts
 /**
  * URL segment marking a parent↔child boundary.
@@ -109,6 +133,47 @@ import { AuthInfo } from "@modelcontextprotocol/sdk/server/auth/types.js";
  * token everywhere (parent fetch, client, helpers).
  */
 declare const SUB_PREFIX = "sub";
+/** One agent identity in a root-first address chain. */
+interface AgentPathStep {
+  /** Agent class name as exported by the Worker. */
+  className: string;
+  /** Logical Agent instance name. */
+  name: string;
+}
+interface BuildAgentPathOptions {
+  /** Top-level route prefix. Must match `routeAgentRequest`; defaults to `agents`. */
+  prefix?: string;
+  /** Pathname suffix appended after the destination Agent identity. */
+  leafPath?: string;
+  /** Root Durable Object binding name, when it differs from the root class name. */
+  rootBinding?: string;
+}
+/** @internal Build the strictly validated path tail for sub-agent routing. */
+declare function buildSubAgentPath(
+  path: ReadonlyArray<AgentPathStep>,
+  leafPath?: string
+): string;
+/** @internal Preserve React's tolerant path composition for disabled placeholders. */
+declare function buildSubAgentPathUnchecked(
+  path: ReadonlyArray<AgentPathStep>,
+  leafPath?: string
+): string;
+/**
+ * Build the canonical pathname for a root Agent or nested sub-agent.
+ *
+ * The address is root-first and accepts `Agent#selfPath`. Pass
+ * `rootBinding` when the root Durable Object binding and class names differ.
+ */
+declare function buildAgentPath(
+  path: ReadonlyArray<AgentPathStep>,
+  options?: BuildAgentPathOptions
+): string;
+/** Build an absolute URL for a root Agent or nested sub-agent. */
+declare function buildAgentUrl(
+  origin: string | URL,
+  path: ReadonlyArray<AgentPathStep>,
+  options?: BuildAgentPathOptions
+): URL;
 interface SubAgentPathMatch {
   /** CamelCase class name of the child, as it appears in `ctx.exports`. */
   childClass: string;
@@ -281,19 +346,6 @@ declare class WorkerTransport extends WebStandardStreamableHTTPServerTransport$1
   private _capturedInitializeParams?;
   private _userOnSessionInitialized?;
   private _bridgeInstalled;
-  /**
-   * Tracks keepalive interval cleanups so we can fire them eagerly when the
-   * SDK closes the underlying SSE stream via `closeSSEStream(requestId)` or
-   * `closeStandaloneSSEStream()`. Keyed by the JSON-RPC request id that
-   * triggered the stream, or the sentinel for the standalone GET stream.
-   */
-  private readonly _keepaliveCleanups;
-  /**
-   * Most recent JSON-RPC request id seen on an incoming POST. Used to key
-   * keepalive cleanups when the response is an SSE stream tied to that
-   * request (so `closeSSEStream(id)` can find and clear the interval).
-   */
-  private _pendingRequestId?;
   /**
    * Request ids whose SSE stream was deliberately torn down via
    * `closeSSEStream`. The SDK's `send()` throws "No connection established"
@@ -314,8 +366,7 @@ declare class WorkerTransport extends WebStandardStreamableHTTPServerTransport$1
   /**
    * Top-level request entry point. Handles CORS preflight, restores any
    * persisted state on first invocation, then delegates to the SDK transport
-   * and finally appends CORS headers + keepalive to whatever response comes
-   * back.
+   * and finally appends CORS headers to whatever response comes back.
    */
   handleRequest(
     request: Request,
@@ -331,7 +382,6 @@ declare class WorkerTransport extends WebStandardStreamableHTTPServerTransport$1
    */
   private normalizeAllowHeader;
   closeSSEStream(requestId: RequestId): void;
-  closeStandaloneSSEStream(): void;
   close(): Promise<void>;
   /**
    * Swallow two classes of message that would otherwise surface as
@@ -356,34 +406,6 @@ declare class WorkerTransport extends WebStandardStreamableHTTPServerTransport$1
     message: JSONRPCMessage$1,
     options?: TransportSendOptions$1
   ): Promise<void>;
-  /**
-   * If the response is an SSE stream, tee the body through a TransformStream
-   * that injects a `: keepalive\n\n` comment frame every 25s. The interval
-   * is cleared when the wrapped stream closes — which happens both when the
-   * SDK ends the underlying stream naturally and when `closeSSEStream` is
-   * called.
-   *
-   * Keepalive policy:
-   *   - POST response streams (`key` is a request id): always keepalive.
-   *     In-progress tool calls have no recovery path — if the stream drops
-   *     mid-execution the result is lost — so we keep it under the
-   *     Cloudflare edge ~5min idle watchdog.
-   *   - Standalone GET stream (`key === "_standalone"`): keepalive only
-   *     when no `eventStore` is configured. When resumability is enabled,
-   *     clients reconnect with `Last-Event-ID` after an idle drop, so we
-   *     skip the keepalive and let the DO hibernate.
-   *
-   * Uses the shared `sse-keepalive` constants so both this wrapper and
-   * `McpAgent.serve()` write identical frames at the same cadence.
-   * See cloudflare/agents#1583.
-   */
-  private withKeepalive;
-  /**
-   * Does the SDK transport have an `eventStore`? Reaches into the SDK's
-   * private field because the option isn't surfaced on the public API —
-   * we only need a yes/no for keepalive policy.
-   */
-  private eventStoreConfigured;
   private getCorsHeaders;
   private withCorsHeaders;
   private installOnSessionInitializedBridge;
@@ -2588,6 +2610,251 @@ declare function getNamespacedData<T extends keyof NamespacedData>(
   type: T
 ): NamespacedData[T];
 //#endregion
+//#region src/workflow-types.d.ts
+type AgentWorkflowPathStep = AgentPathStep;
+type AgentWorkflowOrigin =
+  | {
+      kind: "agent";
+      version: 1 /** Environment binding name for the top-level Agent namespace */;
+      binding: string /** Name/ID of the top-level Agent */;
+      name: string;
+    }
+  | {
+      kind: "facet";
+      version: 1 /** Environment binding name for the root Agent namespace */;
+      rootBinding: string /** Root-first path to the originating facet, including itself */;
+      path: AgentWorkflowPathStep[];
+    };
+/**
+ * Type alias for WorkflowEvent in AgentWorkflow context.
+ * Identical to WorkflowEvent - provided for naming consistency with AgentWorkflowStep.
+ */
+type AgentWorkflowEvent<Params = unknown> = WorkflowEvent<Params>;
+/**
+ * Extended WorkflowStep with durable Agent communication methods.
+ * All added methods on this interface are durable - they're idempotent and won't
+ * repeat on workflow retry.
+ */
+interface AgentWorkflowStep extends WorkflowStep {
+  /**
+   * Report successful completion to the Agent (durable).
+   * Triggers onWorkflowComplete() on the Agent.
+   * @param result - Optional result data
+   */
+  reportComplete<T = unknown>(result?: T): Promise<void>;
+  /**
+   * Report an error to the Agent (durable).
+   * Triggers onWorkflowError() on the Agent.
+   * @param error - Error or error message
+   */
+  reportError(error: Error | string): Promise<void>;
+  /**
+   * Send a custom event to the Agent (durable).
+   * Triggers onWorkflowEvent() on the Agent.
+   * @param event - Custom event payload
+   */
+  sendEvent<T = unknown>(event: T): Promise<void>;
+  /**
+   * Update the Agent's state entirely (durable).
+   * This will replace the Agent's state and broadcast to all connected clients.
+   * @param state - New state to set
+   */
+  updateAgentState(state: unknown): Promise<void>;
+  /**
+   * Merge partial state into the Agent's existing state (durable).
+   * Performs a shallow merge and broadcasts to all connected clients.
+   * @param partialState - Partial state to merge
+   */
+  mergeAgentState(partialState: Record<string, unknown>): Promise<void>;
+  /**
+   * Reset the Agent's state to its initialState (durable).
+   * Broadcasts the reset state to all connected clients.
+   */
+  resetAgentState(): Promise<void>;
+}
+/**
+ * Internal parameters injected by runWorkflow() to identify the originating Agent
+ */
+type AgentWorkflowInternalParams = {
+  /** Name/ID of the Agent that started this workflow */ __agentName: string /** Environment binding name for the Agent's namespace */;
+  __agentBinding: string /** Workflow binding name (for callbacks) */;
+  __workflowName: string /** Versioned origin identity for top-level Agents and sub-agent facets */;
+  __agentOrigin?: AgentWorkflowOrigin;
+};
+/**
+ * Combined workflow params: user params + internal agent params
+ */
+type AgentWorkflowParams<T = unknown> = T & AgentWorkflowInternalParams;
+/**
+ * Workflow callback types for Agent-Workflow communication
+ */
+type WorkflowCallbackType = "progress" | "complete" | "error" | "event";
+/**
+ * Base callback structure sent from Workflow to Agent
+ */
+type WorkflowCallbackBase = {
+  /** Workflow binding name */ workflowName: string /** ID of the workflow instance */;
+  workflowId: string /** Type of callback */;
+  type: WorkflowCallbackType /** Timestamp when callback was sent */;
+  timestamp: number;
+};
+/**
+ * Default progress type - covers common use cases.
+ * Developers can define their own progress type for domain-specific needs.
+ */
+type DefaultProgress = {
+  /** Current step name */ step?: string /** Step/overall status */;
+  status?:
+    | "pending"
+    | "running"
+    | "complete"
+    | "error" /** Human-readable message */;
+  message?: string /** Progress percentage (0-1) */;
+  percent?: number /** Allow additional custom fields */;
+  [key: string]: unknown;
+};
+/**
+ * Progress callback - reports workflow progress with typed payload
+ */
+type WorkflowProgressCallback<P = DefaultProgress> = WorkflowCallbackBase & {
+  type: "progress" /** Typed progress data */;
+  progress: P;
+};
+/**
+ * Complete callback - workflow finished successfully
+ */
+type WorkflowCompleteCallback = WorkflowCallbackBase & {
+  type: "complete" /** Result of the workflow */;
+  result?: unknown;
+};
+/**
+ * Error callback - workflow encountered an error
+ */
+type WorkflowErrorCallback = WorkflowCallbackBase & {
+  type: "error" /** Error message */;
+  error: string;
+};
+/**
+ * Event callback - custom event from workflow
+ */
+type WorkflowEventCallback = WorkflowCallbackBase & {
+  type: "event" /** Custom event payload */;
+  event: unknown;
+};
+/**
+ * Union of all callback types
+ */
+type WorkflowCallback<P = DefaultProgress> =
+  | WorkflowProgressCallback<P>
+  | WorkflowCompleteCallback
+  | WorkflowErrorCallback
+  | WorkflowEventCallback;
+/**
+ * Workflow status values - derived from Cloudflare's InstanceStatus
+ */
+type WorkflowStatus = InstanceStatus["status"];
+/**
+ * Row structure for cf_agents_workflows tracking table
+ */
+type WorkflowTrackingRow = {
+  /** Internal row ID (UUID) */ id: string /** Cloudflare Workflow instance ID */;
+  workflow_id: string /** Workflow binding name */;
+  workflow_name: string /** Current workflow status */;
+  status: WorkflowStatus /** JSON-serialized metadata for querying */;
+  metadata: string | null /** Error name if workflow failed */;
+  error_name: string | null /** Error message if workflow failed */;
+  error_message: string | null /** Unix timestamp when workflow was created */;
+  created_at: number /** Unix timestamp when workflow was last updated */;
+  updated_at: number /** Unix timestamp when workflow completed (null if not complete) */;
+  completed_at: number | null;
+};
+/**
+ * Options for runWorkflow()
+ */
+type RunWorkflowOptions = {
+  /** Custom workflow instance ID (auto-generated if not provided) */ id?: string /** Optional metadata for querying (stored as JSON) */;
+  metadata?: Record<
+    string,
+    unknown
+  > /** Agent binding name (auto-detected from class name if not provided) */;
+  agentBinding?: string /** Retention policy for the underlying Workflow instance */;
+  retention?: WorkflowInstanceCreateOptions["retention"];
+};
+/**
+ * Event payload for sendWorkflowEvent()
+ */
+type WorkflowEventPayload = {
+  /** Event type name */ type: string /** Event payload data */;
+  payload: unknown;
+};
+/**
+ * Parsed workflow tracking info returned by getWorkflow()
+ */
+type WorkflowInfo = {
+  /** Internal row ID */ id: string /** Cloudflare Workflow instance ID */;
+  workflowId: string /** Workflow binding name */;
+  workflowName: string /** Current workflow status */;
+  status: WorkflowStatus /** Metadata (parsed from JSON) */;
+  metadata: Record<string, unknown> | null /** Error info if workflow failed */;
+  error: {
+    name: string;
+    message: string;
+  } | null /** When workflow was created */;
+  createdAt: Date /** When workflow was last updated */;
+  updatedAt: Date /** When workflow completed (null if not complete) */;
+  completedAt: Date | null;
+};
+/**
+ * Criteria for querying tracked workflows
+ */
+type WorkflowQueryCriteria = {
+  /** Filter by status */ status?:
+    | WorkflowStatus
+    | WorkflowStatus[] /** Filter by workflow binding name */;
+  workflowName?: string /** Filter by metadata key-value pairs (exact match) */;
+  metadata?: Record<
+    string,
+    string | number | boolean
+  > /** Limit number of results (default 50, max 100) */;
+  limit?: number /** Order by created_at */;
+  orderBy?:
+    | "asc"
+    | "desc" /** Cursor for pagination (from previous WorkflowPage.nextCursor) */;
+  cursor?: string;
+};
+/**
+ * Paginated result from getWorkflows()
+ */
+type WorkflowPage = {
+  /** Workflows for this page */ workflows: WorkflowInfo[] /** Total count of workflows matching the criteria (ignoring pagination) */;
+  total: number /** Cursor for next page, or null if no more pages */;
+  nextCursor: string | null;
+};
+/**
+ * Standard approval event payload used by approveWorkflow/rejectWorkflow
+ */
+type ApprovalEventPayload = {
+  /** Whether the workflow was approved */ approved: boolean /** Optional reason for approval/rejection */;
+  reason?: string /** Optional additional metadata */;
+  metadata?: Record<string, unknown>;
+};
+/**
+ * Options for waitForApproval()
+ */
+type WaitForApprovalOptions = {
+  /** Step name for waitForEvent (default: "wait-for-approval") */ stepName?: string /** Timeout duration (e.g., "7 days") */;
+  timeout?: WorkflowSleepDuration /** Event type to wait for (default: "approval") */;
+  eventType?: string;
+};
+/**
+ * Error thrown when a workflow is rejected via rejectWorkflow()
+ */
+declare class WorkflowRejectedError extends Error {
+  readonly reason?: string | undefined;
+  readonly workflowId?: string | undefined;
+  constructor(reason?: string | undefined, workflowId?: string | undefined);
+}
+//#endregion
 //#region src/index.d.ts
 /**
  * Structural type for Cloudflare's `send_email` binding.
@@ -2838,10 +3105,6 @@ type Schedule<T = string> = {
       intervalSeconds: number;
     }
 );
-type AgentPathStep = {
-  className: string;
-  name: string;
-};
 type ScheduleStorageRow = {
   id: string;
   callback: string;
@@ -4492,19 +4755,13 @@ declare class Agent<
    *
    * @experimental The API surface may change before stabilizing.
    */
-  get parentPath(): ReadonlyArray<{
-    className: string;
-    name: string;
-  }>;
+  get parentPath(): ReadonlyArray<AgentPathStep>;
   /**
    * Ancestor chain + self, root-first. Convenient for logging.
    *
    * @experimental The API surface may change before stabilizing.
    */
-  get selfPath(): ReadonlyArray<{
-    className: string;
-    name: string;
-  }>;
+  get selfPath(): ReadonlyArray<AgentPathStep>;
   /**
    * Resolve a typed parent stub for this facet's **immediate** parent
    * agent.
@@ -6040,123 +6297,154 @@ type AgentToolEventState<Part extends AgentToolRunPart = AgentToolRunPart> = {
 //#endregion
 export {
   RoutingRetryOptions as $,
-  LegacyMcpHandler as $t,
+  MCPOAuthCallbackResult as $t,
   AgentGetOptions as A,
-  MCPServerFilter as At,
+  StreamableHTTPEdgeClientTransport as An,
+  WorkflowCompleteCallback as At,
   EmailSendBinding as B,
-  RPCServerTransport as Bt,
+  parseSubAgentPath as Bn,
+  WorkflowTrackingRow as Bt,
   DetachedRunAgentToolResult as C,
-  MCPClientManager as Ct,
+  LegacyMcpHandler as Cn,
+  ApprovalEventPayload as Ct,
   AddRpcMcpServerOptions as D,
-  MCPConnectionResult as Dt,
+  WorkerTransport as Dn,
+  WorkflowCallback as Dt,
   AddMcpServerOptions as E,
-  MCPClientOAuthResult as Et,
+  TransportState as En,
+  WaitForApprovalOptions as Et,
   Connection$1 as F,
-  normalizeServerId as Ft,
+  buildAgentPath as Fn,
+  WorkflowPage as Ft,
   FiberStatus as G,
-  ElicitResult$3 as Gt,
+  MCPClientElicitationHandler as Gt,
   FiberInspection as H,
-  RPC_DO_PREFIX as Ht,
+  withInvocationScope as Hn,
+  ElicitResult$2 as Ht,
   ConnectionContext$1 as I,
-  MCPElicitationHandler as It,
+  buildAgentUrl as In,
+  WorkflowProgressCallback as It,
   MCPServerMessage as J,
-  DurableObjectEventStore as Jt,
+  MCPClientManagerOptions as Jt,
   ListFibersOptions as K,
-  McpAgent as Kt,
+  MCPClientElicitationHandlers as Kt,
   DEFAULT_AGENT_STATIC_OPTIONS as L,
-  MCPElicitationHandlers as Lt,
+  buildSubAgentPath as Ln,
+  WorkflowQueryCriteria as Lt,
   AgentOptions as M,
-  MCP_SERVER_ID_MAX_LENGTH as Mt,
+  BuildAgentPathOptions as Mn,
+  WorkflowEventCallback as Mt,
   AgentStaticOptions as N,
-  RegisterServerOptions as Nt,
+  SUB_PREFIX as Nn,
+  WorkflowEventPayload as Nt,
   Agent as O,
-  MCPDiscoverResult as Ot,
+  WorkerTransportOptions as On,
+  WorkflowCallbackBase as Ot,
   CallableMetadata as P,
-  getNamespacedData as Pt,
+  SubAgentPathMatch as Pn,
+  WorkflowInfo as Pt,
   RPCResponse as Q,
-  CreateMcpHandlerOptions$1 as Qt,
+  MCPDiscoverResult as Qt,
   DeleteFibersOptions as R,
-  RPCClientTransport as Rt,
+  buildSubAgentPathUnchecked as Rn,
+  WorkflowRejectedError as Rt,
   DetachedAgentToolConfig as S,
-  MCPClientElicitationHandlers as St,
+  CreateMcpHandlerOptions$1 as Sn,
+  AgentWorkflowStep as St,
   RunAgentToolResult as T,
-  MCPClientOAuthCallbackConfig as Tt,
+  MCPStorageApi as Tn,
+  RunWorkflowOptions as Tt,
   FiberRecoveryContext as U,
-  ElicitRequest$2 as Ut,
+  MCPAITool as Ut,
   FiberContext as V,
-  RPCServerTransportOptions as Vt,
+  routeSubAgentRequest as Vn,
+  ElicitRequest$1 as Vt,
   FiberRecoveryResult as W,
-  ElicitRequestSchema as Wt,
+  MCPAIToolSet as Wt,
   QueueItem as X,
-  experimental_createMcpHandler as Xt,
+  MCPClientOAuthResult as Xt,
   MCPServersState as Y,
-  createMcpHandler$1 as Yt,
+  MCPClientOAuthCallbackConfig as Yt,
   RPCRequest as Z,
-  CreateLegacyMcpHandlerOptions as Zt,
+  MCPConnectionResult as Zt,
   AgentToolRunState as _,
-  ElicitRequest$1 as _t,
+  ClearableEventStore as _n,
+  AgentWorkflowEvent as _t,
   AgentToolEvent as a,
-  SSEEdgeClientTransport as an,
+  normalizeServerId as an,
   StartFiberResult as at,
   AgentToolTerminalStatus as b,
-  MCPAIToolSet as bt,
+  experimental_createMcpHandler as bn,
+  AgentWorkflowParams as bt,
   AgentToolFailure as c,
-  SubAgentPathMatch as cn,
+  RPCClientTransport as cn,
   SubAgentClass as ct,
   AgentToolMilestone as d,
-  routeSubAgentRequest as dn,
+  RPCServerTransportOptions as dn,
   callable as dt,
-  createLegacyMcpHandler as en,
+  MCPServerFilter as en,
   Schedule as et,
   AgentToolProgress as f,
+  RPC_DO_PREFIX as fn,
   getAgentByName as ft,
   AgentToolRunPart as g,
+  McpAgent as gn,
   unstable_callable as gt,
   AgentToolRunInspection as h,
+  ElicitResult$3 as hn,
   routeAgentRequest as ht,
   AgentToolDisplayMetadata as i,
-  WorkerTransportOptions as in,
+  getNamespacedData as in,
   StartFiberOptions as it,
   AgentNamespace as j,
-  MCPServerOptions as jt,
+  AgentPathStep as jn,
+  WorkflowErrorCallback as jt,
   AgentContext as k,
-  MCPOAuthCallbackResult as kt,
+  SSEEdgeClientTransport as kn,
+  WorkflowCallbackType as kt,
   AgentToolInterruptedReason as l,
-  getSubAgentByName as ln,
+  RPCClientTransportOptions as ln,
   SubAgentStub as lt,
   AgentToolRunInfo as m,
+  ElicitRequestSchema as mn,
   routeAgentEmail as mt,
   AGENT_TOOL_PROGRESS_PART as n,
-  TransportState as nn,
+  MCP_SERVER_ID_MAX_LENGTH as nn,
   SendEmailOptions as nt,
   AgentToolEventMessage as o,
-  StreamableHTTPEdgeClientTransport as on,
+  MCPElicitationHandler as on,
   StateUpdateMessage as ot,
   AgentToolProgressSnapshot as p,
+  ElicitRequest$2 as pn,
   getCurrentAgent as pt,
   MCPServer as q,
-  ClearableEventStore as qt,
+  MCPClientManager as qt,
   AgentToolChildAdapter as r,
-  WorkerTransport as rn,
+  RegisterServerOptions as rn,
   SqlError as rt,
   AgentToolEventState as s,
-  SUB_PREFIX as sn,
+  MCPElicitationHandlers as sn,
   StreamingResponse as st,
   AGENT_TOOL_MILESTONE_PART as t,
-  MCPStorageApi as tn,
+  MCPServerOptions as tn,
   ScheduleCriteria as tt,
   AgentToolLifecycleResult as u,
-  parseSubAgentPath as un,
+  RPCServerTransport as un,
   WSMessage$1 as ut,
   AgentToolRunStatus as v,
-  ElicitResult$2 as vt,
+  DurableObjectEventStore as vn,
+  AgentWorkflowInternalParams as vt,
   RunAgentToolOptions as w,
-  MCPClientManagerOptions as wt,
+  createLegacyMcpHandler as wn,
+  DefaultProgress as wt,
   ChatCapableAgentClass as x,
-  MCPClientElicitationHandler as xt,
+  CreateLegacyMcpHandlerOptions as xn,
+  AgentWorkflowPathStep as xt,
   AgentToolStoredChunk as y,
-  MCPAITool as yt,
+  createMcpHandler$1 as yn,
+  AgentWorkflowOrigin as yt,
   EmailRoutingOptions as z,
-  RPCClientTransportOptions as zt
+  getSubAgentByName as zn,
+  WorkflowStatus as zt
 };
-//# sourceMappingURL=agent-tool-types-Btk9ETS-.d.ts.map
+//# sourceMappingURL=agent-tool-types-CzGGB-20.d.ts.map

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

@@ -24,7 +24,7 @@ import {
   w as RunAgentToolOptions,
   x as ChatCapableAgentClass,
   y as AgentToolStoredChunk
-} from "./agent-tool-types-Btk9ETS-.js";
+} from "./agent-tool-types-CzGGB-20.js";
 export {
   AGENT_TOOL_MILESTONE_PART,
   AGENT_TOOL_PROGRESS_PART,

package/dist/{agent-tools-UuScsJg3.d.ts → agent-tools-zR2d5uij.d.ts}

@@ -4,7 +4,7 @@ import {
   o as AgentToolEventMessage,
   s as AgentToolEventState,
   y as AgentToolStoredChunk
-} from "./agent-tool-types-Btk9ETS-.js";
+} from "./agent-tool-types-CzGGB-20.js";
 
 //#region src/chat/agent-tools.d.ts
 type AgentToolProgressEmitResult = "emitted" | "coalesced" | "inactive";
@@ -130,4 +130,4 @@ export {
   interceptAgentToolBroadcast as s,
   AgentToolBroadcastHooks as t
 };
-//# sourceMappingURL=agent-tools-UuScsJg3.d.ts.map
+//# sourceMappingURL=agent-tools-zR2d5uij.d.ts.map