@aomi-labs/react 0.3.18 → 0.3.19

package/dist/index.cjs

@@ -50,34 +50,34 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // packages/react/src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  AomiClient: () => import_client7.AomiClient,
+  AomiClient: () => import_client8.AomiClient,
   AomiRuntimeProvider: () => AomiRuntimeProvider,
   ControlContextProvider: () => ControlContextProvider,
-  DISABLED_PROVIDER_STATE: () => import_client8.DISABLED_PROVIDER_STATE,
+  DISABLED_PROVIDER_STATE: () => import_client9.DISABLED_PROVIDER_STATE,
   EventContextProvider: () => EventContextProvider,
-  MAX_AUTO_FEE_WEI: () => import_client8.MAX_AUTO_FEE_WEI,
+  MAX_AUTO_FEE_WEI: () => import_client9.MAX_AUTO_FEE_WEI,
   NotificationContextProvider: () => NotificationContextProvider,
   RuntimeUserStateProvider: () => RuntimeUserStateProvider,
   SUPPORTED_CHAINS: () => SUPPORTED_CHAINS,
   ThreadContextProvider: () => ThreadContextProvider,
   UserContextProvider: () => UserContextProvider,
   UserState: () => import_client2.UserState,
-  aaModeFromExecutionKind: () => import_client8.aaModeFromExecutionKind,
-  appendFeeCallToPayload: () => import_client8.appendFeeCallToPayload,
-  buildFeeAAWalletCall: () => import_client8.buildFeeAAWalletCall,
+  aaModeFromExecutionKind: () => import_client9.aaModeFromExecutionKind,
+  appendFeeCallToPayload: () => import_client9.appendFeeCallToPayload,
+  buildFeeAAWalletCall: () => import_client9.buildFeeAAWalletCall,
   cn: () => cn,
-  executeWalletCalls: () => import_client8.executeWalletCalls,
+  executeWalletCalls: () => import_client9.executeWalletCalls,
   formatAddress: () => formatAddress,
   getChainInfo: () => getChainInfo,
   getNetworkName: () => getNetworkName,
-  hydrateTxPayloadFromUserState: () => import_client8.hydrateTxPayloadFromUserState,
+  hydrateTxPayloadFromUserState: () => import_client9.hydrateTxPayloadFromUserState,
   initThreadControl: () => initThreadControl,
-  normalizeSimulatedFee: () => import_client8.normalizeSimulatedFee,
-  parseChainId: () => import_client8.parseChainId,
+  normalizeSimulatedFee: () => import_client9.normalizeSimulatedFee,
+  parseChainId: () => import_client9.parseChainId,
   resolveAutoModel: () => resolveAutoModel,
-  toAAWalletCall: () => import_client8.toAAWalletCall,
-  toAAWalletCalls: () => import_client8.toAAWalletCalls,
-  toViemSignTypedDataArgs: () => import_client8.toViemSignTypedDataArgs,
+  toAAWalletCall: () => import_client9.toAAWalletCall,
+  toAAWalletCalls: () => import_client9.toAAWalletCalls,
+  toViemSignTypedDataArgs: () => import_client9.toViemSignTypedDataArgs,
   useAomiRuntime: () => useAomiRuntime,
   useControl: () => useControl,
   useCurrentThreadMessages: () => useCurrentThreadMessages,
@@ -90,12 +90,12 @@ __export(index_exports, {
   useWalletHandler: () => useWalletHandler
 });
 module.exports = __toCommonJS(index_exports);
-var import_client7 = require("@aomi-labs/client");
 var import_client8 = require("@aomi-labs/client");
+var import_client9 = require("@aomi-labs/client");
 
 // packages/react/src/runtime/aomi-runtime.tsx
 var import_react12 = require("react");
-var import_client6 = require("@aomi-labs/client");
+var import_client7 = require("@aomi-labs/client");
 
 // packages/react/src/contexts/control-context.tsx
 var import_react = require("react");
@@ -212,6 +212,7 @@ var ThreadStore = class {
       };
       this.snapshot = this.buildSnapshot();
       this.emit();
