letta-nightly 0.7.2.dev20250423222439__py3-none-any.whl → 0.7.3.dev20250424054013__py3-none-any.whl

letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.7.2"
+__version__ = "0.7.3"
 
 # import clients
 from letta.client.client import LocalClient, RESTClient, create_client

letta/agent.py

@@ -332,13 +332,14 @@ class Agent(BaseAgent):
                 log_telemetry(self.logger, "_get_ai_reply create start")
                 # New LLM client flow
                 llm_client = LLMClient.create(
-                    llm_config=self.agent_state.llm_config,
+                    provider=self.agent_state.llm_config.model_endpoint_type,
                     put_inner_thoughts_first=put_inner_thoughts_first,
                 )
 
                 if llm_client and not stream:
                     response = llm_client.send_llm_request(
                         messages=message_sequence,
+                        llm_config=self.agent_state.llm_config,
                         tools=allowed_functions,
                         stream=stream,
                         force_tool_call=force_tool_call,

letta/agents/letta_agent.py

@@ -66,7 +66,7 @@ class LettaAgent(BaseAgent):
         )
         tool_rules_solver = ToolRulesSolver(agent_state.tool_rules)
         llm_client = LLMClient.create(
-            llm_config=agent_state.llm_config,
+            provider=agent_state.llm_config.model_endpoint_type,
             put_inner_thoughts_first=True,
         )
         for step in range(max_steps):
@@ -182,6 +182,7 @@ class LettaAgent(BaseAgent):
 
         response = await llm_client.send_llm_request_async(
             messages=in_context_messages,
+            llm_config=agent_state.llm_config,
             tools=allowed_tools,
             force_tool_call=force_tool_call,
             stream=stream,

letta/agents/letta_agent_batch.py

@@ -156,7 +156,7 @@ class LettaAgentBatch:
 
         log_event(name="init_llm_client")
         llm_client = LLMClient.create(
-            llm_config=agent_states[0].llm_config,
+            provider=agent_states[0].llm_config.model_endpoint_type,
             put_inner_thoughts_first=True,
         )
         agent_llm_config_mapping = {s.id: s.llm_config for s in agent_states}
@@ -272,9 +272,14 @@ class LettaAgentBatch:
             request_status_updates.append(RequestStatusUpdateInfo(llm_batch_id=llm_batch_id, agent_id=aid, request_status=status))
 
             # translate provider‑specific response → OpenAI‑style tool call (unchanged)
-            llm_client = LLMClient.create(llm_config=item.llm_config, put_inner_thoughts_first=True)
+            llm_client = LLMClient.create(
+                provider=item.llm_config.model_endpoint_type,
+                put_inner_thoughts_first=True,
+            )
             tool_call = (
-                llm_client.convert_response_to_chat_completion(response_data=pr.message.model_dump(), input_messages=[])
+                llm_client.convert_response_to_chat_completion(
+                    response_data=pr.message.model_dump(), input_messages=[], llm_config=item.llm_config
+                )
                 .choices[0]
                 .message.tool_calls[0]
             )

letta/agents/voice_agent.py

@@ -90,7 +90,7 @@ class VoiceAgent(BaseAgent):
         # )
         self.message_buffer_limit = message_buffer_limit
         # self.message_buffer_min = message_buffer_min
-        self.offline_memory_agent = EphemeralMemoryAgent(
+        self.sleeptime_memory_agent = EphemeralMemoryAgent(
             agent_id=agent_id, openai_client=openai_client, message_manager=message_manager, agent_manager=agent_manager, actor=actor
         )
 
@@ -372,7 +372,7 @@ class VoiceAgent(BaseAgent):
                 return f"Failed to call tool. Error: {e}", False
 
     async def _recall_memory(self, query, agent_state: AgentState) -> None:
-        results = await self.offline_memory_agent.step([MessageCreate(role="user", content=[TextContent(text=query)])])
+        results = await self.sleeptime_memory_agent.step([MessageCreate(role="user", content=[TextContent(text=query)])])
         target_block = next(b for b in agent_state.memory.blocks if b.label == self.summary_block_label)
         self.block_manager.update_block(
             block_id=target_block.id, block_update=BlockUpdate(value=results[0].content[0].text), actor=self.actor

letta/client/client.py

@@ -85,6 +85,7 @@ class AbstractClient(object):
         description: Optional[str] = None,
         tags: Optional[List[str]] = None,
         message_buffer_autoclear: bool = False,
+        response_format: Optional[ResponseFormatUnion] = None,
     ) -> AgentState:
         raise NotImplementedError
 
@@ -2352,6 +2353,7 @@ class LocalClient(AbstractClient):
         initial_message_sequence: Optional[List[Message]] = None,
         tags: Optional[List[str]] = None,
         message_buffer_autoclear: bool = False,
+        response_format: Optional[ResponseFormatUnion] = None,
     ) -> AgentState:
         """Create an agent
 
@@ -2405,6 +2407,7 @@ class LocalClient(AbstractClient):
             "initial_message_sequence": initial_message_sequence,
             "tags": tags,
             "message_buffer_autoclear": message_buffer_autoclear,
+            "response_format": response_format,
         }
 
         # Only add name if it's not None

letta/functions/functions.py

@@ -2,7 +2,7 @@ import importlib
 import inspect
 from textwrap import dedent  # remove indentation
 from types import ModuleType
-from typing import Dict, List, Optional
+from typing import Dict, List, Literal, Optional
 
 from letta.errors import LettaToolCreateError
 from letta.functions.schema_generator import generate_schema
@@ -20,6 +20,7 @@ def derive_openai_json_schema(source_code: str, name: Optional[str] = None) -> d
             "Optional": Optional,
             "List": List,
             "Dict": Dict,
+            "Literal": Literal,
             # To support Pydantic models
             # "BaseModel": BaseModel,
             # "Field": Field,

letta/functions/schema_generator.py

@@ -5,6 +5,7 @@ from typing import Any, Dict, List, Optional, Type, Union, get_args, get_origin
 from composio.client.collections import ActionParametersModel
 from docstring_parser import parse
 from pydantic import BaseModel
+from typing_extensions import Literal
 
 from letta.functions.mcp_client.types import MCPTool
 
@@ -70,6 +71,10 @@ def type_to_json_schema_type(py_type) -> dict:
             "items": type_to_json_schema_type(args[0]),
         }
 
+    # Handle literals
+    if get_origin(py_type) is Literal:
+        return {"type": "string", "enum": get_args(py_type)}
+
     # Handle object types
     if py_type == dict or origin in (dict, Dict):
         args = get_args(py_type)

letta/llm_api/anthropic_client.py

@@ -43,18 +43,18 @@ logger = get_logger(__name__)
 
 class AnthropicClient(LLMClientBase):
 
-    def request(self, request_data: dict) -> dict:
+    def request(self, request_data: dict, llm_config: LLMConfig) -> dict:
         client = self._get_anthropic_client(async_client=False)
         response = client.beta.messages.create(**request_data, betas=["tools-2024-04-04"])
         return response.model_dump()
 
-    async def request_async(self, request_data: dict) -> dict:
+    async def request_async(self, request_data: dict, llm_config: LLMConfig) -> dict:
         client = self._get_anthropic_client(async_client=True)
         response = await client.beta.messages.create(**request_data, betas=["tools-2024-04-04"])
         return response.model_dump()
 
     @trace_method
-    async def stream_async(self, request_data: dict) -> AsyncStream[BetaRawMessageStreamEvent]:
+    async def stream_async(self, request_data: dict, llm_config: LLMConfig) -> AsyncStream[BetaRawMessageStreamEvent]:
         client = self._get_anthropic_client(async_client=True)
         request_data["stream"] = True
         return await client.beta.messages.create(**request_data, betas=["tools-2024-04-04"])
@@ -310,6 +310,7 @@ class AnthropicClient(LLMClientBase):
         self,
         response_data: dict,
         input_messages: List[PydanticMessage],
+        llm_config: LLMConfig,
     ) -> ChatCompletionResponse:
         """
         Example response from Claude 3:
@@ -411,7 +412,7 @@ class AnthropicClient(LLMClientBase):
                 total_tokens=prompt_tokens + completion_tokens,
             ),
         )
