@tanstack/ai-client 0.22.1 → 0.23.1

package/dist/esm/cleared-stream-tracker.js

@@ -0,0 +1,97 @@
+import { getChunkRunId } from "./connection-adapters.js";
+//#region src/cleared-stream-tracker.ts
+function getChunkToolCallId(chunk) {
+	return "toolCallId" in chunk && typeof chunk.toolCallId === "string" ? chunk.toolCallId : void 0;
+}
+function getChunkMessageId(chunk) {
+	return "messageId" in chunk && typeof chunk.messageId === "string" ? chunk.messageId : void 0;
+}
+function getChunkParentMessageId(chunk) {
+	return "parentMessageId" in chunk && typeof chunk.parentMessageId === "string" ? chunk.parentMessageId : void 0;
+}
+/** Tracks stream chunks that must be ignored after the owning chat is cleared. */
+var ClearedStreamTracker = class {
+	clearedMessageIds = /* @__PURE__ */ new Set();
+	clearedRunIds = /* @__PURE__ */ new Set();
+	ignoredActiveRunIds = /* @__PURE__ */ new Set();
+	clearedToolCallIds = /* @__PURE__ */ new Set();
+	currentRunlessRunId = null;
+	snapshotClear(context) {
+		for (const message of context.messages) this.clearedMessageIds.add(message.id);
+		for (const runId of context.activeRunIds) {
+			this.clearedRunIds.add(runId);
+			this.ignoredActiveRunIds.add(runId);
+		}
+		if (context.currentRunId) {
+			this.clearedRunIds.add(context.currentRunId);
+			this.ignoredActiveRunIds.add(context.currentRunId);
+		}
+	}
+	shouldIgnoreChunk(chunk) {
+		const runId = getChunkRunId(chunk);
+		if (runId && this.clearedRunIds.has(runId)) {
+			if (chunk.type === "RUN_STARTED") {
+				this.ignoredActiveRunIds.add(runId);
+				this.currentRunlessRunId = runId;
+			}
+			this.markIgnoredChunkIds(chunk);
+			return true;
+		}
+		if (runId && this.ignoredActiveRunIds.has(runId)) {
+			this.markIgnoredChunkIds(chunk);
+			return true;
+		}
+		if (this.isRunlessChunkFromIgnoredRun(chunk)) {
+			this.markIgnoredChunkIds(chunk);
+			return true;
+		}
+		const toolCallId = getChunkToolCallId(chunk);
+		if (toolCallId && this.clearedToolCallIds.has(toolCallId)) return true;
+		const parentMessageId = getChunkParentMessageId(chunk);
+		if (parentMessageId && this.clearedMessageIds.has(parentMessageId)) {
+			if (toolCallId) this.clearedToolCallIds.add(toolCallId);
+			return true;
+		}
+		const messageId = getChunkMessageId(chunk);
+		return Boolean(messageId && this.clearedMessageIds.has(messageId));
+	}
+	onRunStarted(runId) {
+		this.currentRunlessRunId = runId;
+	}
+	onRunSettled(runId) {
+		this.ignoredActiveRunIds.delete(runId);
+		this.clearedRunIds.delete(runId);
+		if (this.currentRunlessRunId === runId) this.currentRunlessRunId = this.ignoredActiveRunIds.values().next().value ?? null;
+	}
+	onSessionRunError() {
+		this.ignoredActiveRunIds.clear();
+		this.currentRunlessRunId = null;
+	}
+	resetActiveRuns() {
+		this.ignoredActiveRunIds.clear();
+		this.currentRunlessRunId = null;
+	}
+	takeRunlessRunId() {
+		const runId = this.currentRunlessRunId;
+		if (!runId) return null;
+		this.ignoredActiveRunIds.delete(runId);
+		this.clearedRunIds.delete(runId);
+		this.currentRunlessRunId = this.ignoredActiveRunIds.values().next().value ?? null;
+		return runId;
+	}
+	markIgnoredChunkIds(chunk) {
+		const messageId = getChunkMessageId(chunk);
+		if (messageId) this.clearedMessageIds.add(messageId);
+		const toolCallId = getChunkToolCallId(chunk);
+		if (toolCallId) this.clearedToolCallIds.add(toolCallId);
+	}
+	isRunlessChunkFromIgnoredRun(chunk) {
+		if (getChunkRunId(chunk) || !this.currentRunlessRunId) return false;
+		if (!this.ignoredActiveRunIds.has(this.currentRunlessRunId) && !this.clearedRunIds.has(this.currentRunlessRunId)) return false;
+		return chunk.type === "TEXT_MESSAGE_START" || chunk.type === "TEXT_MESSAGE_CONTENT" || chunk.type === "TOOL_CALL_START" || chunk.type === "TOOL_CALL_ARGS" || chunk.type === "TOOL_CALL_END" || chunk.type === "TOOL_CALL_RESULT" || chunk.type === "MESSAGES_SNAPSHOT" || chunk.type === "RUN_ERROR";
+	}
+};
+//#endregion
+export { ClearedStreamTracker };
+
+//# sourceMappingURL=cleared-stream-tracker.js.map

