@letta-ai/letta-react 0.0.8 → 0.1.0

package/hooks/useGlobalLettaConfig/useGlobalLettaConfig.d.ts

@@ -1,17 +0,0 @@
-import React, { Dispatch, SetStateAction } from 'react';
-import { LettaClient } from '@letta-ai/letta-client';
-import { type ReactNode } from 'react';
-type CachedData = Record<string, any>;
-interface LettaProviderState {
-    isProviderSet?: boolean;
-    state: LettaClient.Options;
-    cachedData: CachedData;
-    updateCache: Dispatch<SetStateAction<CachedData>>;
-}
-interface LettaProviderProps {
-    options: LettaClient.Options;
-    children: ReactNode;
-}
-export declare function LettaProvider(props: LettaProviderProps): React.JSX.Element;
-export declare function useGlobalLettaConfig(): LettaProviderState;
-export {};

package/hooks/useGlobalLettaConfig/useGlobalLettaConfig.js

@@ -1,22 +0,0 @@
-import React, { useState } from 'react';
-import { createContext, useMemo, useContext } from 'react';
-const LettaContext = createContext({
-    state: {},
-    cachedData: {},
-    updateCache: () => {
-        return;
-    },
-});
-export function LettaProvider(props) {
-    const [cachedData, updateCache] = useState({});
-    const state = useMemo(() => ({
-        state: props.options,
-        cachedData,
-        updateCache,
-        isProviderSet: true,
-    }), [props.options, updateCache, cachedData]);
-    return (React.createElement(LettaContext.Provider, { value: state }, props.children));
-}
-export function useGlobalLettaConfig() {
-    return useContext(LettaContext);
-}

package/hooks/useLettaClient/useLettaClient.d.ts

@@ -1,2 +0,0 @@
-import { LettaClient } from '@letta-ai/letta-client';
-export declare function useLettaClient(localOptions?: LettaClient.Options): LettaClient;

package/hooks/useLettaClient/useLettaClient.js

@@ -1,8 +0,0 @@
-import { useState } from 'react';
-import { LettaClient } from '@letta-ai/letta-client';
-import { useGlobalLettaConfig } from '../useGlobalLettaConfig/useGlobalLettaConfig';
-export function useLettaClient(localOptions = {}) {
-    const globalClient = useGlobalLettaConfig();
-    const [localClient] = useState(() => new LettaClient(Object.assign(Object.assign({}, globalClient.state), localOptions)));
-    return localClient;
-}

package/src/hooks/useAgentMessages/useAgentMessages.ts

