@aomi-labs/react 0.2.0 → 0.2.2

package/dist/index.js

@@ -18,7 +18,7 @@ var __spreadValues = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 
-// src/backend/sse.ts
+// 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;
@@ -204,8 +204,9 @@ function createSseSubscriber({
   return { subscribe: subscribe2 };
 }
 
-// src/backend/client.ts
+// 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)) {
@@ -220,12 +221,16 @@ function withSessionHeader(sessionId, init) {
   headers.set(SESSION_ID_HEADER, sessionId);
   return headers;
 }
-async function postState(backendUrl, path, payload, sessionId) {
+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: withSessionHeader(sessionId)
+    headers
   });
   if (!response.ok) {
     throw new Error(`HTTP ${response.status}: ${response.statusText}`);
@@ -253,15 +258,17 @@ var BackendApi = class {
     }
     return await response.json();
   }
-  async postChatMessage(sessionId, message, publicKey) {
+  async postChatMessage(sessionId, message, namespace, publicKey, apiKey) {
+    const payload = { message, namespace };
+    if (publicKey) {
+      payload.public_key = publicKey;
+    }
     return postState(
       this.backendUrl,
       "/api/chat",
-      {
-        message,
-        public_key: publicKey
-      },
-      sessionId
+      payload,
+      sessionId,
+      apiKey
     );
   }
   async postSystemMessage(sessionId, message) {
@@ -379,25 +386,551 @@ var BackendApi = class {
       if (response.status === 404) return [];
       throw new Error(`Failed to get system events: HTTP ${response.status}`);
     }
-    return await response.json();
-  }
-  // fetchEventsAfter removed: /api/events only supports count now
-};
-
-// src/runtime/aomi-runtime.tsx
-import { useMemo as useMemo3 } from "react";
+    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/runtime/aomi-runtime.tsx
+import { useMemo as useMemo3 } from "react";
+
+// packages/react/src/contexts/control-context.tsx
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useRef,
+  useState,
+  useEffect
+} from "react";
+
+// packages/react/src/utils/uuid.ts
+function generateUUID() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+
+// packages/react/src/state/thread-store.ts
+var shouldLogThreadUpdates = process.env.NODE_ENV !== "production";
+var logThreadMetadataChange = (source, threadId, prev, next) => {
+  if (!shouldLogThreadUpdates) return;
+  if (!prev && !next) return;
+  if (!prev || !next) {
+    console.debug(`[aomi][thread:${source}]`, { threadId, prev, next });
+    return;
+  }
+  if (prev.title !== next.title || prev.status !== next.status || prev.lastActiveAt !== next.lastActiveAt) {
+    console.debug(`[aomi][thread:${source}]`, { threadId, prev, next });
+  }
+};
+function initThreadControl() {
+  return {
+    model: null,
+    namespace: null,
+    controlDirty: false,
+    isProcessing: false
+  };
+}
+var ThreadStore = class {
+  constructor(options) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.subscribe = (listener) => {
+      this.listeners.add(listener);
+      return () => {
+        this.listeners.delete(listener);
+      };
+    };
+    this.getSnapshot = () => this.snapshot;
+    this.setCurrentThreadId = (threadId) => {
+      this.ensureThreadExists(threadId);
+      this.updateState({ currentThreadId: threadId });
+    };
+    this.bumpThreadViewKey = () => {
+      this.updateState({ threadViewKey: this.state.threadViewKey + 1 });
+    };
+    this.setThreadCnt = (updater) => {
+      const nextCnt = this.resolveStateAction(updater, this.state.threadCnt);
+      this.updateState({ threadCnt: nextCnt });
+    };
+    this.setThreads = (updater) => {
+      const nextThreads = this.resolveStateAction(updater, this.state.threads);
+      this.updateState({ threads: new Map(nextThreads) });
+    };
+    this.setThreadMetadata = (updater) => {
+      const prevMetadata = this.state.threadMetadata;
+      const nextMetadata = this.resolveStateAction(updater, prevMetadata);
+      for (const [threadId, next] of nextMetadata.entries()) {
+        logThreadMetadataChange(
+          "setThreadMetadata",
+          threadId,
+          prevMetadata.get(threadId),
+          next
+        );
+      }
+      for (const [threadId, prev] of prevMetadata.entries()) {
+        if (!nextMetadata.has(threadId)) {
+          logThreadMetadataChange("setThreadMetadata", threadId, prev, void 0);
+        }
+      }
+      this.updateState({ threadMetadata: new Map(nextMetadata) });
+    };
+    this.setThreadMessages = (threadId, messages) => {
+      this.ensureThreadExists(threadId);
+      const nextThreads = new Map(this.state.threads);
+      nextThreads.set(threadId, messages);
+      this.updateState({ threads: nextThreads });
+    };
+    this.getThreadMessages = (threadId) => {
+      var _a;
+      return (_a = this.state.threads.get(threadId)) != null ? _a : [];
+    };
+    this.getThreadMetadata = (threadId) => {
+      return this.state.threadMetadata.get(threadId);
+    };
+    this.updateThreadMetadata = (threadId, updates) => {
+      const existing = this.state.threadMetadata.get(threadId);
+      if (!existing) {
+        return;
+      }
+      const next = __spreadValues(__spreadValues({}, existing), updates);
+      const nextMetadata = new Map(this.state.threadMetadata);
+      nextMetadata.set(threadId, next);
+      logThreadMetadataChange("updateThreadMetadata", threadId, existing, next);
+      this.updateState({ threadMetadata: nextMetadata });
+    };
+    var _a;
+    const initialThreadId = (_a = options == null ? void 0 : options.initialThreadId) != null ? _a : generateUUID();
+    this.state = {
+      currentThreadId: initialThreadId,
+      threadViewKey: 0,
+      threadCnt: 1,
+      threads: /* @__PURE__ */ new Map([[initialThreadId, []]]),
+      threadMetadata: /* @__PURE__ */ new Map([
+        [
+          initialThreadId,
+          {
+            title: "New Chat",
+            status: "pending",
+            lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
+            control: initThreadControl()
+          }
+        ]
+      ])
+    };
+    this.snapshot = this.buildSnapshot();
+  }
+  emit() {
+    for (const listener of this.listeners) {
+      listener();
+    }
+  }
+  resolveStateAction(updater, current) {
+    return typeof updater === "function" ? updater(current) : updater;
+  }
+  ensureThreadExists(threadId) {
+    if (!this.state.threadMetadata.has(threadId)) {
+      const nextMetadata = new Map(this.state.threadMetadata);
+      nextMetadata.set(threadId, {
+        title: "New Chat",
+        status: "regular",
+        lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
+        control: initThreadControl()
+      });
+      this.state = __spreadProps(__spreadValues({}, this.state), { threadMetadata: nextMetadata });
+    }
+    if (!this.state.threads.has(threadId)) {
+      const nextThreads = new Map(this.state.threads);
+      nextThreads.set(threadId, []);
+      this.state = __spreadProps(__spreadValues({}, this.state), { threads: nextThreads });
+    }
+  }
+  updateState(partial) {
+    this.state = __spreadValues(__spreadValues({}, this.state), partial);
+    this.snapshot = this.buildSnapshot();
+    this.emit();
+  }
+  buildSnapshot() {
+    return {
+      currentThreadId: this.state.currentThreadId,
+      setCurrentThreadId: this.setCurrentThreadId,
+      threadViewKey: this.state.threadViewKey,
+      bumpThreadViewKey: this.bumpThreadViewKey,
+      allThreads: this.state.threads,
+      setThreads: this.setThreads,
+      allThreadsMetadata: this.state.threadMetadata,
+      setThreadMetadata: this.setThreadMetadata,
+      threadCnt: this.state.threadCnt,
+      setThreadCnt: this.setThreadCnt,
+      getThreadMessages: this.getThreadMessages,
+      setThreadMessages: this.setThreadMessages,
+      getThreadMetadata: this.getThreadMetadata,
+      updateThreadMetadata: this.updateThreadMetadata
+    };
+  }
+};
+
+// packages/react/src/contexts/control-context.tsx
+import { jsx } from "react/jsx-runtime";
+var API_KEY_STORAGE_KEY = "aomi_api_key";
+var ControlContext = createContext(null);
+function useControl() {
+  const ctx = useContext(ControlContext);
+  if (!ctx) {
+    throw new Error("useControl must be used within ControlContextProvider");
+  }
+  return ctx;
+}
+function ControlContextProvider({
+  children,
+  backendApi,
+  sessionId,
+  publicKey,
+  getThreadMetadata,
+  updateThreadMetadata
+}) {
+  var _a, _b;
+  const [state, setStateInternal] = useState(() => ({
+    apiKey: null,
+    availableModels: [],
+    authorizedNamespaces: [],
+    defaultModel: null,
+    defaultNamespace: null
+  }));
+  const stateRef = useRef(state);
+  stateRef.current = state;
+  const backendApiRef = useRef(backendApi);
+  backendApiRef.current = backendApi;
+  const sessionIdRef = useRef(sessionId);
+  sessionIdRef.current = sessionId;
+  const publicKeyRef = useRef(publicKey);
+  publicKeyRef.current = publicKey;
+  const getThreadMetadataRef = useRef(getThreadMetadata);
+  getThreadMetadataRef.current = getThreadMetadata;
+  const updateThreadMetadataRef = useRef(updateThreadMetadata);
+  updateThreadMetadataRef.current = updateThreadMetadata;
+  const callbacks = useRef(/* @__PURE__ */ new Set());
+  const currentThreadMetadata = getThreadMetadata(sessionId);
+  const isProcessing = (_b = (_a = currentThreadMetadata == null ? void 0 : currentThreadMetadata.control) == null ? void 0 : _a.isProcessing) != null ? _b : false;
+  useEffect(() => {
+    var _a2, _b2;
+    try {
+      const storedApiKey = (_b2 = (_a2 = globalThis.localStorage) == null ? void 0 : _a2.getItem(API_KEY_STORAGE_KEY)) != null ? _b2 : null;
+      if (storedApiKey) {
+        setStateInternal((prev) => __spreadProps(__spreadValues({}, prev), { apiKey: storedApiKey }));
+      }
+    } catch (e) {
+    }
+  }, []);
+  useEffect(() => {
+    var _a2, _b2;
+    try {
+      if (state.apiKey) {
+        (_a2 = globalThis.localStorage) == null ? void 0 : _a2.setItem(API_KEY_STORAGE_KEY, state.apiKey);
+      } else {
+        (_b2 = globalThis.localStorage) == null ? void 0 : _b2.removeItem(API_KEY_STORAGE_KEY);
+      }
+    } catch (e) {
+    }
+  }, [state.apiKey]);
+  useEffect(() => {
+    const fetchNamespaces = async () => {
+      var _a2, _b2;
+      try {
+        const namespaces = await backendApiRef.current.getNamespaces(
+          sessionIdRef.current,
+          publicKeyRef.current,
+          (_a2 = stateRef.current.apiKey) != null ? _a2 : void 0
+        );
+        const defaultNs = namespaces.includes("default") ? "default" : (_b2 = namespaces[0]) != null ? _b2 : null;
+        setStateInternal((prev) => __spreadProps(__spreadValues({}, prev), {
+          authorizedNamespaces: namespaces,
+          defaultNamespace: defaultNs
+        }));
+      } catch (error) {
+        console.error("Failed to fetch namespaces:", error);
+        setStateInternal((prev) => __spreadProps(__spreadValues({}, prev), {
+          authorizedNamespaces: ["default"],
+          defaultNamespace: "default"
+        }));
+      }
+    };
+    void fetchNamespaces();
+  }, [state.apiKey]);
+  useEffect(() => {
+    const fetchModels = async () => {
+      try {
+        const models = await backendApiRef.current.getModels(
+          sessionIdRef.current
+        );
+        setStateInternal((prev) => {
+          var _a2;
+          return __spreadProps(__spreadValues({}, prev), {
+            availableModels: models,
+            defaultModel: (_a2 = models[0]) != null ? _a2 : null
+          });
+        });
+      } catch (error) {
+        console.error("Failed to fetch models:", error);
+      }
+    };
+    void fetchModels();
+  }, []);
+  const setApiKey = useCallback((apiKey) => {
+    setStateInternal((prev) => {
+      const next = __spreadProps(__spreadValues({}, prev), { apiKey: apiKey === "" ? null : apiKey });
+      callbacks.current.forEach((cb) => cb(next));
+      return next;
+    });
+  }, []);
+  const getAvailableModels = useCallback(async () => {
+    try {
+      const models = await backendApiRef.current.getModels(
+        sessionIdRef.current
+      );
+      setStateInternal((prev) => {
+        var _a2, _b2;
+        return __spreadProps(__spreadValues({}, prev), {
+          availableModels: models,
+          defaultModel: (_b2 = (_a2 = prev.defaultModel) != null ? _a2 : models[0]) != null ? _b2 : null
+        });
+      });
+      return models;
+    } catch (error) {
+      console.error("Failed to fetch models:", error);
+      return [];
+    }
+  }, []);
+  const getAuthorizedNamespaces = useCallback(async () => {
+    var _a2, _b2;
+    try {
+      const namespaces = await backendApiRef.current.getNamespaces(
+        sessionIdRef.current,
+        publicKeyRef.current,
+        (_a2 = stateRef.current.apiKey) != null ? _a2 : void 0
+      );
+      const defaultNs = namespaces.includes("default") ? "default" : (_b2 = namespaces[0]) != null ? _b2 : null;
+      setStateInternal((prev) => __spreadProps(__spreadValues({}, prev), {
+        authorizedNamespaces: namespaces,
+        defaultNamespace: defaultNs
+      }));
+      return namespaces;
+    } catch (error) {
+      console.error("Failed to fetch namespaces:", error);
+      setStateInternal((prev) => __spreadProps(__spreadValues({}, prev), {
+        authorizedNamespaces: ["default"],
+        defaultNamespace: "default"
+      }));
+      return ["default"];
+    }
+  }, []);
+  const getCurrentThreadControl = useCallback(() => {
+    var _a2;
+    const metadata = getThreadMetadataRef.current(sessionIdRef.current);
+    return (_a2 = metadata == null ? void 0 : metadata.control) != null ? _a2 : initThreadControl();
+  }, []);
+  const onModelSelect = useCallback(async (model) => {
+    var _a2, _b2, _c, _d, _e;
+    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] onModelSelect called", {
+      model,
+      isProcessing: isProcessing2,
+      threadId
+    });
+    if (isProcessing2) {
+      console.warn("[control-context] Cannot switch model while processing");
+      return;
+    }
+    const namespace = (_d = (_c = currentControl.namespace) != null ? _c : stateRef.current.defaultNamespace) != null ? _d : "default";
+    console.log("[control-context] onModelSelect updating metadata", {
+      threadId,
+      model,
+      namespace,
+      currentControl
+    });
+    updateThreadMetadataRef.current(threadId, {
+      control: __spreadProps(__spreadValues({}, currentControl), {
+        model,
+        namespace,
+        controlDirty: true
+      })
+    });
+    console.log("[control-context] onModelSelect calling backend setModel", {
+      threadId,
+      model,
+      namespace,
+      backendUrl: backendApiRef.current
+    });
+    try {
+      const result = await backendApiRef.current.setModel(
+        threadId,
+        model,
+        namespace,
+        (_e = stateRef.current.apiKey) != null ? _e : void 0
+      );
+      console.log("[control-context] onModelSelect backend result", result);
+    } catch (err) {
+      console.error("[control-context] setModel failed:", err);
+      throw err;
+    }
+  }, []);
+  const onNamespaceSelect = useCallback((namespace) => {
+    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,
+      isProcessing: isProcessing2,
+      threadId
+    });
+    if (isProcessing2) {
+      console.warn(
+        "[control-context] Cannot switch namespace while processing"
+      );
+      return;
+    }
+    console.log("[control-context] onNamespaceSelect updating metadata", {
+      threadId,
+      namespace,
+      currentControl
+    });
+    updateThreadMetadataRef.current(threadId, {
+      control: __spreadProps(__spreadValues({}, currentControl), {
+        namespace,
+        controlDirty: true
+      })
+    });
+    console.log("[control-context] onNamespaceSelect metadata updated");
+  }, []);
+  const markControlSynced = useCallback(() => {
+    var _a2, _b2;
+    const threadId = sessionIdRef.current;
+    const currentControl = (_b2 = (_a2 = getThreadMetadataRef.current(threadId)) == null ? void 0 : _a2.control) != null ? _b2 : initThreadControl();
+    if (currentControl.controlDirty) {
+      updateThreadMetadataRef.current(threadId, {
+        control: __spreadProps(__spreadValues({}, currentControl), {
+          controlDirty: false
+        })
+      });
+    }
+  }, []);
+  const getControlState = useCallback(() => stateRef.current, []);
+  const onControlStateChange = useCallback(
+    (callback) => {
+      callbacks.current.add(callback);
+      return () => {
+        callbacks.current.delete(callback);
+      };
+    },
+    []
+  );
+  const setState = useCallback(
+    (updates) => {
+      var _a2;
+      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);
+      }
+    },
+    [setApiKey, onNamespaceSelect]
+  );
+  return /* @__PURE__ */ jsx(
+    ControlContext.Provider,
+    {
+      value: {
+        state,
+        setApiKey,
+        getAvailableModels,
+        getAuthorizedNamespaces,
+        getCurrentThreadControl,
+        onModelSelect,
+        onNamespaceSelect,
+        isProcessing,
+        markControlSynced,
+        getControlState,
+        onControlStateChange,
+        setState
+      },
+      children
+    }
+  );
+}
 