package/dist/esm/cleared-stream-tracker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleared-stream-tracker.js","names":[],"sources":["../../src/cleared-stream-tracker.ts"],"sourcesContent":["import { getChunkRunId } from './connection-adapters'\nimport type { StreamChunk } from '@tanstack/ai/client'\nimport type { UIMessage } from './types'\n\nfunction getChunkToolCallId(chunk: StreamChunk): string | undefined {\n  return 'toolCallId' in chunk && typeof chunk.toolCallId === 'string'\n    ? chunk.toolCallId\n    : undefined\n}\n\nfunction getChunkMessageId(chunk: StreamChunk): string | undefined {\n  return 'messageId' in chunk && typeof chunk.messageId === 'string'\n    ? chunk.messageId\n    : undefined\n}\n\nfunction getChunkParentMessageId(chunk: StreamChunk): string | undefined {\n  return 'parentMessageId' in chunk && typeof chunk.parentMessageId === 'string'\n    ? chunk.parentMessageId\n    : undefined\n}\n\n/** Tracks stream chunks that must be ignored after the owning chat is cleared. */\nexport class ClearedStreamTracker {\n  private readonly clearedMessageIds = new Set<string>()\n  private readonly clearedRunIds = new Set<string>()\n  private readonly ignoredActiveRunIds = new Set<string>()\n  private readonly clearedToolCallIds = new Set<string>()\n  private currentRunlessRunId: string | null = null\n\n  snapshotClear(context: {\n    messages: Array<UIMessage>\n    activeRunIds: Set<string>\n    currentRunId: string | null\n  }): void {\n    for (const message of context.messages) {\n      this.clearedMessageIds.add(message.id)\n    }\n    for (const runId of context.activeRunIds) {\n      this.clearedRunIds.add(runId)\n      this.ignoredActiveRunIds.add(runId)\n    }\n    if (context.currentRunId) {\n      this.clearedRunIds.add(context.currentRunId)\n      this.ignoredActiveRunIds.add(context.currentRunId)\n    }\n  }\n\n  shouldIgnoreChunk(chunk: StreamChunk): boolean {\n    const runId = getChunkRunId(chunk)\n    if (runId && this.clearedRunIds.has(runId)) {\n      if (chunk.type === 'RUN_STARTED') {\n        this.ignoredActiveRunIds.add(runId)\n        this.currentRunlessRunId = runId\n      }\n      this.markIgnoredChunkIds(chunk)\n      return true\n    }\n\n    if (runId && this.ignoredActiveRunIds.has(runId)) {\n      this.markIgnoredChunkIds(chunk)\n      return true\n    }\n\n    if (this.isRunlessChunkFromIgnoredRun(chunk)) {\n      this.markIgnoredChunkIds(chunk)\n      return true\n    }\n\n    const toolCallId = getChunkToolCallId(chunk)\n    if (toolCallId && this.clearedToolCallIds.has(toolCallId)) {\n      return true\n    }\n\n    const parentMessageId = getChunkParentMessageId(chunk)\n    if (parentMessageId && this.clearedMessageIds.has(parentMessageId)) {\n      if (toolCallId) {\n        this.clearedToolCallIds.add(toolCallId)\n      }\n      return true\n    }\n\n    const messageId = getChunkMessageId(chunk)\n    return Boolean(messageId && this.clearedMessageIds.has(messageId))\n  }\n\n  onRunStarted(runId: string): void {\n    this.currentRunlessRunId = runId\n  }\n\n  onRunSettled(runId: string): void {\n    this.ignoredActiveRunIds.delete(runId)\n    this.clearedRunIds.delete(runId)\n    if (this.currentRunlessRunId === runId) {\n      this.currentRunlessRunId =\n        this.ignoredActiveRunIds.values().next().value ?? null\n    }\n  }\n\n  onSessionRunError(): void {\n    this.ignoredActiveRunIds.clear()\n    this.currentRunlessRunId = null\n  }\n\n  resetActiveRuns(): void {\n    this.ignoredActiveRunIds.clear()\n    this.currentRunlessRunId = null\n  }\n\n  takeRunlessRunId(): string | null {\n    const runId = this.currentRunlessRunId\n    if (!runId) return null\n    this.ignoredActiveRunIds.delete(runId)\n    this.clearedRunIds.delete(runId)\n    this.currentRunlessRunId =\n      this.ignoredActiveRunIds.values().next().value ?? null\n    return runId\n  }\n\n  private markIgnoredChunkIds(chunk: StreamChunk): void {\n    const messageId = getChunkMessageId(chunk)\n    if (messageId) {\n      this.clearedMessageIds.add(messageId)\n    }\n    const toolCallId = getChunkToolCallId(chunk)\n    if (toolCallId) {\n      this.clearedToolCallIds.add(toolCallId)\n    }\n  }\n\n  private isRunlessChunkFromIgnoredRun(chunk: StreamChunk): boolean {\n    const runId = getChunkRunId(chunk)\n    if (runId || !this.currentRunlessRunId) return false\n    if (\n      !this.ignoredActiveRunIds.has(this.currentRunlessRunId) &&\n      !this.clearedRunIds.has(this.currentRunlessRunId)\n    ) {\n      return false\n    }\n    return (\n      chunk.type === 'TEXT_MESSAGE_START' ||\n      chunk.type === 'TEXT_MESSAGE_CONTENT' ||\n      chunk.type === 'TOOL_CALL_START' ||\n      chunk.type === 'TOOL_CALL_ARGS' ||\n      chunk.type === 'TOOL_CALL_END' ||\n      chunk.type === 'TOOL_CALL_RESULT' ||\n      chunk.type === 'MESSAGES_SNAPSHOT' ||\n      chunk.type === 'RUN_ERROR'\n    )\n  }\n}\n"],"mappings":";;AAIA,SAAS,mBAAmB,OAAwC;CAClE,OAAO,gBAAgB,SAAS,OAAO,MAAM,eAAe,WACxD,MAAM,aACN,KAAA;AACN;AAEA,SAAS,kBAAkB,OAAwC;CACjE,OAAO,eAAe,SAAS,OAAO,MAAM,cAAc,WACtD,MAAM,YACN,KAAA;AACN;AAEA,SAAS,wBAAwB,OAAwC;CACvE,OAAO,qBAAqB,SAAS,OAAO,MAAM,oBAAoB,WAClE,MAAM,kBACN,KAAA;AACN;;AAGA,IAAa,uBAAb,MAAkC;CAChC,oCAAqC,IAAI,IAAY;CACrD,gCAAiC,IAAI,IAAY;CACjD,sCAAuC,IAAI,IAAY;CACvD,qCAAsC,IAAI,IAAY;CACtD,sBAA6C;CAE7C,cAAc,SAIL;EACP,KAAK,MAAM,WAAW,QAAQ,UAC5B,KAAK,kBAAkB,IAAI,QAAQ,EAAE;EAEvC,KAAK,MAAM,SAAS,QAAQ,cAAc;GACxC,KAAK,cAAc,IAAI,KAAK;GAC5B,KAAK,oBAAoB,IAAI,KAAK;EACpC;EACA,IAAI,QAAQ,cAAc;GACxB,KAAK,cAAc,IAAI,QAAQ,YAAY;GAC3C,KAAK,oBAAoB,IAAI,QAAQ,YAAY;EACnD;CACF;CAEA,kBAAkB,OAA6B;EAC7C,MAAM,QAAQ,cAAc,KAAK;EACjC,IAAI,SAAS,KAAK,cAAc,IAAI,KAAK,GAAG;GAC1C,IAAI,MAAM,SAAS,eAAe;IAChC,KAAK,oBAAoB,IAAI,KAAK;IAClC,KAAK,sBAAsB;GAC7B;GACA,KAAK,oBAAoB,KAAK;GAC9B,OAAO;EACT;EAEA,IAAI,SAAS,KAAK,oBAAoB,IAAI,KAAK,GAAG;GAChD,KAAK,oBAAoB,KAAK;GAC9B,OAAO;EACT;EAEA,IAAI,KAAK,6BAA6B,KAAK,GAAG;GAC5C,KAAK,oBAAoB,KAAK;GAC9B,OAAO;EACT;EAEA,MAAM,aAAa,mBAAmB,KAAK;EAC3C,IAAI,cAAc,KAAK,mBAAmB,IAAI,UAAU,GACtD,OAAO;EAGT,MAAM,kBAAkB,wBAAwB,KAAK;EACrD,IAAI,mBAAmB,KAAK,kBAAkB,IAAI,eAAe,GAAG;GAClE,IAAI,YACF,KAAK,mBAAmB,IAAI,UAAU;GAExC,OAAO;EACT;EAEA,MAAM,YAAY,kBAAkB,KAAK;EACzC,OAAO,QAAQ,aAAa,KAAK,kBAAkB,IAAI,SAAS,CAAC;CACnE;CAEA,aAAa,OAAqB;EAChC,KAAK,sBAAsB;CAC7B;CAEA,aAAa,OAAqB;EAChC,KAAK,oBAAoB,OAAO,KAAK;EACrC,KAAK,cAAc,OAAO,KAAK;EAC/B,IAAI,KAAK,wBAAwB,OAC/B,KAAK,sBACH,KAAK,oBAAoB,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,SAAS;CAExD;CAEA,oBAA0B;EACxB,KAAK,oBAAoB,MAAM;EAC/B,KAAK,sBAAsB;CAC7B;CAEA,kBAAwB;EACtB,KAAK,oBAAoB,MAAM;EAC/B,KAAK,sBAAsB;CAC7B;CAEA,mBAAkC;EAChC,MAAM,QAAQ,KAAK;EACnB,IAAI,CAAC,OAAO,OAAO;EACnB,KAAK,oBAAoB,OAAO,KAAK;EACrC,KAAK,cAAc,OAAO,KAAK;EAC/B,KAAK,sBACH,KAAK,oBAAoB,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,SAAS;EACpD,OAAO;CACT;CAEA,oBAA4B,OAA0B;EACpD,MAAM,YAAY,kBAAkB,KAAK;EACzC,IAAI,WACF,KAAK,kBAAkB,IAAI,SAAS;EAEtC,MAAM,aAAa,mBAAmB,KAAK;EAC3C,IAAI,YACF,KAAK,mBAAmB,IAAI,UAAU;CAE1C;CAEA,6BAAqC,OAA6B;EAEhE,IADc,cAAc,KACxB,KAAS,CAAC,KAAK,qBAAqB,OAAO;EAC/C,IACE,CAAC,KAAK,oBAAoB,IAAI,KAAK,mBAAmB,KACtD,CAAC,KAAK,cAAc,IAAI,KAAK,mBAAmB,GAEhD,OAAO;EAET,OACE,MAAM,SAAS,wBACf,MAAM,SAAS,0BACf,MAAM,SAAS,qBACf,MAAM,SAAS,oBACf,MAAM,SAAS,mBACf,MAAM,SAAS,sBACf,MAAM,SAAS,uBACf,MAAM,SAAS;CAEnB;AACF"}

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

