agents 0.11.4 → 0.11.5

package/README.md

@@ -107,7 +107,7 @@ State changes sync to all connected clients automatically. Call methods like the
 ## Features
 
 ```
-Core         State sync · Routing · HTTP & WebSockets · @callable RPC
+Core         State sync · Routing · HTTP & WebSockets · @callable RPC · Sub-agents (facets)
 Clients      React hook · Vanilla JS · Real-time state sync
 Channels     WebSocket · HTTP · Email · (coming: SMS, Voice, Messengers)
 Background   Queue · Scheduling · Workflows · Human-in-the-loop
@@ -179,6 +179,49 @@ await this.queue("processUpload", { fileId: "abc" });
 // Returns immediately, task runs in background
 ```
 
+### Sub-agents
+
+Spawn child Durable Objects (facets) from a parent agent. Each child has
+its own SQLite storage and runs in parallel, but is addressed under the
+parent's URL:
+
+```typescript
+export class Inbox extends Agent {
+  @callable()
+  async createChat() {
+    const id = crypto.randomUUID();
+    await this.subAgent(Chat, id);
+    return id;
+  }
+
+  override async onBeforeSubAgent(_req, { className, name }) {
+    if (!this.hasSubAgent(className, name)) {
+      return new Response("Not found", { status: 404 });
+    }
+  }
+}
+
+export class Chat extends Agent {
+  async writePreview(text: string) {
+    const inbox = await this.parentAgent(Inbox);
+    await inbox.savePreview(this.name, text);
+  }
+}
+```
+
+Client-side, connect to a child with `useAgent({ sub: [...] })`:
+
+```tsx
+const inbox = useAgent({ agent: "Inbox", name: userId });
+const chat = useAgent({
+  agent: "Inbox",
+  name: userId,
+  sub: [{ agent: "Chat", name: chatId }]
+});
+```
+
+The routed URL becomes `/agents/inbox/{userId}/sub/chat/{chatId}`.
+
 ### WebSocket Connections
 
 Handle real-time communication:

package/dist/chat/index.d.ts

