@letta-ai/letta-react 0.0.7 → 0.0.9

package/README.md

@@ -110,12 +110,29 @@ const {
 });
 ```
 
-##### Getting Agent State
+##### Getting/Setting Agent State
 
 Check out [this example](./packages/letta-react/examples/view-and-send-messages) for more detailed usage.
 
 ```typescript jsx
-const { agentState, error, isLoading, refresh } = useAgentState({
+const {
+  agentState,
+  loadingError,
+  isLoading,
+  refresh,
+  updateAgentState,
+  isUpdating,
+  updatingError,
+} = useAgentState({
   agentId: `your-agent-id`,
 });
 ```
+
+##### Listing Agent Passages
+
+```typescript jsx
+const { passages, loadingError, isLoadingError, isLoading, refresh } =
+  useAgentPassages({
+    agentId: `your-agent-id`,
+  });
+```

package/dist/hooks/useAgentMessages/useAgentMessages.js

@@ -60,7 +60,7 @@ export function useAgentMessages(options) {
     const [localMessages, setLocalMessages] = useCachedState(`messages-${agentId}`, {
         messages: [],
     });
-    const hasInitialLoaded = useRef(false);
+    const agentIdMessagesLoadedRef = useRef(false);
     const [isLoading, setIsLoading] = useState(true);
     const [isFetching, setIsFetching] = useState(false);
     const [loadingError, setLoadingError] = useState(null);
@@ -230,12 +230,11 @@ export function useAgentMessages(options) {
         return getMessages(nextCursor);
     }), [getMessages]);
     useEffect(() => {
-        if (hasInitialLoaded.current) {
-            return;
+        if (!agentIdMessagesLoadedRef.current) {
+            setIsLoading(true);
+            void getMessages();
+            agentIdMessagesLoadedRef.current = true;
         }
-        hasInitialLoaded.current = true;
-        setIsLoading(true);
-        getMessages();
     }, []);
     return {
         messages: localMessages.messages,

package/dist/hooks/useAgentPassages/useAgentPassages.d.ts

@@ -0,0 +1,14 @@
+import type { Passage } from '@letta-ai/letta-client/api';
+import type { LettaClient } from '@letta-ai/letta-client';
+interface UseAgentStateOptions {
+    client?: LettaClient.Options;
+    agentId: string;
+}
+export declare function useAgentPassages(options: UseAgentStateOptions): {
+    isLoading: boolean;
+    loadingError: unknown;
+    isLoadingError: boolean;
+    passages: Passage[] | undefined;
+    refresh: () => Promise<void>;
+};
+export {};

package/dist/hooks/useAgentPassages/useAgentPassages.js

@@ -0,0 +1,46 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { useLettaClient } from '../useLettaClient/useLettaClient';
+import { useCachedState } from '../useCachedState/useCachedState';
+import { useCallback, useEffect, useRef, useState } from 'react';
+export function useAgentPassages(options) {
+    const { client, agentId } = options;
+    const localClient = useLettaClient(client);
+    const loadedAgentId = useRef(null);
+    const [localState, setLocalState] = useCachedState(`agent-passages-${agentId}`, undefined);
+    const [isLoading, setIsLoading] = useState(true);
+    const [loadingError, setLoadingError] = useState(null);
+    const getAgentPassages = useCallback(() => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const state = yield localClient.agents.passages.list(agentId);
+            setLocalState(state);
+        }
+        catch (error) {
+            setLoadingError(error);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }), [agentId, localClient, setLocalState]);
+    useEffect(() => {
+        if (agentId !== loadedAgentId.current) {
+            setIsLoading(true);
+            void getAgentPassages();
+            loadedAgentId.current = agentId;
+        }
+    }, [agentId, getAgentPassages]);
+    return {
+        isLoading,
+        loadingError,
+        isLoadingError: !!loadingError,
+        passages: localState,
+        refresh: getAgentPassages,
+    };
+}

package/dist/hooks/useAgentState/useAgentState.d.ts

@@ -1,12 +1,15 @@
 import type { LettaClient } from '@letta-ai/letta-client';
-import type { AgentState } from '@letta-ai/letta-client/api';
+import type { AgentState, UpdateAgent } from '@letta-ai/letta-client/api';
 interface UseAgentStateOptions {
     client?: LettaClient.Options;
     agentId: string;
 }
 export declare function useAgentState(options: UseAgentStateOptions): {
     isLoading: boolean;
-    error: unknown;
+    updateAgentState: (state: Partial<UpdateAgent>) => Promise<void>;
+    isUpdating: boolean;
+    updatingError: unknown;
+    loadingError: unknown;
     agentState: AgentState | undefined;
     refresh: () => Promise<void>;
 };

package/dist/hooks/useAgentState/useAgentState.js

@@ -15,8 +15,10 @@ export function useAgentState(options) {
     const localClient = useLettaClient(client);
     const [localState, setLocalState] = useCachedState(`agent-state-${agentId}`, undefined);
     const [isLoading, setIsLoading] = useState(true);
+    const [isUpdating, setIsUpdating] = useState(false);
+    const [updatingError, setUpdatingError] = useState(null);
     const [loadingError, setLoadingError] = useState(null);
-    const hasInitialLoaded = useRef(false);
+    const loadedAgentId = useRef(null);
     const getAgentState = useCallback(() => __awaiter(this, void 0, void 0, function* () {
         try {
             const state = yield localClient.agents.retrieve(agentId);
@@ -29,17 +31,32 @@ export function useAgentState(options) {
             setIsLoading(false);
         }
     }), [agentId, localClient, setLocalState]);
+    const updateAgentState = useCallback((state) => __awaiter(this, void 0, void 0, function* () {
+        setIsUpdating(true);
+        try {
+            const response = yield localClient.agents.modify(agentId, state);
+            setLocalState(response);
+        }
+        catch (error) {
+            setUpdatingError(error);
+        }
+        finally {
+            setIsUpdating(false);
+        }
+    }), [agentId, localClient, setLocalState]);
     useEffect(() => {
-        if (hasInitialLoaded.current) {
-            return;
+        if (agentId !== loadedAgentId.current) {
+            setIsLoading(true);
+            void getAgentState();
+            loadedAgentId.current = agentId;
         }
-        hasInitialLoaded.current = true;
-        setIsLoading(true);
-        getAgentState();
-    }, []);
+    }, [agentId]);
     return {
         isLoading,
-        error: loadingError,
+        updateAgentState,
+        isUpdating,
+        updatingError,
+        loadingError,
         agentState: localState,
         refresh: getAgentState,
     };

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export { LettaProvider } from './hooks/useGlobalLettaConfig/useGlobalLettaConfig';
 export { useAgentMessages } from './hooks/useAgentMessages/useAgentMessages';
 export { useAgentState } from './hooks/useAgentState/useAgentState';
+export { useAgentPassages } from './hooks/useAgentPassages/useAgentPassages';

package/dist/index.js

@@ -1,3 +1,4 @@
 export { LettaProvider } from './hooks/useGlobalLettaConfig/useGlobalLettaConfig';
 export { useAgentMessages } from './hooks/useAgentMessages/useAgentMessages';
 export { useAgentState } from './hooks/useAgentState/useAgentState';
+export { useAgentPassages } from './hooks/useAgentPassages/useAgentPassages';

package/examples/view-and-send-messages/src/App.tsx

@@ -1,7 +1,11 @@
 import React, { FormEvent, useCallback } from 'react';
 import { useState } from 'react';
 import './App.css';
-import { useAgentMessages, useAgentState } from '@letta-ai/letta-react';
+import {
+  useAgentMessages,
+  useAgentPassages,
+  useAgentState,
+} from '@letta-ai/letta-react';
 
 function App() {
   const [messageToSend, setMessageToSend] = useState<string>('');
@@ -14,11 +18,15 @@ function App() {
     isSending,
     sendMessage,
   } = useAgentMessages({
-    agentId: 'agent-ed85493d-2164-4404-b52e-119ccbc987b4',
+    agentId: 'agent-0d07e901-64de-4bbd-8a7c-268ce88bc6cb',
+  });
+
+  const { passages, isLoading: isPassagesLoading } = useAgentPassages({
+    agentId: 'agent-0d07e901-64de-4bbd-8a7c-268ce88bc6cb',
   });
 
   const { agentState } = useAgentState({
-    agentId: 'agent-ed85493d-2164-4404-b52e-119ccbc987b4',
+    agentId: 'agent-0d07e901-64de-4bbd-8a7c-268ce88bc6cb',
   });
 
   const handleSubmit = useCallback(
@@ -42,6 +50,16 @@ function App() {
   return (
     <main>
       <header>Talking to: {agentState?.name}</header>
+      {isPassagesLoading ? (
+        <div>Loading passages!</div>
+      ) : (
+        <ul className="passages">
+          {passages?.map((passage) => (
+            <li key={passage.id}>{passage.text}</li>
+          ))}
+        </ul>
+      )}
+
       {hasOlderMessages && (
         <button onClick={fetchOlderMessages} disabled={isFetching}>
           {isFetching ? 'Loading older messages' : 'Load older messages'}

package/hooks/useAgentMessages/useAgentMessages.js

@@ -60,7 +60,7 @@ export function useAgentMessages(options) {
     const [localMessages, setLocalMessages] = useCachedState(`messages-${agentId}`, {
         messages: [],
     });
-    const hasInitialLoaded = useRef(false);
+    const agentIdMessagesLoadedRef = useRef(false);
     const [isLoading, setIsLoading] = useState(true);
     const [isFetching, setIsFetching] = useState(false);
     const [loadingError, setLoadingError] = useState(null);
@@ -230,12 +230,11 @@ export function useAgentMessages(options) {
         return getMessages(nextCursor);
     }), [getMessages]);
     useEffect(() => {
-        if (hasInitialLoaded.current) {
-            return;
+        if (!agentIdMessagesLoadedRef.current) {
+            setIsLoading(true);
+            void getMessages();
+            agentIdMessagesLoadedRef.current = true;
         }
-        hasInitialLoaded.current = true;
-        setIsLoading(true);
-        getMessages();
     }, []);
     return {
         messages: localMessages.messages,

package/hooks/useAgentPassages/useAgentPassages.d.ts

@@ -0,0 +1,14 @@
+import type { Passage } from '@letta-ai/letta-client/api';
+import type { LettaClient } from '@letta-ai/letta-client';
+interface UseAgentStateOptions {
+    client?: LettaClient.Options;
+    agentId: string;
+}
+export declare function useAgentPassages(options: UseAgentStateOptions): {
+    isLoading: boolean;
+    loadingError: unknown;
+    isLoadingError: boolean;
+    passages: Passage[] | undefined;
+    refresh: () => Promise<void>;
+};
+export {};

package/hooks/useAgentPassages/useAgentPassages.js

@@ -0,0 +1,46 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { useLettaClient } from '../useLettaClient/useLettaClient';
+import { useCachedState } from '../useCachedState/useCachedState';
+import { useCallback, useEffect, useRef, useState } from 'react';
+export function useAgentPassages(options) {
+    const { client, agentId } = options;
+    const localClient = useLettaClient(client);
+    const loadedAgentId = useRef(null);
+    const [localState, setLocalState] = useCachedState(`agent-passages-${agentId}`, undefined);
+    const [isLoading, setIsLoading] = useState(true);
+    const [loadingError, setLoadingError] = useState(null);
+    const getAgentPassages = useCallback(() => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const state = yield localClient.agents.passages.list(agentId);
+            setLocalState(state);
+        }
+        catch (error) {
+            setLoadingError(error);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }), [agentId, localClient, setLocalState]);
+    useEffect(() => {
+        if (agentId !== loadedAgentId.current) {
+            setIsLoading(true);
+            void getAgentPassages();
+            loadedAgentId.current = agentId;
+        }
+    }, [agentId, getAgentPassages]);
+    return {
+        isLoading,
+        loadingError,
+        isLoadingError: !!loadingError,
+        passages: localState,
+        refresh: getAgentPassages,
+    };
+}

package/hooks/useAgentState/useAgentState.d.ts

@@ -1,12 +1,15 @@
 import type { LettaClient } from '@letta-ai/letta-client';
-import type { AgentState } from '@letta-ai/letta-client/api';
+import type { AgentState, UpdateAgent } from '@letta-ai/letta-client/api';
 interface UseAgentStateOptions {
     client?: LettaClient.Options;
     agentId: string;
 }
 export declare function useAgentState(options: UseAgentStateOptions): {
     isLoading: boolean;
-    error: unknown;
+    updateAgentState: (state: Partial<UpdateAgent>) => Promise<void>;
+    isUpdating: boolean;
+    updatingError: unknown;
+    loadingError: unknown;
     agentState: AgentState | undefined;
     refresh: () => Promise<void>;
 };

package/hooks/useAgentState/useAgentState.js

@@ -15,8 +15,10 @@ export function useAgentState(options) {
     const localClient = useLettaClient(client);
     const [localState, setLocalState] = useCachedState(`agent-state-${agentId}`, undefined);
     const [isLoading, setIsLoading] = useState(true);
+    const [isUpdating, setIsUpdating] = useState(false);
+    const [updatingError, setUpdatingError] = useState(null);
     const [loadingError, setLoadingError] = useState(null);
-    const hasInitialLoaded = useRef(false);
+    const loadedAgentId = useRef(null);
     const getAgentState = useCallback(() => __awaiter(this, void 0, void 0, function* () {
         try {
             const state = yield localClient.agents.retrieve(agentId);
@@ -29,17 +31,32 @@ export function useAgentState(options) {
             setIsLoading(false);
         }
     }), [agentId, localClient, setLocalState]);
+    const updateAgentState = useCallback((state) => __awaiter(this, void 0, void 0, function* () {
+        setIsUpdating(true);
+        try {
+            const response = yield localClient.agents.modify(agentId, state);
+            setLocalState(response);
+        }
+        catch (error) {
+            setUpdatingError(error);
+        }
+        finally {
+            setIsUpdating(false);
+        }
+    }), [agentId, localClient, setLocalState]);
     useEffect(() => {
-        if (hasInitialLoaded.current) {
-            return;
+        if (agentId !== loadedAgentId.current) {
+            setIsLoading(true);
+            void getAgentState();
+            loadedAgentId.current = agentId;
         }
-        hasInitialLoaded.current = true;
-        setIsLoading(true);
-        getAgentState();
-    }, []);
+    }, [agentId]);
     return {
         isLoading,
-        error: loadingError,
+        updateAgentState,
+        isUpdating,
+        updatingError,
+        loadingError,
         agentState: localState,
         refresh: getAgentState,
     };

package/index.d.ts

@@ -1,3 +1,4 @@
 export { LettaProvider } from './hooks/useGlobalLettaConfig/useGlobalLettaConfig';
 export { useAgentMessages } from './hooks/useAgentMessages/useAgentMessages';
 export { useAgentState } from './hooks/useAgentState/useAgentState';
+export { useAgentPassages } from './hooks/useAgentPassages/useAgentPassages';

package/index.js

@@ -1,3 +1,4 @@
 export { LettaProvider } from './hooks/useGlobalLettaConfig/useGlobalLettaConfig';
 export { useAgentMessages } from './hooks/useAgentMessages/useAgentMessages';
 export { useAgentState } from './hooks/useAgentState/useAgentState';
+export { useAgentPassages } from './hooks/useAgentPassages/useAgentPassages';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@letta-ai/letta-react",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "Letta's react library",
   "private": false,
   "main": "./index.js",

package/src/hooks/useAgentMessages/useAgentMessages.ts

@@ -85,7 +85,7 @@ export function useAgentMessages(options: UseAgentOptions) {
     }
   );
 
-  const hasInitialLoaded = useRef<boolean>(false);
+  const agentIdMessagesLoadedRef = useRef(false);
 
   const [isLoading, setIsLoading] = useState(true);
   const [isFetching, setIsFetching] = useState(false);
@@ -371,15 +371,11 @@ export function useAgentMessages(options: UseAgentOptions) {
   }, [getMessages]);
 
   useEffect(() => {
-    if (hasInitialLoaded.current) {
-      return;
+    if (!agentIdMessagesLoadedRef.current) {
+      setIsLoading(true);
+      void getMessages();
+      agentIdMessagesLoadedRef.current = true;
     }
-
-    hasInitialLoaded.current = true;
-
-    setIsLoading(true);
-
-    getMessages();
   }, []);
 
   return {

package/src/hooks/useAgentPassages/useAgentPassages.ts

@@ -0,0 +1,52 @@
+import { useLettaClient } from '../useLettaClient/useLettaClient';
+import { useCachedState } from '../useCachedState/useCachedState';
+import type { AgentState, Passage } from '@letta-ai/letta-client/api';
+import type { LettaClient } from '@letta-ai/letta-client';
+import { useCallback, useEffect, useRef, useState } from 'react';
+
+interface UseAgentStateOptions {
+  client?: LettaClient.Options;
+  agentId: string;
+}
+
+export function useAgentPassages(options: UseAgentStateOptions) {
+  const { client, agentId } = options;
+  const localClient = useLettaClient(client);
+  const loadedAgentId = useRef<string | null>(null);
+
+  const [localState, setLocalState] = useCachedState<Passage[] | undefined>(
+    `agent-passages-${agentId}`,
+    undefined
+  );
+
+  const [isLoading, setIsLoading] = useState(true);
+  const [loadingError, setLoadingError] = useState<unknown | null>(null);
+
+  const getAgentPassages = useCallback(async () => {
+    try {
+      const state = await localClient.agents.passages.list(agentId);
+
+      setLocalState(state);
+    } catch (error) {
+      setLoadingError(error);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [agentId, localClient, setLocalState]);
+
+  useEffect(() => {
+    if (agentId !== loadedAgentId.current) {
+      setIsLoading(true);
+      void getAgentPassages();
+      loadedAgentId.current = agentId;
+    }
+  }, [agentId, getAgentPassages]);
+
+  return {
+    isLoading,
+    loadingError,
+    isLoadingError: !!loadingError,
+    passages: localState,
+    refresh: getAgentPassages,
+  };
+}

package/src/hooks/useAgentState/useAgentState.ts

@@ -1,7 +1,7 @@
 import { useLettaClient } from '../useLettaClient/useLettaClient';
 import type { LettaClient } from '@letta-ai/letta-client';
 import { useCachedState } from '../useCachedState/useCachedState';
-import type { AgentState } from '@letta-ai/letta-client/api';
+import type { AgentState, UpdateAgent } from '@letta-ai/letta-client/api';
 import { useCallback, useEffect, useRef, useState } from 'react';
 
 interface UseAgentStateOptions {
@@ -19,8 +19,10 @@ export function useAgentState(options: UseAgentStateOptions) {
   );
 
   const [isLoading, setIsLoading] = useState(true);
+  const [isUpdating, setIsUpdating] = useState(false);
+  const [updatingError, setUpdatingError] = useState<unknown | null>(null);
   const [loadingError, setLoadingError] = useState<unknown | null>(null);
-  const hasInitialLoaded = useRef<boolean>(false);
+  const loadedAgentId = useRef<string | null>(null);
 
   const getAgentState = useCallback(async () => {
     try {
@@ -34,21 +36,36 @@ export function useAgentState(options: UseAgentStateOptions) {
     }
   }, [agentId, localClient, setLocalState]);
 
-  useEffect(() => {
-    if (hasInitialLoaded.current) {
-      return;
-    }
-
-    hasInitialLoaded.current = true;
+  const updateAgentState = useCallback(
+    async (state: Partial<UpdateAgent>) => {
+      setIsUpdating(true);
+      try {
+        const response = await localClient.agents.modify(agentId, state);
 
-    setIsLoading(true);
+        setLocalState(response);
+      } catch (error) {
+        setUpdatingError(error);
+      } finally {
+        setIsUpdating(false);
+      }
+    },
+    [agentId, localClient, setLocalState]
+  );
 
-    getAgentState();
-  }, []);
+  useEffect(() => {
+    if (agentId !== loadedAgentId.current) {
+      setIsLoading(true);
+      void getAgentState();
+      loadedAgentId.current = agentId;
+    }
+  }, [agentId]);
 
   return {
     isLoading,
-    error: loadingError,
+    updateAgentState,
+    isUpdating,
+    updatingError,
+    loadingError,
     agentState: localState,
     refresh: getAgentState,
   };

package/src/index.ts

@@ -1,3 +1,4 @@
 export { LettaProvider } from './hooks/useGlobalLettaConfig/useGlobalLettaConfig';
 export { useAgentMessages } from './hooks/useAgentMessages/useAgentMessages';
 export { useAgentState } from './hooks/useAgentState/useAgentState';
+export { useAgentPassages } from './hooks/useAgentPassages/useAgentPassages';