@aomi-labs/react 0.3.15 → 0.3.17

package/dist/index.js

@@ -152,6 +152,29 @@ var ThreadStore = class {
     this.getThreadMetadata = (threadId) => {
       return this.state.threadMetadata.get(threadId);
     };
+    /** Reset store to a single empty "New Chat" thread (e.g. on wallet disconnect). */
+    this.resetToDefault = () => {
+      const threadId = generateUUID();
+      this.state = {
+        currentThreadId: threadId,
+        threadViewKey: this.state.threadViewKey + 1,
+        threadCnt: 1,
+        threads: /* @__PURE__ */ new Map([[threadId, []]]),
+        threadMetadata: /* @__PURE__ */ new Map([
+          [
+            threadId,
+            {
+              title: "New Chat",
+              status: "regular",
+              lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
+              control: initThreadControl()
+            }
+          ]
+        ])
+      };
+      this.snapshot = this.buildSnapshot();
+      this.emit();
+    };
     this.updateThreadMetadata = (threadId, updates) => {
       const existing = this.state.threadMetadata.get(threadId);
       if (!existing) {
@@ -229,7 +252,8 @@ var ThreadStore = class {
       getThreadMessages: this.getThreadMessages,
       setThreadMessages: this.setThreadMessages,
       getThreadMetadata: this.getThreadMetadata,
-      updateThreadMetadata: this.updateThreadMetadata
+      updateThreadMetadata: this.updateThreadMetadata,
+      resetToDefault: this.resetToDefault
     };
   }
 };
@@ -460,7 +484,7 @@ function ControlContextProvider({
       }
     };
     void fetchApps();
-  }, [state.apiKey, publicKey, sessionId]);
+  }, [state.apiKey, publicKey]);
   useEffect(() => {
     const fetchModels = async () => {
       try {
@@ -1163,7 +1187,7 @@ function UserContextProvider({ children }) {
 }
 
 // packages/react/src/runtime/core.tsx
-import { useCallback as useCallback7, useEffect as useEffect4, useMemo as useMemo2, useRef as useRef8 } from "react";
+import { useCallback as useCallback7, useEffect as useEffect4, useMemo as useMemo2, useRef as useRef8, useState as useState6 } from "react";
 import {
   AssistantRuntimeProvider,
   useExternalStoreRuntime
@@ -1175,7 +1199,9 @@ import { useCallback as useCallback5, useEffect as useEffect2, useRef as useRef5
 import { CLIENT_TYPE_WEB_UI } from "@aomi-labs/client";
 
 // packages/react/src/runtime/session-manager.ts
-import { Session as ClientSession } from "@aomi-labs/client";
+import {
+  Session as ClientSession
+} from "@aomi-labs/client";
 var SessionManager = class {
   constructor(clientFactory) {
     this.clientFactory = clientFactory;
@@ -1193,6 +1219,9 @@ var SessionManager = class {
   get(threadId) {
     return this.sessions.get(threadId);
   }
+  get size() {
+    return this.sessions.size;
+  }
   forEach(callback) {
     for (const [threadId, session] of this.sessions) {
       callback(session, threadId);
@@ -1205,6 +1234,21 @@ var SessionManager = class {
       this.sessions.delete(threadId);
     }
   }
+  closeIdleExcept(activeThreadId, onBeforeClose) {
+    const closedThreadIds = [];
+    for (const [threadId, session] of this.sessions) {
+      if (threadId === activeThreadId) continue;
+      if (session.getIsProcessing()) continue;
+      if (session.getIsPolling()) continue;
+      if (session.getPendingRequests().length > 0) continue;
+      closedThreadIds.push(threadId);
+    }
+    for (const threadId of closedThreadIds) {
+      onBeforeClose == null ? void 0 : onBeforeClose(threadId);
+      this.close(threadId);
+    }
+    return closedThreadIds;
+  }
   closeAll() {
     for (const [threadId, session] of this.sessions) {
       session.close();
@@ -1316,28 +1360,113 @@ var SUPPORTED_CHAINS = [
 var getChainInfo = (chainId) => chainId === void 0 ? void 0 : SUPPORTED_CHAINS.find((c) => c.id === chainId);
 
 // packages/react/src/runtime/orchestrator.ts
+var toErrorMessage = (error) => error instanceof Error ? error.message : "Message failed to send";
+var getOptimisticStatus = (message) => {
+  var _a, _b;
+  const status = (_b = (_a = message.metadata) == null ? void 0 : _a.custom) == null ? void 0 : _b.aomiSendStatus;
+  return status === "sending" || status === "sent" || status === "failed" ? status : void 0;
+};
+var hasUnhydratedOptimisticMessage = (messages) => messages.some((message) => {
+  const status = getOptimisticStatus(message);
+  return status === "sending" || status === "sent";
+});
+var withOptimisticStatus = (message, status, error) => {
+  var _a, _b;
+  const custom = __spreadProps(__spreadValues({}, (_b = (_a = message.metadata) == null ? void 0 : _a.custom) != null ? _b : {}), {
+    aomiSendStatus: status
+  });
+  if (error) {
+    custom.aomiSendError = toErrorMessage(error);
+  } else {
+    delete custom.aomiSendError;
+  }
+  return __spreadProps(__spreadValues({}, message), {
+    metadata: __spreadProps(__spreadValues({}, message.metadata), {
+      custom
+    })
+  });
+};
+var updateOptimisticMessage = (threadContext, threadId, messageId, status, error) => {
+  const messages = threadContext.getThreadMessages(threadId);
+  let changed = false;
+  const nextMessages = messages.map((message) => {
+    if (message.id !== messageId) return message;
+    changed = true;
+    return withOptimisticStatus(message, status, error);
+  });
+  if (changed) {
+    threadContext.setThreadMessages(threadId, nextMessages);
+  }
+};
 function useRuntimeOrchestrator(aomiClient, options) {
   const threadContext = useThreadContext();
   const threadContextRef = useRef5(threadContext);
   threadContextRef.current = threadContext;
   const aomiClientRef = useRef5(aomiClient);
   aomiClientRef.current = aomiClient;
+  const optionsRef = useRef5(options);
+  optionsRef.current = options;
   const [isRunning, setIsRunning] = useState4(false);
   const sessionManagerRef = useRef5(null);
   if (!sessionManagerRef.current) {
     sessionManagerRef.current = new SessionManager(() => aomiClientRef.current);
   }
   const pendingFetches = useRef5(/* @__PURE__ */ new Set());
+  const initialStatePromises = useRef5(/* @__PURE__ */ new Map());
+  const hydratedThreadIds = useRef5(/* @__PURE__ */ new Set());
   const listenerCleanups = useRef5(/* @__PURE__ */ new Map());
+  const cleanupSessionListeners = useCallback5((threadId) => {
+    var _a;
+    (_a = listenerCleanups.current.get(threadId)) == null ? void 0 : _a();
+    listenerCleanups.current.delete(threadId);
+  }, []);
+  const closeSession = useCallback5(
+    (threadId) => {
+      var _a;
+      cleanupSessionListeners(threadId);
+      pendingFetches.current.delete(threadId);
+      initialStatePromises.current.delete(threadId);
+      hydratedThreadIds.current.delete(threadId);
+      (_a = sessionManagerRef.current) == null ? void 0 : _a.close(threadId);
+    },
+    [cleanupSessionListeners]
+  );
+  const closeIdleSessionsExcept = useCallback5(
+    (activeThreadId) => {
+      var _a, _b;
+      const closedThreadIds = (_b = (_a = sessionManagerRef.current) == null ? void 0 : _a.closeIdleExcept(
+        activeThreadId,
+        cleanupSessionListeners
+      )) != null ? _b : [];
+      for (const threadId of closedThreadIds) {
+        pendingFetches.current.delete(threadId);
+        initialStatePromises.current.delete(threadId);
+        hydratedThreadIds.current.delete(threadId);
+      }
+      return closedThreadIds;
+    },
+    [cleanupSessionListeners]
+  );
+  const closeAllSessions = useCallback5(() => {
+    var _a;
+    pendingFetches.current.clear();
+    initialStatePromises.current.clear();
+    hydratedThreadIds.current.clear();
+    for (const threadId of Array.from(listenerCleanups.current.keys())) {
+      cleanupSessionListeners(threadId);
+    }
+    (_a = sessionManagerRef.current) == null ? void 0 : _a.closeAll();
+  }, [cleanupSessionListeners]);
   const getSession = useCallback5(
     (threadId) => {
       var _a, _b, _c, _d, _e;
       const manager = sessionManagerRef.current;
-      const nextApp = options.getApp();
-      const nextPublicKey = (_a = options.getPublicKey) == null ? void 0 : _a.call(options);
-      const nextApiKey = (_c = (_b = options.getApiKey) == null ? void 0 : _b.call(options)) != null ? _c : void 0;
-      const nextClientId = (_d = options.getClientId) == null ? void 0 : _d.call(options);
-      const nextUserState = (_e = options.getUserState) == null ? void 0 : _e.call(options);
+      const nextOptions = optionsRef.current;
+      const nextApp = nextOptions.getApp();
+      const nextPublicKey = (_a = nextOptions.getPublicKey) == null ? void 0 : _a.call(nextOptions);
+      const nextApiKey = (_c = (_b = nextOptions.getApiKey) == null ? void 0 : _b.call(nextOptions)) != null ? _c : void 0;
+      const nextClientId = (_d = nextOptions.getClientId) == null ? void 0 : _d.call(nextOptions);
+      const nextUserState = (_e = nextOptions.getUserState) == null ? void 0 : _e.call(nextOptions);
       const existing = manager.get(threadId);
       if (existing) {
         existing.syncRuntimeOptions({
@@ -1366,6 +1495,10 @@ function useRuntimeOrchestrator(aomiClient, options) {
             const converted = toInboundMessage(msg);
             if (converted) threadMessages.push(converted);
           }
+          const existingMessages = threadContextRef.current.getThreadMessages(threadId);
+          if (threadMessages.length === 0 && hasUnhydratedOptimisticMessage(existingMessages)) {
+            return;
+          }
           threadContextRef.current.setThreadMessages(threadId, threadMessages);
         })
       );
@@ -1387,8 +1520,8 @@ function useRuntimeOrchestrator(aomiClient, options) {
         session.on(
           "wallet_requests_changed",
           (requests) => {
-            var _a2;
-            return (_a2 = options.onPendingRequestsChange) == null ? void 0 : _a2.call(options, requests);
+            var _a2, _b2;
+            return (_b2 = (_a2 = optionsRef.current).onPendingRequestsChange) == null ? void 0 : _b2.call(_a2, requests);
           }
         )
       );
@@ -1397,10 +1530,17 @@ function useRuntimeOrchestrator(aomiClient, options) {
           threadContextRef.current.updateThreadMetadata(threadId, { title });
         })
       );
-      const forwardEvent = (type) => session.on(type, (payload) => {
-        var _a2;
-        (_a2 = options.onEvent) == null ? void 0 : _a2.call(options, { type, payload, sessionId: threadId });
-      });
+      const forwardEvent = (type) => session.on(
+        type,
+        (payload) => {
+          var _a2, _b2;
+          (_b2 = (_a2 = optionsRef.current).onEvent) == null ? void 0 : _b2.call(_a2, {
+            type,
+            payload,
+            sessionId: threadId
+          });
+        }
+      );
       cleanups.push(forwardEvent("tool_update"));
       cleanups.push(forwardEvent("tool_complete"));
       cleanups.push(forwardEvent("system_notice"));
@@ -1416,36 +1556,68 @@ function useRuntimeOrchestrator(aomiClient, options) {
   );
   const ensureInitialState = useCallback5(
     async (threadId) => {
-      var _a;
-      if (pendingFetches.current.has(threadId)) return;
-      pendingFetches.current.add(threadId);
-      try {
-        const session = getSession(threadId);
-        await session.fetchCurrentState();
-        (_a = options.onPendingRequestsChange) == null ? void 0 : _a.call(options, session.getPendingRequests());
-        if (threadContextRef.current.currentThreadId === threadId) {
-          setIsRunning(session.getIsProcessing());
-        }
-      } catch (error) {
-        console.error("Failed to fetch initial state:", error);
+      var _a, _b, _c;
+      const existingPromise = initialStatePromises.current.get(threadId);
+      if (existingPromise) {
+        return existingPromise;
+      }
+      const cachedMessages = threadContextRef.current.getThreadMessages(threadId);
+      const existingSession = (_a = sessionManagerRef.current) == null ? void 0 : _a.get(threadId);
+      if (existingSession && (hydratedThreadIds.current.has(threadId) || cachedMessages.length > 0)) {
+        (_c = (_b = optionsRef.current).onPendingRequestsChange) == null ? void 0 : _c.call(
+          _b,
+          existingSession.getPendingRequests()
+        );
         if (threadContextRef.current.currentThreadId === threadId) {
-          setIsRunning(false);
+          setIsRunning(existingSession.getIsProcessing());
         }
-      } finally {
-        pendingFetches.current.delete(threadId);
+        return;
       }
+      const fetchPromise = (async () => {
+        var _a2, _b2;
+        pendingFetches.current.add(threadId);
+        try {
+          const session = getSession(threadId);
+          await session.fetchCurrentState();
+          hydratedThreadIds.current.add(threadId);
+          (_b2 = (_a2 = optionsRef.current).onPendingRequestsChange) == null ? void 0 : _b2.call(
+            _a2,
+            session.getPendingRequests()
+          );
+          if (threadContextRef.current.currentThreadId === threadId) {
+            setIsRunning(session.getIsProcessing());
+          }
+        } catch (error) {
+          console.error("Failed to fetch initial state:", error);
+          if (threadContextRef.current.currentThreadId === threadId) {
+            setIsRunning(false);
+          }
+        } finally {
+          pendingFetches.current.delete(threadId);
+          initialStatePromises.current.delete(threadId);
+        }
+      })();
+      initialStatePromises.current.set(threadId, fetchPromise);
+      return fetchPromise;
     },
     [getSession]
   );
   const sendMessage = useCallback5(
     async (text, threadId) => {
-      var _a;
-      const session = getSession(threadId);
+      var _a, _b, _c, _d;
       const existingMessages = threadContextRef.current.getThreadMessages(threadId);
+      const optimisticMessageId = String(existingMessages.length);
       const userMessage = {
+        id: optimisticMessageId,
         role: "user",
         content: [{ type: "text", text }],
-        createdAt: /* @__PURE__ */ new Date()
+        createdAt: /* @__PURE__ */ new Date(),
+        metadata: {
+          custom: {
+            aomiOriginalText: text,
+            aomiSendStatus: "sending"
+          }
+        }
       };
       threadContextRef.current.setThreadMessages(threadId, [
         ...existingMessages,
@@ -1454,31 +1626,54 @@ function useRuntimeOrchestrator(aomiClient, options) {
       threadContextRef.current.updateThreadMetadata(threadId, {
         lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
       });
-      await session.sendAsync(text);
-      (_a = options.onPendingRequestsChange) == null ? void 0 : _a.call(options, session.getPendingRequests());
-    },
-    [getSession]
-  );
-  const cancelGeneration = useCallback5(
-    async (threadId) => {
-      var _a;
-      const session = (_a = sessionManagerRef.current) == null ? void 0 : _a.get(threadId);
-      if (session) {
-        await session.interrupt();
+      if (threadContextRef.current.currentThreadId === threadId) {
+        setIsRunning(true);
+      }
+      try {
+        await ((_b = (_a = optionsRef.current).prepareThreadForSend) == null ? void 0 : _b.call(_a, threadId));
+        const session = getSession(threadId);
+        await session.sendAsync(text);
+        if (threadContextRef.current.currentThreadId === threadId) {
+          setIsRunning(session.getIsProcessing());
+        }
+        updateOptimisticMessage(
+          threadContextRef.current,
+          threadId,
+          optimisticMessageId,
+          "sent"
+        );
+        (_d = (_c = optionsRef.current).onPendingRequestsChange) == null ? void 0 : _d.call(
+          _c,
+          session.getPendingRequests()
+        );
+      } catch (error) {
+        if (threadContextRef.current.currentThreadId === threadId) {
+          setIsRunning(false);
+        }
+        updateOptimisticMessage(
+          threadContextRef.current,
+          threadId,
+          optimisticMessageId,
+          "failed",
+          error
+        );
+        throw error;
       }
     },
-    []
+    [getSession]
   );
+  const cancelGeneration = useCallback5(async (threadId) => {
+    var _a;
+    const session = (_a = sessionManagerRef.current) == null ? void 0 : _a.get(threadId);
+    if (session) {
+      await session.interrupt();
+    }
+  }, []);
   useEffect2(() => {
     return () => {
-      var _a;
-      (_a = sessionManagerRef.current) == null ? void 0 : _a.closeAll();
-      for (const cleanup of listenerCleanups.current.values()) {
-        cleanup();
-      }
-      listenerCleanups.current.clear();
+      closeAllSessions();
     };
-  }, []);
+  }, [closeAllSessions]);
   return {
     sessionManager: sessionManagerRef.current,
     getSession,
@@ -1487,6 +1682,9 @@ function useRuntimeOrchestrator(aomiClient, options) {
     ensureInitialState,
     sendMessage,
     cancelGeneration,
+    closeSession,
+    closeAllSessions,
+    closeIdleSessionsExcept,
     aomiClientRef
   };
 }
@@ -1497,9 +1695,9 @@ var sortByLastActiveDesc = ([, metaA], [, metaB]) => {
   const tsB = parseTimestamp(metaB.lastActiveAt);
   return tsB - tsA;
 };
-function buildThreadLists(threadMetadata) {
+function buildThreadLists(threadMetadata, shouldShowThread) {
   const entries = Array.from(threadMetadata.entries()).filter(
-    ([, meta]) => !isPlaceholderTitle(meta.title)
+    ([threadId, meta]) => !isPlaceholderTitle(meta.title) && shouldShowThread(threadId)
   );
   const regularThreads = entries.filter(([, meta]) => meta.status !== "archived").sort(sortByLastActiveDesc).map(
     ([id, meta]) => ({
@@ -1521,16 +1719,41 @@ function buildThreadListAdapter({
   aomiClientRef,
   threadContext,
   setIsRunning,
-  getInitialControl = initThreadControl
+  isLoading = false,
+  getInitialControl = initThreadControl,
+  isRemoteThread = () => true
 }) {
+  const shouldShowThread = (threadId) => {
+    if (isRemoteThread(threadId)) return true;
+    return threadContext.getThreadMessages(threadId).some((message) => message.role === "user");
+  };
   const { regularThreads, archivedThreads } = buildThreadLists(
-    threadContext.allThreadsMetadata
+    threadContext.allThreadsMetadata,
+    shouldShowThread
   );
+  const cleanupEmptyLocalThread = () => {
+    const prevId = threadContext.currentThreadId;
+    if (isRemoteThread(prevId)) return;
+    const msgs = threadContext.getThreadMessages(prevId);
+    if (msgs.length > 0) return;
+    threadContext.setThreadMetadata((prev) => {
+      const next = new Map(prev);
+      next.delete(prevId);
+      return next;
+    });
+    threadContext.setThreads((prev) => {
+      const next = new Map(prev);
+      next.delete(prevId);
+      return next;
+    });
+  };
   return {
     threadId: threadContext.currentThreadId,
+    isLoading,
     threads: regularThreads,
     archivedThreads,
     onSwitchToNewThread: () => {
+      cleanupEmptyLocalThread();
       const threadId = generateUUID();
       threadContext.setThreadMetadata(
         (prev) => new Map(prev).set(threadId, {
@@ -1546,6 +1769,7 @@ function buildThreadListAdapter({
       threadContext.bumpThreadViewKey();
     },
     onSwitchToThread: (threadId) => {
+      cleanupEmptyLocalThread();
       threadContext.setCurrentThreadId(threadId);
       threadContext.bumpThreadViewKey();
     },
@@ -1763,6 +1987,22 @@ function RuntimeUserStateProvider({
 
 // packages/react/src/runtime/core.tsx
 import { jsx as jsx7 } from "react/jsx-runtime";
+var THREAD_PREFETCH_LIMIT = 5;
+var PREFETCH_IDLE_TIMEOUT_MS = 1500;
+function scheduleBackgroundTask(task) {
+  const runtimeGlobal = globalThis;
+  if (typeof runtimeGlobal.requestIdleCallback === "function") {
+    const idleId = runtimeGlobal.requestIdleCallback(task, {
+      timeout: PREFETCH_IDLE_TIMEOUT_MS
+    });
+    return () => {
+      var _a;
+      return (_a = runtimeGlobal.cancelIdleCallback) == null ? void 0 : _a.call(runtimeGlobal, idleId);
+    };
+  }
+  const timeoutId = runtimeGlobal.setTimeout(task, 0);
+  return () => runtimeGlobal.clearTimeout(timeoutId);
+}
 function AomiRuntimeCore({
   children,
   aomiClient
@@ -1792,6 +2032,9 @@ function AomiRuntimeCore({
     ensureInitialState,
     sendMessage: orchestratorSendMessage,
     cancelGeneration: orchestratorCancel,
+    closeSession,
+    closeIdleSessionsExcept,
+    closeAllSessions,
     aomiClientRef
   } = useRuntimeOrchestrator(aomiClient, {
     getPublicKey: () => UserState3.isConnected(getUserState()) ? UserState3.address(getUserState()) : void 0,
@@ -1802,10 +2045,22 @@ function AomiRuntimeCore({
       var _a;
       return (_a = getControlState().clientId) != null ? _a : void 0;
     },
+    prepareThreadForSend: async (threadId) => {
+      await ensureBackendThread(threadId);
+      await syncCurrentThreadControl();
+    },
     onPendingRequestsChange: walletHandler.setRequests,
     onEvent: (event) => eventContext.dispatch(event)
   });
   sessionManagerRef.current = sessionManager;
+  const threadContextRef = useRef8(threadContext);
+  threadContextRef.current = threadContext;
+  const remoteThreadIdsRef = useRef8(/* @__PURE__ */ new Set());
+  const warmedThreadIdsRef = useRef8(/* @__PURE__ */ new Set());
+  const warmPromisesRef = useRef8(/* @__PURE__ */ new Map());
+  const prefetchCancelRef = useRef8(null);
+  const [isThreadLoading, setIsThreadLoading] = useState6(false);
+  const [isThreadListLoading, setIsThreadListLoading] = useState6(true);
   const walletSnapshot = useCallback7(
     (nextUser) => {
       var _a;
@@ -1829,6 +2084,9 @@ function AomiRuntimeCore({
       }
       lastWalletStateRef.current = nextWalletState;
       const sessionId = threadContext.currentThreadId;
+      if (!remoteThreadIdsRef.current.has(sessionId)) {
+        return;
+      }
       const message = JSON.stringify({
         type: "wallet:state_changed",
         payload: nextWalletState
@@ -1843,24 +2101,67 @@ function AomiRuntimeCore({
     getUserState,
     walletSnapshot
   ]);
-  const threadContextRef = useRef8(threadContext);
-  threadContextRef.current = threadContext;
-  const remoteThreadIdsRef = useRef8(/* @__PURE__ */ new Set());
-  const warmedThreadIdsRef = useRef8(/* @__PURE__ */ new Set());
   const warmThread = useCallback7(
     async (threadId) => {
       if (!remoteThreadIdsRef.current.has(threadId) || warmedThreadIdsRef.current.has(threadId)) {
         return;
       }
-      const userState = getUserState();
-      await aomiClientRef.current.createThread(
-        threadId,
-        UserState3.isConnected(userState) ? UserState3.address(userState) : void 0
-      );
-      warmedThreadIdsRef.current.add(threadId);
+      const existingPromise = warmPromisesRef.current.get(threadId);
+      if (existingPromise) {
+        return existingPromise;
+      }
+      const warmPromise = (async () => {
+        const userState = getUserState();
+        await aomiClientRef.current.createThread(
+          threadId,
+          UserState3.isConnected(userState) ? UserState3.address(userState) : void 0
+        );
+        warmedThreadIdsRef.current.add(threadId);
+      })();
+      warmPromisesRef.current.set(threadId, warmPromise);
+      try {
+        await warmPromise;
+      } finally {
+        warmPromisesRef.current.delete(threadId);
+      }
     },
     [aomiClientRef, getUserState]
   );
+  const scheduleThreadPrefetch = useCallback7(
+    (threadIds) => {
+      var _a;
+      (_a = prefetchCancelRef.current) == null ? void 0 : _a.call(prefetchCancelRef);
+      const prefetchThreadIds = Array.from(new Set(threadIds)).filter((threadId) => remoteThreadIdsRef.current.has(threadId)).slice(0, THREAD_PREFETCH_LIMIT);
+      if (prefetchThreadIds.length === 0) {
+        prefetchCancelRef.current = null;
+        return;
+      }
+      let cancelled = false;
+      const cancelScheduledTask = scheduleBackgroundTask(() => {
+        void Promise.all(
+          prefetchThreadIds.map(async (threadId) => {
+            if (cancelled || !remoteThreadIdsRef.current.has(threadId)) return;
+            if (threadContextRef.current.getThreadMessages(threadId).length > 0) {
+              return;
+            }
+            try {
+              await warmThread(threadId);
+              if (cancelled || !remoteThreadIdsRef.current.has(threadId))
+                return;
+              await ensureInitialState(threadId);
+            } catch (error) {
+              console.debug("Failed to prefetch thread:", threadId, error);
+            }
+          })
+        );
+      });
+      prefetchCancelRef.current = () => {
+        cancelled = true;
+        cancelScheduledTask();
+      };
+    },
+    [ensureInitialState, warmThread]
+  );
   useEffect4(() => {
     const unsubscribe = eventContext.subscribe("user_state_request", () => {
       var _a, _b, _c;
@@ -1873,19 +2174,49 @@ function AomiRuntimeCore({
     });
     return unsubscribe;
   }, [eventContext, threadContext.currentThreadId, getSession, getUserState]);
+  const ensureBackendThread = useCallback7(
+    async (threadId) => {
+      if (remoteThreadIdsRef.current.has(threadId)) return;
+      const userState = getUserState();
+      await aomiClientRef.current.createThread(
+        threadId,
+        UserState3.isConnected(userState) ? UserState3.address(userState) : void 0
+      );
+      remoteThreadIdsRef.current.add(threadId);
+      warmedThreadIdsRef.current.add(threadId);
+    },
+    [aomiClientRef, getUserState]
+  );
   useEffect4(() => {
     const threadId = threadContext.currentThreadId;
+    closeIdleSessionsExcept(threadId);
+    if (!remoteThreadIdsRef.current.has(threadId)) {
+      setIsThreadLoading(false);
+      return;
+    }
     let cancelled = false;
+    setIsThreadLoading(true);
     void (async () => {
-      await warmThread(threadId);
-      if (!cancelled) {
-        await ensureInitialState(threadId);
+      try {
+        await warmThread(threadId);
+        if (!cancelled) {
+          await ensureInitialState(threadId);
+        }
+      } finally {
+        if (!cancelled) {
+          setIsThreadLoading(false);
+        }
       }
     })();
     return () => {
       cancelled = true;
     };
-  }, [ensureInitialState, threadContext.currentThreadId, warmThread]);
+  }, [
+    closeIdleSessionsExcept,
+    ensureInitialState,
+    threadContext.currentThreadId,
+    warmThread
+  ]);
   useEffect4(() => {
     const threadId = threadContext.currentThreadId;
     const currentMeta = threadContext.getThreadMetadata(threadId);
@@ -1901,23 +2232,38 @@ function AomiRuntimeCore({
     threadContext.currentThreadId
   );
   useEffect4(() => {
+    var _a;
     const userAddress = UserState3.isConnected(user) ? UserState3.address(user) : void 0;
     if (!userAddress) {
+      const hadRemoteThreads = remoteThreadIdsRef.current.size > 0;
+      const hadSessions = sessionManager.size > 0;
+      setIsThreadListLoading(false);
+      (_a = prefetchCancelRef.current) == null ? void 0 : _a.call(prefetchCancelRef);
+      prefetchCancelRef.current = null;
       remoteThreadIdsRef.current.clear();
       warmedThreadIdsRef.current.clear();
+      warmPromisesRef.current.clear();
+      closeAllSessions();
+      if (hadRemoteThreads || hadSessions) {
+        threadContextRef.current.resetToDefault();
+      }
       return;
     }
+    let cancelled = false;
+    setIsThreadListLoading(true);
     const fetchThreadList = async () => {
-      var _a, _b, _c;
+      var _a2, _b, _c;
       try {
+        const remoteThreadIdsAtFetchStart = new Set(remoteThreadIdsRef.current);
         const threadList = await aomiClientRef.current.listThreads(userAddress);
+        if (cancelled) return;
         const currentContext = threadContextRef.current;
         const remoteThreadIds = /* @__PURE__ */ new Set();
         const newMetadata = new Map(currentContext.allThreadsMetadata);
         let maxChatNum = currentContext.threadCnt;
         for (const thread of threadList) {
           remoteThreadIds.add(thread.session_id);
-          const rawTitle = (_a = thread.title) != null ? _a : "";
+          const rawTitle = (_a2 = thread.title) != null ? _a2 : "";
           const title = isPlaceholderTitle(rawTitle) ? "" : rawTitle;
           const lastActive = ((_b = newMetadata.get(thread.session_id)) == null ? void 0 : _b.lastActiveAt) || (/* @__PURE__ */ new Date()).toISOString();
           const existingControl = (_c = newMetadata.get(thread.session_id)) == null ? void 0 : _c.control;
@@ -1935,6 +2281,11 @@ function AomiRuntimeCore({
             }
           }
         }
+        for (const threadId of remoteThreadIdsRef.current) {
+          if (!remoteThreadIdsAtFetchStart.has(threadId)) {
+            remoteThreadIds.add(threadId);
+          }
+        }
         remoteThreadIdsRef.current = remoteThreadIds;
         warmedThreadIdsRef.current = new Set(
           Array.from(warmedThreadIdsRef.current).filter(
@@ -1945,30 +2296,65 @@ function AomiRuntimeCore({
         if (maxChatNum > currentContext.threadCnt) {
           currentContext.setThreadCnt(maxChatNum);
         }
+        scheduleThreadPrefetch(threadList.map((thread) => thread.session_id));
         if (remoteThreadIds.has(currentContext.currentThreadId)) {
-          await warmThread(currentContext.currentThreadId);
-          await ensureInitialState(currentContext.currentThreadId);
+          setIsThreadLoading(true);
+          try {
+            await warmThread(currentContext.currentThreadId);
+            if (!cancelled) {
+              await ensureInitialState(currentContext.currentThreadId);
+            }
+          } finally {
+            if (!cancelled) {
+              setIsThreadLoading(false);
+            }
+          }
         }
       } catch (error) {
         console.error("Failed to fetch thread list:", error);
+      } finally {
+        if (!cancelled) {
+          setIsThreadListLoading(false);
+        }
       }
     };
     void fetchThreadList();
-  }, [user, aomiClientRef, ensureInitialState, warmThread]);
+    return () => {
+      var _a2;
+      cancelled = true;
+      (_a2 = prefetchCancelRef.current) == null ? void 0 : _a2.call(prefetchCancelRef);
+      prefetchCancelRef.current = null;
+    };
+  }, [
+    user,
+    aomiClientRef,
+    ensureInitialState,
+    scheduleThreadPrefetch,
+    warmThread
+  ]);
+  const isRemoteThread = useCallback7(
+    (threadId) => remoteThreadIdsRef.current.has(threadId),
+    []
+  );
   const threadListAdapter = useMemo2(
     () => buildThreadListAdapter({
       aomiClientRef,
       threadContext,
       setIsRunning,
-      getInitialControl: getPreferredThreadControl
+      isLoading: isThreadListLoading,
+      getInitialControl: getPreferredThreadControl,
+      isRemoteThread
     }),
     [
       aomiClientRef,
       getPreferredThreadControl,
+      isRemoteThread,
+      isThreadListLoading,
       setIsRunning,
       threadContext,
       threadContext.currentThreadId,
-      threadContext.allThreadsMetadata
+      threadContext.allThreadsMetadata,
+      currentMessages
     ]
   );
   useEffect4(() => {
@@ -2003,6 +2389,7 @@ function AomiRuntimeCore({
   }, [eventContext, notificationContext]);
   const runtime = useExternalStoreRuntime({
     messages: currentMessages,
+    isLoading: isThreadLoading,
     setMessages: (msgs) => threadContext.setThreadMessages(threadContext.currentThreadId, [...msgs]),
     isRunning,
     onNew: async (message) => {
@@ -2010,7 +2397,6 @@ function AomiRuntimeCore({
         (part) => part.type === "text"
       ).map((part) => part.text).join("\n");
       if (text) {
-        await syncCurrentThreadControl();
         await orchestratorSendMessage(text, threadContext.currentThreadId);
       }
     },
@@ -2022,20 +2408,17 @@ function AomiRuntimeCore({
   });
   useEffect4(() => {
     return () => {
-      sessionManager.closeAll();
+      var _a;
+      (_a = prefetchCancelRef.current) == null ? void 0 : _a.call(prefetchCancelRef);
+      closeAllSessions();
     };
-  }, [sessionManager]);
+  }, [closeAllSessions]);
   const userContext = useUser();
   const sendMessage = useCallback7(
     async (text) => {
-      await syncCurrentThreadControl();
       await orchestratorSendMessage(text, threadContext.currentThreadId);
     },
-    [
-      orchestratorSendMessage,
-      syncCurrentThreadControl,
-      threadContext.currentThreadId
-    ]
+    [orchestratorSendMessage, threadContext.currentThreadId]
   );
   const cancelGeneration = useCallback7(() => {
     void orchestratorCancel(threadContext.currentThreadId);
@@ -2053,10 +2436,10 @@ function AomiRuntimeCore({
   }, [threadListAdapter]);
   const deleteThread = useCallback7(
     async (threadId) => {
-      sessionManager.close(threadId);
+      closeSession(threadId);
       await threadListAdapter.onDelete(threadId);
     },
-    [threadListAdapter, sessionManager]
+    [closeSession, threadListAdapter]
   );
   const renameThread = useCallback7(
     async (threadId, title) => {
@@ -2172,9 +2555,13 @@ function AomiRuntimeCore({
 import { jsx as jsx8 } from "react/jsx-runtime";
 function AomiRuntimeProvider({
   children,
-  backendUrl = "http://localhost:8080"
+  backendUrl = "http://localhost:8080",
+  clientOptions
 }) {
-  const aomiClient = useMemo3(() => new AomiClient({ baseUrl: backendUrl }), [backendUrl]);
+  const aomiClient = useMemo3(
+    () => new AomiClient(__spreadValues({ baseUrl: backendUrl }, clientOptions)),
+    [backendUrl, clientOptions]
+  );
   return /* @__PURE__ */ jsx8(ThreadContextProvider, { children: /* @__PURE__ */ jsx8(NotificationContextProvider, { children: /* @__PURE__ */ jsx8(UserContextProvider, { children: /* @__PURE__ */ jsx8(AomiRuntimeInner, { aomiClient, children }) }) }) });
 }
 function AomiRuntimeInner({
@@ -2205,7 +2592,7 @@ function AomiRuntimeInner({
 }
 
 // packages/react/src/handlers/notification-handler.ts
-import { useCallback as useCallback8, useEffect as useEffect5, useState as useState6 } from "react";
+import { useCallback as useCallback8, useEffect as useEffect5, useState as useState7 } from "react";
 var notificationIdCounter2 = 0;
 function generateNotificationId() {
   return `notif-${Date.now()}-${++notificationIdCounter2}`;
@@ -2214,7 +2601,7 @@ function useNotificationHandler({
   onNotification
 } = {}) {
   const { subscribe } = useEventContext();
-  const [notifications, setNotifications] = useState6([]);
+  const [notifications, setNotifications] = useState7([]);
   useEffect5(() => {
     const unsubscribe = subscribe("notification", (event) => {
       var _a, _b;
@@ -2257,6 +2644,7 @@ export {
   SUPPORTED_CHAINS,
   ThreadContextProvider,
   UserContextProvider,
+  UserState2 as UserState,
   aaModeFromExecutionKind,
   appendFeeCallToPayload,
   buildFeeAAWalletCall,