@@ -1,15 +1,17 @@
 import { StreamChunk } from '@tanstack/ai/client';
-import { ChatClientPersistence, UIMessage } from './types.js';
+import { ChatClientPersistence, ChatPersistedState, ChatResumeSnapshot, UIMessage } from './types.js';
 /**
  * Encapsulates everything persistence-related for `ChatClient` so the client
  * itself stays focused on streaming and message state.
  *
  * Two responsibilities live here:
  *
- * 1. **Storage orchestration** — hydrate from `getItem(id)` on creation, save to
- *    `setItem(id, messages)` on every change through an ordered write queue, and
- *    `removeItem(id)` on clear. A generation counter discards stale writes when a
- *    removal or a newer conversation supersedes an in-flight async operation.
+ * 1. **Storage orchestration** — hydrate from `getItem(id)` on creation, save a
+ *    combined `{ messages, resume? }` record via `setItem` on every change
+ *    through an ordered write queue, and `removeItem(id)` on clear (or when
+ *    both the transcript and resume pointer are empty). A generation counter
+ *    discards stale writes when a removal or a newer conversation supersedes
+ *    an in-flight async operation.
  * 2. **Clear-during-stream suppression** — when a conversation is cleared while a
  *    stream is still producing, late chunks for the cleared run(s) must not
  *    repopulate the now-empty state. The persistor tracks the cleared ids and
@@ -22,33 +24,44 @@ export declare class ChatPersistor {
     private readonly adapter;
     private readonly id;
     private readonly applyMessages;
+    private readonly applyResume?;
     private skipNextPersist;
     private generation;
     private queue;
     private queuePending;
     private messagesGeneration;
+    private lastMessages;
+    private lastResume;
     private readonly clearedMessageIds;
     private readonly clearedRunIds;
     private readonly ignoredActiveRunIds;
     private readonly clearedToolCallIds;
     private currentRunlessRunId;
-    constructor(adapter: ChatClientPersistence, id: string, applyMessages: (messages: Array<UIMessage>) => void);
+    constructor(adapter: ChatClientPersistence, id: string, applyMessages: (messages: Array<UIMessage>) => void, applyResume?: ((snapshot: ChatResumeSnapshot) => void) | undefined);
+    /** Persist the current state as one combined `{ messages, resume? }` record. */
+    private writeState;
     /**
-     * Synchronously read the persisted messages for constructor-time hydration.
-     * Returns the raw `getItem` result (which may be a promise for async stores).
+     * Synchronously read the persisted state for constructor-time hydration.
+     * Returns the normalized combined record, or a promise of it for async stores.
      */
