letta-nightly 0.7.12.dev20250509104216__py3-none-any.whl → 0.7.13.dev20250510172445__py3-none-any.whl

letta/__init__.py

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

letta/cli/cli.py

@@ -42,6 +42,7 @@ def server(
     port: Annotated[Optional[int], typer.Option(help="Port to run the server on")] = None,
     host: Annotated[Optional[str], typer.Option(help="Host to run the server on (default to localhost)")] = None,
     debug: Annotated[bool, typer.Option(help="Turn debugging output on")] = False,
+    reload: Annotated[bool, typer.Option(help="Enable hot-reload")] = False,
     ade: Annotated[bool, typer.Option(help="Allows remote access")] = False,  # NOTE: deprecated
     secure: Annotated[bool, typer.Option(help="Adds simple security access")] = False,
     localhttps: Annotated[bool, typer.Option(help="Setup local https")] = False,
@@ -61,7 +62,7 @@ def server(
         try:
             from letta.server.rest_api.app import start_server
 
-            start_server(port=port, host=host, debug=debug)
+            start_server(port=port, host=host, debug=debug, reload=reload)
 
         except KeyboardInterrupt:
             # Handle CTRL-C

letta/llm_api/google_vertex_client.py

@@ -1,3 +1,4 @@
+import json
 import uuid
 from typing import List, Optional
 

letta/llm_api/helpers.py

@@ -337,6 +337,10 @@ def calculate_summarizer_cutoff(in_context_messages: List[Message], token_counts
                 )
                 break
 
+        # includes the tool response to be summarized after a tool call so we don't have any hanging tool calls after trimming.
+        if i + 1 < len(in_context_messages_openai) and in_context_messages_openai[i + 1]["role"] == "tool":
+            cutoff += 1
+
         logger.info(f"Evicting {cutoff}/{len(in_context_messages)} messages...")
         return cutoff + 1
 

letta/llm_api/llm_api_tools.py

@@ -215,6 +215,9 @@ def create(
                 chat_completion_request=data,
                 stream_interface=stream_interface,
                 name=name,
+                # NOTE: needs to be true for OpenAI proxies that use the `reasoning_content` field
+                # For example, DeepSeek, or LM Studio
+                expect_reasoning_content=False,
             )
         else:  # Client did not request token streaming (expect a blocking backend response)
             data.stream = False
@@ -272,6 +275,9 @@ def create(
                 chat_completion_request=data,
                 stream_interface=stream_interface,
                 name=name,
+                # TODO turn on to support reasoning content from xAI reasoners:
+                # https://docs.x.ai/docs/guides/reasoning#reasoning
+                expect_reasoning_content=False,
             )
         else:  # Client did not request token streaming (expect a blocking backend response)
             data.stream = False
@@ -486,7 +492,10 @@ def create(
         if stream:
             raise NotImplementedError(f"Streaming not yet implemented for TogetherAI (via the /completions endpoint).")
 
-        if model_settings.together_api_key is None and llm_config.model_endpoint == "https://api.together.ai/v1/completions":
+        if model_settings.together_api_key is None and (
+            llm_config.model_endpoint == "https://api.together.ai/v1/completions"
+            or llm_config.model_endpoint == "https://api.together.xyz/v1/completions"
+        ):
             raise LettaConfigurationError(message="TogetherAI key is missing from letta config file", missing_fields=["together_api_key"])
 
         return get_chat_completion(
@@ -560,6 +569,8 @@ def create(
                 chat_completion_request=data,
                 stream_interface=stream_interface,
                 name=name,
+                # TODO should we toggle for R1 vs V3?
+                expect_reasoning_content=True,
             )
         else:  # Client did not request token streaming (expect a blocking backend response)
             data.stream = False

letta/llm_api/openai.py

@@ -8,7 +8,13 @@ from letta.constants import LETTA_MODEL_ENDPOINT
 from letta.errors import ErrorCode, LLMAuthenticationError, LLMError
 from letta.helpers.datetime_helpers import timestamp_to_datetime
 from letta.llm_api.helpers import add_inner_thoughts_to_functions, convert_to_structured_output, make_post_request
-from letta.llm_api.openai_client import accepts_developer_role, supports_parallel_tool_calling, supports_temperature_param
+from letta.llm_api.openai_client import (
+    accepts_developer_role,
+    requires_auto_tool_choice,
+    supports_parallel_tool_calling,
+    supports_structured_output,
+    supports_temperature_param,
+)
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG, INNER_THOUGHTS_KWARG_DESCRIPTION, INNER_THOUGHTS_KWARG_DESCRIPTION_GO_FIRST
 from letta.local_llm.utils import num_tokens_from_functions, num_tokens_from_messages
 from letta.log import get_logger
@@ -49,10 +55,7 @@ def openai_check_valid_api_key(base_url: str, api_key: Union[str, None]) -> None
     else:
         raise ValueError("No API key provided")
 
-
-def openai_get_model_list(
-    url: str, api_key: Optional[str] = None, fix_url: Optional[bool] = False, extra_params: Optional[dict] = None
-) -> dict:
+def openai_get_model_list(url: str, api_key: Optional[str] = None, fix_url: bool = False, extra_params: Optional[dict] = None) -> dict:
     """https://platform.openai.com/docs/api-reference/models/list"""
     from letta.utils import printd
 
@@ -154,7 +157,10 @@ def build_openai_chat_completions_request(
         elif function_call not in ["none", "auto", "required"]:
             tool_choice = ToolFunctionChoice(type="function", function=ToolFunctionChoiceFunctionCall(name=function_call))
         else:
-            tool_choice = function_call
+            if requires_auto_tool_choice(llm_config):
+                tool_choice = "auto"
+            else:
+                tool_choice = function_call
         data = ChatCompletionRequest(
             model=model,
             messages=openai_message_list,
@@ -197,12 +203,13 @@ def build_openai_chat_completions_request(
     if use_structured_output and data.tools is not None and len(data.tools) > 0:
         # Convert to structured output style (which has 'strict' and no optionals)
         for tool in data.tools:
-            try:
-                # tool["function"] = convert_to_structured_output(tool["function"])
-                structured_output_version = convert_to_structured_output(tool.function.model_dump())
-                tool.function = FunctionSchema(**structured_output_version)
-            except ValueError as e:
-                warnings.warn(f"Failed to convert tool function to structured output, tool={tool}, error={e}")
+            if supports_structured_output(llm_config):
+                try:
+                    # tool["function"] = convert_to_structured_output(tool["function"])
+                    structured_output_version = convert_to_structured_output(tool.function.model_dump())
+                    tool.function = FunctionSchema(**structured_output_version)
+                except ValueError as e:
+                    warnings.warn(f"Failed to convert tool function to structured output, tool={tool}, error={e}")
     return data
 
 
@@ -221,7 +228,7 @@ def openai_chat_completions_process_stream(
     expect_reasoning_content: bool = True,
     name: Optional[str] = None,
 ) -> ChatCompletionResponse:
-    """Process a streaming completion response, and return a ChatCompletionRequest at the end.
+    """Process a streaming completion response, and return a ChatCompletionResponse at the end.
 
     To "stream" the response in Letta, we want to call a streaming-compatible interface function
     on the chunks received from the OpenAI-compatible server POST SSE response.
@@ -293,6 +300,9 @@ def openai_chat_completions_process_stream(
             url=url, api_key=api_key, chat_completion_request=chat_completion_request
         ):
             assert isinstance(chat_completion_chunk, ChatCompletionChunkResponse), type(chat_completion_chunk)
+            if chat_completion_chunk.choices is None or len(chat_completion_chunk.choices) == 0:
+                warnings.warn(f"No choices in chunk: {chat_completion_chunk}")
+                continue
 
             # NOTE: this assumes that the tool call ID will only appear in one of the chunks during the stream
             if override_tool_call_id:
@@ -429,6 +439,9 @@ def openai_chat_completions_process_stream(
     except Exception as e:
         if stream_interface:
             stream_interface.stream_end()
+        import traceback
+
+        traceback.print_exc()
         logger.error(f"Parsing ChatCompletion stream failed with error:\n{str(e)}")
         raise e
     finally:
@@ -463,14 +476,27 @@ def openai_chat_completions_request_stream(
     url: str,
     api_key: str,
     chat_completion_request: ChatCompletionRequest,
+    fix_url: bool = False,
 ) -> Generator[ChatCompletionChunkResponse, None, None]:
+
+    # In some cases we may want to double-check the URL and do basic correction, eg:
+    # In Letta config the address for vLLM is w/o a /v1 suffix for simplicity
+    # However if we're treating the server as an OpenAI proxy we want the /v1 suffix on our model hit
+    if fix_url:
+        if not url.endswith("/v1"):
+            url = smart_urljoin(url, "v1")
+
     data = prepare_openai_payload(chat_completion_request)
     data["stream"] = True
     client = OpenAI(api_key=api_key, base_url=url, max_retries=0)
-    stream = client.chat.completions.create(**data)
-    for chunk in stream:
-        # TODO: Use the native OpenAI objects here?
-        yield ChatCompletionChunkResponse(**chunk.model_dump(exclude_none=True))
+    try:
+        stream = client.chat.completions.create(**data)
+        for chunk in stream:
+            # TODO: Use the native OpenAI objects here?
+            yield ChatCompletionChunkResponse(**chunk.model_dump(exclude_none=True))
+    except Exception as e:
+        print(f"Error request stream from /v1/chat/completions, url={url}, data={data}:\n{e}")
+        raise e
 
 
 def openai_chat_completions_request(

letta/llm_api/openai_client.py

@@ -75,6 +75,37 @@ def supports_parallel_tool_calling(model: str) -> bool:
         return True
 
 
+# TODO move into LLMConfig as a field?
+def supports_structured_output(llm_config: LLMConfig) -> bool:
+    """Certain providers don't support structured output."""
+
+    # FIXME pretty hacky - turn off for providers we know users will use,
+    #       but also don't support structured output
+    if "nebius.com" in llm_config.model_endpoint:
+        return False
+    else:
+        return True
+
+
+# TODO move into LLMConfig as a field?
+def requires_auto_tool_choice(llm_config: LLMConfig) -> bool:
+    """Certain providers require the tool choice to be set to 'auto'."""
+
+    if "nebius.com" in llm_config.model_endpoint:
+        return True
+    if "together.ai" in llm_config.model_endpoint or "together.xyz" in llm_config.model_endpoint:
+        return True
+    # proxy also has this issue (FIXME check)
+    elif llm_config.model_endpoint == LETTA_MODEL_ENDPOINT:
+        return True
+    # same with vLLM (FIXME check)
+    elif llm_config.handle and "vllm" in llm_config.handle:
+        return True
+    else:
+        # will use "required" instead of "auto"
+        return False
+
+
 class OpenAIClient(LLMClientBase):
     def _prepare_client_kwargs(self, llm_config: LLMConfig) -> dict:
         api_key = None
@@ -136,7 +167,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 == LETTA_MODEL_ENDPOINT or (llm_config.handle and "vllm" in llm_config.handle):
+        if requires_auto_tool_choice(llm_config):
             tool_choice = "auto"  # TODO change to "required" once proxy supports it
         elif tools:
             # only set if tools is non-Null
@@ -171,11 +202,12 @@ class OpenAIClient(LLMClientBase):
         if data.tools is not None and len(data.tools) > 0:
             # Convert to structured output style (which has 'strict' and no optionals)
             for tool in data.tools:
-                try:
-                    structured_output_version = convert_to_structured_output(tool.function.model_dump())
-                    tool.function = FunctionSchema(**structured_output_version)
-                except ValueError as e:
-                    logger.warning(f"Failed to convert tool function to structured output, tool={tool}, error={e}")
+                if supports_structured_output(llm_config):
+                    try:
+                        structured_output_version = convert_to_structured_output(tool.function.model_dump())
+                        tool.function = FunctionSchema(**structured_output_version)
+                    except ValueError as e:
+                        logger.warning(f"Failed to convert tool function to structured output, tool={tool}, error={e}")
 
         return data.model_dump(exclude_unset=True)
 

letta/orm/source.py

@@ -30,6 +30,7 @@ class Source(SqlalchemyBase, OrganizationMixin):
 
     name: Mapped[str] = mapped_column(doc="the name of the source, must be unique within the org", nullable=False)
     description: Mapped[str] = mapped_column(nullable=True, doc="a human-readable description of the source")
+    instructions: Mapped[str] = mapped_column(nullable=True, doc="instructions for how to use the source")
     embedding_config: Mapped[EmbeddingConfig] = mapped_column(EmbeddingConfigColumn, doc="Configuration settings for embedding.")
     metadata_: Mapped[Optional[dict]] = mapped_column(JSON, nullable=True, doc="metadata for the source.")
 

letta/schemas/llm_config.py

@@ -24,7 +24,6 @@ class LLMConfig(BaseModel):
         max_tokens (int): The maximum number of tokens to generate.
     """
 
-    # TODO: 🤮 don't default to a vendor! bug city!
     model: str = Field(..., description="LLM model name. ")
     model_endpoint_type: Literal[
         "openai",

letta/schemas/openai/chat_completion_response.py

@@ -1,5 +1,5 @@
 import datetime
-from typing import Dict, List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union
 
 from pydantic import BaseModel
 
@@ -27,6 +27,7 @@ class LogProbToken(BaseModel):
     bytes: Optional[List[int]]
 
 
+# Legacy?
 class MessageContentLogProb(BaseModel):
     token: str
     logprob: float
@@ -34,6 +35,25 @@ class MessageContentLogProb(BaseModel):
     top_logprobs: Optional[List[LogProbToken]]
 
 
+class TopLogprob(BaseModel):
+    token: str
+    bytes: Optional[List[int]] = None
+    logprob: float
+
+
+class ChatCompletionTokenLogprob(BaseModel):
+    token: str
+    bytes: Optional[List[int]] = None
+    logprob: float
+    top_logprobs: List[TopLogprob]
+
+
+class ChoiceLogprobs(BaseModel):
+    content: Optional[List[ChatCompletionTokenLogprob]] = None
+
+    refusal: Optional[List[ChatCompletionTokenLogprob]] = None
+
+
 class Message(BaseModel):
     content: Optional[str] = None
     tool_calls: Optional[List[ToolCall]] = None
@@ -49,7 +69,7 @@ class Choice(BaseModel):
     finish_reason: str
     index: int
     message: Message
-    logprobs: Optional[Dict[str, Union[List[MessageContentLogProb], None]]] = None
+    logprobs: Optional[ChoiceLogprobs] = None
     seed: Optional[int] = None  # found in TogetherAI
 
 
@@ -134,7 +154,7 @@ class ChatCompletionResponse(BaseModel):
 class FunctionCallDelta(BaseModel):
     # arguments: Optional[str] = None
     name: Optional[str] = None
-    arguments: str
+    arguments: Optional[str] = None
     # name: str
 
 
@@ -179,7 +199,7 @@ class ChunkChoice(BaseModel):
     finish_reason: Optional[str] = None  # NOTE: when streaming will be null
     index: int
     delta: MessageDelta
-    logprobs: Optional[Dict[str, Union[List[MessageContentLogProb], None]]] = None
+    logprobs: Optional[ChoiceLogprobs] = None
 
 
 class ChatCompletionChunkResponse(BaseModel):

letta/schemas/providers.py

@@ -4,7 +4,7 @@ from typing import List, Literal, Optional
 
 from pydantic import BaseModel, Field, model_validator
 
-from letta.constants import LETTA_MODEL_ENDPOINT, LLM_MAX_TOKENS, MIN_CONTEXT_WINDOW
+from letta.constants import DEFAULT_EMBEDDING_CHUNK_SIZE, LETTA_MODEL_ENDPOINT, LLM_MAX_TOKENS, MIN_CONTEXT_WINDOW
 from letta.llm_api.azure_openai import get_azure_chat_completions_endpoint, get_azure_embeddings_endpoint
 from letta.llm_api.azure_openai_constants import AZURE_MODEL_TO_CONTEXT_LENGTH
 from letta.schemas.embedding_config import EmbeddingConfig
@@ -57,7 +57,7 @@ class Provider(ProviderBase):
         """String representation of the provider for display purposes"""
         raise NotImplementedError
 
-    def get_handle(self, model_name: str, is_embedding: bool = False) -> str:
+    def get_handle(self, model_name: str, is_embedding: bool = False, base_name: Optional[str] = None) -> str:
         """
         Get the handle for a model, with support for custom overrides.
 
@@ -68,11 +68,13 @@ class Provider(ProviderBase):
         Returns:
             str: The handle for the model.
         """
+        base_name = base_name if base_name else self.name
+
         overrides = EMBEDDING_HANDLE_OVERRIDES if is_embedding else LLM_HANDLE_OVERRIDES
-        if self.name in overrides and model_name in overrides[self.name]:
-            model_name = overrides[self.name][model_name]
+        if base_name in overrides and model_name in overrides[base_name]:
+            model_name = overrides[base_name][model_name]
 
-        return f"{self.name}/{model_name}"
+        return f"{base_name}/{model_name}"
 
     def cast_to_subtype(self):
         match (self.provider_type):
@@ -162,21 +164,34 @@ class OpenAIProvider(Provider):
 
         openai_check_valid_api_key(self.base_url, self.api_key)
 
-    def list_llm_models(self) -> List[LLMConfig]:
+    def _get_models(self) -> List[dict]:
         from letta.llm_api.openai import openai_get_model_list
 
         # Some hardcoded support for OpenRouter (so that we only get models with tool calling support)...
         # See: https://openrouter.ai/docs/requests
         extra_params = {"supported_parameters": "tools"} if "openrouter.ai" in self.base_url else None
-        response = openai_get_model_list(self.base_url, api_key=self.api_key, extra_params=extra_params)
 
-        # TogetherAI's response is missing the 'data' field
-        # assert "data" in response, f"OpenAI model query response missing 'data' field: {response}"
+        # Similar to Nebius
+        extra_params = {"verbose": True} if "nebius.com" in self.base_url else None
+
+        response = openai_get_model_list(
+            self.base_url,
+            api_key=self.api_key,
+            extra_params=extra_params,
+            # fix_url=True,  # NOTE: make sure together ends with /v1
+        )
+
         if "data" in response:
             data = response["data"]
         else:
+            # TogetherAI's response is missing the 'data' field
             data = response
 
+        return data
+
+    def list_llm_models(self) -> List[LLMConfig]:
+        data = self._get_models()
+
         configs = []
         for model in data:
             assert "id" in model, f"OpenAI model missing 'id' field: {model}"
@@ -192,8 +207,8 @@ class OpenAIProvider(Provider):
                 continue
 
             # TogetherAI includes the type, which we can use to filter out embedding models
-            if self.base_url == "https://api.together.ai/v1":
-                if "type" in model and model["type"] != "chat":
+            if "api.together.ai" in self.base_url or "api.together.xyz" in self.base_url:
+                if "type" in model and model["type"] not in ["chat", "language"]:
                     continue
 
                 # for TogetherAI, we need to skip the models that don't support JSON mode / function calling
@@ -207,14 +222,17 @@ class OpenAIProvider(Provider):
                 # }
                 if "config" not in model:
                     continue
-                if "chat_template" not in model["config"]:
-                    continue
-                if model["config"]["chat_template"] is None:
-                    continue
-                if "tools" not in model["config"]["chat_template"]:
+
+            if "nebius.com" in self.base_url:
+                # Nebius includes the type, which we can use to filter for text models
+                try:
+                    model_type = model["architecture"]["modality"]
+                    if model_type not in ["text->text", "text+image->text"]:
+                        # print(f"Skipping model w/ modality {model_type}:\n{model}")
+                        continue
+                except KeyError:
+                    print(f"Couldn't access architecture type field, skipping model:\n{model}")
                     continue
-                # if "config" in data and "chat_template" in data["config"] and "tools" not in data["config"]["chat_template"]:
-                # continue
 
             # for openai, filter models
             if self.base_url == "https://api.openai.com/v1":
@@ -235,13 +253,19 @@ class OpenAIProvider(Provider):
                 if skip:
                     continue
 
+            # set the handle to openai-proxy if the base URL isn't OpenAI
+            if self.base_url != "https://api.openai.com/v1":
+                handle = self.get_handle(model_name, base_name="openai-proxy")
+            else:
+                handle = self.get_handle(model_name)
+
             configs.append(
                 LLMConfig(
                     model=model_name,
                     model_endpoint_type="openai",
                     model_endpoint=self.base_url,
                     context_window=context_window_size,
-                    handle=self.get_handle(model_name),
+                    handle=handle,
                     provider_name=self.name,
                     provider_category=self.provider_category,
                 )
@@ -256,33 +280,87 @@ class OpenAIProvider(Provider):
 
     def list_embedding_models(self) -> List[EmbeddingConfig]:
 
-        # TODO: actually automatically list models
-        return [
-            EmbeddingConfig(
-                embedding_model="text-embedding-ada-002",
-                embedding_endpoint_type="openai",
-                embedding_endpoint=self.base_url,
-                embedding_dim=1536,
-                embedding_chunk_size=300,
-                handle=self.get_handle("text-embedding-ada-002", is_embedding=True),
-            ),
-            EmbeddingConfig(
-                embedding_model="text-embedding-3-small",
-                embedding_endpoint_type="openai",
-                embedding_endpoint=self.base_url,
-                embedding_dim=2000,
-                embedding_chunk_size=300,
-                handle=self.get_handle("text-embedding-3-small", is_embedding=True),
-            ),
-            EmbeddingConfig(
-                embedding_model="text-embedding-3-large",
-                embedding_endpoint_type="openai",
-                embedding_endpoint=self.base_url,
-                embedding_dim=2000,
-                embedding_chunk_size=300,
-                handle=self.get_handle("text-embedding-3-large", is_embedding=True),
-            ),
-        ]
+        if self.base_url == "https://api.openai.com/v1":
+            # TODO: actually automatically list models for OpenAI
+            return [
+                EmbeddingConfig(
+                    embedding_model="text-embedding-ada-002",
+                    embedding_endpoint_type="openai",
+                    embedding_endpoint=self.base_url,
+                    embedding_dim=1536,
+                    embedding_chunk_size=300,
+                    handle=self.get_handle("text-embedding-ada-002", is_embedding=True),
+                ),
+                EmbeddingConfig(
+                    embedding_model="text-embedding-3-small",
+                    embedding_endpoint_type="openai",
+                    embedding_endpoint=self.base_url,
+                    embedding_dim=2000,
+                    embedding_chunk_size=300,
+                    handle=self.get_handle("text-embedding-3-small", is_embedding=True),
+                ),
+                EmbeddingConfig(
+                    embedding_model="text-embedding-3-large",
+                    embedding_endpoint_type="openai",
+                    embedding_endpoint=self.base_url,
+                    embedding_dim=2000,
+                    embedding_chunk_size=300,
+                    handle=self.get_handle("text-embedding-3-large", is_embedding=True),
+                ),
+            ]
+
+        else:
+            # Actually attempt to list
+            data = self._get_models()
+
+            configs = []
+            for model in data:
+                assert "id" in model, f"Model missing 'id' field: {model}"
+                model_name = model["id"]
+
+                if "context_length" in model:
+                    # Context length is returned in Nebius as "context_length"
+                    context_window_size = model["context_length"]
+                else:
+                    context_window_size = self.get_model_context_window_size(model_name)
+
+                # We need the context length for embeddings too
+                if not context_window_size:
+                    continue
+
+                if "nebius.com" in self.base_url:
+                    # Nebius includes the type, which we can use to filter for embedidng models
+                    try:
+                        model_type = model["architecture"]["modality"]
+                        if model_type not in ["text->embedding"]:
+                            # print(f"Skipping model w/ modality {model_type}:\n{model}")
+                            continue
+                    except KeyError:
+                        print(f"Couldn't access architecture type field, skipping model:\n{model}")
+                        continue
+
+                elif "together.ai" in self.base_url or "together.xyz" in self.base_url:
+                    # TogetherAI includes the type, which we can use to filter for embedding models
+                    if "type" in model and model["type"] not in ["embedding"]:
+                        # print(f"Skipping model w/ modality {model_type}:\n{model}")
+                        continue
+
+                else:
+                    # For other providers we should skip by default, since we don't want to assume embeddings are supported
+                    continue
+
+                configs.append(
+                    EmbeddingConfig(
+                        embedding_model=model_name,
+                        embedding_endpoint_type=self.provider_type,
+                        embedding_endpoint=self.base_url,
+                        embedding_dim=context_window_size,
+                        embedding_chunk_size=DEFAULT_EMBEDDING_CHUNK_SIZE,
+                        handle=self.get_handle(model, is_embedding=True),
+                    )
+                )
+
+            return configs
 
     def get_model_context_window_size(self, model_name: str):
         if model_name in LLM_MAX_TOKENS:

letta/schemas/source.py

@@ -31,6 +31,7 @@ class Source(BaseSource):
     id: str = BaseSource.generate_id_field()
     name: str = Field(..., description="The name of the source.")
     description: Optional[str] = Field(None, description="The description of the source.")
+    instructions: Optional[str] = Field(None, description="Instructions for how to use the source.")
     embedding_config: EmbeddingConfig = Field(..., description="The embedding configuration used by the source.")
     organization_id: Optional[str] = Field(None, description="The ID of the organization that created the source.")
     metadata: Optional[dict] = Field(None, validation_alias="metadata_", description="Metadata associated with the source.")
@@ -59,6 +60,7 @@ class SourceCreate(BaseSource):
 
     # optional
     description: Optional[str] = Field(None, description="The description of the source.")
+    instructions: Optional[str] = Field(None, description="Instructions for how to use the source.")
     metadata: Optional[dict] = Field(None, description="Metadata associated with the source.")
 
 
@@ -69,5 +71,6 @@ class SourceUpdate(BaseSource):
 
     name: Optional[str] = Field(None, description="The name of the source.")
     description: Optional[str] = Field(None, description="The description of the source.")
+    instructions: Optional[str] = Field(None, description="Instructions for how to use the source.")
     metadata: Optional[dict] = Field(None, description="Metadata associated with the source.")
     embedding_config: Optional[EmbeddingConfig] = Field(None, description="The embedding configuration used by the source.")

letta/server/rest_api/app.py

@@ -333,6 +333,7 @@ def start_server(
     port: Optional[int] = None,
     host: Optional[str] = None,
     debug: bool = False,
+    reload: bool = False,
 ):
     """Convenience method to start the server from within Python"""
     if debug:
@@ -356,7 +357,7 @@ def start_server(
             host=host or "localhost",
             port=port or REST_DEFAULT_PORT,
             workers=settings.uvicorn_workers,
-            reload=settings.uvicorn_reload,
+            reload=reload or settings.uvicorn_reload,
             timeout_keep_alive=settings.uvicorn_timeout_keep_alive,
             ssl_keyfile="certs/localhost-key.pem",
             ssl_certfile="certs/localhost.pem",
@@ -375,6 +376,6 @@ def start_server(
             host=host or "localhost",
             port=port or REST_DEFAULT_PORT,
             workers=settings.uvicorn_workers,
-            reload=settings.uvicorn_reload,
+            reload=reload or settings.uvicorn_reload,
             timeout_keep_alive=settings.uvicorn_timeout_keep_alive,
         )

letta/server/rest_api/interface.py

@@ -482,6 +482,10 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
 
         data: {"function_return": "None", "status": "success", "date": "2024-02-29T06:07:50.847262+00:00"}
         """
+        if not chunk.choices or len(chunk.choices) == 0:
+            warnings.warn(f"No choices in chunk: {chunk}")
+            return None
+
         choice = chunk.choices[0]
         message_delta = choice.delta
         otid = Message.generate_otid_from_id(message_id, message_index)

letta/server/rest_api/routers/v1/agents.py

@@ -3,7 +3,7 @@ import traceback
 from datetime import datetime, timezone
 from typing import Annotated, Any, List, Optional
 
-from fastapi import APIRouter, BackgroundTasks, Body, Depends, File, Header, HTTPException, Query, UploadFile, status
+from fastapi import APIRouter, BackgroundTasks, Body, Depends, File, Header, HTTPException, Query, Request, UploadFile, status
 from fastapi.responses import JSONResponse
 from marshmallow import ValidationError
 from orjson import orjson
@@ -619,6 +619,7 @@ def modify_message(
 )
 async def send_message(
     agent_id: str,
+    request_obj: Request,  # FastAPI Request
     server: SyncServer = Depends(get_letta_server),
     request: LettaRequest = Body(...),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
@@ -630,19 +631,12 @@ async def send_message(
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
     # TODO: This is redundant, remove soon
     agent = server.agent_manager.get_agent_by_id(agent_id, actor)
+    agent_eligible = not agent.enable_sleeptime and not agent.multi_agent_group and agent.agent_type != AgentType.sleeptime_agent
+    experimental_header = request_obj.headers.get("x-experimental")
+    feature_enabled = settings.use_experimental or experimental_header
+    model_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai", "google_vertex", "google_ai"]
 
-    if all(
-        (
-            settings.use_experimental,
-            not agent.enable_sleeptime,
-            not agent.multi_agent_group,
-            not agent.agent_type == AgentType.sleeptime_agent,
-        )
-    ) and (
-        # LLM Model Check: (1) Anthropic or (2) Google Vertex + Flag
-        agent.llm_config.model_endpoint_type == "anthropic"
-        or (agent.llm_config.model_endpoint_type == "google_vertex" and settings.use_vertex_async_loop_experimental)
-    ):
+    if agent_eligible and feature_enabled and model_compatible:
         experimental_agent = LettaAgent(
             agent_id=agent_id,
             message_manager=server.message_manager,
@@ -681,6 +675,7 @@ async def send_message(
 )
 async def send_message_streaming(
     agent_id: str,
+    request_obj: Request,  # FastAPI Request
     server: SyncServer = Depends(get_letta_server),
     request: LettaStreamingRequest = Body(...),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
@@ -694,14 +689,12 @@ async def send_message_streaming(
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
     # TODO: This is redundant, remove soon
     agent = server.agent_manager.get_agent_by_id(agent_id, actor)
+    agent_eligible = not agent.enable_sleeptime and not agent.multi_agent_group and agent.agent_type != AgentType.sleeptime_agent
+    experimental_header = request_obj.headers.get("x-experimental")
+    feature_enabled = settings.use_experimental or experimental_header
+    model_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai"]
 
-    if (
-        agent.llm_config.model_endpoint_type == "anthropic"
-        and not agent.enable_sleeptime
-        and not agent.multi_agent_group
-        and not agent.agent_type == AgentType.sleeptime_agent
-        and settings.use_experimental
-    ):
+    if agent_eligible and feature_enabled and model_compatible:
         experimental_agent = LettaAgent(
             agent_id=agent_id,
             message_manager=server.message_manager,

letta/server/rest_api/utils.py

@@ -72,7 +72,7 @@ async def sse_async_generator(
     ttft_span = None
     if request_start_timestamp_ns is not None:
         ttft_span = tracer.start_span("time_to_first_token", start_time=request_start_timestamp_ns)
-        ttft_span.set_attributes({f"llm_config.{k}": v for k, v in llm_config.model_dump().items()})
+        ttft_span.set_attributes({f"llm_config.{k}": v for k, v in llm_config.model_dump().items() if v is not None})
 
     try:
         async for chunk in generator:

letta/server/server.py

@@ -1219,6 +1219,9 @@ class SyncServer(Server):
             try:
                 llm_models.extend(provider.list_llm_models())
             except Exception as e:
+                import traceback
+
+                traceback.print_exc()
                 warnings.warn(f"An error occurred while listing LLM models for provider {provider}: {e}")
 
         llm_models.extend(self.get_local_llm_configs())

letta/services/agent_manager.py

@@ -866,9 +866,8 @@ class AgentManager:
     @enforce_types
     def trim_older_in_context_messages(self, num: int, agent_id: str, actor: PydanticUser) -> PydanticAgentState:
         message_ids = self.get_agent_by_id(agent_id=agent_id, actor=actor).message_ids
-        newer_messages = self._trim_tool_response(agent_id=agent_id, actor=actor, message_ids=message_ids[num:])
-        trimmed_messages = [message_ids[0]] + newer_messages  # 0 is system message
-        return self.set_in_context_messages(agent_id=agent_id, message_ids=trimmed_messages, actor=actor)
+        new_messages = [message_ids[0]] + message_ids[num:]  # 0 is system message
+        return self.set_in_context_messages(agent_id=agent_id, message_ids=new_messages, actor=actor)
 
     @enforce_types
     def trim_all_in_context_messages_except_system(self, agent_id: str, actor: PydanticUser) -> PydanticAgentState:
@@ -877,16 +876,6 @@ class AgentManager:
         new_messages = [message_ids[0]]  # 0 is system message
         return self.set_in_context_messages(agent_id=agent_id, message_ids=new_messages, actor=actor)
 
-    def _trim_tool_response(self, agent_id: str, actor: PydanticUser, message_ids: list[str]) -> PydanticAgentState:
-        """
-        Trims the tool response from the in-context messages if there is no tool call present in trimmed messages.
-        """
-        if message_ids:
-            messages = self.message_manager.get_messages_by_ids(message_ids=[message_ids[0]], actor=actor)
-            if messages and messages[0].role == "tool":
-                return message_ids[1:]
-        return message_ids
-
     @enforce_types
     def prepend_to_in_context_messages(self, messages: List[PydanticMessage], agent_id: str, actor: PydanticUser) -> PydanticAgentState:
         message_ids = self.get_agent_by_id(agent_id=agent_id, actor=actor).message_ids

letta/services/summarizer/summarizer.py

@@ -107,13 +107,9 @@ class Summarizer:
             self.summarizer_agent.update_message_transcript(message_transcripts=formatted_evicted_messages + formatted_in_context_messages)
 
             # Add line numbers to the formatted messages
-            line_number = 0
-            for i in range(len(formatted_evicted_messages)):
-                formatted_evicted_messages[i] = f"{line_number}. " + formatted_evicted_messages[i]
-                line_number += 1
-            for i in range(len(formatted_in_context_messages)):
-                formatted_in_context_messages[i] = f"{line_number}. " + formatted_in_context_messages[i]
-                line_number += 1
+            offset = len(formatted_evicted_messages)
+            formatted_evicted_messages = [f"{i}. {msg}" for (i, msg) in enumerate(formatted_evicted_messages)]
+            formatted_in_context_messages = [f"{i + offset}. {msg}" for (i, msg) in enumerate(formatted_in_context_messages)]
 
             evicted_messages_str = "\n".join(formatted_evicted_messages)
             in_context_messages_str = "\n".join(formatted_in_context_messages)

letta/settings.py

@@ -2,7 +2,7 @@ import os
 from pathlib import Path
 from typing import Optional
 
-from pydantic import Field
+from pydantic import AliasChoices, Field
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 from letta.local_llm.constants import DEFAULT_WRAPPER_NAME
@@ -70,7 +70,13 @@ class ModelSettings(BaseSettings):
 
     # openai
     openai_api_key: Optional[str] = None
-    openai_api_base: str = "https://api.openai.com/v1"
+    openai_api_base: str = Field(
+        default="https://api.openai.com/v1",
+        # NOTE: We previously used OPENAI_API_BASE, but this was deprecated in favor of OPENAI_BASE_URL
+        # preferred first, fallback second
+        # env=["OPENAI_BASE_URL", "OPENAI_API_BASE"],  # pydantic-settings v2
+        validation_alias=AliasChoices("OPENAI_BASE_URL", "OPENAI_API_BASE"),  # pydantic-settings v1
+    )
 
     # deepseek
     deepseek_api_key: Optional[str] = None

{letta_nightly-0.7.12.dev20250509104216.dist-info → letta_nightly-0.7.13.dev20250510172445.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.7.12.dev20250509104216
+Version: 0.7.13.dev20250510172445
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.7.12.dev20250509104216.dist-info → letta_nightly-0.7.13.dev20250510172445.dist-info}/RECORD

@@ -1,4 +1,4 @@
-letta/__init__.py,sha256=qYLzeNN1fIbaKf7rytyM_j256ng0pvDgtT9fPxM2bh4,916
+letta/__init__.py,sha256=Y_QgodpFyn8eKt2ZRmuBOCwIS1xN_KmXBrjVm8KdcaQ,916
 letta/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
 letta/agent.py,sha256=052xuXY4psY0BGDrtZ8XviOTpKhERSFrzKZnTsuIEvY,72125
 letta/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -12,7 +12,7 @@ letta/agents/voice_agent.py,sha256=YHaGCy3A35lB3bxXMXldIHUsXt76kC88Ti34EDs3zzA,2
 letta/agents/voice_sleeptime_agent.py,sha256=Joi3-8emTpV7v86OR_HGYXblkulrNaHhudCvPmMyXz0,7274
 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.py,sha256=Y3UC0mCvGR283sdegnqgq-6Fcwie59baXy3P0Cf0V-k,16569
 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
@@ -80,14 +80,14 @@ 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=9sKAuu3qGYt7IVGTb7krEUcVeSsPEE6x0V-jRacSgCg,24471
 letta/llm_api/google_constants.py,sha256=4PKWUNNbBHgHi4K5u9YaHr_8UC3fokfI6Qb6Dfpt4mU,693
-letta/llm_api/google_vertex_client.py,sha256=fXG-wSrooENdFxI6ahLAEbVrEBzHpNCYPtka7PMJ7_g,16032
-letta/llm_api/helpers.py,sha256=sLYv30UnKBRVPuhU_KDXfKFdbkUONiDAyVEwGr86l3A,16780
-letta/llm_api/llm_api_tools.py,sha256=Ytq50foJNiO69rC7KasZWfU1ZU2DP6xiR_Z76MEwVoU,28387
+letta/llm_api/google_vertex_client.py,sha256=DAdqBUmHAYjhsBYGcL3HmFquSzII8Wwx4PWPMIw0Ru0,16044
+letta/llm_api/helpers.py,sha256=rpZInutKVKgoywreclisNSi2zVxwFinAzJIuxF6ll4I,17041
+letta/llm_api/llm_api_tools.py,sha256=YbslnPRFiJwaxRMhZ4T8K8SgByw73Ck61k3KNLScPr0,28995
 letta/llm_api/llm_client.py,sha256=qJ92biZVCXyRESzZX3ODeMd-kcgkYtJGdp6oVjV7PBc,2074
 letta/llm_api/llm_client_base.py,sha256=eID0J0l4VITZDL5765xEDvV8WLL4WzwQAzFEsC7ea6I,6067
 letta/llm_api/mistral.py,sha256=fHdfD9ug-rQIk2qn8tRKay1U6w9maF11ryhKi91FfXM,1593
-letta/llm_api/openai.py,sha256=KM70niO7i9hmr9agmhFvdk5D3GXWAmD9y82BqrHgijk,24583
-letta/llm_api/openai_client.py,sha256=8WpEyfGojIiFkNQVVXV6dVkq1bHWMx3aXIqQA38ovAI,14203
+letta/llm_api/openai.py,sha256=KZ9UrL2aIC29o389f4yfF9_LP8UKYRyN4YUgBQuGhYU,25648
+letta/llm_api/openai_client.py,sha256=NACYguMG_4nb5LqqdnR6XiD9RLqNLpn5TeHUzRL9VMc,15294
 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
@@ -158,7 +158,7 @@ letta/orm/organization.py,sha256=STQ5x5zXoPhfagiRQX6j2lWgOqwznPp-K019MPjbY0s,359
 letta/orm/passage.py,sha256=luoQMBAm2DwWpcGtQziMDjDP5JZZNv1pnEmx-InNHFo,3090
 letta/orm/provider.py,sha256=KxIyUijtFapxXsgD86tWCRt1sG0TIETEyqlHEUWB7Fg,1312
 letta/orm/sandbox_config.py,sha256=DyOy_1_zCMlp13elCqPcuuA6OwUove6mrjhcpROTg50,4150
-letta/orm/source.py,sha256=z89VZUHV9K8Ew9JCYoZqUeRb1WEUKmrn0MMFkppaphE,2117
+letta/orm/source.py,sha256=rtehzez80rRrJigXeRBgTlfTZEUy6cVqDizWEN2tvuY,2224
 letta/orm/sources_agents.py,sha256=Ik_PokCBrXRd9wXWomeNeb8EtLUwjb9VMZ8LWXqpK5A,473
 letta/orm/sqlalchemy_base.py,sha256=GAYUfniRNWkSVkhj6I1e5yzfy5H93aopBY72x8kO-cg,27238
 letta/orm/sqlite_functions.py,sha256=JCScKiRlYCKxy9hChQ8wsk4GMKknZE24MunnG3fM1Gw,4255
@@ -218,22 +218,22 @@ letta/schemas/letta_message_content.py,sha256=eF2UEDofQx7S_nS1jc9MZypP4EGVWj7zdi
 letta/schemas/letta_request.py,sha256=acGJDmrv804Xe0432Vnk6_yD8aUt4LZwK9lQKm56uss,1943
 letta/schemas/letta_response.py,sha256=lZ_uCwSmV7g7UCBxNyU_r-FFcXAf6_pBsFqgWJ-WkBs,7955
 letta/schemas/llm_batch_job.py,sha256=i8m58-EFF0xGD7cYfu-LRlbvYZwv5y2B14ckmuRQ_IM,2896
-letta/schemas/llm_config.py,sha256=mMHIuAwtQyvtOo4MfOvvva8cR90dyapyMGGXidSOxnE,8705
+letta/schemas/llm_config.py,sha256=0sXsJm4fYHsggfXhkJMpeiiZ62xtGPOqr-nPlqmWN7c,8651
 letta/schemas/llm_config_overrides.py,sha256=E6qJuVA8TwAAy3VjGitJ5jSQo5PbN-6VPcZOF5qhP9A,1815
 letta/schemas/memory.py,sha256=GOYDfPKzbWftUWO9Hv4KW7xAi1EIQmC8zpP7qvEkVHw,10245
 letta/schemas/message.py,sha256=qHGNuhymW_qAbuPcb0CPRUYrrlBlWj5Pu4Oh2b7ag7Q,51143
 letta/schemas/openai/chat_completion_request.py,sha256=XARKB7717Crt3P2A53eeBZ6hlNJcb9TJHosWwK17tFw,4210
-letta/schemas/openai/chat_completion_response.py,sha256=7SsfVNsWq_EUajmckU5KjFClkK0iXZF2jHWZZ0nr6T4,6701
+letta/schemas/openai/chat_completion_response.py,sha256=f2JZWh5mVz9pk19Iji8EnQD9NKq-sI2SVQkPeZHzzTQ,7067
 letta/schemas/openai/chat_completions.py,sha256=l0e9sT9boTD5VBU5YtJ0s7qUtCfFGB2K-gQLeEZ2LHU,3599
 letta/schemas/openai/embedding_response.py,sha256=WKIZpXab1Av7v6sxKG8feW3ZtpQUNosmLVSuhXYa_xU,357
 letta/schemas/openai/openai.py,sha256=Hilo5BiLAGabzxCwnwfzK5QrWqwYD8epaEKFa4Pwndk,7970
 letta/schemas/organization.py,sha256=TXrHN4IBQnX-mWvRuCOH57XZSLYCVOY0wWm2_UzDQIA,1279
 letta/schemas/passage.py,sha256=RG0vkaewEu4a_NAZM-FVyMammHjqpPP0RDYAdu27g6A,3723
-letta/schemas/providers.py,sha256=QhOhjBpgf356rTG57ht3hDE6jzJ4hXWAUGHul4kPvBA,53510
+letta/schemas/providers.py,sha256=8lso7jhcnnqyzYspp1C3NZSqqJ9YF51qGsRKoetWJYQ,56895
 letta/schemas/response_format.py,sha256=pXNsjbtpA3Tf8HsDyIa40CSmoUbVR_7n2WOfQaX4aFs,2204
 letta/schemas/run.py,sha256=SRqPRziINIiPunjOhE_NlbnQYgxTvqmbauni_yfBQRA,2085
 letta/schemas/sandbox_config.py,sha256=Qfkzw422HCQUsE3GKry94oecQGziAzGXIyd6ke8W06M,5985
-letta/schemas/source.py,sha256=IuenIFs7B8uOuYJIHXqR1E28wVSa-pUX6NkLZH7cukg,3141
+letta/schemas/source.py,sha256=ZDeTjkNp1rKamG7xZzoUHeCptjpW9WNLzAcJ9QQRxlM,3444
 letta/schemas/step.py,sha256=WkcVnruUUOWLKwiWPn2Gfal4EQZPNLqlsd9859xhgsw,2224
 letta/schemas/tool.py,sha256=k8dmXfYA_gcipAjBAwBYWsmhlkGvPnOBqrPG336QpBM,13111
 letta/schemas/tool_execution_result.py,sha256=O65Z-gwNuB2hrX0Vklw_A9uURu0sz67gxTDr1tNwvJM,804
@@ -255,18 +255,18 @@ letta/server/constants.py,sha256=yAdGbLkzlOU_dLTx0lKDmAnj0ZgRXCEaIcPJWO69eaE,92
 letta/server/db.py,sha256=Jt_lWUvqTWFHfgsWUuXcDlGD3yejNBjY1P4J2vI3kL0,4935
 letta/server/generate_openapi_schema.sh,sha256=0OtBhkC1g6CobVmNEd_m2B6sTdppjbJLXaM95icejvE,371
 letta/server/rest_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/server/rest_api/app.py,sha256=ZLtTm2HZwctfM69ujF433xK2Bx9ZILHyYSBnxdRQtcY,14669
+letta/server/rest_api/app.py,sha256=WoAfqDrSkb86Wq0lAvTWJqoxys9e-kgKaS11sGb8Xzg,14715
 letta/server/rest_api/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/auth/index.py,sha256=fQBGyVylGSRfEMLQ17cZzrHd5Y1xiVylvPqH5Rl-lXQ,1378
 letta/server/rest_api/auth_token.py,sha256=725EFEIiNj4dh70hrSd94UysmFD8vcJLrTRfNHkzxDo,774
 letta/server/rest_api/chat_completions_interface.py,sha256=90VOlJ2HTxZtQMDt3aCbrlbGLouj4qHkfEz6PwXtrkc,11089
-letta/server/rest_api/interface.py,sha256=SdRalftQawKjmZL8x2wRtZ1LJ9wLyE00isIfmNyDKQY,65788
+letta/server/rest_api/interface.py,sha256=ypBXEySUQ0tR-CSKfn3RiK28uOggB5gjA_mq3uRMKW4,65929
 letta/server/rest_api/json_parser.py,sha256=IKG2xFAz_wkLfd3Z-18SKykSzCtUDjdYgTKSKaMqj1I,7813
 letta/server/rest_api/routers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/routers/openai/chat_completions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/routers/openai/chat_completions/chat_completions.py,sha256=QBWab1fn2LXVDMtc6li3gOzmrNzDiUw5WUJsMeeMZII,5076
 letta/server/rest_api/routers/v1/__init__.py,sha256=_skmAcDOK9ovHKfywRaBgigo3IvPmnUSQSR2hGVCOhY,1664
-letta/server/rest_api/routers/v1/agents.py,sha256=ugWHhjqH26qEvS8N1ihPTxvoGsKXLNzBy8cplxPpGgQ,35052
+letta/server/rest_api/routers/v1/agents.py,sha256=SzRxDV9eXG0LieBZ0OSLse_Iu7LHlWNqPtuk_ri2-tU,35286
 letta/server/rest_api/routers/v1/blocks.py,sha256=jrDpSYrEgHaGvlnUCn6wczgWnCZa3ZyHVL5NQv2KJNE,4471
 letta/server/rest_api/routers/v1/embeddings.py,sha256=P-Dvt_HNKoTyjRwkScAMg1hlB3cNxMeAQwV7bSatsKI,957
 letta/server/rest_api/routers/v1/groups.py,sha256=JI9ShKewoE8lB58OP02NuAT7eUzPfqSG7y44a6tBh9s,10710
@@ -286,8 +286,8 @@ letta/server/rest_api/routers/v1/tools.py,sha256=FXFx8J4Zs-pZ1H8andFzI5Pyv-PJkY8
 letta/server/rest_api/routers/v1/users.py,sha256=G5DBHSkPfBgVHN2Wkm-rVYiLQAudwQczIq2Z3YLdbVo,2277
 letta/server/rest_api/routers/v1/voice.py,sha256=nSwjoW5Hi9EdScGyRWXpGVooAS0X2G-mOrpLUz0NqNs,1935
 letta/server/rest_api/static_files.py,sha256=NG8sN4Z5EJ8JVQdj19tkFa9iQ1kBPTab9f_CUxd_u4Q,3143
-letta/server/rest_api/utils.py,sha256=sUHtcmbs9yl7__jvtUHzfhiZV1mzU7r5SzrGTJhRIC4,16499
-letta/server/server.py,sha256=1PUlT22tT0ITfoZ2V66OgHKPSlIaydMJrWcMNXFftDU,86522
+letta/server/rest_api/utils.py,sha256=n5ZwtCtF3Oa4b9NFQ8l9f13v4eOI4mWdWNQqFp5d3A0,16516
+letta/server/server.py,sha256=fWg6a01RaaWkjguO6tzehlJWWycs5H7azLve5XJ0MiQ,86594
 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
@@ -301,7 +301,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=AB4yV70NNCzeKR7tR1CD4lqxlJUgPvKLBXOCdsZ6Rik,72665
+letta/services/agent_manager.py,sha256=FfMRz0Ewebn0OGhb9adBxga06-da3YmQ2qlh1BHOXUI,72037
 letta/services/block_manager.py,sha256=rAwOX9MYGSWYlzQsUtS_UXJwoh7jD-5O6aL8VWnA7fw,17327
 letta/services/group_manager.py,sha256=EKYeD3MyJknpZBsH850pqIPZJmsphgEfI8hL-uOZbvU,15896
 letta/services/helpers/agent_manager_helper.py,sha256=2W9DpxGOx3rK2LnpGDtQmBJh9u9sKZ_xwAUAYzAMyS0,20350
@@ -324,7 +324,7 @@ letta/services/source_manager.py,sha256=yW88wAJoeAWtbg0FxifE352jhgOTKNiG7K-IPKXK
 letta/services/step_manager.py,sha256=B64iYn6Dt9yRKsSJ5vLxWQR2t-apvPLfUZyzrUsJTpI,5335
 letta/services/summarizer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/summarizer/enums.py,sha256=szzPX2OBRRJEZsBTGYQThrNz02ELFqhuLwvOR7ozi7A,208
-letta/services/summarizer/summarizer.py,sha256=cbBleCAOi4WFmU226xZ1oEiBeCGdLKQaIhYZBRnA3u0,7791
+letta/services/summarizer/summarizer.py,sha256=LVFZ8NLtS1lz4Pdr7M_cixFYBYsllt2vXNzTOT3Wkxc,7658
 letta/services/tool_executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/tool_executor/tool_execution_manager.py,sha256=NLkHLxxMYp0XKgu8j6YgqBVkhlG1cOioNRTd4muKJyU,4537
 letta/services/tool_executor/tool_execution_sandbox.py,sha256=9gcERJ15Y6u_6AGAVH3KGJP-85fpr2HLCV8SatQAG0w,24891
@@ -335,14 +335,14 @@ letta/services/tool_sandbox/base.py,sha256=pUnPFkEg9I5ktMuT4AOOxbTnTmZTGcTA2phLe
 letta/services/tool_sandbox/e2b_sandbox.py,sha256=umsXfolzM_j67izswECDdVfnlcm03wLpMoZtS6SZ0sc,6147
 letta/services/tool_sandbox/local_sandbox.py,sha256=ksbraC-zcMWt3vS7kSi98uWI9L73I0h73rMayhuTWsw,10474
 letta/services/user_manager.py,sha256=_aoiQy73B4Jm_uVDrfAUrg2TnOYa_tJLRUwa3fF5ASY,4429
-letta/settings.py,sha256=B7oKONj9H8isY-0C12aQNmdxHmv66YK2Dq8ZSZPK71Q,8295
+letta/settings.py,sha256=2SCkE8SppUQmhHWrytR52bbKEJcQmJzkzHNFfGCdsK8,8665
 letta/streaming_interface.py,sha256=kDSc5bnodgGzAuLcnq4Zf7p-uS6cdyxSIZ5U_JA_8FU,16300
 letta/streaming_utils.py,sha256=jLqFTVhUL76FeOuYk8TaRQHmPTf3HSRc2EoJwxJNK6U,11946
 letta/system.py,sha256=mKxmvvekuP8mdgsebRINGBoFbUdJhxLJ260crPBNVyk,8386
 letta/tracing.py,sha256=j9uyBbx02erQZ307XmZmZSNyzQt-d7ZDB7vhFhjDlsU,8448
 letta/utils.py,sha256=IZFvtj9WYcrxUbkoUUYGDxMYQYdn5SgfqsvnARGsAzc,32245
-letta_nightly-0.7.12.dev20250509104216.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.7.12.dev20250509104216.dist-info/METADATA,sha256=7wpN1QJCb_XwnNKRsa60DkRz2wCwZeszgqiklDg3HA4,22232
-letta_nightly-0.7.12.dev20250509104216.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.7.12.dev20250509104216.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.7.12.dev20250509104216.dist-info/RECORD,,
+letta_nightly-0.7.13.dev20250510172445.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.7.13.dev20250510172445.dist-info/METADATA,sha256=lKByluI4-V-R3o79HRcpep7MK7-Y_b8lyiGth_U8rNk,22232
+letta_nightly-0.7.13.dev20250510172445.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.7.13.dev20250510172445.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.7.13.dev20250510172445.dist-info/RECORD,,