@letta-ai/letta-react 0.0.6 → 0.0.8

package/dist/hooks/useAgentMessages/useAgentMessages.js

@@ -46,13 +46,21 @@ function dedupeMessages(messages) {
         return false;
     }, []);
 }
+function messageCreateToMessageUnion(messages) {
+    return messages.map((message, idx) => ({
+        messageType: message.role === 'user' ? 'user_message' : 'system_message',
+        content: message.content,
+        date: new Date(),
+        id: `autogenerated_${Date.now()}_${idx}`,
+    }));
+}
 export function useAgentMessages(options) {
     const { client = {}, method = 'stream', messageOptions = {}, limit = 20, agentId, } = options;
     const localClient = useLettaClient(client);
     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);
@@ -60,26 +68,39 @@ export function useAgentMessages(options) {
     const [sendingError, setSendingError] = useState(null);
     const sendNonStreamedMessage = useCallback(function sendNonStreamedMessage(sendMessagePayload) {
         return __awaiter(this, void 0, void 0, function* () {
+            let originalMessageState = localMessages;
             try {
                 setIsSending(true);
                 setSendingError(null);
+                const newMessages = messageCreateToMessageUnion(sendMessagePayload.messages);
+                setLocalMessages((prevState) => {
+                    originalMessageState = prevState;
+                    return Object.assign(Object.assign({}, prevState), { messages: [...prevState.messages, ...newMessages] });
+                });
                 const response = yield localClient.agents.messages.create(agentId, Object.assign(Object.assign({}, sendMessagePayload), messageOptions));
-                setLocalMessages((prevState) => (Object.assign(Object.assign({}, prevState), { messages: [...response.messages, ...prevState.messages] })));
+                setLocalMessages((prevState) => (Object.assign(Object.assign({}, prevState), { messages: [...prevState.messages, ...response.messages] })));
             }
             catch (e) {
+                setLocalMessages(originalMessageState);
                 setSendingError(e);
             }
             finally {
                 setIsSending(false);
             }
         });
-    }, [localClient]);
+    }, [localClient, localMessages]);
     const sendStreamedMessage = useCallback(function sendStreamedMessage(sendMessagePayload) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, e_1, _b, _c;
+            let originalMessageState = localMessages;
             try {
                 setIsSending(true);
                 setSendingError(null);
+                const newMessages = messageCreateToMessageUnion(sendMessagePayload.messages);
+                setLocalMessages((prevState) => {
+                    originalMessageState = prevState;
+                    return Object.assign(Object.assign({}, prevState), { messages: [...prevState.messages, ...newMessages] });
+                });
                 const response = yield localClient.agents.messages.createStream(agentId, Object.assign(Object.assign(Object.assign({}, sendMessagePayload), messageOptions), { streamTokens: true }));
                 try {
                     for (var _d = true, response_1 = __asyncValues(response), response_1_1; response_1_1 = yield response_1.next(), _a = response_1_1.done, !_a; _d = true) {
@@ -167,13 +188,17 @@ export function useAgentMessages(options) {
         });
     }, [localClient]);
     const sendMessage = useCallback(function sendMessage(payload) {
+        const filteredPayload = Object.assign(Object.assign({}, payload), { messages: payload.messages.filter((e) => !!e.content) });
+        if (filteredPayload.messages.length === 0) {
+            return;
+        }
         if (isSending) {
             return;
         }
         if (method === 'stream') {
-            return sendStreamedMessage(payload);
+            return sendStreamedMessage(filteredPayload);
         }
-        return sendNonStreamedMessage(payload);
+        return sendNonStreamedMessage(filteredPayload);
     }, [method, isSending, sendStreamedMessage, sendNonStreamedMessage]);
     const getMessages = useCallback(function getMessages(before) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -205,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,13 @@
+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;
+    isLoadingError: unknown;
+    passages: Passage[] | undefined;
+    refresh: () => Promise<void>;
+};
+export {};

package/dist/hooks/useAgentPassages/useAgentPassages.js

@@ -0,0 +1,45 @@
+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 [isLoadingError, setIsLoadingError] = 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) {
+            setIsLoadingError(error);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }), [agentId, localClient, setLocalState]);
+    useEffect(() => {
+        if (agentId !== loadedAgentId.current) {
+            setIsLoading(true);
+            void getAgentPassages();
+            loadedAgentId.current = agentId;
+        }
+    }, [agentId, getAgentPassages]);
+    return {
+        isLoading,
+        isLoadingError,
+        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'}
@@ -57,7 +75,6 @@ function App() {
               return (
                 <li key={`${message.id}${message.messageType}`}>
                   {message.content}
-                  {message.id}
                 </li>
               );
             }

package/hooks/useAgentMessages/useAgentMessages.js

@@ -46,13 +46,21 @@ function dedupeMessages(messages) {
         return false;
     }, []);
 }
