@ulearning/ai-sdk-adapter 0.0.0-stage → 1.0.0-next.0

package/dist/runtime/useChatThread.js

@@ -0,0 +1,255 @@
+"use client";
+import { useAISDKRuntime } from "./useAISDKRuntime.js";
+import { AssistantChatTransport } from "../transport/AssistantChatTransport.js";
+import { useChatSnapshot } from "./useChatSnapshot.js";
+import { useResourceCleanup } from "./useResourceCleanup.js";
+import { getResumableAdapter } from "./getResumableAdapter.js";
+import { DynamicChatTransport, getResumedStreamIds } from "./DynamicChatTransport.js";
+import { useDynamicChatTransport } from "./useDynamicChatTransport.js";
+import { pickExternalStoreSharedOptions } from "@ulearning/ai-core";
+import { useCallback, useEffect, useEffectEvent, useInsertionEffect, useMemo, useRef, useState, useSyncExternalStore } from "@ulearning/ai-tap";
+import { Chat } from "@ai-sdk/vue";
+// src/runtime/useChatThread.ts
+const getNoPendingStreamId = () => null;
+/**
+* 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, throttle, toCreateMessage, isDisabled: _isDisabled, isSendDisabled: _isSendDisabled, unstable_capabilities: _unstable_capabilities, suggestions: _suggestions, onResume, canResume, onResumeToolCall, onRespondToToolApproval, onResumeError, joinStrategy, messageRepository, unstable_onBranchChange, unstable_enableMessageQueue, ...chatInit } = options ?? {};
+	return {
+		adapters,
+		transport,
+		throttle,
+		toCreateMessage,
+		onResume,
+		canResume,
+		onResumeToolCall,
+		onRespondToToolApproval,
+		onResumeError,
+		joinStrategy,
+		messageRepository,
+		unstable_onBranchChange,
+		unstable_enableMessageQueue,
+		chatInit
+	};
+};
+const requestsByChat = /* @__PURE__ */ new WeakMap();
+/**
+* Constructs a `Chat` whose callbacks read the latest options through
+* `callbacksRef`, the forwarding `useChat` applies only to a chat it
+* constructs itself.
+*/
+const createChat = (init, callbacksRef) => {
+	const transport = init.transport;
+	const chat = new Chat({
+		...init,
+		...transport && { transport: {
+			get resumeStreamIsReplay() {
+				return transport.resumeStreamIsReplay ?? false;
+			},
+			sendMessages: (options) => {
+				requestsByChat.set(chat, {});
+				if (callbacksRef.current?.canResume) (callbacksRef.current.resumableStorage ?? getResumableAdapter(transport)?.storage)?.clear(options.chatId);
+				return transport.sendMessages(options);
+			},
+			reconnectToStream: async (options) => {
+				const request = {};
+				requestsByChat.set(chat, request);
+				try {
+					return await transport.reconnectToStream(options);
+				} catch (error) {
+					if (typeof error !== "object" || error === null || !("name" in error) || error.name !== "AbortError") request.reconnectFailure = { error };
+					throw error;
+				}
+			}
+		} },
+		onToolCall: (arg) => callbacksRef.current?.onToolCall?.(arg),
+		onData: (arg) => callbacksRef.current?.onData?.(arg),
+		onFinish: (arg) => callbacksRef.current?.onFinish?.(arg),
+		onError: (arg) => callbacksRef.current?.onError?.(arg),
+		sendAutomaticallyWhen: (arg) => callbacksRef.current?.sendAutomaticallyWhen?.(arg) ?? false
+	});
+	return chat;
+};
+const useChatThread = (options, env) => {
+	const { adapters, transport: transportOptions, throttle, toCreateMessage, onResume, canResume, onResumeToolCall, onRespondToToolApproval, onResumeError, joinStrategy, messageRepository, unstable_onBranchChange, unstable_enableMessageQueue, chatInit: chatOptions } = splitChatThreadOptions(options);
+	const { id, isMainThread, getThreadListItem, stopOnClientDestroy = true, hostDestroySignal, chat: externalChat, messageRepositoryInstance } = env;
+	const defaultTransport = useMemo(() => new AssistantChatTransport(), []);
+	const configuredTransport = transportOptions ?? defaultTransport;
+	const transport = useDynamicChatTransport(configuredTransport, externalChat === void 0);
+	const transportContextOwner = useMemo(() => ({}), []);
+	const getThreadListItemRef = useRef(getThreadListItem);
+	useInsertionEffect(() => {
+		getThreadListItemRef.current = getThreadListItem;
+	}, [getThreadListItem]);
+	const getCurrentThreadListItem = useCallback(() => getThreadListItemRef.current(), []);
+	const resumableStorage = useMemo(() => transport instanceof DynamicChatTransport ? transport.getCurrentResumableStorage() : getResumableAdapter(transport)?.storage, [transport]);
+	const transportBindingRef = useRef(null);
+	let initialTransportBinding = null;
+	const chatTransport = useMemo(() => transport instanceof DynamicChatTransport ? transport.createThreadProxy(transportContextOwner, () => {
+		const binding = transportBindingRef.current ?? initialTransportBinding;
+		if (!binding) throw new Error("Chat transport used before runtime setup");
+		return binding;
+	}) : transport, [
+		initialTransportBinding,
+		transport,
+		transportContextOwner
+	]);
+	const latestChatOptionsRef = useRef({
+		...chatOptions,
+		canResume,
+		resumableStorage
+	});
+	useEffect(() => {
+		latestChatOptionsRef.current = {
+			...chatOptions,
+			canResume,
+			resumableStorage
+		};
+	});
+	const [ownedChat] = useState(() => externalChat ?? createChat({
+		...chatOptions,
+		id,
+		transport: chatTransport
+	}, latestChatOptionsRef));
+	const chat = useChatSnapshot(externalChat ?? ownedChat, throttle);
+	useResourceCleanup(stopOnClientDestroy, () => {
+		chat.stop().catch(() => {});
+	}, hostDestroySignal);
+	const subscribeToResumableStorage = useCallback((callback) => isMainThread ? resumableStorage?.subscribe?.(callback, 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 staticResumedStreamIds = useMemo(() => getResumedStreamIds(resumableStorage), [resumableStorage]);
+	const onResumeErrorRef = useRef(onResumeError);
+	useEffect(() => {
+		onResumeErrorRef.current = onResumeError;
+	});
+	const resumeChatStream = chat.resumeStream;
+	const resumeStream = useCallback(async () => {
+		const resumedStreamIds = transport instanceof DynamicChatTransport ? transport.getResumedStreamIds() : staticResumedStreamIds;
+		const streamId = resumableStorage?.getStreamId(id);
+		if (!streamId) return;
+		resumedStreamIds.add(streamId);
+		try {
+			const activeChat = externalChat ?? ownedChat;
+			activeChat.clearError();
+			const pending = resumeChatStream();
+			const request = requestsByChat.get(activeChat);
+			await pending;
+			if (request?.reconnectFailure) throw request.reconnectFailure.error;
+			if (requestsByChat.get(activeChat) === request && activeChat.error) throw activeChat.error;
+		} catch (error) {
+			try {
+				onResumeErrorRef.current?.(error);
+			} catch (callbackError) {
+				console.error("[assistant-ui] resumable: onResumeError callback failed", callbackError);
+			} finally {
+				if (!canResume && resumableStorage?.getStreamId(id) === streamId) resumableStorage.clear(id);
+			}
+			throw error;
+		}
+	}, [
+		canResume,
+		externalChat,
+		id,
+		ownedChat,
+		resumeChatStream,
+		resumableStorage,
+		staticResumedStreamIds,
+		transport
+	]);
+	const handleBranchChange = useCallback((event) => {
+		if (canResume) resumableStorage?.clear(id);
+		unstable_onBranchChange?.(event);
+	}, [
+		canResume,
+		id,
+		resumableStorage,
+		unstable_onBranchChange
+	]);
+	const runtime = useAISDKRuntime(chat, {
+		adapters: {
+			...adapters,
+			threadList: {
+				threadId: id,
+				...adapters?.threadList
+			}
+		},
+		...pickExternalStoreSharedOptions(options ?? {}),
+		...toCreateMessage && { toCreateMessage },
+		...onResume ? { onResume } : canResume && resumableStorage ? { onResume: resumeStream } : {},
+		canResume: onResume ? !!canResume : !!canResume && !!pendingStreamId && !isChatRunning,
+		...onResumeToolCall && { onResumeToolCall },
+		...onRespondToToolApproval && { onRespondToToolApproval },
+		...joinStrategy && { joinStrategy },
+		...messageRepository && { messageRepository },
+		...messageRepositoryInstance && { unstable_messageRepositoryInstance: messageRepositoryInstance },
+		unstable_hostApprovalOwner: externalChat ?? ownedChat,
+		...(canResume && resumableStorage || unstable_onBranchChange) && { unstable_onBranchChange: handleBranchChange },
+		...unstable_enableMessageQueue && { unstable_enableMessageQueue }
+	});
+	initialTransportBinding = {
+		runtime,
+		getThreadListItem: getCurrentThreadListItem
+	};
+	useInsertionEffect(() => {
+		transportBindingRef.current = {
+			runtime,
+			getThreadListItem: getCurrentThreadListItem
+		};
+	}, [runtime, getCurrentThreadListItem]);
+	const registerTransportContext = useEffectEvent((dynamicTransport, chatId) => {
+		dynamicTransport.setThreadContext(chatId, transportContextOwner, runtime, getCurrentThreadListItem);
+		return () => dynamicTransport.unregisterThread(chatId, transportContextOwner);
+	});
+	useInsertionEffect(() => {
+		if (!(transport instanceof DynamicChatTransport)) return void 0;
+		return registerTransportContext(transport, id);
+	}, [
+		id,
+		runtime,
+		transport,
+		transportContextOwner
+	]);
+	if (!(transport instanceof DynamicChatTransport) && configuredTransport instanceof AssistantChatTransport) {
+		configuredTransport.setRuntime(runtime);
+		configuredTransport.__internal_setGetThreadListItem(getCurrentThreadListItem);
+	}
+	const subscribeToRuntime = useCallback((callback) => runtime.thread.subscribe(callback), [runtime]);
+	const getHistoryLoadingSnapshot = useCallback(() => runtime.thread.getState().isLoading, [runtime]);
+	const isLoadingHistory = useSyncExternalStore(subscribeToRuntime, getHistoryLoadingSnapshot, getHistoryLoadingSnapshot);
+	useEffect(() => {
+		const resumedStreamIds = transport instanceof DynamicChatTransport ? transport.getResumedStreamIds() : staticResumedStreamIds;
+		if (!pendingStreamId || resumedStreamIds.has(pendingStreamId)) return;
+		if (isChatRunning) {
+			resumedStreamIds.add(pendingStreamId);
+			return;
+		}
+		if (isLoadingHistory) return;
+		resumeStream().catch((err) => {
+			console.warn("[assistant-ui] resumable: resume failed", err);
+		});
+	}, [
+		isChatRunning,
+		isLoadingHistory,
+		pendingStreamId,
+		resumeStream,
+		staticResumedStreamIds,
+		transport
+	]);
+	return runtime;
+};
+export { createChat, splitChatThreadOptions, useChatThread };
+
+//# sourceMappingURL=useChatThread.js.map

package/dist/runtime/useChatThread.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useChatThread.js","names":[],"sources":["../../src/runtime/useChatThread.ts"],"sourcesContent":["\"use client\";\n\nimport { Chat } from \"@ai-sdk/vue\";\nimport type { UIMessage } from \"ai\";\nimport { useChatSnapshot } from \"./useChatSnapshot\";\nimport type { MessageRepository } from \"@ulearning/ai-core/internal\";\nimport {\n  pickExternalStoreSharedOptions,\n  type AssistantRuntime,\n  type ExternalStoreSharedOptions,\n} from \"@ulearning/ai-core\";\nimport {\n  useAISDKRuntime,\n  type AISDKRuntimeAdapter,\n  type CustomToCreateMessageFunction,\n} from \"./useAISDKRuntime\";\nimport type { ChatInit } from \"ai\";\nimport {\n  AssistantChatTransport,\n  type InitializableThreadListItem,\n} from \"../transport/AssistantChatTransport\";\nimport {\n  useCallback,\n  useEffect,\n  useEffectEvent,\n  useInsertionEffect,\n  useMemo,\n  useRef,\n  useState,\n  useSyncExternalStore,\n} from \"@ulearning/ai-tap\";\nimport { useResourceCleanup } from \"./useResourceCleanup\";\nimport {\n  DynamicChatTransport,\n  getResumedStreamIds,\n} from \"./DynamicChatTransport\";\nimport type { ResumableClientStorage } from \"../transport/resumable\";\nimport { getResumableAdapter } from \"./getResumableAdapter\";\nimport { useDynamicChatTransport } from \"./useDynamicChatTransport\";\n\nexport type ChatThreadOptions<UI_MESSAGE extends UIMessage = UIMessage> =\n  ChatInit<UI_MESSAGE> &\n    ExternalStoreSharedOptions & {\n      throttle?: number | undefined;\n      adapters?: AISDKRuntimeAdapter[\"adapters\"] | undefined;\n      toCreateMessage?: CustomToCreateMessageFunction;\n      onResume?: AISDKRuntimeAdapter[\"onResume\"];\n      canResume?: AISDKRuntimeAdapter[\"canResume\"];\n      onResumeToolCall?: AISDKRuntimeAdapter[\"onResumeToolCall\"];\n      onRespondToToolApproval?: AISDKRuntimeAdapter[\"onRespondToToolApproval\"];\n      /**\n       * Called when a resumable stream reconnect fails. Use this to\n       * surface a toast, report telemetry, or mark the thread as needing a\n       * retry. With `canResume: true`, transient errors keep the stream id for\n       * manual retry. Otherwise, a failed reconnect clears the matching id.\n       * A 204 or 404 from the resume endpoint always clears the matching id.\n       */\n      onResumeError?: ((error: unknown) => void) | undefined;\n      joinStrategy?: AISDKRuntimeAdapter[\"joinStrategy\"];\n      messageRepository?: AISDKRuntimeAdapter<UI_MESSAGE>[\"messageRepository\"];\n      /** @deprecated Experimental since 2026-06-23. Not scheduled for removal; the API may change in any release. */\n      unstable_onBranchChange?: AISDKRuntimeAdapter[\"unstable_onBranchChange\"];\n      /** @deprecated Experimental since 2026-10-15. Not scheduled for removal; the API may change in any release. */\n      unstable_enableMessageQueue?: AISDKRuntimeAdapter[\"unstable_enableMessageQueue\"];\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   * Aborts when the Vue scope hosting the runtime is deleted. A nested\n   * runtime resolves the destroy signal of the provider above it, which\n   * outlives the nested component, so this stops the chat on its own unmount.\n   */\n  hostDestroySignal?: AbortSignal | undefined;\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   * An externally owned per-thread message repository. Hosts that route\n   * multiple threads through one mounting pass a distinct instance per\n   * thread so histories and branches stay isolated.\n   */\n  messageRepositoryInstance?: MessageRepository | undefined;\n};\n\ntype ChatThreadTransportBinding = {\n  runtime: AssistantRuntime;\n  getThreadListItem: () => InitializableThreadListItem | undefined;\n};\n\nconst getNoPendingStreamId = () => null;\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    throttle,\n    toCreateMessage,\n    isDisabled: _isDisabled,\n    isSendDisabled: _isSendDisabled,\n    unstable_capabilities: _unstable_capabilities,\n    suggestions: _suggestions,\n    onResume,\n    canResume,\n    onResumeToolCall,\n    onRespondToToolApproval,\n    onResumeError,\n    joinStrategy,\n    messageRepository,\n    unstable_onBranchChange,\n    unstable_enableMessageQueue,\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    throttle,\n    toCreateMessage,\n    onResume,\n    canResume,\n    onResumeToolCall,\n    onRespondToToolApproval,\n    onResumeError,\n    joinStrategy,\n    messageRepository,\n    unstable_onBranchChange,\n    unstable_enableMessageQueue,\n    chatInit,\n  };\n};\n\ntype ChatCallbacks<UI_MESSAGE extends UIMessage> = Pick<\n  ChatInit<UI_MESSAGE>,\n  \"onToolCall\" | \"onData\" | \"onFinish\" | \"onError\" | \"sendAutomaticallyWhen\"\n> & {\n  canResume?: boolean | undefined;\n  resumableStorage?: ResumableClientStorage | undefined;\n};\n\ntype ChatRequest = {\n  reconnectFailure?: { error: unknown };\n};\n\nconst requestsByChat = new WeakMap<object, ChatRequest>();\n\n/**\n * Constructs a `Chat` whose callbacks read the latest options through\n * `callbacksRef`, the forwarding `useChat` applies only to a chat it\n * constructs itself.\n */\nexport const createChat = <UI_MESSAGE extends UIMessage>(\n  init: ChatInit<UI_MESSAGE>,\n  callbacksRef: { readonly current: ChatCallbacks<UI_MESSAGE> | undefined },\n): Chat<UI_MESSAGE> => {\n  const transport = init.transport;\n  const chat = new Chat<UI_MESSAGE>({\n    ...init,\n    ...(transport && {\n      transport: {\n        get resumeStreamIsReplay() {\n          return transport.resumeStreamIsReplay ?? false;\n        },\n        sendMessages: (options) => {\n          requestsByChat.set(chat, {});\n          // A new send or regeneration changes the replay target even when\n          // the request fails before returning a replacement checkpoint.\n          if (callbacksRef.current?.canResume) {\n            const storage =\n              callbacksRef.current.resumableStorage ??\n              getResumableAdapter(transport)?.storage;\n            storage?.clear(options.chatId);\n          }\n          return transport.sendMessages(options);\n        },\n        reconnectToStream: async (options) => {\n          const request: ChatRequest = {};\n          requestsByChat.set(chat, request);\n          try {\n            return await transport.reconnectToStream(options);\n          } catch (error) {\n            // SDK 7 suppresses a superseded reconnect's rejection after its\n            // abort signal fires. Preserve the actual transport failure for\n            // the resume invocation that owns it, without borrowing Chat.error\n            // from a newer send or resume. Genuine aborts remain cancellation.\n            if (\n              typeof error !== \"object\" ||\n              error === null ||\n              !(\"name\" in error) ||\n              error.name !== \"AbortError\"\n            ) {\n              request.reconnectFailure = { error };\n            }\n            throw error;\n          }\n        },\n      },\n    }),\n    onToolCall: (arg) => callbacksRef.current?.onToolCall?.(arg),\n    onData: (arg) => callbacksRef.current?.onData?.(arg),\n    onFinish: (arg) => callbacksRef.current?.onFinish?.(arg),\n    onError: (arg) => callbacksRef.current?.onError?.(arg),\n    sendAutomaticallyWhen: (arg) =>\n      callbacksRef.current?.sendAutomaticallyWhen?.(arg) ?? false,\n  });\n  return chat;\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    throttle,\n    toCreateMessage,\n    onResume,\n    canResume,\n    onResumeToolCall,\n    onRespondToToolApproval,\n    onResumeError,\n    joinStrategy,\n    messageRepository,\n    unstable_onBranchChange,\n    unstable_enableMessageQueue,\n    chatInit: chatOptions,\n  } = splitChatThreadOptions(options);\n\n  const {\n    id,\n    isMainThread,\n    getThreadListItem,\n    stopOnClientDestroy = true,\n    hostDestroySignal,\n    chat: externalChat,\n    messageRepositoryInstance,\n  } = env;\n\n  const defaultTransport = useMemo(() => new AssistantChatTransport(), []);\n  const configuredTransport = transportOptions ?? defaultTransport;\n  const transport = useDynamicChatTransport(\n    configuredTransport,\n    externalChat === undefined,\n  );\n  const transportContextOwner = useMemo(() => ({}), []);\n  const getThreadListItemRef = useRef(getThreadListItem);\n  useInsertionEffect(() => {\n    getThreadListItemRef.current = getThreadListItem;\n  }, [getThreadListItem]);\n  const getCurrentThreadListItem = useCallback(\n    () => getThreadListItemRef.current(),\n    [],\n  );\n  const resumableStorage = useMemo(\n    () =>\n      transport instanceof DynamicChatTransport\n        ? transport.getCurrentResumableStorage()\n        : getResumableAdapter(transport)?.storage,\n    [transport],\n  );\n\n  const transportBindingRef = useRef<ChatThreadTransportBinding | null>(null);\n  // This is null when useMemo runs, so the proxy pins its mount render's binding. The fallback\n  // serves only pre-commit sends; after insertion effects, transportBindingRef is authoritative.\n  let initialTransportBinding: ChatThreadTransportBinding | null = null;\n  const chatTransport = useMemo(\n    () =>\n      transport instanceof DynamicChatTransport\n        ? transport.createThreadProxy(transportContextOwner, () => {\n            const binding =\n              transportBindingRef.current ?? initialTransportBinding;\n            if (!binding) {\n              throw new Error(\"Chat transport used before runtime setup\");\n            }\n            return binding;\n          })\n        : transport,\n    [initialTransportBinding, transport, transportContextOwner],\n  );\n\n  const latestChatOptionsRef = useRef({\n    ...chatOptions,\n    canResume,\n    resumableStorage,\n  });\n  useEffect(() => {\n    latestChatOptionsRef.current = {\n      ...chatOptions,\n      canResume,\n      resumableStorage,\n    };\n  });\n  // `useChat` stops a chat it constructs whenever it unmounts, and a\n  // resource's soft unmount runs that cleanup, so the thread owns its chat.\n  const [ownedChat] = useState(\n    () =>\n      externalChat ??\n      createChat(\n        { ...chatOptions, id, transport: chatTransport },\n        latestChatOptionsRef,\n      ),\n  );\n\n  const chat = useChatSnapshot(externalChat ?? ownedChat, throttle);\n\n  useResourceCleanup(\n    stopOnClientDestroy,\n    () => {\n      void chat.stop().catch(() => {});\n    },\n    hostDestroySignal,\n  );\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 staticResumedStreamIds = useMemo(\n    () => getResumedStreamIds(resumableStorage),\n    [resumableStorage],\n  );\n  const onResumeErrorRef = useRef(onResumeError);\n  useEffect(() => {\n    onResumeErrorRef.current = onResumeError;\n  });\n  const resumeChatStream = chat.resumeStream;\n  const resumeStream = useCallback(async () => {\n    const resumedStreamIds =\n      transport instanceof DynamicChatTransport\n        ? transport.getResumedStreamIds()\n        : staticResumedStreamIds;\n    const streamId = resumableStorage?.getStreamId(id);\n    if (!streamId) return;\n    resumedStreamIds.add(streamId);\n    try {\n      const activeChat = externalChat ?? ownedChat;\n      activeChat.clearError();\n      const pending = resumeChatStream();\n      const request = requestsByChat.get(activeChat);\n      await pending;\n      if (request?.reconnectFailure) {\n        throw request.reconnectFailure.error;\n      }\n      // Chat.error is shared with sends and resumes that can start before\n      // this promise settles, including inside the caller's onFinish.\n      if (requestsByChat.get(activeChat) === request && activeChat.error) {\n        throw activeChat.error;\n      }\n    } catch (error) {\n      try {\n        onResumeErrorRef.current?.(error);\n      } catch (callbackError) {\n        console.error(\n          \"[assistant-ui] resumable: onResumeError callback failed\",\n          callbackError,\n        );\n      } finally {\n        if (!canResume && resumableStorage?.getStreamId(id) === streamId) {\n          resumableStorage.clear(id);\n        }\n      }\n      throw error;\n    }\n  }, [\n    canResume,\n    externalChat,\n    id,\n    ownedChat,\n    resumeChatStream,\n    resumableStorage,\n    staticResumedStreamIds,\n    transport,\n  ]);\n\n  const handleBranchChange = useCallback<\n    NonNullable<AISDKRuntimeAdapter[\"unstable_onBranchChange\"]>\n  >(\n    (event) => {\n      if (canResume) resumableStorage?.clear(id);\n      unstable_onBranchChange?.(event);\n    },\n    [canResume, id, resumableStorage, unstable_onBranchChange],\n  );\n\n  const runtime = useAISDKRuntime(chat, {\n    adapters: {\n      ...adapters,\n      threadList: { threadId: id, ...adapters?.threadList },\n    },\n    ...pickExternalStoreSharedOptions(options ?? {}),\n    ...(toCreateMessage && { toCreateMessage }),\n    ...(onResume\n      ? { onResume }\n      : canResume && resumableStorage\n        ? { onResume: resumeStream }\n        : {}),\n    // AI SDK 7 starts resume-stream with fresh message state (chat.ts), so the\n    // host must replay the full message with its original start.messageId.\n    // Without that ID the replay appends a second message. A stored stream ID\n    // alone cannot establish this contract; only the host can opt in.\n    canResume: onResume\n      ? !!canResume\n      : !!canResume && !!pendingStreamId && !isChatRunning,\n    ...(onResumeToolCall && { onResumeToolCall }),\n    ...(onRespondToToolApproval && { onRespondToToolApproval }),\n    ...(joinStrategy && { joinStrategy }),\n    ...(messageRepository && { messageRepository }),\n    ...(messageRepositoryInstance && {\n      unstable_messageRepositoryInstance: messageRepositoryInstance,\n    }),\n    // The chat outlives this runtime when a host mounts only the visible\n    // thread, so a host approval answer is kept with it. This is the Chat\n    // instance, not the useChat helpers, which are re-minted every render and\n    // would be a dead WeakMap key by the next one.\n    unstable_hostApprovalOwner: externalChat ?? ownedChat,\n    ...(((canResume && resumableStorage) || unstable_onBranchChange) && {\n      unstable_onBranchChange: handleBranchChange,\n    }),\n    ...(unstable_enableMessageQueue && { unstable_enableMessageQueue }),\n  });\n\n  initialTransportBinding = {\n    runtime,\n    getThreadListItem: getCurrentThreadListItem,\n  };\n  useInsertionEffect(() => {\n    transportBindingRef.current = {\n      runtime,\n      getThreadListItem: getCurrentThreadListItem,\n    };\n  }, [runtime, getCurrentThreadListItem]);\n\n  const registerTransportContext = useEffectEvent(\n    (dynamicTransport: DynamicChatTransport<UI_MESSAGE>, chatId: string) => {\n      dynamicTransport.setThreadContext(\n        chatId,\n        transportContextOwner,\n        runtime,\n        getCurrentThreadListItem,\n      );\n      return () =>\n        dynamicTransport.unregisterThread(chatId, transportContextOwner);\n    },\n  );\n  useInsertionEffect(() => {\n    if (!(transport instanceof DynamicChatTransport)) return undefined;\n    return registerTransportContext(transport, id);\n  }, [id, runtime, transport, transportContextOwner]);\n\n  if (\n    !(transport instanceof DynamicChatTransport) &&\n    configuredTransport instanceof AssistantChatTransport\n  ) {\n    configuredTransport.setRuntime(runtime);\n    configuredTransport.__internal_setGetThreadListItem(\n      getCurrentThreadListItem,\n    );\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  useEffect(() => {\n    const resumedStreamIds =\n      transport instanceof DynamicChatTransport\n        ? transport.getResumedStreamIds()\n        : staticResumedStreamIds;\n    if (!pendingStreamId || resumedStreamIds.has(pendingStreamId)) {\n      return;\n    }\n    if (isChatRunning) {\n      resumedStreamIds.add(pendingStreamId);\n      return;\n    }\n    if (isLoadingHistory) return;\n    resumeStream().catch((err: unknown) => {\n      console.warn(\"[assistant-ui] resumable: resume failed\", err);\n    });\n  }, [\n    isChatRunning,\n    isLoadingHistory,\n    pendingStreamId,\n    resumeStream,\n    staticResumedStreamIds,\n    transport,\n  ]);\n\n  return runtime;\n};\n"],"mappings":"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"}