@@ -1,394 +0,0 @@
-import { LettaClient, type Letta } from '@letta-ai/letta-client';
-import { useCallback, useEffect, useRef, useState } from 'react';
-import type { LettaRequest } from '@letta-ai/letta-client/api/types/LettaRequest';
-import type { MessagesListRequest } from '@letta-ai/letta-client/api/resources/agents';
-import { useGlobalLettaConfig } from '../useGlobalLettaConfig/useGlobalLettaConfig';
-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;
-  agentId: string;
-  limit?: number;
-  messageOptions?: Omit<MessagesListRequest, 'after' | 'before' | 'limit'>;
-  method?: 'stream' | 'basic';
-}
-
-function extendContent(
-  content: string | Letta.TextContent[],
-  nextContent: string | Letta.TextContent[]
-): string | Letta.TextContent[] {
-  if (typeof content === 'string') {
-    if (typeof nextContent === 'string') {
-      return `${content}${nextContent}`;
-    } else {
-      return `${content}${nextContent.join('')}`;
-    }
-  } else {
-    if (typeof nextContent === 'string') {
-      return [...content, { text: nextContent, type: 'text' }];
-    } else {
-      return [...content, ...nextContent];
-    }
-  }
-}
-
-function dedupeMessages(
-  messages: LocalMessagesState['messages']
-): LocalMessagesState['messages'] {
-  const messageIndex = new Set(
-    messages.map((message) => `${message.id}${message.messageType}`)
-  );
-
-  return messages.filter((message) => {
-    // if we have seen this message before, return false
-    if (messageIndex.has(`${message.id}${message.messageType}`)) {
-      messageIndex.delete(`${message.id}${message.messageType}`);
-      return true;
-    }
-
-    return false;
-  }, []);
-}
-
-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'];
-}
-
-export function useAgentMessages(options: UseAgentOptions) {
-  const {
-    client = {},
-    method = 'stream',
-    messageOptions = {},
-    limit = 20,
-    agentId,
-  } = options;
-  const localClient = useLettaClient(client);
-
-  const [localMessages, setLocalMessages] = useCachedState<LocalMessagesState>(
-    `messages-${agentId}`,
-    {
-      messages: [],
-    }
-  );
-
-  const agentIdMessagesLoadedRef = useRef(false);
-
-  const [isLoading, setIsLoading] = useState(true);
-  const [isFetching, setIsFetching] = useState(false);
-  const [loadingError, setLoadingError] = useState<unknown | null>(null);
-
-  const [isSending, setIsSending] = useState(false);
-  const [sendingError, setSendingError] = useState<unknown | null>(null);
-
-  const sendNonStreamedMessage = useCallback(
-    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,
-        });
-
-        setLocalMessages((prevState) => ({
-          ...prevState,
-          messages: [...prevState.messages, ...response.messages],
-        }));
-      } catch (e) {
-        setLocalMessages(originalMessageState);
-        setSendingError(e);
-      } finally {
-        setIsSending(false);
-      }
-    },
-    [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,
-          {
-            ...sendMessagePayload,
-            ...messageOptions,
-            streamTokens: true,
-          }
-        );
-
-        for await (const nextMessage of response) {
-          if (nextMessage.messageType === 'usage_statistics') {
-            return;
-          }
-          // @ts-expect-error - this is a correct lookup, id does exist
-          if (!nextMessage?.id) {
-            return;
-          }
-
-          setLocalMessages((prevState) => {
-            let hasExistingMessage = false;
-            const nextMessages = prevState.messages.map((prevMessage) => {
-              if (nextMessage.messageType === 'usage_statistics') {
-                return prevMessage;
-              }
-
-              // @ts-expect-error - this is a correct lookup, id does exist
-              if (!prevMessage?.id || !nextMessage?.id) {
-                return prevMessage;
-              }
-
-              // @ts-expect-error - this is a correct lookup, id does exist
-              if (prevMessage.id !== nextMessage.id) {
-                return prevMessage;
-              }
-
-              if (
-                nextMessage.messageType === 'reasoning_message' &&
-                prevMessage.messageType === 'reasoning_message'
-              ) {
-                hasExistingMessage = true;
-
-                return {
-                  ...prevMessage,
-                  ...nextMessage,
-                  reasoning: `${prevMessage.reasoning}${nextMessage.reasoning}`,
-                };
-              }
-
-              if (
-                nextMessage.messageType === 'system_message' &&
-                prevMessage.messageType === 'system_message'
-              ) {
-                hasExistingMessage = true;
-
-                return {
-                  ...prevMessage,
-                  ...nextMessage,
-                  content: extendContent(
-                    prevMessage.content,
-                    nextMessage.content
-                  ),
-                };
-              }
-
-              if (
-                nextMessage.messageType === 'user_message' &&
-                prevMessage.messageType === 'user_message'
-              ) {
-                hasExistingMessage = true;
-
-                return {
-                  ...prevMessage,
-                  ...nextMessage,
-                  content: extendContent(
-                    prevMessage.content,
-                    nextMessage.content
-                  ),
-                };
-              }
-
-              if (
-                nextMessage.messageType === 'assistant_message' &&
-                prevMessage.messageType === 'assistant_message'
-              ) {
-                hasExistingMessage = true;
-
-                return {
-                  ...prevMessage,
-                  ...nextMessage,
-                  content: extendContent(
-                    prevMessage.content,
-                    nextMessage.content
-                  ),
-                };
-              }
-
-              if (
-                nextMessage.messageType === 'tool_call_message' &&
-                prevMessage.messageType === 'tool_call_message'
-              ) {
-                hasExistingMessage = true;
-
-                return {
-                  ...prevMessage,
-                  ...nextMessage,
-                };
-              }
-
-              if (
-                nextMessage.messageType === 'tool_return_message' &&
-                prevMessage.messageType === 'tool_return_message'
-              ) {
-                hasExistingMessage = true;
-                return {
-                  ...prevMessage,
-                  ...nextMessage,
-                };
-              }
-
-              return prevMessage;
-            });
-
-            return {
-              ...prevState,
-              messages: [
-                ...nextMessages,
-                ...(!hasExistingMessage
-                  ? [
-                      {
-                        ...nextMessage,
-                      },
-                    ]
-                  : []),
-              ] as LocalMessagesState['messages'],
-            };
-          });
-        }
-      } catch (e) {
-        setSendingError(e);
-      } finally {
-        setIsSending(false);
-      }
-    },
-    [localClient]
-  );
-
-  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(filteredPayload);
-      }
-
-      return sendNonStreamedMessage(filteredPayload);
-    },
-    [method, isSending, sendStreamedMessage, sendNonStreamedMessage]
-  );
-
-  const getMessages = useCallback(
-    async function getMessages(before?: string) {
-      try {
-        if (isFetching) {
-          return;
-        }
-
-        setLoadingError(null);
-        setIsFetching(true);
-
-        const messages = await localClient.agents.messages.list(agentId, {
-          before,
-          limit: limit + 1,
-          ...messageOptions,
-        });
-
-        const messagesToAdd = messages.slice(1, messages.length);
-        const nextCursor = messages.length > limit ? messages[0] : undefined;
-
-        setLocalMessages((prevState) => ({
-          ...prevState,
-          messages: dedupeMessages([...messagesToAdd, ...prevState.messages]),
-          nextCursor: nextCursor?.id,
-        }));
-      } catch (e) {
-        setLoadingError(e);
-      } finally {
-        setIsFetching(false);
-        setIsLoading(false);
-      }
-    },
-    [localClient, isFetching]
-  );
-
-  const fetchOlderMessages = useCallback(async () => {
-    const nextCursor = localMessages.nextCursor;
-
-    if (!nextCursor) {
-      return;
-    }
-
-    return getMessages(nextCursor);
-  }, [getMessages]);
-
-  useEffect(() => {
-    if (!agentIdMessagesLoadedRef.current) {
-      setIsLoading(true);
-      void getMessages();
-      agentIdMessagesLoadedRef.current = true;
-    }
-  }, []);
-
-  return {
-    messages: localMessages.messages,
-    isLoading,
-    isFetching,
-    isLoadingError: !!loadingError,
-    loadingError,
-    sendMessage,
-    isSending,
-    sendingError,
-    isSendingError: !!sendingError,
-    fetchOlderMessages,
-    hasOlderMessages: localMessages.nextCursor,
-  };
-}

