@athenaintel/react 0.10.3 → 0.10.5

package/dist/index.d.ts

@@ -486,6 +486,27 @@ export declare interface AthenaTheme {
     threadMaxWidth?: string;
 }
 
+/**
+ * Public hook for managing thread state and navigation.
+ *
+ * Wraps the underlying runtime to provide a clean, Athena-branded API
+ * for reading the active thread, listing threads, and switching between them.
+ *
+ * Must be used inside `<AthenaProvider enableThreadList>`.
+ */
+export declare interface AthenaThreadManagerState {
+    /** The ID of the currently active thread, or null if not yet available. */
+    activeThreadId: string | null;
+    /** All available (non-archived) thread IDs, sorted by most recent. */
+    threadIds: readonly string[];
+    /** Whether the thread list is still loading from the backend. */
+    isLoading: boolean;
+    /** Switch the chat to a different thread by ID. */
+    switchToThread: (threadId: string) => Promise<void>;
+    /** Create and switch to a new empty thread. */
+    switchToNewThread: () => Promise<void>;
+}
+
 /**
  * Athena user information — a simplified, PropelAuth-agnostic representation.
  */
@@ -1171,6 +1192,29 @@ export declare const useAthenaLinkClickHandler: () => AthenaLinkClickHandler;
 
 export declare const useAthenaRuntime: (config: AthenaRuntimeConfig) => AssistantRuntime;
 
