agents 0.22.0 → 0.24.0

package/dist/durable-object-lifecycle-ei7M7lqB.d.ts

@@ -0,0 +1,157 @@
+import {
+  T as WSMessage,
+  b as LifecycleJobs,
+  i as DurableObjectCapability,
+  u as LifecycleRouteAddress
+} from "./capability-runner-BUBa6Ake.js";
+import { DurableObject } from "cloudflare:workers";
+
+//#region src/lifecycle/durable-object-lifecycle.d.ts
+/** Internal envelope transported between routed Lifecycle instances. */
+type LifecycleRouteEnvelope = {
+  readonly capability: string;
+  readonly source: LifecycleRouteAddress | undefined;
+  readonly payload: unknown;
+};
+/** Configuration accepted when constructing a {@link Lifecycle}. */
+type LifecycleOptions = {
+  /**
+   * Consecutive alarm invocations that may end in a Durable Object
+   * memory-limit reset before the circuit breaker (#1825) seals recovery
+   * work instead of backing it off. Default: 3.
+   */
+  readonly maxAlarmMemoryLimitStrikes?: number;
+};
+declare class Lifecycle<
+  Env extends object = Cloudflare.Env,
+  Props extends Record<string, unknown> = Record<string, unknown>
+> {
+  #private;
+  /**
+   * Construct and install a lifecycle in one explicit operation.
+   *
+   * @param host - The Durable Object whose runtime handlers the lifecycle owns.
+   * @returns The installed lifecycle.
+   */
+  static install<
+    Env extends object,
+    Props extends Record<string, unknown> = Record<string, unknown>
+  >(
+    host: DurableObject<Env>,
+    options?: LifecycleOptions
+  ): Lifecycle<Env, Props>;
+  /**
+   * Bind a lifecycle to a Durable Object instance without mutating its handlers.
+   *
+   * @param host - The Durable Object whose runtime lifecycle this object owns.
+   * @param options - Policy configuration for this lifecycle.
+   */
+  constructor(host: DurableObject<Env>, options?: LifecycleOptions);
+  /**
+   * Install platform fetch, alarm, and hibernating WebSocket handlers.
+   *
+   * Existing handlers are preserved for framework-owned dispatch such as the
+   * Agent's sub-agent router and alarm circuit breaker. Calling this method
+   * more than once is an error.
+   */
+  installHandlers(): void;
+  /**
+   * Add a reusable capability before this lifecycle starts.
+   *
+   * Capabilities dispatch in registration order, except that a capability
+   * declaring `claims: "catch-all"` always comes last, whenever it was
+   * installed. Catch-alls are unique per dispatch hook: two may coexist
+   * when they claim disjoint traffic (one `onRequest`, one
+   * `onWebSocketUpgrade`), but a second catch-all for the same hook could
+   * never be reached and is refused.
+   *
+   * @param capability - The capability to add.
+   * @returns This lifecycle.
+   */
+  use(capability: DurableObjectCapability<Props>): this;
+  /** @internal Deliver a generic capability envelope to this Lifecycle. */
+  route(envelope: LifecycleRouteEnvelope): Promise<unknown>;
+  /**
+   * Execute SQL queries against the Durable Object's database
+   * @template T Type of the returned rows
+   * @param strings SQL query template strings
+   * @param values Values to be inserted into the query
+   * @returns Array of query results
+   */
+  sql<T = Record<string, string | number | boolean | null>>(
+    strings: TemplateStringsArray,
+    ...values: (string | number | boolean | null)[]
+  ): T[];
+  /**
+   * Handle an incoming request for the owning Durable Object.
+   *
+   * Non-upgrade requests run through the capability middleware chain first,
+   * then fall through to the host's `onRequest`.
+   */
+  fetch(request: Request): Promise<Response>;
+  /** @internal Dispatch a hibernating WebSocket message. */
+  webSocketMessage(ws: WebSocket, message: WSMessage): Promise<void>;
+  /** @internal Dispatch a hibernating WebSocket close. */
+  webSocketClose(
+    ws: WebSocket,
+    code: number,
+    reason: string,
+    wasClean: boolean
+  ): Promise<void>;
+  /** @internal Dispatch a hibernating WebSocket error. */
+  webSocketError(ws: WebSocket, error: unknown): Promise<void>;
+  /**
+   * Start lifecycle capabilities and the owning Durable Object.
+   *
+   * Runtime fetch, alarm, and WebSocket entry points call this automatically.
+   * RPC methods may call it explicitly because native RPC bypasses fetch.
+   *
+   * @param props - Optional properties supplied to capability and host startup.
+   */
+  start(props?: Props): Promise<void>;
+  /**
+   * The name used to address this Durable Object.
+   *
+   * Native `ctx.id.name` is authoritative. A read-only legacy storage fallback
+   * lets objects created by older PartyServer releases migrate without new
+   * name writes.
+   */
+  get name(): string;
+  /**
+   * The host's scoped access to the Lifecycle work queue. Items pushed here
+   * are dispatched to the host's `onJob` inside the host invocation
+   * boundary.
+   */
+  get jobs(): LifecycleJobs;
+  /**
+   * Recompute the physical Durable Object alarm from job-queue state.
+   *
+   * Concurrent requests are serialized so a later durable-state change cannot
+   * be overwritten by an earlier alarm calculation. Queue mutations call this
+   * automatically; it stays public for composition roots and tests.
+   */
+  rearmAlarm(): Promise<void>;
+  /**
+   * Keep work a job handed off at a bounded return inside the current
+   * alarm's memory-limit breaker domain (#1825). Hosts call this where a
+   * queue-driven callback detaches long work and returns.
+   *
+   * @returns True when called during an alarm invocation; false otherwise.
+   */
+  trackAlarmWork(work: Promise<unknown>): boolean;
+  /** Dispose installed capabilities in reverse registration order. */
+  dispose(): Promise<void>;
+  /** Permanently disable and clear alarms during explicit object teardown. */
+  disableAlarms(): Promise<void>;
+  /**
+   * Run one alarm invocation. The job driver owns the event loop — deadman
+   * pre-arm, due-job dispatch with retry and deferral policy, the alarm
+   * memory-limit circuit breaker (#1825) — and re-arms the physical alarm
+   * from queue state. The host's `onAlarm()` runs after due jobs, inside
+   * the host invocation boundary.
+   */
+  alarm(): Promise<void>;
+}
+//#endregion
+export { LifecycleOptions as n, LifecycleRouteEnvelope as r, Lifecycle as t };
+//# sourceMappingURL=durable-object-lifecycle-ei7M7lqB.d.ts.map

