@aomi-labs/react 0.3.0 → 0.3.2

package/dist/index.js

@@ -18,438 +18,13 @@ 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";
+import { toViemSignTypedDataArgs } 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 +64,7 @@ var logThreadMetadataChange = (source, threadId, prev, next) => {
 function initThreadControl() {
   return {
     model: null,
-    namespace: null,
+    app: null,
     controlDirty: false,
     isProcessing: false
   };
@@ -635,6 +210,16 @@ var ThreadStore = class {
 // packages/react/src/contexts/control-context.tsx
 import { jsx } from "react/jsx-runtime";
 var API_KEY_STORAGE_KEY = "aomi_api_key";
+function getDefaultApp(apps) {
+  var _a;
+  return apps.includes("default") ? "default" : (_a = apps[0]) != null ? _a : null;
+}
+function resolveAuthorizedApp(app, authorizedApps, defaultApp) {
+  if (app && authorizedApps.includes(app)) {
+    return app;
+  }
+  return defaultApp;
+}
 var ControlContext = createContext(null);
 function useControl() {
   const ctx = useContext(ControlContext);
@@ -645,7 +230,7 @@ function useControl() {
 }
 function ControlContextProvider({
   children,
-  backendApi,
+  aomiClient,
   sessionId,
   publicKey,
   getThreadMetadata,
@@ -655,14 +240,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 +281,35 @@ function ControlContextProvider({
     }
   }, [state.apiKey]);
   useEffect(() => {
-    const fetchNamespaces = async () => {
-      var _a2, _b2;
+    const fetchApps = async () => {
+      var _a2;
       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 = getDefaultApp(apps);
         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();
-  }, [state.apiKey]);
+    void fetchApps();
+  }, [state.apiKey, publicKey, sessionId]);
   useEffect(() => {
     const fetchModels = async () => {
       try {
-        const models = await backendApiRef.current.getModels(
+        const models = await aomiClientRef.current.getModels(
           sessionIdRef.current
         );
         setStateInternal((prev) => {
@@ -747,7 +334,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 +350,27 @@ function ControlContextProvider({
       return [];
     }
   }, []);
-  const getAuthorizedNamespaces = useCallback(async () => {
-    var _a2, _b2;
+  const getAuthorizedApps = useCallback(async () => {
+    var _a2;
     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 = getDefaultApp(apps);
       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"];
     }
@@ -791,8 +380,17 @@ function ControlContextProvider({
     const metadata = getThreadMetadataRef.current(sessionIdRef.current);
     return (_a2 = metadata == null ? void 0 : metadata.control) != null ? _a2 : initThreadControl();
   }, []);
+  const getCurrentThreadApp = useCallback(() => {
+    var _a2, _b2, _c;
+    const currentControl = (_b2 = (_a2 = getThreadMetadataRef.current(sessionIdRef.current)) == null ? void 0 : _a2.control) != null ? _b2 : initThreadControl();
+    return (_c = resolveAuthorizedApp(
+      currentControl.app,
+      stateRef.current.authorizedApps,
+      stateRef.current.defaultApp
+    )) != null ? _c : "default";
+  }, []);
   const onModelSelect = useCallback(async (model) => {
-    var _a2, _b2, _c, _d, _e;
+    var _a2, _b2, _c, _d;
     const threadId = sessionIdRef.current;
     const currentControl = (_b2 = (_a2 = getThreadMetadataRef.current(threadId)) == null ? void 0 : _a2.control) != null ? _b2 : initThreadControl();
     const isProcessing2 = currentControl.isProcessing;
@@ -805,32 +403,35 @@ 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 = (_c = resolveAuthorizedApp(
+      currentControl.app,
+      stateRef.current.authorizedApps,
+      stateRef.current.defaultApp
+    )) != null ? _c : "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: (_d = stateRef.current.apiKey) != null ? _d : void 0 }
       );
       console.log("[control-context] onModelSelect backend result", result);
     } catch (err) {
@@ -838,34 +439,38 @@ 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", {
+    if (stateRef.current.authorizedApps.length > 0 && !stateRef.current.authorizedApps.includes(app)) {
+      console.warn("[control-context] Cannot select unauthorized app", { app });
+      return;
+    }
+    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 +500,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 +513,11 @@ function ControlContextProvider({
         state,
         setApiKey,
         getAvailableModels,
-        getAuthorizedNamespaces,
+        getAuthorizedApps,
         getCurrentThreadControl,
+        getCurrentThreadApp,
         onModelSelect,
-        onNamespaceSelect,
+        onAppSelect,
         isProcessing,
         markControlSynced,
         getControlState,
@@ -932,20 +538,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 +603,7 @@ function useEventContext() {
 }
 function EventContextProvider({
   children,
-  backendApi,
+  aomiClient,
   sessionId
 }) {
   const bufferRef = useRef2(null);
@@ -1017,7 +615,7 @@ function EventContextProvider({
   useEffect2(() => {
     setSSEStatus(buffer, "connecting");
     setSseStatus("connecting");
-    const unsubscribe = backendApi.subscribeSSE(
+    const unsubscribe = aomiClient.subscribeSSE(
       sessionId,
       (event) => {
         enqueueInbound(buffer, {
@@ -1047,7 +645,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 +659,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) => {
@@ -1452,19 +1050,16 @@ var MessageController = class {
       lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
     });
     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);
@@ -1488,7 +1083,7 @@ var MessageController = class {
     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);
       }
@@ -1536,7 +1131,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
         );
@@ -1584,12 +1179,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);
@@ -1597,7 +1192,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;
@@ -1619,13 +1214,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
@@ -1638,7 +1233,7 @@ function useRuntimeOrchestrator(backendApi, options) {
     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
       );
@@ -1670,7 +1265,7 @@ function useRuntimeOrchestrator(backendApi, options) {
     isRunning,
     setIsRunning,
     ensureInitialState,
-    backendApiRef
+    aomiClientRef
   };
 }
 
@@ -1701,7 +1296,7 @@ function buildThreadLists(threadMetadata) {
   return { regularThreads, archivedThreads };
 }
 function buildThreadListAdapter({
-  backendApiRef,
+  aomiClientRef,
   threadContext,
   setIsRunning
 }) {
@@ -1729,6 +1324,7 @@ function buildThreadListAdapter({
     },
     onSwitchToThread: (threadId) => {
       threadContext.setCurrentThreadId(threadId);
+      threadContext.bumpThreadViewKey();
     },
     onRename: async (threadId, newTitle) => {
       var _a, _b;
@@ -1738,7 +1334,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, {
@@ -1749,7 +1345,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" });
@@ -1758,7 +1354,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" });
@@ -1766,7 +1362,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);
@@ -1821,6 +1417,10 @@ function useAomiRuntime() {
 
 // packages/react/src/handlers/wallet-handler.ts
 import { useCallback as useCallback6, useEffect as useEffect3, useRef as useRef6, useState as useState6 } from "react";
+import {
+  normalizeEip712Payload,
+  normalizeTxPayload
+} from "@aomi-labs/client";
 
 // packages/react/src/state/wallet-buffer.ts
 function createWalletBuffer() {
@@ -1867,7 +1467,11 @@ function useWalletHandler({
     const unsubscribe = subscribe2(
       "wallet_tx_request",
       (event) => {
-        const payload = event.payload;
+        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();
       }
@@ -1879,7 +1483,7 @@ function useWalletHandler({
       "wallet_eip712_request",
       (event) => {
         var _a;
-        const payload = (_a = event.payload) != null ? _a : {};
+        const payload = normalizeEip712Payload((_a = event.payload) != null ? _a : {});
         enqueue(bufferRef.current, "eip712_sign", payload);
         syncState();
       }
@@ -1969,14 +1573,14 @@ function useWalletHandler({
 import { jsx as jsx6 } from "react/jsx-runtime";
 function AomiRuntimeCore({
   children,
-  backendApi
+  aomiClient
 }) {
   const threadContext = useThreadContext();
   const eventContext = useEventContext();
   const notificationContext = useNotification();
   const { dispatchInboundSystem: dispatchSystemEvents } = eventContext;
   const { user, onUserStateChange, getUserState } = useUser();
-  const { getControlState, getCurrentThreadControl } = useControl();
+  const { getControlState, getCurrentThreadApp } = useControl();
   const {
     backendStateRef,
     polling,
@@ -1984,15 +1588,12 @@ function AomiRuntimeCore({
     isRunning,
     setIsRunning,
     ensureInitialState,
-    backendApiRef
-  } = useRuntimeOrchestrator(backendApi, {
+    aomiClientRef
+  } = useRuntimeOrchestrator(aomiClient, {
     onSyncEvents: dispatchSystemEvents,
     getPublicKey: () => getUserState().address,
     getUserState,
-    getNamespace: () => {
-      var _a, _b;
-      return (_b = (_a = getCurrentThreadControl().namespace) != null ? _a : getControlState().defaultNamespace) != null ? _b : "default";
-    },
+    getApp: getCurrentThreadApp,
     getApiKey: () => getControlState().apiKey
   });
   useEffect4(() => {
@@ -2007,10 +1608,10 @@ function AomiRuntimeCore({
           ensName: newUser.ensName
         }
       });
-      await backendApiRef.current.postSystemMessage(sessionId, message);
+      await aomiClientRef.current.sendSystemMessage(sessionId, message);
     });
     return unsubscribe;
-  }, [onUserStateChange, backendApiRef, threadContext.currentThreadId]);
+  }, [onUserStateChange, aomiClientRef, threadContext.currentThreadId]);
   const threadContextRef = useRef7(threadContext);
   threadContextRef.current = threadContext;
   const currentThreadIdRef = useRef7(threadContext.currentThreadId);
@@ -2058,21 +1659,13 @@ function AomiRuntimeCore({
   const currentMessages = threadContext.getThreadMessages(
     threadContext.currentThreadId
   );
-  const resolvedSessionId = useMemo2(
-    () => resolveThreadId(backendStateRef.current, threadContext.currentThreadId),
-    [
-      backendStateRef,
-      threadContext.currentThreadId,
-      threadContext.allThreadsMetadata
-    ]
-  );
   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;
@@ -2104,25 +1697,22 @@ 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: () => {
-        var _a, _b;
-        return (_b = (_a = getCurrentThreadControl().namespace) != null ? _a : getControlState().defaultNamespace) != null ? _b : "default";
-      },
+      getApp: getCurrentThreadApp,
       getApiKey: () => getControlState().apiKey,
       getUserState
     }),
     [
-      backendApiRef,
+      aomiClientRef,
       polling,
       user.address,
       backendStateRef,
@@ -2131,63 +1721,44 @@ function AomiRuntimeCore({
       threadContext.currentThreadId,
       threadContext.allThreadsMetadata,
       getControlState,
+      getCurrentThreadApp,
       getUserState
     ]
   );
   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
-            });
-          }
-          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;
-          });
-        }
+    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
-  ]);
+      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;
@@ -2356,12 +1927,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();
@@ -2369,7 +1940,7 @@ function AomiRuntimeInner({
   return /* @__PURE__ */ jsx7(
     ControlContextProvider,
     {
-      backendApi,
+      aomiClient,
       sessionId: threadContext.currentThreadId,
       publicKey: (_a = user.address) != null ? _a : void 0,
       getThreadMetadata: threadContext.getThreadMetadata,
@@ -2377,9 +1948,9 @@ function AomiRuntimeInner({
       children: /* @__PURE__ */ jsx7(
         EventContextProvider,
         {
-          backendApi,
+          aomiClient,
           sessionId: threadContext.currentThreadId,
-          children: /* @__PURE__ */ jsx7(AomiRuntimeCore, { backendApi, children })
+          children: /* @__PURE__ */ jsx7(AomiRuntimeCore, { aomiClient, children })
         }
       )
     }
@@ -2428,8 +1999,8 @@ function useNotificationHandler({
   };
 }
 export {
+  AomiClient2 as AomiClient,
   AomiRuntimeProvider,
-  BackendApi,
   ControlContextProvider,
   EventContextProvider,
   NotificationContextProvider,
@@ -2441,6 +2012,7 @@ export {
   getChainInfo,
   getNetworkName,
   initThreadControl,
+  toViemSignTypedDataArgs,
   useAomiRuntime,
   useControl,
   useCurrentThreadMessages,