@assistant-ui/ai-sdk 0.0.1

package/dist/runtime/useChatRuntime.js

@@ -0,0 +1,52 @@
+"use client";
+import { useChatThread } from "./useChatThread.js";
+import { useCloudThreadListAdapter, useRemoteThreadListRuntime } from "@assistant-ui/core/react";
+import { useAui, useAuiState } from "@assistant-ui/store";
+import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+//#region src/runtime/useChatRuntime.ts
+const useChatThreadRuntime = (options) => {
+	const $ = c(6);
+	const id = useAuiState(_temp);
+	const isMainThread = useAuiState(_temp2);
+	const aui = useAui();
+	let t0;
+	if ($[0] !== aui) {
+		t0 = () => aui.threadListItem.source ? aui.threadListItem : void 0;
+		$[0] = aui;
+		$[1] = t0;
+	} else t0 = $[1];
+	let t1;
+	if ($[2] !== id || $[3] !== isMainThread || $[4] !== t0) {
+		t1 = {
+			id,
+			isMainThread,
+			getThreadListItem: t0
+		};
+		$[2] = id;
+		$[3] = isMainThread;
+		$[4] = t0;
+		$[5] = t1;
+	} else t1 = $[5];
+	return useChatThread(options, t1);
+};
+const useChatRuntime = ({ cloud, onThreadIdChange, ...options } = {}) => {
+	const cloudAdapter = useCloudThreadListAdapter({ cloud });
+	return useRemoteThreadListRuntime({
+		runtimeHook: function RuntimeHook() {
+			return useChatThreadRuntime(options);
+		},
+		adapter: cloudAdapter,
+		allowNesting: true,
+		onThreadIdChange
+	});
+};
+function _temp(s) {
+	return s.threadListItem.id;
+}
+function _temp2(s_0) {
+	return s_0.threads.mainThreadId === s_0.threadListItem.id;
+}
+//#endregion
+export { useChatRuntime };
+
+//# sourceMappingURL=useChatRuntime.js.map

package/dist/runtime/useChatRuntime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useChatRuntime.js","names":["c","_c","UIMessage","AssistantCloud","AssistantRuntime","useCloudThreadListAdapter","useRemoteThreadListRuntime","useAui","useAuiState","useChatThread","ChatThreadOptions","UseChatRuntimeOptions","UI_MESSAGE","cloud","onThreadIdChange","threadId","useChatThreadRuntime","options","$","id","_temp","isMainThread","_temp2","aui","t0","threadListItem","source","undefined","t1","getThreadListItem","useChatRuntime","cloudAdapter","runtimeHook","RuntimeHook","adapter","allowNesting","s","s_0","threads","mainThreadId"],"sources":["../../src/runtime/useChatRuntime.ts"],"sourcesContent":["\"use client\";\n\nimport type { UIMessage } from \"@ai-sdk/react\";\nimport type { AssistantCloud } from \"assistant-cloud\";\nimport type { AssistantRuntime } from \"@assistant-ui/core\";\nimport {\n  useCloudThreadListAdapter,\n  useRemoteThreadListRuntime,\n} from \"@assistant-ui/core/react\";\nimport { useAui, useAuiState } from \"@assistant-ui/store\";\nimport { useChatThread, type ChatThreadOptions } from \"./useChatThread\";\n\nexport type UseChatRuntimeOptions<UI_MESSAGE extends UIMessage = UIMessage> =\n  ChatThreadOptions<UI_MESSAGE> & {\n    cloud?: AssistantCloud | undefined;\n    onThreadIdChange?: ((threadId: string | undefined) => void) | undefined;\n  };\n\nconst useChatThreadRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(\n  options?: ChatThreadOptions<UI_MESSAGE>,\n): AssistantRuntime => {\n  const id = useAuiState((s) => s.threadListItem.id);\n  const isMainThread = useAuiState(\n    (s) => s.threads.mainThreadId === s.threadListItem.id,\n  );\n  const aui = useAui();\n  return useChatThread(options, {\n    id,\n    isMainThread,\n    getThreadListItem: () =>\n      aui.threadListItem.source ? aui.threadListItem : undefined,\n  });\n};\n\nexport const useChatRuntime = <UI_MESSAGE extends UIMessage = UIMessage>({\n  cloud,\n  onThreadIdChange,\n  ...options\n}: UseChatRuntimeOptions<UI_MESSAGE> = {}): AssistantRuntime => {\n  const cloudAdapter = useCloudThreadListAdapter({ cloud });\n  return useRemoteThreadListRuntime({\n    runtimeHook: function RuntimeHook() {\n      return useChatThreadRuntime(options);\n    },\n    adapter: cloudAdapter,\n    allowNesting: true,\n    onThreadIdChange,\n  });\n};\n"],"mappings":";;;;;;AAkBA,MAAMgB,wBAAuBC,YAAA;CAAA,MAAAC,IAAAjB,EAAA,CAAA;CAG3B,MAAAkB,KAAWX,YAAYY,KAA0B;CACjD,MAAAC,eAAqBb,YACnBc,MACF;CACA,MAAAC,MAAYhB,OAAO;CAAE,IAAAiB;CAAA,IAAAN,EAAA,OAAAK,KAAA;EAIAC,WACjBD,IAAGE,eAAeC,SAAUH,IAAGE,iBAA/BE,KAAAA;EAA0DT,EAAA,KAAAK;EAAAL,EAAA,KAAAM;CAAA,OAAAA,KAAAN,EAAA;CAAA,IAAAU;CAAA,IAAAV,EAAA,OAAAC,MAAAD,EAAA,OAAAG,gBAAAH,EAAA,OAAAM,IAAA;EAJhCI,KAAA;GAAAT;GAAAE;GAAAQ,mBAGTL;EAErB;EAACN,EAAA,KAAAC;EAAAD,EAAA,KAAAG;EAAAH,EAAA,KAAAM;EAAAN,EAAA,KAAAU;CAAA,OAAAA,KAAAV,EAAA;CAAA,OALMT,cAAcQ,SAASW,EAK7B;AAAC;AAGJ,MAAaE,kBAA4D,EACvEjB,OACAC,kBACA,GAAGG,YACkC,CAAC,MAAwB;CAC9D,MAAMc,eAAe1B,0BAA0B,EAAEQ,MAAM,CAAC;CACxD,OAAOP,2BAA2B;EAChC0B,aAAa,SAASC,cAAc;GAClC,OAAOjB,qBAAqBC,OAAO;EACrC;EACAiB,SAASH;EACTI,cAAc;EACdrB;CACF,CAAC;AACH;AA9B6B,SAAAM,MAAAgB,GAAA;CAAA,OAGGA,EAACX,eAAeN;AAAG;AAHtB,SAAAG,OAAAe,KAAA;CAAA,OAKlBD,IAACE,QAAQC,iBAAkBH,IAACX,eAAeN;AAAG"}