package/dist/index-BB0kqhIz.d.ts

@@ -0,0 +1,101 @@
+import {
+  D as ChannelInboundMessage,
+  F as ChannelMessageSurface,
+  U as UserIdentity,
+  V as ChannelIdentity,
+  a as ChannelApprovalRequestOptions,
+  d as ChannelRoute,
+  h as DeliveryResult,
+  j as ChannelIngressEvent,
+  l as ChannelDeliveryOptions,
+  n as Channel,
+  p as ChannelStreamOptions,
+  s as ChannelChunkSource,
+  u as ChannelMessage,
+  w as ChannelEmailInput,
+  y as ChannelApprovalResponse
+} from "./channel-Bnm4S7T2.js";
+
+//#region src/channels/host/index.d.ts
+type ChannelMessageEvent = {
+  channelKey: string;
+  route: string /** Stable identity derived only from the configured Channel and eventId. */;
+  dispatchId: string;
+  message: ChannelInboundMessage;
+};
+type ChannelApprovalResponseEvent = {
+  channelKey: string;
+  route: string /** Stable identity derived only from the configured Channel and eventId. */;
+  dispatchId: string;
+  response: ChannelApprovalResponse;
+};
+type ChannelRouteEvent = {
+  channelKey: string;
+  event: ChannelIngressEvent;
+  route:
+    | string
+    | null /** Stable identity derived only from the configured Channel and eventId. */;
+  dispatchId: string;
+};
+type ChannelHostOptions = {
+  channels: Record<
+    string,
+    Channel
+  > /** Used when a Channel does not provide a route. Default: event thread id. */;
+  defaultRoute?: ChannelRoute /** Resolve an existing, explicitly linked application user. */;
+  findUser?(
+    identity: ChannelIdentity
+  ): Promise<UserIdentity | null> /** Observes every valid route outcome before application dispatch. */;
+  onRoute?(event: ChannelRouteEvent): void | Promise<void>;
+  onMessage?(event: ChannelMessageEvent): void | Promise<void>;
+  onApprovalResponse?(
+    event: ChannelApprovalResponseEvent
+  ): void | Promise<void>;
+};
+/**
+ * Authenticates and normalizes ingress through configured Channel adapters,
+ * resolves outbound surfaces, and awaits the application's durable handoff.
+ */
+declare class ChannelHost {
+  #private;
+  constructor(options: ChannelHostOptions);
+  handleRequest(request: Request): Promise<Response | undefined>;
+  handleEmail(email: ChannelEmailInput): Promise<boolean>;
+  /** Deliver through the configured Channel or composite named by the surface. */
+  deliver(
+    surface: ChannelMessageSurface,
+    message: ChannelMessage,
+    options?: ChannelDeliveryOptions
+  ): Promise<DeliveryResult>;
+  /**
+   * Deliver a progressively generated answer to the Channel or composite
+   * named by the surface.
+   *
+   * A Channel that can stream consumes the stream itself. A Channel that
+   * cannot never learns it was a stream, because the Host collects the answer
+   * and calls `deliver` once.
+   */
+  stream(
+    surface: ChannelMessageSurface,
+    chunks: ChannelChunkSource,
+    options?: ChannelStreamOptions
+  ): Promise<DeliveryResult>;
+  /** Request approval through the Channel or composite named by the surface. */
+  requestApproval(
+    surface: ChannelMessageSurface,
+    options: ChannelApprovalRequestOptions
+  ): Promise<DeliveryResult>;
+  /** Return the identity's configured Channel destination, when supported. */
+  contactSurface(identity: ChannelIdentity): ChannelMessageSurface | null;
+  /** Resolve whether a surface can currently be selected without delivery. */
+  isAvailable(surface: ChannelMessageSurface): Promise<boolean>;
+}
+//#endregion
+export {
+  ChannelRouteEvent as a,
+  ChannelMessageEvent as i,
+  ChannelHost as n,
+  ChannelHostOptions as r,
+  ChannelApprovalResponseEvent as t
+};
+//# sourceMappingURL=index-BB0kqhIz.d.ts.map

