assistant-cloud 0.1.43 → 0.2.1

package/dist/CloudEngagementReporter.js

@@ -0,0 +1,132 @@
+//#region src/CloudEngagementReporter.ts
+const MAX_REMEMBERED_THREADS = 256;
+function remember(map, threadId, value) {
+	map.delete(threadId);
+	map.set(threadId, value);
+	if (map.size > MAX_REMEMBERED_THREADS) map.delete(map.keys().next().value);
+}
+function mark(set, threadId) {
+	set.delete(threadId);
+	set.add(threadId);
+	if (set.size > MAX_REMEMBERED_THREADS) set.delete(set.values().next().value);
+}
+const passThroughIds = (threadId, messageId) => ({
+	thread_id: threadId,
+	...messageId !== void 0 ? { message_id: messageId } : void 0
+});
+/**
+* Derives engagement events from what a chat integration observes and keeps
+* the per thread state the events need: a run's start for the stop duration,
+* a run's end for the time to the next message, one error and one suggestion
+* list per run or thread. A started run is kept until it ends or stops; the
+* rest is kept for the 256 most recently touched threads, so a long session
+* does not grow it without bound. Delivery goes through the cloud's event
+* buffer, so a disabled telemetry setting drops everything here as well.
+*/
+var CloudEngagementReporter = class {
+	runStartedAt = /* @__PURE__ */ new Map();
+	runEndedAt = /* @__PURE__ */ new Map();
+	shownErrors = /* @__PURE__ */ new Set();
+	shownSuggestions = /* @__PURE__ */ new Set();
+	getCloud;
+	resolveIds;
+	constructor(cloud, resolveIds = passThroughIds) {
+		this.getCloud = typeof cloud === "function" ? cloud : () => cloud;
+		this.resolveIds = resolveIds;
+	}
+	runStarted(threadId) {
+		this.runStartedAt.set(threadId, Date.now());
+		this.shownErrors.delete(threadId);
+	}
+	runEnded(threadId) {
+		this.runStartedAt.delete(threadId);
+		remember(this.runEndedAt, threadId, Date.now());
+	}
+	/** Reported once per started run, with the time the run had been going. */
+	runStopped(threadId) {
+		const startedAt = this.runStartedAt.get(threadId);
+		if (startedAt === void 0) return;
+		this.runStartedAt.delete(threadId);
+		this.track("run_stopped", threadId, void 0, { value: Math.max(0, Date.now() - startedAt) });
+	}
+	/** Carries the time since the previous run of the thread ended, when known. */
+	messageSent(threadId, init) {
+		const previousRunEndedAt = this.runEndedAt.get(threadId);
+		this.track("message_sent", threadId, init.messageId, {
+			props: {
+				chars: init.chars,
+				attachments: init.attachments
+			},
+			...previousRunEndedAt !== void 0 ? { value: Math.max(0, Date.now() - previousRunEndedAt) } : void 0
+		}, { awaitThread: true });
+	}
+	messageEdited(threadId, init) {
+		this.track("message_edited", threadId, init.messageId, { props: { chars: init.chars } });
+	}
+	messageRegenerated(threadId, messageId) {
+		this.track("message_regenerated", threadId, messageId);
+	}
+	/** Reported once per run, so a retried render of the same error stays one event. */
+	errorShown(threadId, init) {
+		if (this.shownErrors.has(threadId)) return;
+		mark(this.shownErrors, threadId);
+		this.track("error_shown", threadId, init.messageId, { props: { reason: init.reason } });
+	}
+	/** Reported once per thread, with the number of suggestions on offer. */
+	suggestionsShown(threadId, count) {
+		if (this.shownSuggestions.has(threadId)) return;
+		mark(this.shownSuggestions, threadId);
+		this.track("suggestions_shown", threadId, void 0, { value: count });
+	}
+	suggestionClicked(threadId) {
+		this.track("suggestion_clicked", threadId);
+	}
+	attachmentAdded(threadId, init) {
+		this.track("attachment_added", threadId, init.messageId, { ...init.contentType ? { props: { type: init.contentType } } : void 0 });
+	}
+	attachmentFailed(threadId, init) {
+		this.track("attachment_failed", threadId, init.messageId, { ...init.contentType ? { props: { type: init.contentType } } : void 0 });
+	}
+	voiceStarted(threadId) {
+		this.track("voice_started", threadId);
+	}
+	speechStarted(threadId, messageId) {
+		this.track("speech_started", threadId, messageId);
+	}
+	branchSwitched(threadId, messageId) {
+		this.track("branch_switched", threadId, messageId);
+	}
+	messageCopied(threadId, messageId) {
+		this.track("message_copied", threadId, messageId);
+	}
+	toolApproved(threadId, messageId, toolCallId, toolName) {
+		this.track("tool_approved", threadId, messageId, { props: {
+			toolCallId,
+			toolName
+		} });
+	}
+	toolRejected(threadId, messageId, toolCallId, toolName) {
+		this.track("tool_rejected", threadId, messageId, { props: {
+			toolCallId,
+			toolName
+		} });
+	}
+	/** Reported only for a thread the cloud already knows. */
+	threadSwitched(threadId) {
+		this.track("thread_switched", threadId);
+	}
+	track(kind, threadId, messageId, init = {}, options = { awaitThread: false }) {
+		Promise.resolve().then(() => this.resolveIds(threadId, messageId, options)).then((ids) => {
+			if (kind === "thread_switched" && !ids.thread_id) return;
+			this.getCloud().events.track({
+				kind,
+				...init,
+				...ids
+			});
+		}).catch(() => {});
+	}
+};
+//#endregion
+export { CloudEngagementReporter };
+
+//# sourceMappingURL=CloudEngagementReporter.js.map