package/dist/runtime/useDynamicChatTransport.d.ts

@@ -0,0 +1,4 @@
+import type { UIMessage } from "ai";
+import type { ChatTransport } from "ai";
+export declare const useDynamicChatTransport: <UI_MESSAGE extends UIMessage>(transport: ChatTransport<UI_MESSAGE>, enabled?: boolean) => ChatTransport<UI_MESSAGE>;
+//# sourceMappingURL=useDynamicChatTransport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDynamicChatTransport.d.ts","mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,IAAI;AAIvC,eAAO,MAAM,uBAAuB,GAAI,UAAU,SAAS,SAAS,EAClE,WAAW,aAAa,CAAC,UAAU,CAAC,EACpC,iBAAc,KACb,aAAa,CAAC,UAAU,CAiB1B","names":[],"ignoreList":[],"sources":["../../src/runtime/useDynamicChatTransport.ts"],"sourcesContent":[null]}

package/dist/runtime/useDynamicChatTransport.js

@@ -0,0 +1,26 @@
+import { DynamicChatTransport } from "./DynamicChatTransport.js";
+import { useEffect, useInsertionEffect, useState } from "@ulearning/ai-tap";
+// src/runtime/useDynamicChatTransport.ts
+const useDynamicChatTransport = (transport, enabled = true) => {
+	const [dynamicTransport] = useState(() => transport instanceof DynamicChatTransport ? transport : new DynamicChatTransport(transport));
+	useInsertionEffect(() => {
+		if (!enabled || dynamicTransport === transport) return;
+		dynamicTransport.setTransport(transport);
+	}, [
+		dynamicTransport,
+		enabled,
+		transport
+	]);
+	useEffect(() => {
+		if (!enabled || dynamicTransport === transport) return;
+		dynamicTransport.flushTransportChange();
+	}, [
+		dynamicTransport,
+		enabled,
+		transport
+	]);
+	return enabled ? dynamicTransport : transport;
+};
+export { useDynamicChatTransport };
+
+//# sourceMappingURL=useDynamicChatTransport.js.map

