@tanstack/ai-client 0.28.0 → 0.29.0

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

@@ -125,6 +125,8 @@ export declare class ChatClient<TTools extends ReadonlyArray<AnyClientTool> = an
     private processingResolve;
     private errorReportedGeneration;
     private streamGeneration;
+    private continuationGeneration;
+    private streamContinuationGeneration;
     private continuationSkipped;
     private draining;
     private sessionGenerating;
@@ -239,6 +241,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";
@@ -205,6 +206,8 @@ var ChatClient = class {
 	processingResolve = null;
 	errorReportedGeneration = null;
 	streamGeneration = 0;
+	continuationGeneration = 0;
+	streamContinuationGeneration = 0;
 	continuationSkipped = false;
 	draining = false;
 	sessionGenerating = false;
@@ -333,6 +336,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 +351,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 +359,7 @@ var ChatClient = class {
 									output: null,
 									state: "output-error",
 									errorText: error.message
-								}, clientTool, runEventContext);
+								}, clientTool, continuationGeneration, runEventContext);
 							} finally {
 								this.pendingToolExecutions.delete(args.toolCallId);
 							}
@@ -491,7 +495,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,
@@ -649,10 +653,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 +676,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 +685,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 +916,7 @@ var ChatClient = class {
 			threadId: this.threadId,
 			runId
 		};
+		this.streamContinuationGeneration = this.continuationGeneration;
 		this.setIsLoading(true);
 		this.setStatus("streaming");
 		(async () => {
@@ -1224,6 +1235,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;
@@ -1390,9 +1402,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 +1443,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 +1460,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 +1503,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 +1526,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;