-// src/contexts/event-context.tsx
+// packages/react/src/contexts/event-context.tsx
 import {
-  createContext,
-  useCallback,
-  useContext,
-  useEffect,
-  useRef,
-  useState
+  createContext as createContext2,
+  useCallback as useCallback2,
+  useContext as useContext2,
+  useEffect as useEffect2,
+  useRef as useRef2,
+  useState as useState2
 } from "react";
 
-// src/backend/types.ts
+// packages/react/src/backend/types.ts
 function isInlineCall(event) {
   return "InlineCall" in event;
 }
@@ -411,7 +944,7 @@ function isAsyncCallback(event) {
   return "AsyncCallback" in event;
 }
 
-// src/state/event-buffer.ts
+// packages/react/src/state/event-buffer.ts
 function createEventBuffer() {
   return {
     inboundQueue: [],
@@ -455,11 +988,11 @@ function setSSEStatus(state, status) {
   state.sseStatus = status;
 }
 
-// src/contexts/event-context.tsx
-import { jsx } from "react/jsx-runtime";
-var EventContextState = createContext(null);
+// packages/react/src/contexts/event-context.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var EventContextState = createContext2(null);
 function useEventContext() {
-  const context = useContext(EventContextState);
+  const context = useContext2(EventContextState);
   if (!context) {
     throw new Error(
       "useEventContext must be used within EventContextProvider. Wrap your app with <EventContextProvider>...</EventContextProvider>"
@@ -472,13 +1005,13 @@ function EventContextProvider({
   backendApi,
   sessionId
 }) {
-  const bufferRef = useRef(null);
+  const bufferRef = useRef2(null);
   if (!bufferRef.current) {
     bufferRef.current = createEventBuffer();
   }
   const buffer = bufferRef.current;
-  const [sseStatus, setSseStatus] = useState("disconnected");
-  useEffect(() => {
+  const [sseStatus, setSseStatus] = useState2("disconnected");
+  useEffect2(() => {
     setSSEStatus(buffer, "connecting");
     setSseStatus("connecting");
     const unsubscribe = backendApi.subscribeSSE(
@@ -512,13 +1045,13 @@ function EventContextProvider({
       setSseStatus("disconnected");
     };
   }, [backendApi, sessionId, buffer]);
-  const subscribeCallback = useCallback(
+  const subscribeCallback = useCallback2(
     (type, callback) => {
       return subscribe(buffer, type, callback);
     },
     [buffer]
   );
-  const sendOutbound = useCallback(
+  const sendOutbound = useCallback2(
     async (event) => {
       try {
         const message = JSON.stringify({
@@ -532,7 +1065,7 @@ function EventContextProvider({
     },
     [backendApi]
   );
-  const dispatchSystemEvents = useCallback(
+  const dispatchSystemEvents = useCallback2(
     (sessionId2, events) => {
       var _a;
       for (const event of events) {
@@ -577,20 +1110,20 @@ function EventContextProvider({
     dispatchInboundSystem: dispatchSystemEvents,
     sseStatus
   };
-  return /* @__PURE__ */ jsx(EventContextState.Provider, { value: contextValue, children });
+  return /* @__PURE__ */ jsx2(EventContextState.Provider, { value: contextValue, children });
 }
 
-// src/contexts/notification-context.tsx
+// packages/react/src/contexts/notification-context.tsx
 import {
-  createContext as createContext2,
-  useCallback as useCallback2,
-  useContext as useContext2,
-  useState as useState2
+  createContext as createContext3,
+  useCallback as useCallback3,
+  useContext as useContext3,
+  useState as useState3
 } from "react";
-import { jsx as jsx2 } from "react/jsx-runtime";
-var NotificationContext = createContext2(null);
+import { jsx as jsx3 } from "react/jsx-runtime";
+var NotificationContext = createContext3(null);
 function useNotification() {
-  const context = useContext2(NotificationContext);
+  const context = useContext3(NotificationContext);
   if (!context) {
     throw new Error(
       "useNotification must be used within NotificationContextProvider"
@@ -605,8 +1138,8 @@ function generateId() {
 function NotificationContextProvider({
   children
 }) {
-  const [notifications, setNotifications] = useState2([]);
-  const showNotification = useCallback2((params) => {
+  const [notifications, setNotifications] = useState3([]);
+  const showNotification = useCallback3((params) => {
     const id = generateId();
     const notification = __spreadProps(__spreadValues({}, params), {
       id,
@@ -615,10 +1148,10 @@ function NotificationContextProvider({
     setNotifications((prev) => [notification, ...prev]);
     return id;
   }, []);
-  const dismissNotification = useCallback2((id) => {
+  const dismissNotification = useCallback3((id) => {
     setNotifications((prev) => prev.filter((n) => n.id !== id));
   }, []);
-  const clearAll = useCallback2(() => {
+  const clearAll = useCallback3(() => {
     setNotifications([]);
   }, []);
   const value = {
@@ -627,172 +1160,21 @@ function NotificationContextProvider({
     dismissNotification,
     clearAll
   };
-  return /* @__PURE__ */ jsx2(NotificationContext.Provider, { value, children });
+  return /* @__PURE__ */ jsx3(NotificationContext.Provider, { value, children });
 }
 
-// src/contexts/thread-context.tsx
+// packages/react/src/contexts/thread-context.tsx
 import {
-  createContext as createContext3,
-  useContext as useContext3,
+  createContext as createContext4,
+  useContext as useContext4,
   useMemo,
-  useRef as useRef2,
+  useRef as useRef3,
   useSyncExternalStore
 } from "react";
-
-// src/state/thread-store.ts
-var shouldLogThreadUpdates = process.env.NODE_ENV !== "production";
-var logThreadMetadataChange = (source, threadId, prev, next) => {
-  if (!shouldLogThreadUpdates) return;
-  if (!prev && !next) return;
-  if (!prev || !next) {
-    console.debug(`[aomi][thread:${source}]`, { threadId, prev, next });
-    return;
-  }
-  if (prev.title !== next.title || prev.status !== next.status || prev.lastActiveAt !== next.lastActiveAt) {
-    console.debug(`[aomi][thread:${source}]`, { threadId, prev, next });
-  }
-};
-var ThreadStore = class {
-  constructor(options) {
-    this.listeners = /* @__PURE__ */ new Set();
-    this.subscribe = (listener) => {
-      this.listeners.add(listener);
-      return () => {
-        this.listeners.delete(listener);
-      };
-    };
-    this.getSnapshot = () => this.snapshot;
-    this.setCurrentThreadId = (threadId) => {
-      this.ensureThreadExists(threadId);
-      this.updateState({ currentThreadId: threadId });
-    };
-    this.bumpThreadViewKey = () => {
-      this.updateState({ threadViewKey: this.state.threadViewKey + 1 });
-    };
-    this.setThreadCnt = (updater) => {
-      const nextCnt = this.resolveStateAction(updater, this.state.threadCnt);
-      this.updateState({ threadCnt: nextCnt });
-    };
-    this.setThreads = (updater) => {
-      const nextThreads = this.resolveStateAction(updater, this.state.threads);
-      this.updateState({ threads: new Map(nextThreads) });
-    };
-    this.setThreadMetadata = (updater) => {
-      const prevMetadata = this.state.threadMetadata;
-      const nextMetadata = this.resolveStateAction(updater, prevMetadata);
-      for (const [threadId, next] of nextMetadata.entries()) {
-        logThreadMetadataChange(
-          "setThreadMetadata",
-          threadId,
-          prevMetadata.get(threadId),
-          next
-        );
-      }
-      for (const [threadId, prev] of prevMetadata.entries()) {
-        if (!nextMetadata.has(threadId)) {
-          logThreadMetadataChange("setThreadMetadata", threadId, prev, void 0);
-        }
-      }
-      this.updateState({ threadMetadata: new Map(nextMetadata) });
-    };
-    this.setThreadMessages = (threadId, messages) => {
-      this.ensureThreadExists(threadId);
-      const nextThreads = new Map(this.state.threads);
-      nextThreads.set(threadId, messages);
-      this.updateState({ threads: nextThreads });
-    };
-    this.getThreadMessages = (threadId) => {
-      var _a;
-      return (_a = this.state.threads.get(threadId)) != null ? _a : [];
-    };
-    this.getThreadMetadata = (threadId) => {
-      return this.state.threadMetadata.get(threadId);
-    };
-    this.updateThreadMetadata = (threadId, updates) => {
-      const existing = this.state.threadMetadata.get(threadId);
-      if (!existing) {
-        return;
-      }
-      const next = __spreadValues(__spreadValues({}, existing), updates);
-      const nextMetadata = new Map(this.state.threadMetadata);
-      nextMetadata.set(threadId, next);
-      logThreadMetadataChange("updateThreadMetadata", threadId, existing, next);
-      this.updateState({ threadMetadata: nextMetadata });
-    };
-    var _a;
-    const initialThreadId = (_a = options == null ? void 0 : options.initialThreadId) != null ? _a : crypto.randomUUID();
-    this.state = {
-      currentThreadId: initialThreadId,
-      threadViewKey: 0,
-      threadCnt: 1,
-      threads: /* @__PURE__ */ new Map([[initialThreadId, []]]),
-      threadMetadata: /* @__PURE__ */ new Map([
-        [
-          initialThreadId,
-          {
-            title: "New Chat",
-            status: "pending",
-            lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
-          }
-        ]
-      ])
-    };
-    this.snapshot = this.buildSnapshot();
-  }
-  emit() {
-    for (const listener of this.listeners) {
-      listener();
-    }
-  }
-  resolveStateAction(updater, current) {
-    return typeof updater === "function" ? updater(current) : updater;
-  }
-  ensureThreadExists(threadId) {
-    if (!this.state.threadMetadata.has(threadId)) {
-      const nextMetadata = new Map(this.state.threadMetadata);
-      nextMetadata.set(threadId, {
-        title: "New Chat",
-        status: "regular",
-        lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      this.state = __spreadProps(__spreadValues({}, this.state), { threadMetadata: nextMetadata });
-    }
-    if (!this.state.threads.has(threadId)) {
-      const nextThreads = new Map(this.state.threads);
-      nextThreads.set(threadId, []);
-      this.state = __spreadProps(__spreadValues({}, this.state), { threads: nextThreads });
-    }
-  }
-  updateState(partial) {
-    this.state = __spreadValues(__spreadValues({}, this.state), partial);
-    this.snapshot = this.buildSnapshot();
-    this.emit();
-  }
-  buildSnapshot() {
-    return {
-      currentThreadId: this.state.currentThreadId,
-      setCurrentThreadId: this.setCurrentThreadId,
-      threadViewKey: this.state.threadViewKey,
-      bumpThreadViewKey: this.bumpThreadViewKey,
-      allThreads: this.state.threads,
-      setThreads: this.setThreads,
-      allThreadsMetadata: this.state.threadMetadata,
-      setThreadMetadata: this.setThreadMetadata,
-      threadCnt: this.state.threadCnt,
-      setThreadCnt: this.setThreadCnt,
-      getThreadMessages: this.getThreadMessages,
-      setThreadMessages: this.setThreadMessages,
-      getThreadMetadata: this.getThreadMetadata,
-      updateThreadMetadata: this.updateThreadMetadata
-    };
-  }
-};
-
-// src/contexts/thread-context.tsx
-import { jsx as jsx3 } from "react/jsx-runtime";
-var ThreadContextState = createContext3(null);
+import { jsx as jsx4 } from "react/jsx-runtime";
+var ThreadContextState = createContext4(null);
 function useThreadContext() {
-  const context = useContext3(ThreadContextState);
+  const context = useContext4(ThreadContextState);
   if (!context) {
     throw new Error(
       "useThreadContext must be used within ThreadContextProvider. Wrap your app with <ThreadContextProvider>...</ThreadContextProvider>"
@@ -804,7 +1186,7 @@ function ThreadContextProvider({
   children,
   initialThreadId
 }) {
-  const storeRef = useRef2(null);
+  const storeRef = useRef3(null);
   if (!storeRef.current) {
     storeRef.current = new ThreadStore({ initialThreadId });
   }
@@ -814,7 +1196,7 @@ function ThreadContextProvider({
     store.getSnapshot,
     store.getSnapshot
   );
-  return /* @__PURE__ */ jsx3(ThreadContextState.Provider, { value, children });
+  return /* @__PURE__ */ jsx4(ThreadContextState.Provider, { value, children });
 }
 function useCurrentThreadMessages() {
   const { currentThreadId, getThreadMessages } = useThreadContext();
@@ -831,18 +1213,18 @@ function useCurrentThreadMetadata() {
   );
 }
 
-// src/contexts/user-context.tsx
+// packages/react/src/contexts/user-context.tsx
 import {
-  createContext as createContext4,
-  useCallback as useCallback3,
-  useContext as useContext4,
-  useRef as useRef3,
-  useState as useState3
+  createContext as createContext5,
+  useCallback as useCallback4,
+  useContext as useContext5,
+  useRef as useRef4,
+  useState as useState4
 } from "react";
-import { jsx as jsx4 } from "react/jsx-runtime";
-var UserContext = createContext4(void 0);
+import { jsx as jsx5 } from "react/jsx-runtime";
+var UserContext = createContext5(void 0);
 function useUser() {
-  const context = useContext4(UserContext);
+  const context = useContext5(UserContext);
   if (!context) {
     throw new Error("useUser must be used within UserContextProvider");
   }
@@ -854,18 +1236,18 @@ function useUser() {
   };
 }
 function UserContextProvider({ children }) {
-  const [user, setUserState] = useState3({
+  const [user, setUserState] = useState4({
     isConnected: false,
     address: void 0,
     chainId: void 0,
     ensName: void 0
   });
-  const userRef = useRef3(user);
+  const userRef = useRef4(user);
   userRef.current = user;
-  const StateChangeCallbacks = useRef3(
+  const StateChangeCallbacks = useRef4(
     /* @__PURE__ */ new Set()
   );
-  const setUser = useCallback3((data) => {
+  const setUser = useCallback4((data) => {
     setUserState((prev) => {
       const next = __spreadValues(__spreadValues({}, prev), data);
       StateChangeCallbacks.current.forEach((callback) => {
@@ -874,8 +1256,8 @@ function UserContextProvider({ children }) {
       return next;
     });
   }, []);
-  const getUserState = useCallback3(() => userRef.current, []);
-  const onUserStateChange = useCallback3(
+  const getUserState = useCallback4(() => userRef.current, []);
+  const onUserStateChange = useCallback4(
     (callback) => {
       StateChangeCallbacks.current.add(callback);
       return () => {
@@ -884,7 +1266,7 @@ function UserContextProvider({ children }) {
     },
     []
   );
-  return /* @__PURE__ */ jsx4(
+  return /* @__PURE__ */ jsx5(
     UserContext.Provider,
     {
       value: {
@@ -898,17 +1280,17 @@ function UserContextProvider({ children }) {
   );
 }
 
-// src/runtime/core.tsx
-import { useCallback as useCallback5, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef5 } from "react";
+// packages/react/src/runtime/core.tsx
+import { useCallback as useCallback6, useEffect as useEffect3, useMemo as useMemo2, useRef as useRef6 } from "react";
 import {
   AssistantRuntimeProvider,
   useExternalStoreRuntime
 } from "@assistant-ui/react";
 
-// src/runtime/orchestrator.ts
-import { useCallback as useCallback4, useRef as useRef4, useState as useState4 } from "react";
+// packages/react/src/runtime/orchestrator.ts
+import { useCallback as useCallback5, useRef as useRef5, useState as useState5 } from "react";
 
-// src/runtime/utils.ts
+// packages/react/src/runtime/utils.ts
 import { clsx } from "clsx";
 import { twMerge } from "tailwind-merge";
 function cn(...inputs) {
@@ -1001,7 +1383,7 @@ var getNetworkName = (chainId) => {
 };
 var formatAddress = (addr) => addr ? `${addr.slice(0, 6)}...${addr.slice(-4)}` : "Connect Wallet";
 
-// src/state/backend-state.ts
+// packages/react/src/state/backend-state.ts
 function createBackendState() {
   return {
     skipInitialFetch: /* @__PURE__ */ new Set(),
@@ -1052,7 +1434,7 @@ function hasPendingChat(state, threadId) {
   return ((_b = (_a = state.pendingChat.get(threadId)) == null ? void 0 : _a.length) != null ? _b : 0) > 0;
 }
 
-// src/runtime/message-controller.ts
+// packages/react/src/runtime/message-controller.ts
 var MessageController = class {
   constructor(config) {
     this.config = config;
@@ -1073,7 +1455,7 @@ var MessageController = class {
     this.getThreadContextApi().setThreadMessages(threadId, threadMessages);
   }
   async outbound(message, threadId) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e, _f;
     const backendState = this.config.backendStateRef.current;
     const text = message.content.filter(
       (part) => part.type === "text"
@@ -1098,21 +1480,22 @@ var MessageController = class {
       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;
     try {
       this.markRunning(threadId, true);
-      const response = publicKey ? await this.config.backendApiRef.current.postChatMessage(
+      const response = await this.config.backendApiRef.current.postChatMessage(
         backendThreadId,
         text,
-        publicKey
-      ) : await this.config.backendApiRef.current.postChatMessage(
-        backendThreadId,
-        text
+        namespace,
+        publicKey,
+        apiKey
       );
       if (response == null ? void 0 : response.messages) {
         this.inbound(threadId, response.messages);
       }
-      if (((_c = response == null ? void 0 : response.system_events) == null ? void 0 : _c.length) && this.config.onSyncEvents) {
+      if (((_f = response == null ? void 0 : response.system_events) == null ? void 0 : _f.length) && this.config.onSyncEvents) {
         this.config.onSyncEvents(backendThreadId, response.system_events);
       }
       if (response == null ? void 0 : response.is_processing) {
@@ -1126,26 +1509,23 @@ var MessageController = class {
     }
   }
   async flushPendingChat(threadId) {
-    var _a, _b;
+    var _a, _b, _c, _d, _e;
     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;
     for (const text of pending) {
       try {
-        if (publicKey) {
-          await this.config.backendApiRef.current.postChatMessage(
-            backendThreadId,
-            text,
-            publicKey
-          );
-        } else {
-          await this.config.backendApiRef.current.postChatMessage(
-            backendThreadId,
-            text
-          );
-        }
+        await this.config.backendApiRef.current.postChatMessage(
+          backendThreadId,
+          text,
+          namespace,
+          publicKey,
+          apiKey
+        );
       } catch (error) {
         console.error("Failed to send queued message:", error);
       }
@@ -1184,7 +1564,7 @@ var MessageController = class {
   }
 };
 
-// src/runtime/polling-controller.ts
+// packages/react/src/runtime/polling-controller.ts
 var PollingController = class {
   constructor(config) {
     this.config = config;
@@ -1255,18 +1635,18 @@ var PollingController = class {
   }
 };
 
-// src/runtime/orchestrator.ts
+// packages/react/src/runtime/orchestrator.ts
 function useRuntimeOrchestrator(backendApi, options) {
   const threadContext = useThreadContext();
-  const threadContextRef = useRef4(threadContext);
+  const threadContextRef = useRef5(threadContext);
   threadContextRef.current = threadContext;
-  const backendApiRef = useRef4(backendApi);
+  const backendApiRef = useRef5(backendApi);
   backendApiRef.current = backendApi;
-  const backendStateRef = useRef4(createBackendState());
-  const [isRunning, setIsRunning] = useState4(false);
-  const messageControllerRef = useRef4(null);
-  const pollingRef = useRef4(null);
-  const pendingFetches = useRef4(/* @__PURE__ */ new Set());
+  const backendStateRef = useRef5(createBackendState());
+  const [isRunning, setIsRunning] = useState5(false);
+  const messageControllerRef = useRef5(null);
+  const pollingRef = useRef5(null);
+  const pendingFetches = useRef5(/* @__PURE__ */ new Set());
   if (!pollingRef.current) {
     pollingRef.current = new PollingController({
       backendApiRef,
@@ -1275,8 +1655,8 @@ function useRuntimeOrchestrator(backendApi, options) {
         var _a;
         (_a = messageControllerRef.current) == null ? void 0 : _a.inbound(threadId, msgs);
       },
-      onSyncEvents: options == null ? void 0 : options.onSyncEvents,
-      getUserState: options == null ? void 0 : options.getUserState,
+      onSyncEvents: options.onSyncEvents,
+      getUserState: options.getUserState,
       onStart: (threadId) => {
         if (threadContextRef.current.currentThreadId === threadId) {
           setIsRunning(true);
@@ -1296,11 +1676,13 @@ function useRuntimeOrchestrator(backendApi, options) {
       threadContextRef,
       polling: pollingRef.current,
       setGlobalIsRunning: setIsRunning,
-      getPublicKey: options == null ? void 0 : options.getPublicKey,
-      onSyncEvents: options == null ? void 0 : options.onSyncEvents
+      getPublicKey: options.getPublicKey,
+      getNamespace: options.getNamespace,
+      getApiKey: options.getApiKey,
+      onSyncEvents: options.onSyncEvents
     });
   }
-  const ensureInitialState = useCallback4(async (threadId) => {
+  const ensureInitialState = useCallback5(async (threadId) => {
     var _a, _b, _c, _d;
     const backendState = backendStateRef.current;
     if (shouldSkipInitialFetch(backendState, threadId)) {
@@ -1320,13 +1702,13 @@ function useRuntimeOrchestrator(backendApi, options) {
     const backendThreadId = resolveThreadId(backendState, threadId);
     pendingFetches.current.add(threadId);
     try {
-      const userState = (_a = options == null ? void 0 : options.getUserState) == null ? void 0 : _a.call(options);
+      const userState = (_a = options.getUserState) == null ? void 0 : _a.call(options);
       const state = await backendApiRef.current.fetchState(
         backendThreadId,
         userState
       );
       (_b = messageControllerRef.current) == null ? void 0 : _b.inbound(threadId, state.messages);
-      if (((_c = state.system_events) == null ? void 0 : _c.length) && (options == null ? void 0 : options.onSyncEvents)) {
+      if (((_c = state.system_events) == null ? void 0 : _c.length) && options.onSyncEvents) {
         options.onSyncEvents(backendThreadId, state.system_events);
       }
       if (threadContextRef.current.currentThreadId === threadId) {
@@ -1357,7 +1739,7 @@ function useRuntimeOrchestrator(backendApi, options) {
   };
 }
 
-// src/runtime/threadlist-adapter.ts
+// packages/react/src/runtime/threadlist-adapter.ts
 var sortByLastActiveDesc = ([, metaA], [, metaB]) => {
   const tsA = parseTimestamp(metaA.lastActiveAt);
   const tsB = parseTimestamp(metaB.lastActiveAt);
@@ -1390,7 +1772,9 @@ function buildThreadListAdapter({
   currentThreadIdRef,
   polling,
   userAddress,
-  setIsRunning
+  setIsRunning,
+  getNamespace,
+  getApiKey
 }) {
   const backendState = backendStateRef.current;
   const { regularThreads, archivedThreads } = buildThreadLists(
@@ -1418,7 +1802,8 @@ function buildThreadListAdapter({
       (prev) => new Map(prev).set(threadId, {
         title: "New Chat",
         status: "pending",
-        lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
+        lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
+        control: initThreadControl()
       })
     );
     threadContext.setThreadMessages(threadId, []);
@@ -1445,15 +1830,13 @@ function buildThreadListAdapter({
         return;
       }
       if (backendState.createThreadPromise) {
-        preparePendingThread(
-          (_a = backendState.creatingThreadId) != null ? _a : crypto.randomUUID()
-        );
+        preparePendingThread((_a = backendState.creatingThreadId) != null ? _a : generateUUID());
         return;
       }
-      const threadId = crypto.randomUUID();
+      const threadId = generateUUID();
       preparePendingThread(threadId);
       const createPromise = backendApiRef.current.createThread(threadId, userAddress).then(async (newThread) => {
-        var _a2;
+        var _a2, _b;
         const uiThreadId = (_a2 = backendState.creatingThreadId) != null ? _a2 : threadId;
         const backendId = newThread.session_id;
         if (uiThreadId !== backendId) {
@@ -1464,14 +1847,15 @@ function buildThreadListAdapter({
         }
         markSkipInitialFetch(backendState, uiThreadId);
         threadContext.setThreadMetadata((prev) => {
-          var _a3, _b;
+          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: (_b = existing == null ? void 0 : existing.lastActiveAt) != null ? _b : (/* @__PURE__ */ new Date()).toISOString()
+            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;
         });
@@ -1481,9 +1865,17 @@ function buildThreadListAdapter({
         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;
           for (const text of pendingMessages) {
             try {
-              await backendApiRef.current.postChatMessage(backendId, text);
+              await backendApiRef.current.postChatMessage(
+                backendId,
+                text,
+                namespace,
+                userAddress,
+                apiKey
+              );
             } catch (error) {
               console.error("Failed to send queued message:", error);
             }
@@ -1582,7 +1974,8 @@ function buildThreadListAdapter({
               (prev) => new Map(prev).set(defaultId, {
                 title: "New Chat",
                 status: "regular",
-                lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
+                lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
+                control: initThreadControl()
               })
             );
             threadContext.setThreadMessages(defaultId, []);
@@ -1597,12 +1990,12 @@ function buildThreadListAdapter({
   };
 }
 
-// src/interface.tsx
-import { createContext as createContext5, useContext as useContext5 } from "react";
-var AomiRuntimeContext = createContext5(null);
+// packages/react/src/interface.tsx
+import { createContext as createContext6, useContext as useContext6 } from "react";
+var AomiRuntimeContext = createContext6(null);
 var AomiRuntimeApiProvider = AomiRuntimeContext.Provider;
 function useAomiRuntime() {
-  const context = useContext5(AomiRuntimeContext);
+  const context = useContext6(AomiRuntimeContext);
   if (!context) {
     throw new Error(
       "useAomiRuntime must be used within AomiRuntimeProvider. Wrap your app with <AomiRuntimeProvider>...</AomiRuntimeProvider>"
@@ -1611,8 +2004,8 @@ function useAomiRuntime() {
   return context;
 }
 
-// src/runtime/core.tsx
-import { jsx as jsx5 } from "react/jsx-runtime";
+// packages/react/src/runtime/core.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
 function AomiRuntimeCore({
   children,
   backendApi
@@ -1622,6 +2015,7 @@ function AomiRuntimeCore({
   const notificationContext = useNotification();
   const { dispatchInboundSystem: dispatchSystemEvents } = eventContext;
   const { user, onUserStateChange, getUserState } = useUser();
+  const { getControlState, getCurrentThreadControl } = useControl();
   const {
     backendStateRef,
     polling,
@@ -1633,9 +2027,14 @@ function AomiRuntimeCore({
   } = useRuntimeOrchestrator(backendApi, {
     onSyncEvents: dispatchSystemEvents,
     getPublicKey: () => getUserState().address,
-    getUserState
+    getUserState,
+    getNamespace: () => {
+      var _a, _b;
+      return (_b = (_a = getCurrentThreadControl().namespace) != null ? _a : getControlState().defaultNamespace) != null ? _b : "default";
+    },
+    getApiKey: () => getControlState().apiKey
   });
-  useEffect2(() => {
+  useEffect3(() => {
     const unsubscribe = onUserStateChange(async (newUser) => {
       const sessionId = threadContext.currentThreadId;
       const message = JSON.stringify({
@@ -1651,19 +2050,30 @@ function AomiRuntimeCore({
     });
     return unsubscribe;
   }, [onUserStateChange, backendApiRef, threadContext.currentThreadId]);
-  const threadContextRef = useRef5(threadContext);
+  const threadContextRef = useRef6(threadContext);
   threadContextRef.current = threadContext;
-  const currentThreadIdRef = useRef5(threadContext.currentThreadId);
-  useEffect2(() => {
+  const currentThreadIdRef = useRef6(threadContext.currentThreadId);
+  useEffect3(() => {
     currentThreadIdRef.current = threadContext.currentThreadId;
   }, [threadContext.currentThreadId]);
-  useEffect2(() => {
+  useEffect3(() => {
     void ensureInitialState(threadContext.currentThreadId);
   }, [ensureInitialState, threadContext.currentThreadId]);
-  useEffect2(() => {
+  useEffect3(() => {
     const threadId = threadContext.currentThreadId;
     setIsRunning(isThreadRunning(backendStateRef.current, threadId));
   }, [backendStateRef, setIsRunning, threadContext.currentThreadId]);
+  useEffect3(() => {
+    const threadId = threadContext.currentThreadId;
+    const currentMeta = threadContext.getThreadMetadata(threadId);
+    if (currentMeta && currentMeta.control.isProcessing !== isRunning) {
+      threadContext.updateThreadMetadata(threadId, {
+        control: __spreadProps(__spreadValues({}, currentMeta.control), {
+          isProcessing: isRunning
+        })
+      });
+    }
+  }, [isRunning, threadContext]);
   const currentMessages = threadContext.getThreadMessages(
     threadContext.currentThreadId
   );
@@ -1675,11 +2085,11 @@ function AomiRuntimeCore({
       threadContext.allThreadsMetadata
     ]
   );
-  useEffect2(() => {
+  useEffect3(() => {
     const userAddress = user.address;
     if (!userAddress) return;
     const fetchThreadList = async () => {
-      var _a, _b;
+      var _a, _b, _c;
       try {
         const threadList = await backendApiRef.current.fetchThreads(userAddress);
         const currentContext = threadContextRef.current;
@@ -1689,10 +2099,12 @@ function AomiRuntimeCore({
           const rawTitle = (_a = thread.title) != null ? _a : "";
           const title = isPlaceholderTitle(rawTitle) ? "" : rawTitle;
           const lastActive = ((_b = newMetadata.get(thread.session_id)) == null ? void 0 : _b.lastActiveAt) || (/* @__PURE__ */ new Date()).toISOString();
+          const existingControl = (_c = newMetadata.get(thread.session_id)) == null ? void 0 : _c.control;
           newMetadata.set(thread.session_id, {
             title,
             status: thread.is_archived ? "archived" : "regular",
-            lastActiveAt: lastActive
+            lastActiveAt: lastActive,
+            control: existingControl != null ? existingControl : initThreadControl()
           });
           const match = title.match(/^Chat (\d+)$/);
           if (match) {
@@ -1720,7 +2132,12 @@ function AomiRuntimeCore({
       currentThreadIdRef,
       polling,
       userAddress: user.address,
-      setIsRunning
+      setIsRunning,
+      getNamespace: () => {
+        var _a, _b;
+        return (_b = (_a = getCurrentThreadControl().namespace) != null ? _a : getControlState().defaultNamespace) != null ? _b : "default";
+      },
+      getApiKey: () => getControlState().apiKey
     }),
     [
       backendApiRef,
@@ -1730,10 +2147,11 @@ function AomiRuntimeCore({
       setIsRunning,
       threadContext,
       threadContext.currentThreadId,
-      threadContext.allThreadsMetadata
+      threadContext.allThreadsMetadata,
+      getControlState
     ]
   );
-  useEffect2(() => {
+  useEffect3(() => {
     const backendState = backendStateRef.current;
     const currentSessionId = threadContext.currentThreadId;
     if (process.env.NODE_ENV !== "production") {
@@ -1764,14 +2182,15 @@ function AomiRuntimeCore({
             });
           }
           threadContextRef.current.setThreadMetadata((prev) => {
-            var _a;
+            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()
+              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;
           });
@@ -1790,12 +2209,12 @@ function AomiRuntimeCore({
     threadContext.currentThreadId,
     resolvedSessionId
   ]);
-  useEffect2(() => {
+  useEffect3(() => {
     const threadId = threadContext.currentThreadId;
     if (!isThreadReady(backendStateRef.current, threadId)) return;
     void messageController.flushPendingChat(threadId);
   }, [messageController, backendStateRef, threadContext.currentThreadId]);
-  useEffect2(() => {
+  useEffect3(() => {
     const showToolNotification = (eventType) => (event) => {
       const payload = event.payload;
       const toolName = typeof (payload == null ? void 0 : payload.tool_name) === "string" ? payload.tool_name : void 0;
@@ -1820,15 +2239,10 @@ function AomiRuntimeCore({
       unsubscribeComplete();
     };
   }, [eventContext, notificationContext]);
-  useEffect2(() => {
+  useEffect3(() => {
     const unsubscribe = eventContext.subscribe("system_notice", (event) => {
       const payload = event.payload;
       const message = payload == null ? void 0 : payload.message;
-      notificationContext.showNotification({
-        type: "notice",
-        title: "System notice",
-        message
-      });
     });
     return unsubscribe;
   }, [eventContext, notificationContext]);
@@ -1841,13 +2255,13 @@ function AomiRuntimeCore({
     convertMessage: (msg) => msg,
     adapters: { threadList: threadListAdapter }
   });
-  useEffect2(() => {
+  useEffect3(() => {
     return () => {
       polling.stopAll();
     };
   }, [polling]);
   const userContext = useUser();
-  const sendMessage = useCallback5(
+  const sendMessage = useCallback6(
     async (text) => {
       const appendMessage = {
         role: "user",
@@ -1860,39 +2274,39 @@ function AomiRuntimeCore({
     },
     [messageController, threadContext.currentThreadId]
   );
-  const cancelGeneration = useCallback5(() => {
+  const cancelGeneration = useCallback6(() => {
     messageController.cancel(threadContext.currentThreadId);
   }, [messageController, threadContext.currentThreadId]);
-  const getMessages = useCallback5(
+  const getMessages = useCallback6(
     (threadId) => {
       const id = threadId != null ? threadId : threadContext.currentThreadId;
       return threadContext.getThreadMessages(id);
     },
     [threadContext]
   );
-  const createThread = useCallback5(async () => {
+  const createThread = useCallback6(async () => {
     await threadListAdapter.onSwitchToNewThread();
     return threadContextRef.current.currentThreadId;
   }, [threadListAdapter]);
-  const deleteThread = useCallback5(
+  const deleteThread = useCallback6(
     async (threadId) => {
       await threadListAdapter.onDelete(threadId);
     },
     [threadListAdapter]
   );
-  const renameThread = useCallback5(
+  const renameThread = useCallback6(
     async (threadId, title) => {
       await threadListAdapter.onRename(threadId, title);
     },
     [threadListAdapter]
   );
-  const archiveThread = useCallback5(
+  const archiveThread = useCallback6(
     async (threadId) => {
       await threadListAdapter.onArchive(threadId);
     },
     [threadListAdapter]
   );
-  const selectThread = useCallback5(
+  const selectThread = useCallback6(
     (threadId) => {
       if (threadContext.allThreadsMetadata.has(threadId)) {
         threadListAdapter.onSwitchToThread(threadId);
@@ -1953,45 +2367,57 @@ function AomiRuntimeCore({
       eventContext
     ]
   );
-  return /* @__PURE__ */ jsx5(AomiRuntimeApiProvider, { value: aomiRuntimeApi, children: /* @__PURE__ */ jsx5(AssistantRuntimeProvider, { runtime, children }) });
+  return /* @__PURE__ */ jsx6(AomiRuntimeApiProvider, { value: aomiRuntimeApi, children: /* @__PURE__ */ jsx6(AssistantRuntimeProvider, { runtime, children }) });
 }
 
-// src/runtime/aomi-runtime.tsx
-import { jsx as jsx6 } from "react/jsx-runtime";
+// packages/react/src/runtime/aomi-runtime.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
 function AomiRuntimeProvider({
   children,
   backendUrl = "http://localhost:8080"
 }) {
   const backendApi = useMemo3(() => new BackendApi(backendUrl), [backendUrl]);
-  return /* @__PURE__ */ jsx6(ThreadContextProvider, { children: /* @__PURE__ */ jsx6(NotificationContextProvider, { children: /* @__PURE__ */ jsx6(UserContextProvider, { children: /* @__PURE__ */ jsx6(AomiRuntimeInner, { backendApi, children }) }) }) });
+  return /* @__PURE__ */ jsx7(ThreadContextProvider, { children: /* @__PURE__ */ jsx7(NotificationContextProvider, { children: /* @__PURE__ */ jsx7(UserContextProvider, { children: /* @__PURE__ */ jsx7(AomiRuntimeInner, { backendApi, children }) }) }) });
 }
 function AomiRuntimeInner({
   children,
   backendApi
 }) {
+  var _a;
   const threadContext = useThreadContext();
-  return /* @__PURE__ */ jsx6(
-    EventContextProvider,
+  const { user } = useUser();
+  return /* @__PURE__ */ jsx7(
+    ControlContextProvider,
     {
       backendApi,
       sessionId: threadContext.currentThreadId,
-      children: /* @__PURE__ */ jsx6(AomiRuntimeCore, { backendApi, children })
+      publicKey: (_a = user.address) != null ? _a : void 0,
+      getThreadMetadata: threadContext.getThreadMetadata,
+      updateThreadMetadata: threadContext.updateThreadMetadata,
+      children: /* @__PURE__ */ jsx7(
+        EventContextProvider,
+        {
+          backendApi,
+          sessionId: threadContext.currentThreadId,
+          children: /* @__PURE__ */ jsx7(AomiRuntimeCore, { backendApi, children })
+        }
+      )
     }
   );
 }
 
-// src/handlers/wallet-handler.ts
-import { useCallback as useCallback6, useEffect as useEffect3, useState as useState5 } from "react";
+// 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] = useState5(
+  const [pendingTxRequests, setPendingTxRequests] = useState6(
     []
   );
-  useEffect3(() => {
+  useEffect4(() => {
     const unsubscribe = subscribe2(
       "wallet_tx_request",
       (event) => {
@@ -2002,7 +2428,7 @@ function useWalletHandler({
     );
     return unsubscribe;
   }, [subscribe2, onTxRequest]);
-  useEffect3(() => {
+  useEffect4(() => {
     const unsubscribe = subscribe2(
       "user_state_request",
       (event) => {
@@ -2015,7 +2441,7 @@ function useWalletHandler({
     );
     return unsubscribe;
   }, [subscribe2, onTxRequest]);
-  const sendTxComplete = useCallback6(
+  const sendTxComplete = useCallback7(
     (tx) => {
       sendOutbound({
         type: "wallet:tx_complete",
@@ -2025,7 +2451,7 @@ function useWalletHandler({
     },
     [sendOutbound, sessionId]
   );
-  const sendConnectionChange = useCallback6(
+  const sendConnectionChange = useCallback7(
     (status, address, chainId) => {
       if (status === "connected") {
         setUser({
@@ -2048,7 +2474,7 @@ function useWalletHandler({
     },
     [setUser, sendOutbound, sessionId]
   );
-  const clearTxRequest = useCallback6((index) => {
+  const clearTxRequest = useCallback7((index) => {
     setPendingTxRequests((prev) => prev.filter((_, i) => i !== index));
   }, []);
   return {
@@ -2059,8 +2485,8 @@ function useWalletHandler({
   };
 }
 
-// src/handlers/notification-handler.ts
-import { useCallback as useCallback7, useEffect as useEffect4, useState as useState6 } from "react";
+// packages/react/src/handlers/notification-handler.ts
+import { useCallback as useCallback8, useEffect as useEffect5, useState as useState7 } from "react";
 var notificationIdCounter2 = 0;
 function generateNotificationId() {
   return `notif-${Date.now()}-${++notificationIdCounter2}`;
@@ -2069,8 +2495,8 @@ function useNotificationHandler({
   onNotification
 } = {}) {
   const { subscribe: subscribe2 } = useEventContext();
-  const [notifications, setNotifications] = useState6([]);
-  useEffect4(() => {
+  const [notifications, setNotifications] = useState7([]);
+  useEffect5(() => {
     const unsubscribe = subscribe2("notification", (event) => {
       var _a, _b;
       const payload = event.payload;
@@ -2089,7 +2515,7 @@ function useNotificationHandler({
     return unsubscribe;
   }, [subscribe2, onNotification]);
   const unhandledCount = notifications.filter((n) => !n.handled).length;
-  const markHandled = useCallback7((id) => {
+  const markHandled = useCallback8((id) => {
     setNotifications(
       (prev) => prev.map((n) => n.id === id ? __spreadProps(__spreadValues({}, n), { handled: true }) : n)
     );
@@ -2103,6 +2529,7 @@ function useNotificationHandler({
 export {
   AomiRuntimeProvider,
   BackendApi,
+  ControlContextProvider,
   EventContextProvider,
   NotificationContextProvider,
   ThreadContextProvider,
@@ -2110,7 +2537,9 @@ export {
   cn,
   formatAddress,
   getNetworkName,
+  initThreadControl,
   useAomiRuntime,
+  useControl,
   useCurrentThreadMessages,
   useCurrentThreadMetadata,
   useEventContext,