package/dist/runtime/useDynamicChatTransport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDynamicChatTransport.js","names":[],"sources":["../../src/runtime/useDynamicChatTransport.ts"],"sourcesContent":["import type { UIMessage } from \"ai\";\nimport type { ChatTransport } from \"ai\";\nimport { useEffect, useInsertionEffect, useState } from \"@ulearning/ai-tap\";\nimport { DynamicChatTransport } from \"./DynamicChatTransport\";\n\nexport const useDynamicChatTransport = <UI_MESSAGE extends UIMessage>(\n  transport: ChatTransport<UI_MESSAGE>,\n  enabled = true,\n): ChatTransport<UI_MESSAGE> => {\n  const [dynamicTransport] = useState(() =>\n    transport instanceof DynamicChatTransport\n      ? transport\n      : new DynamicChatTransport(transport),\n  );\n\n  useInsertionEffect(() => {\n    if (!enabled || dynamicTransport === transport) return;\n    dynamicTransport.setTransport(transport);\n  }, [dynamicTransport, enabled, transport]);\n  useEffect(() => {\n    if (!enabled || dynamicTransport === transport) return;\n    dynamicTransport.flushTransportChange();\n  }, [dynamicTransport, enabled, transport]);\n\n  return enabled ? dynamicTransport : transport;\n};\n"],"mappings":";;;AAKA,MAAa,2BACX,WACA,UAAU,SACoB;CAC9B,MAAM,CAAC,oBAAoB,eACzB,qBAAqB,uBACjB,YACA,IAAI,qBAAqB,SAAS,CACxC;CAEA,yBAAyB;EACvB,IAAI,CAAC,WAAW,qBAAqB,WAAW;EAChD,iBAAiB,aAAa,SAAS;CACzC,GAAG;EAAC;EAAkB;EAAS;CAAS,CAAC;CACzC,gBAAgB;EACd,IAAI,CAAC,WAAW,qBAAqB,WAAW;EAChD,iBAAiB,qBAAqB;CACxC,GAAG;EAAC;EAAkB;EAAS;CAAS,CAAC;CAEzC,OAAO,UAAU,mBAAmB;AACtC"}