package/src/hooks/useAgentPassages/useAgentPassages.ts

@@ -1,51 +0,0 @@
-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,72 +0,0 @@
-import { useLettaClient } from '../useLettaClient/useLettaClient';
-import type { LettaClient } from '@letta-ai/letta-client';
-import { useCachedState } from '../useCachedState/useCachedState';
-import type { AgentState, UpdateAgent } from '@letta-ai/letta-client/api';
-import { useCallback, useEffect, useRef, useState } from 'react';
-
-interface UseAgentStateOptions {
-  client?: LettaClient.Options;
-  agentId: string;
-}
-
-export function useAgentState(options: UseAgentStateOptions) {
-  const { client, agentId } = options;
-  const localClient = useLettaClient(client);
-
-  const [localState, setLocalState] = useCachedState<AgentState | undefined>(
-    `agent-state-${agentId}`,
-    undefined
-  );
-
-  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 loadedAgentId = useRef<string | null>(null);
-
-  const getAgentState = useCallback(async () => {
-    try {
-      const state = await localClient.agents.retrieve(agentId);
-
-      setLocalState(state);
-    } catch (error) {
-      setLoadingError(error);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [agentId, localClient, setLocalState]);
-
-  const updateAgentState = useCallback(
-    async (state: Partial<UpdateAgent>) => {
-      setIsUpdating(true);
-      try {
-        const response = await localClient.agents.modify(agentId, state);
-
-        setLocalState(response);
-      } catch (error) {
-        setUpdatingError(error);
-      } finally {
-        setIsUpdating(false);
-      }
-    },
-    [agentId, localClient, setLocalState]
-  );
-
-  useEffect(() => {
-    if (agentId !== loadedAgentId.current) {
-      setIsLoading(true);
-      void getAgentState();
-      loadedAgentId.current = agentId;
-    }
-  }, [agentId]);
-
-  return {
-    isLoading,
-    updateAgentState,
-    isUpdating,
-    updatingError,
-    loadingError,
-    agentState: localState,
-    refresh: getAgentState,
-  };
-}

package/src/hooks/useCachedState/useCachedState.ts

@@ -1,30 +0,0 @@
-import { useGlobalLettaConfig } from '../useGlobalLettaConfig/useGlobalLettaConfig';
-import { Dispatch, SetStateAction, useState } from 'react';
-
-export function useCachedState<T>(
-  key: string,
-  defaultValue: T
-): [T, Dispatch<SetStateAction<T>>] {
-  const { isProviderSet, cachedData, updateCache } = useGlobalLettaConfig();
-
-  const [localState, setLocalState] = useState<T>(defaultValue);
-
-  if (!isProviderSet) {
-    return [localState, setLocalState];
-  }
-
-  return [
-    cachedData?.[key] || defaultValue,
-    (value: T) => {
-      updateCache((prevState) => {
-        return {
-          ...prevState,
-          [key]:
-            typeof value === 'function'
-              ? value(prevState?.[key] || defaultValue)
-              : value,
-        };
-      });
-    },
-  ] as [T, Dispatch<SetStateAction<T>>];
-}

package/src/hooks/useGlobalLettaConfig/useGlobalLettaConfig.tsx

@@ -1,49 +0,0 @@
-import React, { Dispatch, SetStateAction, useState } from 'react';
-import { LettaClient } from '@letta-ai/letta-client';
-import { createContext, useMemo, type ReactNode, useContext } from 'react';
-
-type CachedData = Record<string, any>;
-
-interface LettaProviderState {
-  isProviderSet?: boolean;
-  state: LettaClient.Options;
-  cachedData: CachedData;
-  updateCache: Dispatch<SetStateAction<CachedData>>;
-}
-
-const LettaContext = createContext<LettaProviderState>({
-  state: {},
-  cachedData: {},
-  updateCache: () => {
-    return;
-  },
-});
-
-interface LettaProviderProps {
-  options: LettaClient.Options;
-  children: ReactNode;
-}
-
-export function LettaProvider(props: LettaProviderProps) {
-  const [cachedData, updateCache] = useState({});
-
-  const state = useMemo(
-    () => ({
-      state: props.options,
-      cachedData,
-      updateCache,
-      isProviderSet: true,
-    }),
-    [props.options, updateCache, cachedData]
-  );
-
-  return (
-    <LettaContext.Provider value={state}>
-      {props.children}
-    </LettaContext.Provider>
-  );
-}
-
-export function useGlobalLettaConfig() {
-  return useContext(LettaContext);
-}

package/src/hooks/useLettaClient/useLettaClient.ts

@@ -1,17 +0,0 @@
-import { useState } from 'react';
-import { LettaClient } from '@letta-ai/letta-client';
-import { useGlobalLettaConfig } from '../useGlobalLettaConfig/useGlobalLettaConfig';
-
-export function useLettaClient(localOptions: LettaClient.Options = {}) {
-  const globalClient = useGlobalLettaConfig();
-
-  const [localClient] = useState(
-    () =>
-      new LettaClient({
-        ...globalClient.state,
-        ...localOptions,
-      })
-  );
-
-  return localClient;
-}

package/src/types.ts

@@ -1,6 +0,0 @@
-import type { Letta } from '@letta-ai/letta-client';
-
-export interface LocalMessagesState {
-  messages: Letta.LettaMessageUnion[];
-  nextCursor?: string;
-}

package/types.d.ts

@@ -1,5 +0,0 @@
-import type { Letta } from '@letta-ai/letta-client';
-export interface LocalMessagesState {
-    messages: Letta.LettaMessageUnion[];
-    nextCursor?: string;
-}

package/types.js

@@ -1 +0,0 @@
-export {};