agents 0.20.1 → 0.21.0

package/README.md

@@ -16,6 +16,11 @@ Or add to an existing project:
 npm install agents
 ```
 
+The examples below use `@callable()` decorators. Vite projects must extend
+`agents/tsconfig` and add the `agents/vite` plugin; other bundlers must support
+TC39 decorators (`2023-11`). See
+[Adding Agents to an Existing Project](../../docs/agents/adding-to-existing-project.md#4-configure-typescript-and-vite).
+
 ---
 
 ## Why Agents, Why Now
@@ -44,7 +49,7 @@ A counter agent with real-time state sync and callable methods:
 // server.ts
 import { Agent, callable } from "agents";
 
-type State = { count: number };
+export type State = { count: number };
 
 export class CounterAgent extends Agent<Env, State> {
   initialState: State = { count: 0 };
@@ -67,11 +72,12 @@ export class CounterAgent extends Agent<Env, State> {
 // client.tsx
 import { useAgent } from "agents/react";
 import { useState } from "react";
+import type { CounterAgent, State } from "./server";
 
 function Counter() {
   const [count, setCount] = useState(0);
 
-  const agent = useAgent<State>({
+  const agent = useAgent<CounterAgent, State>({
     agent: "counter-agent",
     name: "my-counter",
     onStateUpdate: (state) => setCount(state.count)
@@ -120,8 +126,12 @@ Platform     Observability · Cross-domain auth · Resumable streams
 State persists across requests and syncs to all connected clients:
 
 ```typescript
-export class MyAgent extends Agent<Env, { items: string[] }> {
-  initialState = { items: [] };
+import { Agent, callable, type Connection } from "agents";
+
+type State = { items: string[] };
+
+export class MyAgent extends Agent<Env, State> {
+  initialState: State = { items: [] };
 
   @callable()
   addItem(item: string) {
@@ -262,6 +272,29 @@ export class Assistant extends Think<Env> {
 }
 ```
 
+`inputSchema` accepts schemas supported by the AI SDK, including Zod, Standard
+JSON Schema-compatible schemas, raw JSON Schema through `jsonSchema()`, and
+schemas exposed through AI SDK adapters. For example, use `@ai-sdk/valibot` v2
+with AI SDK 6 or v3 with AI SDK 7:
+
+```typescript
+import { valibotSchema } from "@ai-sdk/valibot";
+import * as v from "valibot";
+
+const researchInput = valibotSchema(
+  v.object({ query: v.pipe(v.string(), v.minLength(3)) })
+);
+
+agentTool(Researcher, {
+  description: "Research one topic in depth.",
+  inputSchema: researchInput
+});
+```
+
+Tool inputs need model-facing JSON Schema in addition to runtime validation. A
+validation-only Standard Schema is therefore insufficient; use its Standard
+JSON Schema extension or an AI SDK adapter.
+
 For deterministic fan-out, call `this.runAgentTool(Researcher, { input })`
 directly. Parent recovery reconciles stale child rows after restarts and marks
 unrecoverable runs `interrupted` instead of hanging. In React, use
@@ -294,7 +327,9 @@ async onClose(connection: Connection) {
 Agents can receive and respond to emails:
 
 ```typescript
-async onEmail(email: EmailMessage) {
+import type { AgentEmail } from "agents/email";
+
+async onEmail(email: AgentEmail) {
   const from = email.from;
   const subject = email.headers.get("subject");
   // Process incoming email
@@ -392,15 +427,18 @@ For AI-powered chat experiences with persistent conversations, streaming respons
 
 ```typescript
 import { AIChatAgent } from "@cloudflare/ai-chat";
+import { createWorkersAI } from "workers-ai-provider";
+import { convertToModelMessages, streamText } from "ai";
 
 export class ChatAgent extends AIChatAgent<Env> {
-  async onChatMessage(onFinish) {
-    return streamText({
-      model: openai("gpt-4o"),
-      messages: this.messages,
-      tools: this.tools,
-      onFinish
+  async onChatMessage() {
+    const workersai = createWorkersAI({ binding: this.env.AI });
+    const result = streamText({
+      model: workersai("@cf/moonshotai/kimi-k2.7-code"),
+      messages: await convertToModelMessages(this.messages)
     });
+
+    return result.toUIMessageStreamResponse();
   }
 }
 ```
@@ -409,7 +447,7 @@ export class ChatAgent extends AIChatAgent<Env> {
 // Client
 import { useAgentChat } from "@cloudflare/ai-chat/react";
 
-const { messages, input, handleSubmit } = useAgentChat({
+const { messages, sendMessage } = useAgentChat({
   agent: useAgent({ agent: "chat-agent" })
 });
 ```

package/dist/{agent-tool-types-BC-WFlsz.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,
@@ -136,6 +133,47 @@ declare function withInvocationScope<T>(
  * 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;
@@ -2572,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.
@@ -2822,10 +3105,6 @@ type Schedule<T = string> = {
       intervalSeconds: number;
     }
 );
-type AgentPathStep = {
-  className: string;
-  name: string;
-};
 type ScheduleStorageRow = {
   id: string;
   callback: string;
@@ -4476,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.
@@ -6024,124 +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,
-  withInvocationScope as fn,
+  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-BC-WFlsz.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-BC-WFlsz.js";
+} from "./agent-tool-types-CzGGB-20.js";
 export {
   AGENT_TOOL_MILESTONE_PART,
   AGENT_TOOL_PROGRESS_PART,