@tanstack/ai-client 0.31.1 → 0.32.0

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

@@ -144,6 +144,16 @@ export declare class ChatClient<TTools extends ReadonlyArray<AnyClientTool> = an
     /** Constructor inputs `attach()` needs on every re-attach, not just the first. */
     private readonly rejoinRunId;
     private readonly cachesMessages;
+    /**
+     * Newest-window size from `history.pageSize`. Only set when
+     * `persistence === true`.
+     */
+    private readonly historyPageSize;
+    private hasOlderMessages;
+    private olderMessagesCursor;
+    private readonly knownServerMessageIds;
+    private loadOlderMessagesInFlight;
+    private historyGeneration;
     private devtoolsMounted;
     private readonly callbacksRef;
     constructor(options: ChatClientOptions<TTools, TContext, TInterrupts>);
@@ -470,6 +480,23 @@ export declare class ChatClient<TTools extends ReadonlyArray<AnyClientTool> = an
      * Get current messages
      */
     getMessages(): Array<UIMessage<TTools>>;
+    /**
+     * True when the last hydrate or older-page response said more messages exist.
+     */
+    getHasOlderMessages(): boolean;
+    /**
+     * Fetch the next older window and put it in front of the painted messages.
+     *
+     * No-op when there is no older page, no cursor, or a page load is already
+     * running. A network failure rejects and leaves the painted messages as they
+     * are; {@link getHasOlderMessages} stays true.
+     */
+    loadOlderMessages(): Promise<void>;
+    private resetHistoryPaging;
+    private applyHydrationPage;
+    private rememberServerMessageIds;
+    private rememberProcessorMessageIds;
+    private messagesForSend;
     /**
      * True when an interrupt (or another direct send) claimed the client during
      * a drain. Read via a method so cross-await mutations are not constant-folded

package/dist/esm/chat-client.js

@@ -235,6 +235,16 @@ var ChatClient = class {
 	/** Constructor inputs `attach()` needs on every re-attach, not just the first. */
 	rejoinRunId;
 	cachesMessages;