package/dist/runtime/useChatThread.d.ts

@@ -0,0 +1,77 @@
+import { AISDKRuntimeAdapter, CustomToCreateMessageFunction } from "./useAISDKRuntime.js";
+import { InitializableThreadListItem } from "../transport/AssistantChatTransport.js";
+import { ChatInit, ChatTransport } from "ai";
+import { AssistantRuntime, ExternalStoreSharedOptions } from "@assistant-ui/core";
+import { Chat, UIMessage as UIMessage$1 } from "@ai-sdk/react";
+//#region src/runtime/useChatThread.d.ts
+type ChatThreadOptions<UI_MESSAGE extends UIMessage$1 = UIMessage$1> = ChatInit<UI_MESSAGE> & ExternalStoreSharedOptions & {
+  adapters?: AISDKRuntimeAdapter["adapters"] | undefined;
+  toCreateMessage?: CustomToCreateMessageFunction;
+  onResume?: AISDKRuntimeAdapter["onResume"];
+  onResumeToolCall?: AISDKRuntimeAdapter["onResumeToolCall"];
+  /**
+   * Called when an automatic resumable stream reconnect fails. Use this to
+   * surface a toast, report telemetry, or mark the thread as needing a
+   * retry. The failed stream id is cleared after the callback unless a
+   * newer id has replaced it.
+   */
+  onResumeError?: ((error: unknown) => void) | undefined;
+  joinStrategy?: AISDKRuntimeAdapter["joinStrategy"];
+};
+type ChatThreadEnvironment<UI_MESSAGE extends UIMessage$1 = UIMessage$1> = {
+  id: string;
+  isMainThread: boolean;
+  getThreadListItem: () => InitializableThreadListItem | undefined;
+  stopOnClientDestroy?: boolean;
+  /**
+   * An externally owned chat instance. State lives on the instance, so it
+   * survives the hosting resource unmounting; construction options are read
+   * from the instance.
+   */
+  chat?: Chat<UI_MESSAGE> | undefined;
+};
+/**
+ * Splits the combined options into the assistant-ui side and the `ChatInit`
+ * remainder the AI SDK consumes, so external `Chat` construction forwards the
+ * same fields `useChat` would.
+ */
+declare const splitChatThreadOptions: <UI_MESSAGE extends UIMessage$1>(options: ChatThreadOptions<UI_MESSAGE> | undefined) => {
+  adapters: ({
+    attachments?: import("@assistant-ui/core").AttachmentAdapter | undefined;
+    speech?: import("@assistant-ui/core").SpeechSynthesisAdapter | undefined;
+    dictation?: import("@assistant-ui/core").DictationAdapter | undefined;
+    voice?: import("@assistant-ui/core").RealtimeVoiceAdapter | undefined;
+    feedback?: import("@assistant-ui/core").FeedbackAdapter | undefined;
+    threadList?: import("@assistant-ui/core").ExternalStoreThreadListAdapter | undefined;
+  } & {
+    history?: import("@assistant-ui/core").ThreadHistoryAdapter | undefined;
+    suggestion?: import("@assistant-ui/core").SuggestionAdapter | undefined;
+  }) | undefined;
+  transport: ChatTransport<UI_MESSAGE> | undefined;
+  toCreateMessage: CustomToCreateMessageFunction | undefined;
+  onResume: ((config: import("@assistant-ui/core").ResumeRunConfig) => Promise<void>) | undefined;
+  onResumeToolCall: ((options: {
+    toolCallId: string;
+    payload: unknown;
+  }) => void) | undefined;
+  onResumeError: ((error: unknown) => void) | undefined;
+  joinStrategy: import("@assistant-ui/core/store").JoinStrategy | undefined;
+  chatInit: {
+    id?: string;
+    messageMetadataSchema?: import("ai").FlexibleSchema<UI_MESSAGE extends UIMessage$1<infer METADATA, import("ai").UIDataTypes, import("ai").UITools> ? METADATA : unknown>;
+    dataPartSchemas?: (UI_MESSAGE extends UIMessage$1<unknown, infer DATA_TYPES extends import("ai").UIDataTypes, import("ai").UITools> ? DATA_TYPES : import("ai").UIDataTypes) extends (infer T extends import("ai").UIDataTypes) ? { [K in keyof T]: import("ai").FlexibleSchema<T[K]>; } : never;
+    messages?: UI_MESSAGE[];
+    generateId?: import("ai").IdGenerator;
+    onError?: import("ai").ChatOnErrorCallback;
+    onToolCall?: import("ai").ChatOnToolCallCallback<UI_MESSAGE>;
+    onFinish?: import("ai").ChatOnFinishCallback<UI_MESSAGE>;
+    onData?: import("ai").ChatOnDataCallback<UI_MESSAGE>;
+    sendAutomaticallyWhen?: (options: {
+      messages: UI_MESSAGE[];
+    }) => boolean | PromiseLike<boolean>;
+  };
+};
+declare const useChatThread: <UI_MESSAGE extends UIMessage$1 = UIMessage$1>(options: ChatThreadOptions<UI_MESSAGE> | undefined, env: ChatThreadEnvironment<UI_MESSAGE>) => AssistantRuntime;
+//#endregion
+export { ChatThreadEnvironment, ChatThreadOptions, splitChatThreadOptions, useChatThread };
+//# sourceMappingURL=useChatThread.d.ts.map

