agents 0.21.0 → 0.22.0

package/dist/capability-BjSKYpzg.js

@@ -0,0 +1,42 @@
+//#region src/lifecycle/capability.ts
+const installedServices = /* @__PURE__ */ new WeakMap();
+/**
+* Base class for capabilities that consume standard Lifecycle services.
+*
+* @experimental The API surface may change before stabilizing.
+*/
+var LifecycleCapability = class {
+	constructor(capabilityId) {
+		if (capabilityId.trim() === "") throw new Error("Lifecycle capability IDs must be non-empty");
+		this.capabilityId = capabilityId;
+	}
+	/** Default startup hook; capabilities override when they own startup work. */
+	onStart(_context) {}
+	/** Standard services when installed, or undefined in isolated unit tests. */
+	get lifecycleServices() {
+		return installedServices.get(this);
+	}
+	/** Standard services supplied when Lifecycle installs this capability. */
+	get lifecycle() {
+		const services = this.lifecycleServices;
+		if (!services) throw new Error(`${this.constructor.name} must be installed with Lifecycle.use() before use`);
+		return services;
+	}
+};
+/**
+* @internal Bind the standard service surface to one capability instance.
+* `Lifecycle.use()` calls this during installation. Test a capability by
+* installing it on a minimal Durable Object with a real Lifecycle rather
+* than binding fake services.
+*/
+function bindLifecycleCapability(capability, services) {
+	installedServices.set(capability, services);
+}
+/** @internal Read a capability ID without exposing installation internals. */
+function lifecycleCapabilityId(capability) {
+	return capability instanceof LifecycleCapability ? capability.capabilityId : void 0;
+}
+//#endregion
+export { bindLifecycleCapability as n, lifecycleCapabilityId as r, LifecycleCapability as t };
+
+//# sourceMappingURL=capability-BjSKYpzg.js.map