+function messageCreateToMessageUnion(messages) {
+    return messages.map((message, idx) => ({
+        messageType: message.role === 'user' ? 'user_message' : 'system_message',
+        content: message.content,
+        date: new Date(),
+        id: `autogenerated_${Date.now()}_${idx}`,
+    }));
+}
 export function useAgentMessages(options) {
     const { client = {}, method = 'stream', messageOptions = {}, limit = 20, agentId, } = options;
     const localClient = useLettaClient(client);
     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);
@@ -60,26 +68,39 @@ export function useAgentMessages(options) {
     const [sendingError, setSendingError] = useState(null);
     const sendNonStreamedMessage = useCallback(function sendNonStreamedMessage(sendMessagePayload) {
         return __awaiter(this, void 0, void 0, function* () {
+            let originalMessageState = localMessages;
             try {
                 setIsSending(true);
                 setSendingError(null);
+                const newMessages = messageCreateToMessageUnion(sendMessagePayload.messages);
+                setLocalMessages((prevState) => {
+                    originalMessageState = prevState;
+                    return Object.assign(Object.assign({}, prevState), { messages: [...prevState.messages, ...newMessages] });
+                });
                 const response = yield localClient.agents.messages.create(agentId, Object.assign(Object.assign({}, sendMessagePayload), messageOptions));
-                setLocalMessages((prevState) => (Object.assign(Object.assign({}, prevState), { messages: [...response.messages, ...prevState.messages] })));
+                setLocalMessages((prevState) => (Object.assign(Object.assign({}, prevState), { messages: [...prevState.messages, ...response.messages] })));
             }
             catch (e) {
+                setLocalMessages(originalMessageState);
                 setSendingError(e);
             }
             finally {
                 setIsSending(false);
             }
         });
-    }, [localClient]);
+    }, [localClient, localMessages]);
     const sendStreamedMessage = useCallback(function sendStreamedMessage(sendMessagePayload) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, e_1, _b, _c;
+            let originalMessageState = localMessages;
             try {
                 setIsSending(true);
                 setSendingError(null);
+                const newMessages = messageCreateToMessageUnion(sendMessagePayload.messages);
+                setLocalMessages((prevState) => {
+                    originalMessageState = prevState;
+                    return Object.assign(Object.assign({}, prevState), { messages: [...prevState.messages, ...newMessages] });
+                });
                 const response = yield localClient.agents.messages.createStream(agentId, Object.assign(Object.assign(Object.assign({}, sendMessagePayload), messageOptions), { streamTokens: true }));
                 try {
                     for (var _d = true, response_1 = __asyncValues(response), response_1_1; response_1_1 = yield response_1.next(), _a = response_1_1.done, !_a; _d = true) {
@@ -167,13 +188,17 @@ export function useAgentMessages(options) {
         });
     }, [localClient]);
     const sendMessage = useCallback(function sendMessage(payload) {
+        const filteredPayload = Object.assign(Object.assign({}, payload), { messages: payload.messages.filter((e) => !!e.content) });
+        if (filteredPayload.messages.length === 0) {
+            return;
+        }
         if (isSending) {
             return;
         }
         if (method === 'stream') {
-            return sendStreamedMessage(payload);
+            return sendStreamedMessage(filteredPayload);
         }
-        return sendNonStreamedMessage(payload);
+        return sendNonStreamedMessage(filteredPayload);
     }, [method, isSending, sendStreamedMessage, sendNonStreamedMessage]);
     const getMessages = useCallback(function getMessages(before) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -205,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,13 @@
+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;
+    isLoadingError: unknown;
+    passages: Passage[] | undefined;
+    refresh: () => Promise<void>;
+};
+export {};

package/hooks/useAgentPassages/useAgentPassages.js

@@ -0,0 +1,45 @@
+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 [isLoadingError, setIsLoadingError] = 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) {
+            setIsLoadingError(error);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }), [agentId, localClient, setLocalState]);
+    useEffect(() => {
+        if (agentId !== loadedAgentId.current) {
+            setIsLoading(true);
+            void getAgentPassages();
+            loadedAgentId.current = agentId;
+        }
+    }, [agentId, getAgentPassages]);
+    return {
+        isLoading,
+        isLoadingError,
+        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.6",
+  "version": "0.0.8",
   "description": "Letta's react library",
   "private": false,
   "main": "./index.js",

package/src/hooks/useAgentMessages/useAgentMessages.ts

@@ -6,6 +6,7 @@ import { useGlobalLettaConfig } from '../useGlobalLettaConfig/useGlobalLettaConf
 import type { LocalMessagesState } from '../../types';
 import { useCachedState } from '../useCachedState/useCachedState';
 import { useLettaClient } from '../useLettaClient/useLettaClient';
+import { LettaMessageUnion, MessageCreate } from '@letta-ai/letta-client/api';
 
 interface UseAgentOptions {
   client?: LettaClient.Options;
@@ -52,6 +53,17 @@ function dedupeMessages(
   }, []);
 }
 