+/**
+ * Hook for managing thread navigation.
+ *
+ * Returns `null` when called outside `<AthenaProvider enableThreadList>`
+ * or before the runtime has initialized.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const threads = useAthenaThreadManager();
+ *   if (!threads) return null;
+ *
+ *   return (
+ *     <div>
+ *       <p>Active: {threads.activeThreadId}</p>
+ *       <button onClick={() => threads.switchToNewThread()}>New Chat</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useAthenaThreadManager(): AthenaThreadManagerState | null;
+
 /**
  * Hook for programmatic composer file attachment control.
  *

package/dist/index.js

@@ -1360,8 +1360,8 @@ const createStoreImpl = (createState) => {
   return api;
 };
 const createStore = ((createState) => createState ? createStoreImpl(createState) : createStoreImpl);
-const identity = (arg) => arg;
-function useStore$1(api, selector = identity) {
+const identity$1 = (arg) => arg;
+function useStore$1(api, selector = identity$1) {
   const slice2 = React__default.useSyncExternalStore(
     api.subscribe,
     React__default.useCallback(() => selector(api.getState()), [api, selector]),
@@ -9571,6 +9571,72 @@ const AssistantRuntimeProviderImpl = ({ children, aui, runtime }) => {
   return jsxs(AssistantProviderBase, { runtime, aui: aui ?? null, children: [jsx(DevToolsRegistration, {}), jsx(ThreadPrimitiveViewportProvider, { children })] });
 };
 const AssistantRuntimeProvider = memo(AssistantRuntimeProviderImpl);
+const debugVerifyPrototype = (runtime, prototype) => {
+  const unboundMethods = Object.getOwnPropertyNames(prototype).filter((methodStr) => {
+    const descriptor = Object.getOwnPropertyDescriptor(prototype, methodStr);
+    const isMethod = descriptor && typeof descriptor.value === "function";
+    if (!isMethod)
+      return false;
+    const methodName = methodStr;
+    return isMethod && !methodName.startsWith("_") && methodName !== "constructor" && prototype[methodName] === runtime[methodName];
+  });
+  if (unboundMethods.length > 0) {
+    throw new Error(`The following methods are not bound: ${JSON.stringify(unboundMethods)}`);
+  }
+  const prototypePrototype = Object.getPrototypeOf(prototype);
+  if (prototypePrototype && prototypePrototype !== Object.prototype) {
+    debugVerifyPrototype(runtime, prototypePrototype);
+  }
+};
+const ensureBinding = (r2) => {
+  var _a2;
+  const runtime = r2;
+  if (runtime.__isBound)
+    return;
+  (_a2 = runtime.__internal_bindMethods) == null ? void 0 : _a2.call(runtime);
+  runtime.__isBound = true;
+  if (process.env.NODE_ENV !== "production") {
+    debugVerifyPrototype(runtime, Object.getPrototypeOf(runtime));
+  }
+};
+function useRuntimeStateInternal(runtime, selector = identity) {
+  ensureBinding(runtime);
+  const slice2 = useSyncExternalStore(runtime.subscribe, () => selector(runtime.getState()), () => selector(runtime.getState()));
+  useDebugValue(slice2);
+  return slice2;
+}
+const identity = (arg) => arg;
+function createStateHookForRuntime(useRuntime) {
+  function useStoreHook(param) {
+    let optional = false;
+    let selector;
+    if (typeof param === "function") {
+      selector = param;
+    } else if (param) {
+      optional = !!param.optional;
+      selector = param.selector;
+    }
+    const store = useRuntime({ optional });
+    if (!store)
+      return null;
+    return useRuntimeStateInternal(store, selector);
+  }
+  return useStoreHook;
+}
+function useAssistantRuntime(options) {
+  var _a2, _b;
+  const aui = useAui();
+  const runtime = ((_b = (_a2 = aui.threads()).__internal_getAssistantRuntime) == null ? void 0 : _b.call(_a2)) ?? null;
+  if (!runtime && !(options == null ? void 0 : options.optional)) {
+    throw new Error("AssistantRuntime is not available");
+  }
+  return runtime;
+}
+const useThreadListRuntime = (opt) => {
+  var _a2;
+  return ((_a2 = useAssistantRuntime(opt)) == null ? void 0 : _a2.threads) ?? null;
+};
+const useThreadList = createStateHookForRuntime(useThreadListRuntime);
 function useComposerRuntime(options) {
   const aui = useAui();
   const runtime = useAuiState(() => {
@@ -9582,6 +9648,18 @@ function useComposerRuntime(options) {
   }
   return runtime;
 }
+function useThreadRuntime(options) {
+  const aui = useAui();
+  const runtime = useAuiState(() => {
+    var _a2, _b;
+    return aui.thread.source ? ((_b = (_a2 = aui.thread()).__internal_getRuntime) == null ? void 0 : _b.call(_a2)) ?? null : null;
+  });
+  if (!runtime && !(options == null ? void 0 : options.optional)) {
+    throw new Error("ThreadRuntime is not available");
+  }
+  return runtime;
+}
+const useThread = createStateHookForRuntime(useThreadRuntime);
 function setRef(ref, value) {
   if (typeof ref === "function") {
     return ref(value);
@@ -66508,6 +66586,31 @@ function ThreadListItem() {
     /* @__PURE__ */ jsx("span", { className: "flex-1 truncate text-left", children: /* @__PURE__ */ jsx(ThreadListItemPrimitiveTitle, { fallback: "Untitled" }) })
   ] }) });
 }
+function useAthenaThreadManager() {
+  const runtime = useAssistantRuntime({ optional: true });
+  const threadId = useThread({ optional: true, selector: (s) => s.threadId });
+  const threadList = useThreadList({ optional: true });
+  const switchToThread = useCallback(
+    (id) => runtime.threads.switchToThread(id),
+    [runtime]
+  );
+  const switchToNewThread = useCallback(
+    () => runtime.threads.switchToNewThread(),
+    [runtime]
+  );
+  return useMemo(() => {
+    if (!runtime || !threadList) {
+      return null;
+    }
+    return {
+      activeThreadId: threadId ?? null,
+      threadIds: threadList.threadIds,
+      isLoading: threadList.isLoading,
+      switchToThread,
+      switchToNewThread
+    };
+  }, [runtime, threadId, threadList, switchToThread, switchToNewThread]);
+}
 function useAppendToComposer() {
   const aui = useAui();
   return useCallback(
@@ -66686,6 +66789,7 @@ export {
   useAthenaConfig,
   useAthenaLinkClickHandler,
   useAthenaRuntime,
+  useAthenaThreadManager,
   useComposerAttachment,
   useFileUpload,
   useMentionSuggestions,