@tanstack/ai-client 0.28.0 → 0.29.1

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

@@ -123,8 +123,16 @@ export declare class ChatClient<TTools extends ReadonlyArray<AnyClientTool> = an
     private continuationPending;
     private subscriptionAbortController;
     private processingResolve;
+    /**
+     * `connect()` adapters push the full HTTP body into the subscribe queue, then
+     * wait until that queue is idle. After `send()` returns, every chunk from this
+     * request has been processed. Subscribe/send sockets do not drain that way.
+     */
+    private connectionDrainsOnSend;
     private errorReportedGeneration;
     private streamGeneration;
+    private continuationGeneration;
+    private streamContinuationGeneration;
     private continuationSkipped;
     private draining;
     private sessionGenerating;
@@ -239,6 +247,7 @@ export declare class ChatClient<TTools extends ReadonlyArray<AnyClientTool> = an
     retryInterrupts(): void;
     /** Unsafe low-level resume escape hatch. Prefer bound interrupt methods. */
     resumeInterruptsUnsafe(resume: Array<RunAgentResumeItem>, state?: ChatResumeState): Promise<boolean>;
+    private resumeInterruptsUnsafeForGeneration;
     /** @deprecated Use bound interrupt methods or resumeInterruptsUnsafe(). */
     resumeInterrupts(resume: Array<RunAgentResumeItem>, state?: ChatResumeState): Promise<boolean>;
     private submitInterruptBatch;

package/dist/esm/chat-client.js

@@ -1,5 +1,6 @@
 import { prepareResolvedByokHeaders, resolveByokProviderId } from "./byok/resolve.js";
 import { createNoOpChatDevtoolsBridge } from "./devtools-noop.js";
+import { normalizeMessagesDates } from "./message-date-normalizer.js";
 import { fetcherToConnectionAdapter, getChunkRunId as getChunkRunId$1, normalizeConnectionAdapter } from "./connection-adapters.js";
 import { ChatPersistor } from "./client-persistor.js";
 import { ClearedStreamTracker } from "./cleared-stream-tracker.js";
@@ -21,6 +22,16 @@ function resolveTransport(transport) {
 	if (fetcher) return fetcherToConnectionAdapter(fetcher);
 	throw new Error("ChatClient: either `connection` or `fetcher` is required.");
 }
