@athenaintel/react 0.10.2 → 0.10.4

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);
@@ -24957,6 +25035,7 @@ function AthenaWithThreadList({
   linkClicks,
   citationLinks
 }) {
+  var _a2;
   const adapter = useAthenaThreadListAdapter({
     backendUrl,
     apiKey,
@@ -24999,15 +25078,17 @@ function AthenaWithThreadList({
     adapter
   });
   const handleRefresh = useCallback(() => {
-    var _a2;
-    const core = (_a2 = runtime == null ? void 0 : runtime._core) == null ? void 0 : _a2.threads;
+    var _a3;
+    const core = (_a3 = runtime == null ? void 0 : runtime._core) == null ? void 0 : _a3.threads;
     if (core) {
       core._loadThreadsPromise = void 0;
       core.__internal_load();
     }
   }, [runtime]);
   const previousAuthRefreshKeyRef = useRef(null);
-  const authRefreshKey = `${backendUrl}::${apiKey ?? ""}::${token ?? ""}`;
+  const authContext = useContext(AthenaAuthContext);
+  const authUserId = ((_a2 = authContext == null ? void 0 : authContext.user) == null ? void 0 : _a2.userId) ?? "";
+  const authRefreshKey = `${backendUrl}::${apiKey ?? ""}::${authUserId}`;
   useEffect(() => {
     const previousAuthRefreshKey = previousAuthRefreshKeyRef.current;
     previousAuthRefreshKeyRef.current = authRefreshKey;
@@ -64826,11 +64907,24 @@ function highlightSql(code2) {
       i += str.length;
       continue;
     }
+    if (code2.slice(i, i + 2) === "/*") {
+      const end = code2.indexOf("*/", i + 2);
+      const str = end >= 0 ? code2.slice(i, end + 2) : code2.slice(i);
+      result += `<span style="color:var(--aui-syn-comment, #6a9955)">${escapeHtml(str)}</span>`;
+      i += str.length;
+      continue;
+    }
     if (code2[i] === "'" || code2[i] === '"') {
       const q = code2[i];
       let j = i + 1;
-      while (j < code2.length && code2[j] !== q) {
-        if (code2[j] === "\\") j++;
+      while (j < code2.length) {
+        if (code2[j] === q) {
+          if (j + 1 < code2.length && code2[j + 1] === q) {
+            j += 2;
+            continue;
+          }
+          break;
+        }
         j++;
       }
       const str = code2.slice(i, j + 1);
@@ -64979,9 +65073,11 @@ const RunSqlToolUIImpl = ({
               i
             )) })
           ] }) }),
-          parsed.rows.length > 50 && /* @__PURE__ */ jsxs("div", { className: "border-t border-border/30 px-4 py-1.5 text-[10px] text-muted-foreground", children: [
-            "Showing first 50 of ",
-            parsed.rows.length,
+          (parsed.rows.length > 50 || parsed.rowCount !== null && parsed.rowCount > parsed.rows.length) && /* @__PURE__ */ jsxs("div", { className: "border-t border-border/30 px-4 py-1.5 text-[10px] text-muted-foreground", children: [
+            "Showing first ",
+            Math.min(50, parsed.rows.length),
+            " of ",
+            parsed.rowCount ?? parsed.rows.length,
             " rows"
           ] })
         ] }),
@@ -66490,6 +66586,21 @@ 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 });
+  if (!runtime || !threadList) {
+    return null;
+  }
+  return {
+    activeThreadId: threadId ?? null,
+    threadIds: threadList.threadIds,
+    isLoading: threadList.isLoading,
+    switchToThread: (id) => runtime.threads.switchToThread(id),
+    switchToNewThread: () => runtime.threads.switchToNewThread()
+  };
+}
 function useAppendToComposer() {
   const aui = useAui();
   return useCallback(
@@ -66668,6 +66779,7 @@ export {
   useAthenaConfig,
   useAthenaLinkClickHandler,
   useAthenaRuntime,
+  useAthenaThreadManager,
   useComposerAttachment,
   useFileUpload,
   useMentionSuggestions,