@@ -599,5 +599,77 @@ type ChatProtocolEvent = {
  */
 declare function parseProtocolMessage(raw: string): ChatProtocolEvent | null;
 //#endregion
-export { AbortRegistry, type BroadcastStreamEvent, type BroadcastStreamState, type TransitionResult as BroadcastTransitionResult, CHAT_MESSAGE_TYPES, type ChatProtocolEvent, type ChunkAction, type ChunkResult, type ClientToolSchema, type ContinuationConnection, type ContinuationDeferred, type ContinuationPending, ContinuationState, type EnqueueOptions, type MessagePart, type MessageParts, ROW_MAX_BYTES, ResumableStream, type SqlTaggedTemplate, StreamAccumulator, type StreamAccumulatorOptions, type StreamChunkData, type ToolPartUpdate, TurnQueue, type TurnResult, applyChunkToParts, applyToolUpdate, transition as broadcastTransition, byteLength, createToolsFromClientSchemas, enforceRowSizeLimit, parseProtocolMessage, sanitizeMessage, toolApprovalUpdate, toolResultUpdate };
+//#region src/chat/lifecycle.d.ts
+/**
+ * Result passed to the `onChatResponse` lifecycle hook after a chat
+ * turn completes.
+ */
+type ChatResponseResult = {
+  /** The finalized assistant message from this turn. */message: UIMessage; /** The request ID associated with this turn. */
+  requestId: string; /** Whether this turn was a continuation of a previous assistant turn. */
+  continuation: boolean; /** How the turn ended. */
+  status: "completed" | "error" | "aborted"; /** Error message when `status` is `"error"`. */
+  error?: string;
+};
+/**
+ * Result returned by programmatic entry points that may skip execution
+ * when the chat state has been invalidated mid-flight (e.g. by a
+ * `CHAT_CLEAR` protocol message).
+ */
+type SaveMessagesResult = {
+  /** Server-generated request ID for the chat turn. */requestId: string; /** Whether the turn ran or was skipped (e.g. because the chat was cleared). */
+  status: "completed" | "skipped";
+};
+/**
+ * Context passed to the `onChatRecovery` hook when an interrupted chat
+ * stream is detected after DO restart.
+ */
+type ChatRecoveryContext = {
+  /** Stream ID from the interrupted stream. */streamId: string; /** Request ID from the interrupted stream. */
+  requestId: string; /** Partial text extracted from stored chunks. */
+  partialText: string; /** Partial message parts reconstructed from chunks. */
+  partialParts: MessagePart[]; /** Checkpoint data from `this.stash()` during the interrupted stream. */
+  recoveryData: unknown | null; /** Current persisted messages. */
+  messages: UIMessage[]; /** Custom body from the last chat request. */
+  lastBody?: Record<string, unknown>; /** Client tool schemas from the last chat request. */
+  lastClientTools?: ClientToolSchema[];
+  /**
+   * Epoch milliseconds when the underlying fiber was started. Compare
+   * against `Date.now()` to suppress continuations for turns that have
+   * been orphaned too long to safely replay.
+   */
+  createdAt: number;
+};
+/**
+ * Options returned from `onChatRecovery` to control recovery behavior.
+ */
+type ChatRecoveryOptions = {
+  /** Save the partial response from stored chunks. Default: true. */persist?: boolean; /** Schedule a continuation via `continueLastTurn()`. Default: true. */
+  continue?: boolean;
+};
+/**
+ * Controls how overlapping user submit requests behave while another
+ * chat turn is already active or queued.
+ *
+ * - `"queue"` (default) — queue every submit and process them in order.
+ * - `"latest"` — keep only the latest overlapping submit; superseded
+ *   submits still persist their user messages, but do not start their
+ *   own model turn.
+ * - `"merge"` — like `latest`, but all overlapping user messages remain
+ *   in the conversation history. The model sees them all in one turn.
+ * - `"drop"` — ignore overlapping submits entirely (messages not
+ *   persisted).
+ * - `{ strategy: "debounce", debounceMs? }` — trailing-edge latest with
+ *   a quiet window.
+ *
+ * Only applies to `submit-message` requests. Regenerations, tool
+ * continuations, approvals, clears, programmatic `saveMessages`, and
+ * `continueLastTurn` keep their existing serialized behavior.
+ */
+type MessageConcurrency = "queue" | "latest" | "merge" | "drop" | {
+  strategy: "debounce";
+  debounceMs?: number;
+};
+//#endregion
+export { AbortRegistry, type BroadcastStreamEvent, type BroadcastStreamState, type TransitionResult as BroadcastTransitionResult, CHAT_MESSAGE_TYPES, type ChatProtocolEvent, type ChatRecoveryContext, type ChatRecoveryOptions, type ChatResponseResult, type ChunkAction, type ChunkResult, type ClientToolSchema, type ContinuationConnection, type ContinuationDeferred, type ContinuationPending, ContinuationState, type EnqueueOptions, type MessageConcurrency, type MessagePart, type MessageParts, ROW_MAX_BYTES, ResumableStream, type SaveMessagesResult, type SqlTaggedTemplate, StreamAccumulator, type StreamAccumulatorOptions, type StreamChunkData, type ToolPartUpdate, TurnQueue, type TurnResult, applyChunkToParts, applyToolUpdate, transition as broadcastTransition, byteLength, createToolsFromClientSchemas, enforceRowSizeLimit, parseProtocolMessage, sanitizeMessage, toolApprovalUpdate, toolResultUpdate };
 //# sourceMappingURL=index.d.ts.map

package/dist/{client-B_xdiZbn.js → client-BYF13FDD.js}

@@ -1446,8 +1446,10 @@ var MCPClientManager = class {
 		const entries = [];
 		for (const tool of getNamespacedData(connections, "tools")) try {
 			const toolKey = `tool_${tool.serverId.replace(/-/g, "")}_${tool.name}`;
+			const title = tool.title ?? tool.annotations?.title;
 			entries.push([toolKey, {
 				description: tool.description,
+				title,
 				execute: async (args) => {
 					const result = await this.callTool({
 						arguments: args,
@@ -1617,4 +1619,4 @@ function getNamespacedData(mcpClients, type) {
 //#endregion
 export { RPCServerTransport as a, RPCClientTransport as i, getNamespacedData as n, RPC_DO_PREFIX as o, MCPConnectionState as r, DisposableStore as s, MCPClientManager as t };
 
-//# sourceMappingURL=client-B_xdiZbn.js.map
+//# sourceMappingURL=client-BYF13FDD.js.map