@aomi-labs/react 0.3.18 → 0.3.19

package/dist/index.js

@@ -174,6 +174,7 @@ var ThreadStore = class {
       };
       this.snapshot = this.buildSnapshot();
       this.emit();
+      return threadId;
     };
     this.updateThreadMetadata = (threadId, updates) => {
       const existing = this.state.threadMetadata.get(threadId);
@@ -275,13 +276,9 @@ function resolveAutoModel(models) {
   return (_a = models[0]) != null ? _a : null;
 }
 
-// packages/react/src/contexts/control-context.tsx
-import { jsx } from "react/jsx-runtime";
-var API_KEY_STORAGE_KEY = "aomi_api_key";
+// packages/react/src/utils/client-session.ts
 var CLIENT_ID_STORAGE_KEY = "aomi_client_id";
-var PROVIDER_KEYS_STORAGE_KEY = "aomi_provider_keys";
-var MODEL_SELECTION_STORAGE_KEY = "aomi_model_selection";
-var PROVIDER_KEY_SECRET_PREFIX = "PROVIDER_KEY:";
+var CONTROL_SESSION_PREFIX = "control:";
 function getOrCreateClientId() {
   var _a, _b, _c, _d, _e;
   try {
@@ -300,6 +297,17 @@ function getOrCreateClientId() {
   }
   return clientId;
 }
+function getControlSessionId(clientId, fallbackSessionId) {
+  const trimmedClientId = clientId == null ? void 0 : clientId.trim();
+  return trimmedClientId ? `${CONTROL_SESSION_PREFIX}${trimmedClientId}` : fallbackSessionId;
+}
+
+// packages/react/src/contexts/control-context.tsx
+import { jsx } from "react/jsx-runtime";
+var API_KEY_STORAGE_KEY = "aomi_api_key";
+var PROVIDER_KEYS_STORAGE_KEY = "aomi_provider_keys";
+var MODEL_SELECTION_STORAGE_KEY = "aomi_model_selection";
+var PROVIDER_KEY_SECRET_PREFIX = "PROVIDER_KEY:";
 function getDefaultApp(apps) {
   var _a;
   return apps.includes("default") ? "default" : (_a = apps[0]) != null ? _a : null;
@@ -392,6 +400,10 @@ function ControlContextProvider({
   const updateThreadMetadataRef = useRef(updateThreadMetadata);
   updateThreadMetadataRef.current = updateThreadMetadata;
   const callbacks = useRef(/* @__PURE__ */ new Set());
+  const getCurrentControlSessionId = useCallback(
+    () => getControlSessionId(stateRef.current.clientId, sessionIdRef.current),
+    []
+  );
   const currentThreadMetadata = getThreadMetadata(sessionId);
   const isProcessing = (_b = (_a = currentThreadMetadata == null ? void 0 : currentThreadMetadata.control) == null ? void 0 : _a.isProcessing) != null ? _b : false;
   useEffect(() => {
@@ -458,18 +470,21 @@ function ControlContextProvider({
     for (const [provider, entry] of Object.entries(keys)) {
       secrets[`${PROVIDER_KEY_SECRET_PREFIX}${provider}`] = entry.apiKey;
     }
-    void aomiClientRef.current.ingestSecrets(state.clientId, secrets).catch((err) => {
+    void aomiClientRef.current.ingestSecrets(getCurrentControlSessionId(), state.clientId, secrets).catch((err) => {
       console.error("Failed to auto-ingest provider keys:", err);
     });
-  }, [state.clientId, state.providerKeys]);
+  }, [getCurrentControlSessionId, state.clientId, state.providerKeys]);
   useEffect(() => {
     const fetchApps = async () => {
       var _a2;
       try {
-        const apps = await aomiClientRef.current.getApps(sessionIdRef.current, {
-          publicKey: publicKeyRef.current,
-          apiKey: (_a2 = stateRef.current.apiKey) != null ? _a2 : void 0
-        });
+        const apps = await aomiClientRef.current.getApps(
+          getCurrentControlSessionId(),
+          {
+            publicKey: publicKeyRef.current,
+            apiKey: (_a2 = stateRef.current.apiKey) != null ? _a2 : void 0
+          }
+        );
         const defaultApp = getDefaultApp(apps);
         setStateInternal((prev) => __spreadProps(__spreadValues({}, prev), {
           authorizedApps: apps,
@@ -484,12 +499,12 @@ function ControlContextProvider({
       }
     };
     void fetchApps();
-  }, [state.apiKey, publicKey]);
+  }, [getCurrentControlSessionId, state.apiKey, publicKey]);
   useEffect(() => {
     const fetchModels = async () => {
       try {
         const models = await aomiClientRef.current.getModels(
-          sessionIdRef.current
+          getCurrentControlSessionId()
         );
         setStateInternal((prev) => __spreadProps(__spreadValues({}, prev), {
           availableModels: models,
@@ -500,7 +515,7 @@ function ControlContextProvider({
       }
     };
     void fetchModels();
-  }, []);
+  }, [getCurrentControlSessionId]);
   const setApiKey = useCallback((apiKey) => {
     setStateInternal((prev) => {
       const next = __spreadProps(__spreadValues({}, prev), { apiKey: apiKey === "" ? null : apiKey });
@@ -513,19 +528,24 @@ function ControlContextProvider({
       const clientId = stateRef.current.clientId;
       if (!clientId) throw new Error("clientId not initialized");
       const { handles } = await aomiClientRef.current.ingestSecrets(
+        getCurrentControlSessionId(),
         clientId,
         secrets
       );
       return handles;
     },
-    []
+    [getCurrentControlSessionId]
   );
   const clearSecrets = useCallback(async () => {
     var _a2, _b2;
     const clientId = stateRef.current.clientId;
     if (!clientId) return;
-    await ((_b2 = (_a2 = aomiClientRef.current).clearSecrets) == null ? void 0 : _b2.call(_a2, clientId));
-  }, []);
+    await ((_b2 = (_a2 = aomiClientRef.current).clearSecrets) == null ? void 0 : _b2.call(
+      _a2,
+      getCurrentControlSessionId(),
+      clientId
+    ));
+  }, [getCurrentControlSessionId]);
   const setProviderKey = useCallback(
     async (provider, apiKey, label) => {
       const trimmed = apiKey.trim();
@@ -545,21 +565,26 @@ function ControlContextProvider({
       const clientId = stateRef.current.clientId;
       if (clientId) {
         try {
-          await aomiClientRef.current.ingestSecrets(clientId, {
-            [`${PROVIDER_KEY_SECRET_PREFIX}${provider}`]: trimmed
-          });
+          await aomiClientRef.current.ingestSecrets(
+            getCurrentControlSessionId(),
+            clientId,
+            {
+              [`${PROVIDER_KEY_SECRET_PREFIX}${provider}`]: trimmed
+            }
+          );
         } catch (err) {
           console.error("Failed to ingest provider key:", err);
         }
       }
     },
-    []
+    [getCurrentControlSessionId]
   );
   const removeProviderKey = useCallback(
     async (provider) => {
       const clientId = stateRef.current.clientId;
       if (clientId) {
         await aomiClientRef.current.deleteSecret(
+          getCurrentControlSessionId(),
           clientId,
           `${PROVIDER_KEY_SECRET_PREFIX}${provider}`
         );
@@ -571,7 +596,7 @@ function ControlContextProvider({
         return next;
       });
     },
-    []
+    [getCurrentControlSessionId]
   );
   const getProviderKeys = useCallback(
     () => stateRef.current.providerKeys,
@@ -585,7 +610,7 @@ function ControlContextProvider({
   const getAvailableModels = useCallback(async () => {
     try {
       const models = await aomiClientRef.current.getModels(
-        sessionIdRef.current
+        getCurrentControlSessionId()
       );
       setStateInternal((prev) => __spreadProps(__spreadValues({}, prev), {
         availableModels: models,
@@ -596,14 +621,17 @@ function ControlContextProvider({
       console.error("Failed to fetch models:", error);
       return [];
     }
-  }, []);
+  }, [getCurrentControlSessionId]);
   const getAuthorizedApps = useCallback(async () => {
     var _a2;
     try {
-      const apps = await aomiClientRef.current.getApps(sessionIdRef.current, {
-        publicKey: publicKeyRef.current,
-        apiKey: (_a2 = stateRef.current.apiKey) != null ? _a2 : void 0
-      });
+      const apps = await aomiClientRef.current.getApps(
+        getCurrentControlSessionId(),
+        {
+          publicKey: publicKeyRef.current,
+          apiKey: (_a2 = stateRef.current.apiKey) != null ? _a2 : void 0
+        }
+      );
       const defaultApp = getDefaultApp(apps);
       setStateInternal((prev) => __spreadProps(__spreadValues({}, prev), {
         authorizedApps: apps,
@@ -618,7 +646,7 @@ function ControlContextProvider({
       }));
       return ["default"];
     }
-  }, []);
+  }, [getCurrentControlSessionId]);
   const getCurrentThreadControl = useCallback(() => {
     var _a2;
     const metadata = getThreadMetadataRef.current(sessionIdRef.current);
@@ -1187,7 +1215,7 @@ function UserContextProvider({ children }) {
 }
 
 // packages/react/src/runtime/core.tsx
-import { useCallback as useCallback7, useEffect as useEffect4, useMemo as useMemo2, useRef as useRef8, useState as useState6 } from "react";
+import { useCallback as useCallback8, useEffect as useEffect4, useMemo as useMemo2, useRef as useRef8, useState as useState7 } from "react";
 import {
   AssistantRuntimeProvider,
   useExternalStoreRuntime
@@ -1546,6 +1574,7 @@ function useRuntimeOrchestrator(aomiClient, options) {
       cleanups.push(forwardEvent("system_notice"));
       cleanups.push(forwardEvent("system_error"));
       cleanups.push(forwardEvent("async_callback"));
+      cleanups.push(forwardEvent("user_state_request"));
       listenerCleanups.current.set(threadId, () => {
         for (const cleanup of cleanups) cleanup();
       });
@@ -1953,40 +1982,14 @@ function useWalletHandler({
 }
 
 // packages/react/src/runtime/user-state-provider.tsx
-import { useEffect as useEffect3, useRef as useRef7 } from "react";
+import {
+  useCallback as useCallback7,
+  useEffect as useEffect3,
+  useRef as useRef7,
+  useState as useState6
+} from "react";
+import { UserState as UserStateHelpers } from "@aomi-labs/client";
 import { Fragment, jsx as jsx6 } from "react/jsx-runtime";
-function stableStateString(state) {
-  return JSON.stringify(state != null ? state : {});
-}
-function RuntimeUserStateProvider({
-  children,
-  sessionManager,
-  getUserState,
-  onUserStateChange
-}) {
-  const lastSerializedStateRef = useRef7("");
-  useEffect3(() => {
-    const applyToSessions = (next) => {
-      const serialized = stableStateString(next);
-      if (serialized === lastSerializedStateRef.current) {
-        return;
-      }
-      lastSerializedStateRef.current = serialized;
-      sessionManager.forEach((session) => {
-        session.resolveUserState(next);
-      });
-    };
-    applyToSessions(getUserState());
-    const unsubscribe = onUserStateChange((next) => {
-      applyToSessions(next);
-    });
-    return unsubscribe;
-  }, [getUserState, onUserStateChange, sessionManager]);
-  return /* @__PURE__ */ jsx6(Fragment, { children });
-}
-
-// 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) {
@@ -2003,87 +2006,42 @@ function scheduleBackgroundTask(task) {
   const timeoutId = runtimeGlobal.setTimeout(task, 0);
   return () => runtimeGlobal.clearTimeout(timeoutId);
 }
-function AomiRuntimeCore({
-  children,
-  aomiClient
-}) {
-  const threadContext = useThreadContext();
-  const eventContext = useEventContext();
-  const notificationContext = useNotification();
-  const { user, onUserStateChange, getUserState } = useUser();
-  const {
-    getControlState,
-    getCurrentThreadApp,
-    getPreferredThreadControl,
-    syncCurrentThreadControl
-  } = useControl();
-  const sessionManagerRef = useRef8(null);
-  const walletHandler = useWalletHandler({
-    getSession: () => {
-      var _a;
-      return (_a = sessionManagerRef.current) == null ? void 0 : _a.get(threadContext.currentThreadId);
-    }
-  });
-  const {
-    sessionManager,
-    getSession,
-    isRunning,
-    setIsRunning,
-    ensureInitialState,
-    sendMessage: orchestratorSendMessage,
-    cancelGeneration: orchestratorCancel,
-    closeSession,
-    closeIdleSessionsExcept,
-    closeAllSessions,
-    aomiClientRef
-  } = useRuntimeOrchestrator(aomiClient, {
-    getPublicKey: () => UserState3.isConnected(getUserState()) ? UserState3.address(getUserState()) : void 0,
-    getUserState,
-    getApp: getCurrentThreadApp,
-    getApiKey: () => getControlState().apiKey,
-    getClientId: () => {
-      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);
+function stableStateString(state) {
+  return JSON.stringify(state != null ? state : {});
+}
+function useWalletStateSync(context, sessions, remoteThreads) {
+  const { getUserState, onUserStateChange, threadContextRef } = context;
+  const { aomiClientRef } = sessions;
+  const { remoteThreadIdsRef } = remoteThreads;
   const walletSnapshot = useCallback7(
     (nextUser) => {
       var _a;
       return {
-        address: UserState3.address(nextUser),
-        chain_id: UserState3.chainId(nextUser),
-        is_connected: (_a = UserState3.isConnected(nextUser)) != null ? _a : false,
+        address: UserStateHelpers.address(nextUser),
+        chain_id: UserStateHelpers.chainId(nextUser),
+        is_connected: (_a = UserStateHelpers.isConnected(nextUser)) != null ? _a : false,
         ens_name: typeof nextUser.ens_name === "string" ? nextUser.ens_name : void 0
       };
     },
     [getUserState]
   );
-  const lastWalletStateRef = useRef8(walletSnapshot(getUserState()));
-  useEffect4(() => {
+  const lastWalletStateRef = useRef7(walletSnapshot(getUserState()));
+  useEffect3(() => {
     lastWalletStateRef.current = walletSnapshot(getUserState());
     const unsubscribe = onUserStateChange(async (newUser) => {
+      var _a, _b;
       const nextWalletState = walletSnapshot(newUser);
       const prevWalletState = lastWalletStateRef.current;
+      const previousAddress = (_a = prevWalletState.address) == null ? void 0 : _a.toLowerCase();
+      const nextAddress = (_b = nextWalletState.address) == null ? void 0 : _b.toLowerCase();
       if (prevWalletState.address === nextWalletState.address && prevWalletState.chain_id === nextWalletState.chain_id && prevWalletState.is_connected === nextWalletState.is_connected && prevWalletState.ens_name === nextWalletState.ens_name) {
         return;
       }
       lastWalletStateRef.current = nextWalletState;
-      const sessionId = threadContext.currentThreadId;
+      if (previousAddress !== void 0 && nextAddress !== void 0 && previousAddress !== nextAddress) {
+        return;
+      }
+      const sessionId = threadContextRef.current.currentThreadId;
       if (!remoteThreadIdsRef.current.has(sessionId)) {
         return;
       }
@@ -2095,38 +2053,55 @@ function AomiRuntimeCore({
     });
     return unsubscribe;
   }, [
-    onUserStateChange,
     aomiClientRef,
-    threadContext.currentThreadId,
     getUserState,
+    onUserStateChange,
+    remoteThreadIdsRef,
+    threadContextRef,
     walletSnapshot
   ]);
-  const warmThread = useCallback7(
-    async (threadId) => {
-      if (!remoteThreadIdsRef.current.has(threadId) || warmedThreadIdsRef.current.has(threadId)) {
-        return;
-      }
-      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]
-  );
+}
+function useUserStateRequestResponder(context, sessions) {
+  const eventContext = useEventContext();
+  const { getUserState, threadContextRef } = context;
+  const { getSession } = sessions;
+  useEffect3(() => {
+    const unsubscribe = eventContext.subscribe("user_state_request", () => {
+      var _a, _b;
+      const sessionId = threadContextRef.current.currentThreadId;
+      const session = getSession(sessionId);
+      const payload = (_b = (_a = UserStateHelpers.reconcile(session.getUserState(), getUserState())) != null ? _a : session.getUserState()) != null ? _b : getUserState();
+      eventContext.sendOutboundSystem({
+        type: "user_state_response",
+        sessionId,
+        payload
+      });
+    });
+    return unsubscribe;
+  }, [eventContext, getSession, getUserState, threadContextRef]);
+}
+function useRemoteThreadListSync(context, sessions, remoteThreads) {
+  const [isThreadListLoading, setIsThreadListLoading] = useState6(true);
+  const prefetchCancelRef = useRef7(null);
+  const lastConnectedAddressRef = useRef7(void 0);
+  const {
+    getControlState,
+    threadContextRef,
+    user
+  } = context;
+  const {
+    aomiClientRef,
+    closeAllSessions,
+    ensureInitialState,
+    sessionManager,
+    setIsThreadLoading
+  } = sessions;
+  const {
+    remoteThreadIdsRef,
+    warmPromisesRef,
+    warmedThreadIdsRef,
+    warmThread
+  } = remoteThreads;
   const scheduleThreadPrefetch = useCallback7(
     (threadIds) => {
       var _a;
@@ -2146,8 +2121,9 @@ function AomiRuntimeCore({
             }
             try {
               await warmThread(threadId);
-              if (cancelled || !remoteThreadIdsRef.current.has(threadId))
+              if (cancelled || !remoteThreadIdsRef.current.has(threadId)) {
                 return;
+              }
               await ensureInitialState(threadId);
             } catch (error) {
               console.debug("Failed to prefetch thread:", threadId, error);
@@ -2160,81 +2136,16 @@ function AomiRuntimeCore({
         cancelScheduledTask();
       };
     },
-    [ensureInitialState, warmThread]
-  );
-  useEffect4(() => {
-    const unsubscribe = eventContext.subscribe("user_state_request", () => {
-      var _a, _b, _c;
-      const session = (_b = (_a = sessionManagerRef.current) == null ? void 0 : _a.get(threadContext.currentThreadId)) != null ? _b : getSession(threadContext.currentThreadId);
-      eventContext.sendOutboundSystem({
-        type: "user_state_response",
-        sessionId: threadContext.currentThreadId,
-        payload: (_c = session.getUserState()) != null ? _c : getUserState()
-      });
-    });
-    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 () => {
-      try {
-        await warmThread(threadId);
-        if (!cancelled) {
-          await ensureInitialState(threadId);
-        }
-      } finally {
-        if (!cancelled) {
-          setIsThreadLoading(false);
-        }
-      }
-    })();
-    return () => {
-      cancelled = true;
-    };
-  }, [
-    closeIdleSessionsExcept,
-    ensureInitialState,
-    threadContext.currentThreadId,
-    warmThread
-  ]);
-  useEffect4(() => {
-    const threadId = threadContext.currentThreadId;
-    const currentMeta = threadContext.getThreadMetadata(threadId);
-    if (currentMeta && currentMeta.control.isProcessing !== isRunning) {
-      threadContext.updateThreadMetadata(threadId, {
-        control: __spreadProps(__spreadValues({}, currentMeta.control), {
-          isProcessing: isRunning
-        })
-      });
-    }
-  }, [isRunning, threadContext]);
-  const currentMessages = threadContext.getThreadMessages(
-    threadContext.currentThreadId
+    [ensureInitialState, remoteThreadIdsRef, threadContextRef, warmThread]
   );
-  useEffect4(() => {
-    var _a;
-    const userAddress = UserState3.isConnected(user) ? UserState3.address(user) : void 0;
+  useEffect3(() => {
+    var _a, _b;
+    const userAddress = UserStateHelpers.isConnected(user) ? UserStateHelpers.address(user) : void 0;
+    const normalizedUserAddress = userAddress == null ? void 0 : userAddress.toLowerCase();
+    const previousAddress = lastConnectedAddressRef.current;
+    const walletChanged = previousAddress !== void 0 && normalizedUserAddress !== void 0 && previousAddress !== normalizedUserAddress;
     if (!userAddress) {
+      lastConnectedAddressRef.current = void 0;
       const hadRemoteThreads = remoteThreadIdsRef.current.size > 0;
       const hadSessions = sessionManager.size > 0;
       setIsThreadListLoading(false);
@@ -2249,23 +2160,46 @@ function AomiRuntimeCore({
       }
       return;
     }
+    lastConnectedAddressRef.current = normalizedUserAddress;
+    const resetThreadId = walletChanged ? threadContextRef.current.resetToDefault() : void 0;
+    if (walletChanged) {
+      (_b = prefetchCancelRef.current) == null ? void 0 : _b.call(prefetchCancelRef);
+      prefetchCancelRef.current = null;
+      remoteThreadIdsRef.current.clear();
+      warmedThreadIdsRef.current.clear();
+      warmPromisesRef.current.clear();
+      closeAllSessions();
+    }
     let cancelled = false;
     setIsThreadListLoading(true);
     const fetchThreadList = async () => {
-      var _a2, _b, _c;
+      var _a2, _b2, _c;
       try {
         const remoteThreadIdsAtFetchStart = new Set(remoteThreadIdsRef.current);
-        const threadList = await aomiClientRef.current.listThreads(userAddress);
-        if (cancelled) return;
         const currentContext = threadContextRef.current;
+        const controlSessionId = getControlSessionId(
+          getControlState().clientId,
+          resetThreadId != null ? resetThreadId : currentContext.currentThreadId
+        );
+        const threadList = await aomiClientRef.current.listThreads(
+          controlSessionId,
+          userAddress
+        );
+        if (cancelled) return;
         const remoteThreadIds = /* @__PURE__ */ new Set();
-        const newMetadata = new Map(currentContext.allThreadsMetadata);
-        let maxChatNum = currentContext.threadCnt;
+        const newMetadata = resetThreadId !== void 0 ? new Map(
+          (() => {
+            const resetMetadata = threadContextRef.current.getThreadMetadata(resetThreadId);
+            return resetMetadata ? [[resetThreadId, resetMetadata]] : [];
+          })()
+        ) : new Map(currentContext.allThreadsMetadata);
+        const baseThreadCount = resetThreadId !== void 0 ? 1 : currentContext.threadCnt;
+        let maxChatNum = baseThreadCount;
         for (const thread of threadList) {
           remoteThreadIds.add(thread.session_id);
           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 lastActive = ((_b2 = newMetadata.get(thread.session_id)) == null ? void 0 : _b2.lastActiveAt) || (/* @__PURE__ */ new Date()).toISOString();
           const existingControl = (_c = newMetadata.get(thread.session_id)) == null ? void 0 : _c.control;
           newMetadata.set(thread.session_id, {
             title,
@@ -2293,16 +2227,17 @@ function AomiRuntimeCore({
           )
         );
         currentContext.setThreadMetadata(newMetadata);
-        if (maxChatNum > currentContext.threadCnt) {
+        if (maxChatNum > baseThreadCount) {
           currentContext.setThreadCnt(maxChatNum);
         }
         scheduleThreadPrefetch(threadList.map((thread) => thread.session_id));
-        if (remoteThreadIds.has(currentContext.currentThreadId)) {
+        const activeThreadId = threadContextRef.current.currentThreadId;
+        if (remoteThreadIds.has(activeThreadId)) {
           setIsThreadLoading(true);
           try {
-            await warmThread(currentContext.currentThreadId);
+            await warmThread(activeThreadId);
             if (!cancelled) {
-              await ensureInitialState(currentContext.currentThreadId);
+              await ensureInitialState(activeThreadId);
             }
           } finally {
             if (!cancelled) {
@@ -2326,13 +2261,249 @@ function AomiRuntimeCore({
       prefetchCancelRef.current = null;
     };
   }, [
-    user,
     aomiClientRef,
+    closeAllSessions,
     ensureInitialState,
+    getControlState,
+    remoteThreadIdsRef,
     scheduleThreadPrefetch,
+    sessionManager,
+    setIsThreadLoading,
+    threadContextRef,
+    user,
+    warmPromisesRef,
+    warmedThreadIdsRef,
+    warmThread
+  ]);
+  return { isThreadListLoading };
+}
+function useRuntimeUserStateEffects({
+  sessions: {
+    aomiClientRef,
+    sessionManager,
+    getSession,
+    closeAllSessions,
+    ensureInitialState,
+    setIsThreadLoading
+  },
+  remoteThreads
+}) {
+  const threadContext = useThreadContext();
+  const { user, getUserState, onUserStateChange } = useUser();
+  const { getControlState } = useControl();
+  const threadContextRef = useRef7(threadContext);
+  threadContextRef.current = threadContext;
+  const context = {
+    getControlState,
+    getUserState,
+    onUserStateChange,
+    threadContextRef,
+    user
+  };
+  const sessions = {
+    aomiClientRef,
+    sessionManager,
+    getSession,
+    closeAllSessions,
+    ensureInitialState,
+    setIsThreadLoading
+  };
+  useWalletStateSync(context, sessions, remoteThreads);
+  useUserStateRequestResponder(context, sessions);
+  return useRemoteThreadListSync(context, sessions, remoteThreads);
+}
+function RuntimeUserStateProvider({
+  children,
+  sessionManager,
+  getUserState,
+  onUserStateChange
+}) {
+  const lastSerializedStateRef = useRef7("");
+  useEffect3(() => {
+    const applyToSessions = (next) => {
+      const serialized = stableStateString(next);
+      if (serialized === lastSerializedStateRef.current) {
+        return;
+      }
+      lastSerializedStateRef.current = serialized;
+      sessionManager.forEach((session) => {
+        session.resolveUserState(next);
+      });
+    };
+    applyToSessions(getUserState());
+    const unsubscribe = onUserStateChange((next) => {
+      applyToSessions(next);
+    });
+    return unsubscribe;
+  }, [getUserState, onUserStateChange, sessionManager]);
+  return /* @__PURE__ */ jsx6(Fragment, { children });
+}
+
+// packages/react/src/runtime/core.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+function AomiRuntimeCore({
+  children,
+  aomiClient
+}) {
+  const threadContext = useThreadContext();
+  const eventContext = useEventContext();
+  const notificationContext = useNotification();
+  const { getUserState } = useUser();
+  const {
+    getControlState,
+    getCurrentThreadApp,
+    getPreferredThreadControl,
+    syncCurrentThreadControl
+  } = useControl();
+  const sessionManagerRef = useRef8(null);
+  const walletHandler = useWalletHandler({
+    getSession: () => {
+      var _a;
+      return (_a = sessionManagerRef.current) == null ? void 0 : _a.get(threadContext.currentThreadId);
+    }
+  });
+  const {
+    sessionManager,
+    getSession,
+    isRunning,
+    setIsRunning,
+    ensureInitialState,
+    sendMessage: orchestratorSendMessage,
+    cancelGeneration: orchestratorCancel,
+    closeSession,
+    closeIdleSessionsExcept,
+    closeAllSessions,
+    aomiClientRef
+  } = useRuntimeOrchestrator(aomiClient, {
+    getPublicKey: () => UserState3.isConnected(getUserState()) ? UserState3.address(getUserState()) : void 0,
+    getUserState,
+    getApp: getCurrentThreadApp,
+    getApiKey: () => getControlState().apiKey,
+    getClientId: () => {
+      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 [isThreadLoading, setIsThreadLoading] = useState7(false);
+  const warmThread = useCallback8(
+    async (threadId) => {
+      if (!remoteThreadIdsRef.current.has(threadId) || warmedThreadIdsRef.current.has(threadId)) {
+        return;
+      }
+      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 ensureBackendThread = useCallback8(
+    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]
+  );
+  const getRuntimeSession = useCallback8(
+    (threadId) => {
+      var _a, _b;
+      return (_b = (_a = sessionManagerRef.current) == null ? void 0 : _a.get(threadId)) != null ? _b : getSession(threadId);
+    },
+    [getSession]
+  );
+  const { isThreadListLoading } = useRuntimeUserStateEffects({
+    sessions: {
+      aomiClientRef,
+      sessionManager,
+      getSession: getRuntimeSession,
+      closeAllSessions,
+      ensureInitialState,
+      setIsThreadLoading
+    },
+    remoteThreads: {
+      remoteThreadIdsRef,
+      warmPromisesRef,
+      warmedThreadIdsRef,
+      warmThread
+    }
+  });
+  useEffect4(() => {
+    const threadId = threadContext.currentThreadId;
+    closeIdleSessionsExcept(threadId);
+    if (!remoteThreadIdsRef.current.has(threadId)) {
+      setIsThreadLoading(false);
+      return;
+    }
+    let cancelled = false;
+    setIsThreadLoading(true);
+    void (async () => {
+      try {
+        await warmThread(threadId);
+        if (!cancelled) {
+          await ensureInitialState(threadId);
+        }
+      } finally {
+        if (!cancelled) {
+          setIsThreadLoading(false);
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    closeIdleSessionsExcept,
+    ensureInitialState,
+    threadContext.currentThreadId,
     warmThread
   ]);
-  const isRemoteThread = useCallback7(
+  useEffect4(() => {
+    const threadId = threadContext.currentThreadId;
+    const currentMeta = threadContext.getThreadMetadata(threadId);
+    if (currentMeta && currentMeta.control.isProcessing !== isRunning) {
+      threadContext.updateThreadMetadata(threadId, {
+        control: __spreadProps(__spreadValues({}, currentMeta.control), {
+          isProcessing: isRunning
+        })
+      });
+    }
+  }, [isRunning, threadContext]);
+  const currentMessages = threadContext.getThreadMessages(
+    threadContext.currentThreadId
+  );
+  const isRemoteThread = useCallback8(
     (threadId) => remoteThreadIdsRef.current.has(threadId),
     []
   );
@@ -2408,52 +2579,50 @@ function AomiRuntimeCore({
   });
   useEffect4(() => {
     return () => {
-      var _a;
-      (_a = prefetchCancelRef.current) == null ? void 0 : _a.call(prefetchCancelRef);
       closeAllSessions();
     };
   }, [closeAllSessions]);
   const userContext = useUser();
-  const sendMessage = useCallback7(
+  const sendMessage = useCallback8(
     async (text) => {
       await orchestratorSendMessage(text, threadContext.currentThreadId);
     },
     [orchestratorSendMessage, threadContext.currentThreadId]
   );
-  const cancelGeneration = useCallback7(() => {
+  const cancelGeneration = useCallback8(() => {
     void orchestratorCancel(threadContext.currentThreadId);
   }, [orchestratorCancel, threadContext.currentThreadId]);
-  const getMessages = useCallback7(
+  const getMessages = useCallback8(
     (threadId) => {
       const id = threadId != null ? threadId : threadContext.currentThreadId;
       return threadContext.getThreadMessages(id);
     },
     [threadContext]
   );
-  const createThread = useCallback7(async () => {
+  const createThread = useCallback8(async () => {
     await threadListAdapter.onSwitchToNewThread();
     return threadContextRef.current.currentThreadId;
   }, [threadListAdapter]);
-  const deleteThread = useCallback7(
+  const deleteThread = useCallback8(
     async (threadId) => {
       closeSession(threadId);
       await threadListAdapter.onDelete(threadId);
     },
     [closeSession, threadListAdapter]
   );
-  const renameThread = useCallback7(
+  const renameThread = useCallback8(
     async (threadId, title) => {
       await threadListAdapter.onRename(threadId, title);
     },
     [threadListAdapter]
   );
-  const archiveThread = useCallback7(
+  const archiveThread = useCallback8(
     async (threadId) => {
       await threadListAdapter.onArchive(threadId);
     },
     [threadListAdapter]
   );
-  const selectThread = useCallback7(
+  const selectThread = useCallback8(
     (threadId) => {
       if (threadContext.allThreadsMetadata.has(threadId)) {
         threadListAdapter.onSwitchToThread(threadId);
@@ -2463,7 +2632,7 @@ function AomiRuntimeCore({
     },
     [threadContext.allThreadsMetadata, threadListAdapter]
   );
-  const simulateBatchTransactions = useCallback7(
+  const simulateBatchTransactions = useCallback8(
     async (transactions, options) => {
       var _a, _b;
       const session = (_b = (_a = sessionManagerRef.current) == null ? void 0 : _a.get(threadContext.currentThreadId)) != null ? _b : getSession(threadContext.currentThreadId);
@@ -2592,7 +2761,7 @@ function AomiRuntimeInner({
 }
 
 // packages/react/src/handlers/notification-handler.ts
-import { useCallback as useCallback8, useEffect as useEffect5, useState as useState7 } from "react";
+import { useCallback as useCallback9, useEffect as useEffect5, useState as useState8 } from "react";
 var notificationIdCounter2 = 0;
 function generateNotificationId() {
   return `notif-${Date.now()}-${++notificationIdCounter2}`;
@@ -2601,7 +2770,7 @@ function useNotificationHandler({
   onNotification
 } = {}) {
   const { subscribe } = useEventContext();
-  const [notifications, setNotifications] = useState7([]);
+  const [notifications, setNotifications] = useState8([]);
   useEffect5(() => {
     const unsubscribe = subscribe("notification", (event) => {
       var _a, _b;
@@ -2621,7 +2790,7 @@ function useNotificationHandler({
     return unsubscribe;
   }, [subscribe, onNotification]);
   const unhandledCount = notifications.filter((n) => !n.handled).length;
-  const markHandled = useCallback8((id) => {
+  const markHandled = useCallback9((id) => {
     setNotifications(
       (prev) => prev.map((n) => n.id === id ? __spreadProps(__spreadValues({}, n), { handled: true }) : n)
     );