package/dist/CloudEngagementReporter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CloudEngagementReporter.js","names":[],"sources":["../src/CloudEngagementReporter.ts"],"sourcesContent":["import type { AssistantCloud } from \"./AssistantCloud\";\nimport type {\n  AssistantCloudEvent,\n  AssistantCloudEventKind,\n} from \"./AssistantCloudEvents\";\n\nexport type EngagementEventIds = Pick<\n  AssistantCloudEvent,\n  \"thread_id\" | \"message_id\" | \"run_id\"\n>;\n\n/**\n * Turns the ids an integration knows (its own thread and message ids) into the\n * ids the cloud stores. A send is the one event that may create the remote\n * thread, so it asks for `awaitThread`; every other event reads the ids that\n * already exist.\n */\nexport type EngagementIdResolver = (\n  threadId: string,\n  messageId: string | undefined,\n  options: { awaitThread: boolean },\n) => EngagementEventIds | Promise<EngagementEventIds>;\n\ntype EngagementEventInit = Pick<AssistantCloudEvent, \"value\" | \"props\">;\n\nconst MAX_REMEMBERED_THREADS = 256;\n\nfunction remember<T>(map: Map<string, T>, threadId: string, value: T): void {\n  map.delete(threadId);\n  map.set(threadId, value);\n  if (map.size > MAX_REMEMBERED_THREADS) {\n    map.delete(map.keys().next().value!);\n  }\n}\n\nfunction mark(set: Set<string>, threadId: string): void {\n  set.delete(threadId);\n  set.add(threadId);\n  if (set.size > MAX_REMEMBERED_THREADS) {\n    set.delete(set.values().next().value!);\n  }\n}\n\nconst passThroughIds: EngagementIdResolver = (threadId, messageId) => ({\n  thread_id: threadId,\n  ...(messageId !== undefined ? { message_id: messageId } : undefined),\n});\n\n/**\n * Derives engagement events from what a chat integration observes and keeps\n * the per thread state the events need: a run's start for the stop duration,\n * a run's end for the time to the next message, one error and one suggestion\n * list per run or thread. A started run is kept until it ends or stops; the\n * rest is kept for the 256 most recently touched threads, so a long session\n * does not grow it without bound. Delivery goes through the cloud's event\n * buffer, so a disabled telemetry setting drops everything here as well.\n */\nexport class CloudEngagementReporter {\n  private readonly runStartedAt = new Map<string, number>();\n  private readonly runEndedAt = new Map<string, number>();\n  private readonly shownErrors = new Set<string>();\n  private readonly shownSuggestions = new Set<string>();\n\n  private readonly getCloud: () => AssistantCloud;\n  private readonly resolveIds: EngagementIdResolver;\n\n  constructor(\n    cloud: AssistantCloud | (() => AssistantCloud),\n    resolveIds: EngagementIdResolver = passThroughIds,\n  ) {\n    this.getCloud = typeof cloud === \"function\" ? cloud : () => cloud;\n    this.resolveIds = resolveIds;\n  }\n\n  public runStarted(threadId: string): void {\n    this.runStartedAt.set(threadId, Date.now());\n    this.shownErrors.delete(threadId);\n  }\n\n  public runEnded(threadId: string): void {\n    this.runStartedAt.delete(threadId);\n    remember(this.runEndedAt, threadId, Date.now());\n  }\n\n  /** Reported once per started run, with the time the run had been going. */\n  public runStopped(threadId: string): void {\n    const startedAt = this.runStartedAt.get(threadId);\n    if (startedAt === undefined) return;\n    this.runStartedAt.delete(threadId);\n    this.track(\"run_stopped\", threadId, undefined, {\n      value: Math.max(0, Date.now() - startedAt),\n    });\n  }\n\n  /** Carries the time since the previous run of the thread ended, when known. */\n  public messageSent(\n    threadId: string,\n    init: {\n      messageId?: string | undefined;\n      chars: number;\n      attachments: number;\n    },\n  ): void {\n    const previousRunEndedAt = this.runEndedAt.get(threadId);\n    this.track(\n      \"message_sent\",\n      threadId,\n      init.messageId,\n      {\n        props: { chars: init.chars, attachments: init.attachments },\n        ...(previousRunEndedAt !== undefined\n          ? { value: Math.max(0, Date.now() - previousRunEndedAt) }\n          : undefined),\n      },\n      { awaitThread: true },\n    );\n  }\n\n  public messageEdited(\n    threadId: string,\n    init: { messageId: string; chars: number },\n  ): void {\n    this.track(\"message_edited\", threadId, init.messageId, {\n      props: { chars: init.chars },\n    });\n  }\n\n  public messageRegenerated(threadId: string, messageId?: string): void {\n    this.track(\"message_regenerated\", threadId, messageId);\n  }\n\n  /** Reported once per run, so a retried render of the same error stays one event. */\n  public errorShown(\n    threadId: string,\n    init: { messageId?: string | undefined; reason: string },\n  ): void {\n    if (this.shownErrors.has(threadId)) return;\n    mark(this.shownErrors, threadId);\n    this.track(\"error_shown\", threadId, init.messageId, {\n      props: { reason: init.reason },\n    });\n  }\n\n  /** Reported once per thread, with the number of suggestions on offer. */\n  public suggestionsShown(threadId: string, count: number): void {\n    if (this.shownSuggestions.has(threadId)) return;\n    mark(this.shownSuggestions, threadId);\n    this.track(\"suggestions_shown\", threadId, undefined, { value: count });\n  }\n\n  public suggestionClicked(threadId: string): void {\n    this.track(\"suggestion_clicked\", threadId);\n  }\n\n  public attachmentAdded(\n    threadId: string,\n    init: { messageId?: string | undefined; contentType?: string | undefined },\n  ): void {\n    this.track(\"attachment_added\", threadId, init.messageId, {\n      ...(init.contentType ? { props: { type: init.contentType } } : undefined),\n    });\n  }\n\n  public attachmentFailed(\n    threadId: string,\n    init: { messageId?: string | undefined; contentType?: string | undefined },\n  ): void {\n    this.track(\"attachment_failed\", threadId, init.messageId, {\n      ...(init.contentType ? { props: { type: init.contentType } } : undefined),\n    });\n  }\n\n  public voiceStarted(threadId: string): void {\n    this.track(\"voice_started\", threadId);\n  }\n\n  public speechStarted(threadId: string, messageId?: string): void {\n    this.track(\"speech_started\", threadId, messageId);\n  }\n\n  public branchSwitched(threadId: string, messageId?: string): void {\n    this.track(\"branch_switched\", threadId, messageId);\n  }\n\n  public messageCopied(threadId: string, messageId?: string): void {\n    this.track(\"message_copied\", threadId, messageId);\n  }\n\n  public toolApproved(\n    threadId: string,\n    messageId: string,\n    toolCallId: string,\n    toolName: string,\n  ): void {\n    this.track(\"tool_approved\", threadId, messageId, {\n      props: { toolCallId, toolName },\n    });\n  }\n\n  public toolRejected(\n    threadId: string,\n    messageId: string,\n    toolCallId: string,\n    toolName: string,\n  ): void {\n    this.track(\"tool_rejected\", threadId, messageId, {\n      props: { toolCallId, toolName },\n    });\n  }\n\n  /** Reported only for a thread the cloud already knows. */\n  public threadSwitched(threadId: string): void {\n    this.track(\"thread_switched\", threadId);\n  }\n\n  private track(\n    kind: AssistantCloudEventKind,\n    threadId: string,\n    messageId?: string,\n    init: EngagementEventInit = {},\n    options: { awaitThread: boolean } = { awaitThread: false },\n  ): void {\n    void Promise.resolve()\n      .then(() => this.resolveIds(threadId, messageId, options))\n      .then((ids) => {\n        if (kind === \"thread_switched\" && !ids.thread_id) return;\n        this.getCloud().events.track({ kind, ...init, ...ids });\n      })\n      .catch(() => {});\n  }\n}\n"],"mappings":"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"}

package/dist/CloudMessagePersistence.d.ts