package/dist/capability-BjSKYpzg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability-BjSKYpzg.js","names":[],"sources":["../src/lifecycle/capability.ts"],"sourcesContent":["import type {\n  CapabilityStartContext,\n  DurableObjectCapability\n} from \"./capability-runner\";\n\n/** Opaque address understood by a Lifecycle routing transport. */\nexport type LifecycleRouteAddress = {\n  /** Stable equality and storage key. */\n  readonly key: string;\n  /** Transport-owned serialized address. */\n  readonly data: string;\n};\n\n/** Context supplied with a routed capability message. */\nexport type LifecycleRouteContext = {\n  /** Address of the sending Lifecycle, or undefined for an unrouted root. */\n  readonly source: LifecycleRouteAddress | undefined;\n  /** Capability-owned message payload. */\n  readonly payload: unknown;\n};\n\n/** Alarm coordination available to every Lifecycle capability. */\nexport type LifecycleAlarms = {\n  /** Recompute the physical alarm from installed capability state. */\n  readonly rearm: () => Promise<void>;\n  /**\n   * True once explicit host teardown permanently disabled alarm arming.\n   * Capabilities stop dispatching durable work when this reports true.\n   */\n  readonly disabled: () => boolean;\n};\n\n/** Best-effort telemetry available to every Lifecycle capability. */\nexport type LifecycleEvents = {\n  /** Publish an event under this capability's stable identity. */\n  readonly emit: (type: string, payload: unknown) => void;\n};\n\n/** Routing available to every Lifecycle capability. */\nexport type LifecycleRoutes = {\n  /** This Lifecycle's transport address, or undefined at the route root. */\n  readonly source: LifecycleRouteAddress | undefined;\n  /** Route a capability-owned message to the root Lifecycle. */\n  readonly toRoot: (payload: unknown) => Promise<unknown>;\n  /** Route a capability-owned message to another Lifecycle. */\n  readonly to: (\n    target: LifecycleRouteAddress,\n    payload: unknown\n  ) => Promise<unknown>;\n};\n\n/**\n * Standard services granted to every installed Lifecycle capability.\n *\n * @experimental The API surface may change before stabilizing.\n */\nexport type LifecycleServices = {\n  readonly storage: DurableObjectStorage;\n  readonly ready: () => Promise<void>;\n  /** True while capability and host startup hooks are still running. */\n  readonly starting: () => boolean;\n  readonly alarms: LifecycleAlarms;\n  /**\n   * Run a capability-held user callback inside the host invocation context.\n   * Capability hooks run outside host context; this is the one boundary for\n   * entering it, and a host composition root may substitute its own wrapper\n   * (Agent adds tracing span scope).\n   */\n  readonly runInHostContext: (fn: () => unknown) => Promise<unknown>;\n  readonly events: LifecycleEvents;\n  readonly routes: LifecycleRoutes;\n};\n\nconst installedServices = new WeakMap<object, LifecycleServices>();\n\n/**\n * Base class for capabilities that consume standard Lifecycle services.\n *\n * @experimental The API surface may change before stabilizing.\n */\nexport abstract class LifecycleCapability<Props extends object = object> {\n  readonly capabilityId: string;\n\n  protected constructor(capabilityId: string) {\n    if (capabilityId.trim() === \"\") {\n      throw new Error(\"Lifecycle capability IDs must be non-empty\");\n    }\n    this.capabilityId = capabilityId;\n  }\n\n  /** Default startup hook; capabilities override when they own startup work. */\n  onStart(_context: CapabilityStartContext<Props>): void {}\n\n  /** Standard services when installed, or undefined in isolated unit tests. */\n  protected get lifecycleServices(): LifecycleServices | undefined {\n    return installedServices.get(this);\n  }\n\n  /** Standard services supplied when Lifecycle installs this capability. */\n  protected get lifecycle(): LifecycleServices {\n    const services = this.lifecycleServices;\n    if (!services) {\n      throw new Error(\n        `${this.constructor.name} must be installed with Lifecycle.use() before use`\n      );\n    }\n    return services;\n  }\n}\n\n/**\n * @internal Bind the standard service surface to one capability instance.\n * `Lifecycle.use()` calls this during installation. Test a capability by\n * installing it on a minimal Durable Object with a real Lifecycle rather\n * than binding fake services.\n */\nexport function bindLifecycleCapability(\n  capability: LifecycleCapability,\n  services: LifecycleServices\n): void {\n  installedServices.set(capability, services);\n}\n\n/** @internal Read a capability ID without exposing installation internals. */\nexport function lifecycleCapabilityId(\n  capability: DurableObjectCapability\n): string | undefined {\n  return capability instanceof LifecycleCapability\n    ? capability.capabilityId\n    : undefined;\n}\n"],"mappings":";AAyEA,MAAM,oCAAoB,IAAI,QAAmC;;;;;;AAOjE,IAAsB,sBAAtB,MAAyE;CAGvE,YAAsB,cAAsB;EAC1C,IAAI,aAAa,KAAK,MAAM,IAC1B,MAAM,IAAI,MAAM,4CAA4C;EAE9D,KAAK,eAAe;CACtB;;CAGA,QAAQ,UAA+C,CAAC;;CAGxD,IAAc,oBAAmD;EAC/D,OAAO,kBAAkB,IAAI,IAAI;CACnC;;CAGA,IAAc,YAA+B;EAC3C,MAAM,WAAW,KAAK;EACtB,IAAI,CAAC,UACH,MAAM,IAAI,MACR,GAAG,KAAK,YAAY,KAAK,mDAC3B;EAEF,OAAO;CACT;AACF;;;;;;;AAQA,SAAgB,wBACd,YACA,UACM;CACN,kBAAkB,IAAI,YAAY,QAAQ;AAC5C;;AAGA,SAAgB,sBACd,YACoB;CACpB,OAAO,sBAAsB,sBACzB,WAAW,eACX,KAAA;AACN"}

package/dist/capability-runner-CvHGZqUu.d.ts