package/dist/index-BVVgDSdq.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index-Dlgtd3Mj.d.ts

@@ -0,0 +1,78 @@
+import {
+  s as LifecycleCapability,
+  x as Connection
+} from "./capability-runner-BUBa6Ake.js";
+//#region src/state/index.d.ts
+/**
+ * Source of a state change: `"server"` for host code (e.g. `setState()`), or
+ * the {@link Connection} the change arrived from. Hosts use it to exclude the
+ * originating connection from a broadcast.
+ */
+type StateChangeSource = Connection | "server";
+/**
+ * Options for a {@link State} capability. Validation and the post-change hook
+ * stay on the host, which passes them in; the capability owns storage and
+ * change ordering.
+ *
+ * @experimental The API surface may change before stabilizing.
+ */
+interface StateOptions<T = unknown> {
+  /** Seeded on first access when nothing is stored. `undefined` seeds nothing. */
+  readonly initialState?: T;
+  /** Called after a change is validated and persisted. May be async. */
+  readonly onChanged?: (
+    state: T,
+    source: StateChangeSource
+  ) => void | Promise<void>;
+  /**
+   * Synchronous gating hook run before a change is persisted. Throw to reject
+   * the change; the throw propagates to the caller of {@link State.set}.
+   */
+  readonly validateStateChange?: (
+    nextState: T,
+    source: StateChangeSource
+  ) => void;
+}
+/**
+ * Durable state storage for a Lifecycle Object.
+ *
+ * Owns the `cf_agents_state` state row, lazy load with an in-memory cache, and
+ * validated persistence. Install the instance with `Lifecycle.use()`. State
+ * validation and the post-change notification hook stay on the host, which
+ * injects both callbacks. This capability never touches connections.
+ *
+ * @experimental The API surface may change before stabilizing.
+ */
+declare class State<T = unknown> extends LifecycleCapability {
+  #private;
+  /**
+   * Create a durable state capability.
+   *
+   * @param options - Optional initial state and a synchronous validation hook
+   * injected by the host.
+   */
+  constructor(options?: StateOptions<T>);
+  /** Initialize state storage during Lifecycle startup. */
+  onStart(): Promise<void>;
+  /**
+   * Current state.
+   *
+   * Loads lazily from storage on first access and caches in memory. Row
+   * existence in `cf_agents_state` is the signal that state was previously
+   * set, so falsy values persist correctly. On a corrupt row, falls back to
+   * the initial state (re-persisting it) or clears the row.
+   */
+  get(): T | undefined;
+  /**
+   * Validate and persist a state change, then call the change hook.
+   *
+   * @param nextState - The new state to persist.
+   * @param source - `"server"` for host-originated changes, or the originating
+   * connection for client-originated changes.
+   * @throws Whatever the injected `validateStateChange` throws.
+   */
+  set(nextState: T, source?: StateChangeSource): void;
+}
+//#endregion
+export { StateChangeSource as n, StateOptions as r, State as t };
+//# sourceMappingURL=index-Dlgtd3Mj.d.ts.map