+function connectionDrainsOnSend(connection) {
+	return "connect" in connection;
+}
+function isIntermediateToolTurn(chunk) {
+	if (chunk.type !== "RUN_FINISHED") return false;
+	if (chunk.outcome?.type === "interrupt") return false;
+	const extra = chunk;
+	if (extra.finishReason !== void 0) return extra.finishReason === "tool_calls";
+	return tanstackMetadata(chunk)?.finishReason === "tool_calls";
+}
 function normalizeQueueOption(option) {
 	const base = {
 		whenBusy: "queue",
@@ -203,8 +214,16 @@ var ChatClient = class {
 	continuationPending = false;
 	subscriptionAbortController = null;
 	processingResolve = null;
+	/**
+	* `connect()` adapters push the full HTTP body into the subscribe queue, then
+	* wait until that queue is idle. After `send()` returns, every chunk from this
+	* request has been processed. Subscribe/send sockets do not drain that way.
+	*/
+	connectionDrainsOnSend = false;
 	errorReportedGeneration = null;
 	streamGeneration = 0;
+	continuationGeneration = 0;
+	streamContinuationGeneration = 0;
 	continuationSkipped = false;
 	draining = false;
 	sessionGenerating = false;
@@ -236,7 +255,9 @@ var ChatClient = class {
 		this.byokProvider = options.byokProvider;
 		this.context = options.context;
 		this.queueConfig = normalizeQueueOption(options.queue);
-		this.connection = normalizeConnectionAdapter(resolveTransport(options));
+		const transport = resolveTransport(options);
+		this.connectionDrainsOnSend = connectionDrainsOnSend(transport);
+		this.connection = normalizeConnectionAdapter(transport);
 		this.clientToolsRef = { current: /* @__PURE__ */ new Map() };
 		if (options.tools) for (const tool of options.tools) this.clientToolsRef.current.set(tool.name, tool);
 		this.devtoolsBridge = (options.devtoolsBridgeFactory ?? createNoOpChatDevtoolsBridge)(this.buildDevtoolsBridgeOptions(options.devtools));
@@ -333,6 +354,7 @@ var ChatClient = class {
 					const clientTool = (this.activeClientTools ?? this.clientToolsRef.current).get(args.toolName);
 					const executeFunc = clientTool?.execute;
 					if (executeFunc) {
+						const continuationGeneration = this.continuationGeneration;
 						const runEventContext = this.devtoolsBridge.getCurrentRunEventContext();
 						const executionPromise = (async () => {
 							try {
@@ -347,7 +369,7 @@ var ChatClient = class {
 									tool: args.toolName,
 									output,
 									state: "output-available"
-								}, clientTool, runEventContext);
+								}, clientTool, continuationGeneration, runEventContext);
 							} catch (error) {
 								await this.addToolResultForClientTool({
 									toolCallId: args.toolCallId,
@@ -355,7 +377,7 @@ var ChatClient = class {
 									output: null,
 									state: "output-error",
 									errorText: error.message
-								}, clientTool, runEventContext);
+								}, clientTool, continuationGeneration, runEventContext);
 							} finally {
 								this.pendingToolExecutions.delete(args.toolCallId);
 							}
@@ -370,6 +392,7 @@ var ChatClient = class {
 				},
 				onCustomEvent: (eventType, data, context) => {
 					if (eventType === "memory:state") this.devtoolsBridge.recordMemoryState(data);
+					if (eventType === "skills:state") this.devtoolsBridge.recordSkillsState(data);
 					this.callbacksRef.current.onCustomEvent(eventType, data, context);
 				}
 			}
@@ -491,7 +514,7 @@ var ChatClient = class {
 			}
 			if (this.disposed || !this.tailing) return;
 			if (this.isLoading || this.abortController) return;
-			if (result.messages.length > 0) this.processor.setMessages(result.messages);
+			if (result.messages.length > 0) this.processor.setMessages(normalizeMessagesDates(result.messages));
 			if (result.interrupts && result.interrupts.pending.length > 0) this.applyResumeSnapshot({
 				resumeState: {
 					threadId: this.threadId,
@@ -558,7 +581,8 @@ var ChatClient = class {
 			this.clearedStreamTracker.onSessionRunError();
 		}
 		this.setSessionGenerating(this.activeRunIds.size > 0);
-		if (options?.resolveProcessing !== false) this.resolveProcessing();
+		const skipProcessingResolve = chunk.type === "RUN_FINISHED" && isIntermediateToolTurn(chunk);
+		if (options?.resolveProcessing !== false && !skipProcessingResolve) this.resolveProcessing();
 	}
 	/**
 	* Track interrupt state off the stream's terminal events. A RUN_FINISHED with
@@ -649,10 +673,14 @@ var ChatClient = class {
 	resumeInterruptsUnsafe(resume, state) {
 		const target = state ?? this.lastResume;
 		if (!target) return Promise.resolve(false);
+		return this.resumeInterruptsUnsafeForGeneration(resume, target, this.continuationGeneration);
+	}
+	resumeInterruptsUnsafeForGeneration(resume, target, continuationGeneration) {
+		if (continuationGeneration !== this.continuationGeneration) return Promise.resolve(false);
 		if (this.isLoading) return new Promise((resolve, reject) => {
 			this.queuePostStreamAction(async () => {
 				try {
-					resolve(await this.resumeInterruptsUnsafe(resume, target));
+					resolve(await this.resumeInterruptsUnsafeForGeneration(resume, target, continuationGeneration));
 				} catch (error) {
 					reject(error);
 				}
@@ -668,6 +696,7 @@ var ChatClient = class {
 		return this.resumeInterruptsUnsafe(resume, state);
 	}
 	async submitInterruptBatch(submission) {
+		const continuationGeneration = this.continuationGeneration;
 		this.activeInterruptSubmission = submission;
 		this.interruptSubmissionFailure = void 0;
 		for (const resolution of submission.resolutions) {
@@ -676,12 +705,13 @@ var ChatClient = class {
 			const approvalId = resolution.interruptId;
 			this.processor.addToolApprovalResponse(approvalId, approved);
 		}
-		const resumed = await this.resumeInterruptsUnsafe([...submission.resolutions], {
+		const resumed = await this.resumeInterruptsUnsafeForGeneration([...submission.resolutions], {
 			threadId: submission.threadId,
 			runId: submission.interruptedRunId
-		}).finally(() => {
-			this.activeInterruptSubmission = void 0;
+		}, continuationGeneration).finally(() => {
+			if (this.activeInterruptSubmission === submission) this.activeInterruptSubmission = void 0;
 		});
+		if (continuationGeneration !== this.continuationGeneration) return;
 		const failure = this.takeInterruptSubmissionFailure();
 		if (failure !== void 0) throw { errors: failure.errors };
 		if (!resumed) throw new Error("Interrupt continuation could not be started.");
@@ -906,6 +936,7 @@ var ChatClient = class {
 			threadId: this.threadId,
 			runId
 		};
+		this.streamContinuationGeneration = this.continuationGeneration;
 		this.setIsLoading(true);
 		this.setStatus("streaming");
 		(async () => {
@@ -1224,6 +1255,7 @@ var ChatClient = class {
 	async streamResponse() {
 		if (this.isLoading) return false;
 		const generation = ++this.streamGeneration;
+		this.streamContinuationGeneration = this.continuationGeneration;
 		const resumeThreadId = this.pendingResumeThreadId;
 		const resumeParentRunId = this.pendingResumeParentRunId;
 		const resumeItems = this.pendingResumeItems;
@@ -1290,6 +1322,7 @@ var ChatClient = class {
 			this.devtoolsBridge.emitSnapshot();
 			await this.connection.send(messages, mergedBody, signal, runContext);
 			if (generation !== this.streamGeneration || signal.aborted) return false;
+			if (this.connectionDrainsOnSend) this.resolveProcessing();
 			await processingComplete;
 			if (generation !== this.streamGeneration) return false;
 			if (this.status === "error") {
@@ -1390,9 +1423,13 @@ var ChatClient = class {
 	* Stop the current stream
 	*/
 	stop() {
+		this.continuationGeneration++;
 		const hadLocalStream = this.abortController !== null;
 		this.cancelInFlightStream({ setReadyStatus: true });
 		this.discardPendingSends();
+		this.lastResume = null;
+		this.activeInterruptSubmission = void 0;
+		this.interruptManager.reset();
 		if (hadLocalStream) this.resetSessionGenerating();
 		this.events.stopped();
 	}
@@ -1427,9 +1464,9 @@ var ChatClient = class {
 	*/
 	async addToolResult(result) {
 		const clientTool = this.clientToolsRef.current.get(result.tool);
-		await this.addToolResultForClientTool(result, clientTool);
+		await this.addToolResultForClientTool(result, clientTool, this.streamContinuationGeneration);
 	}
-	async addToolResultForClientTool(result, clientTool, context) {
+	async addToolResultForClientTool(result, clientTool, continuationGeneration, context) {
 		if (clientTool && result.state !== "output-error") try {
 			result = {
 				...result,
@@ -1444,11 +1481,12 @@ var ChatClient = class {
 			};
 		}
 		this.events.toolResultAdded(result.toolCallId, result.tool, result.output, result.state || "output-available", context);
+		if (continuationGeneration !== this.continuationGeneration) return;
 		this.processor.addToolResult(result.toolCallId, result.output, result.state === "output-error" ? result.errorText || "Tool execution failed" : void 0);
 		this.devtoolsBridge.emitSnapshot();
 		if (this.interruptManager.resolveClientToolOutput(result.toolCallId, result.state === "output-error" ? { error: result.errorText || "Tool execution failed" } : result.output)) return;
 		if (this.isLoading) {
-			this.queuePostStreamAction(() => this.checkForContinuation());
+			this.queuePostStreamAction(() => continuationGeneration === this.continuationGeneration ? this.checkForContinuation() : Promise.resolve());
 			return;
 		}
 		await this.checkForContinuation();
@@ -1486,7 +1524,11 @@ var ChatClient = class {
 	* Queue an action to be executed after the current stream ends
 	*/
 	queuePostStreamAction(action) {
-		this.postStreamActions.push(action);
+		const continuationGeneration = this.continuationGeneration;
+		this.postStreamActions.push(async () => {
+			if (continuationGeneration !== this.continuationGeneration) return;
+			await action();
+		});
 	}
 	/**
 	* Drain and execute all queued post-stream actions
@@ -1505,6 +1547,7 @@ var ChatClient = class {
 	* Check if we should continue the flow and do so if needed
 	*/
 	async checkForContinuation() {
+		if (this.streamContinuationGeneration !== this.continuationGeneration) return;
 		if (this.hasPendingInterrupts()) return;
 		if (this.continuationPending || this.isLoading) {
 			this.continuationSkipped = true;
@@ -1688,10 +1731,12 @@ var ChatClient = class {
 			this.resetSessionGenerating();
 			this.setIsSubscribed(false);
 			this.setConnectionStatus("disconnected");
-			this.connection = normalizeConnectionAdapter(resolveTransport({
+			const transport = resolveTransport({
 				connection: options.connection,
 				fetcher: options.fetcher
-			}));
+			});
+			this.connectionDrainsOnSend = connectionDrainsOnSend(transport);
+			this.connection = normalizeConnectionAdapter(transport);
 			if (wasSubscribed) this.subscribe();
 		}
 		if (options.body !== void 0) this.bodyOption = options.body;