-        if self.llm_config.put_inner_thoughts_in_kwargs:
+        if llm_config.put_inner_thoughts_in_kwargs:
             chat_completion_response = unpack_all_inner_thoughts_from_kwargs(
                 response=chat_completion_response, inner_thoughts_key=INNER_THOUGHTS_KWARG
             )

letta/llm_api/google_ai_client.py

@@ -25,15 +25,15 @@ logger = get_logger(__name__)
 
 class GoogleAIClient(LLMClientBase):
 
-    def request(self, request_data: dict) -> dict:
+    def request(self, request_data: dict, llm_config: LLMConfig) -> dict:
         """
         Performs underlying request to llm and returns raw response.
         """
         # print("[google_ai request]", json.dumps(request_data, indent=2))
 
         url, headers = get_gemini_endpoint_and_headers(
-            base_url=str(self.llm_config.model_endpoint),
-            model=self.llm_config.model,
+            base_url=str(llm_config.model_endpoint),
+            model=llm_config.model,
             api_key=str(model_settings.gemini_api_key),
             key_in_header=True,
             generate_content=True,
@@ -55,7 +55,7 @@ class GoogleAIClient(LLMClientBase):
             tool_objs = [Tool(**t) for t in tools]
             tool_names = [t.function.name for t in tool_objs]
             # Convert to the exact payload style Google expects
-            tools = self.convert_tools_to_google_ai_format(tool_objs)
+            tools = self.convert_tools_to_google_ai_format(tool_objs, llm_config)
         else:
             tool_names = []
 
@@ -88,6 +88,7 @@ class GoogleAIClient(LLMClientBase):
         self,
         response_data: dict,
         input_messages: List[PydanticMessage],
+        llm_config: LLMConfig,
     ) -> ChatCompletionResponse:
         """
         Converts custom response format from llm client into an OpenAI
@@ -150,7 +151,7 @@ class GoogleAIClient(LLMClientBase):
                         assert isinstance(function_args, dict), function_args
 
                         # NOTE: this also involves stripping the inner monologue out of the function
-                        if self.llm_config.put_inner_thoughts_in_kwargs:
+                        if llm_config.put_inner_thoughts_in_kwargs:
                             from letta.local_llm.constants import INNER_THOUGHTS_KWARG
 
                             assert INNER_THOUGHTS_KWARG in function_args, f"Couldn't find inner thoughts in function args:\n{function_call}"
@@ -259,49 +260,14 @@ class GoogleAIClient(LLMClientBase):
             return ChatCompletionResponse(
                 id=response_id,
                 choices=choices,
-                model=self.llm_config.model,  # NOTE: Google API doesn't pass back model in the response
+                model=llm_config.model,  # NOTE: Google API doesn't pass back model in the response
                 created=get_utc_time_int(),
                 usage=usage,
             )
         except KeyError as e:
             raise e
 
-    def _clean_google_ai_schema_properties(self, schema_part: dict):
-        """Recursively clean schema parts to remove unsupported Google AI keywords."""
-        if not isinstance(schema_part, dict):
-            return
-
-        # Per https://ai.google.dev/gemini-api/docs/function-calling?example=meeting#notes_and_limitations
-        # * Only a subset of the OpenAPI schema is supported.
-        # * Supported parameter types in Python are limited.
-        unsupported_keys = ["default", "exclusiveMaximum", "exclusiveMinimum"]
-        keys_to_remove_at_this_level = [key for key in unsupported_keys if key in schema_part]
-        for key_to_remove in keys_to_remove_at_this_level:
-            logger.warning(f"Removing unsupported keyword 	'{key_to_remove}' from schema part.")
-            del schema_part[key_to_remove]
-
-        if schema_part.get("type") == "string" and "format" in schema_part:
-            allowed_formats = ["enum", "date-time"]
-            if schema_part["format"] not in allowed_formats:
-                logger.warning(f"Removing unsupported format 	'{schema_part['format']}' for string type. Allowed: {allowed_formats}")
-                del schema_part["format"]
-
-        # Check properties within the current level
-        if "properties" in schema_part and isinstance(schema_part["properties"], dict):
-            for prop_name, prop_schema in schema_part["properties"].items():
-                self._clean_google_ai_schema_properties(prop_schema)
-
-        # Check items within arrays
-        if "items" in schema_part and isinstance(schema_part["items"], dict):
-            self._clean_google_ai_schema_properties(schema_part["items"])
-
-        # Check within anyOf, allOf, oneOf lists
-        for key in ["anyOf", "allOf", "oneOf"]:
-            if key in schema_part and isinstance(schema_part[key], list):
-                for item_schema in schema_part[key]:
-                    self._clean_google_ai_schema_properties(item_schema)
-
-    def convert_tools_to_google_ai_format(self, tools: List[Tool]) -> List[dict]:
+    def convert_tools_to_google_ai_format(self, tools: List[Tool], llm_config: LLMConfig) -> List[dict]:
         """
         OpenAI style:
         "tools": [{
@@ -365,7 +331,7 @@ class GoogleAIClient(LLMClientBase):
                 self._clean_google_ai_schema_properties(func["parameters"])
 
             # Add inner thoughts
-            if self.llm_config.put_inner_thoughts_in_kwargs:
+            if llm_config.put_inner_thoughts_in_kwargs:
                 from letta.local_llm.constants import INNER_THOUGHTS_KWARG, INNER_THOUGHTS_KWARG_DESCRIPTION
 
                 func["parameters"]["properties"][INNER_THOUGHTS_KWARG] = {

letta/llm_api/google_vertex_client.py

@@ -18,7 +18,7 @@ from letta.utils import get_tool_call_id
 
 class GoogleVertexClient(GoogleAIClient):
 
-    def request(self, request_data: dict) -> dict:
+    def request(self, request_data: dict, llm_config: LLMConfig) -> dict:
         """
         Performs underlying request to llm and returns raw response.
         """
@@ -29,7 +29,7 @@ class GoogleVertexClient(GoogleAIClient):
             http_options={"api_version": "v1"},
         )
         response = client.models.generate_content(
-            model=self.llm_config.model,
+            model=llm_config.model,
             contents=request_data["contents"],
             config=request_data["config"],
         )
@@ -45,7 +45,7 @@ class GoogleVertexClient(GoogleAIClient):
         """
         Constructs a request object in the expected data format for this client.
         """
-        request_data = super().build_request_data(messages, self.llm_config, tools, force_tool_call)
+        request_data = super().build_request_data(messages, llm_config, tools, force_tool_call)
         request_data["config"] = request_data.pop("generation_config")
         request_data["config"]["tools"] = request_data.pop("tools")
 
@@ -75,6 +75,7 @@ class GoogleVertexClient(GoogleAIClient):
         self,
         response_data: dict,
         input_messages: List[PydanticMessage],
+        llm_config: LLMConfig,
     ) -> ChatCompletionResponse:
         """
         Converts custom response format from llm client into an OpenAI
@@ -136,7 +137,7 @@ class GoogleVertexClient(GoogleAIClient):
                         assert isinstance(function_args, dict), function_args
 
                         # NOTE: this also involves stripping the inner monologue out of the function
-                        if self.llm_config.put_inner_thoughts_in_kwargs:
+                        if llm_config.put_inner_thoughts_in_kwargs:
                             from letta.local_llm.constants import INNER_THOUGHTS_KWARG
 
                             assert INNER_THOUGHTS_KWARG in function_args, f"Couldn't find inner thoughts in function args:\n{function_call}"
@@ -233,7 +234,7 @@ class GoogleVertexClient(GoogleAIClient):
             return ChatCompletionResponse(
                 id=response_id,
                 choices=choices,
-                model=self.llm_config.model,  # NOTE: Google API doesn't pass back model in the response
+                model=llm_config.model,  # NOTE: Google API doesn't pass back model in the response
                 created=get_utc_time_int(),
                 usage=usage,
             )

letta/llm_api/llm_client.py

@@ -1,7 +1,7 @@
 from typing import Optional
 
 from letta.llm_api.llm_client_base import LLMClientBase
-from letta.schemas.llm_config import LLMConfig
+from letta.schemas.enums import ProviderType
 
 
 class LLMClient:
@@ -9,17 +9,15 @@ class LLMClient:
 
     @staticmethod
     def create(
-        llm_config: LLMConfig,
+        provider: ProviderType,
         put_inner_thoughts_first: bool = True,
     ) -> Optional[LLMClientBase]:
         """
         Create an LLM client based on the model endpoint type.
 
         Args:
-            llm_config: Configuration for the LLM model
+            provider: The model endpoint type
             put_inner_thoughts_first: Whether to put inner thoughts first in the response
-            use_structured_output: Whether to use structured output
-            use_tool_naming: Whether to use tool naming
 
         Returns:
             An instance of LLMClientBase subclass
@@ -27,33 +25,29 @@ class LLMClient:
         Raises:
             ValueError: If the model endpoint type is not supported
         """
-        match llm_config.model_endpoint_type:
-            case "google_ai":
+        match provider:
+            case ProviderType.google_ai:
                 from letta.llm_api.google_ai_client import GoogleAIClient
 
                 return GoogleAIClient(
-                    llm_config=llm_config,
                     put_inner_thoughts_first=put_inner_thoughts_first,
                 )
-            case "google_vertex":
+            case ProviderType.google_vertex:
                 from letta.llm_api.google_vertex_client import GoogleVertexClient
 
                 return GoogleVertexClient(
-                    llm_config=llm_config,
                     put_inner_thoughts_first=put_inner_thoughts_first,
                 )
-            case "anthropic":
+            case ProviderType.anthropic:
                 from letta.llm_api.anthropic_client import AnthropicClient
 
                 return AnthropicClient(
-                    llm_config=llm_config,
                     put_inner_thoughts_first=put_inner_thoughts_first,
                 )
-            case "openai":
+            case ProviderType.openai:
                 from letta.llm_api.openai_client import OpenAIClient
 
                 return OpenAIClient(
-                    llm_config=llm_config,
                     put_inner_thoughts_first=put_inner_thoughts_first,
                 )
             case _:

letta/llm_api/llm_client_base.py

@@ -20,17 +20,16 @@ class LLMClientBase:
 
     def __init__(
         self,
-        llm_config: LLMConfig,
         put_inner_thoughts_first: Optional[bool] = True,
         use_tool_naming: bool = True,
     ):
-        self.llm_config = llm_config
         self.put_inner_thoughts_first = put_inner_thoughts_first
         self.use_tool_naming = use_tool_naming
 
     def send_llm_request(
         self,
         messages: List[Message],
+        llm_config: LLMConfig,
         tools: Optional[List[dict]] = None,  # TODO: change to Tool object
         stream: bool = False,
         force_tool_call: Optional[str] = None,
@@ -40,23 +39,24 @@ class LLMClientBase:
         If stream=True, returns a Stream[ChatCompletionChunk] that can be iterated over.
         Otherwise returns a ChatCompletionResponse.
         """
-        request_data = self.build_request_data(messages, self.llm_config, tools, force_tool_call)
+        request_data = self.build_request_data(messages, llm_config, tools, force_tool_call)
 
         try:
             log_event(name="llm_request_sent", attributes=request_data)
             if stream:
-                return self.stream(request_data)
+                return self.stream(request_data, llm_config)
             else:
-                response_data = self.request(request_data)
+                response_data = self.request(request_data, llm_config)
             log_event(name="llm_response_received", attributes=response_data)
         except Exception as e:
             raise self.handle_llm_error(e)
 
-        return self.convert_response_to_chat_completion(response_data, messages)
+        return self.convert_response_to_chat_completion(response_data, messages, llm_config)
 
     async def send_llm_request_async(
         self,
         messages: List[Message],
+        llm_config: LLMConfig,
         tools: Optional[List[dict]] = None,  # TODO: change to Tool object
         stream: bool = False,
         force_tool_call: Optional[str] = None,
@@ -66,19 +66,19 @@ class LLMClientBase:
         If stream=True, returns an AsyncStream[ChatCompletionChunk] that can be async iterated over.
         Otherwise returns a ChatCompletionResponse.
         """
-        request_data = self.build_request_data(messages, self.llm_config, tools, force_tool_call)
+        request_data = self.build_request_data(messages, llm_config, tools, force_tool_call)
 
         try:
             log_event(name="llm_request_sent", attributes=request_data)
             if stream:
-                return await self.stream_async(request_data)
+                return await self.stream_async(request_data, llm_config)
             else:
-                response_data = await self.request_async(request_data)
+                response_data = await self.request_async(request_data, llm_config)
             log_event(name="llm_response_received", attributes=response_data)
         except Exception as e:
             raise self.handle_llm_error(e)
 
-        return self.convert_response_to_chat_completion(response_data, messages)
+        return self.convert_response_to_chat_completion(response_data, messages, llm_config)
 
     async def send_llm_batch_request_async(
         self,
@@ -102,14 +102,14 @@ class LLMClientBase:
         raise NotImplementedError
 
     @abstractmethod
-    def request(self, request_data: dict) -> dict:
+    def request(self, request_data: dict, llm_config: LLMConfig) -> dict:
         """
         Performs underlying request to llm and returns raw response.
         """
         raise NotImplementedError
 
     @abstractmethod
-    async def request_async(self, request_data: dict) -> dict:
+    async def request_async(self, request_data: dict, llm_config: LLMConfig) -> dict:
         """
         Performs underlying request to llm and returns raw response.
         """
@@ -120,6 +120,7 @@ class LLMClientBase:
         self,
         response_data: dict,
         input_messages: List[Message],
+        llm_config: LLMConfig,
     ) -> ChatCompletionResponse:
         """
         Converts custom response format from llm client into an OpenAI
@@ -128,18 +129,18 @@ class LLMClientBase:
         raise NotImplementedError
 
     @abstractmethod
-    def stream(self, request_data: dict) -> Stream[ChatCompletionChunk]:
+    def stream(self, request_data: dict, llm_config: LLMConfig) -> Stream[ChatCompletionChunk]:
         """
         Performs underlying streaming request to llm and returns raw response.
         """
-        raise NotImplementedError(f"Streaming is not supported for {self.llm_config.model_endpoint_type}")
+        raise NotImplementedError(f"Streaming is not supported for {llm_config.model_endpoint_type}")
 
     @abstractmethod
-    async def stream_async(self, request_data: dict) -> AsyncStream[ChatCompletionChunk]:
+    async def stream_async(self, request_data: dict, llm_config: LLMConfig) -> AsyncStream[ChatCompletionChunk]:
         """
         Performs underlying streaming request to llm and returns raw response.
         """
-        raise NotImplementedError(f"Streaming is not supported for {self.llm_config.model_endpoint_type}")
+        raise NotImplementedError(f"Streaming is not supported for {llm_config.model_endpoint_type}")
 
     @abstractmethod
     def handle_llm_error(self, e: Exception) -> Exception:

letta/llm_api/openai_client.py

@@ -62,11 +62,11 @@ def supports_parallel_tool_calling(model: str) -> bool:
 
 
 class OpenAIClient(LLMClientBase):
-    def _prepare_client_kwargs(self) -> dict:
+    def _prepare_client_kwargs(self, llm_config: LLMConfig) -> dict:
         api_key = model_settings.openai_api_key or os.environ.get("OPENAI_API_KEY")
         # supposedly the openai python client requires a dummy API key
         api_key = api_key or "DUMMY_API_KEY"
-        kwargs = {"api_key": api_key, "base_url": self.llm_config.model_endpoint}
+        kwargs = {"api_key": api_key, "base_url": llm_config.model_endpoint}
 
         return kwargs
 
@@ -115,7 +115,7 @@ class OpenAIClient(LLMClientBase):
         # TODO(matt) move into LLMConfig
         # TODO: This vllm checking is very brittle and is a patch at most
         tool_choice = None
-        if llm_config.model_endpoint == "https://inference.memgpt.ai" or (llm_config.handle and "vllm" in self.llm_config.handle):
+        if llm_config.model_endpoint == "https://inference.memgpt.ai" or (llm_config.handle and "vllm" in llm_config.handle):
             tool_choice = "auto"  # TODO change to "required" once proxy supports it
         elif tools:
             # only set if tools is non-Null
@@ -152,20 +152,20 @@ class OpenAIClient(LLMClientBase):
 
         return data.model_dump(exclude_unset=True)
 
-    def request(self, request_data: dict) -> dict:
+    def request(self, request_data: dict, llm_config: LLMConfig) -> dict:
         """
         Performs underlying synchronous request to OpenAI API and returns raw response dict.
         """
-        client = OpenAI(**self._prepare_client_kwargs())
+        client = OpenAI(**self._prepare_client_kwargs(llm_config))
 
         response: ChatCompletion = client.chat.completions.create(**request_data)
         return response.model_dump()
 
-    async def request_async(self, request_data: dict) -> dict:
+    async def request_async(self, request_data: dict, llm_config: LLMConfig) -> dict:
         """
         Performs underlying asynchronous request to OpenAI API and returns raw response dict.
         """
-        client = AsyncOpenAI(**self._prepare_client_kwargs())
+        client = AsyncOpenAI(**self._prepare_client_kwargs(llm_config))
         response: ChatCompletion = await client.chat.completions.create(**request_data)
         return response.model_dump()
 
@@ -173,6 +173,7 @@ class OpenAIClient(LLMClientBase):
         self,
         response_data: dict,
         input_messages: List[PydanticMessage],  # Included for consistency, maybe used later
+        llm_config: LLMConfig,
     ) -> ChatCompletionResponse:
         """
         Converts raw OpenAI response dict into the ChatCompletionResponse Pydantic model.
@@ -183,30 +184,30 @@ class OpenAIClient(LLMClientBase):
         chat_completion_response = ChatCompletionResponse(**response_data)
 
         # Unpack inner thoughts if they were embedded in function arguments
-        if self.llm_config.put_inner_thoughts_in_kwargs:
+        if llm_config.put_inner_thoughts_in_kwargs:
             chat_completion_response = unpack_all_inner_thoughts_from_kwargs(
                 response=chat_completion_response, inner_thoughts_key=INNER_THOUGHTS_KWARG
             )
 
         # If we used a reasoning model, create a content part for the ommitted reasoning
-        if is_openai_reasoning_model(self.llm_config.model):
+        if is_openai_reasoning_model(llm_config.model):
             chat_completion_response.choices[0].message.ommitted_reasoning_content = True
 
         return chat_completion_response
 
-    def stream(self, request_data: dict) -> Stream[ChatCompletionChunk]:
+    def stream(self, request_data: dict, llm_config: LLMConfig) -> Stream[ChatCompletionChunk]:
         """
         Performs underlying streaming request to OpenAI and returns the stream iterator.
         """
-        client = OpenAI(**self._prepare_client_kwargs())
+        client = OpenAI(**self._prepare_client_kwargs(llm_config))
         response_stream: Stream[ChatCompletionChunk] = client.chat.completions.create(**request_data, stream=True)
         return response_stream
 
-    async def stream_async(self, request_data: dict) -> AsyncStream[ChatCompletionChunk]:
+    async def stream_async(self, request_data: dict, llm_config: LLMConfig) -> AsyncStream[ChatCompletionChunk]:
         """
         Performs underlying asynchronous streaming request to OpenAI and returns the async stream iterator.
         """
-        client = AsyncOpenAI(**self._prepare_client_kwargs())
+        client = AsyncOpenAI(**self._prepare_client_kwargs(llm_config))
         response_stream: AsyncStream[ChatCompletionChunk] = await client.chat.completions.create(**request_data, stream=True)
         return response_stream
 

letta/memory.py

@@ -79,7 +79,7 @@ def summarize_messages(
     llm_config_no_inner_thoughts.put_inner_thoughts_in_kwargs = False
 
     llm_client = LLMClient.create(
-        llm_config=llm_config_no_inner_thoughts,
+        provider=llm_config_no_inner_thoughts.model_endpoint_type,
         put_inner_thoughts_first=False,
     )
     # try to use new client, otherwise fallback to old flow
@@ -87,6 +87,7 @@ def summarize_messages(
     if llm_client:
         response = llm_client.send_llm_request(
             messages=message_sequence,
+            llm_config=llm_config_no_inner_thoughts,
             stream=False,
         )
     else:

letta/personas/examples/sleeptime_memory_persona.txt

@@ -0,0 +1,5 @@
+I am an expert conversation memory agent that can do the following:
+- Consolidate memories into more concise blocks
+- Identify patterns in user behavior
+- Make inferences based on the memory
+I manage the memory blocks such that they contain everything that is important about the conversation.

letta/schemas/enums.py

@@ -3,6 +3,9 @@ from enum import Enum
 
 class ProviderType(str, Enum):
     anthropic = "anthropic"
+    google_ai = "google_ai"
+    google_vertex = "google_vertex"
+    openai = "openai"
 
 
 class MessageRole(str, Enum):

letta/server/server.py

@@ -766,12 +766,7 @@ class SyncServer(Server):
             memory_blocks=[
                 CreateBlock(
                     label="memory_persona",
-                    value=(
-                        "I am an expert conversation memory manager. "
-                        "I manage the memory blocks such that they "
-                        "contain everything that is important about "
-                        "the conversation."
-                    ),
+                    value=get_persona_text("sleeptime_memory_persona"),
                 ),
             ],
             llm_config=main_agent.llm_config,

letta/services/agent_manager.py

@@ -236,6 +236,7 @@ class AgentManager:
                     base_template_id=agent_create.base_template_id,
                     message_buffer_autoclear=agent_create.message_buffer_autoclear,
                     enable_sleeptime=agent_create.enable_sleeptime,
+                    response_format=agent_create.response_format,
                     created_by_id=actor.id,
                     last_updated_by_id=actor.id,
                 )

{letta_nightly-0.7.2.dev20250423222439.dist-info → letta_nightly-0.7.3.dev20250424054013.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.7.2.dev20250423222439
+Version: 0.7.3.dev20250424054013
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.7.2.dev20250423222439.dist-info → letta_nightly-0.7.3.dev20250424054013.dist-info}/RECORD

@@ -1,21 +1,21 @@
-letta/__init__.py,sha256=Vn0bUZvcMtIJHa5k4fpXa2QL1Fd05BUjvVsE1nwn6Xw,917
+letta/__init__.py,sha256=ShZtnPIM0QOgxGGKrq6VfF4qXaE6_ZDoAQ6zXI0RepM,917
 letta/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
-letta/agent.py,sha256=FLb_4sYByecGSw38nmBdpb7qbJh6LZY-k-bC4HDQREU,72088
+letta/agent.py,sha256=YmAkpFXHwZ0UhoatyIE-ZrV-kQDwg7f4A1o4cymoI-Y,72170
 letta/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/agents/base_agent.py,sha256=yjB1Yz6L-9hTFinqkvyf6c-8dDX9O4u8VCrKrvA4G3s,2348
 letta/agents/ephemeral_agent.py,sha256=el-SUF_16vv_7OouIR-6z0pAE9Yc0PLibygvfCKwqfo,2736
 letta/agents/ephemeral_memory_agent.py,sha256=tVRsL18EvruNyrhzPkzLqiptfWa9jAC2GmSjUf5zKQo,4821
 letta/agents/helpers.py,sha256=sYfjJLCEQg0aaKDRIJ2Xm_fG1yivCB9wU6bSskZMPKg,2568
-letta/agents/letta_agent.py,sha256=hEcTc9RE9sim_P-Fj08cEPgT-6QvRfSAQB6zK_s_0a8,17751
-letta/agents/letta_agent_batch.py,sha256=TFOaWEodfhowylbcwK2Yz2mDe1pcduKZ9gW-eGckT1w,22750
-letta/agents/voice_agent.py,sha256=ywc6zsyEjeRxmhCwD1-opO9mAEhr2l9PRV3lf9y7HDc,17330
+letta/agents/letta_agent.py,sha256=9kOJW8hU_UhRwaVujYBWxVxsOGbh367xfdymI81RdNI,17816
+letta/agents/letta_agent_batch.py,sha256=YsuYKwanRAmSPwmT5NVG3oIyOjlOz08hrQgpgRNhXt0,22899
+letta/agents/voice_agent.py,sha256=qzDw7MWQYwxsqOT4nIJ9OSl72n7b2Xy3ZUqc2_AEP5M,17334
 letta/benchmark/benchmark.py,sha256=ebvnwfp3yezaXOQyGXkYCDYpsmre-b9hvNtnyx4xkG0,3701
 letta/benchmark/constants.py,sha256=aXc5gdpMGJT327VuxsT5FngbCK2J41PQYeICBO7g_RE,536
 letta/cli/cli.py,sha256=zJz78-qDUz-depb7VQWkg87RBKiETQU4h9DI6ukQBa8,16477
 letta/cli/cli_config.py,sha256=MNMhIAAjXiAy2gX_gAtqiY0Ya6VNbzXJWjIcRVEZa-k,8597
 letta/cli/cli_load.py,sha256=vER0PwpHnsCZtCHcR2YjEXM-VVuO9jhfQibdo3gI3S0,2703
 letta/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/client/client.py,sha256=BzGlA6Z1FB0zi6-17x7eus5l_GPvmnnKiPFl4D-kGaE,138050
+letta/client/client.py,sha256=nF2KxkTMp7JUx_ITLKhsU14z0e9Uwwkux3heskQmfeE,138224
 letta/client/streaming.py,sha256=UsDS_tDTsA3HgYryIDvGGmx_dWfnfQwtmEwLi4Z89Ik,4701
 letta/client/utils.py,sha256=VCGV-op5ZSmurd4yw7Vhf93XDQ0BkyBT8qsuV7EqfiU,2859
 letta/config.py,sha256=JFGY4TWW0Wm5fTbZamOwWqk5G8Nn-TXyhgByGoAqy2c,12375
@@ -29,7 +29,7 @@ letta/functions/ast_parsers.py,sha256=CQI0rUoIXcLKAev_GYrXcldRIGN5ZQtk5u4FLoHe5s
 letta/functions/function_sets/base.py,sha256=Z-trOG7dKbOWpJlsEBNSGlwcQnPuRXqnQ9NMed98nbY,16392
 letta/functions/function_sets/extras.py,sha256=mG7jCd2RUsf1w9G8mVcv26twJWpiDhbWI6VvnLZoEOk,4899
 letta/functions/function_sets/multi_agent.py,sha256=de2_wNVpWQviF1-XUkrliFvVresj6cOw7nOB61nGGW8,6899
-letta/functions/functions.py,sha256=NyWLh7a-f4mXti5vM1oWDwXzfA58VmVVqL03O9vosKY,5672
+letta/functions/functions.py,sha256=No9DSb_BsXD3xwyODiEZRfmudKI3KoEK4bOtVQXFiJo,5713
 letta/functions/helpers.py,sha256=q-Ipwp4jB0zrw2slAVWBt2QsYbPoDkTq8PdFVoYYB6I,28043
 letta/functions/interface.py,sha256=pN1gpDnLISW44gRcic1IX6I6pDwOT9UbkST_4ICuMvQ,2936
 letta/functions/mcp_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -38,7 +38,7 @@ letta/functions/mcp_client/exceptions.py,sha256=IE5SLCuMK7hK9V1QsJafPo6u0S0OwqRv
 letta/functions/mcp_client/sse_client.py,sha256=XOLnWIcrjBEkZ-IksgnHKSdVds3pC2E8OPkIhCNxloo,1470
 letta/functions/mcp_client/stdio_client.py,sha256=2oouLGphu4S15OrYj97n9_ZYZo-GMRWNLWwaw-U4TNs,4562
 letta/functions/mcp_client/types.py,sha256=nmcnQn2EpxXzXg5_pWPsHZobfxO6OucaUgz1bVvam7o,1411
-letta/functions/schema_generator.py,sha256=4hiDQpHemyfKWME-5X6xJuSiv7g9V_BgAPFegohHBIM,22327
+letta/functions/schema_generator.py,sha256=OoXDHd5oZMNjljZJplEIMOMmKvxO_rfDFtAi-E9EHMA,22488
 letta/groups/dynamic_multi_agent.py,sha256=OLCxhICFLYyx8wjKGPr1INc6pniEuk4YGZyZhq2vkiY,12230
 letta/groups/helpers.py,sha256=Cof7vfZMOT2gApYpROpiAyKSKrofP1UPJxZQWFcZaqA,4336
 letta/groups/round_robin_multi_agent.py,sha256=uUJff0bO68udOREiKFWeS7eEQlk3bF7hcfLSFXMScqI,6999
@@ -67,22 +67,22 @@ letta/jobs/scheduler.py,sha256=nsXQTpW2YfVC8g6X35RUjguLVPV0NOku2Zt8SdDSnhg,2154
 letta/jobs/types.py,sha256=K8GKEnqEgAT6Kq4F2hUrBC4ZAFM9OkfOjVMStzxKuXQ,742
 letta/llm_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/llm_api/anthropic.py,sha256=gF8IbHlNSjD2vSw7MukHEJqWAUr9h0kx5OzF-C0AG0s,44521
-letta/llm_api/anthropic_client.py,sha256=9xrto08r_uU9YV7_xtwMkrM8tqiDNmaFaXKhBNAouYc,24323
+letta/llm_api/anthropic_client.py,sha256=9nQdoONlt_stvgX3hl30sgzv66_Yk_PeAnvOEO2Msgg,24418
 letta/llm_api/aws_bedrock.py,sha256=kAPpKPRe4ZUa6fkxFbo8xwQgq4fJf3QoZEAP1LOCfaw,4168
 letta/llm_api/azure_openai.py,sha256=YAkXwKyfnJFNhB45pkJVFsoxUNB_M74rQYchtw_CN6I,5099
 letta/llm_api/azure_openai_constants.py,sha256=ZaR2IasJThijG0uhLKJThrixdAxLPD2IojfeaJ-KQMQ,294
 letta/llm_api/cohere.py,sha256=IZ6LXyOFMYjWHTeNG9lvFxCdV_NIl0hY2q9SPFYXNkQ,14849
 letta/llm_api/deepseek.py,sha256=b1mSW8gnBrpAI8d2GcBpDyLYDnuC-P1UP6xJPalfQS4,12456
-letta/llm_api/google_ai_client.py,sha256=xkxPnUEJtcajV4ZsiHRr0y7caW8sQ586nnr1XOilejI,22694
+letta/llm_api/google_ai_client.py,sha256=FGNmoMPV1ciZ6opeRcpSqgu_t9P66kM4aapaN0wfQpw,20792
 letta/llm_api/google_constants.py,sha256=1dqwt-YwdYGnAHV5rIPfGHfE3ybPzSn_48vlNYfd-bk,588
-letta/llm_api/google_vertex_client.py,sha256=YnDlqADuRdBoUCpsh_pj05UfpGybG71pEiaqsJxXJfk,11611
+letta/llm_api/google_vertex_client.py,sha256=lTfAUTPSqwe-cuOoEgUehdwg2ZVHLqXRiu-sj6g8PJg,11645
 letta/llm_api/helpers.py,sha256=sLYv30UnKBRVPuhU_KDXfKFdbkUONiDAyVEwGr86l3A,16780
 letta/llm_api/llm_api_tools.py,sha256=s1n3YDGp-ShHOzxeuQ1BOje0oh7H_yGefRVwFXsc_A8,27547
-letta/llm_api/llm_client.py,sha256=PWnzdwD_7TMmbBuZnCWt10pJL4WXLCsQ3yS9-Y3Nh-c,2112
-letta/llm_api/llm_client_base.py,sha256=ea4YyfZQqmkm6IcG7U3nu86VX820eXbX9gWuw5hDdzg,5766
+letta/llm_api/llm_client.py,sha256=JpSZWLoJsHdjlfavyhNyNf_j7N5Ks2DktDuA2PyQO70,1827
+letta/llm_api/llm_client_base.py,sha256=-RSVo4986iNLbOyUR3IKggKL2zWD4IBsr8ZbF8p28Ac,5935
 letta/llm_api/mistral.py,sha256=fHdfD9ug-rQIk2qn8tRKay1U6w9maF11ryhKi91FfXM,1593
 letta/llm_api/openai.py,sha256=qTTOyI6qQA-KmS1atmy2giSyT1XpjysqkQZbbUY7eKs,23425
-letta/llm_api/openai_client.py,sha256=sM7sgYpqmqZHqbD3q9mDeB9N9RPTlf87bYhzPWGQWJA,13111
+letta/llm_api/openai_client.py,sha256=qm9-zgJIlUnP9vmdfFBR2BCOenzf2aYGEsBVIBzKgB8,13277
 letta/local_llm/README.md,sha256=hFJyw5B0TU2jrh9nb0zGZMgdH-Ei1dSRfhvPQG_NSoU,168
 letta/local_llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/local_llm/chat_completion_proxy.py,sha256=gc5gaKoHP8QaWRulDeEYPk7Onl8KdCBmpF2l9znXKeQ,13853
@@ -122,7 +122,7 @@ letta/local_llm/webui/legacy_settings.py,sha256=BLmd3TSx5StnY3ibjwaxYATPt_Lvq-o1
 letta/local_llm/webui/settings.py,sha256=gmLHfiOl1u4JmlAZU2d2O8YKF9lafdakyjwR_ftVPh8,552
 letta/log.py,sha256=FbFwU9KEX7k0FBYhPl7fJ6uQ3NO3-ZbsnM2OpcTFXjo,2217
 letta/main.py,sha256=_agyaYPJq70OL0goNwO34zENL2KupnTgqlg-HVcNaTY,15379
-letta/memory.py,sha256=NC6YDx9OY-bUS_6GTyzpcjeNhxX-ZqssImvIQmeWHMg,4111
+letta/memory.py,sha256=E3Xa_hiqnuHmsq0XOGUqUoxQm_es7EWYCtbOFAS23h0,4182
 letta/openai_backcompat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/openai_backcompat/openai_object.py,sha256=GSzeCTwLpLD2fH4X8wVqzwdmoTjKK2I4PnriBY453lc,13505
 letta/orm/__all__.py,sha256=2gh2MZTkA3Hw67VWVKK3JIStJOqTeLdpCvYSVYNeEDA,692
@@ -167,11 +167,11 @@ letta/personas/examples/google_search_persona.txt,sha256=RyObU80MIk2oeJJDWOK1aX5
 letta/personas/examples/memgpt_doc.txt,sha256=_McafHuYkJYAnBFwvu_LVEaSEQGbs0flCgJIIJYlZgc,425
 letta/personas/examples/memgpt_starter.txt,sha256=x-fEozRrfUVlCJUEjkwHDCGeBb2z50d0jd6QF78SHKQ,160
 letta/personas/examples/o1_persona.txt,sha256=VKSDXuMaiOg-fnaiMFnEauYy85q88LJKW0y8N7V5j3g,339
-letta/personas/examples/offline_memory_persona.txt,sha256=u2ZK9X72hxA7BbKRzkailEVisFaICdHhLi6hBNS4kC0,178
 letta/personas/examples/sam.txt,sha256=V1-3-x9gud_opkeNL3XPXyCyJySCp4sYi-XTFD26gnc,1223
 letta/personas/examples/sam_pov.txt,sha256=NUZOfkz91aBwnv2M3iDsPZYf8MlaGF0zQB0nFOUC56k,1171
 letta/personas/examples/sam_simple_pov_gpt35.txt,sha256=vP6R5GxPeO0QuMartRs3DBfSs1LFWW8CHNqo7II0BuA,1053
 letta/personas/examples/sleeptime_doc_persona.txt,sha256=vVlo5bifdpIc2phV0vgdKCWeDIpun_5vQYLDEaurJQk,351
+letta/personas/examples/sleeptime_memory_persona.txt,sha256=ueMQ7ki7IEs-YUvuOH_F0dQoHJChw1w09B9kMBIM4dU,294
 letta/personas/examples/sqldb/test.db,sha256=MU5Di7exdYdtQH62Q8dfkM6YpckkcwHDiO1fed98XBY,8192
 letta/prompts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/prompts/gpt_summarize.py,sha256=sOUKcVrTRbX00yLOZVVhwKgduRRVCY64l80ptOY4Ghg,1125
@@ -197,7 +197,7 @@ letta/schemas/agent.py,sha256=PJIQJW5fx4EGD_3Q3wbl4scoISSXqMVqr7Yvgvk-ZTE,17263
 letta/schemas/block.py,sha256=rMWflyj982qW86dQK-9saXBHKaLCu3aUG2gQTckG3Ik,4984
 letta/schemas/embedding_config.py,sha256=ufboqW9ctSBJdhwzJRbrGtTzOTwSKfT0LY0mowpr6fs,3398
 letta/schemas/embedding_config_overrides.py,sha256=lkTa4y-EQ2RnaEKtKDM0sEAk7EwNa67REw8DGNNtGQY,84
-letta/schemas/enums.py,sha256=7Z4Wotyndp_eghhIvSdjFA3nMp_Vh_pcK1A_MrkBFRA,1357
+letta/schemas/enums.py,sha256=443ybuOZZL963Vt0fYhtJ6AWkIetlOKNUMG0Nz7l2Ss,1443
 letta/schemas/environment_variables.py,sha256=VRtzOjdeQdHcSHXisk7oJUQlheruxhSWNS0xqlfGzbs,2429
 letta/schemas/file.py,sha256=ChN2CWzLI2TT9WLItcfElEH0E8b7kzPylF2OQBr6Beg,1550
 letta/schemas/group.py,sha256=aEO0_59TEozgRMjVk7S2U4Eq4RnCr3QnbnHt-36mILM,4328
@@ -278,7 +278,7 @@ letta/server/rest_api/routers/v1/users.py,sha256=G5DBHSkPfBgVHN2Wkm-rVYiLQAudwQc
 letta/server/rest_api/routers/v1/voice.py,sha256=0lerWjrKLkt4gXLhZl1cIcgstOz9Q2HZwc67L58BCXE,2451
 letta/server/rest_api/static_files.py,sha256=NG8sN4Z5EJ8JVQdj19tkFa9iQ1kBPTab9f_CUxd_u4Q,3143
 letta/server/rest_api/utils.py,sha256=OKUWg7u4vmROVweqRrs83bQvS958bZAoR_bUFDwwqsc,14861
-letta/server/server.py,sha256=K7GZsDTjvd2v14B04uPCfnfti-yrLhuUkZMa-XR64ak,79959
+letta/server/server.py,sha256=XcZ_vrQkG2CVr_mgCKVAV6EMVjuR4lQVtU3FTAUJIIc,79726
 letta/server/startup.sh,sha256=MRXh1RKbS5lyA7XAsk7O6Q4LEKOqnv5B-dwe0SnTHeQ,2514
 letta/server/static_files/assets/index-048c9598.js,sha256=mR16XppvselwKCcNgONs4L7kZEVa4OEERm4lNZYtLSk,146819
 letta/server/static_files/assets/index-0e31b727.css,sha256=SBbja96uiQVLDhDOroHgM6NSl7tS4lpJRCREgSS_hA8,7672
@@ -292,7 +292,7 @@ letta/server/ws_api/interface.py,sha256=TWl9vkcMCnLsUtgsuENZ-ku2oMDA-OUTzLh_yNRo
 letta/server/ws_api/protocol.py,sha256=5mDgpfNZn_kNwHnpt5Dsuw8gdNH298sgxTGed3etzYg,1836
 letta/server/ws_api/server.py,sha256=cBSzf-V4zT1bL_0i54OTI3cMXhTIIxqjSRF8pYjk7fg,5835
 letta/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/services/agent_manager.py,sha256=yjML99WV91bDmVae8LjV8ZafO2dO1P6MJfIODxvgs4I,71057
+letta/services/agent_manager.py,sha256=I893THGSJrwQt-NynuY2rUJxTOGVCetIlXdkEZALc7w,71123
 letta/services/block_manager.py,sha256=rphbpGBIEDFvCJ5GJt6A1OfbURGFQZ3WardljELQyAc,15225
 letta/services/group_manager.py,sha256=z1woWRRnjkWrGG_auSicXr2bJaJ653JV6PYl2N_AUfw,12224
 letta/services/helpers/agent_manager_helper.py,sha256=57ARg5TcmE_JdrWmhz5uaNHAt1NGlJ3wQH1tP2XOiAs,17825
@@ -327,8 +327,8 @@ letta/streaming_utils.py,sha256=jLqFTVhUL76FeOuYk8TaRQHmPTf3HSRc2EoJwxJNK6U,1194
 letta/system.py,sha256=dnOrS2FlRMwijQnOvfrky0Lg8wEw-FUq2zzfAJOUSKA,8477
 letta/tracing.py,sha256=RstWXpfWVF77nmb_ISORVWd9IQw2Ky3de40k_S70yKI,8258
 letta/utils.py,sha256=IZFvtj9WYcrxUbkoUUYGDxMYQYdn5SgfqsvnARGsAzc,32245
-letta_nightly-0.7.2.dev20250423222439.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.7.2.dev20250423222439.dist-info/METADATA,sha256=kByy0bUZbRDntWr776qN-8dzCs-8jvFLNKzd_yxKGaU,22282
-letta_nightly-0.7.2.dev20250423222439.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.7.2.dev20250423222439.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.7.2.dev20250423222439.dist-info/RECORD,,
+letta_nightly-0.7.3.dev20250424054013.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.7.3.dev20250424054013.dist-info/METADATA,sha256=5LOq2K7liO_JkxDVOlEhu9MiKdT-qMyWdbZC5zQn5UE,22282
+letta_nightly-0.7.3.dev20250424054013.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.7.3.dev20250424054013.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.7.3.dev20250424054013.dist-info/RECORD,,

letta/personas/examples/offline_memory_persona.txt

@@ -1,4 +0,0 @@
-I am an expert memory agent that can do the following:
-- Consolidate memories into more concise blocks
-- Identify patterns in user behavior
-- Make inferences based on the memory