package/dist/index-XDkuQ7zm.d.ts

@@ -0,0 +1,89 @@
+//#region src/tasks/errors.d.ts
+/**
+ * Error classes for the Tasks capability. Each carries a stable `name` so
+ * hosts and tests can classify failures without depending on message text.
+ */
+/**
+ * Thrown by a step callback to fail its run immediately, skipping any
+ * remaining retry attempts.
+ *
+ * Errors named `"NonRetryableError"` from other sources (for example
+ * `cloudflare:workflows`) are honored the same way.
+ *
+ * @experimental The API surface may change before stabilizing.
+ */
+declare class NonRetryableError extends Error {
+  constructor(
+    message: string,
+    options?: {
+      cause?: unknown;
+    }
+  );
+}
+/**
+ * Thrown before executing user code when one replay uses the same step name
+ * twice. Step names are durable journal keys and must be unique within a run.
+ *
+ * @experimental The API surface may change before stabilizing.
+ */
+declare class DuplicateTaskStepError extends Error {
+  /** The step name used more than once. */
+  readonly stepName: string;
+  constructor(stepName: string);
+}
+/**
+ * Thrown when a replay observes a journal that this handler code cannot have
+ * written — a known step under a different kind, for example. The run fails
+ * rather than guessing; changing a definition's step layout for in-flight
+ * runs requires versioning the definition name.
+ *
+ * @experimental The API surface may change before stabilizing.
+ */
+declare class TaskReplayDivergedError extends Error {
+  /** The step name where replay diverged from the journal. */
+  readonly stepName: string;
+  constructor(stepName: string, detail: string);
+}
+/**
+ * Recorded against a run whose persisted definition name is no longer
+ * registered after a deployment. The run fails visibly; it is never silently
+ * deleted and never replayed against a different handler.
+ *
+ * @experimental The API surface may change before stabilizing.
+ */
+declare class MissingTaskDefinitionError extends Error {
+  /** The persisted definition name that no longer resolves. */
+  readonly definition: string;
+  constructor(definition: string);
+}
+/**
+ * Thrown when a Task input, step result, metadata value, or final result is
+ * not JSON-serializable or exceeds the serialized size limit.
+ *
+ * @experimental The API surface may change before stabilizing.
+ */
+declare class TaskSerializationError extends Error {
+  constructor(context: string, detail: string);
+}
+//#endregion
+//#region src/tasks/serialization.d.ts
+/**
+ * Value serialization for the Tasks capability.
+ *
+ * Task inputs, step results, metadata, and final results persist as JSON
+ * text in SQLite. `undefined` (and a `void` handler result) is represented
+ * as SQL `NULL` rather than a JSON envelope, so the JSON column space stays
+ * plain: `"null"` is JSON `null`, column `NULL` is `undefined`.
+ */
+/** Default ceiling for one serialized value (1 MiB). */
+declare const MAX_SERIALIZED_BYTES = 1048576;
+//#endregion
+export {
+  TaskReplayDivergedError as a,
+  NonRetryableError as i,
+  DuplicateTaskStepError as n,
+  TaskSerializationError as o,
+  MissingTaskDefinitionError as r,
+  MAX_SERIALIZED_BYTES as t
+};
+//# sourceMappingURL=index-XDkuQ7zm.d.ts.map