+      return threadId;
     };
     this.updateThreadMetadata = (threadId, updates) => {
       const existing = this.state.threadMetadata.get(threadId);
@@ -313,13 +314,9 @@ function resolveAutoModel(models) {
   return (_a = models[0]) != null ? _a : null;
 }
 
-// packages/react/src/contexts/control-context.tsx
-var import_jsx_runtime = require("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 {
@@ -338,6 +335,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
+var import_jsx_runtime = require("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;
@@ -430,6 +438,10 @@ function ControlContextProvider({
   const updateThreadMetadataRef = (0, import_react.useRef)(updateThreadMetadata);
   updateThreadMetadataRef.current = updateThreadMetadata;
   const callbacks = (0, import_react.useRef)(/* @__PURE__ */ new Set());
+  const getCurrentControlSessionId = (0, import_react.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;
   (0, import_react.useEffect)(() => {
@@ -496,18 +508,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]);
   (0, import_react.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,
@@ -522,12 +537,12 @@ function ControlContextProvider({
       }
     };
     void fetchApps();
-  }, [state.apiKey, publicKey]);
+  }, [getCurrentControlSessionId, state.apiKey, publicKey]);
   (0, import_react.useEffect)(() => {
     const fetchModels = async () => {
       try {
         const models = await aomiClientRef.current.getModels(
-          sessionIdRef.current
+          getCurrentControlSessionId()
         );
         setStateInternal((prev) => __spreadProps(__spreadValues({}, prev), {
           availableModels: models,
@@ -538,7 +553,7 @@ function ControlContextProvider({
       }
     };
     void fetchModels();
-  }, []);
+  }, [getCurrentControlSessionId]);
   const setApiKey = (0, import_react.useCallback)((apiKey) => {
     setStateInternal((prev) => {
       const next = __spreadProps(__spreadValues({}, prev), { apiKey: apiKey === "" ? null : apiKey });
@@ -551,19 +566,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 = (0, import_react.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 = (0, import_react.useCallback)(
     async (provider, apiKey, label) => {
       const trimmed = apiKey.trim();
@@ -583,21 +603,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 = (0, import_react.useCallback)(
     async (provider) => {
       const clientId = stateRef.current.clientId;
       if (clientId) {
         await aomiClientRef.current.deleteSecret(
+          getCurrentControlSessionId(),
           clientId,
           `${PROVIDER_KEY_SECRET_PREFIX}${provider}`
         );
@@ -609,7 +634,7 @@ function ControlContextProvider({
         return next;
       });
     },
-    []
+    [getCurrentControlSessionId]
   );
   const getProviderKeys = (0, import_react.useCallback)(
     () => stateRef.current.providerKeys,
@@ -623,7 +648,7 @@ function ControlContextProvider({
   const getAvailableModels = (0, import_react.useCallback)(async () => {
     try {
       const models = await aomiClientRef.current.getModels(
-        sessionIdRef.current
+        getCurrentControlSessionId()
       );
       setStateInternal((prev) => __spreadProps(__spreadValues({}, prev), {
         availableModels: models,
@@ -634,14 +659,17 @@ function ControlContextProvider({
       console.error("Failed to fetch models:", error);
       return [];
     }
-  }, []);
+  }, [getCurrentControlSessionId]);
   const getAuthorizedApps = (0, import_react.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,
@@ -656,7 +684,7 @@ function ControlContextProvider({
       }));
       return ["default"];
     }
-  }, []);
+  }, [getCurrentControlSessionId]);
   const getCurrentThreadControl = (0, import_react.useCallback)(() => {
     var _a2;
     const metadata = getThreadMetadataRef.current(sessionIdRef.current);
@@ -1205,7 +1233,7 @@ function UserContextProvider({ children }) {
 // packages/react/src/runtime/core.tsx
 var import_react10 = require("react");
 var import_react11 = require("@assistant-ui/react");
-var import_client5 = require("@aomi-labs/client");
+var import_client6 = require("@aomi-labs/client");
 
 // packages/react/src/runtime/orchestrator.ts
 var import_react6 = require("react");
@@ -1557,6 +1585,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();
       });
@@ -1965,39 +1994,8 @@ function useWalletHandler({
 
 // packages/react/src/runtime/user-state-provider.tsx
 var import_react9 = require("react");
+var import_client5 = require("@aomi-labs/client");
 var import_jsx_runtime6 = require("react/jsx-runtime");
-function stableStateString(state) {
-  return JSON.stringify(state != null ? state : {});
-}
-function RuntimeUserStateProvider({
-  children,
-  sessionManager,
-  getUserState,
-  onUserStateChange
-}) {
-  const lastSerializedStateRef = (0, import_react9.useRef)("");
-  (0, import_react9.useEffect)(() => {
-    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__ */ (0, import_jsx_runtime6.jsx)(import_jsx_runtime6.Fragment, { children });
-}
-
-// packages/react/src/runtime/core.tsx
-var import_jsx_runtime7 = require("react/jsx-runtime");
 var THREAD_PREFETCH_LIMIT = 5;
 var PREFETCH_IDLE_TIMEOUT_MS = 1500;
 function scheduleBackgroundTask(task) {
@@ -2014,65 +2012,14 @@ 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 = (0, import_react10.useRef)(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: () => import_client5.UserState.isConnected(getUserState()) ? import_client5.UserState.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 = (0, import_react10.useRef)(threadContext);
-  threadContextRef.current = threadContext;
-  const remoteThreadIdsRef = (0, import_react10.useRef)(/* @__PURE__ */ new Set());
-  const warmedThreadIdsRef = (0, import_react10.useRef)(/* @__PURE__ */ new Set());
-  const warmPromisesRef = (0, import_react10.useRef)(/* @__PURE__ */ new Map());
-  const prefetchCancelRef = (0, import_react10.useRef)(null);
-  const [isThreadLoading, setIsThreadLoading] = (0, import_react10.useState)(false);
-  const [isThreadListLoading, setIsThreadListLoading] = (0, import_react10.useState)(true);
-  const walletSnapshot = (0, import_react10.useCallback)(
+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 = (0, import_react9.useCallback)(
     (nextUser) => {
       var _a;
       return {
@@ -2084,17 +2031,23 @@ function AomiRuntimeCore({
     },
     [getUserState]
   );
-  const lastWalletStateRef = (0, import_react10.useRef)(walletSnapshot(getUserState()));
-  (0, import_react10.useEffect)(() => {
+  const lastWalletStateRef = (0, import_react9.useRef)(walletSnapshot(getUserState()));
+  (0, import_react9.useEffect)(() => {
     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;
       }
@@ -2106,39 +2059,56 @@ function AomiRuntimeCore({
     });
     return unsubscribe;
   }, [
-    onUserStateChange,
     aomiClientRef,
-    threadContext.currentThreadId,
     getUserState,
+    onUserStateChange,
+    remoteThreadIdsRef,
+    threadContextRef,
     walletSnapshot
   ]);
-  const warmThread = (0, import_react10.useCallback)(
-    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,
-          import_client5.UserState.isConnected(userState) ? import_client5.UserState.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 = (0, import_react10.useCallback)(
+}
+function useUserStateRequestResponder(context, sessions) {
+  const eventContext = useEventContext();
+  const { getUserState, threadContextRef } = context;
+  const { getSession } = sessions;
+  (0, import_react9.useEffect)(() => {
+    const unsubscribe = eventContext.subscribe("user_state_request", () => {
+      var _a, _b;
+      const sessionId = threadContextRef.current.currentThreadId;
+      const session = getSession(sessionId);
+      const payload = (_b = (_a = import_client5.UserState.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] = (0, import_react9.useState)(true);
+  const prefetchCancelRef = (0, import_react9.useRef)(null);
+  const lastConnectedAddressRef = (0, import_react9.useRef)(void 0);
+  const {
+    getControlState,
+    threadContextRef,
+    user
+  } = context;
+  const {
+    aomiClientRef,
+    closeAllSessions,
+    ensureInitialState,
+    sessionManager,
+    setIsThreadLoading
+  } = sessions;
+  const {
+    remoteThreadIdsRef,
+    warmPromisesRef,
+    warmedThreadIdsRef,
+    warmThread
+  } = remoteThreads;
+  const scheduleThreadPrefetch = (0, import_react9.useCallback)(
     (threadIds) => {
       var _a;
       (_a = prefetchCancelRef.current) == null ? void 0 : _a.call(prefetchCancelRef);
@@ -2157,8 +2127,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);
@@ -2171,81 +2142,16 @@ function AomiRuntimeCore({
         cancelScheduledTask();
       };
     },
-    [ensureInitialState, warmThread]
-  );
-  (0, import_react10.useEffect)(() => {
-    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 = (0, import_react10.useCallback)(
-    async (threadId) => {
-      if (remoteThreadIdsRef.current.has(threadId)) return;
-      const userState = getUserState();
-      await aomiClientRef.current.createThread(
-        threadId,
-        import_client5.UserState.isConnected(userState) ? import_client5.UserState.address(userState) : void 0
-      );
-      remoteThreadIdsRef.current.add(threadId);
-      warmedThreadIdsRef.current.add(threadId);
-    },
-    [aomiClientRef, getUserState]
-  );
-  (0, import_react10.useEffect)(() => {
-    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
-  ]);
-  (0, import_react10.useEffect)(() => {
-    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]
   );
-  (0, import_react10.useEffect)(() => {
-    var _a;
+  (0, import_react9.useEffect)(() => {
+    var _a, _b;
     const userAddress = import_client5.UserState.isConnected(user) ? import_client5.UserState.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);
@@ -2260,23 +2166,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,
@@ -2304,16 +2233,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) {
@@ -2337,12 +2267,248 @@ 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 = (0, import_react9.useRef)(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 = (0, import_react9.useRef)("");
+  (0, import_react9.useEffect)(() => {
+    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__ */ (0, import_jsx_runtime6.jsx)(import_jsx_runtime6.Fragment, { children });
+}
+
+// packages/react/src/runtime/core.tsx
+var import_jsx_runtime7 = require("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 = (0, import_react10.useRef)(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: () => import_client6.UserState.isConnected(getUserState()) ? import_client6.UserState.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 = (0, import_react10.useRef)(threadContext);
+  threadContextRef.current = threadContext;
+  const remoteThreadIdsRef = (0, import_react10.useRef)(/* @__PURE__ */ new Set());
+  const warmedThreadIdsRef = (0, import_react10.useRef)(/* @__PURE__ */ new Set());
+  const warmPromisesRef = (0, import_react10.useRef)(/* @__PURE__ */ new Map());
+  const [isThreadLoading, setIsThreadLoading] = (0, import_react10.useState)(false);
+  const warmThread = (0, import_react10.useCallback)(
+    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,
+          import_client6.UserState.isConnected(userState) ? import_client6.UserState.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 = (0, import_react10.useCallback)(
+    async (threadId) => {
+      if (remoteThreadIdsRef.current.has(threadId)) return;
+      const userState = getUserState();
+      await aomiClientRef.current.createThread(
+        threadId,
+        import_client6.UserState.isConnected(userState) ? import_client6.UserState.address(userState) : void 0
+      );
+      remoteThreadIdsRef.current.add(threadId);
+      warmedThreadIdsRef.current.add(threadId);
+    },
+    [aomiClientRef, getUserState]
+  );
+  const getRuntimeSession = (0, import_react10.useCallback)(
+    (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
+    }
+  });
+  (0, import_react10.useEffect)(() => {
+    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
+  ]);
+  (0, import_react10.useEffect)(() => {
+    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 = (0, import_react10.useCallback)(
     (threadId) => remoteThreadIdsRef.current.has(threadId),
     []
@@ -2419,8 +2585,6 @@ function AomiRuntimeCore({
   });
   (0, import_react10.useEffect)(() => {
     return () => {
-      var _a;
-      (_a = prefetchCancelRef.current) == null ? void 0 : _a.call(prefetchCancelRef);
       closeAllSessions();
     };
   }, [closeAllSessions]);
@@ -2570,7 +2734,7 @@ function AomiRuntimeProvider({
   clientOptions
 }) {
   const aomiClient = (0, import_react12.useMemo)(
-    () => new import_client6.AomiClient(__spreadValues({ baseUrl: backendUrl }, clientOptions)),
+    () => new import_client7.AomiClient(__spreadValues({ baseUrl: backendUrl }, clientOptions)),
     [backendUrl, clientOptions]
   );
   return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(ThreadContextProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(NotificationContextProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(UserContextProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(AomiRuntimeInner, { aomiClient, children }) }) }) });
@@ -2587,7 +2751,7 @@ function AomiRuntimeInner({
     {
       aomiClient,
       sessionId: threadContext.currentThreadId,
-      publicKey: import_client6.UserState.isConnected(user) ? (_a = import_client6.UserState.address(user)) != null ? _a : void 0 : void 0,
+      publicKey: import_client7.UserState.isConnected(user) ? (_a = import_client7.UserState.address(user)) != null ? _a : void 0 : void 0,
       getThreadMetadata: threadContext.getThreadMetadata,
       updateThreadMetadata: threadContext.updateThreadMetadata,
       children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(