-    readInitial(): Array<UIMessage> | null | undefined | Promise<Array<UIMessage> | null | undefined>;
+    readInitial(): ChatPersistedState | undefined | Promise<ChatPersistedState | undefined>;
     /**
-     * Apply messages from an async `getItem` once it resolves, unless the message
+     * Apply state from an async `getItem` once it resolves, unless the message
      * list has already changed since hydration began.
      */
-    hydrateAsync(persistedMessages: Array<UIMessage> | null | undefined | Promise<Array<UIMessage> | null | undefined>): void;
+    hydrateAsync(persistedState: ChatPersistedState | undefined | Promise<ChatPersistedState | undefined>): void;
     /**
-     * Record a message-list change and queue a `setItem` write for it. Skips a
+     * Record a message-list change and queue a combined write for it. Skips a
      * single write after {@link beginClear} so the clear's empty snapshot isn't
      * persisted between `clearMessages()` and {@link remove}.
      */
     notifyMessagesChanged(messages: Array<UIMessage>): void;
+    /**
+     * Record the current resume snapshot (which run to rejoin / which interrupts
+     * are pending) and persist it alongside the messages. Pass `null` to clear it
+     * once the run reaches a non-interrupt terminal.
+     */
+    persistResumeSnapshot(snapshot: ChatResumeSnapshot | null): void;
     /** Remove the persisted conversation. Invalidates any queued writes. */
     remove(): void;
     private runOperation;