@@ -0,0 +1,150 @@
+//#region src/lifecycle/capability.d.ts
+/** Opaque address understood by a Lifecycle routing transport. */
+type LifecycleRouteAddress = {
+  /** Stable equality and storage key. */ readonly key: string /** Transport-owned serialized address. */;
+  readonly data: string;
+};
+/** Context supplied with a routed capability message. */
+type LifecycleRouteContext = {
+  /** Address of the sending Lifecycle, or undefined for an unrouted root. */ readonly source:
+    | LifecycleRouteAddress
+    | undefined /** Capability-owned message payload. */;
+  readonly payload: unknown;
+};
+/** Alarm coordination available to every Lifecycle capability. */
+type LifecycleAlarms = {
+  /** Recompute the physical alarm from installed capability state. */ readonly rearm: () => Promise<void>;
+  /**
+   * True once explicit host teardown permanently disabled alarm arming.
+   * Capabilities stop dispatching durable work when this reports true.
+   */
+  readonly disabled: () => boolean;
+};
+/** Best-effort telemetry available to every Lifecycle capability. */
+type LifecycleEvents = {
+  /** Publish an event under this capability's stable identity. */ readonly emit: (
+    type: string,
+    payload: unknown
+  ) => void;
+};
+/** Routing available to every Lifecycle capability. */
+type LifecycleRoutes = {
+  /** This Lifecycle's transport address, or undefined at the route root. */ readonly source:
+    | LifecycleRouteAddress
+    | undefined /** Route a capability-owned message to the root Lifecycle. */;
+  readonly toRoot: (
+    payload: unknown
+  ) => Promise<unknown> /** Route a capability-owned message to another Lifecycle. */;
+  readonly to: (
+    target: LifecycleRouteAddress,
+    payload: unknown
+  ) => Promise<unknown>;
+};
+/**
+ * Standard services granted to every installed Lifecycle capability.
+ *
+ * @experimental The API surface may change before stabilizing.
+ */
+type LifecycleServices = {
+  readonly storage: DurableObjectStorage;
+  readonly ready: () => Promise<void> /** True while capability and host startup hooks are still running. */;
+  readonly starting: () => boolean;
+  readonly alarms: LifecycleAlarms;
+  /**
+   * Run a capability-held user callback inside the host invocation context.
+   * Capability hooks run outside host context; this is the one boundary for
+   * entering it, and a host composition root may substitute its own wrapper
+   * (Agent adds tracing span scope).
+   */
+  readonly runInHostContext: (fn: () => unknown) => Promise<unknown>;
+  readonly events: LifecycleEvents;
+  readonly routes: LifecycleRoutes;
+};
+/**
+ * Base class for capabilities that consume standard Lifecycle services.
+ *
+ * @experimental The API surface may change before stabilizing.
+ */
+declare abstract class LifecycleCapability<Props extends object = object> {
+  readonly capabilityId: string;
+  protected constructor(capabilityId: string);
+  /** Default startup hook; capabilities override when they own startup work. */
+  onStart(_context: CapabilityStartContext<Props>): void;
+  /** Standard services when installed, or undefined in isolated unit tests. */
+  protected get lifecycleServices(): LifecycleServices | undefined;
+  /** Standard services supplied when Lifecycle installs this capability. */
+  protected get lifecycle(): LifecycleServices;
+}
+//#endregion
+//#region src/lifecycle/capability-runner.d.ts
+type MaybePromise<T> = T | Promise<T>;
+/** One capability's requested physical alarm. */
+type AlarmContribution =
+  | number
+  | {
+      /** Epoch time in milliseconds. */ readonly time: number /** Ignore ordinary wake-time candidates while this request exists. */;
+      readonly exclusive: true;
+    }
+  | null;
+/** One best-effort event published by a Lifecycle capability. */
+type LifecycleEvent = {
+  /** Stable capability or subsystem name. */ readonly source: string /** Stable event name within that source. */;
+  readonly type: string /** Event-specific data. */;
+  readonly payload: unknown;
+};
+/** Context supplied when durable capabilities start. */
+type CapabilityStartContext<Props extends object = object> = {
+  /** Properties supplied while resolving the Durable Object. */ readonly props:
+    | Props
+    | undefined;
+};
+/** Context supplied when durable capabilities inspect an HTTP request. */
+type CapabilityRequestContext = {
+  /** The request entering the Durable Object. */ readonly request: Request;
+};
+/**
+ * A capability installed into a Durable Object lifecycle.
+ *
+ * Capabilities extending `LifecycleCapability` receive the standard storage,
+ * readiness, alarm, event, and routing surface. Host-specific bindings and
+ * protocol adapters remain explicit constructor dependencies. Hook parameters
+ * carry only phase data; hooks do not run in ambient host context.
+ *
+ * @experimental The API surface may change before stabilizing.
+ */
+interface DurableObjectCapability<Props extends object = object> {
+  /** Initialize or recover the capability before the host handles work. */
+  onStart?(context: CapabilityStartContext<Props>): MaybePromise<void>;
+  /**
+   * Inspect an HTTP request before the host's request handler.
+   *
+   * Return a response to handle the request, or `undefined` to continue.
+   */
+  onRequest?(
+    context: CapabilityRequestContext
+  ): MaybePromise<Response | undefined | void>;
+  /** Run work assigned to the capability when the host's alarm fires. */
+  onAlarm?(): MaybePromise<void>;
+  /** Handle one message routed to this capability identity. */
+  onRoute?(context: LifecycleRouteContext): MaybePromise<unknown>;
+  /** Return this capability's next requested physical alarm. */
+  getNextAlarm?(): MaybePromise<AlarmContribution>;
+  /** Release live or in-memory resources during explicit host destruction. */
+  dispose?(): MaybePromise<void>;
+}
+//#endregion
+export {
+  LifecycleEvent as a,
+  LifecycleEvents as c,
+  LifecycleRoutes as d,
+  LifecycleServices as f,
+  DurableObjectCapability as i,
+  LifecycleRouteAddress as l,
+  CapabilityRequestContext as n,
+  LifecycleAlarms as o,
+  CapabilityStartContext as r,
+  LifecycleCapability as s,
+  AlarmContribution as t,
+  LifecycleRouteContext as u
+};
+//# sourceMappingURL=capability-runner-CvHGZqUu.d.ts.map

