@tanstack/ai-client 0.33.2 → 0.35.1

package/dist/esm/chat-client.d.ts

@@ -1,7 +1,7 @@
 import { AnyClientTool, InterruptDefinition, ModelMessage, RunAgentResumeItem, StreamChunk } from '@tanstack/ai/client';
 import { ByokClient } from './byok.js';
 import { ConnectionAdapter } from './connection-adapters.js';
-import { BoundInterrupts, ChatClientOptions, ChatClientState, ChatFetcher, ChatInterruptState, ResolvableChatInterrupt, ChatResumeState, ConnectionStatus, MultimodalContent, QueueOption, QueueStrategy, QueuedMessage, SendMessageOptions, UIMessage, WhenBusy } from './types.js';
+import { BoundInterrupts, ChatClientOptions, ChatClientState, ChatFetcher, ChatInterruptState, ResolvableChatInterrupt, ChatResumeState, ConnectionStatus, MultimodalContent, QueueOption, QueueStrategy, QueuedMessage, SendMessageOptions, SubagentHandle, UIMessage, WhenBusy } from './types.js';
 type ChatClientUpdateOptionsWithoutContext<TTools extends ReadonlyArray<AnyClientTool>, TInterrupts extends ReadonlyArray<InterruptDefinition<any, any, any, any>> = readonly []> = {
     connection?: ConnectionAdapter;
     fetcher?: ChatFetcher;
@@ -51,6 +51,8 @@ export interface NormalizedQueueConfig {
 export declare function normalizeQueueOption(option: QueueOption | undefined): NormalizedQueueConfig;
 export declare class ChatClient<TTools extends ReadonlyArray<AnyClientTool> = any, TContext = unknown, TInterrupts extends ReadonlyArray<InterruptDefinition<any, any, any, any>> = any> {
     private readonly processor;
+    private readonly subagentHandles;
+    private readonly stoppedSubagentIds;
     private connection;
     private uniqueId;
     private threadId;
@@ -141,6 +143,8 @@ export declare class ChatClient<TTools extends ReadonlyArray<AnyClientTool> = an
     private readonly activeRunIds;
     /** Latched by `dispose()`; stops any late async callback starting new work. */
     private disposed;
+    /** The error a failed mount hydration set, cleared by the next successful one. */
+    private hydrationError;
     /** Whether a view is currently watching. See `attach` / `detach`. */
     private tailing;
     /** Constructor inputs `attach()` needs on every re-attach, not just the first. */
@@ -217,6 +221,19 @@ export declare class ChatClient<TTools extends ReadonlyArray<AnyClientTool> = an
      * send that starts first owns the client (hydration then backs off).
      */
     private hydrateFromServer;
+    /**
+     * Surface a mount-hydration failure (`persistence: true`) on the observable
+     * fields, mirroring `GenerationClient.failHydration`, so "this thread failed
+     * to load" is distinguishable from "this thread has no messages" and the app
+     * can show an error / offer a retry. A genuine miss — the server having no
+     * record for a fresh thread — resolves normally and never reaches here; only a
+     * thrown transport / authorize-gate error does.
+     *
+     * Skipped when the view unmounted (`!tailing`) or a `sendMessage` took
+     * ownership while the hydrate GET was in flight, so a live run's state always
+     * wins over a stale mount-time failure — same guard as the success path above.
+     */
+    private failHydration;
     mountDevtools(): void;
     private ensureThreadId;
     /**
@@ -484,6 +501,12 @@ export declare class ChatClient<TTools extends ReadonlyArray<AnyClientTool> = an
      * Get current messages
      */
     getMessages(): Array<UIMessage<TTools>>;
+    getSubagents(): SubagentHandle[];
+    private devtoolsSnapshotQueued;
+    /** One devtools snapshot per microtask, however many chunks arrive. */
+    private queueDevtoolsSnapshot;
+    private syncSubagentHandles;
+    private stopSubagent;
     /**
      * True when the last hydrate or older-page response said more messages exist.
      */

package/dist/esm/chat-client.js

@@ -6,7 +6,7 @@ import { fetcherToConnectionAdapter, getChunkRunId as getChunkRunId$1, normalize
 import { ChatPersistor } from "./client-persistor.js";
 import { ClearedStreamTracker } from "./cleared-stream-tracker.js";
 import { InterruptManager } from "./interrupt-manager.js";
-import { StreamProcessor, convertSchemaToJsonSchema, generateMessageId, isStandardSchema, mergeMetadata, normalizeToUIMessage, parseWithStandardSchema, restoreInboundChunk, tanstackMetadata } from "@tanstack/ai/client";
+import { EventType, StreamProcessor, convertSchemaToJsonSchema, generateMessageId, isStandardSchema, mergeMetadata, normalizeToUIMessage, parseWithStandardSchema, restoreInboundChunk, tanstackMetadata } from "@tanstack/ai/client";
 import { ByokBlockedError, ByokMissingError, ByokUnresolvedProviderError } from "@tanstack/ai/byok";
 //#region src/chat-client.ts
 function assertUniqueInterruptDefinitions(interrupts) {
@@ -138,12 +138,42 @@ var REJOIN_CONNECT_DEADLINE_MS = 2e3;
 var REJOIN_REBUILD_TRIGGERS = /* @__PURE__ */ new Set([
 	"TEXT_MESSAGE_START",
 	"TEXT_MESSAGE_CONTENT",
+	"REASONING_MESSAGE_CONTENT",
 	"TOOL_CALL_START",
-	"MESSAGES_SNAPSHOT"
+	"MESSAGES_SNAPSHOT",
+	"SUBAGENT_STARTED"
 ]);
+function rebuildsAssistantMessage(chunk) {
+	if (chunk.type === "REASONING_ENCRYPTED_VALUE") return chunk.subtype === "message" && typeof chunk.encryptedValue === "string" && chunk.encryptedValue.length > 0;
+	if (chunk.type === "STEP_FINISHED") return "signature" in chunk && Boolean(chunk.signature);
+	return REJOIN_REBUILD_TRIGGERS.has(chunk.type);
+}
+/** Every subagent card in the messages, nested cards included. */
+function collectSubagentParts(messages) {
+	const cards = [];
+	for (const message of messages) for (const part of message.parts) {
+		if (part.type !== "subagent") continue;
+		cards.push(part);
+		cards.push(...collectSubagentParts(part.subagent.messages));
+	}
+	return cards;
+}
+function readSubagentRunId(chunk) {
+	if ("subagentRunId" in chunk && typeof chunk.subagentRunId === "string") return chunk.subagentRunId;
+}
 var MAX_RUN_LINEAGE_DEPTH = 64;
+function copyForDevtools(value) {
+	if (Array.isArray(value)) return value.map(copyForDevtools);
+	if (value instanceof Date) return new Date(value.getTime());
+	if (value === null || typeof value !== "object") return value;
+	const out = {};
+	for (const [key, item] of Object.entries(value)) if (typeof item !== "function") out[key] = copyForDevtools(item);
+	return out;
+}
 var ChatClient = class {
 	processor;
+	subagentHandles = /* @__PURE__ */ new Map();
+	stoppedSubagentIds = /* @__PURE__ */ new Set();
 	connection;
 	uniqueId;
 	threadId;
@@ -234,6 +264,8 @@ var ChatClient = class {
 	activeRunIds = /* @__PURE__ */ new Set();
 	/** Latched by `dispose()`; stops any late async callback starting new work. */
 	disposed = false;
+	/** The error a failed mount hydration set, cleared by the next successful one. */
+	hydrationError;
 	/** Whether a view is currently watching. See `attach` / `detach`. */
 	tailing = false;
 	/** Constructor inputs `attach()` needs on every re-attach, not just the first. */
@@ -321,8 +353,10 @@ var ChatClient = class {
 			...initialMessages ? { initialMessages } : {},
 			events: {
 				onMessagesChange: (messages) => {
+					this.syncSubagentHandles();
 					this.persistor?.notifyMessagesChanged(messages);
 					this.callbacksRef.current.onMessagesChange(messages);
+					this.queueDevtoolsSnapshot();
 				},
 				onStreamStart: () => {
 					this.setStatus("streaming");
@@ -414,6 +448,7 @@ var ChatClient = class {
 				}
 			}
 		});
+		this.syncSubagentHandles();
 		this.persistor?.hydrateAsync(persistedState);
 		this.rejoinRunId = rejoinRunId;
 		this.cachesMessages = cachesMessages;
@@ -529,12 +564,18 @@ var ChatClient = class {
 			const generation = this.historyGeneration;
 			try {
 				result = await hydrate(this.threadId, hydrateOptions);
-			} catch {
+			} catch (cause) {
+				if (generation === this.historyGeneration) this.failHydration(cause);
 				return;
 			}
 			if (generation !== this.historyGeneration) return;
 			if (this.disposed || !this.tailing) return;
 			if (this.isLoading || this.abortController) return;
+			if (this.hydrationError && this.error === this.hydrationError) {
+				this.setError(void 0);
+				this.setStatus("ready");
+			}
+			this.hydrationError = void 0;
 			this.applyHydrationPage(result.page);
 			if (result.messages.length > 0) {
 				const windowMessages = normalizeMessagesDates(result.messages);
@@ -551,6 +592,29 @@ var ChatClient = class {
 			else if (result.activeRun?.runId) this.maybeRejoinInFlight(result.activeRun.runId);
 		})();
 	}
+	/**
+	* Surface a mount-hydration failure (`persistence: true`) on the observable
+	* fields, mirroring `GenerationClient.failHydration`, so "this thread failed
+	* to load" is distinguishable from "this thread has no messages" and the app
+	* can show an error / offer a retry. A genuine miss — the server having no
+	* record for a fresh thread — resolves normally and never reaches here; only a
+	* thrown transport / authorize-gate error does.
+	*
+	* Skipped when the view unmounted (`!tailing`) or a `sendMessage` took
+	* ownership while the hydrate GET was in flight, so a live run's state always
+	* wins over a stale mount-time failure — same guard as the success path above.
+	*/
+	failHydration(cause) {
+		if (this.disposed || !this.tailing) return;
+		if (this.isLoading || this.abortController) return;
+		const error = cause instanceof Error ? cause : new Error(String(cause));
+		if (error instanceof ByokMissingError) this.byok?.request(error.provider, "missing");
+		if (error instanceof ByokBlockedError && error.reason === "locked") this.byok?.request(error.provider, "locked");
+		this.hydrationError = error;
+		this.setStatus("error");
+		this.setError(error);
+		this.callbacksRef.current.onError(error);
+	}
 	mountDevtools() {
 		this.ensureThreadId();
 		if (this.devtoolsMounted) return;
@@ -882,7 +946,7 @@ var ChatClient = class {
 	}
 	getDevtoolsSnapshot() {
 		return {
-			messages: this.processor.getMessages(),
+			messages: copyForDevtools(this.processor.getMessages()),
 			status: this.status,
 			isLoading: this.isLoading,
 			isSubscribed: this.isSubscribed,
@@ -1006,7 +1070,7 @@ var ChatClient = class {
 						attached = true;
 						clearTimeout(connectTimer);
 					}
-					if (!rebuilt && REJOIN_REBUILD_TRIGGERS.has(chunk.type)) {
+					if (!rebuilt && rebuildsAssistantMessage(chunk)) {
 						rebuilt = true;
 						this.dropTrailingInFlightAssistant();
 					}
@@ -1061,7 +1125,15 @@ var ChatClient = class {
 		}
 		this.callbacksRef.current.onChunk(chunk);
 		this.devtoolsBridge.observeChunk(chunk);
+		const attributedId = readSubagentRunId(chunk);
+		if (attributedId && chunk.type === EventType.SUBAGENT_STARTED) this.stoppedSubagentIds.delete(attributedId);
+		if (attributedId && this.stoppedSubagentIds.has(attributedId)) {
+			this.updateRunLifecycle(chunk);
+			this.resolveJoinedRun(chunk);
+			return;
+		}
 		this.processor.processChunk(chunk);
+		this.syncSubagentHandles();
 		this.updateRunLifecycle(chunk);
 		this.observeInterruptState(chunk);
 		if (options?.defer !== false && (typeof document === "undefined" || !document.hidden)) await new Promise((resolve) => setTimeout(resolve, 0));
@@ -1502,6 +1574,7 @@ var ChatClient = class {
 		this.resetHistoryPaging();
 		this.discardPendingSends();
 		this.persistor?.remove();
+		this.stoppedSubagentIds.clear();
 		this.lastResume = null;
 		this.interruptManager.reset();
 		this.pendingResumeThreadId = null;
@@ -1639,6 +1712,59 @@ var ChatClient = class {
 	getMessages() {
 		return this.processor.getMessages();
 	}
+	getSubagents() {
+		return [...this.subagentHandles.values()];
+	}
+	devtoolsSnapshotQueued = false;
+	/** One devtools snapshot per microtask, however many chunks arrive. */
+	queueDevtoolsSnapshot() {
+		if (this.devtoolsSnapshotQueued) return;
+		this.devtoolsSnapshotQueued = true;
+		queueMicrotask(() => {
+			this.devtoolsSnapshotQueued = false;
+			this.devtoolsBridge.emitSnapshot();
+		});
+	}
+	syncSubagentHandles() {
+		const cards = collectSubagentParts(this.processor.getMessages());
+		const present = new Set(cards.map((part) => part.subagent.id));
+		for (const id of this.subagentHandles.keys()) if (!present.has(id)) this.subagentHandles.delete(id);
+		for (const part of cards) {
+			const id = part.subagent.id;
+			const existing = this.subagentHandles.get(id);
+			if (existing) {
+				if (part.subagent === existing) continue;
+				const { stop } = existing;
+				for (const key of Object.keys(existing)) Reflect.deleteProperty(existing, key);
+				Object.assign(existing, part.subagent, { stop });
+				part.subagent = existing;
+				continue;
+			}
+			const handle = {
+				...part.subagent,
+				stop: () => {
+					this.stopSubagent(id);
+				}
+			};
+			this.subagentHandles.set(id, handle);
+			part.subagent = handle;
+		}
+	}
+	stopSubagent(id) {
+		const handle = this.subagentHandles.get(id);
+		if (!handle || handle.status !== "running") return;
+		this.stoppedSubagentIds.add(id);
+		this.processor.processChunk({
+			type: EventType.SUBAGENT_ERROR,
+			subagentRunId: id,
+			message: "Stopped",
+			timestamp: Date.now()
+		});
+		this.syncSubagentHandles();
+		handle.status = "error";
+		handle.error = { message: "Stopped" };
+		this.abortController?.abort();
+	}
 	/**
 	* True when the last hydrate or older-page response said more messages exist.
 	*/