@aomi-labs/react 0.2.4 → 0.3.1

package/dist/index.js

@@ -18,438 +18,12 @@ var __spreadValues = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 
-// packages/react/src/backend/sse.ts
-function extractSseData(rawEvent) {
-  const dataLines = rawEvent.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart());
-  if (!dataLines.length) return null;
-  return dataLines.join("\n");
-}
-async function readSseStream(stream, signal, onMessage) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  try {
-    while (!signal.aborted) {
-      const { value, done } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      buffer = buffer.replace(/\r/g, "");
-      let separatorIndex = buffer.indexOf("\n\n");
-      while (separatorIndex >= 0) {
-        const rawEvent = buffer.slice(0, separatorIndex);
-        buffer = buffer.slice(separatorIndex + 2);
-        const data = extractSseData(rawEvent);
-        if (data) {
-          onMessage(data);
-        }
-        separatorIndex = buffer.indexOf("\n\n");
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}
-function createSseSubscriber({
-  backendUrl,
-  getHeaders,
-  shouldLog = process.env.NODE_ENV !== "production"
-}) {
-  const subscriptions = /* @__PURE__ */ new Map();
-  const subscribe2 = (sessionId, onUpdate, onError) => {
-    const existing = subscriptions.get(sessionId);
-    const listener = { onUpdate, onError };
-    if (existing) {
-      existing.listeners.add(listener);
-      if (shouldLog) {
-        console.debug("[aomi][sse] listener added", {
-          sessionId,
-          listeners: existing.listeners.size
-        });
-      }
-      return () => {
-        existing.listeners.delete(listener);
-        if (shouldLog) {
-          console.debug("[aomi][sse] listener removed", {
-            sessionId,
-            listeners: existing.listeners.size
-          });
-        }
-        if (existing.listeners.size === 0) {
-          existing.stop("unsubscribe");
-          if (subscriptions.get(sessionId) === existing) {
-            subscriptions.delete(sessionId);
-          }
-        }
-      };
-    }
-    const subscription = {
-      abortController: null,
-      retries: 0,
-      retryTimer: null,
-      stopped: false,
-      listeners: /* @__PURE__ */ new Set([listener]),
-      stop: (reason) => {
-        var _a;
-        subscription.stopped = true;
-        if (subscription.retryTimer) {
-          clearTimeout(subscription.retryTimer);
-          subscription.retryTimer = null;
-        }
-        (_a = subscription.abortController) == null ? void 0 : _a.abort();
-        subscription.abortController = null;
-        if (shouldLog) {
-          console.debug("[aomi][sse] stop", {
-            sessionId,
-            reason,
-            retries: subscription.retries
-          });
-        }
-      }
-    };
-    const scheduleRetry = () => {
-      if (subscription.stopped) return;
-      subscription.retries += 1;
-      const delayMs = Math.min(500 * 2 ** (subscription.retries - 1), 1e4);
-      if (shouldLog) {
-        console.debug("[aomi][sse] retry scheduled", {
-          sessionId,
-          delayMs,
-          retries: subscription.retries
-        });
-      }
-      subscription.retryTimer = setTimeout(() => {
-        void open();
-      }, delayMs);
-    };
-    const open = async () => {
-      var _a;
-      if (subscription.stopped) return;
-      if (subscription.retryTimer) {
-        clearTimeout(subscription.retryTimer);
-        subscription.retryTimer = null;
-      }
-      const controller = new AbortController();
-      subscription.abortController = controller;
-      const openedAt = Date.now();
-      try {
-        const response = await fetch(`${backendUrl}/api/updates`, {
-          headers: getHeaders(sessionId),
-          signal: controller.signal
-        });
-        if (!response.ok) {
-          throw new Error(
-            `SSE HTTP ${response.status}: ${response.statusText}`
-          );
-        }
-        if (!response.body) {
-          throw new Error("SSE response missing body");
-        }
-        subscription.retries = 0;
-        await readSseStream(response.body, controller.signal, (data) => {
-          var _a2, _b;
-          let parsed;
-          try {
-            parsed = JSON.parse(data);
-          } catch (error) {
-            for (const item of subscription.listeners) {
-              (_a2 = item.onError) == null ? void 0 : _a2.call(item, error);
-            }
-            return;
-          }
-          for (const item of subscription.listeners) {
-            try {
-              item.onUpdate(parsed);
-            } catch (error) {
-              (_b = item.onError) == null ? void 0 : _b.call(item, error);
-            }
-          }
-        });
-        if (shouldLog) {
-          console.debug("[aomi][sse] stream ended", {
-            sessionId,
-            aborted: controller.signal.aborted,
-            stopped: subscription.stopped,
-            durationMs: Date.now() - openedAt
-          });
-        }
-      } catch (error) {
-        if (!controller.signal.aborted && !subscription.stopped) {
-          for (const item of subscription.listeners) {
-            (_a = item.onError) == null ? void 0 : _a.call(item, error);
-          }
-        }
-      }
-      if (!subscription.stopped) {
-        scheduleRetry();
-      }
-    };
-    subscriptions.set(sessionId, subscription);
-    void open();
-    return () => {
-      subscription.listeners.delete(listener);
-      if (shouldLog) {
-        console.debug("[aomi][sse] listener removed", {
-          sessionId,
-          listeners: subscription.listeners.size
-        });
-      }
-      if (subscription.listeners.size === 0) {
-        subscription.stop("unsubscribe");
-        if (subscriptions.get(sessionId) === subscription) {
-          subscriptions.delete(sessionId);
-        }
-      }
-    };
-  };
-  return { subscribe: subscribe2 };
-}
-
-// packages/react/src/backend/client.ts
-var SESSION_ID_HEADER = "X-Session-Id";
-var API_KEY_HEADER = "X-API-Key";
-function toQueryString(payload) {
-  const params = new URLSearchParams();
-  for (const [key, value] of Object.entries(payload)) {
-    if (value === void 0 || value === null) continue;
-    params.set(key, String(value));
-  }
-  const qs = params.toString();
-  return qs ? `?${qs}` : "";
-}
-function withSessionHeader(sessionId, init) {
-  const headers = new Headers(init);
-  headers.set(SESSION_ID_HEADER, sessionId);
-  return headers;
-}
-async function postState(backendUrl, path, payload, sessionId, apiKey) {
-  const query = toQueryString(payload);
-  const url = `${backendUrl}${path}${query}`;
-  const headers = new Headers(withSessionHeader(sessionId));
-  if (apiKey) {
-    headers.set(API_KEY_HEADER, apiKey);
-  }
-  const response = await fetch(url, {
-    method: "POST",
-    headers
-  });
-  if (!response.ok) {
-    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-  }
-  return await response.json();
-}
-var BackendApi = class {
-  constructor(backendUrl) {
-    this.backendUrl = backendUrl;
-    this.sseSubscriber = createSseSubscriber({
-      backendUrl,
-      getHeaders: (sessionId) => withSessionHeader(sessionId, { Accept: "text/event-stream" })
-    });
-  }
-  async fetchState(sessionId, userState) {
-    const url = new URL("/api/state", this.backendUrl);
-    if (userState) {
-      url.searchParams.set("user_state", JSON.stringify(userState));
-    }
-    const response = await fetch(url.toString(), {
-      headers: withSessionHeader(sessionId)
-    });
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-    }
-    return await response.json();
-  }
-  async postChatMessage(sessionId, message, namespace, publicKey, apiKey, userState) {
-    const payload = { message, namespace };
-    if (publicKey) {
-      payload.public_key = publicKey;
-    }
-    if (userState) {
-      payload.user_state = JSON.stringify(userState);
-    }
-    return postState(
-      this.backendUrl,
-      "/api/chat",
-      payload,
-      sessionId,
-      apiKey
-    );
-  }
-  async postSystemMessage(sessionId, message) {
-    return postState(
-      this.backendUrl,
-      "/api/system",
-      {
-        message
-      },
-      sessionId
-    );
-  }
-  async postInterrupt(sessionId) {
-    return postState(
-      this.backendUrl,
-      "/api/interrupt",
-      {},
-      sessionId
-    );
-  }
-  /**
-   * Subscribe to SSE updates for a session.
-   * Uses fetch streaming and reconnects on disconnects.
-   * Returns an unsubscribe function.
-   */
-  subscribeSSE(sessionId, onUpdate, onError) {
-    return this.sseSubscriber.subscribe(sessionId, onUpdate, onError);
-  }
-  async fetchThreads(publicKey) {
-    const url = `${this.backendUrl}/api/sessions?public_key=${encodeURIComponent(publicKey)}`;
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch threads: HTTP ${response.status}`);
-    }
-    return await response.json();
-  }
-  async fetchThread(sessionId) {
-    const url = `${this.backendUrl}/api/sessions/${encodeURIComponent(sessionId)}`;
-    const response = await fetch(url, {
-      headers: withSessionHeader(sessionId)
-    });
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-    }
-    return await response.json();
-  }
-  async createThread(threadId, publicKey) {
-    const body = {};
-    if (publicKey) body.public_key = publicKey;
-    const url = `${this.backendUrl}/api/sessions`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: withSessionHeader(threadId, {
-        "Content-Type": "application/json"
-      }),
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to create thread: HTTP ${response.status}`);
-    }
-    return await response.json();
-  }
-  async archiveThread(sessionId) {
-    const url = `${this.backendUrl}/api/sessions/${encodeURIComponent(sessionId)}/archive`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: withSessionHeader(sessionId)
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to archive thread: HTTP ${response.status}`);
-    }
-  }
-  async unarchiveThread(sessionId) {
-    const url = `${this.backendUrl}/api/sessions/${encodeURIComponent(sessionId)}/unarchive`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: withSessionHeader(sessionId)
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to unarchive thread: HTTP ${response.status}`);
-    }
-  }
-  async deleteThread(sessionId) {
-    const url = `${this.backendUrl}/api/sessions/${encodeURIComponent(sessionId)}`;
-    const response = await fetch(url, {
-      method: "DELETE",
-      headers: withSessionHeader(sessionId)
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to delete thread: HTTP ${response.status}`);
-    }
-  }
-  async renameThread(sessionId, newTitle) {
-    const url = `${this.backendUrl}/api/sessions/${encodeURIComponent(sessionId)}`;
-    const response = await fetch(url, {
-      method: "PATCH",
-      headers: withSessionHeader(sessionId, {
-        "Content-Type": "application/json"
-      }),
-      body: JSON.stringify({ title: newTitle })
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to rename thread: HTTP ${response.status}`);
-    }
-  }
-  async getSystemEvents(sessionId, count) {
-    const url = new URL("/api/events", this.backendUrl);
-    if (count !== void 0) {
-      url.searchParams.set("count", String(count));
-    }
-    const response = await fetch(url.toString(), {
-      headers: withSessionHeader(sessionId)
-    });
-    if (!response.ok) {
-      if (response.status === 404) return [];
-      throw new Error(`Failed to get system events: HTTP ${response.status}`);
-    }
-    return await response.json();
-  }
-  // ===========================================================================
-  // Control API
-  // ===========================================================================
-  /**
-   * Get allowed namespaces for the current request context.
-   */
-  async getNamespaces(sessionId, publicKey, apiKey) {
-    const url = new URL("/api/control/namespaces", this.backendUrl);
-    if (publicKey) {
-      url.searchParams.set("public_key", publicKey);
-    }
-    console.log("[BackendApi.getNamespaces]", {
-      backendUrl: this.backendUrl,
-      fullUrl: url.toString(),
-      sessionId,
-      publicKey
-    });
-    const headers = new Headers(withSessionHeader(sessionId));
-    if (apiKey) {
-      headers.set(API_KEY_HEADER, apiKey);
-    }
-    const response = await fetch(url.toString(), { headers });
-    if (!response.ok) {
-      throw new Error(`Failed to get namespaces: HTTP ${response.status}`);
-    }
-    return await response.json();
-  }
-  /**
-   * Get available models.
-   */
-  async getModels(sessionId) {
-    const url = new URL("/api/control/models", this.backendUrl);
-    console.log("[BackendApi.getModels]", {
-      backendUrl: this.backendUrl,
-      fullUrl: url.toString(),
-      sessionId
-    });
-    const response = await fetch(url.toString(), {
-      headers: withSessionHeader(sessionId)
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to get models: HTTP ${response.status}`);
-    }
-    return await response.json();
-  }
-  /**
-   * Set the model selection for a session.
-   */
-  async setModel(sessionId, rig, namespace, apiKey) {
-    const payload = { rig };
-    if (namespace) {
-      payload.namespace = namespace;
-    }
-    return postState(this.backendUrl, "/api/control/model", payload, sessionId, apiKey);
-  }
-};
+// packages/react/src/index.ts
+import { AomiClient as AomiClient2 } from "@aomi-labs/client";
 
 // packages/react/src/runtime/aomi-runtime.tsx
 import { useMemo as useMemo3 } from "react";
+import { AomiClient } from "@aomi-labs/client";
 
 // packages/react/src/contexts/control-context.tsx
 import {
@@ -489,7 +63,7 @@ var logThreadMetadataChange = (source, threadId, prev, next) => {
 function initThreadControl() {
   return {
     model: null,
-    namespace: null,
+    app: null,
     controlDirty: false,
     isProcessing: false
   };
@@ -573,7 +147,7 @@ var ThreadStore = class {
           initialThreadId,
           {
             title: "New Chat",
-            status: "pending",
+            status: "regular",
             lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
             control: initThreadControl()
           }
@@ -645,7 +219,7 @@ function useControl() {
 }
 function ControlContextProvider({
   children,
-  backendApi,
+  aomiClient,
   sessionId,
   publicKey,
   getThreadMetadata,
@@ -655,14 +229,14 @@ function ControlContextProvider({
   const [state, setStateInternal] = useState(() => ({
     apiKey: null,
     availableModels: [],
-    authorizedNamespaces: [],
+    authorizedApps: [],
     defaultModel: null,
-    defaultNamespace: null
+    defaultApp: null
   }));
   const stateRef = useRef(state);
   stateRef.current = state;
-  const backendApiRef = useRef(backendApi);
-  backendApiRef.current = backendApi;
+  const aomiClientRef = useRef(aomiClient);
+  aomiClientRef.current = aomiClient;
   const sessionIdRef = useRef(sessionId);
   sessionIdRef.current = sessionId;
   const publicKeyRef = useRef(publicKey);
@@ -696,33 +270,32 @@ function ControlContextProvider({
     }
   }, [state.apiKey]);
   useEffect(() => {
-    const fetchNamespaces = async () => {
+    const fetchApps = async () => {
       var _a2, _b2;
       try {
-        const namespaces = await backendApiRef.current.getNamespaces(
+        const apps = await aomiClientRef.current.getApps(
           sessionIdRef.current,
-          publicKeyRef.current,
-          (_a2 = stateRef.current.apiKey) != null ? _a2 : void 0
+          { publicKey: publicKeyRef.current, apiKey: (_a2 = stateRef.current.apiKey) != null ? _a2 : void 0 }
         );
-        const defaultNs = namespaces.includes("default") ? "default" : (_b2 = namespaces[0]) != null ? _b2 : null;
+        const defaultApp = apps.includes("default") ? "default" : (_b2 = apps[0]) != null ? _b2 : null;
         setStateInternal((prev) => __spreadProps(__spreadValues({}, prev), {
-          authorizedNamespaces: namespaces,
-          defaultNamespace: defaultNs
+          authorizedApps: apps,
+          defaultApp
         }));
       } catch (error) {
-        console.error("Failed to fetch namespaces:", error);
+        console.error("Failed to fetch apps:", error);
         setStateInternal((prev) => __spreadProps(__spreadValues({}, prev), {
-          authorizedNamespaces: ["default"],
-          defaultNamespace: "default"
+          authorizedApps: ["default"],
+          defaultApp: "default"
         }));
       }
     };
-    void fetchNamespaces();
+    void fetchApps();
   }, [state.apiKey]);
   useEffect(() => {
     const fetchModels = async () => {
       try {
-        const models = await backendApiRef.current.getModels(
+        const models = await aomiClientRef.current.getModels(
           sessionIdRef.current
         );
         setStateInternal((prev) => {
@@ -747,7 +320,7 @@ function ControlContextProvider({
   }, []);
   const getAvailableModels = useCallback(async () => {
     try {
-      const models = await backendApiRef.current.getModels(
+      const models = await aomiClientRef.current.getModels(
         sessionIdRef.current
       );
       setStateInternal((prev) => {
@@ -763,25 +336,24 @@ function ControlContextProvider({
       return [];
     }
   }, []);
-  const getAuthorizedNamespaces = useCallback(async () => {
+  const getAuthorizedApps = useCallback(async () => {
     var _a2, _b2;
     try {
-      const namespaces = await backendApiRef.current.getNamespaces(
+      const apps = await aomiClientRef.current.getApps(
         sessionIdRef.current,
-        publicKeyRef.current,
-        (_a2 = stateRef.current.apiKey) != null ? _a2 : void 0
+        { publicKey: publicKeyRef.current, apiKey: (_a2 = stateRef.current.apiKey) != null ? _a2 : void 0 }
       );
-      const defaultNs = namespaces.includes("default") ? "default" : (_b2 = namespaces[0]) != null ? _b2 : null;
+      const defaultApp = apps.includes("default") ? "default" : (_b2 = apps[0]) != null ? _b2 : null;
       setStateInternal((prev) => __spreadProps(__spreadValues({}, prev), {
-        authorizedNamespaces: namespaces,
-        defaultNamespace: defaultNs
+        authorizedApps: apps,
+        defaultApp
       }));
-      return namespaces;
+      return apps;
     } catch (error) {
-      console.error("Failed to fetch namespaces:", error);
+      console.error("Failed to fetch apps:", error);
       setStateInternal((prev) => __spreadProps(__spreadValues({}, prev), {
-        authorizedNamespaces: ["default"],
-        defaultNamespace: "default"
+        authorizedApps: ["default"],
+        defaultApp: "default"
       }));
       return ["default"];
     }
@@ -805,32 +377,31 @@ function ControlContextProvider({
       console.warn("[control-context] Cannot switch model while processing");
       return;
     }
-    const namespace = (_d = (_c = currentControl.namespace) != null ? _c : stateRef.current.defaultNamespace) != null ? _d : "default";
+    const app = (_d = (_c = currentControl.app) != null ? _c : stateRef.current.defaultApp) != null ? _d : "default";
     console.log("[control-context] onModelSelect updating metadata", {
       threadId,
       model,
-      namespace,
+      app,
       currentControl
     });
     updateThreadMetadataRef.current(threadId, {
       control: __spreadProps(__spreadValues({}, currentControl), {
         model,
-        namespace,
+        app,
         controlDirty: true
       })
     });
     console.log("[control-context] onModelSelect calling backend setModel", {
       threadId,
       model,
-      namespace,
-      backendUrl: backendApiRef.current
+      app,
+      backendUrl: aomiClientRef.current
     });
     try {
-      const result = await backendApiRef.current.setModel(
+      const result = await aomiClientRef.current.setModel(
         threadId,
         model,
-        namespace,
-        (_e = stateRef.current.apiKey) != null ? _e : void 0
+        { app, apiKey: (_e = stateRef.current.apiKey) != null ? _e : void 0 }
       );
       console.log("[control-context] onModelSelect backend result", result);
     } catch (err) {
@@ -838,34 +409,34 @@ function ControlContextProvider({
       throw err;
     }
   }, []);
-  const onNamespaceSelect = useCallback((namespace) => {
+  const onAppSelect = useCallback((app) => {
     var _a2, _b2;
     const threadId = sessionIdRef.current;
     const currentControl = (_b2 = (_a2 = getThreadMetadataRef.current(threadId)) == null ? void 0 : _a2.control) != null ? _b2 : initThreadControl();
     const isProcessing2 = currentControl.isProcessing;
-    console.log("[control-context] onNamespaceSelect called", {
-      namespace,
+    console.log("[control-context] onAppSelect called", {
+      app,
       isProcessing: isProcessing2,
       threadId
     });
     if (isProcessing2) {
       console.warn(
-        "[control-context] Cannot switch namespace while processing"
+        "[control-context] Cannot switch app while processing"
       );
       return;
     }
-    console.log("[control-context] onNamespaceSelect updating metadata", {
+    console.log("[control-context] onAppSelect updating metadata", {
       threadId,
-      namespace,
+      app,
       currentControl
     });
     updateThreadMetadataRef.current(threadId, {
       control: __spreadProps(__spreadValues({}, currentControl), {
-        namespace,
+        app,
         controlDirty: true
       })
     });
-    console.log("[control-context] onNamespaceSelect metadata updated");
+    console.log("[control-context] onAppSelect metadata updated");
   }, []);
   const markControlSynced = useCallback(() => {
     var _a2, _b2;
@@ -895,11 +466,11 @@ function ControlContextProvider({
       if ("apiKey" in updates) {
         setApiKey((_a2 = updates.apiKey) != null ? _a2 : null);
       }
-      if ("namespace" in updates && updates.namespace !== void 0 && updates.namespace !== null) {
-        onNamespaceSelect(updates.namespace);
+      if ("app" in updates && updates.app !== void 0 && updates.app !== null) {
+        onAppSelect(updates.app);
       }
     },
-    [setApiKey, onNamespaceSelect]
+    [setApiKey, onAppSelect]
   );
   return /* @__PURE__ */ jsx(
     ControlContext.Provider,
@@ -908,10 +479,10 @@ function ControlContextProvider({
         state,
         setApiKey,
         getAvailableModels,
-        getAuthorizedNamespaces,
+        getAuthorizedApps,
         getCurrentThreadControl,
         onModelSelect,
-        onNamespaceSelect,
+        onAppSelect,
         isProcessing,
         markControlSynced,
         getControlState,
@@ -932,20 +503,12 @@ import {
   useRef as useRef2,
   useState as useState2
 } from "react";
-
-// packages/react/src/backend/types.ts
-function isInlineCall(event) {
-  return "InlineCall" in event;
-}
-function isSystemNotice(event) {
-  return "SystemNotice" in event;
-}
-function isSystemError(event) {
-  return "SystemError" in event;
-}
-function isAsyncCallback(event) {
-  return "AsyncCallback" in event;
-}
+import {
+  isInlineCall,
+  isSystemNotice,
+  isSystemError,
+  isAsyncCallback
+} from "@aomi-labs/client";
 
 // packages/react/src/state/event-buffer.ts
 function createEventBuffer() {
@@ -1005,7 +568,7 @@ function useEventContext() {
 }
 function EventContextProvider({
   children,
-  backendApi,
+  aomiClient,
   sessionId
 }) {
   const bufferRef = useRef2(null);
@@ -1017,7 +580,7 @@ function EventContextProvider({
   useEffect2(() => {
     setSSEStatus(buffer, "connecting");
     setSseStatus("connecting");
-    const unsubscribe = backendApi.subscribeSSE(
+    const unsubscribe = aomiClient.subscribeSSE(
       sessionId,
       (event) => {
         enqueueInbound(buffer, {
@@ -1047,7 +610,7 @@ function EventContextProvider({
       setSSEStatus(buffer, "disconnected");
       setSseStatus("disconnected");
     };
-  }, [backendApi, sessionId, buffer]);
+  }, [aomiClient, sessionId, buffer]);
   const subscribeCallback = useCallback2(
     (type, callback) => {
       return subscribe(buffer, type, callback);
@@ -1061,12 +624,12 @@ function EventContextProvider({
           type: event.type,
           payload: event.payload
         });
-        await backendApi.postSystemMessage(event.sessionId, message);
+        await aomiClient.sendSystemMessage(event.sessionId, message);
       } catch (error) {
         console.error("Failed to send outbound event:", error);
       }
     },
-    [backendApi]
+    [aomiClient]
   );
   const dispatchSystemEvents = useCallback2(
     (sessionId2, events) => {
@@ -1284,7 +847,7 @@ function UserContextProvider({ children }) {
 }
 
 // packages/react/src/runtime/core.tsx
-import { useCallback as useCallback6, useEffect as useEffect3, useMemo as useMemo2, useRef as useRef6 } from "react";
+import { useCallback as useCallback7, useEffect as useEffect4, useMemo as useMemo2, useRef as useRef7 } from "react";
 import {
   AssistantRuntimeProvider,
   useExternalStoreRuntime
@@ -1398,28 +961,12 @@ var getChainInfo = (chainId) => chainId === void 0 ? void 0 : SUPPORTED_CHAINS.f
 // packages/react/src/state/backend-state.ts
 function createBackendState() {
   return {
-    skipInitialFetch: /* @__PURE__ */ new Set(),
-    pendingChat: /* @__PURE__ */ new Map(),
-    runningThreads: /* @__PURE__ */ new Set(),
-    creatingThreadId: null,
-    createThreadPromise: null
+    runningThreads: /* @__PURE__ */ new Set()
   };
 }
-function resolveThreadId(state, threadId) {
+function resolveThreadId(_state, threadId) {
   return threadId;
 }
-function isThreadReady(state, threadId) {
-  return state.creatingThreadId !== threadId;
-}
-function markSkipInitialFetch(state, threadId) {
-  state.skipInitialFetch.add(threadId);
-}
-function shouldSkipInitialFetch(state, threadId) {
-  return state.skipInitialFetch.has(threadId);
-}
-function clearSkipInitialFetch(state, threadId) {
-  state.skipInitialFetch.delete(threadId);
-}
 function setThreadRunning(state, threadId, running) {
   if (running) {
     state.runningThreads.add(threadId);
@@ -1430,21 +977,6 @@ function setThreadRunning(state, threadId, running) {
 function isThreadRunning(state, threadId) {
   return state.runningThreads.has(threadId);
 }
-function enqueuePendingChat(state, threadId, text) {
-  var _a;
-  const existing = (_a = state.pendingChat.get(threadId)) != null ? _a : [];
-  state.pendingChat.set(threadId, [...existing, text]);
-}
-function dequeuePendingChat(state, threadId) {
-  var _a;
-  const pending = (_a = state.pendingChat.get(threadId)) != null ? _a : [];
-  state.pendingChat.delete(threadId);
-  return pending;
-}
-function hasPendingChat(state, threadId) {
-  var _a, _b;
-  return ((_b = (_a = state.pendingChat.get(threadId)) == null ? void 0 : _a.length) != null ? _b : 0) > 0;
-}
 
 // packages/react/src/runtime/message-controller.ts
 var MessageController = class {
@@ -1452,11 +984,7 @@ var MessageController = class {
     this.config = config;
   }
   inbound(threadId, msgs) {
-    const backendState = this.config.backendStateRef.current;
     if (!msgs) return;
-    if (hasPendingChat(backendState, threadId)) {
-      return;
-    }
     const threadMessages = [];
     for (const msg of msgs) {
       const threadMessage = toInboundMessage(msg);
@@ -1486,25 +1014,17 @@ var MessageController = class {
     threadState.updateThreadMetadata(threadId, {
       lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
     });
-    if (!isThreadReady(backendState, threadId)) {
-      this.markRunning(threadId, true);
-      enqueuePendingChat(backendState, threadId, text);
-      return;
-    }
     const backendThreadId = resolveThreadId(backendState, threadId);
-    const namespace = this.config.getNamespace();
+    const app = this.config.getApp();
     const publicKey = (_b = (_a = this.config).getPublicKey) == null ? void 0 : _b.call(_a);
     const apiKey = (_e = (_d = (_c = this.config).getApiKey) == null ? void 0 : _d.call(_c)) != null ? _e : void 0;
     const userState = (_g = (_f = this.config).getUserState) == null ? void 0 : _g.call(_f);
     try {
       this.markRunning(threadId, true);
-      const response = await this.config.backendApiRef.current.postChatMessage(
+      const response = await this.config.aomiClientRef.current.sendMessage(
         backendThreadId,
         text,
-        namespace,
-        publicKey,
-        apiKey,
-        userState
+        { app, publicKey, apiKey, userState }
       );
       if (response == null ? void 0 : response.messages) {
         this.inbound(threadId, response.messages);
@@ -1522,40 +1042,13 @@ var MessageController = class {
       this.markRunning(threadId, false);
     }
   }
-  async flushPendingChat(threadId) {
-    var _a, _b, _c, _d, _e, _f, _g;
-    const backendState = this.config.backendStateRef.current;
-    const pending = dequeuePendingChat(backendState, threadId);
-    if (!pending.length) return;
-    const backendThreadId = resolveThreadId(backendState, threadId);
-    const namespace = this.config.getNamespace();
-    const publicKey = (_b = (_a = this.config).getPublicKey) == null ? void 0 : _b.call(_a);
-    const apiKey = (_e = (_d = (_c = this.config).getApiKey) == null ? void 0 : _d.call(_c)) != null ? _e : void 0;
-    const userState = (_g = (_f = this.config).getUserState) == null ? void 0 : _g.call(_f);
-    for (const text of pending) {
-      try {
-        await this.config.backendApiRef.current.postChatMessage(
-          backendThreadId,
-          text,
-          namespace,
-          publicKey,
-          apiKey,
-          userState
-        );
-      } catch (error) {
-        console.error("Failed to send queued message:", error);
-      }
-    }
-    this.config.polling.start(threadId);
-  }
   async cancel(threadId) {
     var _a;
-    const backendState = this.config.backendStateRef.current;
-    if (!isThreadReady(backendState, threadId)) return;
     this.config.polling.stop(threadId);
+    const backendState = this.config.backendStateRef.current;
     const backendThreadId = resolveThreadId(backendState, threadId);
     try {
-      const response = await this.config.backendApiRef.current.postInterrupt(backendThreadId);
+      const response = await this.config.aomiClientRef.current.interrupt(backendThreadId);
       if (response == null ? void 0 : response.messages) {
         this.inbound(threadId, response.messages);
       }
@@ -1591,7 +1084,6 @@ var PollingController = class {
   start(threadId) {
     var _a, _b;
     const backendState = this.config.backendStateRef.current;
-    if (!isThreadReady(backendState, threadId)) return;
     if (this.intervals.has(threadId)) return;
     const backendThreadId = resolveThreadId(backendState, threadId);
     setThreadRunning(backendState, threadId, true);
@@ -1604,7 +1096,7 @@ var PollingController = class {
           threadId
         );
         const userState = (_b2 = (_a2 = this.config).getUserState) == null ? void 0 : _b2.call(_a2);
-        const state = await this.config.backendApiRef.current.fetchState(
+        const state = await this.config.aomiClientRef.current.fetchState(
           backendThreadId,
           userState
         );
@@ -1652,12 +1144,12 @@ var PollingController = class {
 };
 
 // packages/react/src/runtime/orchestrator.ts
-function useRuntimeOrchestrator(backendApi, options) {
+function useRuntimeOrchestrator(aomiClient, options) {
   const threadContext = useThreadContext();
   const threadContextRef = useRef5(threadContext);
   threadContextRef.current = threadContext;
-  const backendApiRef = useRef5(backendApi);
-  backendApiRef.current = backendApi;
+  const aomiClientRef = useRef5(aomiClient);
+  aomiClientRef.current = aomiClient;
   const backendStateRef = useRef5(createBackendState());
   const [isRunning, setIsRunning] = useState5(false);
   const messageControllerRef = useRef5(null);
@@ -1665,7 +1157,7 @@ function useRuntimeOrchestrator(backendApi, options) {
   const pendingFetches = useRef5(/* @__PURE__ */ new Set());
   if (!pollingRef.current) {
     pollingRef.current = new PollingController({
-      backendApiRef,
+      aomiClientRef,
       backendStateRef,
       applyMessages: (threadId, msgs) => {
         var _a;
@@ -1687,13 +1179,13 @@ function useRuntimeOrchestrator(backendApi, options) {
   }
   if (!messageControllerRef.current) {
     messageControllerRef.current = new MessageController({
-      backendApiRef,
+      aomiClientRef,
       backendStateRef,
       threadContextRef,
       polling: pollingRef.current,
       setGlobalIsRunning: setIsRunning,
       getPublicKey: options.getPublicKey,
-      getNamespace: options.getNamespace,
+      getApp: options.getApp,
       getApiKey: options.getApiKey,
       getUserState: options.getUserState,
       onSyncEvents: options.onSyncEvents
@@ -1701,26 +1193,12 @@ function useRuntimeOrchestrator(backendApi, options) {
   }
   const ensureInitialState = useCallback5(async (threadId) => {
     var _a, _b, _c, _d;
-    const backendState = backendStateRef.current;
-    if (shouldSkipInitialFetch(backendState, threadId)) {
-      clearSkipInitialFetch(backendState, threadId);
-      if (threadContextRef.current.currentThreadId === threadId) {
-        setIsRunning(false);
-      }
-      return;
-    }
-    if (!isThreadReady(backendState, threadId)) {
-      if (threadContextRef.current.currentThreadId === threadId) {
-        setIsRunning(false);
-      }
-      return;
-    }
     if (pendingFetches.current.has(threadId)) return;
-    const backendThreadId = resolveThreadId(backendState, threadId);
+    const backendThreadId = resolveThreadId(backendStateRef.current, threadId);
     pendingFetches.current.add(threadId);
     try {
       const userState = (_a = options.getUserState) == null ? void 0 : _a.call(options);
-      const state = await backendApiRef.current.fetchState(
+      const state = await aomiClientRef.current.fetchState(
         backendThreadId,
         userState
       );
@@ -1752,7 +1230,7 @@ function useRuntimeOrchestrator(backendApi, options) {
     isRunning,
     setIsRunning,
     ensureInitialState,
-    backendApiRef
+    aomiClientRef
   };
 }
 
@@ -1783,151 +1261,35 @@ function buildThreadLists(threadMetadata) {
   return { regularThreads, archivedThreads };
 }
 function buildThreadListAdapter({
-  backendStateRef,
-  backendApiRef,
+  aomiClientRef,
   threadContext,
-  currentThreadIdRef,
-  polling,
-  userAddress,
-  setIsRunning,
-  getNamespace,
-  getApiKey,
-  getUserState
+  setIsRunning
 }) {
-  const backendState = backendStateRef.current;
   const { regularThreads, archivedThreads } = buildThreadLists(
     threadContext.allThreadsMetadata
   );
-  const preparePendingThread = (threadId) => {
-    const previousPendingId = backendState.creatingThreadId;
-    if (previousPendingId && previousPendingId !== threadId) {
-      threadContext.setThreadMetadata((prev) => {
-        const next = new Map(prev);
-        next.delete(previousPendingId);
-        return next;
-      });
-      threadContext.setThreads((prev) => {
-        const next = new Map(prev);
-        next.delete(previousPendingId);
-        return next;
-      });
-      backendState.pendingChat.delete(previousPendingId);
-      backendState.skipInitialFetch.delete(previousPendingId);
-    }
-    backendState.creatingThreadId = threadId;
-    backendState.pendingChat.delete(threadId);
-    threadContext.setThreadMetadata(
-      (prev) => new Map(prev).set(threadId, {
-        title: "New Chat",
-        status: "pending",
-        lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
-        control: initThreadControl()
-      })
-    );
-    threadContext.setThreadMessages(threadId, []);
-    threadContext.setCurrentThreadId(threadId);
-    setIsRunning(false);
-    threadContext.bumpThreadViewKey();
-  };
-  const findPendingThreadId = () => {
-    if (backendState.creatingThreadId) return backendState.creatingThreadId;
-    for (const [id, meta] of threadContext.allThreadsMetadata.entries()) {
-      if (meta.status === "pending") return id;
-    }
-    return null;
-  };
   return {
     threadId: threadContext.currentThreadId,
     threads: regularThreads,
     archivedThreads,
-    onSwitchToNewThread: async () => {
-      var _a;
-      const pendingId = findPendingThreadId();
-      if (pendingId) {
-        preparePendingThread(pendingId);
-        return;
-      }
-      if (backendState.createThreadPromise) {
-        preparePendingThread((_a = backendState.creatingThreadId) != null ? _a : generateUUID());
-        return;
-      }
+    onSwitchToNewThread: () => {
       const threadId = generateUUID();
-      preparePendingThread(threadId);
-      const createPromise = backendApiRef.current.createThread(threadId, userAddress).then(async (newThread) => {
-        var _a2, _b;
-        const uiThreadId = (_a2 = backendState.creatingThreadId) != null ? _a2 : threadId;
-        const backendId = newThread.session_id;
-        if (uiThreadId !== backendId) {
-          console.warn("[aomi][thread] backend id mismatch", {
-            uiThreadId,
-            backendId
-          });
-        }
-        markSkipInitialFetch(backendState, uiThreadId);
-        threadContext.setThreadMetadata((prev) => {
-          var _a3, _b2, _c;
-          const next = new Map(prev);
-          const existing = next.get(uiThreadId);
-          const nextStatus = (existing == null ? void 0 : existing.status) === "archived" ? "archived" : "regular";
-          next.set(uiThreadId, {
-            title: (_a3 = existing == null ? void 0 : existing.title) != null ? _a3 : "New Chat",
-            status: nextStatus,
-            lastActiveAt: (_b2 = existing == null ? void 0 : existing.lastActiveAt) != null ? _b2 : (/* @__PURE__ */ new Date()).toISOString(),
-            control: (_c = existing == null ? void 0 : existing.control) != null ? _c : initThreadControl()
-          });
-          return next;
-        });
-        if (backendState.creatingThreadId === uiThreadId) {
-          backendState.creatingThreadId = null;
-        }
-        const pendingMessages = backendState.pendingChat.get(uiThreadId);
-        if (pendingMessages == null ? void 0 : pendingMessages.length) {
-          backendState.pendingChat.delete(uiThreadId);
-          const namespace = getNamespace();
-          const apiKey = (_b = getApiKey == null ? void 0 : getApiKey()) != null ? _b : void 0;
-          const userState = getUserState == null ? void 0 : getUserState();
-          for (const text of pendingMessages) {
-            try {
-              await backendApiRef.current.postChatMessage(
-                backendId,
-                text,
-                namespace,
-                userAddress,
-                apiKey,
-                userState
-              );
-            } catch (error) {
-              console.error("Failed to send queued message:", error);
-            }
-          }
-          if (currentThreadIdRef.current === uiThreadId) {
-            polling == null ? void 0 : polling.start(uiThreadId);
-          }
-        }
-      }).catch((error) => {
-        var _a2;
-        console.error("Failed to create new thread:", error);
-        const failedId = (_a2 = backendState.creatingThreadId) != null ? _a2 : threadId;
-        threadContext.setThreadMetadata((prev) => {
-          const next = new Map(prev);
-          next.delete(failedId);
-          return next;
-        });
-        threadContext.setThreads((prev) => {
-          const next = new Map(prev);
-          next.delete(failedId);
-          return next;
-        });
-        if (backendState.creatingThreadId === failedId) {
-          backendState.creatingThreadId = null;
-        }
-      }).finally(() => {
-        backendState.createThreadPromise = null;
-      });
-      backendState.createThreadPromise = createPromise;
+      threadContext.setThreadMetadata(
+        (prev) => new Map(prev).set(threadId, {
+          title: "New Chat",
+          status: "regular",
+          lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
+          control: initThreadControl()
+        })
+      );
+      threadContext.setThreadMessages(threadId, []);
+      threadContext.setCurrentThreadId(threadId);
+      setIsRunning(false);
+      threadContext.bumpThreadViewKey();
     },
     onSwitchToThread: (threadId) => {
       threadContext.setCurrentThreadId(threadId);
+      threadContext.bumpThreadViewKey();
     },
     onRename: async (threadId, newTitle) => {
       var _a, _b;
@@ -1937,7 +1299,7 @@ function buildThreadListAdapter({
         title: normalizedTitle
       });
       try {
-        await backendApiRef.current.renameThread(threadId, newTitle);
+        await aomiClientRef.current.renameThread(threadId, newTitle);
       } catch (error) {
         console.error("Failed to rename thread:", error);
         threadContext.updateThreadMetadata(threadId, {
@@ -1948,7 +1310,7 @@ function buildThreadListAdapter({
     onArchive: async (threadId) => {
       threadContext.updateThreadMetadata(threadId, { status: "archived" });
       try {
-        await backendApiRef.current.archiveThread(threadId);
+        await aomiClientRef.current.archiveThread(threadId);
       } catch (error) {
         console.error("Failed to archive thread:", error);
         threadContext.updateThreadMetadata(threadId, { status: "regular" });
@@ -1957,7 +1319,7 @@ function buildThreadListAdapter({
     onUnarchive: async (threadId) => {
       threadContext.updateThreadMetadata(threadId, { status: "regular" });
       try {
-        await backendApiRef.current.unarchiveThread(threadId);
+        await aomiClientRef.current.unarchiveThread(threadId);
       } catch (error) {
         console.error("Failed to unarchive thread:", error);
         threadContext.updateThreadMetadata(threadId, { status: "archived" });
@@ -1965,7 +1327,7 @@ function buildThreadListAdapter({
     },
     onDelete: async (threadId) => {
       try {
-        await backendApiRef.current.deleteThread(threadId);
+        await aomiClientRef.current.deleteThread(threadId);
         threadContext.setThreadMetadata((prev) => {
           const next = new Map(prev);
           next.delete(threadId);
@@ -1976,12 +1338,6 @@ function buildThreadListAdapter({
           next.delete(threadId);
           return next;
         });
-        backendState.pendingChat.delete(threadId);
-        backendState.skipInitialFetch.delete(threadId);
-        backendState.runningThreads.delete(threadId);
-        if (backendState.creatingThreadId === threadId) {
-          backendState.creatingThreadId = null;
-        }
         if (threadContext.currentThreadId === threadId) {
           const firstRegularThread = Array.from(
             threadContext.allThreadsMetadata.entries()
@@ -2024,11 +1380,223 @@ function useAomiRuntime() {
   return context;
 }
 
+// packages/react/src/handlers/wallet-handler.ts
+import { useCallback as useCallback6, useEffect as useEffect3, useRef as useRef6, useState as useState6 } from "react";
+
+// packages/react/src/state/wallet-buffer.ts
+function createWalletBuffer() {
+  return { queue: [], nextId: 1 };
+}
+function enqueue(buffer, kind, payload) {
+  const request = {
+    id: `wreq-${buffer.nextId++}`,
+    kind,
+    payload,
+    status: "pending",
+    timestamp: Date.now()
+  };
+  buffer.queue.push(request);
+  return request;
+}
+function dequeue(buffer, id) {
+  const index = buffer.queue.findIndex((r) => r.id === id);
+  if (index === -1) return null;
+  return buffer.queue.splice(index, 1)[0];
+}
+function markProcessing(buffer, id) {
+  const request = buffer.queue.find((r) => r.id === id);
+  if (!request || request.status !== "pending") return false;
+  request.status = "processing";
+  return true;
+}
+function getAll(buffer) {
+  return [...buffer.queue];
+}
+
+// packages/react/src/handlers/wallet-handler.ts
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  return value;
+}
+function getToolArgs(payload) {
+  const root = asRecord(payload);
+  const nestedArgs = asRecord(root == null ? void 0 : root.args);
+  return nestedArgs != null ? nestedArgs : root != null ? root : {};
+}
+function parseChainId(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  if (trimmed.startsWith("0x")) {
+    const parsedHex = Number.parseInt(trimmed.slice(2), 16);
+    return Number.isFinite(parsedHex) ? parsedHex : void 0;
+  }
+  const parsed = Number.parseInt(trimmed, 10);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function normalizeTxPayload(payload) {
+  var _a, _b, _c;
+  const root = asRecord(payload);
+  const args = getToolArgs(payload);
+  const ctx = asRecord(root == null ? void 0 : root.ctx);
+  const to = typeof args.to === "string" ? args.to : void 0;
+  if (!to) return null;
+  const valueRaw = args.value;
+  const value = typeof valueRaw === "string" ? valueRaw : typeof valueRaw === "number" && Number.isFinite(valueRaw) ? String(Math.trunc(valueRaw)) : void 0;
+  const data = typeof args.data === "string" ? args.data : void 0;
+  const chainId = (_c = (_b = (_a = parseChainId(args.chainId)) != null ? _a : parseChainId(args.chain_id)) != null ? _b : parseChainId(ctx == null ? void 0 : ctx.user_chain_id)) != null ? _c : parseChainId(ctx == null ? void 0 : ctx.userChainId);
+  return {
+    to,
+    value,
+    data,
+    chainId
+  };
+}
+function normalizeEip712Payload(payload) {
+  var _a;
+  const args = getToolArgs(payload);
+  const typedDataRaw = (_a = args.typed_data) != null ? _a : args.typedData;
+  let typedData;
+  if (typeof typedDataRaw === "string") {
+    try {
+      const parsed = JSON.parse(typedDataRaw);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        typedData = parsed;
+      }
+    } catch (e) {
+      typedData = void 0;
+    }
+  } else if (typedDataRaw && typeof typedDataRaw === "object" && !Array.isArray(typedDataRaw)) {
+    typedData = typedDataRaw;
+  }
+  const description = typeof args.description === "string" ? args.description : void 0;
+  return {
+    typed_data: typedData,
+    description
+  };
+}
+function useWalletHandler({
+  sessionId,
+  onRequestComplete
+}) {
+  const { subscribe: subscribe2, sendOutboundSystem: sendOutbound } = useEventContext();
+  const bufferRef = useRef6(createWalletBuffer());
+  const [pendingRequests, setPendingRequests] = useState6([]);
+  const syncState = useCallback6(() => {
+    setPendingRequests(getAll(bufferRef.current));
+  }, []);
+  useEffect3(() => {
+    const unsubscribe = subscribe2(
+      "wallet_tx_request",
+      (event) => {
+        const payload = normalizeTxPayload(event.payload);
+        if (!payload) {
+          console.warn("[aomi][wallet] Ignoring tx request with invalid payload", event.payload);
+          return;
+        }
+        enqueue(bufferRef.current, "transaction", payload);
+        syncState();
+      }
+    );
+    return unsubscribe;
+  }, [subscribe2, syncState]);
+  useEffect3(() => {
+    const unsubscribe = subscribe2(
+      "wallet_eip712_request",
+      (event) => {
+        var _a;
+        const payload = normalizeEip712Payload((_a = event.payload) != null ? _a : {});
+        enqueue(bufferRef.current, "eip712_sign", payload);
+        syncState();
+      }
+    );
+    return unsubscribe;
+  }, [subscribe2, syncState]);
+  const startProcessingCb = useCallback6(
+    (id) => {
+      markProcessing(bufferRef.current, id);
+      syncState();
+    },
+    [syncState]
+  );
+  const resolveRequest = useCallback6(
+    (id, result) => {
+      var _a;
+      const removed = dequeue(bufferRef.current, id);
+      if (!removed) return;
+      let outbound;
+      if (removed.kind === "transaction") {
+        outbound = sendOutbound({
+          type: "wallet:tx_complete",
+          sessionId,
+          payload: {
+            txHash: (_a = result.txHash) != null ? _a : "",
+            status: "success",
+            amount: result.amount
+          }
+        });
+      } else {
+        const eip712Payload = removed.payload;
+        outbound = sendOutbound({
+          type: "wallet_eip712_response",
+          sessionId,
+          payload: {
+            status: "success",
+            signature: result.signature,
+            description: eip712Payload.description
+          }
+        });
+      }
+      outbound.then(() => onRequestComplete == null ? void 0 : onRequestComplete());
+      syncState();
+    },
+    [sendOutbound, sessionId, syncState, onRequestComplete]
+  );
+  const rejectRequest = useCallback6(
+    (id, error) => {
+      const removed = dequeue(bufferRef.current, id);
+      if (!removed) return;
+      let outbound;
+      if (removed.kind === "transaction") {
+        outbound = sendOutbound({
+          type: "wallet:tx_complete",
+          sessionId,
+          payload: {
+            txHash: "",
+            status: "failed"
+          }
+        });
+      } else {
+        const eip712Payload = removed.payload;
+        outbound = sendOutbound({
+          type: "wallet_eip712_response",
+          sessionId,
+          payload: {
+            status: "failed",
+            error: error != null ? error : "EIP-712 signing failed",
+            description: eip712Payload.description
+          }
+        });
+      }
+      outbound.then(() => onRequestComplete == null ? void 0 : onRequestComplete());
+      syncState();
+    },
+    [sendOutbound, sessionId, syncState, onRequestComplete]
+  );
+  return {
+    pendingRequests,
+    startProcessing: startProcessingCb,
+    resolveRequest,
+    rejectRequest
+  };
+}
+
 // packages/react/src/runtime/core.tsx
 import { jsx as jsx6 } from "react/jsx-runtime";
 function AomiRuntimeCore({
   children,
-  backendApi
+  aomiClient
 }) {
   const threadContext = useThreadContext();
   const eventContext = useEventContext();
@@ -2043,18 +1611,18 @@ function AomiRuntimeCore({
     isRunning,
     setIsRunning,
     ensureInitialState,
-    backendApiRef
-  } = useRuntimeOrchestrator(backendApi, {
+    aomiClientRef
+  } = useRuntimeOrchestrator(aomiClient, {
     onSyncEvents: dispatchSystemEvents,
     getPublicKey: () => getUserState().address,
     getUserState,
-    getNamespace: () => {
+    getApp: () => {
       var _a, _b;
-      return (_b = (_a = getCurrentThreadControl().namespace) != null ? _a : getControlState().defaultNamespace) != null ? _b : "default";
+      return (_b = (_a = getCurrentThreadControl().app) != null ? _a : getControlState().defaultApp) != null ? _b : "default";
     },
     getApiKey: () => getControlState().apiKey
   });
-  useEffect3(() => {
+  useEffect4(() => {
     const unsubscribe = onUserStateChange(async (newUser) => {
       const sessionId = threadContext.currentThreadId;
       const message = JSON.stringify({
@@ -2066,24 +1634,44 @@ function AomiRuntimeCore({
           ensName: newUser.ensName
         }
       });
-      await backendApiRef.current.postSystemMessage(sessionId, message);
+      await aomiClientRef.current.sendSystemMessage(sessionId, message);
     });
     return unsubscribe;
-  }, [onUserStateChange, backendApiRef, threadContext.currentThreadId]);
-  const threadContextRef = useRef6(threadContext);
+  }, [onUserStateChange, aomiClientRef, threadContext.currentThreadId]);
+  const threadContextRef = useRef7(threadContext);
   threadContextRef.current = threadContext;
-  const currentThreadIdRef = useRef6(threadContext.currentThreadId);
-  useEffect3(() => {
+  const currentThreadIdRef = useRef7(threadContext.currentThreadId);
+  useEffect4(() => {
     currentThreadIdRef.current = threadContext.currentThreadId;
   }, [threadContext.currentThreadId]);
-  useEffect3(() => {
+  const onWalletRequestComplete = useCallback7(() => {
+    polling.start(currentThreadIdRef.current);
+  }, [polling]);
+  const walletHandler = useWalletHandler({
+    sessionId: threadContext.currentThreadId,
+    onRequestComplete: onWalletRequestComplete
+  });
+  useEffect4(() => {
+    const unsubscribe = eventContext.subscribe(
+      "user_state_request",
+      () => {
+        eventContext.sendOutboundSystem({
+          type: "user_state_response",
+          sessionId: threadContext.currentThreadId,
+          payload: getUserState()
+        });
+      }
+    );
+    return unsubscribe;
+  }, [eventContext, threadContext.currentThreadId, getUserState]);
+  useEffect4(() => {
     void ensureInitialState(threadContext.currentThreadId);
   }, [ensureInitialState, threadContext.currentThreadId]);
-  useEffect3(() => {
+  useEffect4(() => {
     const threadId = threadContext.currentThreadId;
     setIsRunning(isThreadRunning(backendStateRef.current, threadId));
   }, [backendStateRef, setIsRunning, threadContext.currentThreadId]);
-  useEffect3(() => {
+  useEffect4(() => {
     const threadId = threadContext.currentThreadId;
     const currentMeta = threadContext.getThreadMetadata(threadId);
     if (currentMeta && currentMeta.control.isProcessing !== isRunning) {
@@ -2097,21 +1685,13 @@ function AomiRuntimeCore({
   const currentMessages = threadContext.getThreadMessages(
     threadContext.currentThreadId
   );
-  const resolvedSessionId = useMemo2(
-    () => resolveThreadId(backendStateRef.current, threadContext.currentThreadId),
-    [
-      backendStateRef,
-      threadContext.currentThreadId,
-      threadContext.allThreadsMetadata
-    ]
-  );
-  useEffect3(() => {
+  useEffect4(() => {
     const userAddress = user.address;
     if (!userAddress) return;
     const fetchThreadList = async () => {
       var _a, _b, _c;
       try {
-        const threadList = await backendApiRef.current.fetchThreads(userAddress);
+        const threadList = await aomiClientRef.current.listThreads(userAddress);
         const currentContext = threadContextRef.current;
         const newMetadata = new Map(currentContext.allThreadsMetadata);
         let maxChatNum = currentContext.threadCnt;
@@ -2143,25 +1723,25 @@ function AomiRuntimeCore({
       }
     };
     void fetchThreadList();
-  }, [user.address, backendApiRef]);
+  }, [user.address, aomiClientRef]);
   const threadListAdapter = useMemo2(
     () => buildThreadListAdapter({
       backendStateRef,
-      backendApiRef,
+      aomiClientRef,
       threadContext,
       currentThreadIdRef,
       polling,
       userAddress: user.address,
       setIsRunning,
-      getNamespace: () => {
+      getApp: () => {
         var _a, _b;
-        return (_b = (_a = getCurrentThreadControl().namespace) != null ? _a : getControlState().defaultNamespace) != null ? _b : "default";
+        return (_b = (_a = getCurrentThreadControl().app) != null ? _a : getControlState().defaultApp) != null ? _b : "default";
       },
       getApiKey: () => getControlState().apiKey,
       getUserState
     }),
     [
-      backendApiRef,
+      aomiClientRef,
       polling,
       user.address,
       backendStateRef,
@@ -2173,70 +1753,41 @@ function AomiRuntimeCore({
       getUserState
     ]
   );
-  useEffect3(() => {
+  useEffect4(() => {
     const backendState = backendStateRef.current;
-    const currentSessionId = threadContext.currentThreadId;
-    if (process.env.NODE_ENV !== "production") {
-      console.debug("[aomi][sse] subscribe", {
-        currentSessionId,
-        resolvedSessionId,
-        hasMapping: currentSessionId !== resolvedSessionId
-      });
-    }
-    const unsubscribe = backendApiRef.current.subscribeSSE(
-      resolvedSessionId,
-      (event) => {
-        const eventType = event.type;
-        const sessionId = event.session_id;
-        if (eventType === "title_changed") {
-          const newTitle = event.new_title;
-          const targetThreadId = resolveThreadId(backendState, sessionId);
-          const normalizedTitle = isPlaceholderTitle(newTitle) ? "" : newTitle;
-          if (process.env.NODE_ENV !== "production") {
-            console.debug("[aomi][sse] title_changed", {
-              sessionId,
-              newTitle,
-              normalizedTitle,
-              currentThreadId: threadContextRef.current.currentThreadId,
-              targetThreadId,
-              hasMapping: sessionId !== targetThreadId,
-              creatingThreadId: backendState.creatingThreadId
-            });
-          }
-          threadContextRef.current.setThreadMetadata((prev) => {
-            var _a, _b;
-            const next = new Map(prev);
-            const existing = next.get(targetThreadId);
-            const nextStatus = (existing == null ? void 0 : existing.status) === "archived" ? "archived" : "regular";
-            next.set(targetThreadId, {
-              title: normalizedTitle,
-              status: nextStatus,
-              lastActiveAt: (_a = existing == null ? void 0 : existing.lastActiveAt) != null ? _a : (/* @__PURE__ */ new Date()).toISOString(),
-              control: (_b = existing == null ? void 0 : existing.control) != null ? _b : initThreadControl()
-            });
-            return next;
-          });
-          if (!isPlaceholderTitle(newTitle) && backendState.creatingThreadId === targetThreadId) {
-            backendState.creatingThreadId = null;
-          }
-        }
+    const unsubscribe = eventContext.subscribe("title_changed", (event) => {
+      const sessionId = event.sessionId;
+      const payload = event.payload;
+      const newTitle = payload == null ? void 0 : payload.new_title;
+      if (typeof newTitle !== "string") return;
+      const targetThreadId = resolveThreadId(backendState, sessionId);
+      const normalizedTitle = isPlaceholderTitle(newTitle) ? "" : newTitle;
+      if (process.env.NODE_ENV !== "production") {
+        console.debug("[aomi][sse] title_changed", {
+          sessionId,
+          newTitle,
+          normalizedTitle,
+          currentThreadId: threadContextRef.current.currentThreadId,
+          targetThreadId
+        });
       }
-    );
-    return () => {
-      unsubscribe == null ? void 0 : unsubscribe();
-    };
-  }, [
-    backendApiRef,
-    backendStateRef,
-    threadContext.currentThreadId,
-    resolvedSessionId
-  ]);
-  useEffect3(() => {
-    const threadId = threadContext.currentThreadId;
-    if (!isThreadReady(backendStateRef.current, threadId)) return;
-    void messageController.flushPendingChat(threadId);
-  }, [messageController, backendStateRef, threadContext.currentThreadId]);
-  useEffect3(() => {
+      threadContextRef.current.setThreadMetadata((prev) => {
+        var _a, _b;
+        const next = new Map(prev);
+        const existing = next.get(targetThreadId);
+        const nextStatus = (existing == null ? void 0 : existing.status) === "archived" ? "archived" : "regular";
+        next.set(targetThreadId, {
+          title: normalizedTitle,
+          status: nextStatus,
+          lastActiveAt: (_a = existing == null ? void 0 : existing.lastActiveAt) != null ? _a : (/* @__PURE__ */ new Date()).toISOString(),
+          control: (_b = existing == null ? void 0 : existing.control) != null ? _b : initThreadControl()
+        });
+        return next;
+      });
+    });
+    return unsubscribe;
+  }, [eventContext, backendStateRef]);
+  useEffect4(() => {
     const showToolNotification = (eventType) => (event) => {
       const payload = event.payload;
       const toolName = typeof (payload == null ? void 0 : payload.tool_name) === "string" ? payload.tool_name : void 0;
@@ -2261,7 +1812,7 @@ function AomiRuntimeCore({
       unsubscribeComplete();
     };
   }, [eventContext, notificationContext]);
-  useEffect3(() => {
+  useEffect4(() => {
     const unsubscribe = eventContext.subscribe("system_notice", (event) => {
       const payload = event.payload;
       const message = payload == null ? void 0 : payload.message;
@@ -2277,13 +1828,13 @@ function AomiRuntimeCore({
     convertMessage: (msg) => msg,
     adapters: { threadList: threadListAdapter }
   });
-  useEffect3(() => {
+  useEffect4(() => {
     return () => {
       polling.stopAll();
     };
   }, [polling]);
   const userContext = useUser();
-  const sendMessage = useCallback6(
+  const sendMessage = useCallback7(
     async (text) => {
       const appendMessage = {
         role: "user",
@@ -2296,39 +1847,39 @@ function AomiRuntimeCore({
     },
     [messageController, threadContext.currentThreadId]
   );
-  const cancelGeneration = useCallback6(() => {
+  const cancelGeneration = useCallback7(() => {
     messageController.cancel(threadContext.currentThreadId);
   }, [messageController, threadContext.currentThreadId]);
-  const getMessages = useCallback6(
+  const getMessages = useCallback7(
     (threadId) => {
       const id = threadId != null ? threadId : threadContext.currentThreadId;
       return threadContext.getThreadMessages(id);
     },
     [threadContext]
   );
-  const createThread = useCallback6(async () => {
+  const createThread = useCallback7(async () => {
     await threadListAdapter.onSwitchToNewThread();
     return threadContextRef.current.currentThreadId;
   }, [threadListAdapter]);
-  const deleteThread = useCallback6(
+  const deleteThread = useCallback7(
     async (threadId) => {
       await threadListAdapter.onDelete(threadId);
     },
     [threadListAdapter]
   );
-  const renameThread = useCallback6(
+  const renameThread = useCallback7(
     async (threadId, title) => {
       await threadListAdapter.onRename(threadId, title);
     },
     [threadListAdapter]
   );
-  const archiveThread = useCallback6(
+  const archiveThread = useCallback7(
     async (threadId) => {
       await threadListAdapter.onArchive(threadId);
     },
     [threadListAdapter]
   );
-  const selectThread = useCallback6(
+  const selectThread = useCallback7(
     (threadId) => {
       if (threadContext.allThreadsMetadata.has(threadId)) {
         threadListAdapter.onSwitchToThread(threadId);
@@ -2365,6 +1916,11 @@ function AomiRuntimeCore({
       showNotification: notificationContext.showNotification,
       dismissNotification: notificationContext.dismissNotification,
       clearAllNotifications: notificationContext.clearAll,
+      // Wallet API
+      pendingWalletRequests: walletHandler.pendingRequests,
+      startWalletRequest: walletHandler.startProcessing,
+      resolveWalletRequest: walletHandler.resolveRequest,
+      rejectWalletRequest: walletHandler.rejectRequest,
       // Event API
       subscribe: eventContext.subscribe,
       sendSystemCommand: eventContext.sendOutboundSystem,
@@ -2386,6 +1942,7 @@ function AomiRuntimeCore({
       sendMessage,
       cancelGeneration,
       notificationContext,
+      walletHandler,
       eventContext
     ]
   );
@@ -2398,12 +1955,12 @@ function AomiRuntimeProvider({
   children,
   backendUrl = "http://localhost:8080"
 }) {
-  const backendApi = useMemo3(() => new BackendApi(backendUrl), [backendUrl]);
-  return /* @__PURE__ */ jsx7(ThreadContextProvider, { children: /* @__PURE__ */ jsx7(NotificationContextProvider, { children: /* @__PURE__ */ jsx7(UserContextProvider, { children: /* @__PURE__ */ jsx7(AomiRuntimeInner, { backendApi, children }) }) }) });
+  const aomiClient = useMemo3(() => new AomiClient({ baseUrl: backendUrl }), [backendUrl]);
+  return /* @__PURE__ */ jsx7(ThreadContextProvider, { children: /* @__PURE__ */ jsx7(NotificationContextProvider, { children: /* @__PURE__ */ jsx7(UserContextProvider, { children: /* @__PURE__ */ jsx7(AomiRuntimeInner, { aomiClient, children }) }) }) });
 }
 function AomiRuntimeInner({
   children,
-  backendApi
+  aomiClient
 }) {
   var _a;
   const threadContext = useThreadContext();
@@ -2411,7 +1968,7 @@ function AomiRuntimeInner({
   return /* @__PURE__ */ jsx7(
     ControlContextProvider,
     {
-      backendApi,
+      aomiClient,
       sessionId: threadContext.currentThreadId,
       publicKey: (_a = user.address) != null ? _a : void 0,
       getThreadMetadata: threadContext.getThreadMetadata,
@@ -2419,94 +1976,15 @@ function AomiRuntimeInner({
       children: /* @__PURE__ */ jsx7(
         EventContextProvider,
         {
-          backendApi,
+          aomiClient,
           sessionId: threadContext.currentThreadId,
-          children: /* @__PURE__ */ jsx7(AomiRuntimeCore, { backendApi, children })
+          children: /* @__PURE__ */ jsx7(AomiRuntimeCore, { aomiClient, children })
         }
       )
     }
   );
 }
 
-// packages/react/src/handlers/wallet-handler.ts
-import { useCallback as useCallback7, useEffect as useEffect4, useState as useState6 } from "react";
-function useWalletHandler({
-  sessionId,
-  onTxRequest
-}) {
-  const { subscribe: subscribe2, sendOutboundSystem: sendOutbound } = useEventContext();
-  const { setUser, getUserState } = useUser();
-  const [pendingTxRequests, setPendingTxRequests] = useState6(
-    []
-  );
-  useEffect4(() => {
-    const unsubscribe = subscribe2(
-      "wallet_tx_request",
-      (event) => {
-        const request = event.payload;
-        setPendingTxRequests((prev) => [...prev, request]);
-        onTxRequest == null ? void 0 : onTxRequest(request);
-      }
-    );
-    return unsubscribe;
-  }, [subscribe2, onTxRequest]);
-  useEffect4(() => {
-    const unsubscribe = subscribe2(
-      "user_state_request",
-      (event) => {
-        sendOutbound({
-          type: "user_state_response",
-          sessionId,
-          payload: getUserState()
-        });
-      }
-    );
-    return unsubscribe;
-  }, [subscribe2, onTxRequest]);
-  const sendTxComplete = useCallback7(
-    (tx) => {
-      sendOutbound({
-        type: "wallet:tx_complete",
-        sessionId,
-        payload: tx
-      });
-    },
-    [sendOutbound, sessionId]
-  );
-  const sendConnectionChange = useCallback7(
-    (status, address, chainId) => {
-      if (status === "connected") {
-        setUser({
-          isConnected: true,
-          address,
-          chainId
-        });
-      } else {
-        setUser({
-          isConnected: false,
-          address: void 0,
-          chainId: void 0
-        });
-      }
-      sendOutbound({
-        type: status === "connected" ? "wallet:connected" : "wallet:disconnected",
-        sessionId,
-        payload: { status, address }
-      });
-    },
-    [setUser, sendOutbound, sessionId]
-  );
-  const clearTxRequest = useCallback7((index) => {
-    setPendingTxRequests((prev) => prev.filter((_, i) => i !== index));
-  }, []);
-  return {
-    sendTxComplete,
-    sendConnectionChange,
-    pendingTxRequests,
-    clearTxRequest
-  };
-}
-
 // packages/react/src/handlers/notification-handler.ts
 import { useCallback as useCallback8, useEffect as useEffect5, useState as useState7 } from "react";
 var notificationIdCounter2 = 0;
@@ -2549,8 +2027,8 @@ function useNotificationHandler({
   };
 }
 export {
+  AomiClient2 as AomiClient,
   AomiRuntimeProvider,
-  BackendApi,
   ControlContextProvider,
   EventContextProvider,
   NotificationContextProvider,