package/dist/runtime/useChatThread.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useChatThread.d.ts","names":[],"sources":["../../src/runtime/useChatThread.ts"],"mappings":";;;;;;KA+BY,kBAAkB,mBAAmB,cAAY,eAC3D,SAAS,cACP;EACE,WAAW;EACX,kBAAkB;EAClB,WAAW;EACX,mBAAmB;;;;;;;EAOnB,kBAAkB;EAClB,eAAe;;KAGT,sBAAsB,mBAAmB,cAAY;EAC/D;EACA;EACA,yBAAyB;EACzB;;;;;;EAMA,OAAO,KAAK;;;;;;;cA4DD,yBAA0B,mBAAmB,aACxD,SAAS,kBAAkB;;;;;;;;;;;;;;;;;;;EA3EE,iBAAA;;;;;;;;;;;;;;;;;cA4GlB,gBAAiB,mBAAmB,cAAY,aAC3D,SAAS,kBAAkB,yBAC3B,KAAK,sBAAsB,gBAC1B"}

package/dist/runtime/useChatThread.js

@@ -0,0 +1,134 @@
+"use client";
+import { useAISDKRuntime } from "./useAISDKRuntime.js";
+import { AssistantChatTransport } from "../transport/AssistantChatTransport.js";
+import { useResourceCleanup } from "./useResourceCleanup.js";
+import { useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from "@assistant-ui/tap/react-shim";
+import { pickExternalStoreSharedOptions } from "@assistant-ui/core";
+import { useChat } from "@ai-sdk/react";
+//#region src/runtime/useChatThread.ts
+const useDynamicChatTransport = (transport) => {
+	const transportRef = useRef(transport);
+	useEffect(() => {
+		transportRef.current = transport;
+	});
+	return useMemo(() => new Proxy(transportRef.current, { get(_, prop) {
+		const res = transportRef.current[prop];
+		return typeof res === "function" ? res.bind(transportRef.current) : res;
+	} }), []);
+};
+const getResumableAdapter = (transport) => {
+	if (transport instanceof AssistantChatTransport) return transport.getResumableAdapter();
+	const candidate = transport.getResumableAdapter;
+	if (typeof candidate !== "function") return void 0;
+	return candidate.call(transport);
+};
+const getNoPendingStreamId = () => null;
+const resumedStreamIdsByStorage = /* @__PURE__ */ new WeakMap();
+const getResumedStreamIds = (storage) => {
+	if (!storage) return /* @__PURE__ */ new Set();
+	let resumedStreamIds = resumedStreamIdsByStorage.get(storage);
+	if (!resumedStreamIds) {
+		resumedStreamIds = /* @__PURE__ */ new Set();
+		resumedStreamIdsByStorage.set(storage, resumedStreamIds);
+	}
+	return resumedStreamIds;
+};
+/**
+* Splits the combined options into the assistant-ui side and the `ChatInit`
+* remainder the AI SDK consumes, so external `Chat` construction forwards the
+* same fields `useChat` would.
+*/
+const splitChatThreadOptions = (options) => {
+	const { adapters, transport, toCreateMessage, isDisabled: _isDisabled, isSendDisabled: _isSendDisabled, unstable_capabilities: _unstable_capabilities, suggestions: _suggestions, onResume, onResumeToolCall, onResumeError, joinStrategy, ...chatInit } = options ?? {};
+	return {
+		adapters,
+		transport,
+		toCreateMessage,
+		onResume,
+		onResumeToolCall,
+		onResumeError,
+		joinStrategy,
+		chatInit
+	};
+};
+const useChatThread = (options, env) => {
+	const { adapters, transport: transportOptions, toCreateMessage, onResume, onResumeToolCall, onResumeError, joinStrategy, chatInit: chatOptions } = splitChatThreadOptions(options);
+	const { id, isMainThread, getThreadListItem, stopOnClientDestroy = false, chat: externalChat } = env;
+	const defaultTransport = useMemo(() => new AssistantChatTransport(), []);
+	const sourceTransport = transportOptions ?? defaultTransport;
+	const transport = useDynamicChatTransport(sourceTransport);
+	const chat = useChat({
+		...chatOptions,
+		id,
+		transport,
+		...externalChat !== void 0 && { chat: externalChat }
+	});
+	useResourceCleanup(stopOnClientDestroy, () => {
+		chat.stop().catch(() => {});
+	});
+	const runtime = useAISDKRuntime(chat, {
+		adapters,
+		...pickExternalStoreSharedOptions(options ?? {}),
+		...toCreateMessage && { toCreateMessage },
+		...onResume && { onResume },
+		...onResumeToolCall && { onResumeToolCall },
+		...joinStrategy && { joinStrategy }
+	});
+	if (sourceTransport instanceof AssistantChatTransport) {
+		sourceTransport.setRuntime(runtime);
+		sourceTransport.__internal_setGetThreadListItem(getThreadListItem);
+	}
+	const subscribeToRuntime = useCallback((callback) => runtime.thread.subscribe(callback), [runtime]);
+	const getHistoryLoadingSnapshot = useCallback(() => runtime.thread.getState().isLoading, [runtime]);
+	const isLoadingHistory = useSyncExternalStore(subscribeToRuntime, getHistoryLoadingSnapshot, getHistoryLoadingSnapshot);
+	const resumableStorage = useMemo(() => getResumableAdapter(sourceTransport)?.storage, [sourceTransport]);
+	const subscribeToResumableStorage = useCallback((callback_0) => isMainThread ? resumableStorage?.subscribe?.(callback_0, id) ?? (() => {}) : () => {}, [
+		id,
+		isMainThread,
+		resumableStorage
+	]);
+	const getPendingStreamId = useCallback(() => isMainThread ? resumableStorage?.getStreamId(id) ?? null : null, [
+		id,
+		isMainThread,
+		resumableStorage
+	]);
+	const pendingStreamId = useSyncExternalStore(subscribeToResumableStorage, getPendingStreamId, getNoPendingStreamId);
+	const isChatRunning = chat.status === "submitted" || chat.status === "streaming";
+	const resumedStreamIds = useMemo(() => getResumedStreamIds(resumableStorage), [resumableStorage]);
+	const onResumeErrorRef = useRef(onResumeError);
+	useEffect(() => {
+		onResumeErrorRef.current = onResumeError;
+	});
+	useEffect(() => {
+		if (!pendingStreamId || resumedStreamIds.has(pendingStreamId)) return;
+		if (isChatRunning) {
+			resumedStreamIds.add(pendingStreamId);
+			return;
+		}
+		if (isLoadingHistory) return;
+		resumedStreamIds.add(pendingStreamId);
+		chat.resumeStream().catch((err) => {
+			console.warn("[assistant-ui] resumable: resume failed", err);
+			try {
+				onResumeErrorRef.current?.(err);
+			} catch (callbackError) {
+				console.error("[assistant-ui] resumable: onResumeError callback failed", callbackError);
+			} finally {
+				if (resumableStorage?.getStreamId(id) === pendingStreamId) resumableStorage.clear(id);
+			}
+		});
+	}, [
+		chat,
+		id,
+		isChatRunning,
+		isLoadingHistory,
+		pendingStreamId,
+		resumableStorage,
+		resumedStreamIds
+	]);
+	return runtime;
+};
+//#endregion
+export { splitChatThreadOptions, useChatThread };
+
+//# sourceMappingURL=useChatThread.js.map

package/dist/runtime/useChatThread.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useChatThread.js","names":["useChat","Chat","UIMessage","pickExternalStoreSharedOptions","AssistantRuntime","ExternalStoreSharedOptions","useAISDKRuntime","AISDKRuntimeAdapter","CustomToCreateMessageFunction","ChatInit","ChatTransport","AssistantChatTransport","InitializableThreadListItem","AssistantChatResumableOptions","ResumableClientStorage","useCallback","useEffect","useMemo","useRef","useSyncExternalStore","useResourceCleanup","ChatThreadOptions","UI_MESSAGE","adapters","toCreateMessage","onResume","onResumeToolCall","onResumeError","error","joinStrategy","ChatThreadEnvironment","id","isMainThread","getThreadListItem","stopOnClientDestroy","chat","useDynamicChatTransport","transport","transportRef","current","dynamicTransport","Proxy","get","_","prop","res","bind","getResumableAdapter","candidate","undefined","call","getNoPendingStreamId","resumedStreamIdsByStorage","WeakMap","Set","getResumedStreamIds","storage","resumedStreamIds","set","splitChatThreadOptions","options","isDisabled","_isDisabled","isSendDisabled","_isSendDisabled","unstable_capabilities","_unstable_capabilities","suggestions","_suggestions","chatInit","useChatThread","env","transportOptions","chatOptions","externalChat","defaultTransport","sourceTransport","stop","catch","runtime","setRuntime","__internal_setGetThreadListItem","subscribeToRuntime","callback","thread","subscribe","getHistoryLoadingSnapshot","getState","isLoading","isLoadingHistory","resumableStorage","subscribeToResumableStorage","getPendingStreamId","getStreamId","pendingStreamId","isChatRunning","status","onResumeErrorRef","has","add","resumeStream","err","console","warn","callbackError","clear"],"sources":["../../src/runtime/useChatThread.ts"],"sourcesContent":["\"use client\";\n\nimport { useChat, type Chat, type UIMessage } from \"@ai-sdk/react\";\nimport {\n  pickExternalStoreSharedOptions,\n  type AssistantRuntime,\n  type ExternalStoreSharedOptions,\n} from \"@assistant-ui/core\";\nimport {\n  useAISDKRuntime,\n  type AISDKRuntimeAdapter,\n  type CustomToCreateMessageFunction,\n} from \"./useAISDKRuntime\";\nimport type { ChatInit, ChatTransport } from \"ai\";\nimport {\n  AssistantChatTransport,\n  type InitializableThreadListItem,\n} from \"../transport/AssistantChatTransport\";\nimport type {\n  AssistantChatResumableOptions,\n  ResumableClientStorage,\n} from \"../transport/resumable\";\nimport {\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useSyncExternalStore,\n} from \"react\";\nimport { useResourceCleanup } from \"./useResourceCleanup\";\n\nexport type ChatThreadOptions<UI_MESSAGE extends UIMessage = UIMessage> =\n  ChatInit<UI_MESSAGE> &\n    ExternalStoreSharedOptions & {\n      adapters?: AISDKRuntimeAdapter[\"adapters\"] | undefined;\n      toCreateMessage?: CustomToCreateMessageFunction;\n      onResume?: AISDKRuntimeAdapter[\"onResume\"];\n      onResumeToolCall?: AISDKRuntimeAdapter[\"onResumeToolCall\"];\n      /**\n       * Called when an automatic resumable stream reconnect fails. Use this to\n       * surface a toast, report telemetry, or mark the thread as needing a\n       * retry. The failed stream id is cleared after the callback unless a\n       * newer id has replaced it.\n       */\n      onResumeError?: ((error: unknown) => void) | undefined;\n      joinStrategy?: AISDKRuntimeAdapter[\"joinStrategy\"];\n    };\n\nexport type ChatThreadEnvironment<UI_MESSAGE extends UIMessage = UIMessage> = {\n  id: string;\n  isMainThread: boolean;\n  getThreadListItem: () => InitializableThreadListItem | undefined;\n  stopOnClientDestroy?: boolean;\n  /**\n   * An externally owned chat instance. State lives on the instance, so it\n   * survives the hosting resource unmounting; construction options are read\n   * from the instance.\n   */\n  chat?: Chat<UI_MESSAGE> | undefined;\n};\n\nconst useDynamicChatTransport = <UI_MESSAGE extends UIMessage = UIMessage>(\n  transport: ChatTransport<UI_MESSAGE>,\n): ChatTransport<UI_MESSAGE> => {\n  const transportRef = useRef<ChatTransport<UI_MESSAGE>>(transport);\n  useEffect(() => {\n    transportRef.current = transport;\n  });\n  const dynamicTransport = useMemo(\n    () =>\n      new Proxy(transportRef.current, {\n        get(_, prop) {\n          const res =\n            transportRef.current[prop as keyof ChatTransport<UI_MESSAGE>];\n          return typeof res === \"function\"\n            ? res.bind(transportRef.current)\n            : res;\n        },\n      }),\n    [],\n  );\n  return dynamicTransport;\n};\n\nconst getResumableAdapter = <UI_MESSAGE extends UIMessage>(\n  transport: ChatTransport<UI_MESSAGE>,\n): AssistantChatResumableOptions | undefined => {\n  if (transport instanceof AssistantChatTransport) {\n    return transport.getResumableAdapter();\n  }\n  const candidate = (transport as { getResumableAdapter?: () => unknown })\n    .getResumableAdapter;\n  if (typeof candidate !== \"function\") return undefined;\n  return candidate.call(transport) as AssistantChatResumableOptions | undefined;\n};\n\nconst getNoPendingStreamId = () => null;\n\nconst resumedStreamIdsByStorage = new WeakMap<\n  ResumableClientStorage,\n  Set<string>\n>();\n\nconst getResumedStreamIds = (storage: ResumableClientStorage | undefined) => {\n  if (!storage) return new Set<string>();\n  let resumedStreamIds = resumedStreamIdsByStorage.get(storage);\n  if (!resumedStreamIds) {\n    resumedStreamIds = new Set();\n    resumedStreamIdsByStorage.set(storage, resumedStreamIds);\n  }\n  return resumedStreamIds;\n};\n\n/**\n * Splits the combined options into the assistant-ui side and the `ChatInit`\n * remainder the AI SDK consumes, so external `Chat` construction forwards the\n * same fields `useChat` would.\n */\nexport const splitChatThreadOptions = <UI_MESSAGE extends UIMessage>(\n  options: ChatThreadOptions<UI_MESSAGE> | undefined,\n) => {\n  const {\n    adapters,\n    transport,\n    toCreateMessage,\n    isDisabled: _isDisabled,\n    isSendDisabled: _isSendDisabled,\n    unstable_capabilities: _unstable_capabilities,\n    suggestions: _suggestions,\n    onResume,\n    onResumeToolCall,\n    onResumeError,\n    joinStrategy,\n    ...chatInit\n  } = options ?? {};\n  // peel guard: any shared key left in `chatInit` collapses this to `never`\n  true satisfies keyof typeof chatInit &\n    keyof ExternalStoreSharedOptions extends never\n    ? true\n    : never;\n  return {\n    adapters,\n    transport,\n    toCreateMessage,\n    onResume,\n    onResumeToolCall,\n    onResumeError,\n    joinStrategy,\n    chatInit,\n  };\n};\n\nexport const useChatThread = <UI_MESSAGE extends UIMessage = UIMessage>(\n  options: ChatThreadOptions<UI_MESSAGE> | undefined,\n  env: ChatThreadEnvironment<UI_MESSAGE>,\n): AssistantRuntime => {\n  const {\n    adapters,\n    transport: transportOptions,\n    toCreateMessage,\n    onResume,\n    onResumeToolCall,\n    onResumeError,\n    joinStrategy,\n    chatInit: chatOptions,\n  } = splitChatThreadOptions(options);\n\n  const {\n    id,\n    isMainThread,\n    getThreadListItem,\n    stopOnClientDestroy = false,\n    chat: externalChat,\n  } = env;\n\n  const defaultTransport = useMemo(() => new AssistantChatTransport(), []);\n  const sourceTransport = transportOptions ?? defaultTransport;\n  const transport = useDynamicChatTransport(sourceTransport);\n\n  const chat = useChat({\n    ...chatOptions,\n    id,\n    transport,\n    ...(externalChat !== undefined && { chat: externalChat }),\n  });\n\n  useResourceCleanup(stopOnClientDestroy, () => {\n    void chat.stop().catch(() => {});\n  });\n\n  const runtime = useAISDKRuntime(chat, {\n    adapters,\n    ...pickExternalStoreSharedOptions(options ?? {}),\n    ...(toCreateMessage && { toCreateMessage }),\n    ...(onResume && { onResume }),\n    ...(onResumeToolCall && { onResumeToolCall }),\n    ...(joinStrategy && { joinStrategy }),\n  });\n\n  if (sourceTransport instanceof AssistantChatTransport) {\n    sourceTransport.setRuntime(runtime);\n    sourceTransport.__internal_setGetThreadListItem(getThreadListItem);\n  }\n\n  const subscribeToRuntime = useCallback(\n    (callback: () => void) => runtime.thread.subscribe(callback),\n    [runtime],\n  );\n  const getHistoryLoadingSnapshot = useCallback(\n    () => runtime.thread.getState().isLoading,\n    [runtime],\n  );\n  const isLoadingHistory = useSyncExternalStore(\n    subscribeToRuntime,\n    getHistoryLoadingSnapshot,\n    getHistoryLoadingSnapshot,\n  );\n\n  const resumableStorage = useMemo(\n    () => getResumableAdapter(sourceTransport)?.storage,\n    [sourceTransport],\n  );\n  const subscribeToResumableStorage = useCallback(\n    (callback: () => void) =>\n      isMainThread\n        ? (resumableStorage?.subscribe?.(callback, id) ?? (() => {}))\n        : () => {},\n    [id, isMainThread, resumableStorage],\n  );\n  const getPendingStreamId = useCallback(\n    () => (isMainThread ? (resumableStorage?.getStreamId(id) ?? null) : null),\n    [id, isMainThread, resumableStorage],\n  );\n  const pendingStreamId = useSyncExternalStore(\n    subscribeToResumableStorage,\n    getPendingStreamId,\n    getNoPendingStreamId,\n  );\n  const isChatRunning =\n    chat.status === \"submitted\" || chat.status === \"streaming\";\n\n  const resumedStreamIds = useMemo(\n    () => getResumedStreamIds(resumableStorage),\n    [resumableStorage],\n  );\n  const onResumeErrorRef = useRef(onResumeError);\n  useEffect(() => {\n    onResumeErrorRef.current = onResumeError;\n  });\n  useEffect(() => {\n    if (!pendingStreamId || resumedStreamIds.has(pendingStreamId)) {\n      return;\n    }\n    if (isChatRunning) {\n      resumedStreamIds.add(pendingStreamId);\n      return;\n    }\n    if (isLoadingHistory) return;\n    resumedStreamIds.add(pendingStreamId);\n    chat.resumeStream().catch((err: unknown) => {\n      console.warn(\"[assistant-ui] resumable: resume failed\", err);\n      try {\n        onResumeErrorRef.current?.(err);\n      } catch (callbackError) {\n        console.error(\n          \"[assistant-ui] resumable: onResumeError callback failed\",\n          callbackError,\n        );\n      } finally {\n        if (resumableStorage?.getStreamId(id) === pendingStreamId) {\n          resumableStorage.clear(id);\n        }\n      }\n    });\n  }, [\n    chat,\n    id,\n    isChatRunning,\n    isLoadingHistory,\n    pendingStreamId,\n    resumableStorage,\n    resumedStreamIds,\n  ]);\n\n  return runtime;\n};\n"],"mappings":"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"}