+function messageCreateToMessageUnion(
+  messages: MessageCreate[]
+): LettaMessageUnion[] {
+  return messages.map((message, idx) => ({
+    messageType: message.role === 'user' ? 'user_message' : 'system_message',
+    content: message.content,
+    date: new Date(),
+    id: `autogenerated_${Date.now()}_${idx}`,
+  }));
+}
+
 interface SendMessagePayload {
   messages: LettaRequest['messages'];
 }
@@ -73,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);
@@ -86,10 +98,24 @@ export function useAgentMessages(options: UseAgentOptions) {
     async function sendNonStreamedMessage(
       sendMessagePayload: SendMessagePayload
     ) {
+      let originalMessageState: LocalMessagesState = localMessages;
       try {
         setIsSending(true);
         setSendingError(null);
 
+        const newMessages = messageCreateToMessageUnion(
+          sendMessagePayload.messages
+        );
+
+        setLocalMessages((prevState) => {
+          originalMessageState = prevState;
+
+          return {
+            ...prevState,
+            messages: [...prevState.messages, ...newMessages],
+          };
+        });
+
         const response = await localClient.agents.messages.create(agentId, {
           ...sendMessagePayload,
           ...messageOptions,
@@ -97,23 +123,39 @@ export function useAgentMessages(options: UseAgentOptions) {
 
         setLocalMessages((prevState) => ({
           ...prevState,
-          messages: [...response.messages, ...prevState.messages],
+          messages: [...prevState.messages, ...response.messages],
         }));
       } catch (e) {
+        setLocalMessages(originalMessageState);
         setSendingError(e);
       } finally {
         setIsSending(false);
       }
     },
-    [localClient]
+    [localClient, localMessages]
   );
 
   const sendStreamedMessage = useCallback(
     async function sendStreamedMessage(sendMessagePayload: SendMessagePayload) {
+      let originalMessageState: LocalMessagesState = localMessages;
+
       try {
         setIsSending(true);
         setSendingError(null);
 
+        const newMessages = messageCreateToMessageUnion(
+          sendMessagePayload.messages
+        );
+
+        setLocalMessages((prevState) => {
+          originalMessageState = prevState;
+
+          return {
+            ...prevState,
+            messages: [...prevState.messages, ...newMessages],
+          };
+        });
+
         const response = await localClient.agents.messages.createStream(
           agentId,
           {
@@ -262,15 +304,24 @@ export function useAgentMessages(options: UseAgentOptions) {
 
   const sendMessage = useCallback(
     function sendMessage(payload: SendMessagePayload) {
+      const filteredPayload = {
+        ...payload,
+        messages: payload.messages.filter((e) => !!e.content),
+      };
+
+      if (filteredPayload.messages.length === 0) {
+        return;
+      }
+
       if (isSending) {
         return;
       }
 
       if (method === 'stream') {
-        return sendStreamedMessage(payload);
+        return sendStreamedMessage(filteredPayload);
       }
 
-      return sendNonStreamedMessage(payload);
+      return sendNonStreamedMessage(filteredPayload);
     },
     [method, isSending, sendStreamedMessage, sendNonStreamedMessage]
   );
@@ -320,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,51 @@
+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 [isLoadingError, setIsLoadingError] = useState<unknown | null>(null);
+
+  const getAgentPassages = useCallback(async () => {
+    try {
+      const state = await localClient.agents.passages.list(agentId);
+
+      setLocalState(state);
+    } catch (error) {
+      setIsLoadingError(error);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [agentId, localClient, setLocalState]);
+
+  useEffect(() => {
+    if (agentId !== loadedAgentId.current) {
+      setIsLoading(true);
+      void getAgentPassages();
+      loadedAgentId.current = agentId;
+    }
+  }, [agentId, getAgentPassages]);
+
+  return {
+    isLoading,
+    isLoadingError,
+    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';