+	/**
+	* Newest-window size from `history.pageSize`. Only set when
+	* `persistence === true`.
+	*/
+	historyPageSize;
+	hasOlderMessages = false;
+	olderMessagesCursor;
+	knownServerMessageIds = /* @__PURE__ */ new Set();
+	loadOlderMessagesInFlight = false;
+	historyGeneration = 0;
 	devtoolsMounted = false;
 	callbacksRef;
 	constructor(options) {
@@ -245,10 +255,12 @@ var ChatClient = class {
 		if (options.persistence === true) {
 			if (!options.threadId) throw new Error("[TanStack AI] persistence needs a stable `threadId` to key on. Pass a threadId from your app (for example support-42).");
 			cachesMessages = false;
+			this.historyPageSize = options.history?.pageSize;
 		} else if (options.persistence) {
 			if (!options.threadId) throw new Error("[TanStack AI] persistence needs a stable `threadId` to key on. Pass a threadId from your app (for example support-42).");
 			this.persistor = new ChatPersistor(options.persistence, options.threadId, (messages) => this.processor.setMessages(messages), (snapshot) => this.applyPersistedResume(snapshot));
-		}
+			this.historyPageSize = void 0;
+		} else this.historyPageSize = void 0;
 		this.bodyOption = options.body || {};
 		this.forwardedPropsOption = options.forwardedProps || {};
 		this.byok = options.byok;
@@ -506,16 +518,25 @@ var ChatClient = class {
 		if (!hydrate) return;
 		if (this.isLoading || this.abortController) return;
 		if (this.disposed) return;
+		const pageSize = this.historyPageSize;
+		const hydrateOptions = pageSize === void 0 ? void 0 : { limit: pageSize };
 		(async () => {
 			let result;
+			const generation = this.historyGeneration;
 			try {
-				result = await hydrate(this.threadId);
+				result = await hydrate(this.threadId, hydrateOptions);
 			} catch {
 				return;
 			}
+			if (generation !== this.historyGeneration) return;
 			if (this.disposed || !this.tailing) return;
 			if (this.isLoading || this.abortController) return;
-			if (result.messages.length > 0) this.processor.setMessages(normalizeMessagesDates(result.messages));
+			this.applyHydrationPage(result.page);
+			if (result.messages.length > 0) {
+				const windowMessages = normalizeMessagesDates(result.messages);
+				this.processor.setMessages(windowMessages);
+				this.rememberServerMessageIds(windowMessages);
+			}
 			if (result.interrupts && result.interrupts.pending.length > 0) this.applyResumeSnapshot({
 				resumeState: {
 					threadId: this.threadId,
@@ -1275,7 +1296,7 @@ var ChatClient = class {
 		let activeDevtoolsRunId = null;
 		let runTerminalEventEmitted = false;
 		try {
-			const messages = this.processor.getMessages();
+			const messages = this.messagesForSend(this.processor.getMessages());
 			const clientTools = new Map(this.clientToolsRef.current);
 			const runtimeContext = this.context;
 			await this.callbacksRef.current.onResponse();
@@ -1368,6 +1389,7 @@ var ChatClient = class {
 				}
 				await this.drainPostStreamActions();
 				if (streamCompletedSuccessfully) {
+					this.rememberProcessorMessageIds();
 					if (this.status !== "ready") this.setStatus("ready");
 					if (!this.messageQueueDraining) await this.drainQueue();
 				} else this.flushQueue();
@@ -1446,6 +1468,7 @@ var ChatClient = class {
 		} else if (this.activeRunIds.size > 0) this.resetSessionGenerating({ preserveClearedStreamTracking: true });
 		this.persistor?.beginClear();
 		this.processor.clearMessages();
+		this.resetHistoryPaging();
 		this.discardPendingSends();
 		this.persistor?.remove();
 		this.lastResume = null;
@@ -1586,6 +1609,79 @@ var ChatClient = class {
 		return this.processor.getMessages();
 	}
 	/**
+	* True when the last hydrate or older-page response said more messages exist.
+	*/
+	getHasOlderMessages() {
+		return this.hasOlderMessages;
+	}
+	/**
+	* Fetch the next older window and put it in front of the painted messages.
+	*
+	* No-op when there is no older page, no cursor, or a page load is already
+	* running. A network failure rejects and leaves the painted messages as they
+	* are; {@link getHasOlderMessages} stays true.
+	*/
+	async loadOlderMessages() {
+		const hydrate = this.connection.hydrate;
+		if (hydrate === void 0) return;
+		if (this.disposed) return;
+		if (!this.hasOlderMessages) return;
+		const cursor = this.olderMessagesCursor;
+		if (cursor === void 0) return;
+		if (this.loadOlderMessagesInFlight) return;
+		const hydrateOptions = { before: cursor };
+		if (this.historyPageSize !== void 0) hydrateOptions.limit = this.historyPageSize;
+		this.loadOlderMessagesInFlight = true;
+		const generation = this.historyGeneration;
+		try {
+			const result = await hydrate(this.threadId, hydrateOptions);
+			if (this.disposed) return;
+			if (generation !== this.historyGeneration) return;
+			const olderMessages = normalizeMessagesDates(result.messages);
+			if (olderMessages.length === 0) throw new Error("Older page was empty");
+			this.applyHydrationPage(result.page);
+			this.processor.prependMessages(olderMessages);
+			this.rememberServerMessageIds(olderMessages);
+		} finally {
+			this.loadOlderMessagesInFlight = false;
+		}
+	}
+	resetHistoryPaging() {
+		this.hasOlderMessages = false;
+		this.olderMessagesCursor = void 0;
+		this.knownServerMessageIds.clear();
+		this.historyGeneration++;
+	}
+	applyHydrationPage(page) {
+		if (page?.truncated === true) {
+			this.hasOlderMessages = true;
+			this.olderMessagesCursor = page.cursor;
+			return;
+		}
+		this.hasOlderMessages = false;
+		this.olderMessagesCursor = void 0;
+	}
+	rememberServerMessageIds(messages) {
+		const ids = messages.map((message) => message.id);
+		for (const id of ids) this.knownServerMessageIds.add(id);
+	}
+	rememberProcessorMessageIds() {
+		if (this.historyPageSize === void 0) return;
+		this.rememberServerMessageIds(this.processor.getMessages());
+	}
+	messagesForSend(messages) {
+		if (this.historyPageSize === void 0) return messages;
+		const unknownMessages = [];
+		for (const message of messages) {
+			if (this.knownServerMessageIds.has(message.id)) continue;
+			unknownMessages.push(message);
+		}
+		if (unknownMessages.length > 0) return unknownMessages;
+		const lastUserIndex = messages.findLastIndex((message) => message.role === "user");
+		if (lastUserIndex === -1) return [];
+		return messages.slice(lastUserIndex);
+	}
+	/**
 	* True when an interrupt (or another direct send) claimed the client during
 	* a drain. Read via a method so cross-await mutations are not constant-folded
 	* by control-flow analysis.