package/dist/runtime/useExternalHistory.d.ts

@@ -0,0 +1,11 @@
+import { RefObject } from "react";
+import { AssistantRuntime, ExportedMessageRepository, MessageFormatAdapter, MessageFormatRepository, ThreadHistoryAdapter, ThreadMessage } from "@assistant-ui/core";
+//#region src/runtime/useExternalHistory.d.ts
+declare const toExportedMessageRepository: <TMessage>(toThreadMessages: (messages: TMessage[]) => ThreadMessage[], messages: MessageFormatRepository<TMessage>) => ExportedMessageRepository;
+declare const useExternalHistory: <TMessage>(runtimeRef: RefObject<AssistantRuntime>, historyAdapter: ThreadHistoryAdapter | undefined, toThreadMessages: (messages: TMessage[]) => ThreadMessage[], storageFormatAdapter: MessageFormatAdapter<TMessage, any>, onSetMessages: (messages: TMessage[]) => void) => {
+  isLoading: boolean;
+  deleteMessage: (messageId: string) => Promise<void>;
+};
+//#endregion
+export { toExportedMessageRepository, useExternalHistory };
+//# sourceMappingURL=useExternalHistory.d.ts.map

package/dist/runtime/useExternalHistory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExternalHistory.d.ts","names":[],"sources":["../../src/runtime/useExternalHistory.ts"],"mappings":";;;cAsBa,8BAA+B,UAC1C,mBAAmB,UAAU,eAAe,iBAC5C,UAAU,wBAAwB,cACjC;cAoCU,qBAAsB,UACjC,YAAY,UAAU,mBACtB,gBAAgB,kCAChB,mBAAmB,UAAU,eAAe,iBAC5C,sBAAsB,qBAAqB,gBAC3C,gBAAgB,UAAU;;EAsUN,gBAAA,sBAAM"}