package/dist/{index-DcSAZKsB.d.ts → index-YSKgfgg9.d.ts}

@@ -785,6 +785,8 @@ declare const channels: {
   readonly chat: Channel<any, any>;
   readonly transcript: Channel<any, any>;
   readonly fiber: Channel<any, any>;
+  readonly task: Channel<any, any>;
+  readonly stream: Channel<any, any>;
   readonly agentTool: Channel<any, any>;
   readonly schedule: Channel<any, any>;
   readonly lifecycle: Channel<any, any>;
@@ -932,4 +934,4 @@ export {
   MCPObservabilityEvent as s,
   ChannelEventMap as t
 };
-//# sourceMappingURL=index-DcSAZKsB.d.ts.map
+//# sourceMappingURL=index-YSKgfgg9.d.ts.map

package/dist/index.d.ts

@@ -1,101 +1,97 @@
 /// <reference path="../skills-module.d.ts" />
 import {
-  c as WSMessage,
-  i as __DO_NOT_USE_WILL_BREAK__agentContext,
-  l as Connection,
-  u as ConnectionContext
-} from "./current-agent-CuMErtly.js";
+  S as ConnectionContext,
+  T as WSMessage,
+  x as Connection
+} from "./capability-runner-BUBa6Ake.js";
 import {
-  $ as AgentToolRunPart,
-  A as StateUpdateMessage,
-  B as AgentToolChildAdapter,
-  C as MCPServerMessage,
-  Cn as AgentPathStep,
-  D as RPCResponse,
-  Dn as buildAgentPath,
-  E as RPCRequest,
-  En as SubAgentPathMatch,
-  F as getCurrentAgent,
-  Ft as MCPAITool,
-  G as AgentToolFailure,
-  H as AgentToolEvent,
-  I as routeAgentEmail,
-  It as MCPAIToolSet,
-  J as AgentToolMilestone,
-  Jt as MCP_SERVER_ID_MAX_LENGTH,
-  K as AgentToolInterruptedReason,
-  L as unstable_callable,
-  M as SubAgentClass,
-  Mn as parseSubAgentPath,
-  N as SubAgentStub,
-  Nn as routeSubAgentRequest,
-  O as StartFiberOptions,
-  On as buildAgentUrl,
-  P as callable,
-  Pn as withInvocationScope,
-  Q as AgentToolRunInspection,
-  R as AGENT_TOOL_MILESTONE_PART,
-  S as MCPServer,
-  T as QueueItem,
-  Tn as SUB_PREFIX,
-  U as AgentToolEventMessage,
-  V as AgentToolDisplayMetadata,
-  W as AgentToolEventState,
-  X as AgentToolProgressSnapshot,
-  Y as AgentToolProgress,
-  Z as AgentToolRunInfo,
-  Zt as normalizeServerId,
-  _ as FiberInspection,
+  i as isDurableObjectStorageReset,
+  n as isDurableObjectCodeUpdateReset,
+  r as isDurableObjectMemoryLimitReset,
+  s as isPlatformTransientError,
+  t as RetryOptions
+} from "./retries-D9B2UCq3.js";
+import { i as __DO_NOT_USE_WILL_BREAK__agentContext } from "./current-agent-C4w86kcN.js";
+import {
+  $ as DetachedAgentToolConfig,
+  A as getCurrentAgent,
+  An as withInvocationScope,
+  At as MCPAIToolSet,
+  B as AgentToolInterruptedReason,
+  C as MCPServersState,
+  Cn as buildAgentPath,
+  D as StartFiberResult,
+  Dn as getSubAgentByName,
+  E as StartFiberOptions,
+  F as AgentToolDisplayMetadata,
+  G as AgentToolRunInfo,
+  Gt as normalizeServerId,
+  H as AgentToolMilestone,
+  Ht as MCP_SERVER_ID_MAX_LENGTH,
+  I as AgentToolEvent,
+  J as AgentToolRunState,
+  K as AgentToolRunInspection,
+  L as AgentToolEventMessage,
+  M as AGENT_TOOL_MILESTONE_PART,
+  N as AGENT_TOOL_PROGRESS_PART,
+  O as StateUpdateMessage,
+  On as parseSubAgentPath,
+  P as AgentToolChildAdapter,
+  Q as ChatCapableAgentClass,
+  R as AgentToolEventState,
+  S as MCPServerMessage,
+  Sn as SubAgentPathMatch,
+  T as RPCResponse,
+  U as AgentToolProgress,
+  V as AgentToolLifecycleResult,
+  W as AgentToolProgressSnapshot,
+  X as AgentToolStoredChunk,
+  Y as AgentToolRunStatus,
+  Z as AgentToolTerminalStatus,
+  _ as FiberRecoveryContext,
+  _n as DynamicAgentClass,
   a as routeAgentRequest,
-  at as DetachedAgentToolConfig,
-  b as FiberStatus,
+  b as ListFibersOptions,
+  bn as BuildAgentPathOptions,
   c as Agent,
-  ct as RunAgentToolResult,
   d as AgentStaticOptions,
-  et as AgentToolRunState,
-  f as CallableMetadata,
-  g as FiberContext,
-  h as EmailRoutingOptions,
+  et as DetachedRunAgentToolResult,
+  f as DEFAULT_AGENT_STATIC_OPTIONS,
+  g as FiberInspection,
+  h as FiberContext,
   i as getAgentByName,
-  it as ChatCapableAgentClass,
-  j as StreamingResponse,
-  jn as getSubAgentByName,
-  k as StartFiberResult,
+  j as routeAgentEmail,
+  k as StreamingResponse,
+  kn as routeSubAgentRequest,
+  kt as MCPAITool,
   l as AgentContext,
-  m as DeleteFibersOptions,
+  m as EmailRoutingOptions,
   n as AgentOptions,
-  nt as AgentToolStoredChunk,
+  nt as RunAgentToolResult,
   o as AddMcpServerOptions,
-  ot as DetachedRunAgentToolResult,
-  p as DEFAULT_AGENT_STATIC_OPTIONS,
-  q as AgentToolLifecycleResult,
+  p as DeleteFibersOptions,
+  q as AgentToolRunPart,
   r as RoutingRetryOptions,
-  rt as AgentToolTerminalStatus,
   s as AddRpcMcpServerOptions,
-  st as RunAgentToolOptions,
   t as AgentGetOptions,
-  tt as AgentToolRunStatus,
+  tt as RunAgentToolOptions,
   u as AgentNamespace,
-  v as FiberRecoveryContext,
-  w as MCPServersState,
-  wn as BuildAgentPathOptions,
-  x as ListFibersOptions,
-  y as FiberRecoveryResult,
-  z as AGENT_TOOL_PROGRESS_PART
-} from "./agent-routing-CnkaHb-v.js";
+  v as FiberRecoveryResult,
+  vn as DynamicAgentStub,
+  w as RPCRequest,
+  wn as buildAgentUrl,
+  x as MCPServer,
+  xn as SUB_PREFIX,
+  y as FiberStatus,
+  yn as AgentPathStep,
+  z as AgentToolFailure
+} from "./agent-routing-B2XLNMxq.js";
 import {
   a as EmailSendBinding,
   d as createHeaderBasedEmailResolver,
   s as SendEmailOptions
 } from "./email-7TatiTnl.js";
 import { n as camelCaseToKebabCase } from "./utils-CGtGDSgA.js";