package/dist/esm/client-persistor.js

@@ -1,243 +1,268 @@
 import { getChunkRunId } from "./connection-adapters.js";
+//#region src/client-persistor.ts
+/** Normalize a raw `getItem` result (legacy bare array or combined record). */
+function normalizePersistedState(raw) {
+	if (Array.isArray(raw)) return { messages: raw };
+	if (raw && Array.isArray(raw.messages)) return raw;
+}
 function getChunkToolCallId(chunk) {
-  return "toolCallId" in chunk && typeof chunk.toolCallId === "string" ? chunk.toolCallId : void 0;
+	return "toolCallId" in chunk && typeof chunk.toolCallId === "string" ? chunk.toolCallId : void 0;
 }
 function getChunkMessageId(chunk) {
-  return "messageId" in chunk && typeof chunk.messageId === "string" ? chunk.messageId : void 0;
+	return "messageId" in chunk && typeof chunk.messageId === "string" ? chunk.messageId : void 0;
 }
 function getChunkParentMessageId(chunk) {
-  return "parentMessageId" in chunk && typeof chunk.parentMessageId === "string" ? chunk.parentMessageId : void 0;
-}
-class ChatPersistor {
-  constructor(adapter, id, applyMessages) {
-    this.adapter = adapter;
-    this.id = id;
-    this.applyMessages = applyMessages;
-  }
-  adapter;
-  id;
-  applyMessages;
-  // --- storage queue state ---
-  skipNextPersist = false;
-  generation = 0;
-  queue = Promise.resolve();
-  queuePending = false;
-  // Bumped on every message change; lets an in-flight async hydration detect
-  // that the message list moved on and avoid clobbering it.
-  messagesGeneration = 0;
-  // --- clear-during-stream suppression state ---
-  clearedMessageIds = /* @__PURE__ */ new Set();
-  clearedRunIds = /* @__PURE__ */ new Set();
-  ignoredActiveRunIds = /* @__PURE__ */ new Set();
-  clearedToolCallIds = /* @__PURE__ */ new Set();
-  currentRunlessRunId = null;
-  // ---------------------------------------------------------------------------
-  // Storage orchestration
-  // ---------------------------------------------------------------------------
-  /**
-   * Synchronously read the persisted messages for constructor-time hydration.
-   * Returns the raw `getItem` result (which may be a promise for async stores).
-   */
-  readInitial() {
-    try {
-      return this.adapter.getItem(this.id);
-    } catch {
-      return void 0;
-    }
-  }
-  /**
-   * Apply messages from an async `getItem` once it resolves, unless the message
-   * list has already changed since hydration began.
-   */
-  hydrateAsync(persistedMessages) {
-    if (!(persistedMessages instanceof Promise)) {
-      return;
-    }
-    const hydrationGeneration = this.messagesGeneration;
-    persistedMessages.then((messages) => {
-      if (Array.isArray(messages) && this.messagesGeneration === hydrationGeneration) {
-        this.applyMessages(messages);
-      }
-    }).catch(() => {
-    });
-  }
-  /**
-   * Record a message-list change and queue a `setItem` write for it. Skips a
-   * single write after {@link beginClear} so the clear's empty snapshot isn't
-   * persisted between `clearMessages()` and {@link remove}.
-   */
-  notifyMessagesChanged(messages) {
-    this.messagesGeneration++;
-    if (this.skipNextPersist) {
-      this.skipNextPersist = false;
-      return;
-    }
-    const generation = this.generation;
-    const messagesSnapshot = [...messages];
-    this.runOperation(() => {
-      if (generation !== this.generation) {
-        return;
-      }
-      return this.adapter.setItem(this.id, messagesSnapshot);
-    });
-  }
-  /** Remove the persisted conversation. Invalidates any queued writes. */
-  remove() {
-    const generation = ++this.generation;
-    this.runOperation(() => {
-      if (generation !== this.generation) {
-        return;
-      }
-      return this.adapter.removeItem(this.id);
-    });
-  }
-  runOperation(operation) {
-    if (this.queuePending) {
-      const queued = this.queue.then(operation).catch(() => {
-      });
-      this.queue = queued;
-      void queued.finally(() => {
-        if (this.queue === queued) {
-          this.queuePending = false;
-        }
-      });
-      return;
-    }
-    try {
-      const result = operation();
-      if (result instanceof Promise) {
-        this.queuePending = true;
-        const queued = result.catch(() => {
-        });
-        this.queue = queued;
-        void queued.finally(() => {
-          if (this.queue === queued) {
-            this.queuePending = false;
-          }
-        });
-      }
-    } catch {
-    }
-  }
-  // ---------------------------------------------------------------------------
-  // Clear-during-stream suppression
-  // ---------------------------------------------------------------------------
-  /**
-   * Capture the message/run ids that exist at the moment of a clear so chunks
-   * still arriving for them can be ignored.
-   */
-  snapshotClear(context) {
-    for (const message of context.messages) {
-      this.clearedMessageIds.add(message.id);
-    }
-    for (const runId of context.activeRunIds) {
-      this.clearedRunIds.add(runId);
-      this.ignoredActiveRunIds.add(runId);
-    }
-    if (context.currentRunId) {
-      this.clearedRunIds.add(context.currentRunId);
-      this.ignoredActiveRunIds.add(context.currentRunId);
-    }
-  }
-  /** Mark that the next persisted message change (the clear itself) is skipped. */
-  beginClear() {
-    this.skipNextPersist = true;
-  }
-  /** Whether a chunk belongs to cleared state and should not be processed. */
-  shouldIgnoreChunk(chunk) {
-    const runId = getChunkRunId(chunk);
-    if (runId && this.clearedRunIds.has(runId)) {
-      if (chunk.type === "RUN_STARTED") {
-        this.ignoredActiveRunIds.add(runId);
-        this.currentRunlessRunId = runId;
-      }
-      this.markIgnoredChunkIds(chunk);
-      return true;
-    }
-    if (runId && this.ignoredActiveRunIds.has(runId)) {
-      this.markIgnoredChunkIds(chunk);
-      return true;
-    }
-    if (this.isRunlessChunkFromIgnoredRun(chunk)) {
-      this.markIgnoredChunkIds(chunk);
-      return true;
-    }
-    const toolCallId = getChunkToolCallId(chunk);
-    if (toolCallId && this.clearedToolCallIds.has(toolCallId)) {
-      return true;
-    }
-    const parentMessageId = getChunkParentMessageId(chunk);
-    if (parentMessageId && this.clearedMessageIds.has(parentMessageId)) {
-      if (toolCallId) {
-        this.clearedToolCallIds.add(toolCallId);
-      }
-      return true;
-    }
-    const messageId = getChunkMessageId(chunk);
-    if (!messageId) {
-      return false;
-    }
-    if (this.clearedMessageIds.has(messageId)) {
-      return true;
-    }
-    return false;
-  }
-  /**
-   * The owning client calls this when a run starts so runless content chunks
-   * (adapters that omit `runId` on content events) can be attributed to it.
-   */
-  onRunStarted(runId) {
-    this.currentRunlessRunId = runId;
-  }
-  /** Forget a settled run, advancing the runless pointer to another ignored run. */
-  onRunSettled(runId) {
-    this.ignoredActiveRunIds.delete(runId);
-    this.clearedRunIds.delete(runId);
-    if (this.currentRunlessRunId === runId) {
-      this.currentRunlessRunId = this.ignoredActiveRunIds.values().next().value ?? null;
-    }
-  }
-  /** A session-level (runId-less) RUN_ERROR clears all ignored-run tracking. */
-  onSessionRunError() {
-    this.ignoredActiveRunIds.clear();
-    this.currentRunlessRunId = null;
-  }
-  /** Clear the ignored-active-run markers (mirrors a session-generating reset). */
-  resetIgnored() {
-    this.ignoredActiveRunIds.clear();
-  }
-  /**
-   * Consume the current runless run id (if any), forgetting it. Used when an
-   * ignored, runId-less RUN_ERROR drains the run the client is still tracking.
-   */
-  takeRunlessRunId() {
-    const runId = this.currentRunlessRunId;
-    if (!runId) return null;
-    this.ignoredActiveRunIds.delete(runId);
-    this.clearedRunIds.delete(runId);
-    this.currentRunlessRunId = this.ignoredActiveRunIds.values().next().value ?? null;
-    return runId;
-  }
-  markIgnoredChunkIds(chunk) {
-    const messageId = getChunkMessageId(chunk);
-    if (messageId) {
-      this.clearedMessageIds.add(messageId);
-    }
-    const toolCallId = getChunkToolCallId(chunk);
-    if (toolCallId) {
-      this.clearedToolCallIds.add(toolCallId);
-    }
-  }
-  isRunlessChunkFromIgnoredRun(chunk) {
-    const runId = getChunkRunId(chunk);
-    if (runId || !this.currentRunlessRunId) return false;
-    if (!this.ignoredActiveRunIds.has(this.currentRunlessRunId) && !this.clearedRunIds.has(this.currentRunlessRunId)) {
-      return false;
-    }
-    return chunk.type === "TEXT_MESSAGE_START" || chunk.type === "TEXT_MESSAGE_CONTENT" || chunk.type === "TOOL_CALL_START" || chunk.type === "TOOL_CALL_ARGS" || chunk.type === "TOOL_CALL_END" || chunk.type === "TOOL_CALL_RESULT" || chunk.type === "MESSAGES_SNAPSHOT" || chunk.type === "RUN_ERROR";
-  }
+	return "parentMessageId" in chunk && typeof chunk.parentMessageId === "string" ? chunk.parentMessageId : void 0;
 }