package/dist/runtime/useExternalHistory.js

@@ -0,0 +1,278 @@
+"use client";
+import { useCallback, useEffect, useMemo, useRef, useState } from "@assistant-ui/tap/react-shim";
+import { getExternalStoreMessages } from "@assistant-ui/core";
+import { MessageRepository } from "@assistant-ui/core/internal";
+import { useAui } from "@assistant-ui/store";
+//#region src/runtime/useExternalHistory.ts
+const toExportedMessageRepository = (toThreadMessages, messages) => {
+	const survivingIds = /* @__PURE__ */ new Set();
+	const survivors = messages.messages.flatMap((m) => {
+		const message = toThreadMessages([m.message])[0];
+		if (!message) {
+			console.warn("Skipping a stored message that could not be loaded.");
+			return [];
+		}
+		if (m.parentId && !survivingIds.has(m.parentId)) return [];
+		survivingIds.add(message.id);
+		return [{
+			...m,
+			message
+		}];
+	});
+	return {
+		headId: messages.headId && survivingIds.has(messages.headId) ? messages.headId : null,
+		messages: survivors
+	};
+};
+const isAwaitingToolApproval = (message) => message.status?.type === "requires-action" && message.status.reason === "tool-calls";
+const snapshotExternalMessages = (messages) => new Map(messages.map((message) => [message.id, [...getExternalStoreMessages(message)]]));
+const useExternalHistory = (runtimeRef, historyAdapter, toThreadMessages, storageFormatAdapter, onSetMessages) => {
+	const loadedRef = useRef(false);
+	const [itemEpoch, setItemEpoch] = useState(0);
+	const aui = useAui();
+	const optionalThreadListItem = useCallback(() => aui.threadListItem.source ? aui.threadListItem : null, [aui]);
+	const [hasLoaded, setHasLoaded] = useState(false);
+	const historyIds = useRef(/* @__PURE__ */ new Set());
+	const persistedInnerIds = useRef(/* @__PURE__ */ new Set());
+	const deferredTelemetryIds = useRef(/* @__PURE__ */ new Set());
+	const persistedExternalMessages = useRef(/* @__PURE__ */ new Map());
+	const onSetMessagesRef = useRef(onSetMessages);
+	useEffect(() => {
+		onSetMessagesRef.current = onSetMessages;
+	});
+	const formatAdapter = useMemo(() => {
+		if (!historyAdapter) return void 0;
+		if (!historyAdapter.withFormat) throw new Error("useAISDKRuntime: ThreadHistoryAdapter is missing the required `withFormat` method.");
+		return historyAdapter.withFormat(storageFormatAdapter);
+	}, [historyAdapter, storageFormatAdapter]);
+	const isLoading = formatAdapter != null && !hasLoaded;
+	useEffect(() => {
+		if (!formatAdapter || loadedRef.current) return void 0;
+		const loadHistory = async () => {
+			try {
+				const repo = await formatAdapter.load();
+				if (repo && repo.messages.length > 0) {
+					for (const m of repo.messages) persistedInnerIds.current.add(storageFormatAdapter.getId(m.message));
+					const converted = toExportedMessageRepository(toThreadMessages, repo);
+					runtimeRef.current.thread.import(converted);
+					const tempRepo = new MessageRepository();
+					tempRepo.import(converted);
+					const messages = tempRepo.getMessages();
+					onSetMessagesRef.current(messages.flatMap(getExternalStoreMessages));
+					historyIds.current = /* @__PURE__ */ new Set();
+					for (const m_0 of converted.messages) {
+						historyIds.current.add(m_0.message.id);
+						if (isAwaitingToolApproval(m_0.message)) deferredTelemetryIds.current.add(m_0.message.id);
+					}
+					persistedExternalMessages.current = snapshotExternalMessages(converted.messages.map((m_1) => m_1.message));
+				}
+			} catch (error) {
+				console.error("Failed to load message history:", error);
+			} finally {
+				setHasLoaded(true);
+			}
+		};
+		formatAdapter.pin?.();
+		if (!optionalThreadListItem()?.getState().remoteId) {
+			setHasLoaded(true);
+			return aui.subscribe(() => {
+				if (optionalThreadListItem()?.getState().remoteId) setItemEpoch((n) => n + 1);
+			});
+		}
+		const threadState = runtimeRef.current.thread.getState();
+		if (threadState.isRunning || threadState.messages.length > 0) {
+			loadedRef.current = true;
+			setHasLoaded(true);
+			return;
+		}
+		loadedRef.current = true;
+		loadHistory();
+	}, [
+		formatAdapter,
+		toThreadMessages,
+		runtimeRef,
+		optionalThreadListItem,
+		aui,
+		itemEpoch,
+		storageFormatAdapter
+	]);
+	const runStartRef = useRef(null);
+	const persistTimerRef = useRef(null);
+	const persistInFlightRef = useRef(Promise.resolve());
+	const stepBoundariesRef = useRef([]);
+	const wasRunningRef = useRef(false);
+	const toolCallCountRef = useRef(0);
+	useEffect(() => {
+		if (!formatAdapter) return;
+		const adapter = formatAdapter;
+		const unsubscribe = runtimeRef.current.thread.subscribe(() => {
+			const threadState_0 = runtimeRef.current.thread.getState();
+			const { isRunning } = threadState_0;
+			const wasRunning = wasRunningRef.current;
+			wasRunningRef.current = isRunning;
+			if (runStartRef.current != null) {
+				const lastMsg = threadState_0.messages.at(-1);
+				if (lastMsg?.role === "assistant") {
+					const currentToolCallCount = lastMsg.content.filter((p) => p.type === "tool-call").length;
+					while (toolCallCountRef.current < currentToolCallCount) {
+						stepBoundariesRef.current.push(Date.now() - runStartRef.current);
+						toolCallCountRef.current++;
+					}
+				}
+			}
+			if (isRunning) {
+				if (runStartRef.current == null) {
+					runStartRef.current = Date.now();
+					stepBoundariesRef.current = [];
+					toolCallCountRef.current = 0;
+					adapter.pin?.();
+				}
+				if (persistTimerRef.current) {
+					clearTimeout(persistTimerRef.current);
+					persistTimerRef.current = null;
+				}
+				return;
+			}
+			if (!wasRunning) return;
+			if (runStartRef.current != null) stepBoundariesRef.current.push(Date.now() - runStartRef.current);
+			if (persistTimerRef.current) clearTimeout(persistTimerRef.current);
+			persistTimerRef.current = setTimeout(() => {
+				persistSettled(false);
+			}, 0);
+		});
+		function persistSettled(ignoreRunning) {
+			persistTimerRef.current = null;
+			const latest = runtimeRef.current.thread.getState();
+			if (!ignoreRunning && latest.isRunning) return;
+			const boundaries = stepBoundariesRef.current;
+			const durationMs = boundaries.length > 0 ? boundaries.at(-1) : void 0;
+			if (boundaries.length === 1 && durationMs != null) {
+				const lastAssistant = latest.messages.findLast((m_2) => m_2.role === "assistant");
+				if (lastAssistant) {
+					const tcCount = lastAssistant.content.filter((p_0) => p_0.type === "tool-call").length;
+					if (tcCount > 0) {
+						const totalSteps = tcCount + 1;
+						const stepDur = durationMs / totalSteps;
+						boundaries.length = 0;
+						for (let i = 0; i < totalSteps; i++) boundaries.push(Math.round((i + 1) * stepDur));
+					}
+				}
+			}
+			const stepTimestamps = boundaries.length > 1 ? boundaries.map((endMs, i_0) => ({
+				start_ms: i_0 === 0 ? 0 : boundaries[i_0 - 1],
+				end_ms: endMs
+			})) : void 0;
+			runStartRef.current = null;
+			stepBoundariesRef.current = [];
+			const telemetryOptions = {
+				...durationMs != null ? { durationMs } : void 0,
+				...stepTimestamps != null ? { stepTimestamps } : void 0
+			};
+			persistInFlightRef.current = persistInFlightRef.current.then(async () => {
+				const changedRunMessageIds = /* @__PURE__ */ new Set();
+				for (const message of latest.messages) {
+					const externalMessages = getExternalStoreMessages(message);
+					const previous = persistedExternalMessages.current.get(message.id);
+					if (previous === void 0 || previous.length !== externalMessages.length || externalMessages.some((item, index) => item !== previous[index])) changedRunMessageIds.add(message.id);
+				}
+				const { messages: messages_0 } = latest;
+				let lastInnerMessageId = null;
+				const failedUpdateIds = /* @__PURE__ */ new Set();
+				const getLastInnerId = (msgs) => msgs.length > 0 ? storageFormatAdapter.getId(msgs.at(-1)) : null;
+				const toBatchItems = (msgs_0) => msgs_0.map((msg, idx) => ({
+					parentId: idx === 0 ? lastInnerMessageId : storageFormatAdapter.getId(msgs_0[idx - 1]),
+					message: msg
+				}));
+				for (const message_0 of messages_0) {
+					const innerMessages = getExternalStoreMessages(message_0);
+					const isTerminal = message_0.status === void 0 || message_0.status.type === "complete" || message_0.status.type === "incomplete";
+					const isAwaitingToolCalls = isAwaitingToolApproval(message_0);
+					if (!(isTerminal || isAwaitingToolCalls && adapter.update !== void 0)) {
+						lastInnerMessageId = getLastInnerId(innerMessages) ?? lastInnerMessageId;
+						continue;
+					}
+					const isPersistedMessage = historyIds.current.has(message_0.id);
+					if (isPersistedMessage && !changedRunMessageIds.has(message_0.id)) {
+						lastInnerMessageId = getLastInnerId(innerMessages) ?? lastInnerMessageId;
+						continue;
+					}
+					if (!isPersistedMessage) {
+						historyIds.current.add(message_0.id);
+						deferredTelemetryIds.current.add(message_0.id);
+					}
+					const batchItems = toBatchItems(innerMessages);
+					for (const item_0 of batchItems) {
+						const innerId = storageFormatAdapter.getId(item_0.message);
+						if (!persistedInnerIds.current.has(innerId)) {
+							await adapter.append(item_0);
+							persistedInnerIds.current.add(innerId);
+						} else if (durationMs !== void 0) try {
+							await adapter.update?.(item_0, innerId);
+						} catch {
+							failedUpdateIds.add(message_0.id);
+						}
+					}
+					lastInnerMessageId = getLastInnerId(innerMessages) ?? lastInnerMessageId;
+					if (deferredTelemetryIds.current.has(message_0.id) && isTerminal) {
+						deferredTelemetryIds.current.delete(message_0.id);
+						adapter.reportTelemetry?.(batchItems, telemetryOptions);
+					}
+				}
+				const nextSnapshot = snapshotExternalMessages(latest.messages);
+				for (const id of failedUpdateIds) nextSnapshot.delete(id);
+				persistedExternalMessages.current = nextSnapshot;
+			}).catch((error_0) => {
+				console.error("Failed to persist message history:", error_0);
+			});
+		}
+		return () => {
+			unsubscribe();
+			if (persistTimerRef.current) {
+				clearTimeout(persistTimerRef.current);
+				persistTimerRef.current = null;
+				persistSettled(false);
+			}
+		};
+	}, [
+		formatAdapter,
+		storageFormatAdapter,
+		runtimeRef
+	]);
+	return {
+		isLoading,
+		deleteMessage: useCallback(async (messageId) => {
+			const deleteMessages = formatAdapter?.delete?.bind(formatAdapter);
+			if (!deleteMessages) return;
+			const messages_1 = runtimeRef.current.thread.getState().messages;
+			const messageIndex = messages_1.findIndex((m_3) => m_3.id === messageId);
+			if (messageIndex === -1) return;
+			const previousInnerMessages = messages_1.slice(0, messageIndex).flatMap(getExternalStoreMessages);
+			let parentId = previousInnerMessages.at(-1) ? storageFormatAdapter.getId(previousInnerMessages.at(-1)) : null;
+			const itemsToDelete = getExternalStoreMessages(messages_1[messageIndex]).map((message_1) => {
+				const item_1 = {
+					parentId,
+					message: message_1
+				};
+				parentId = storageFormatAdapter.getId(message_1);
+				return item_1;
+			});
+			const deletion = persistInFlightRef.current.then(async () => {
+				await deleteMessages(itemsToDelete);
+				historyIds.current.delete(messageId);
+				deferredTelemetryIds.current.delete(messageId);
+				persistedExternalMessages.current.delete(messageId);
+				for (const item_2 of itemsToDelete) persistedInnerIds.current.delete(storageFormatAdapter.getId(item_2.message));
+			});
+			persistInFlightRef.current = deletion.catch(() => {});
+			await deletion;
+		}, [
+			formatAdapter,
+			runtimeRef,
+			storageFormatAdapter
+		])
+	};
+};
+//#endregion
+export { toExportedMessageRepository, useExternalHistory };
+
+//# sourceMappingURL=useExternalHistory.js.map