package/dist/runtime/useExternalHistory.d.ts

@@ -0,0 +1,12 @@
+import type { AssistantRuntime, ThreadHistoryAdapter, ThreadMessage, MessageFormatAdapter, MessageFormatRepository, ExportedMessageRepository, RespondToToolApprovalOptions, Unstable_ToolInteractionLog } from "@ulearning/ai-core";
+export declare const toExportedMessageRepository: <TMessage>(toThreadMessages: (messages: TMessage[]) => ThreadMessage[], messages: MessageFormatRepository<TMessage>) => ExportedMessageRepository;
+export declare const useExternalHistory: <TMessage>(runtimeRef: {
+    current: AssistantRuntime;
+}, historyAdapter: ThreadHistoryAdapter | undefined, toThreadMessages: (messages: TMessage[]) => ThreadMessage[], storageFormatAdapter: MessageFormatAdapter<TMessage, any>, onSetMessages: (messages: TMessage[]) => void, getToolArtifacts?: () => ReadonlyMap<string, unknown>, onToolArtifactsRestored?: (next: Map<string, unknown>) => void, getToolInteractions?: () => ReadonlyMap<string, Unstable_ToolInteractionLog>, onToolInteractionsRestored?: (next: Map<string, Unstable_ToolInteractionLog>) => void, toolApprovalResponses?: Map<string, RespondToToolApprovalOptions>, onToolApprovalResponsesRestored?: () => void) => {
+    isLoading: boolean;
+    deleteMessage: (messageId: string) => Promise<void>;
+    markRunCancelled: () => void;
+    persistToolInteractions: (messageId: string) => Promise<void>;
+    persistToolApprovalResponses: (messageId: string) => Promise<void>;
+};
+//# sourceMappingURL=useExternalHistory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useExternalHistory.d.ts","mappings":"AAEA,OAAO,KAAK,EACV,gBAAgB,EAEhB,oBAAoB,EACpB,aAAa,EACb,oBAAoB,EAEpB,uBAAuB,EACvB,yBAAyB,EACzB,4BAA4B,EAC5B,2BAA2B,EAC5B,MAAM,oBAAoB;AAwB3B,eAAO,MAAM,2BAA2B,GAAI,QAAQ,EAClD,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,aAAa,EAAE,EAC3D,UAAU,uBAAuB,CAAC,QAAQ,CAAC,KAC1C,yBAyBF;AA0DD,eAAO,MAAM,kBAAkB,GAAI,QAAQ,EACzC,YAAY;IAAE,OAAO,EAAE,gBAAgB;CAAE,EACzC,gBAAgB,oBAAoB,GAAG,SAAS,EAChD,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,aAAa,EAAE,EAC3D,sBAAsB,oBAAoB,CAAC,QAAQ,EAAE,GAAG,CAAC,EACzD,eAAe,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,IAAI,EAC7C,mBAAmB,MAAM,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,EACrD,0BAA0B,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,EAC9D,sBAAsB,MAAM,WAAW,CAAC,MAAM,EAAE,2BAA2B,CAAC,EAC5E,6BAA6B,CAC3B,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,2BAA2B,CAAC,KAC3C,IAAI,EACT,wBAAwB,GAAG,CAAC,MAAM,EAAE,4BAA4B,CAAC,EACjE,kCAAkC,MAAM,IAAI;;+BAqtBxB,MAAM;;yCAreZ,MAAM;8CAAN,MAAM;CA6gBrB","names":[],"ignoreList":[],"sources":["../../src/runtime/useExternalHistory.ts"],"sourcesContent":[null]}