-import {
-  i as isDurableObjectStorageReset,
-  n as isDurableObjectCodeUpdateReset,
-  o as isPlatformTransientError,
-  r as isDurableObjectMemoryLimitReset,
-  t as RetryOptions
-} from "./retries-CAvxtG9d.js";
 import {
   n as AgentsOAuthProvider,
   r as DurableObjectOAuthClientProvider,
@@ -103,7 +99,17 @@ import {
 } from "./do-oauth-client-provider-Tmf1vgKz.js";
 import { f as TransportType } from "./handler-stateless-DxYpJ_XF.js";
 import { t as MessageType } from "./types-6Zo2zfoO.js";
-import { a as ScheduleCriteria, i as Schedule } from "./scheduler-DQoTGoAW.js";
+import {
+  a as ScheduleCriteria,
+  i as Schedule,
+  o as ScheduleOptions
+} from "./scheduler-BGq6M5Kd.js";
+import { i as QueueItem } from "./types-DCD6BNZH.js";
+import {
+  n as callable,
+  s as unstable_callable,
+  t as CallableMetadata
+} from "./callable-decorator-DP__HhBA.js";
 import { t as SqlError } from "./sql-error-CPY-GXyI.js";
 export {
   AGENT_TOOL_MILESTONE_PART,
@@ -138,7 +144,7 @@ export {
   type AgentToolTerminalStatus,
   type AgentsOAuthProvider,
   type BuildAgentPathOptions,
-  CallableMetadata,
+  type CallableMetadata,
   type ChatCapableAgentClass,
   type Connection,
   type ConnectionContext,
@@ -147,6 +153,10 @@ export {
   type DetachedAgentToolConfig,
   type DetachedRunAgentToolResult,
   DurableObjectOAuthClientProvider,
+  type DynamicAgentClass,
+  type DynamicAgentClass as SubAgentClass,
+  type DynamicAgentStub,
+  type DynamicAgentStub as SubAgentStub,
   EmailRoutingOptions,
   type EmailSendBinding,
   FiberContext,
@@ -162,7 +172,7 @@ export {
   MCPServersState,
   MCP_SERVER_ID_MAX_LENGTH,
   MessageType,
-  QueueItem,
+  type QueueItem,
   RPCRequest,
   RPCResponse,
   type RetryOptions,
@@ -172,15 +182,14 @@ export {
   SUB_PREFIX,
   type Schedule,
   type ScheduleCriteria,
+  type ScheduleOptions,
   type SendEmailOptions,
   SqlError,
   StartFiberOptions,
   StartFiberResult,
   StateUpdateMessage,
   StreamingResponse,
-  SubAgentClass,
   type SubAgentPathMatch,
-  SubAgentStub,
   type TransportType,
   type WSMessage,
   __DO_NOT_USE_WILL_BREAK__agentContext,