@tanstack/ai-client 0.35.1 → 0.36.0

package/README.md

@@ -240,6 +240,7 @@ Official adapters include:
 | [`@tanstack/ai-byteplus`](https://tanstack.com/ai/latest/docs/adapters/byteplus)     | BytePlus Seed chat, Seedance video, Seedream image, and Seed Speech TTS/ASR            |
 | [`@tanstack/ai-fal`](https://tanstack.com/ai/latest/docs/adapters/fal)               | fal.ai image, video, audio, speech, and transcription models                           |
 | [`@tanstack/ai-reactor`](https://tanstack.com/ai/latest/docs/adapters/reactor)       | Reactor live world and video generation (Orbis, Happy Oyster, LingBot, Helios, FastH3) |
+| [`@tanstack/ai-worldlabs`](https://tanstack.com/ai/latest/docs/adapters/worldlabs)   | World Labs Marble persistent 3D world generation                                       |
 | [`@tanstack/ai-cloudflare`](https://tanstack.com/ai/latest/docs/adapters/cloudflare) | Cloudflare Workers AI chat, embeddings, image, speech, transcription, and AI Gateway   |
 
 The adapter system is tree-shakeable by activity. Import `openaiText` for chat,

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

@@ -310,7 +310,8 @@ export declare class ChatClient<TTools extends ReadonlyArray<AnyClientTool> = an
      */
     private startSubscription;
     /**
-     * Consume chunks from the connection subscription.
+     * Consume chunks from the connection subscription. Chunks are processed in
+     * order; the loop yields to the host after each processing budget.
      */
     private consumeSubscription;
     /**
@@ -332,7 +333,7 @@ export declare class ChatClient<TTools extends ReadonlyArray<AnyClientTool> = an
      * give up after {@link REJOIN_CONNECT_DEADLINE_MS} if no chunk arrives and
      * clear the dead pointer so it does not retry on the next load.
      *
-     * Replay chunks are processed WITHOUT the per-chunk yield the live path uses,
+     * Replay chunks are processed WITHOUT the time-slice yield the live path uses,
      * so the buffered prefix snaps in and only the genuinely-live tail streams at
      * network speed — a reload looks like the run continued, not like it re-typed.
      */

package/dist/esm/chat-client.js

@@ -6,9 +6,15 @@ 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 { EventType, StreamProcessor, convertSchemaToJsonSchema, generateMessageId, isStandardSchema, mergeMetadata, normalizeToUIMessage, parseWithStandardSchema, restoreInboundChunk, tanstackMetadata } from "@tanstack/ai/client";
+import { EventType, StreamProcessor, cloneAndDeepFreezeJson, convertSchemaToJsonSchema, generateMessageId, isStandardSchema, mergeMetadata, normalizeToUIMessage, restoreInboundChunk, tanstackMetadata, validateWithStandardSchema } from "@tanstack/ai/client";
 import { ByokBlockedError, ByokMissingError, ByokUnresolvedProviderError } from "@tanstack/ai/byok";
 //#region src/chat-client.ts
+var STREAM_PROCESSING_BUDGET_MS = 8;
+function yieldToHost() {
+	const { scheduler } = globalThis;
+	if (scheduler?.yield) return scheduler.yield();
+	return new Promise((resolve) => setTimeout(resolve, 0));
+}
 function assertUniqueInterruptDefinitions(interrupts) {
 	const ids = /* @__PURE__ */ new Set();
 	for (const interrupt of interrupts ?? []) {
@@ -582,7 +588,7 @@ var ChatClient = class {
 				this.processor.setMessages(windowMessages);
 				this.rememberServerMessageIds(windowMessages);
 			}
-			if (result.interrupts && result.interrupts.pending.length > 0) this.applyResumeSnapshot({
+			if (result.interrupts && result.interrupts.pending.length > 0 && (!result.activeRun?.runId || result.activeRun.runId === result.interrupts.runId)) this.applyResumeSnapshot({
 				resumeState: {
 					threadId: this.threadId,
 					runId: result.interrupts.runId
@@ -1011,13 +1017,21 @@ var ChatClient = class {
 		});
 	}
 	/**
-	* Consume chunks from the connection subscription.
+	* Consume chunks from the connection subscription. Chunks are processed in
+	* order; the loop yields to the host after each processing budget.
 	*/
 	async consumeSubscription(signal) {
 		const stream = this.connection.subscribe(signal);
+		let chunkProcessingTime = 0;
 		for await (const chunk of stream) {
 			if (signal.aborted) break;
-			await this.processIncomingChunk(chunk);
+			const startedAt = performance.now();
+			this.processIncomingChunk(chunk);
+			chunkProcessingTime += performance.now() - startedAt;
+			if (chunkProcessingTime < STREAM_PROCESSING_BUDGET_MS) continue;
+			chunkProcessingTime = 0;
+			if (typeof document !== "undefined" && document.hidden) continue;
+			await yieldToHost();
 		}
 	}
 	/**
@@ -1039,7 +1053,7 @@ var ChatClient = class {
 	* give up after {@link REJOIN_CONNECT_DEADLINE_MS} if no chunk arrives and
 	* clear the dead pointer so it does not retry on the next load.
 	*
-	* Replay chunks are processed WITHOUT the per-chunk yield the live path uses,
+	* Replay chunks are processed WITHOUT the time-slice yield the live path uses,
 	* so the buffered prefix snaps in and only the genuinely-live tail streams at
 	* network speed — a reload looks like the run continued, not like it re-typed.
 	*/
@@ -1074,7 +1088,7 @@ var ChatClient = class {
 						rebuilt = true;
 						this.dropTrailingInFlightAssistant();
 					}
-					await this.processIncomingChunk(chunk, { defer: false });
+					this.processIncomingChunk(chunk);
 				}
 				if (this.pendingToolExecutions.size > 0) await Promise.all(this.pendingToolExecutions.values());
 			} catch (error) {
@@ -1107,7 +1121,7 @@ var ChatClient = class {
 		const last = messages[messages.length - 1];
 		if (last && last.role === "assistant") this.processor.setMessages(messages.slice(0, -1));
 	}
-	async processIncomingChunk(chunk, options) {
+	processIncomingChunk(chunk) {
 		chunk = restoreInboundChunk(chunk);
 		if (chunk.type === "RUN_ERROR" && this.isActiveInterruptSubmissionFailure(chunk)) {
 			const interruptErrors = tanstackMetadata(chunk)?.interruptErrors;
@@ -1136,7 +1150,6 @@ var ChatClient = class {
 		this.syncSubagentHandles();
 		this.updateRunLifecycle(chunk);
 		this.observeInterruptState(chunk);
-		if (options?.defer !== false && (typeof document === "undefined" || !document.hidden)) await new Promise((resolve) => setTimeout(resolve, 0));
 		this.resolveJoinedRun(chunk);
 	}
 	isActiveInterruptSubmissionFailure(chunk) {
@@ -1591,10 +1604,12 @@ var ChatClient = class {
 		await this.addToolResultForClientTool(result, clientTool, this.streamContinuationGeneration);
 	}
 	async addToolResultForClientTool(result, clientTool, continuationGeneration, context) {
-		if (clientTool && result.state !== "output-error") try {
+		if (result.state !== "output-error") try {
+			let output = clientTool?.outputSchema && isStandardSchema(clientTool.outputSchema) ? await this.validateClientToolOutput(clientTool, result.output) : result.output;
+			if (this.interruptManager.getDescriptors().some((interrupt) => interrupt.toolCallId === result.toolCallId)) output = cloneAndDeepFreezeJson(output);
 			result = {
 				...result,
-				output: this.validateClientToolOutput(clientTool, result.output)
+				output
 			};
 		} catch (error) {
 			result = {
@@ -1608,16 +1623,17 @@ var ChatClient = class {
 		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 (result.state === "output-error" ? this.interruptManager.resolveClientToolError(result.toolCallId, result.errorText || "Tool execution failed") : this.interruptManager.resolveClientToolOutput(result.toolCallId, result.output)) return;
 		if (this.isLoading) {
 			this.queuePostStreamAction(() => continuationGeneration === this.continuationGeneration ? this.checkForContinuation() : Promise.resolve());
 			return;
 		}
 		await this.checkForContinuation();
 	}
-	validateClientToolOutput(clientTool, output) {
-		if (clientTool.outputSchema && isStandardSchema(clientTool.outputSchema)) return parseWithStandardSchema(clientTool.outputSchema, output);
-		return output;
+	async validateClientToolOutput(clientTool, output) {
+		const validation = await validateWithStandardSchema(clientTool.outputSchema, output);
+		if (!validation.success) throw new Error(validation.issues.map((issue) => issue.message).join(", "));
+		return validation.data;
 	}
 	/**
 	* Respond to a tool approval request