@athenaintel/react 0.4.2 → 0.4.4

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,36 @@ async function listThreads(backendUrl, auth, opts = {}) {
   }
   return res.json();
 }
+function deserializeMessage(msg) {
+  if (msg && typeof msg === "object" && "lc" in msg && "kwargs" in msg && msg.type === "constructor") {
+    const kwargs = msg.kwargs;
+    if (Array.isArray(kwargs.tool_calls)) {
+      kwargs.tool_calls = kwargs.tool_calls.map((tc) => {
+        if (tc && typeof tc === "object" && "lc" in tc && "kwargs" in tc) {
+          return tc.kwargs;
+        }
+        return tc;
+      });
+    }
+    return kwargs;
+  }
+  return msg;
+}
+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}`);
+  }
+  const data = await res.json();
+  if (Array.isArray(data.messages)) {
+    data.messages = data.messages.map(deserializeMessage);
+  }
+  return data;
+}
 async function archiveThread(backendUrl, auth, threadId) {
   const base2 = getAgoraBaseUrl(backendUrl);
   const res = await fetch(`${base2}/api/conversations/threads/archive`, {
@@ -24234,7 +24265,8 @@ function AthenaRuntimeInner({
   workbench,
   knowledgeBase,
   systemPrompt,
-  threadId
+  threadId,
+  initialMessages
 }) {
   const auiTools = useMemo(() => Tools({ toolkit: frontendTools }), [frontendTools]);
   const aui = useAui({ tools: auiTools });
@@ -24250,7 +24282,8 @@ function AthenaRuntimeInner({
     workbench,
     knowledgeBase,
     systemPrompt,
-    threadId
+    threadId,
+    initialMessages
   });
   const athenaConfig = useMemo(
     () => ({ backendUrl, apiKey, token }),
@@ -24258,6 +24291,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) => {
@@ -24323,7 +24416,7 @@ function AthenaProvider({
     }
   }, [activeThreadId, resolvedThreadId, enableThreadList]);
   const inner = /* @__PURE__ */ jsx(
-    AthenaRuntimeInner,
+    ThreadStateLoader,
     {
       apiUrl,
       backendUrl: effectiveBackendUrl,