agents 0.16.2 → 0.17.0

package/dist/{agent-tools-3zLG7MgA.js → message-builder-BymO4N_D.js}

@@ -205,8 +205,12 @@ function applyChunkToParts(parts, chunk) {
 			const toolPart = findToolPartByCallId(parts, chunk.toolCallId);
 			if (toolPart) {
 				const p = toolPart;
+				if (p.state === "approval-responded" || p.state === "output-available" || p.state === "output-error" || p.state === "output-denied") return true;
 				p.state = "approval-requested";
-				p.approval = { id: chunk.approvalId };
+				p.approval = {
+					id: chunk.approvalId,
+					...chunk.approvalDescriptor !== void 0 && { descriptor: chunk.approvalDescriptor }
+				};
 			}
 			return true;
 		}
@@ -214,6 +218,7 @@ function applyChunkToParts(parts, chunk) {
 			const toolPart = findToolPartByCallId(parts, chunk.toolCallId);
 			if (toolPart) {
 				const p = toolPart;
+				if (p.state === "output-available" || p.state === "output-error" || p.state === "output-denied" || p.state === "approval-responded") return true;
 				p.state = "output-denied";
 			}
 			return true;
@@ -283,8 +288,29 @@ function applyChunkToParts(parts, chunk) {
 * - `tool-input-available` for a `toolCallId` whose existing part is no
 *   longer `input-streaming` (i.e. has already advanced to `input-available`
 *   or any terminal state).
+* - `tool-output-denied` for a `toolCallId` whose existing part is already
+*   settled (`output-available` / `output-error` / `output-denied`) or
+*   user-approved (`approval-responded`). A continuation that re-validates
+*   the transcript can re-emit a denial for an approval the SDK now deems
+*   unneeded; `applyChunkToParts` already drops it server-side, and this stops
+*   it reaching the client (where the in-place `updateToolPart` would flip the
+*   part to `output-denied`) and the replay buffer. Mirrors the
+*   first-write-wins guard in `applyChunkToParts`.
+* - `tool-approval-request` for a `toolCallId` whose existing part is already
+*   `approval-responded` or settled. A continuation replaying a prior tool
+*   round-trip can re-emit the approval request; left unfiltered it would
+*   revert an already-approved tool back to `approval-requested` on the client
+*   (re-showing Approve/Reject) and replay that regression on reconnect. Same
+*   pattern and rationale as `tool-output-denied`.
 */
 function isReplayChunk(parts, chunk) {
+	if (chunk.type === "tool-output-denied" || chunk.type === "tool-approval-request") {
+		if (!chunk.toolCallId) return false;
+		const existing = findToolPartByCallId(parts, chunk.toolCallId);
+		if (!existing) return false;
+		const state = existing.state;
+		return state === "output-available" || state === "output-error" || state === "output-denied" || state === "approval-responded";
+	}
 	if (chunk.type !== "tool-input-start" && chunk.type !== "tool-input-delta" && chunk.type !== "tool-input-available") return false;
 	if (!chunk.toolCallId) return false;
 	const existing = findToolPartByCallId(parts, chunk.toolCallId);
@@ -335,133 +361,26 @@ function findDataPartByTypeAndId(parts, type, id) {
 		if (p.type === type && "id" in p && p.id === id) return p;
 	}
 }
-//#endregion
-//#region src/chat/agent-tools.ts
-function sortRuns(runs) {
-	return [...runs].sort((a, b) => {
-		if (a.order !== b.order) return a.order - b.order;
-		return a.runId.localeCompare(b.runId);
-	});
-}
-function rebuildIndexes(runsById) {
-	const grouped = {};
-	const unboundRuns = [];
-	for (const run of Object.values(runsById)) if (run.parentToolCallId) {
-		grouped[run.parentToolCallId] = grouped[run.parentToolCallId] ?? [];
-		grouped[run.parentToolCallId].push(run);
-	} else unboundRuns.push(run);
-	for (const [toolCallId, runs] of Object.entries(grouped)) grouped[toolCallId] = sortRuns(runs);
-	return {
-		runsByToolCallId: grouped,
-		unboundRuns: sortRuns(unboundRuns)
-	};
-}
-function emptyRun(message) {
-	const { event } = message;
-	if (event.kind === "started") return {
-		runId: event.runId,
-		agentType: event.agentType,
-		parentToolCallId: message.parentToolCallId,
-		inputPreview: event.inputPreview,
-		order: event.order,
-		display: event.display,
-		status: "running",
-		parts: [],
-		subAgent: {
-			agent: event.agentType,
-			name: event.runId
-		}
-	};
-}
-function applyToRun(prev, message) {
-	const seeded = prev ?? emptyRun(message);
-	const { event } = message;
-	switch (event.kind) {
-		case "started":
-			if (seeded?.status === "completed" || seeded?.status === "error" || seeded?.status === "aborted" || seeded?.status === "interrupted") return seeded;
-			return {
-				...seeded,
-				runId: event.runId,
-				agentType: event.agentType,
-				parentToolCallId: message.parentToolCallId,
-				inputPreview: event.inputPreview,
-				order: event.order,
-				display: event.display,
-				status: "running",
-				parts: seeded?.parts ?? [],
-				subAgent: {
-					agent: event.agentType,
-					name: event.runId
-				}
-			};
-		case "chunk": {
-			if (!seeded) return void 0;
-			const parts = [...seeded.parts];
-			try {
-				applyChunkToParts(parts, JSON.parse(event.body));
-			} catch {
-				return seeded;
-			}
-			return {
-				...seeded,
-				parts
-			};
-		}
-		case "finished":
-			if (!seeded) return void 0;
-			return {
-				...seeded,
-				status: "completed",
-				summary: event.summary,
-				error: void 0
-			};
-		case "error":
-			if (!seeded) return void 0;
-			return {
-				...seeded,
-				status: "error",
-				error: event.error
-			};
-		case "aborted":
-			if (!seeded) return void 0;
-			return {
-				...seeded,
-				status: "aborted",
-				error: event.reason
-			};
-		case "interrupted":
-			if (!seeded) return void 0;
-			return {
-				...seeded,
-				status: "interrupted",
-				error: event.error,
-				reason: event.reason,
-				childStillRunning: event.childStillRunning
-			};
-	}
-}
-function createAgentToolEventState() {
-	return {
-		runsById: {},
-		runsByToolCallId: {},
-		unboundRuns: []
-	};
-}
-function applyAgentToolEvent(state, message) {
-	if (message.type !== "agent-tool-event") return state;
-	const runId = message.event.runId;
-	const nextRun = applyToRun(state.runsById[runId], message);
-	if (!nextRun) return state;
-	const runsById = {
-		...state.runsById,
-		[runId]: nextRun
-	};
+/**
+* Rebuild the partial text + parts of an interrupted assistant turn from its
+* stored resumable-stream chunks. Replays each chunk body through
+* {@link applyChunkToParts}; malformed bodies are skipped. Shared by
+* `AIChatAgent` and `Think`, which read the chunks from their
+* `ResumableStream` (`getStreamChunks`) and pass them in.
+*
+* `@internal`
+*/
+function getPartialStreamText(chunks) {
+	const parts = [];
+	for (const chunk of chunks) try {
+		applyChunkToParts(parts, JSON.parse(chunk.body));
+	} catch {}
 	return {
-		runsById,
-		...rebuildIndexes(runsById)
+		text: parts.filter((p) => p.type === "text" && "text" in p).map((p) => p.text).join(""),
+		parts
 	};
 }
 //#endregion
-export { normalizeToolInput as a, isReplayChunk as i, createAgentToolEventState as n, applyChunkToParts as r, applyAgentToolEvent as t };
+export { normalizeToolInput as i, getPartialStreamText as n, isReplayChunk as r, applyChunkToParts as t };
 
-//# sourceMappingURL=agent-tools-3zLG7MgA.js.map
+//# sourceMappingURL=message-builder-BymO4N_D.js.map

package/dist/message-builder-BymO4N_D.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-builder-BymO4N_D.js","names":[],"sources":["../src/chat/message-builder.ts"],"sourcesContent":["/**\n * Shared message builder for reconstructing UIMessage parts from stream chunks.\n *\n * Used by both @cloudflare/ai-chat (server + client) and @cloudflare/think\n * to avoid duplicating the chunk-type switch/case logic.\n *\n * Operates on a mutable parts array for performance (avoids allocating new arrays\n * on every chunk during streaming).\n */\n\nimport type { UIMessage } from \"ai\";\n\n/** The parts array type from UIMessage */\nexport type MessageParts = UIMessage[\"parts\"];\n\n/** A single part from the UIMessage parts array */\nexport type MessagePart = MessageParts[number];\n\n/**\n * Parsed chunk data from an AI SDK stream event.\n * This is the JSON-parsed body of a CF_AGENT_USE_CHAT_RESPONSE message,\n * or the `data:` payload of an SSE line.\n */\nexport type StreamChunkData = {\n  type: string;\n  id?: string;\n  delta?: string;\n  text?: string;\n  mediaType?: string;\n  url?: string;\n  sourceId?: string;\n  title?: string;\n  filename?: string;\n  toolCallId?: string;\n  toolName?: string;\n  input?: unknown;\n  inputTextDelta?: string;\n  output?: unknown;\n  state?: string;\n  errorText?: string;\n  /** When true, the output is preliminary (may be updated by a later chunk) */\n  preliminary?: boolean;\n  /** Approval ID for tools with needsApproval */\n  approvalId?: string;\n  /** Optional framework-specific metadata for the approval request. */\n  approvalDescriptor?: unknown;\n  providerMetadata?: Record<string, unknown>;\n  /** Whether the tool was executed by the provider (e.g. Gemini code execution) */\n  providerExecuted?: boolean;\n  /** Payload for data-* parts (developer-defined typed JSON) */\n  data?: unknown;\n  /** When true, data parts are ephemeral and not persisted to message.parts */\n  transient?: boolean;\n  /** Message ID assigned by the server at stream start */\n  messageId?: string;\n  /** Per-message metadata attached by start/finish/message-metadata chunks */\n  messageMetadata?: unknown;\n  [key: string]: unknown;\n};\n\n/** Whether a value is a plain (non-array, non-null) object. */\nfunction isPlainObject(value: unknown): value is Record<string, unknown> {\n  return value !== null && typeof value === \"object\" && !Array.isArray(value);\n}\n\n/**\n * Coerce a tool part's `input` into a provider-acceptable object.\n *\n * The Anthropic Messages API requires `tool_use.input` to be a JSON **object** —\n * `null`, `undefined`, `\"\"`, a raw string, **or an array** are all rejected with\n * `tool_use.input: Input should be an object` (verified empirically against the\n * live API: `{}` → 200, but `\"\"`, `[]`, and `[{...}]` all → 400). A streamed\n * tool call that finishes with no `input_json_delta` events (the model called\n * the tool with no args), or whose input surfaces as a stringified JSON blob,\n * can persist one of these shapes — and because it lives in durable storage, the\n * session is then wedged across reconnects, redeploys, and DO evictions.\n * Enforcing the invariant at the write boundary (and as a read-side repair\n * backstop) keeps the transcript valid.\n *\n * - A plain (non-array) object is returned untouched (`changed: false`).\n * - A string that parses to a plain object is parsed.\n * - Everything else (`null`, `undefined`, `\"\"`, arrays, primitives, non-object\n *   or unparseable JSON) collapses to `{}`.\n */\nexport function normalizeToolInput(raw: unknown): {\n  input: unknown;\n  changed: boolean;\n} {\n  if (isPlainObject(raw)) return { input: raw, changed: false };\n  if (typeof raw === \"string\" && raw.trim().startsWith(\"{\")) {\n    try {\n      const parsed: unknown = JSON.parse(raw);\n      if (isPlainObject(parsed)) return { input: parsed, changed: true };\n    } catch {\n      // Unparseable / partial JSON — fall through to the empty-object default.\n    }\n  }\n  return { input: {}, changed: true };\n}\n\n/**\n * Applies a stream chunk to a mutable parts array, building up the message\n * incrementally. Returns true if the chunk was handled, false if it was\n * an unrecognized type (caller may handle it with additional logic).\n *\n * Handles all common chunk types that both server and client need:\n * - text-start / text-delta / text-end\n * - reasoning-start / reasoning-delta / reasoning-end\n * - file\n * - source-url / source-document\n * - tool-input-start / tool-input-delta / tool-input-available / tool-input-error\n * - tool-output-available / tool-output-error\n * - step-start (aliased from start-step)\n * - data-* (developer-defined typed JSON blobs)\n *\n * @param parts - The mutable parts array to update\n * @param chunk - The parsed stream chunk data\n * @returns true if handled, false if the chunk type is not recognized\n */\nexport function applyChunkToParts(\n  parts: MessagePart[],\n  chunk: StreamChunkData\n): boolean {\n  switch (chunk.type) {\n    case \"text-start\": {\n      parts.push({\n        type: \"text\",\n        text: \"\",\n        state: \"streaming\"\n      } as MessagePart);\n      return true;\n    }\n\n    case \"text-delta\": {\n      const lastTextPart = findLastPartByType(parts, \"text\");\n      if (lastTextPart && lastTextPart.type === \"text\") {\n        (lastTextPart as { text: string }).text += chunk.delta ?? \"\";\n      } else {\n        // No text-start received — create a new text part (stream resumption fallback)\n        parts.push({\n          type: \"text\",\n          text: chunk.delta ?? \"\",\n          state: \"streaming\"\n        } as MessagePart);\n      }\n      return true;\n    }\n\n    case \"text-end\": {\n      const lastTextPart = findLastPartByType(parts, \"text\");\n      if (lastTextPart && \"state\" in lastTextPart) {\n        (lastTextPart as { state: string }).state = \"done\";\n      }\n      return true;\n    }\n\n    case \"reasoning-start\": {\n      parts.push({\n        type: \"reasoning\",\n        text: \"\",\n        state: \"streaming\"\n      } as MessagePart);\n      return true;\n    }\n\n    case \"reasoning-delta\": {\n      const lastReasoningPart = findLastPartByType(parts, \"reasoning\");\n      if (lastReasoningPart && lastReasoningPart.type === \"reasoning\") {\n        (lastReasoningPart as { text: string }).text += chunk.delta ?? \"\";\n        mergeProviderMetadata(lastReasoningPart, chunk.providerMetadata);\n      } else {\n        // No reasoning-start received — create a new reasoning part (stream resumption fallback)\n        parts.push({\n          type: \"reasoning\",\n          text: chunk.delta ?? \"\",\n          state: \"streaming\",\n          ...(chunk.providerMetadata != null\n            ? { providerMetadata: chunk.providerMetadata }\n            : {})\n        } as MessagePart);\n      }\n      return true;\n    }\n\n    case \"reasoning-end\": {\n      const lastReasoningPart = findLastPartByType(parts, \"reasoning\");\n      if (lastReasoningPart && \"state\" in lastReasoningPart) {\n        (lastReasoningPart as { state: string }).state = \"done\";\n        mergeProviderMetadata(lastReasoningPart, chunk.providerMetadata);\n      }\n      return true;\n    }\n\n    case \"file\": {\n      parts.push({\n        type: \"file\",\n        mediaType: chunk.mediaType,\n        url: chunk.url\n      } as MessagePart);\n      return true;\n    }\n\n    case \"source-url\": {\n      parts.push({\n        type: \"source-url\",\n        sourceId: chunk.sourceId,\n        url: chunk.url,\n        title: chunk.title,\n        providerMetadata: chunk.providerMetadata\n      } as MessagePart);\n      return true;\n    }\n\n    case \"source-document\": {\n      parts.push({\n        type: \"source-document\",\n        sourceId: chunk.sourceId,\n        mediaType: chunk.mediaType,\n        title: chunk.title,\n        filename: chunk.filename,\n        providerMetadata: chunk.providerMetadata\n      } as MessagePart);\n      return true;\n    }\n\n    case \"tool-input-start\": {\n      // Idempotent against an existing tool part with the same toolCallId.\n      // Some providers (notably the OpenAI Responses API) replay prior\n      // tool calls in continuation streams as a fresh `tool-input-start`\n      // → `tool-input-delta` → `tool-input-available` →\n      // `tool-output-available` sequence carrying the original toolCallId\n      // and original output. Without this guard a replay would push a\n      // duplicate part into the streaming message *and* clobber the\n      // original part's state when the AI SDK's mutate-in-place\n      // `updateToolPart` processes the replay on the client (issue #1404).\n      // A model that genuinely wants a fresh tool call always emits a\n      // new toolCallId, so an existing match is never a legitimate\n      // \"start over\".\n      const existing = findToolPartByCallId(parts, chunk.toolCallId);\n      if (existing) {\n        return true;\n      }\n      parts.push({\n        type: `tool-${chunk.toolName}`,\n        toolCallId: chunk.toolCallId,\n        toolName: chunk.toolName,\n        state: \"input-streaming\",\n        input: undefined,\n        ...(chunk.providerExecuted != null\n          ? { providerExecuted: chunk.providerExecuted }\n          : {}),\n        ...(chunk.providerMetadata != null\n          ? { callProviderMetadata: chunk.providerMetadata }\n          : {}),\n        ...(chunk.title != null ? { title: chunk.title } : {})\n      } as MessagePart);\n      return true;\n    }\n\n    case \"tool-input-delta\": {\n      // Only mutate input while the tool is still actively input-streaming.\n      // Deltas arriving after the tool has already advanced (input-available\n      // or any terminal state) are provider replay and must not regress\n      // a fully-formed input back to a partial one.\n      const toolPart = findToolPartByCallId(parts, chunk.toolCallId);\n      if (\n        toolPart &&\n        (toolPart as Record<string, unknown>).state === \"input-streaming\"\n      ) {\n        (toolPart as Record<string, unknown>).input = chunk.input;\n      }\n      return true;\n    }\n\n    case \"tool-input-available\": {\n      const existing = findToolPartByCallId(parts, chunk.toolCallId);\n      if (existing) {\n        const p = existing as Record<string, unknown>;\n        // Only advance from the streaming-input phase. Once the tool is\n        // already at input-available or any terminal state\n        // (output-available, output-error, output-denied,\n        // approval-requested, approval-responded), this chunk is a\n        // provider replay and must not regress state or overwrite a\n        // resolved input/output. See the comment on tool-input-start.\n        if (p.state === \"input-streaming\") {\n          p.state = \"input-available\";\n          p.input = normalizeToolInput(chunk.input).input;\n          if (chunk.providerExecuted != null) {\n            p.providerExecuted = chunk.providerExecuted;\n          }\n          if (chunk.providerMetadata != null) {\n            p.callProviderMetadata = chunk.providerMetadata;\n          }\n          if (chunk.title != null) {\n            p.title = chunk.title;\n          }\n        }\n        return true;\n      }\n      parts.push({\n        type: `tool-${chunk.toolName}`,\n        toolCallId: chunk.toolCallId,\n        toolName: chunk.toolName,\n        state: \"input-available\",\n        input: normalizeToolInput(chunk.input).input,\n        ...(chunk.providerExecuted != null\n          ? { providerExecuted: chunk.providerExecuted }\n          : {}),\n        ...(chunk.providerMetadata != null\n          ? { callProviderMetadata: chunk.providerMetadata }\n          : {}),\n        ...(chunk.title != null ? { title: chunk.title } : {})\n      } as MessagePart);\n      return true;\n    }\n\n    case \"tool-input-error\": {\n      const existing = findToolPartByCallId(parts, chunk.toolCallId);\n      if (existing) {\n        const p = existing as Record<string, unknown>;\n        // First-write-wins: a tool that's already terminal must not be\n        // regressed (or re-decided as an error) by a later chunk. A\n        // tool-input-error here is either provider replay or a confused\n        // upstream — preserve the existing terminal state.\n        if (\n          p.state === \"output-available\" ||\n          p.state === \"output-error\" ||\n          p.state === \"output-denied\"\n        ) {\n          return true;\n        }\n        p.state = \"output-error\";\n        p.errorText = chunk.errorText;\n        p.input = normalizeToolInput(chunk.input).input;\n        if (chunk.providerExecuted != null) {\n          p.providerExecuted = chunk.providerExecuted;\n        }\n        if (chunk.providerMetadata != null) {\n          p.callProviderMetadata = chunk.providerMetadata;\n        }\n      } else {\n        parts.push({\n          type: `tool-${chunk.toolName}`,\n          toolCallId: chunk.toolCallId,\n          toolName: chunk.toolName,\n          state: \"output-error\",\n          input: normalizeToolInput(chunk.input).input,\n          errorText: chunk.errorText,\n          ...(chunk.providerExecuted != null\n            ? { providerExecuted: chunk.providerExecuted }\n            : {}),\n          ...(chunk.providerMetadata != null\n            ? { callProviderMetadata: chunk.providerMetadata }\n            : {})\n        } as MessagePart);\n      }\n      return true;\n    }\n\n    case \"tool-approval-request\": {\n      const toolPart = findToolPartByCallId(parts, chunk.toolCallId);\n      if (toolPart) {\n        const p = toolPart as Record<string, unknown>;\n        // First-write-wins: a continuation can replay the prior tool\n        // round-trip and re-emit `tool-approval-request`. Never regress a part\n        // the user has already responded to (`approval-responded`) or that has\n        // otherwise settled — that would silently discard the approval\n        // decision. Matches the guards on the `tool-input-*` /\n        // `tool-output-denied` handlers.\n        if (\n          p.state === \"approval-responded\" ||\n          p.state === \"output-available\" ||\n          p.state === \"output-error\" ||\n          p.state === \"output-denied\"\n        ) {\n          return true;\n        }\n        p.state = \"approval-requested\";\n        p.approval = {\n          id: chunk.approvalId,\n          ...(chunk.approvalDescriptor !== undefined && {\n            descriptor: chunk.approvalDescriptor\n          })\n        };\n      }\n      return true;\n    }\n\n    case \"tool-output-denied\": {\n      const toolPart = findToolPartByCallId(parts, chunk.toolCallId);\n      if (toolPart) {\n        const p = toolPart as Record<string, unknown>;\n        // First-write-wins: a tool that's already terminal must not be\n        // regressed by a later/replayed chunk. Also preserve an\n        // `approval-responded` (user-approved) part — a continuation that\n        // re-validates the transcript can emit `tool-output-denied` for an\n        // approval the SDK deems unneeded (e.g. a tool without\n        // `needsApproval`); that must not silently flip a granted approval\n        // into a denial.\n        if (\n          p.state === \"output-available\" ||\n          p.state === \"output-error\" ||\n          p.state === \"output-denied\" ||\n          p.state === \"approval-responded\"\n        ) {\n          return true;\n        }\n        p.state = \"output-denied\";\n      }\n      return true;\n    }\n\n    case \"tool-output-available\": {\n      const toolPart = findToolPartByCallId(parts, chunk.toolCallId);\n      if (toolPart) {\n        const p = toolPart as Record<string, unknown>;\n        p.state = \"output-available\";\n        p.output = chunk.output;\n        if (chunk.preliminary !== undefined) {\n          p.preliminary = chunk.preliminary;\n        }\n      }\n      return true;\n    }\n\n    case \"tool-output-error\": {\n      const toolPart = findToolPartByCallId(parts, chunk.toolCallId);\n      if (toolPart) {\n        const p = toolPart as Record<string, unknown>;\n        p.state = \"output-error\";\n        p.errorText = chunk.errorText;\n      }\n      return true;\n    }\n\n    // Both \"step-start\" (client convention) and \"start-step\" (server convention)\n    case \"step-start\":\n    case \"start-step\": {\n      parts.push({ type: \"step-start\" } as MessagePart);\n      return true;\n    }\n\n    default: {\n      // https://ai-sdk.dev/docs/ai-sdk-ui/streaming-data\n      if (chunk.type.startsWith(\"data-\")) {\n        // Transient parts are ephemeral — the AI SDK client fires an onData\n        // callback instead of adding them to message.parts. On the server we\n        // still broadcast them (so connected clients see them in real time)\n        // but skip persisting them into the stored message parts.\n        if (chunk.transient) {\n          return true;\n        }\n\n        // Reconciliation: if a part with the same type AND id already exists,\n        // update its data in-place instead of appending a duplicate.\n        if (chunk.id != null) {\n          const existing = findDataPartByTypeAndId(parts, chunk.type, chunk.id);\n          if (existing) {\n            (existing as Record<string, unknown>).data = chunk.data;\n            return true;\n          }\n        }\n\n        // Append new data parts to the array directly.\n        // Note: `chunk.data` should always be provided — if omitted, the\n        // persisted part will have `data: undefined` which JSON.stringify\n        // drops, so the part will have no `data` field on reload.\n        // The cast is needed because UIMessage[\"parts\"] doesn't include\n        // data-* types in its union because they're an open extension point.\n        parts.push({\n          type: chunk.type,\n          ...(chunk.id != null && { id: chunk.id }),\n          data: chunk.data\n        } as MessagePart);\n        return true;\n      }\n\n      return false;\n    }\n  }\n}\n\n/**\n * Returns true if `chunk` would be a no-op replay against the already-known\n * `parts` — i.e. some upstream is re-emitting events for a tool call that\n * the message has already advanced past.\n *\n * Used by stream broadcasters to suppress re-broadcasting these chunks to\n * connected clients. AI SDK v6's `updateToolPart` mutates an existing tool\n * part in place when a chunk arrives with a matching `toolCallId`, so a\n * replayed `tool-input-start` would clobber an `output-available` part back\n * to `input-streaming` on the client (issue #1404).\n *\n * Only returns true when re-broadcasting would *visibly regress* state on\n * a v6 client. Safe-by-construction chunk types (e.g. `tool-output-available`\n * carrying the same output the part already has) return false.\n *\n * Conditions:\n * - `tool-input-start` for a `toolCallId` that already exists in `parts`.\n * - `tool-input-delta` for a `toolCallId` whose existing part is no longer\n *   `input-streaming`.\n * - `tool-input-available` for a `toolCallId` whose existing part is no\n *   longer `input-streaming` (i.e. has already advanced to `input-available`\n *   or any terminal state).\n * - `tool-output-denied` for a `toolCallId` whose existing part is already\n *   settled (`output-available` / `output-error` / `output-denied`) or\n *   user-approved (`approval-responded`). A continuation that re-validates\n *   the transcript can re-emit a denial for an approval the SDK now deems\n *   unneeded; `applyChunkToParts` already drops it server-side, and this stops\n *   it reaching the client (where the in-place `updateToolPart` would flip the\n *   part to `output-denied`) and the replay buffer. Mirrors the\n *   first-write-wins guard in `applyChunkToParts`.\n * - `tool-approval-request` for a `toolCallId` whose existing part is already\n *   `approval-responded` or settled. A continuation replaying a prior tool\n *   round-trip can re-emit the approval request; left unfiltered it would\n *   revert an already-approved tool back to `approval-requested` on the client\n *   (re-showing Approve/Reject) and replay that regression on reconnect. Same\n *   pattern and rationale as `tool-output-denied`.\n */\nexport function isReplayChunk(\n  parts: MessagePart[],\n  chunk: StreamChunkData\n): boolean {\n  if (\n    chunk.type === \"tool-output-denied\" ||\n    chunk.type === \"tool-approval-request\"\n  ) {\n    if (!chunk.toolCallId) return false;\n    const existing = findToolPartByCallId(parts, chunk.toolCallId);\n    if (!existing) return false;\n    const state = (existing as Record<string, unknown>).state;\n    return (\n      state === \"output-available\" ||\n      state === \"output-error\" ||\n      state === \"output-denied\" ||\n      state === \"approval-responded\"\n    );\n  }\n\n  if (\n    chunk.type !== \"tool-input-start\" &&\n    chunk.type !== \"tool-input-delta\" &&\n    chunk.type !== \"tool-input-available\"\n  ) {\n    return false;\n  }\n  if (!chunk.toolCallId) return false;\n  const existing = findToolPartByCallId(parts, chunk.toolCallId);\n  if (!existing) return false;\n  if (chunk.type === \"tool-input-start\") return true;\n  const state = (existing as Record<string, unknown>).state;\n  return state !== \"input-streaming\";\n}\n\n/**\n * Finds the last part in the array matching the given type.\n * Searches from the end for efficiency (the part we want is usually recent).\n */\nfunction findLastPartByType(\n  parts: MessagePart[],\n  type: string\n): MessagePart | undefined {\n  for (let i = parts.length - 1; i >= 0; i--) {\n    if (parts[i].type === type) {\n      return parts[i];\n    }\n  }\n  return undefined;\n}\n\n/**\n * Finds a tool part by its toolCallId.\n * Searches from the end since the tool part is usually recent.\n */\nfunction findToolPartByCallId(\n  parts: MessagePart[],\n  toolCallId: string | undefined\n): MessagePart | undefined {\n  if (!toolCallId) return undefined;\n  for (let i = parts.length - 1; i >= 0; i--) {\n    const p = parts[i];\n    if (\"toolCallId\" in p && p.toolCallId === toolCallId) {\n      return p;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Shallow-merges providerMetadata from a chunk onto an existing part.\n * Preserves any metadata already on the part (e.g. from earlier deltas)\n * while adding new keys from the chunk. This is critical for providers\n * like Anthropic that emit the thinking block signature on reasoning-end.\n */\nfunction mergeProviderMetadata(\n  part: MessagePart,\n  metadata: Record<string, unknown> | undefined\n): void {\n  if (metadata == null) return;\n  const p = part as Record<string, unknown>;\n  p.providerMetadata = {\n    ...(p.providerMetadata as Record<string, unknown> | undefined),\n    ...metadata\n  };\n}\n\n/**\n * Finds a data part by its type and id for reconciliation.\n * Data parts use type+id as a composite key so when the same combination\n * is seen again, the existing part's data is updated in-place.\n */\nfunction findDataPartByTypeAndId(\n  parts: MessagePart[],\n  type: string,\n  id: string\n): MessagePart | undefined {\n  for (let i = parts.length - 1; i >= 0; i--) {\n    const p = parts[i];\n    if (p.type === type && \"id\" in p && (p as { id: string }).id === id) {\n      return p;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Rebuild the partial text + parts of an interrupted assistant turn from its\n * stored resumable-stream chunks. Replays each chunk body through\n * {@link applyChunkToParts}; malformed bodies are skipped. Shared by\n * `AIChatAgent` and `Think`, which read the chunks from their\n * `ResumableStream` (`getStreamChunks`) and pass them in.\n *\n * `@internal`\n */\nexport function getPartialStreamText(chunks: ReadonlyArray<{ body: string }>): {\n  text: string;\n  parts: MessagePart[];\n} {\n  const parts: MessagePart[] = [];\n\n  for (const chunk of chunks) {\n    try {\n      const data = JSON.parse(chunk.body);\n      applyChunkToParts(parts, data);\n    } catch {\n      // Skip malformed chunk bodies\n    }\n  }\n\n  const text = parts\n    .filter(\n      (p): p is MessagePart & { type: \"text\"; text: string } =>\n        p.type === \"text\" && \"text\" in p\n    )\n    .map((p) => p.text)\n    .join(\"\");\n\n  return { text, parts };\n}\n"],"mappings":"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"}

package/dist/observability/index.d.ts

@@ -5,7 +5,7 @@ import {
   o as subscribe,
   r as ObservabilityEvent,
   t as ChannelEventMap
-} from "../index-B7IbEeze.js";
+} from "../index-CcbnKkNh.js";
 export {
   ChannelEventMap,
   Observability,

package/dist/observability/index.js

@@ -27,7 +27,8 @@ const channels = {
 	lifecycle: channel("agents:lifecycle"),
 	workflow: channel("agents:workflow"),
 	mcp: channel("agents:mcp"),
-	email: channel("agents:email")
+	email: channel("agents:email"),
+	channel: channel("agents:channel")
 };
 /**
 * Channel keys whose diagnostics channel name differs from `agents:${key}`.
@@ -46,10 +47,11 @@ function getChannel(type) {
 	if (type.startsWith("chat:")) return channels.chat;
 	if (type.startsWith("agent_tool:")) return channels.agentTool;
 	if (type.startsWith("schedule:") || type.startsWith("queue:")) return channels.schedule;
-	if (type.startsWith("message:") || type.startsWith("tool:") || type.startsWith("submission:")) return channels.message;
+	if (type.startsWith("message:") || type.startsWith("tool:") || type.startsWith("submission:") || type.startsWith("action:")) return channels.message;
 	if (type === "rpc" || type.startsWith("rpc:")) return channels.rpc;
 	if (type.startsWith("state:")) return channels.state;
 	if (type.startsWith("email:")) return channels.email;
+	if (type.startsWith("channel:") || type.startsWith("notice:")) return channels.channel;
 	return channels.lifecycle;
 }
 /**

package/dist/observability/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["dcUnsubscribe"],"sources":["../../src/observability/index.ts"],"sourcesContent":["import {\n  channel,\n  subscribe as dcSubscribe,\n  unsubscribe as dcUnsubscribe,\n  type Channel\n} from \"node:diagnostics_channel\";\nimport type { AgentObservabilityEvent } from \"./agent\";\nimport type { MCPObservabilityEvent } from \"./mcp\";\n\n/**\n * Union of all observability event types from different domains\n */\nexport type ObservabilityEvent =\n  | AgentObservabilityEvent\n  | MCPObservabilityEvent;\n\nexport interface Observability {\n  /**\n   * Emit an event for the Agent's observability implementation to handle.\n   * @param event - The event to emit\n   */\n  emit(event: ObservabilityEvent): void;\n}\n\n/**\n * Diagnostics channels for agent observability.\n *\n * Events are published to named channels using the Node.js diagnostics_channel API.\n * By default, publishing to a channel with no subscribers is a no-op (zero overhead).\n *\n * To observe events, subscribe to the channels you care about:\n * ```ts\n * import { subscribe } from \"node:diagnostics_channel\";\n * subscribe(\"agents:rpc\", (event) => console.log(event));\n * ```\n *\n * In production, all published messages are automatically forwarded to\n * Tail Workers via `event.diagnosticsChannelEvents` — no subscription needed.\n */\nexport const channels = {\n  state: channel(\"agents:state\"),\n  rpc: channel(\"agents:rpc\"),\n  message: channel(\"agents:message\"),\n  chat: channel(\"agents:chat\"),\n  transcript: channel(\"agents:transcript\"),\n  fiber: channel(\"agents:fiber\"),\n  agentTool: channel(\"agents:agent_tool\"),\n  schedule: channel(\"agents:schedule\"),\n  lifecycle: channel(\"agents:lifecycle\"),\n  workflow: channel(\"agents:workflow\"),\n  mcp: channel(\"agents:mcp\"),\n  email: channel(\"agents:email\")\n} as const;\n\n/**\n * Channel keys whose diagnostics channel name differs from `agents:${key}`.\n * Keep this in sync with {@link channels} for any camelCase key that maps to a\n * snake_case diagnostics channel.\n */\nconst CHANNEL_DIAGNOSTIC_NAME_OVERRIDES: Partial<Record<string, string>> = {\n  agentTool: \"agents:agent_tool\"\n};\n\n/**\n * Map event type prefixes to their diagnostics channel.\n */\nfunction getChannel(type: string): Channel {\n  if (type.startsWith(\"mcp:\")) return channels.mcp;\n  if (type.startsWith(\"workflow:\")) return channels.workflow;\n  if (type.startsWith(\"fiber:\")) return channels.fiber;\n  if (type.startsWith(\"transcript:\") || type.startsWith(\"chat:transcript:\"))\n    return channels.transcript;\n  if (type.startsWith(\"chat:\")) return channels.chat;\n  if (type.startsWith(\"agent_tool:\")) return channels.agentTool;\n  if (type.startsWith(\"schedule:\") || type.startsWith(\"queue:\"))\n    return channels.schedule;\n  if (\n    type.startsWith(\"message:\") ||\n    type.startsWith(\"tool:\") ||\n    type.startsWith(\"submission:\")\n  )\n    return channels.message;\n  if (type === \"rpc\" || type.startsWith(\"rpc:\")) return channels.rpc;\n  if (type.startsWith(\"state:\")) return channels.state;\n  if (type.startsWith(\"email:\")) return channels.email;\n  // connect, disconnect, destroy\n  return channels.lifecycle;\n}\n\n/**\n * The default observability implementation.\n *\n * Publishes events to diagnostics_channel. Events are silent unless\n * a subscriber is registered or a Tail Worker is attached.\n */\nexport const genericObservability: Observability = {\n  emit(event) {\n    getChannel(event.type).publish(event);\n  }\n};\n\n/**\n * Maps each channel key to the observability events it carries.\n */\nexport type ChannelEventMap = {\n  state: Extract<ObservabilityEvent, { type: `state:${string}` }>;\n  rpc: Extract<ObservabilityEvent, { type: \"rpc\" | `rpc:${string}` }>;\n  message: Extract<\n    ObservabilityEvent,\n    { type: `message:${string}` | `tool:${string}` | `submission:${string}` }\n  >;\n  chat: Exclude<\n    Extract<ObservabilityEvent, { type: `chat:${string}` }>,\n    { type: `chat:transcript:${string}` }\n  >;\n  transcript: Extract<\n    ObservabilityEvent,\n    { type: `transcript:${string}` | `chat:transcript:${string}` }\n  >;\n  fiber: Extract<ObservabilityEvent, { type: `fiber:${string}` }>;\n  agentTool: Extract<ObservabilityEvent, { type: `agent_tool:${string}` }>;\n  schedule: Extract<\n    ObservabilityEvent,\n    { type: `schedule:${string}` | `queue:${string}` }\n  >;\n  lifecycle: Extract<\n    ObservabilityEvent,\n    { type: \"connect\" | \"disconnect\" | \"destroy\" }\n  >;\n  workflow: Extract<ObservabilityEvent, { type: `workflow:${string}` }>;\n  mcp: Extract<ObservabilityEvent, { type: `mcp:${string}` }>;\n  email: Extract<ObservabilityEvent, { type: `email:${string}` }>;\n};\n\n/**\n * Subscribe to a typed observability channel.\n *\n * ```ts\n * import { subscribe } from \"agents/observability\";\n *\n * const unsub = subscribe(\"rpc\", (event) => {\n *   console.log(event.payload.method); // fully typed\n * });\n * ```\n *\n * @returns A function that unsubscribes the callback.\n */\nexport function subscribe<K extends keyof ChannelEventMap>(\n  channelKey: K,\n  callback: (event: ChannelEventMap[K]) => void\n): () => void {\n  const name =\n    CHANNEL_DIAGNOSTIC_NAME_OVERRIDES[channelKey] ?? `agents:${channelKey}`;\n  const handler = (message: unknown, _name: string | symbol) =>\n    callback(message as ChannelEventMap[K]);\n  dcSubscribe(name, handler);\n  return () => dcUnsubscribe(name, handler);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAuCA,MAAa,WAAW;CACtB,OAAO,QAAQ,cAAc;CAC7B,KAAK,QAAQ,YAAY;CACzB,SAAS,QAAQ,gBAAgB;CACjC,MAAM,QAAQ,aAAa;CAC3B,YAAY,QAAQ,mBAAmB;CACvC,OAAO,QAAQ,cAAc;CAC7B,WAAW,QAAQ,mBAAmB;CACtC,UAAU,QAAQ,iBAAiB;CACnC,WAAW,QAAQ,kBAAkB;CACrC,UAAU,QAAQ,iBAAiB;CACnC,KAAK,QAAQ,YAAY;CACzB,OAAO,QAAQ,cAAc;AAC/B;;;;;;AAOA,MAAM,oCAAqE,EACzE,WAAW,oBACb;;;;AAKA,SAAS,WAAW,MAAuB;CACzC,IAAI,KAAK,WAAW,MAAM,GAAG,OAAO,SAAS;CAC7C,IAAI,KAAK,WAAW,WAAW,GAAG,OAAO,SAAS;CAClD,IAAI,KAAK,WAAW,QAAQ,GAAG,OAAO,SAAS;CAC/C,IAAI,KAAK,WAAW,aAAa,KAAK,KAAK,WAAW,kBAAkB,GACtE,OAAO,SAAS;CAClB,IAAI,KAAK,WAAW,OAAO,GAAG,OAAO,SAAS;CAC9C,IAAI,KAAK,WAAW,aAAa,GAAG,OAAO,SAAS;CACpD,IAAI,KAAK,WAAW,WAAW,KAAK,KAAK,WAAW,QAAQ,GAC1D,OAAO,SAAS;CAClB,IACE,KAAK,WAAW,UAAU,KAC1B,KAAK,WAAW,OAAO,KACvB,KAAK,WAAW,aAAa,GAE7B,OAAO,SAAS;CAClB,IAAI,SAAS,SAAS,KAAK,WAAW,MAAM,GAAG,OAAO,SAAS;CAC/D,IAAI,KAAK,WAAW,QAAQ,GAAG,OAAO,SAAS;CAC/C,IAAI,KAAK,WAAW,QAAQ,GAAG,OAAO,SAAS;CAE/C,OAAO,SAAS;AAClB;;;;;;;AAQA,MAAa,uBAAsC,EACjD,KAAK,OAAO;CACV,WAAW,MAAM,IAAI,CAAC,CAAC,QAAQ,KAAK;AACtC,EACF;;;;;;;;;;;;;;AAgDA,SAAgB,UACd,YACA,UACY;CACZ,MAAM,OACJ,kCAAkC,eAAe,UAAU;CAC7D,MAAM,WAAW,SAAkB,UACjC,SAAS,OAA6B;CACxC,YAAY,MAAM,OAAO;CACzB,aAAaA,YAAc,MAAM,OAAO;AAC1C"}
+{"version":3,"file":"index.js","names":["dcUnsubscribe"],"sources":["../../src/observability/index.ts"],"sourcesContent":["import {\n  channel,\n  subscribe as dcSubscribe,\n  unsubscribe as dcUnsubscribe,\n  type Channel\n} from \"node:diagnostics_channel\";\nimport type { AgentObservabilityEvent } from \"./agent\";\nimport type { MCPObservabilityEvent } from \"./mcp\";\n\n/**\n * Union of all observability event types from different domains\n */\nexport type ObservabilityEvent =\n  | AgentObservabilityEvent\n  | MCPObservabilityEvent;\n\nexport interface Observability {\n  /**\n   * Emit an event for the Agent's observability implementation to handle.\n   * @param event - The event to emit\n   */\n  emit(event: ObservabilityEvent): void;\n}\n\n/**\n * Diagnostics channels for agent observability.\n *\n * Events are published to named channels using the Node.js diagnostics_channel API.\n * By default, publishing to a channel with no subscribers is a no-op (zero overhead).\n *\n * To observe events, subscribe to the channels you care about:\n * ```ts\n * import { subscribe } from \"node:diagnostics_channel\";\n * subscribe(\"agents:rpc\", (event) => console.log(event));\n * ```\n *\n * In production, all published messages are automatically forwarded to\n * Tail Workers via `event.diagnosticsChannelEvents` — no subscription needed.\n */\nexport const channels = {\n  state: channel(\"agents:state\"),\n  rpc: channel(\"agents:rpc\"),\n  message: channel(\"agents:message\"),\n  chat: channel(\"agents:chat\"),\n  transcript: channel(\"agents:transcript\"),\n  fiber: channel(\"agents:fiber\"),\n  agentTool: channel(\"agents:agent_tool\"),\n  schedule: channel(\"agents:schedule\"),\n  lifecycle: channel(\"agents:lifecycle\"),\n  workflow: channel(\"agents:workflow\"),\n  mcp: channel(\"agents:mcp\"),\n  email: channel(\"agents:email\"),\n  channel: channel(\"agents:channel\")\n} as const;\n\n/**\n * Channel keys whose diagnostics channel name differs from `agents:${key}`.\n * Keep this in sync with {@link channels} for any camelCase key that maps to a\n * snake_case diagnostics channel.\n */\nconst CHANNEL_DIAGNOSTIC_NAME_OVERRIDES: Partial<Record<string, string>> = {\n  agentTool: \"agents:agent_tool\"\n};\n\n/**\n * Map event type prefixes to their diagnostics channel.\n */\nfunction getChannel(type: string): Channel {\n  if (type.startsWith(\"mcp:\")) return channels.mcp;\n  if (type.startsWith(\"workflow:\")) return channels.workflow;\n  if (type.startsWith(\"fiber:\")) return channels.fiber;\n  if (type.startsWith(\"transcript:\") || type.startsWith(\"chat:transcript:\"))\n    return channels.transcript;\n  if (type.startsWith(\"chat:\")) return channels.chat;\n  if (type.startsWith(\"agent_tool:\")) return channels.agentTool;\n  if (type.startsWith(\"schedule:\") || type.startsWith(\"queue:\"))\n    return channels.schedule;\n  if (\n    type.startsWith(\"message:\") ||\n    type.startsWith(\"tool:\") ||\n    type.startsWith(\"submission:\") ||\n    type.startsWith(\"action:\")\n  )\n    return channels.message;\n  if (type === \"rpc\" || type.startsWith(\"rpc:\")) return channels.rpc;\n  if (type.startsWith(\"state:\")) return channels.state;\n  if (type.startsWith(\"email:\")) return channels.email;\n  if (type.startsWith(\"channel:\") || type.startsWith(\"notice:\"))\n    return channels.channel;\n  // connect, disconnect, destroy\n  return channels.lifecycle;\n}\n\n/**\n * The default observability implementation.\n *\n * Publishes events to diagnostics_channel. Events are silent unless\n * a subscriber is registered or a Tail Worker is attached.\n */\nexport const genericObservability: Observability = {\n  emit(event) {\n    getChannel(event.type).publish(event);\n  }\n};\n\n/**\n * Maps each channel key to the observability events it carries.\n */\nexport type ChannelEventMap = {\n  state: Extract<ObservabilityEvent, { type: `state:${string}` }>;\n  rpc: Extract<ObservabilityEvent, { type: \"rpc\" | `rpc:${string}` }>;\n  message: Extract<\n    ObservabilityEvent,\n    {\n      type:\n        | `message:${string}`\n        | `tool:${string}`\n        | `submission:${string}`\n        | `action:${string}`;\n    }\n  >;\n  chat: Exclude<\n    Extract<ObservabilityEvent, { type: `chat:${string}` }>,\n    { type: `chat:transcript:${string}` }\n  >;\n  transcript: Extract<\n    ObservabilityEvent,\n    { type: `transcript:${string}` | `chat:transcript:${string}` }\n  >;\n  fiber: Extract<ObservabilityEvent, { type: `fiber:${string}` }>;\n  agentTool: Extract<ObservabilityEvent, { type: `agent_tool:${string}` }>;\n  schedule: Extract<\n    ObservabilityEvent,\n    { type: `schedule:${string}` | `queue:${string}` }\n  >;\n  lifecycle: Extract<\n    ObservabilityEvent,\n    { type: \"connect\" | \"disconnect\" | \"destroy\" }\n  >;\n  workflow: Extract<ObservabilityEvent, { type: `workflow:${string}` }>;\n  mcp: Extract<ObservabilityEvent, { type: `mcp:${string}` }>;\n  email: Extract<ObservabilityEvent, { type: `email:${string}` }>;\n  channel: Extract<\n    ObservabilityEvent,\n    { type: `channel:${string}` | `notice:${string}` }\n  >;\n};\n\n/**\n * Subscribe to a typed observability channel.\n *\n * ```ts\n * import { subscribe } from \"agents/observability\";\n *\n * const unsub = subscribe(\"rpc\", (event) => {\n *   console.log(event.payload.method); // fully typed\n * });\n * ```\n *\n * @returns A function that unsubscribes the callback.\n */\nexport function subscribe<K extends keyof ChannelEventMap>(\n  channelKey: K,\n  callback: (event: ChannelEventMap[K]) => void\n): () => void {\n  const name =\n    CHANNEL_DIAGNOSTIC_NAME_OVERRIDES[channelKey] ?? `agents:${channelKey}`;\n  const handler = (message: unknown, _name: string | symbol) =>\n    callback(message as ChannelEventMap[K]);\n  dcSubscribe(name, handler);\n  return () => dcUnsubscribe(name, handler);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAuCA,MAAa,WAAW;CACtB,OAAO,QAAQ,cAAc;CAC7B,KAAK,QAAQ,YAAY;CACzB,SAAS,QAAQ,gBAAgB;CACjC,MAAM,QAAQ,aAAa;CAC3B,YAAY,QAAQ,mBAAmB;CACvC,OAAO,QAAQ,cAAc;CAC7B,WAAW,QAAQ,mBAAmB;CACtC,UAAU,QAAQ,iBAAiB;CACnC,WAAW,QAAQ,kBAAkB;CACrC,UAAU,QAAQ,iBAAiB;CACnC,KAAK,QAAQ,YAAY;CACzB,OAAO,QAAQ,cAAc;CAC7B,SAAS,QAAQ,gBAAgB;AACnC;;;;;;AAOA,MAAM,oCAAqE,EACzE,WAAW,oBACb;;;;AAKA,SAAS,WAAW,MAAuB;CACzC,IAAI,KAAK,WAAW,MAAM,GAAG,OAAO,SAAS;CAC7C,IAAI,KAAK,WAAW,WAAW,GAAG,OAAO,SAAS;CAClD,IAAI,KAAK,WAAW,QAAQ,GAAG,OAAO,SAAS;CAC/C,IAAI,KAAK,WAAW,aAAa,KAAK,KAAK,WAAW,kBAAkB,GACtE,OAAO,SAAS;CAClB,IAAI,KAAK,WAAW,OAAO,GAAG,OAAO,SAAS;CAC9C,IAAI,KAAK,WAAW,aAAa,GAAG,OAAO,SAAS;CACpD,IAAI,KAAK,WAAW,WAAW,KAAK,KAAK,WAAW,QAAQ,GAC1D,OAAO,SAAS;CAClB,IACE,KAAK,WAAW,UAAU,KAC1B,KAAK,WAAW,OAAO,KACvB,KAAK,WAAW,aAAa,KAC7B,KAAK,WAAW,SAAS,GAEzB,OAAO,SAAS;CAClB,IAAI,SAAS,SAAS,KAAK,WAAW,MAAM,GAAG,OAAO,SAAS;CAC/D,IAAI,KAAK,WAAW,QAAQ,GAAG,OAAO,SAAS;CAC/C,IAAI,KAAK,WAAW,QAAQ,GAAG,OAAO,SAAS;CAC/C,IAAI,KAAK,WAAW,UAAU,KAAK,KAAK,WAAW,SAAS,GAC1D,OAAO,SAAS;CAElB,OAAO,SAAS;AAClB;;;;;;;AAQA,MAAa,uBAAsC,EACjD,KAAK,OAAO;CACV,WAAW,MAAM,IAAI,CAAC,CAAC,QAAQ,KAAK;AACtC,EACF;;;;;;;;;;;;;;AA0DA,SAAgB,UACd,YACA,UACY;CACZ,MAAM,OACJ,kCAAkC,eAAe,UAAU;CAC7D,MAAM,WAAW,SAAkB,UACjC,SAAS,OAA6B;CACxC,YAAY,MAAM,OAAO;CACzB,aAAaA,YAAc,MAAM,OAAO;AAC1C"}

package/dist/react.d.ts

@@ -1,9 +1,11 @@
 import {
-  V as MCPServersState,
-  d as AgentToolRunState
-} from "./agent-tool-types-CTw3UJUP.js";
+  Y as MCPServersState,
+  _ as AgentToolRunState,
+  g as AgentToolRunPart
+} from "./agent-tool-types-Cd1TZPfB.js";
 import { ClientParameters } from "./serializable.js";
 import {
+  AgentConnectionError,
   AgentPromiseReturnType,
   AgentStub,
   CallOptions,
@@ -18,6 +20,9 @@ import { usePartySocket } from "partysocket/react";
 
 //#region src/react.d.ts
 type QueryObject = Record<string, string | null>;
+type TerminalReconnectOptions = {
+  shouldReconnectOnClose?: (event: CloseEvent) => boolean;
+};
 interface CacheEntry {
   promise: Promise<QueryObject>;
   expiresAt: number;
@@ -56,108 +61,110 @@ declare const _testUtils: {
 type UseAgentOptions<State = unknown> = Omit<
   Parameters<typeof usePartySocket>[0],
   "party" | "room" | "query"
-> & {
-  /** Name of the agent to connect to (ignored if basePath is set) */ agent: string /** Name of the specific Agent instance (ignored if basePath is set) */;
-  name?: string;
-  /**
-   * Full URL path - bypasses agent/name URL construction.
-   * When set, the client connects to this path directly.
-   * Server must handle routing manually (e.g., with getAgentByName + fetch).
-   * @example
-   * // Client connects to /user, server routes based on session
-   * useAgent({ agent: "UserAgent", basePath: "user" })
-   */
-  basePath?: string /** Query parameters - can be static object or async function */;
-  query?:
-    | QueryObject
-    | (() => Promise<QueryObject>) /** Dependencies for async query caching */;
-  queryDeps?: unknown[] /** Cache TTL in milliseconds for auth tokens/time-sensitive data */;
-  cacheTtl?: number /** Called when the Agent's state is updated */;
-  onStateUpdate?: (
-    state: State,
-    source: "server" | "client"
-  ) => void /** Called when a state update fails (e.g., connection is readonly) */;
-  onStateUpdateError?: (
-    error: string
-  ) => void /** Called when MCP server state is updated */;
-  onMcpUpdate?: (mcpServers: MCPServersState) => void;
-  /**
-   * Called when the server sends the agent's identity on connect.
-   * Useful when using basePath, as the actual instance name is determined server-side.
-   * @param name The actual agent instance name
-   * @param agent The agent class name (kebab-case)
-   */
-  onIdentity?: (name: string, agent: string) => void;
-  /**
-   * Called when identity changes on reconnect (different instance than before).
-   * If not provided and identity changes, a warning will be logged.
-   * @param oldName Previous instance name
-   * @param newName New instance name
-   * @param oldAgent Previous agent class name
-   * @param newAgent New agent class name
-   */
-  onIdentityChange?: (
-    oldName: string,
-    newName: string,
-    oldAgent: string,
-    newAgent: string
-  ) => void;
-  /**
-   * Additional path to append to the URL.
-   * Works with both standard routing and basePath.
-   * @example
-   * // With basePath: /user/settings
-   * { basePath: "user", path: "settings" }
-   * // Standard: /agents/my-agent/room/settings
-   * { agent: "MyAgent", name: "room", path: "settings" }
-   */
-  path?: string;
-  /**
-   * Connect to a sub-agent (facet) via its parent. Flat array,
-   * root-first. Each step addresses one parent↔child hop.
-   *
-   * The hook's returned `.agent` / `.name` report the **leaf**
-   * identity (the deepest entry in `sub`), so downstream hooks
-   * like `useAgentChat` see the child they actually talk to.
-   * `.path` exposes the full chain for observability, deep links,
-   * and reconnect keying.
-   *
-   * @example
-   * ```ts
-   * // Two-level nesting: Inbox (Alice) → Chat (abc)
-   * useAgent({
-   *   agent: "inbox", name: userId,
-   *   sub: [{ agent: "chat", name: chatId }]
-   * });
-   *
-   * // Three-level: tenant → inbox → chat
-   * useAgent({
-   *   agent: "tenant", name: tenantId,
-   *   sub: [
-   *     { agent: "inbox", name: userId },
-   *     { agent: "chat",  name: chatId }
-   *   ]
-   * });
-   * ```
-   *
-   * @experimental The API surface may change before stabilizing.
-   */
-  sub?: ReadonlyArray<{
-    agent: string;
-    name: string;
-  }>;
-  /**
-   * Default timeout (in milliseconds) applied to non-streaming `call()`s
-   * that don't pass an explicit `timeout`. Acts as a backstop so calls
-   * whose response is lost (e.g. the connection is replaced mid-flight)
-   * reject instead of hanging forever.
-   *
-   * Defaults to 30 000 ms. Set to `0` to disable the default timeout.
-   * Streaming calls never get a default timeout (long-lived streams are
-   * legitimate); pass an explicit `timeout` to bound them.
-   */
-  defaultCallTimeout?: number;
-};
+> &
+  TerminalReconnectOptions & {
+    /** Name of the agent to connect to (ignored if basePath is set) */ agent: string /** Name of the specific Agent instance (ignored if basePath is set) */;
+    name?: string;
+    /**
+     * Full URL path - bypasses agent/name URL construction.
+     * When set, the client connects to this path directly.
+     * Server must handle routing manually (e.g., with getAgentByName + fetch).
+     * @example
+     * // Client connects to /user, server routes based on session
+     * useAgent({ agent: "UserAgent", basePath: "user" })
+     */
+    basePath?: string /** Query parameters - can be static object or async function */;
+    query?:
+      | QueryObject
+      | (() => Promise<QueryObject>) /** Dependencies for async query caching */;
+    queryDeps?: unknown[] /** Cache TTL in milliseconds for auth tokens/time-sensitive data */;
+    cacheTtl?: number /** Called when the Agent's state is updated */;
+    onStateUpdate?: (
+      state: State,
+      source: "server" | "client"
+    ) => void /** Called when a state update fails (e.g., connection is readonly) */;
+    onStateUpdateError?: (
+      error: string
+    ) => void /** Called when MCP server state is updated */;
+    onMcpUpdate?: (mcpServers: MCPServersState) => void;
+    /**
+     * Called when the server sends the agent's identity on connect.
+     * Useful when using basePath, as the actual instance name is determined server-side.
+     * @param name The actual agent instance name
+     * @param agent The agent class name (kebab-case)
+     */
+    onIdentity?: (name: string, agent: string) => void;
+    /**
+     * Called when identity changes on reconnect (different instance than before).
+     * If not provided and identity changes, a warning will be logged.
+     * @param oldName Previous instance name
+     * @param newName New instance name
+     * @param oldAgent Previous agent class name
+     * @param newAgent New agent class name
+     */
+    onIdentityChange?: (
+      oldName: string,
+      newName: string,
+      oldAgent: string,
+      newAgent: string
+    ) => void;
+    /**
+     * Additional path to append to the URL.
+     * Works with both standard routing and basePath.
+     * @example
+     * // With basePath: /user/settings
+     * { basePath: "user", path: "settings" }
+     * // Standard: /agents/my-agent/room/settings
+     * { agent: "MyAgent", name: "room", path: "settings" }
+     */
+    path?: string;
+    /**
+     * Connect to a sub-agent (facet) via its parent. Flat array,
+     * root-first. Each step addresses one parent↔child hop.
+     *
+     * The hook's returned `.agent` / `.name` report the **leaf**
+     * identity (the deepest entry in `sub`), so downstream hooks
+     * like `useAgentChat` see the child they actually talk to.
+     * `.path` exposes the full chain for observability, deep links,
+     * and reconnect keying.
+     *
+     * @example
+     * ```ts
+     * // Two-level nesting: Inbox (Alice) → Chat (abc)
+     * useAgent({
+     *   agent: "inbox", name: userId,
+     *   sub: [{ agent: "chat", name: chatId }]
+     * });
+     *
+     * // Three-level: tenant → inbox → chat
+     * useAgent({
+     *   agent: "tenant", name: tenantId,
+     *   sub: [
+     *     { agent: "inbox", name: userId },
+     *     { agent: "chat",  name: chatId }
+     *   ]
+     * });
+     * ```
+     *
+     * @experimental The API surface may change before stabilizing.
+     */
+    sub?: ReadonlyArray<{
+      agent: string;
+      name: string;
+    }>;
+    /**
+     * Default timeout (in milliseconds) applied to non-streaming `call()`s
+     * that don't pass an explicit `timeout`. Acts as a backstop so calls
+     * whose response is lost (e.g. the connection is replaced mid-flight)
+     * reject instead of hanging forever.
+     *
+     * Defaults to 30 000 ms. Set to `0` to disable the default timeout.
+     * Streaming calls never get a default timeout (long-lived streams are
+     * legitimate); pass an explicit `timeout` to bound them.
+     */
+    defaultCallTimeout?: number /** Called when the connection closes with a terminal code and will not reconnect. */;
+    onConnectionError?: (error: AgentConnectionError) => void;
+  };
 type OptionalArgsAgentMethodCall<AgentT> = <
   K extends keyof OptionalAgentMethods<AgentT>
 >(
@@ -194,6 +201,7 @@ declare function useAgent<State = unknown>(
   identified: boolean;
   ready: Promise<void>;
   state: State | undefined;
+  connectionError: AgentConnectionError | null;
   setState: (state: State) => void;
   call: UntypedAgentMethodCall;
   stub: UntypedAgentStub;
@@ -216,6 +224,7 @@ declare function useAgent<
   identified: boolean;
   ready: Promise<void>;
   state: State | undefined;
+  connectionError: AgentConnectionError | null;
   setState: (state: State) => void;
   call: AgentMethodCall<AgentT>;
   stub: AgentStub<AgentT>;
@@ -225,11 +234,15 @@ type AgentToolEventAgent = Pick<
   PartySocket,
   "addEventListener" | "removeEventListener"
 >;
-declare function useAgentToolEvents(options: { agent: AgentToolEventAgent }): {
-  runsById: Record<string, AgentToolRunState>;
-  runsByToolCallId: Record<string, AgentToolRunState[]>;
-  unboundRuns: AgentToolRunState[];
-  getRunsForToolCall(toolCallId: string): AgentToolRunState[];
+declare function useAgentToolEvents<
+  Part extends AgentToolRunPart = AgentToolRunPart
+>(options: {
+  agent: AgentToolEventAgent;
+}): {
+  runsById: Record<string, AgentToolRunState<Part>>;
+  runsByToolCallId: Record<string, AgentToolRunState<Part>[]>;
+  unboundRuns: AgentToolRunState<Part>[];
+  getRunsForToolCall(toolCallId: string): AgentToolRunState<Part>[];
   resetLocalState(): void;
 };
 //#endregion