package/dist/chat/index.d.ts

@@ -1,10 +1,10 @@
 import {
-  U as FiberRecoveryContext,
-  _ as AgentToolRunState,
-  a as AgentToolEvent,
-  o as AgentToolEventMessage,
-  s as AgentToolEventState
-} from "../agent-tool-types-CzGGB-20.js";
+  H as AgentToolEvent,
+  U as AgentToolEventMessage,
+  W as AgentToolEventState,
+  et as AgentToolRunState,
+  v as FiberRecoveryContext
+} from "../agent-routing-CnkaHb-v.js";
 import {
   n as ClientToolSchema,
   r as createToolsFromClientSchemas,
@@ -18,7 +18,7 @@ import {
   r as AgentToolProgressEmitResult,
   s as interceptAgentToolBroadcast,
   t as AgentToolBroadcastHooks
-} from "../agent-tools-zR2d5uij.js";
+} from "../agent-tools-C0XJqWzB.js";
 import { JSONSchema7, UIMessage } from "ai";
 import { Connection } from "agents";
 
@@ -192,7 +192,9 @@ declare function enforceRowSizeLimit(
 //#region src/chat/stream-accumulator.d.ts
 interface StreamAccumulatorOptions {
   messageId: string;
+  /** Whether chunks continue the current assistant message when merged. */
   continuation?: boolean;
+  /** Eager seed; omitted continuations seed from the messages passed to `mergeInto`. */
   existingParts?: UIMessage["parts"];
   existingMetadata?: Record<string, unknown>;
 }
@@ -236,6 +238,7 @@ declare class StreamAccumulator {
   readonly parts: UIMessage["parts"];
   metadata?: Record<string, unknown>;
   private _isContinuation;
+  private _pendingContinuationChunks;
   constructor(options: StreamAccumulatorOptions);
   applyChunk(chunk: StreamChunkData): ChunkResult;
   /** Snapshot the current state as a UIMessage. */
@@ -243,7 +246,8 @@ declare class StreamAccumulator {
   /**
    * Merge this accumulator's message into an existing message array.
    * Handles continuation (walk backward for last assistant), replacement
-   * (update existing by messageId), or append (new message).
+   * (update existing by messageId), or append (new message). An unseeded
+   * continuation adopts current parts here before applying its queued chunks.
    */
   mergeInto(messages: UIMessage[]): UIMessage[];
 }
@@ -521,9 +525,11 @@ type ChatRecoveryProgressContext = {
   ageMs: number;
 };
 /**
- * Configuration for durable chat recovery. `true` uses these defaults:
- * `maxAttempts: 10`, `stableTimeoutMs: 10_000`, `noProgressTimeoutMs: 300_000`
- * (5 min), `maxRecoveryWork: 1000`, and a generic terminal message.
+ * Configuration for durable chat recovery, which is always enabled for chat
+ * turns. `true` uses these defaults: `maxAttempts: 10`,
+ * `stableTimeoutMs: 10_000`, `noProgressTimeoutMs: 300_000` (5 min),
+ * `maxRecoveryWork: 1000`, and a generic terminal message. Assign an object to
+ * tune recovery without disabling its durable bookkeeping.
  *
  * **Apply this as a class field or in the constructor — never assign it in
  * `onStart()`.** On every wake the SDK evaluates recovery budgets (and may seal
@@ -535,7 +541,7 @@ type ChatRecoveryProgressContext = {
  * `onStart()`.
  */
 type ChatRecoveryConfig =
-  | boolean
+  | true
   | {
       maxAttempts?: number;
       stableTimeoutMs?: number;
@@ -596,8 +602,8 @@ type ChatRecoveryConfig =
       ): boolean | Promise<boolean>;
       onExhausted?(ctx: ChatRecoveryExhaustedContext): void | Promise<void>;
     };
+/** Fully-defaulted configuration for always-on durable chat recovery. */
 type ResolvedChatRecoveryConfig = {
-  enabled: boolean;
   maxAttempts: number;
   stableTimeoutMs: number;
   terminalMessage: string;
@@ -708,7 +714,7 @@ type BroadcastStreamEvent =
       error?: boolean;
       replay?: boolean;
       replayComplete?: boolean;
-      continuation?: boolean /** Required when continuation=true so the accumulator can pick up existing parts. */;
+      continuation?: boolean /** @deprecated Continuations now seed from current messages in `messagesUpdate`. */;
       currentMessages?: UIMessage[];
     }
   | {
@@ -2272,7 +2278,8 @@ declare const CHAT_RECOVERY_ALARM_DEBOUNCE_MS: number;
 declare const CHAT_RECOVERING_FLAG_TTL_MS: number;
 /**
  * Resolve a raw `chatRecovery` config field into the fully-defaulted form the
- * engine reasons about. Identical defaulting in both packages today.
+ * engine reasons about. Durable recovery is always enabled; a legacy runtime
+ * `false` value from previously compiled JavaScript safely receives defaults.
  */
 declare function resolveChatRecoveryConfig(
   raw: ChatRecoveryConfig | undefined

package/dist/chat/index.js

@@ -1,9 +1,9 @@
 import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, r as _assertClassBrand, t as _classPrivateFieldGet2 } from "../classPrivateFieldGet2-DZBYAB34.js";
+import { t as _classPrivateMethodInitSpec } from "../classPrivateMethodInitSpec-qMjJ6sHQ.js";
 import { i as normalizeToolInput, n as getPartialStreamText, r as isReplayChunk, t as applyChunkToParts } from "../message-builder-BymO4N_D.js";
 import { i as interceptAgentToolBroadcast, n as applyAgentToolEvent, r as createAgentToolEventState, t as AgentToolProgressEmitter } from "../agent-tools-y7zLfw4Q.js";
-import { t as _classPrivateMethodInitSpec } from "../classPrivateMethodInitSpec-qMjJ6sHQ.js";
 import { t as truncateToolOutput } from "../tool-output-truncation-CNnnGZQ3.js";
-import { i as StreamAccumulator, n as STREAM_RESUME_NONE_REASONS, r as transition, t as CHAT_MESSAGE_TYPES } from "../protocol-Dqc2MQxo.js";
+import { i as StreamAccumulator, n as STREAM_RESUME_NONE_REASONS, r as transition, t as CHAT_MESSAGE_TYPES } from "../protocol-B0nh6KNf.js";
 import { t as MessageType } from "../wire-types-CnMt6_HR.js";
 import { jsonSchema, tool } from "ai";
 import { nanoid } from "nanoid";
@@ -2561,12 +2561,12 @@ const CHAT_RECOVERY_ALARM_DEBOUNCE_MS = 30 * 1e3;
 const CHAT_RECOVERING_FLAG_TTL_MS = 900 * 1e3;
 /**
 * Resolve a raw `chatRecovery` config field into the fully-defaulted form the
-* engine reasons about. Identical defaulting in both packages today.
+* engine reasons about. Durable recovery is always enabled; a legacy runtime
+* `false` value from previously compiled JavaScript safely receives defaults.
 */
 function resolveChatRecoveryConfig(raw) {
 	const custom = typeof raw === "object" && raw !== null ? raw : void 0;
 	return {
-		enabled: raw !== false,
 		maxAttempts: Math.max(1, Math.floor(custom?.maxAttempts ?? 10)),
 		stableTimeoutMs: Math.max(0, Math.floor(custom?.stableTimeoutMs ?? 1e4)),
 		terminalMessage: custom?.terminalMessage ?? "The assistant was interrupted and could not recover. Please try again.",