@athenaintel/react 0.4.1 → 0.4.3

package/dist/index.d.ts

@@ -6,6 +6,7 @@ import { ComponentPropsWithRef } from 'react';
 import { FC } from 'react';
 import { ForwardRefExoticComponent } from 'react';
 import { JSX } from 'react/jsx-runtime';
+import { LangChainMessage } from '@assistant-ui/react-langgraph';
 import * as React_2 from 'react';
 import { ReactNode } from 'react';
 import { RefAttributes } from 'react';
@@ -152,6 +153,8 @@ export declare interface AthenaRuntimeConfig {
     systemPrompt?: string;
     /** Thread ID override. Auto-generated if not provided. */
     threadId?: string;
+    /** Pre-loaded messages for existing threads (from thread switching). */
+    initialMessages?: LangChainMessage[];
 }
 
 export declare const BrowseToolUI: ToolCallMessagePartComponent;

package/dist/index.js

@@ -7622,7 +7622,7 @@ const toAppendMessage = (messages, message) => {
     startRun: message.startRun
   };
 };
-const getThreadState = (runtime, threadListItemState) => {
+const getThreadState$1 = (runtime, threadListItemState) => {
   const lastMessage = runtime.messages.at(-1);
   return Object.freeze({
     threadId: threadListItemState.id,
@@ -7645,7 +7645,7 @@ class ThreadRuntimeImpl {
     __publicField(this, "_eventSubscriptionSubjects", /* @__PURE__ */ new Map());
     const stateBinding = new ShallowMemoizeSubject({
       path: threadBinding.path,
-      getState: () => getThreadState(threadBinding.getState(), threadListItemBinding.getState()),
+      getState: () => getThreadState$1(threadBinding.getState(), threadListItemBinding.getState()),
       subscribe: (callback) => {
         const sub1 = threadBinding.subscribe(callback);
         const sub2 = threadListItemBinding.subscribe(callback);
@@ -20758,7 +20758,8 @@ const useAthenaRuntime = (config2) => {
     workbench = [],
     knowledgeBase = [],
     systemPrompt,
-    threadId: threadIdProp
+    threadId: threadIdProp,
+    initialMessages
   } = config2;
   const generatedIdRef = useRef(null);
   if (generatedIdRef.current === null) {
@@ -20776,7 +20777,7 @@ const useAthenaRuntime = (config2) => {
   const apiKeyRef = useRef(apiKey);
   apiKeyRef.current = apiKey;
   const runtime = useAssistantTransportRuntime({
-    initialState: { messages: [] },
+    initialState: { messages: initialMessages ?? [] },
     converter,
     api: apiUrl,
     headers: async () => {
@@ -24163,6 +24164,17 @@ async function listThreads(backendUrl, auth, opts = {}) {
   }
   return res.json();
 }
+async function getThreadState(backendUrl, auth, threadId) {
+  const base2 = getAgoraBaseUrl(backendUrl);
+  const res = await fetch(`${base2}/api/unstable/threads/${threadId}`, {
+    method: "GET",
+    headers: { ...getAuthHeaders(auth) }
+  });
+  if (!res.ok) {
+    throw new Error(`[AthenaSDK] Failed to get thread state: ${res.status}`);
+  }
+  return res.json();
+}
 async function archiveThread(backendUrl, auth, threadId) {
   const base2 = getAgoraBaseUrl(backendUrl);
   const res = await fetch(`${base2}/api/conversations/threads/archive`, {
@@ -24194,6 +24206,9 @@ function createThreadListStore(config2) {
       }
     },
     switchThread: (threadId) => {
+      if (process.env.NODE_ENV !== "production") {
+        console.log("[AthenaThreads] switchThread called", { threadId, prev: get2().activeThreadId });
+      }
       set2({ activeThreadId: threadId });
     },
     newThread: async () => {
@@ -24231,7 +24246,8 @@ function AthenaRuntimeInner({
   workbench,
   knowledgeBase,
   systemPrompt,
-  threadId
+  threadId,
+  initialMessages
 }) {
   const auiTools = useMemo(() => Tools({ toolkit: frontendTools }), [frontendTools]);
   const aui = useAui({ tools: auiTools });
@@ -24247,7 +24263,8 @@ function AthenaRuntimeInner({
     workbench,
     knowledgeBase,
     systemPrompt,
-    threadId
+    threadId,
+    initialMessages
   });
   const athenaConfig = useMemo(
     () => ({ backendUrl, apiKey, token }),
@@ -24255,6 +24272,66 @@ function AthenaRuntimeInner({
   );
   return /* @__PURE__ */ jsx(AssistantRuntimeProvider, { aui, runtime, children: /* @__PURE__ */ jsx(AthenaContext.Provider, { value: athenaConfig, children: /* @__PURE__ */ jsx(TooltipProvider, { children }) }) });
 }
+function ThreadStateLoader({
+  children,
+  threadId,
+  backendUrl,
+  apiKey,
+  token,
+  ...runtimeProps
+}) {
+  const [initialMessages, setInitialMessages] = useState(void 0);
+  const [isLoading, setIsLoading] = useState(!!threadId);
+  useEffect(() => {
+    if (!threadId) {
+      setInitialMessages(void 0);
+      setIsLoading(false);
+      return;
+    }
+    let cancelled = false;
+    setIsLoading(true);
+    getThreadState(backendUrl, { apiKey, token }, threadId).then((state) => {
+      var _a2;
+      if (cancelled) return;
+      if (process.env.NODE_ENV !== "production") {
+        console.log("[AthenaThreads] Loaded thread state", {
+          threadId,
+          messageCount: ((_a2 = state.messages) == null ? void 0 : _a2.length) ?? 0
+        });
+      }
+      setInitialMessages(state.messages ?? []);
+      setIsLoading(false);
+    }).catch((err) => {
+      if (cancelled) return;
+      if (process.env.NODE_ENV !== "production") {
+        console.warn("[AthenaThreads] Failed to load thread state, starting fresh", err);
+      }
+      setInitialMessages(void 0);
+      setIsLoading(false);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [threadId, backendUrl, apiKey, token]);
+  if (isLoading) {
+    return /* @__PURE__ */ jsxs("div", { style: { display: "flex", alignItems: "center", justifyContent: "center", height: "100%", width: "100%" }, children: [
+      /* @__PURE__ */ jsx("div", { style: { width: 24, height: 24, border: "2px solid currentColor", borderTopColor: "transparent", borderRadius: "50%", animation: "spin 0.6s linear infinite", opacity: 0.4 } }),
+      /* @__PURE__ */ jsx("style", { children: `@keyframes spin { to { transform: rotate(360deg); } }` })
+    ] });
+  }
+  return /* @__PURE__ */ jsx(
+    AthenaRuntimeInner,
+    {
+      threadId,
+      backendUrl,
+      apiKey,
+      token,
+      initialMessages,
+      ...runtimeProps,
+      children
+    }
+  );
+}
 function useActiveThreadFromStore(store) {
   return useSyncExternalStore(
     (cb) => {
@@ -24286,6 +24363,17 @@ function AthenaProvider({
   const parentAuthToken = useParentAuth();
   const effectiveToken = tokenProp ?? parentAuthToken;
   const effectiveBackendUrl = backendUrl ?? DEFAULT_BACKEND_URL;
+  useEffect(() => {
+    if (process.env.NODE_ENV !== "production") {
+      console.log("[AthenaAuth] AthenaProvider auth state", {
+        hasTokenProp: !!tokenProp,
+        hasParentAuthToken: !!parentAuthToken,
+        hasEffectiveToken: !!effectiveToken,
+        hasApiKey: !!apiKey,
+        authMethod: effectiveToken ? "Bearer token (PropelAuth)" : apiKey ? "X-API-KEY" : "NONE"
+      });
+    }
+  }, [tokenProp, parentAuthToken, effectiveToken, apiKey]);
   const threadListStoreRef = useRef(null);
   if (enableThreadList && !threadListStoreRef.current) {
     threadListStoreRef.current = createThreadListStore({
@@ -24298,8 +24386,18 @@ function AthenaProvider({
     enableThreadList ? threadListStoreRef.current : null
   );
   const resolvedThreadId = threadIdProp ?? activeThreadId ?? void 0;
+  useEffect(() => {
+    if (process.env.NODE_ENV !== "production") {
+      console.log("[AthenaThreads] AthenaProvider render", {
+        activeThreadId,
+        resolvedThreadId,
+        enableThreadList,
+        hasStore: !!threadListStoreRef.current
+      });
+    }
+  }, [activeThreadId, resolvedThreadId, enableThreadList]);
   const inner = /* @__PURE__ */ jsx(
-    AthenaRuntimeInner,
+    ThreadStateLoader,
     {
       apiUrl,
       backendUrl: effectiveBackendUrl,