@@ -3,15 +3,9 @@ import { AssistantCloud } from "./AssistantCloud.js";
 import { ReadonlyJSONObject } from "assistant-stream/utils";
 //#region src/CloudMessagePersistence.d.ts
 /**
- * Shared persistence logic for cloud message storage.
- *
- * Handles ID mapping (local → remote) and parent_id chaining for both:
- * - AssistantCloudThreadHistoryAdapter (assistant-ui runtime)
- * - useCloudChat (standalone AI SDK hook)
- *
- * The promise-based ID resolution handles concurrent appends — if message B's
- * parent is message A, and A is still being created, we await A's promise
- * to get its remote ID before creating B.
+ * Appends, updates and loads cloud messages while mapping local ids to cloud
+ * ids and chaining parent_id. A parent that is still being created is awaited,
+ * so concurrent appends land under the right parent.
  */
 declare class CloudMessagePersistence {
   private idMapping;
@@ -41,12 +35,18 @@ declare class CloudMessagePersistence {
    * Returns undefined if not persisted.
    */
   getRemoteId(messageId: string): Promise<string | undefined>;
+  getResolvedRemoteId(messageId: string): string | undefined;
   /**
    * Load messages from the cloud and populate the ID mapping.
    *
+   * The list endpoint caps a response at 200 rows, so pages are followed by
+   * message ID cursor until a short page and concatenated in server order.
+   *
    * The ID mapping is populated so that `isPersisted()` returns true for
    * loaded messages, preventing re-persistence of already-stored messages.
    *
+   * A loaded ID that an append already maps keeps the remote ID from that append, and falls back to the loaded ID if the append fails.
+   *
    * @param threadId - Remote thread ID
    * @param format - Optional format filter
    * @returns Array of cloud messages
@@ -54,6 +54,9 @@ declare class CloudMessagePersistence {
   load(threadId: string, format?: string): Promise<CloudMessage[]>;
   /**
    * Reset the ID mapping (call when switching threads).
+   *
+   * Pending `load()` and `append()` calls are not cancelled and still settle
+   * normally, but their results no longer populate the ID mapping.
    */
   reset(): void;
 }

package/dist/CloudMessagePersistence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CloudMessagePersistence.d.ts","names":[],"sources":["../src/CloudMessagePersistence.ts"],"mappings":";;;;;;;;;;;;;;;cAca;UACH;UACA;EAEI,YAAA,OAAO;EACP,YAAA,gBAAgB;;;;;;;;;;EActB,OACJ,kBACA,mBACA,yBACA,gBACA,SAAS,qBACR;;;;EAqCG,OACJ,kBACA,mBACA,iBACA,SAAS,qBACR;;;;EAeH,YAAY;;;;;EAQN,YAAY,oBAAoB;;;;;;;;;;;EAgBhC,KAAK,kBAAkB,kBAAe,QAhBN;;;;EAgCtC"}
+{"version":3,"file":"CloudMessagePersistence.d.ts","names":[],"sources":["../src/CloudMessagePersistence.ts"],"mappings":";;;;;;;;;cAWa;UACH;UACA;EAEI,YAAA,OAAO;EACP,YAAA,gBAAgB;;;;;;;;;;EActB,OACJ,kBACA,mBACA,yBACA,gBACA,SAAS,qBACR;;;;EAsCG,OACJ,kBACA,mBACA,iBACA,SAAS,qBACR;;;;EAeH,YAAY;;;;;EAQN,YAAY,oBAAoB;EAMtC,oBAAoB;;;;;;;;;;;;;;;;EAoBd,KAAK,kBAAkB,kBAAe,QAAA;;;;;;;EAmD5C"}

package/dist/CloudMessagePersistence.js

@@ -1,17 +1,12 @@
 //#region src/CloudMessagePersistence.ts
+const CLOUD_MESSAGE_PAGE_SIZE = 200;
 /**
-* Shared persistence logic for cloud message storage.
-*
-* Handles ID mapping (local → remote) and parent_id chaining for both:
-* - AssistantCloudThreadHistoryAdapter (assistant-ui runtime)
-* - useCloudChat (standalone AI SDK hook)
-*
-* The promise-based ID resolution handles concurrent appends — if message B's
-* parent is message A, and A is still being created, we await A's promise
-* to get its remote ID before creating B.
+* Appends, updates and loads cloud messages while mapping local ids to cloud
+* ids and chaining parent_id. A parent that is still being created is awaited,
+* so concurrent appends land under the right parent.
 */
 var CloudMessagePersistence = class {
-	idMapping = {};
+	idMapping = /* @__PURE__ */ new Map();
 	getCloud;
 	constructor(cloud) {
 		this.getCloud = typeof cloud === "function" ? cloud : () => cloud;
@@ -27,13 +22,14 @@ var CloudMessagePersistence = class {
 	*/
 	async append(threadId, messageId, parentId, format, content) {
 		const cloud = this.getCloud();
-		const existing = this.idMapping[messageId];
+		const existing = this.idMapping.get(messageId);
 		if (existing instanceof Promise) {
 			await existing;
 			return;
 		}
 		const task = (async () => {
-			const resolvedParentId = parentId ? await this.idMapping[parentId] ?? parentId : null;
+			const parentEntry = parentId ? this.idMapping.get(parentId) : void 0;
+			const resolvedParentId = parentId ? await parentEntry ?? parentId : null;
 			const { message_id } = await cloud.threads.messages.create(threadId, {
 				parent_id: resolvedParentId,
 				format,
@@ -41,12 +37,12 @@ var CloudMessagePersistence = class {
 			});
 			return message_id;
 		})();
-		this.idMapping[messageId] = task;
+		this.idMapping.set(messageId, task);
 		try {
 			const remoteId = await task;
-			if (this.idMapping[messageId] === task) this.idMapping[messageId] = remoteId;
+			if (this.idMapping.get(messageId) === task) this.idMapping.set(messageId, remoteId);
 		} catch (err) {
-			if (this.idMapping[messageId] === task) delete this.idMapping[messageId];
+			if (this.idMapping.get(messageId) === task) this.idMapping.delete(messageId);
 			throw err;
 		}
 	}
@@ -66,37 +62,75 @@ var CloudMessagePersistence = class {
 	* Check if a message has been persisted (or is currently being persisted).
 	*/
 	isPersisted(messageId) {
-		return messageId in this.idMapping;
+		return this.idMapping.has(messageId);
 	}
 	/**
 	* Get the remote ID for a local message ID (resolved).
 	* Returns undefined if not persisted.
 	*/
 	async getRemoteId(messageId) {
-		const entry = this.idMapping[messageId];
+		const entry = this.idMapping.get(messageId);
 		if (!entry) return void 0;
 		return entry;
 	}
+	getResolvedRemoteId(messageId) {
+		const entry = this.idMapping.get(messageId);
+		return typeof entry === "string" ? entry : void 0;
+	}
 	/**
 	* Load messages from the cloud and populate the ID mapping.
 	*
+	* The list endpoint caps a response at 200 rows, so pages are followed by
+	* message ID cursor until a short page and concatenated in server order.
+	*
 	* The ID mapping is populated so that `isPersisted()` returns true for
 	* loaded messages, preventing re-persistence of already-stored messages.
 	*
+	* A loaded ID that an append already maps keeps the remote ID from that append, and falls back to the loaded ID if the append fails.
+	*
 	* @param threadId - Remote thread ID
 	* @param format - Optional format filter
 	* @returns Array of cloud messages
 	*/
 	async load(threadId, format) {
-		const { messages } = await this.getCloud().threads.messages.list(threadId, format ? { format } : void 0);
-		for (const m of messages) this.idMapping[m.id] = m.id;
+		const idMapping = this.idMapping;
+		const cloud = this.getCloud();
+		const messages = [];
+		const seen = /* @__PURE__ */ new Set();
+		let after;
+		while (true) {
+			const page = await cloud.threads.messages.list(threadId, {
+				...format ? { format } : void 0,
+				limit: CLOUD_MESSAGE_PAGE_SIZE,
+				...after ? { after } : void 0
+			});
+			const last = page.messages.at(-1);
+			if (!last) break;
+			const fresh = page.messages.filter((m) => !seen.has(m.id));
+			if (fresh.length === 0) break;
+			for (const m of fresh) seen.add(m.id);
+			messages.push(...fresh);
+			if (page.messages.length < CLOUD_MESSAGE_PAGE_SIZE) break;
+			after = last.id;
+		}
+		if (this.idMapping === idMapping) for (const m of messages) {
+			const entry = idMapping.get(m.id);
+			if (entry === void 0) idMapping.set(m.id, m.id);
+			else if (entry instanceof Promise) entry.catch(() => {
+				const current = idMapping.get(m.id);
+				if (current === void 0 || current === entry) idMapping.set(m.id, m.id);
+			});
+		}
 		return messages;
 	}
 	/**
 	* Reset the ID mapping (call when switching threads).
+	*
+	* Pending `load()` and `append()` calls are not cancelled and still settle
+	* normally, but their results no longer populate the ID mapping.
 	*/
 	reset() {
-		this.idMapping = {};
+		this.idMapping = /* @__PURE__ */ new Map();
 	}
 };
 //#endregion

package/dist/CloudMessagePersistence.js.map

@@ -1 +1 @@
-{"version":3,"file":"CloudMessagePersistence.js","names":[],"sources":["../src/CloudMessagePersistence.ts"],"sourcesContent":["import type { ReadonlyJSONObject } from \"assistant-stream/utils\";\nimport type { AssistantCloud } from \"./AssistantCloud\";\n\n/**\n * Shared persistence logic for cloud message storage.\n *\n * Handles ID mapping (local → remote) and parent_id chaining for both:\n * - AssistantCloudThreadHistoryAdapter (assistant-ui runtime)\n * - useCloudChat (standalone AI SDK hook)\n *\n * The promise-based ID resolution handles concurrent appends — if message B's\n * parent is message A, and A is still being created, we await A's promise\n * to get its remote ID before creating B.\n */\nexport class CloudMessagePersistence {\n  private idMapping: Record<string, string | Promise<string>> = {};\n  private getCloud: () => AssistantCloud;\n\n  constructor(cloud: AssistantCloud);\n  constructor(getCloud: () => AssistantCloud);\n  constructor(cloud: AssistantCloud | (() => AssistantCloud)) {\n    this.getCloud = typeof cloud === \"function\" ? cloud : () => cloud;\n  }\n\n  /**\n   * Persist a message to the cloud.\n   *\n   * @param threadId - Remote thread ID\n   * @param messageId - Local message ID (used for tracking)\n   * @param parentId - Local parent message ID (or null for first message)\n   * @param format - Message format (e.g., \"aui/v0\", \"ai-sdk/v6\")\n   * @param content - Message content (format-specific)\n   */\n  async append(\n    threadId: string,\n    messageId: string,\n    parentId: string | null,\n    format: string,\n    content: ReadonlyJSONObject,\n  ): Promise<void> {\n    const cloud = this.getCloud();\n    const existing = this.idMapping[messageId];\n    if (existing instanceof Promise) {\n      await existing;\n      return;\n    }\n\n    const task = (async () => {\n      const resolvedParentId = parentId\n        ? ((await this.idMapping[parentId]) ?? parentId)\n        : null;\n      const { message_id } = await cloud.threads.messages.create(threadId, {\n        parent_id: resolvedParentId,\n        format,\n        content,\n      });\n      return message_id;\n    })();\n\n    this.idMapping[messageId] = task;\n    try {\n      const remoteId = await task;\n      if (this.idMapping[messageId] === task) {\n        this.idMapping[messageId] = remoteId;\n      }\n    } catch (err) {\n      if (this.idMapping[messageId] === task) {\n        delete this.idMapping[messageId];\n      }\n      throw err;\n    }\n  }\n\n  /**\n   * Update an already-persisted message in the cloud.\n   */\n  async update(\n    threadId: string,\n    messageId: string,\n    _format: string,\n    content: ReadonlyJSONObject,\n  ): Promise<void> {\n    const cloud = this.getCloud();\n    const remoteId = await this.getRemoteId(messageId);\n    if (!remoteId) {\n      console.warn(\n        `Skipping update for message ${messageId}: no remote id is mapped.`,\n      );\n      return;\n    }\n    await cloud.threads.messages.update(threadId, remoteId, { content });\n  }\n\n  /**\n   * Check if a message has been persisted (or is currently being persisted).\n   */\n  isPersisted(messageId: string): boolean {\n    return messageId in this.idMapping;\n  }\n\n  /**\n   * Get the remote ID for a local message ID (resolved).\n   * Returns undefined if not persisted.\n   */\n  async getRemoteId(messageId: string): Promise<string | undefined> {\n    const entry = this.idMapping[messageId];\n    if (!entry) return undefined;\n    return entry;\n  }\n\n  /**\n   * Load messages from the cloud and populate the ID mapping.\n   *\n   * The ID mapping is populated so that `isPersisted()` returns true for\n   * loaded messages, preventing re-persistence of already-stored messages.\n   *\n   * @param threadId - Remote thread ID\n   * @param format - Optional format filter\n   * @returns Array of cloud messages\n   */\n  async load(threadId: string, format?: string) {\n    const cloud = this.getCloud();\n    const { messages } = await cloud.threads.messages.list(\n      threadId,\n      format ? { format } : undefined,\n    );\n    // Populate ID mapping so isPersisted() recognizes loaded messages\n    for (const m of messages) {\n      this.idMapping[m.id] = m.id;\n    }\n    return messages;\n  }\n\n  /**\n   * Reset the ID mapping (call when switching threads).\n   */\n  reset() {\n    this.idMapping = {};\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAcA,IAAa,0BAAb,MAAqC;CACnC,YAA8D,CAAC;CAC/D;CAIA,YAAY,OAAgD;EAC1D,KAAK,WAAW,OAAO,UAAU,aAAa,cAAc;CAC9D;;;;;;;;;;CAWA,MAAM,OACJ,UACA,WACA,UACA,QACA,SACe;EACf,MAAM,QAAQ,KAAK,SAAS;EAC5B,MAAM,WAAW,KAAK,UAAU;EAChC,IAAI,oBAAoB,SAAS;GAC/B,MAAM;GACN;EACF;EAEA,MAAM,QAAQ,YAAY;GACxB,MAAM,mBAAmB,WACnB,MAAM,KAAK,UAAU,aAAc,WACrC;GACJ,MAAM,EAAE,eAAe,MAAM,MAAM,QAAQ,SAAS,OAAO,UAAU;IACnE,WAAW;IACX;IACA;GACF,CAAC;GACD,OAAO;EACT,EAAA,CAAG;EAEH,KAAK,UAAU,aAAa;EAC5B,IAAI;GACF,MAAM,WAAW,MAAM;GACvB,IAAI,KAAK,UAAU,eAAe,MAChC,KAAK,UAAU,aAAa;EAEhC,SAAS,KAAK;GACZ,IAAI,KAAK,UAAU,eAAe,MAChC,OAAO,KAAK,UAAU;GAExB,MAAM;EACR;CACF;;;;CAKA,MAAM,OACJ,UACA,WACA,SACA,SACe;EACf,MAAM,QAAQ,KAAK,SAAS;EAC5B,MAAM,WAAW,MAAM,KAAK,YAAY,SAAS;EACjD,IAAI,CAAC,UAAU;GACb,QAAQ,KACN,+BAA+B,UAAU,0BAC3C;GACA;EACF;EACA,MAAM,MAAM,QAAQ,SAAS,OAAO,UAAU,UAAU,EAAE,QAAQ,CAAC;CACrE;;;;CAKA,YAAY,WAA4B;EACtC,OAAO,aAAa,KAAK;CAC3B;;;;;CAMA,MAAM,YAAY,WAAgD;EAChE,MAAM,QAAQ,KAAK,UAAU;EAC7B,IAAI,CAAC,OAAO,OAAO,KAAA;EACnB,OAAO;CACT;;;;;;;;;;;CAYA,MAAM,KAAK,UAAkB,QAAiB;EAE5C,MAAM,EAAE,aAAa,MADP,KAAK,SACY,CAAC,CAAC,QAAQ,SAAS,KAChD,UACA,SAAS,EAAE,OAAO,IAAI,KAAA,CACxB;EAEA,KAAK,MAAM,KAAK,UACd,KAAK,UAAU,EAAE,MAAM,EAAE;EAE3B,OAAO;CACT;;;;CAKA,QAAQ;EACN,KAAK,YAAY,CAAC;CACpB;AACF"}
+{"version":3,"file":"CloudMessagePersistence.js","names":[],"sources":["../src/CloudMessagePersistence.ts"],"sourcesContent":["import type { ReadonlyJSONObject } from \"assistant-stream/utils\";\nimport type { AssistantCloud } from \"./AssistantCloud\";\nimport type { CloudMessage } from \"./AssistantCloudThreadMessages\";\n\nconst CLOUD_MESSAGE_PAGE_SIZE = 200;\n\n/**\n * Appends, updates and loads cloud messages while mapping local ids to cloud\n * ids and chaining parent_id. A parent that is still being created is awaited,\n * so concurrent appends land under the right parent.\n */\nexport class CloudMessagePersistence {\n  private idMapping = new Map<string, string | Promise<string>>();\n  private getCloud: () => AssistantCloud;\n\n  constructor(cloud: AssistantCloud);\n  constructor(getCloud: () => AssistantCloud);\n  constructor(cloud: AssistantCloud | (() => AssistantCloud)) {\n    this.getCloud = typeof cloud === \"function\" ? cloud : () => cloud;\n  }\n\n  /**\n   * Persist a message to the cloud.\n   *\n   * @param threadId - Remote thread ID\n   * @param messageId - Local message ID (used for tracking)\n   * @param parentId - Local parent message ID (or null for first message)\n   * @param format - Message format (e.g., \"aui/v0\", \"ai-sdk/v6\")\n   * @param content - Message content (format-specific)\n   */\n  async append(\n    threadId: string,\n    messageId: string,\n    parentId: string | null,\n    format: string,\n    content: ReadonlyJSONObject,\n  ): Promise<void> {\n    const cloud = this.getCloud();\n    const existing = this.idMapping.get(messageId);\n    if (existing instanceof Promise) {\n      await existing;\n      return;\n    }\n\n    const task = (async () => {\n      const parentEntry = parentId ? this.idMapping.get(parentId) : undefined;\n      const resolvedParentId = parentId\n        ? ((await parentEntry) ?? parentId)\n        : null;\n      const { message_id } = await cloud.threads.messages.create(threadId, {\n        parent_id: resolvedParentId,\n        format,\n        content,\n      });\n      return message_id;\n    })();\n\n    this.idMapping.set(messageId, task);\n    try {\n      const remoteId = await task;\n      if (this.idMapping.get(messageId) === task) {\n        this.idMapping.set(messageId, remoteId);\n      }\n    } catch (err) {\n      if (this.idMapping.get(messageId) === task) {\n        this.idMapping.delete(messageId);\n      }\n      throw err;\n    }\n  }\n\n  /**\n   * Update an already-persisted message in the cloud.\n   */\n  async update(\n    threadId: string,\n    messageId: string,\n    _format: string,\n    content: ReadonlyJSONObject,\n  ): Promise<void> {\n    const cloud = this.getCloud();\n    const remoteId = await this.getRemoteId(messageId);\n    if (!remoteId) {\n      console.warn(\n        `Skipping update for message ${messageId}: no remote id is mapped.`,\n      );\n      return;\n    }\n    await cloud.threads.messages.update(threadId, remoteId, { content });\n  }\n\n  /**\n   * Check if a message has been persisted (or is currently being persisted).\n   */\n  isPersisted(messageId: string): boolean {\n    return this.idMapping.has(messageId);\n  }\n\n  /**\n   * Get the remote ID for a local message ID (resolved).\n   * Returns undefined if not persisted.\n   */\n  async getRemoteId(messageId: string): Promise<string | undefined> {\n    const entry = this.idMapping.get(messageId);\n    if (!entry) return undefined;\n    return entry;\n  }\n\n  getResolvedRemoteId(messageId: string): string | undefined {\n    const entry = this.idMapping.get(messageId);\n    return typeof entry === \"string\" ? entry : undefined;\n  }\n\n  /**\n   * Load messages from the cloud and populate the ID mapping.\n   *\n   * The list endpoint caps a response at 200 rows, so pages are followed by\n   * message ID cursor until a short page and concatenated in server order.\n   *\n   * The ID mapping is populated so that `isPersisted()` returns true for\n   * loaded messages, preventing re-persistence of already-stored messages.\n   *\n   * A loaded ID that an append already maps keeps the remote ID from that append, and falls back to the loaded ID if the append fails.\n   *\n   * @param threadId - Remote thread ID\n   * @param format - Optional format filter\n   * @returns Array of cloud messages\n   */\n  async load(threadId: string, format?: string) {\n    const idMapping = this.idMapping;\n    const cloud = this.getCloud();\n    const messages: CloudMessage[] = [];\n    const seen = new Set<string>();\n    let after: string | undefined;\n\n    while (true) {\n      const page = await cloud.threads.messages.list(threadId, {\n        ...(format ? { format } : undefined),\n        limit: CLOUD_MESSAGE_PAGE_SIZE,\n        ...(after ? { after } : undefined),\n      });\n      const last = page.messages.at(-1);\n      if (!last) break;\n\n      // A cursor the server cannot resolve drops the keyset filter and replays\n      // an earlier page, so already-seen rows end the walk instead of repeating.\n      const fresh = page.messages.filter((m) => !seen.has(m.id));\n      if (fresh.length === 0) break;\n      for (const m of fresh) seen.add(m.id);\n\n      messages.push(...fresh);\n      if (page.messages.length < CLOUD_MESSAGE_PAGE_SIZE) break;\n      after = last.id;\n    }\n\n    if (this.idMapping === idMapping) {\n      for (const m of messages) {\n        const entry = idMapping.get(m.id);\n        if (entry === undefined) {\n          idMapping.set(m.id, m.id);\n        } else if (entry instanceof Promise) {\n          void entry.catch(() => {\n            const current = idMapping.get(m.id);\n            if (current === undefined || current === entry) {\n              idMapping.set(m.id, m.id);\n            }\n          });\n        }\n      }\n    }\n    return messages;\n  }\n\n  /**\n   * Reset the ID mapping (call when switching threads).\n   *\n   * Pending `load()` and `append()` calls are not cancelled and still settle\n   * normally, but their results no longer populate the ID mapping.\n   */\n  reset() {\n    this.idMapping = new Map();\n  }\n}\n"],"mappings":"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"}

package/dist/CloudRunReporter.d.ts

@@ -0,0 +1,20 @@
+import { RunReportInit } from "./runTelemetry.js";
+import { AssistantCloud } from "./AssistantCloud.js";
+//#region src/CloudRunReporter.d.ts
+type CloudRunReportInit = Omit<RunReportInit, "telemetry">;
+/**
+ * Sends run reports the way every client integration has to: nothing while
+ * telemetry is off, the cloud's environment, release and tags on every report,
+ * the `beforeReport` hook applied last, and a failed send that never surfaces.
+ * A report given a key is sent once per key, so an integration that observes
+ * the same finished run twice reports it once.
+ */
+declare class CloudRunReporter {
+  private readonly reported;
+  private readonly getCloud;
+  constructor(cloud: AssistantCloud | (() => AssistantCloud));
+  report(init: CloudRunReportInit, key?: string): Promise<void>;
+}
+//#endregion
+export { CloudRunReportInit, CloudRunReporter };
+//# sourceMappingURL=CloudRunReporter.d.ts.map

package/dist/CloudRunReporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CloudRunReporter.d.ts","names":[],"sources":["../src/CloudRunReporter.ts"],"mappings":";;;KAGY,qBAAqB,KAAK;;;;;;;;cASzB;mBACM;mBACA;EAEL,YAAA,OAAO,wBAAwB;EAI9B,OAAO,MAAM,oBAAoB,eAAe"}

package/dist/CloudRunReporter.js

@@ -0,0 +1,38 @@
+import { createRunReport } from "./runTelemetry.js";
+//#region src/CloudRunReporter.ts
+/**
+* Sends run reports the way every client integration has to: nothing while
+* telemetry is off, the cloud's environment, release and tags on every report,
+* the `beforeReport` hook applied last, and a failed send that never surfaces.
+* A report given a key is sent once per key, so an integration that observes
+* the same finished run twice reports it once.
+*/
+var CloudRunReporter = class {
+	reported = /* @__PURE__ */ new Set();
+	getCloud;
+	constructor(cloud) {
+		this.getCloud = typeof cloud === "function" ? cloud : () => cloud;
+	}
+	async report(init, key) {
+		try {
+			const cloud = this.getCloud();
+			if (!cloud.telemetry.enabled) return;
+			if (key !== void 0 && this.reported.has(key)) return;
+			const initial = createRunReport({
+				...init,
+				telemetry: cloud.telemetry
+			});
+			const { beforeReport } = cloud.telemetry;
+			const report = beforeReport ? beforeReport(initial) : initial;
+			if (!report) return;
+			if (key !== void 0) this.reported.add(key);
+			await cloud.runs.report(report);
+		} catch {
+			return;
+		}
+	}
+};
+//#endregion
+export { CloudRunReporter };
+
+//# sourceMappingURL=CloudRunReporter.js.map

package/dist/CloudRunReporter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CloudRunReporter.js","names":[],"sources":["../src/CloudRunReporter.ts"],"sourcesContent":["import type { AssistantCloud } from \"./AssistantCloud\";\nimport { createRunReport, type RunReportInit } from \"./runTelemetry\";\n\nexport type CloudRunReportInit = Omit<RunReportInit, \"telemetry\">;\n\n/**\n * Sends run reports the way every client integration has to: nothing while\n * telemetry is off, the cloud's environment, release and tags on every report,\n * the `beforeReport` hook applied last, and a failed send that never surfaces.\n * A report given a key is sent once per key, so an integration that observes\n * the same finished run twice reports it once.\n */\nexport class CloudRunReporter {\n  private readonly reported = new Set<string>();\n  private readonly getCloud: () => AssistantCloud;\n\n  constructor(cloud: AssistantCloud | (() => AssistantCloud)) {\n    this.getCloud = typeof cloud === \"function\" ? cloud : () => cloud;\n  }\n\n  public async report(init: CloudRunReportInit, key?: string): Promise<void> {\n    try {\n      const cloud = this.getCloud();\n      if (!cloud.telemetry.enabled) return;\n      if (key !== undefined && this.reported.has(key)) return;\n\n      const initial = createRunReport({ ...init, telemetry: cloud.telemetry });\n      const { beforeReport } = cloud.telemetry;\n      const report = beforeReport ? beforeReport(initial) : initial;\n      if (!report) return;\n\n      if (key !== undefined) this.reported.add(key);\n      await cloud.runs.report(report);\n    } catch {\n      return;\n    }\n  }\n}\n"],"mappings":";;;;;;;;;AAYA,IAAa,mBAAb,MAA8B;CAC5B,2BAA4B,IAAI,IAAY;CAC5C;CAEA,YAAY,OAAgD;EAC1D,KAAK,WAAW,OAAO,UAAU,aAAa,cAAc;CAC9D;CAEA,MAAa,OAAO,MAA0B,KAA6B;EACzE,IAAI;GACF,MAAM,QAAQ,KAAK,SAAS;GAC5B,IAAI,CAAC,MAAM,UAAU,SAAS;GAC9B,IAAI,QAAQ,KAAA,KAAa,KAAK,SAAS,IAAI,GAAG,GAAG;GAEjD,MAAM,UAAU,gBAAgB;IAAE,GAAG;IAAM,WAAW,MAAM;GAAU,CAAC;GACvE,MAAM,EAAE,iBAAiB,MAAM;GAC/B,MAAM,SAAS,eAAe,aAAa,OAAO,IAAI;GACtD,IAAI,CAAC,QAAQ;GAEb,IAAI,QAAQ,KAAA,GAAW,KAAK,SAAS,IAAI,GAAG;GAC5C,MAAM,MAAM,KAAK,OAAO,MAAM;EAChC,QAAQ;GACN;EACF;CACF;AACF"}

package/dist/FormattedCloudPersistence.d.ts

@@ -23,14 +23,9 @@ type MessageFormatAdapter<TMessage, TStorageFormat> = {
   getId(message: TMessage): string;
 };
 /**
- * Wraps a CloudMessagePersistence instance with format-aware encode/decode.
- *
- * This centralizes the pattern used by both:
- * - useCloudChat (standalone AI SDK hook)
- * - AssistantCloudThreadHistoryAdapter.withFormat() (assistant-ui runtime)
- *
- * The persistence parameter is typed structurally (not by class) so callers
- * don't need to import CloudMessagePersistence directly.
+ * Wraps a CloudMessagePersistence with a MessageFormatAdapter's encode and
+ * decode. The persistence parameter is typed structurally, so a caller does
+ * not need to import the class.
  */
 declare const createFormattedPersistence: <TMessage, TStorageFormat>(persistence: {
   append: (threadId: string, messageId: string, parentId: string | null, format: string, content: ReadonlyJSONObject) => Promise<void>;

package/dist/FormattedCloudPersistence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FormattedCloudPersistence.d.ts","names":[],"sources":["../src/FormattedCloudPersistence.ts"],"mappings":";;;;;;;KAOY,qBAAqB,UAAU;EACzC;EACA,OAAO;IAAQ;IAAyB,SAAS;MAAa;EAC9D,OAAO;IACL;IACA;IACA;IACA,SAAS;;IACL;IAAyB,SAAS;;EACxC,MAAM,SAAS;;;;;;;;;;;;cAaJ,6BAA8B,UAAU,gBACnD;EACE,SACE,kBACA,mBACA,yBACA,gBACA,SAAS,uBACN;EACL,OAAO,kBAAkB,oBAAoB;EAC7C,cAAc;EACd,UACE,kBACA,mBACA,gBACA,SAAS,uBACN;GAEP,SAAS,qBAAqB,UAAU;EAG5B,SAAA,kBAAM;IACR;IAAyB,SAAS;QACzC;EAaa,UAAA,kBAAM;IACR;IAAyB,SAAS;KAAU,sBAEnD;EAUgB,OAAA,qBAAM;;MA/Db;;;;EA+ES,cAAA"}
+{"version":3,"file":"FormattedCloudPersistence.d.ts","names":[],"sources":["../src/FormattedCloudPersistence.ts"],"mappings":";;;;;;;KAOY,qBAAqB,UAAU;EACzC;EACA,OAAO;IAAQ;IAAyB,SAAS;MAAa;EAC9D,OAAO;IACL;IACA;IACA;IACA,SAAS;;IACL;IAAyB,SAAS;;EACxC,MAAM,SAAS;;;;;;;cAQJ,6BAA8B,UAAU,gBACnD;EACE,SACE,kBACA,mBACA,yBACA,gBACA,SAAS,uBACN;EACL,OAAO,kBAAkB,oBAAoB;EAC7C,cAAc;EACd,UACE,kBACA,mBACA,gBACA,SAAS,uBACN;GAEP,SAAS,qBAAqB,UAAU;EAG5B,SAAA,kBAAM;IACR;IAAyB,SAAS;QACzC;EAaa,UAAA,kBAAM;IACR;IAAyB,SAAS;KAAU,sBAEnD;EAUgB,OAAA,qBAAM;;MA1Db;;;;EA0ES,cAAA"}

package/dist/FormattedCloudPersistence.js

@@ -1,13 +1,8 @@
 //#region src/FormattedCloudPersistence.ts
 /**
-* Wraps a CloudMessagePersistence instance with format-aware encode/decode.
-*
-* This centralizes the pattern used by both:
-* - useCloudChat (standalone AI SDK hook)
-* - AssistantCloudThreadHistoryAdapter.withFormat() (assistant-ui runtime)
-*
-* The persistence parameter is typed structurally (not by class) so callers
-* don't need to import CloudMessagePersistence directly.
+* Wraps a CloudMessagePersistence with a MessageFormatAdapter's encode and
+* decode. The persistence parameter is typed structurally, so a caller does
+* not need to import the class.
 */
 const createFormattedPersistence = (persistence, adapter) => ({
 	append: async (threadId, item) => {

package/dist/FormattedCloudPersistence.js.map

@@ -1 +1 @@
-{"version":3,"file":"FormattedCloudPersistence.js","names":[],"sources":["../src/FormattedCloudPersistence.ts"],"sourcesContent":["import type { ReadonlyJSONObject } from \"assistant-stream/utils\";\n\n/**\n * Format adapter shape — structurally identical to the MessageFormatAdapter\n * in @assistant-ui/react, but defined here to avoid cross-package type moves.\n * TypeScript's structural typing ensures these are interchangeable.\n */\nexport type MessageFormatAdapter<TMessage, TStorageFormat> = {\n  format: string;\n  encode(item: { parentId: string | null; message: TMessage }): TStorageFormat;\n  decode(stored: {\n    id: string;\n    parent_id: string | null;\n    format: string;\n    content: TStorageFormat;\n  }): { parentId: string | null; message: TMessage };\n  getId(message: TMessage): string;\n};\n\n/**\n * Wraps a CloudMessagePersistence instance with format-aware encode/decode.\n *\n * This centralizes the pattern used by both:\n * - useCloudChat (standalone AI SDK hook)\n * - AssistantCloudThreadHistoryAdapter.withFormat() (assistant-ui runtime)\n *\n * The persistence parameter is typed structurally (not by class) so callers\n * don't need to import CloudMessagePersistence directly.\n */\nexport const createFormattedPersistence = <TMessage, TStorageFormat>(\n  persistence: {\n    append: (\n      threadId: string,\n      messageId: string,\n      parentId: string | null,\n      format: string,\n      content: ReadonlyJSONObject,\n    ) => Promise<void>;\n    load: (threadId: string, format?: string) => Promise<any[]>;\n    isPersisted: (messageId: string) => boolean;\n    update?: (\n      threadId: string,\n      messageId: string,\n      format: string,\n      content: ReadonlyJSONObject,\n    ) => Promise<void>;\n  },\n  adapter: MessageFormatAdapter<TMessage, TStorageFormat>,\n) => ({\n  append: async (\n    threadId: string,\n    item: { parentId: string | null; message: TMessage },\n  ): Promise<void> => {\n    const messageId = adapter.getId(item.message);\n    const encoded = adapter.encode(item);\n    return persistence.append(\n      threadId,\n      messageId,\n      item.parentId,\n      adapter.format,\n      encoded as ReadonlyJSONObject,\n    );\n  },\n  update: persistence.update\n    ? async (\n        threadId: string,\n        item: { parentId: string | null; message: TMessage },\n        messageId: string,\n      ): Promise<void> => {\n        const encoded = adapter.encode(item);\n        return persistence.update!(\n          threadId,\n          messageId,\n          adapter.format,\n          encoded as ReadonlyJSONObject,\n        );\n      }\n    : undefined,\n  load: async (threadId: string) => {\n    const messages = await persistence.load(threadId, adapter.format);\n    return {\n      messages: messages\n        .filter((m) => m.format === adapter.format)\n        .map((m) =>\n          adapter.decode({\n            id: m.id,\n            parent_id: m.parent_id,\n            format: m.format,\n            content: m.content as TStorageFormat,\n          }),\n        )\n        .reverse(),\n    };\n  },\n  isPersisted: (messageId: string) => persistence.isPersisted(messageId),\n});\n"],"mappings":";;;;;;;;;;;AA6BA,MAAa,8BACX,aAiBA,aACI;CACJ,QAAQ,OACN,UACA,SACkB;EAClB,MAAM,YAAY,QAAQ,MAAM,KAAK,OAAO;EAC5C,MAAM,UAAU,QAAQ,OAAO,IAAI;EACnC,OAAO,YAAY,OACjB,UACA,WACA,KAAK,UACL,QAAQ,QACR,OACF;CACF;CACA,QAAQ,YAAY,SAChB,OACE,UACA,MACA,cACkB;EAClB,MAAM,UAAU,QAAQ,OAAO,IAAI;EACnC,OAAO,YAAY,OACjB,UACA,WACA,QAAQ,QACR,OACF;CACF,IACA,KAAA;CACJ,MAAM,OAAO,aAAqB;EAEhC,OAAO,EACL,WAAU,MAFW,YAAY,KAAK,UAAU,QAAQ,MAAM,EAAA,CAG3D,QAAQ,MAAM,EAAE,WAAW,QAAQ,MAAM,CAAC,CAC1C,KAAK,MACJ,QAAQ,OAAO;GACb,IAAI,EAAE;GACN,WAAW,EAAE;GACb,QAAQ,EAAE;GACV,SAAS,EAAE;EACb,CAAC,CACH,CAAC,CACA,QAAQ,EACb;CACF;CACA,cAAc,cAAsB,YAAY,YAAY,SAAS;AACvE"}
+{"version":3,"file":"FormattedCloudPersistence.js","names":[],"sources":["../src/FormattedCloudPersistence.ts"],"sourcesContent":["import type { ReadonlyJSONObject } from \"assistant-stream/utils\";\n\n/**\n * Format adapter shape — structurally identical to the MessageFormatAdapter\n * in @assistant-ui/react, but defined here to avoid cross-package type moves.\n * TypeScript's structural typing ensures these are interchangeable.\n */\nexport type MessageFormatAdapter<TMessage, TStorageFormat> = {\n  format: string;\n  encode(item: { parentId: string | null; message: TMessage }): TStorageFormat;\n  decode(stored: {\n    id: string;\n    parent_id: string | null;\n    format: string;\n    content: TStorageFormat;\n  }): { parentId: string | null; message: TMessage };\n  getId(message: TMessage): string;\n};\n\n/**\n * Wraps a CloudMessagePersistence with a MessageFormatAdapter's encode and\n * decode. The persistence parameter is typed structurally, so a caller does\n * not need to import the class.\n */\nexport const createFormattedPersistence = <TMessage, TStorageFormat>(\n  persistence: {\n    append: (\n      threadId: string,\n      messageId: string,\n      parentId: string | null,\n      format: string,\n      content: ReadonlyJSONObject,\n    ) => Promise<void>;\n    load: (threadId: string, format?: string) => Promise<any[]>;\n    isPersisted: (messageId: string) => boolean;\n    update?: (\n      threadId: string,\n      messageId: string,\n      format: string,\n      content: ReadonlyJSONObject,\n    ) => Promise<void>;\n  },\n  adapter: MessageFormatAdapter<TMessage, TStorageFormat>,\n) => ({\n  append: async (\n    threadId: string,\n    item: { parentId: string | null; message: TMessage },\n  ): Promise<void> => {\n    const messageId = adapter.getId(item.message);\n    const encoded = adapter.encode(item);\n    return persistence.append(\n      threadId,\n      messageId,\n      item.parentId,\n      adapter.format,\n      encoded as ReadonlyJSONObject,\n    );\n  },\n  update: persistence.update\n    ? async (\n        threadId: string,\n        item: { parentId: string | null; message: TMessage },\n        messageId: string,\n      ): Promise<void> => {\n        const encoded = adapter.encode(item);\n        return persistence.update!(\n          threadId,\n          messageId,\n          adapter.format,\n          encoded as ReadonlyJSONObject,\n        );\n      }\n    : undefined,\n  load: async (threadId: string) => {\n    const messages = await persistence.load(threadId, adapter.format);\n    return {\n      messages: messages\n        .filter((m) => m.format === adapter.format)\n        .map((m) =>\n          adapter.decode({\n            id: m.id,\n            parent_id: m.parent_id,\n            format: m.format,\n            content: m.content as TStorageFormat,\n          }),\n        )\n        .reverse(),\n    };\n  },\n  isPersisted: (messageId: string) => persistence.isPersisted(messageId),\n});\n"],"mappings":";;;;;;AAwBA,MAAa,8BACX,aAiBA,aACI;CACJ,QAAQ,OACN,UACA,SACkB;EAClB,MAAM,YAAY,QAAQ,MAAM,KAAK,OAAO;EAC5C,MAAM,UAAU,QAAQ,OAAO,IAAI;EACnC,OAAO,YAAY,OACjB,UACA,WACA,KAAK,UACL,QAAQ,QACR,OACF;CACF;CACA,QAAQ,YAAY,SAChB,OACE,UACA,MACA,cACkB;EAClB,MAAM,UAAU,QAAQ,OAAO,IAAI;EACnC,OAAO,YAAY,OACjB,UACA,WACA,QAAQ,QACR,OACF;CACF,IACA,KAAA;CACJ,MAAM,OAAO,aAAqB;EAEhC,OAAO,EACL,WAAU,MAFW,YAAY,KAAK,UAAU,QAAQ,MAAM,EAAA,CAG3D,QAAQ,MAAM,EAAE,WAAW,QAAQ,MAAM,CAAC,CAC1C,KAAK,MACJ,QAAQ,OAAO;GACb,IAAI,EAAE;GACN,WAAW,EAAE;GACb,QAAQ,EAAE;GACV,SAAS,EAAE;EACb,CAAC,CACH,CAAC,CACA,QAAQ,EACb;CACF;CACA,cAAc,cAAsB,YAAY,YAAY,SAAS;AACvE"}

package/dist/ai-sdk/index.d.ts

@@ -0,0 +1,33 @@
+import { RunMessageTelemetry } from "../runTelemetry.js";
+import { MessageFormatAdapter } from "../FormattedCloudPersistence.js";
+import { UIMessage } from "ai";
+//#region src/ai-sdk/index.d.ts
+type AISDKStorageFormat = Omit<UIMessage, "id">;
+/** The stored form of an AI SDK message: the message without its id. */
+declare const aiSDKV6FormatAdapter: MessageFormatAdapter<UIMessage, AISDKStorageFormat>;
+/**
+ * A message as an AI SDK integration holds it, or as the cloud stored it under
+ * the ai-sdk/v6 format, which drops the id. Parts are typed by their `type`
+ * alone, so this shape and the telemetry read from it need nothing from `ai`.
+ */
+type AISDKMessageLike = {
+  id?: string | undefined;
+  role: string;
+  parts: readonly {
+    type: string;
+    [key: string]: unknown;
+  }[];
+  metadata?: unknown;
+};
+/**
+ * Reads the run report fields out of the assistant messages of one run. A run
+ * the AI SDK streamed as one message is one element; a run the cloud stored as
+ * several assistant rows is aggregated, step by step, in order. Returns null
+ * when no assistant message is present. Status reads completed when the run
+ * produced text or tool calls, as a live finish with reason `tool-calls` does;
+ * an integration that observed the finish event overrides it.
+ */
+declare function extractAISDKRunTelemetry(messages: readonly AISDKMessageLike[]): RunMessageTelemetry | null;
+//#endregion
+export { AISDKMessageLike, AISDKStorageFormat, aiSDKV6FormatAdapter, extractAISDKRunTelemetry };
+//# sourceMappingURL=index.d.ts.map

package/dist/ai-sdk/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/ai-sdk/index.ts"],"mappings":";;;;KAeY,qBAAqB,KAAK;;cAGzB,sBAAsB,qBACjC,WACA;;;;;;KAgBU;EACV;EACA;EACA;IAAkB;KAAe;;EACjC;;;;;;;;;;iBAgHc,yBACd,mBAAmB,qBAClB"}