-export {
-  ChatPersistor
+/**
+* Encapsulates everything persistence-related for `ChatClient` so the client
+* itself stays focused on streaming and message state.
+*
+* Two responsibilities live here:
+*
+* 1. **Storage orchestration** — hydrate from `getItem(id)` on creation, save a
+*    combined `{ messages, resume? }` record via `setItem` on every change
+*    through an ordered write queue, and `removeItem(id)` on clear (or when
+*    both the transcript and resume pointer are empty). A generation counter
+*    discards stale writes when a removal or a newer conversation supersedes
+*    an in-flight async operation.
+* 2. **Clear-during-stream suppression** — when a conversation is cleared while a
+*    stream is still producing, late chunks for the cleared run(s) must not
+*    repopulate the now-empty state. The persistor tracks the cleared ids and
+*    decides, per chunk, whether the client should ignore it.
+*
+* All adapter calls are best-effort: a throwing or rejecting adapter is swallowed
+* so storage problems never break the chat.
+*/
+var ChatPersistor = class {
+	adapter;
+	id;
+	applyMessages;
+	applyResume;
+	skipNextPersist = false;
+	generation = 0;
+	queue = Promise.resolve();
+	queuePending = false;
+	messagesGeneration = 0;
+	lastMessages = [];
+	lastResume = null;
+	clearedMessageIds = /* @__PURE__ */ new Set();
+	clearedRunIds = /* @__PURE__ */ new Set();
+	ignoredActiveRunIds = /* @__PURE__ */ new Set();
+	clearedToolCallIds = /* @__PURE__ */ new Set();
+	currentRunlessRunId = null;
+	constructor(adapter, id, applyMessages, applyResume) {
+		this.adapter = adapter;
+		this.id = id;
+		this.applyMessages = applyMessages;
+		this.applyResume = applyResume;
+	}
+	/** Persist the current state as one combined `{ messages, resume? }` record. */
+	writeState() {
+		const messages = [...this.lastMessages];
+		if (messages.length === 0 && !this.lastResume) {
+			const generation = this.generation;
+			this.runOperation(() => {
+				if (generation !== this.generation) return;
+				return this.adapter.removeItem(this.id);
+			});
+			return;
+		}
+		const generation = this.generation;
+		const state = {
+			messages,
+			...this.lastResume ? { resume: this.lastResume } : {}
+		};
+		this.runOperation(() => {
+			if (generation !== this.generation) return;
+			return this.adapter.setItem(this.id, state);
+		});
+	}
+	/**
+	* Synchronously read the persisted state for constructor-time hydration.
+	* Returns the normalized combined record, or a promise of it for async stores.
+	*/
+	readInitial() {
+		try {
+			const raw = this.adapter.getItem(this.id);
+			if (raw instanceof Promise) return raw.then(normalizePersistedState).catch(() => void 0);
+			const state = normalizePersistedState(raw);
+			if (state) {
+				this.lastMessages = state.messages;
+				this.lastResume = state.resume ?? null;
+			}
+			return state;
+		} catch {
+			return;
+		}
+	}
+	/**
+	* Apply state from an async `getItem` once it resolves, unless the message
+	* list has already changed since hydration began.
+	*/
+	hydrateAsync(persistedState) {
+		if (!(persistedState instanceof Promise)) return;
+		const hydrationGeneration = this.messagesGeneration;
+		persistedState.then((state) => {
+			if (!state || this.messagesGeneration !== hydrationGeneration) return;
+			this.lastResume = state.resume ?? null;
+			this.lastMessages = state.messages;
+			this.applyMessages(state.messages);
+			if (state.resume && this.applyResume) this.applyResume(state.resume);
+		}).catch(() => {});
+	}
+	/**
+	* Record a message-list change and queue a combined write for it. Skips a
+	* single write after {@link beginClear} so the clear's empty snapshot isn't
+	* persisted between `clearMessages()` and {@link remove}.
+	*/
+	notifyMessagesChanged(messages) {
+		this.messagesGeneration++;
+		this.lastMessages = [...messages];
+		if (this.skipNextPersist) {
+			this.skipNextPersist = false;
+			return;
+		}
+		this.writeState();
+	}
+	/**
+	* Record the current resume snapshot (which run to rejoin / which interrupts
+	* are pending) and persist it alongside the messages. Pass `null` to clear it
+	* once the run reaches a non-interrupt terminal.
+	*/
+	persistResumeSnapshot(snapshot) {
+		this.lastResume = snapshot;
+		if (this.skipNextPersist) return;
+		this.writeState();
+	}
+	/** Remove the persisted conversation. Invalidates any queued writes. */
+	remove() {
+		this.lastMessages = [];
+		this.lastResume = null;
+		const generation = ++this.generation;
+		this.runOperation(() => {
+			if (generation !== this.generation) return;
+			return this.adapter.removeItem(this.id);
+		});
+	}
+	runOperation(operation) {
+		if (this.queuePending) {
+			const queued = this.queue.then(operation).catch(() => {});
+			this.queue = queued;
+			queued.finally(() => {
+				if (this.queue === queued) this.queuePending = false;
+			});
+			return;
+		}
+		try {
+			const result = operation();
+			if (result instanceof Promise) {
+				this.queuePending = true;
+				const queued = result.catch(() => {});
+				this.queue = queued;
+				queued.finally(() => {
+					if (this.queue === queued) this.queuePending = false;
+				});
+			}
+		} catch {}
+	}
+	/**
+	* Capture the message/run ids that exist at the moment of a clear so chunks
+	* still arriving for them can be ignored.
+	*/
+	snapshotClear(context) {
+		for (const message of context.messages) this.clearedMessageIds.add(message.id);
+		for (const runId of context.activeRunIds) {
+			this.clearedRunIds.add(runId);
+			this.ignoredActiveRunIds.add(runId);
+		}
+		if (context.currentRunId) {
+			this.clearedRunIds.add(context.currentRunId);
+			this.ignoredActiveRunIds.add(context.currentRunId);
+		}
+	}
+	/** Mark that the next persisted message change (the clear itself) is skipped. */
+	beginClear() {
+		this.skipNextPersist = true;
+	}
+	/** Whether a chunk belongs to cleared state and should not be processed. */
+	shouldIgnoreChunk(chunk) {
+		const runId = getChunkRunId(chunk);
+		if (runId && this.clearedRunIds.has(runId)) {
+			if (chunk.type === "RUN_STARTED") {
+				this.ignoredActiveRunIds.add(runId);
+				this.currentRunlessRunId = runId;
+			}
+			this.markIgnoredChunkIds(chunk);
+			return true;
+		}
+		if (runId && this.ignoredActiveRunIds.has(runId)) {
+			this.markIgnoredChunkIds(chunk);
+			return true;
+		}
+		if (this.isRunlessChunkFromIgnoredRun(chunk)) {
+			this.markIgnoredChunkIds(chunk);
+			return true;
+		}
+		const toolCallId = getChunkToolCallId(chunk);
+		if (toolCallId && this.clearedToolCallIds.has(toolCallId)) return true;
+		const parentMessageId = getChunkParentMessageId(chunk);
+		if (parentMessageId && this.clearedMessageIds.has(parentMessageId)) {
+			if (toolCallId) this.clearedToolCallIds.add(toolCallId);
+			return true;
+		}
+		const messageId = getChunkMessageId(chunk);
+		if (!messageId) return false;
+		if (this.clearedMessageIds.has(messageId)) return true;
+		return false;
+	}
+	/**
+	* The owning client calls this when a run starts so runless content chunks
+	* (adapters that omit `runId` on content events) can be attributed to it.
+	*/
+	onRunStarted(runId) {
+		this.currentRunlessRunId = runId;
+	}
+	/** Forget a settled run, advancing the runless pointer to another ignored run. */
+	onRunSettled(runId) {
+		this.ignoredActiveRunIds.delete(runId);
+		this.clearedRunIds.delete(runId);
+		if (this.currentRunlessRunId === runId) this.currentRunlessRunId = this.ignoredActiveRunIds.values().next().value ?? null;
+	}
+	/** A session-level (runId-less) RUN_ERROR clears all ignored-run tracking. */
+	onSessionRunError() {
+		this.ignoredActiveRunIds.clear();
+		this.currentRunlessRunId = null;
+	}
+	/** Clear the ignored-active-run markers (mirrors a session-generating reset). */
+	resetIgnored() {
+		this.ignoredActiveRunIds.clear();
+	}
+	/**
+	* Consume the current runless run id (if any), forgetting it. Used when an
+	* ignored, runId-less RUN_ERROR drains the run the client is still tracking.
+	*/
+	takeRunlessRunId() {
+		const runId = this.currentRunlessRunId;
+		if (!runId) return null;
+		this.ignoredActiveRunIds.delete(runId);
+		this.clearedRunIds.delete(runId);
+		this.currentRunlessRunId = this.ignoredActiveRunIds.values().next().value ?? null;
+		return runId;
+	}
+	markIgnoredChunkIds(chunk) {
+		const messageId = getChunkMessageId(chunk);
+		if (messageId) this.clearedMessageIds.add(messageId);
+		const toolCallId = getChunkToolCallId(chunk);
+		if (toolCallId) this.clearedToolCallIds.add(toolCallId);
+	}
+	isRunlessChunkFromIgnoredRun(chunk) {
+		if (getChunkRunId(chunk) || !this.currentRunlessRunId) return false;
+		if (!this.ignoredActiveRunIds.has(this.currentRunlessRunId) && !this.clearedRunIds.has(this.currentRunlessRunId)) return false;
+		return chunk.type === "TEXT_MESSAGE_START" || chunk.type === "TEXT_MESSAGE_CONTENT" || chunk.type === "TOOL_CALL_START" || chunk.type === "TOOL_CALL_ARGS" || chunk.type === "TOOL_CALL_END" || chunk.type === "TOOL_CALL_RESULT" || chunk.type === "MESSAGES_SNAPSHOT" || chunk.type === "RUN_ERROR";
+	}
 };
-//# sourceMappingURL=client-persistor.js.map
+//#endregion
+export { ChatPersistor };
+
+//# sourceMappingURL=client-persistor.js.map