letta-nightly 0.13.1.dev20251031234110__py3-none-any.whl → 0.13.1.dev20251101010313__py3-none-any.whl

letta/agents/letta_agent_v3.py

@@ -455,6 +455,13 @@ class LettaAgentV3(LettaAgentV2):
                                         request_data["parallel_tool_calls"] = True
                                     else:
                                         request_data["parallel_tool_calls"] = False
+
+                            # Gemini (Google AI/Vertex) parallel tool use
+                            elif self.agent_state.llm_config.model_endpoint_type in ["google_ai", "google_vertex"]:
+                                # Gemini supports parallel tool calling natively through multiple parts in the response
+                                # We just need to ensure the config flag is set for tracking purposes
+                                # The actual handling happens in GoogleVertexClient.convert_response_to_chat_completion
+                                pass  # No specific request_data field needed for Gemini
                         except Exception:
                             # if this fails, we simply don't enable parallel tool use
                             pass

letta/constants.py

@@ -439,3 +439,6 @@ WEB_SEARCH_MODEL_ENV_VAR_DEFAULT_VALUE = "gpt-4.1-mini-2025-04-14"
 EXCLUDE_MODEL_KEYWORDS_FROM_BASE_TOOL_RULES = ["claude-4-sonnet", "claude-3-5-sonnet", "gpt-5", "gemini-2.5-pro"]
 # But include models with these keywords in base tool rules (overrides exclusion)
 INCLUDE_MODEL_KEYWORDS_BASE_TOOL_RULES = ["mini"]
+
+# Default handle for model used to generate tools
+DEFAULT_GENERATE_TOOL_MODEL_HANDLE = "openai/gpt-4.1"

letta/llm_api/google_vertex_client.py

@@ -444,14 +444,14 @@ class GoogleVertexClient(LLMClientBase):
                 # NOTE(Apr 9, 2025): there's a very strange bug on 2.5 where the response has a part with broken text
                 # {'candidates': [{'content': {'parts': [{'functionCall': {'name': 'send_message', 'args': {'request_heartbeat': False, 'message': 'Hello! How can I make your day better?', 'inner_thoughts': 'User has initiated contact. Sending a greeting.'}}}], 'role': 'model'}, 'finishReason': 'STOP', 'avgLogprobs': -0.25891534213362066}], 'usageMetadata': {'promptTokenCount': 2493, 'candidatesTokenCount': 29, 'totalTokenCount': 2522, 'promptTokensDetails': [{'modality': 'TEXT', 'tokenCount': 2493}], 'candidatesTokensDetails': [{'modality': 'TEXT', 'tokenCount': 29}]}, 'modelVersion': 'gemini-1.5-pro-002'}
                 # To patch this, if we have multiple parts we can take the last one
-                if len(parts) > 1 and not llm_config.enable_reasoner:
+                # Unless parallel tool calling is enabled, in which case multiple parts may be intentional
+                if len(parts) > 1 and not llm_config.enable_reasoner and not llm_config.parallel_tool_calls:
                     logger.warning(f"Unexpected multiple parts in response from Google AI: {parts}")
-                    # only truncate if reasoning is off
+                    # only truncate if reasoning is off and parallel tool calls are disabled
                     parts = [parts[-1]]
 
                 # TODO support parts / multimodal
-                # TODO support parallel tool calling natively
-                # TODO Alternative here is to throw away everything else except for the first part
+                # Parallel tool calling is now supported when llm_config.parallel_tool_calls is enabled
                 openai_response_message = None
                 for response_message in parts:
                     # Convert the actual message style to OpenAI style

letta/orm/agent.py

@@ -280,6 +280,8 @@ class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, TemplateEntityMixin
             if resolver:
                 state[field_name] = resolver()
 
+        state["model"] = self.llm_config._to_model() if self.llm_config else None
+
         return self.__pydantic_model__(**state)
 
     async def to_pydantic_async(
@@ -417,5 +419,6 @@ class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, TemplateEntityMixin
         state["managed_group"] = multi_agent_group
         state["tool_exec_environment_variables"] = tool_exec_environment_variables
         state["secrets"] = tool_exec_environment_variables
+        state["model"] = self.llm_config._to_model() if self.llm_config else None
 
         return self.__pydantic_model__(**state)

letta/schemas/agent.py

@@ -17,6 +17,7 @@ from letta.schemas.letta_base import OrmMetadataBase
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import Memory
 from letta.schemas.message import Message, MessageCreate
+from letta.schemas.model import EmbeddingModelSettings, ModelSettings
 from letta.schemas.openai.chat_completion_response import UsageStatistics
 from letta.schemas.response_format import ResponseFormatUnion
 from letta.schemas.source import Source
@@ -87,11 +88,19 @@ class AgentState(OrmMetadataBase, validate_assignment=True):
     # agent configuration
     agent_type: AgentType = Field(..., description="The type of agent.")
 
-    # llm information
-    llm_config: LLMConfig = Field(..., description="The LLM configuration used by the agent.")
-    embedding_config: EmbeddingConfig = Field(..., description="The embedding configuration used by the agent.")
+    # model information
+    llm_config: LLMConfig = Field(
+        ..., description="Deprecated: Use `model` field instead. The LLM configuration used by the agent.", deprecated=True
+    )
+    embedding_config: EmbeddingConfig = Field(
+        ..., description="Deprecated: Use `embedding` field instead. The embedding configuration used by the agent.", deprecated=True
+    )
+    model: Optional[ModelSettings] = Field(None, description="The model used by the agent.")
+    embedding: Optional[EmbeddingModelSettings] = Field(None, description="The embedding model used by the agent.")
+
     response_format: Optional[ResponseFormatUnion] = Field(
-        None, description="The response format used by the agent when returning from `send_message`."
+        None,
+        description="The response format used by the agent",
     )
 
     # This is an object representing the in-process state of a running `Agent`
@@ -99,7 +108,7 @@ class AgentState(OrmMetadataBase, validate_assignment=True):
     description: Optional[str] = Field(None, description="The description of the agent.")
     metadata: Optional[Dict] = Field(None, description="The metadata of the agent.")
 
-    memory: Memory = Field(..., description="The in-context memory of the agent.", deprecated=True)
+    memory: Memory = Field(..., description="Deprecated: Use `blocks` field instead. The in-context memory of the agent.", deprecated=True)
     blocks: List[Block] = Field(..., description="The memory blocks used by the agent.")
     tools: List[Tool] = Field(..., description="The tools used by the agent.")
     sources: List[Source] = Field(..., description="The sources used by the agent.")
@@ -117,7 +126,9 @@ class AgentState(OrmMetadataBase, validate_assignment=True):
     base_template_id: Optional[str] = Field(None, description="The base template id of the agent.")
     deployment_id: Optional[str] = Field(None, description="The id of the deployment.")
     entity_id: Optional[str] = Field(None, description="The id of the entity within the template.")
-    identity_ids: List[str] = Field([], description="The ids of the identities associated with this agent.", deprecated=True)
+    identity_ids: List[str] = Field(
+        [], description="Deprecated: Use `identities` field instead. The ids of the identities associated with this agent.", deprecated=True
+    )
     identities: List[Identity] = Field([], description="The identities associated with this agent.")
 
     # An advanced configuration that makes it so this agent does not remember any previous messages
@@ -130,7 +141,9 @@ class AgentState(OrmMetadataBase, validate_assignment=True):
         description="If set to True, memory management will move to a background agent thread.",
     )
 
-    multi_agent_group: Optional[Group] = Field(None, description="The multi-agent group that this agent manages", deprecated=True)
+    multi_agent_group: Optional[Group] = Field(
+        None, description="Deprecated: Use `managed_group` field instead. The multi-agent group that this agent manages.", deprecated=True
+    )
     managed_group: Optional[Group] = Field(None, description="The multi-agent group that this agent manages")
     # Run metrics
     last_run_completion: Optional[datetime] = Field(None, description="The timestamp when the agent last completed a run.")
@@ -202,8 +215,6 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
     tags: Optional[List[str]] = Field(None, description="The tags associated with the agent.")
     system: Optional[str] = Field(None, description="The system prompt used by the agent.")
     agent_type: AgentType = Field(default_factory=lambda: AgentType.memgpt_v2_agent, description="The type of agent.")
-    llm_config: Optional[LLMConfig] = Field(None, description="The LLM configuration used by the agent.")
-    embedding_config: Optional[EmbeddingConfig] = Field(None, description="The embedding configuration used by the agent.")
     # Note: if this is None, then we'll populate with the standard "more human than human" initial message sequence
     # If the client wants to make this empty, then the client can set the arg to an empty list
     initial_message_sequence: Optional[List[MessageCreate]] = Field(
@@ -216,43 +227,78 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
     include_base_tool_rules: Optional[bool] = Field(
         None, description="If true, attaches the Letta base tool rules (e.g. deny all tools not explicitly allowed)."
     )
-    include_default_source: bool = Field(
-        False, description="If true, automatically creates and attaches a default data source for this agent."
+    include_default_source: bool = Field(  # TODO: get rid of this
+        False, description="If true, automatically creates and attaches a default data source for this agent.", deprecated=True
     )
     description: Optional[str] = Field(None, description="The description of the agent.")
     metadata: Optional[Dict] = Field(None, description="The metadata of the agent.")
-    model: Optional[str] = Field(
+
+    # model configuration
+    llm_config: Optional[LLMConfig] = Field(
+        None, description="Deprecated: Use `model` field instead. The LLM configuration used by the agent.", deprecated=True
+    )
+    embedding_config: Optional[EmbeddingConfig] = Field(
+        None, description="Deprecated: Use `embedding` field instead. The embedding configuration used by the agent.", deprecated=True
+    )
+    model: Optional[str | ModelSettings] = Field(  # TODO: make this required  (breaking change)
         None,
-        description="The LLM configuration handle used by the agent, specified in the format "
-        "provider/model-name, as an alternative to specifying llm_config.",
+        description="The model handle or model settings for the agent to use, specified either by a handle or an object. See the model schema for more information.",
     )
-    embedding: Optional[str] = Field(
+    embedding: Optional[str | EmbeddingModelSettings] = Field(
         None, description="The embedding configuration handle used by the agent, specified in the format provider/model-name."
     )
+
     context_window_limit: Optional[int] = Field(None, description="The context window limit used by the agent.")
-    embedding_chunk_size: Optional[int] = Field(DEFAULT_EMBEDDING_CHUNK_SIZE, description="The embedding chunk size used by the agent.")
+    embedding_chunk_size: Optional[int] = Field(
+        DEFAULT_EMBEDDING_CHUNK_SIZE, description="Deprecated: No longer used. The embedding chunk size used by the agent.", deprecated=True
+    )
     max_tokens: Optional[int] = Field(
         None,
-        description="The maximum number of tokens to generate, including reasoning step. If not set, the model will use its default value.",
+        description="Deprecated: Use `model` field to configure max output tokens instead. The maximum number of tokens to generate, including reasoning step.",
+        deprecated=True,
     )
     max_reasoning_tokens: Optional[int] = Field(
-        None, description="The maximum number of tokens to generate for reasoning step. If not set, the model will use its default value."
+        None,
+        description="Deprecated: Use `model` field to configure reasoning tokens instead. The maximum number of tokens to generate for reasoning step.",
+        deprecated=True,
+    )
+    enable_reasoner: Optional[bool] = Field(
+        True,
+        description="Deprecated: Use `model` field to configure reasoning instead. Whether to enable internal extended thinking step for a reasoner model.",
+        deprecated=True,
+    )
+    reasoning: Optional[bool] = Field(
+        None,
+        description="Deprecated: Use `model` field to configure reasoning instead. Whether to enable reasoning for this agent.",
+        deprecated=True,
+    )
+    from_template: Optional[str] = Field(
+        None, description="Deprecated: please use the 'create agents from a template' endpoint instead.", deprecated=True
     )
-    enable_reasoner: Optional[bool] = Field(True, description="Whether to enable internal extended thinking step for a reasoner model.")
-    reasoning: Optional[bool] = Field(None, description="Whether to enable reasoning for this agent.")
-    from_template: Optional[str] = Field(None, description="Deprecated: please use the 'create agents from a template' endpoint instead.")
-    template: bool = Field(False, description="Deprecated: No longer used")
+    template: bool = Field(False, description="Deprecated: No longer used.", deprecated=True)
     project: Optional[str] = Field(
         None,
         deprecated=True,
-        description="Deprecated: Project should now be passed via the X-Project header instead of in the request body. If using the sdk, this can be done via the new x_project field below.",
+        description="Deprecated: Project should now be passed via the X-Project header instead of in the request body. If using the SDK, this can be done via the x_project parameter.",
+    )
+    tool_exec_environment_variables: Optional[Dict[str, str]] = Field(
+        None, description="Deprecated: Use `secrets` field instead. Environment variables for tool execution.", deprecated=True
     )
-    tool_exec_environment_variables: Optional[Dict[str, str]] = Field(None, description="Deprecated: use `secrets` field instead.")
     secrets: Optional[Dict[str, str]] = Field(None, description="The environment variables for tool execution specific to this agent.")
-    memory_variables: Optional[Dict[str, str]] = Field(None, description="The variables that should be set for the agent.")
-    project_id: Optional[str] = Field(None, description="The id of the project the agent belongs to.")
-    template_id: Optional[str] = Field(None, description="The id of the template the agent belongs to.")
-    base_template_id: Optional[str] = Field(None, description="The base template id of the agent.")
+    memory_variables: Optional[Dict[str, str]] = Field(
+        None,
+        description="Deprecated: Only relevant for creating agents from a template. Use the 'create agents from a template' endpoint instead.",
+        deprecated=True,
+    )
+    project_id: Optional[str] = Field(
+        None, description="Deprecated: No longer used. The id of the project the agent belongs to.", deprecated=True
+    )
+    template_id: Optional[str] = Field(
+        None, description="Deprecated: No longer used. The id of the template the agent belongs to.", deprecated=True
+    )
+    base_template_id: Optional[str] = Field(
+        None, description="Deprecated: No longer used. The base template id of the agent.", deprecated=True
+    )
     identity_ids: Optional[List[str]] = Field(None, description="The ids of the identities associated with this agent.")
     message_buffer_autoclear: bool = Field(
         False,
@@ -271,9 +317,14 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
     )
     hidden: Optional[bool] = Field(
         None,
-        description="If set to True, the agent will be hidden.",
+        description="Deprecated: No longer used. If set to True, the agent will be hidden.",
+        deprecated=True,
+    )
+    parallel_tool_calls: Optional[bool] = Field(
+        False,
+        description="Deprecated: Use `model` field to configure parallel tool calls instead. If set to True, enables parallel tool calling.",
+        deprecated=True,
     )
-    parallel_tool_calls: Optional[bool] = Field(False, description="If set to True, enables parallel tool calling. Defaults to False.")
 
     @field_validator("name")
     @classmethod
@@ -355,8 +406,6 @@ class UpdateAgent(BaseModel):
     tags: Optional[List[str]] = Field(None, description="The tags associated with the agent.")
     system: Optional[str] = Field(None, description="The system prompt used by the agent.")
     tool_rules: Optional[List[ToolRule]] = Field(None, description="The tool rules governing the agent.")
-    llm_config: Optional[LLMConfig] = Field(None, description="The LLM configuration used by the agent.")
-    embedding_config: Optional[EmbeddingConfig] = Field(None, description="The embedding configuration used by the agent.")
     message_ids: Optional[List[str]] = Field(None, description="The ids of the messages in the agent's in-context memory.")
     description: Optional[str] = Field(None, description="The description of the agent.")
     metadata: Optional[Dict] = Field(None, description="The metadata of the agent.")
@@ -370,22 +419,42 @@ class UpdateAgent(BaseModel):
         None,
         description="If set to True, the agent will not remember previous messages (though the agent will still retain state via core memory blocks and archival/recall memory). Not recommended unless you have an advanced use case.",
     )
-    model: Optional[str] = Field(
+
+    # model configuration
+    model: Optional[str | ModelSettings] = Field(
         None,
-        description="The LLM configuration handle used by the agent, specified in the format "
-        "provider/model-name, as an alternative to specifying llm_config.",
+        description="The model used by the agent, specified either by a handle or an object. See the model schema for more information.",
     )
-    embedding: Optional[str] = Field(
+    embedding: Optional[str | EmbeddingModelSettings] = Field(
         None, description="The embedding configuration handle used by the agent, specified in the format provider/model-name."
     )
     context_window_limit: Optional[int] = Field(None, description="The context window limit used by the agent.")
+    reasoning: Optional[bool] = Field(
+        None,
+        description="Deprecated: Use `model` field to configure reasoning instead. Whether to enable reasoning for this agent.",
+        deprecated=True,
+    )
+    llm_config: Optional[LLMConfig] = Field(
+        None, description="Deprecated: Use `model` field instead. The LLM configuration used by the agent.", deprecated=True
+    )
+    embedding_config: Optional[EmbeddingConfig] = Field(None, description="The embedding configuration used by the agent.")
+    parallel_tool_calls: Optional[bool] = Field(
+        False,
+        description="Deprecated: Use `model` field to configure parallel tool calls instead. If set to True, enables parallel tool calling.",
+        deprecated=True,
+    )
+    response_format: Optional[ResponseFormatUnion] = Field(
+        None,
+        description="Deprecated: Use `model` field to configure response format instead. The response format for the agent.",
+        deprecated=True,
+    )
     max_tokens: Optional[int] = Field(
         None,
-        description="The maximum number of tokens to generate, including reasoning step. If not set, the model will use its default value.",
+        description="Deprecated: Use `model` field to configure max output tokens instead. The maximum number of tokens to generate, including reasoning step.",
+        deprecated=True,
     )
-    reasoning: Optional[bool] = Field(None, description="Whether to enable reasoning for this agent.")
+
     enable_sleeptime: Optional[bool] = Field(None, description="If set to True, memory management will move to a background agent thread.")
-    response_format: Optional[ResponseFormatUnion] = Field(None, description="The response format for the agent.")
     last_run_completion: Optional[datetime] = Field(None, description="The timestamp when the agent last completed a run.")
     last_run_duration_ms: Optional[int] = Field(None, description="The duration in milliseconds of the agent's last run.")
     timezone: Optional[str] = Field(None, description="The timezone of the agent (IANA format).")
@@ -401,7 +470,6 @@ class UpdateAgent(BaseModel):
         None,
         description="If set to True, the agent will be hidden.",
     )
-    parallel_tool_calls: Optional[bool] = Field(False, description="If set to True, enables parallel tool calling. Defaults to False.")
 
     model_config = ConfigDict(extra="ignore")  # Ignores extra fields
 

letta/schemas/llm_config.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Literal, Optional
+from typing import TYPE_CHECKING, Annotated, Literal, Optional, Union
 
 from pydantic import BaseModel, ConfigDict, Field, model_validator
 
@@ -7,6 +7,9 @@ from letta.errors import LettaInvalidArgumentError
 from letta.log import get_logger
 from letta.schemas.enums import AgentType, ProviderCategory
 
+if TYPE_CHECKING:
+    from letta.schemas.model import ModelSettings
+
 logger = get_logger(__name__)
 
 
@@ -252,6 +255,98 @@ class LLMConfig(BaseModel):
             + (f" [ip={self.model_endpoint}]" if self.model_endpoint else "")
         )
 
+    def _to_model(self) -> "ModelSettings":
+        """
+        Convert LLMConfig back into a Model schema (OpenAIModelSettings, AnthropicModelSettings, etc.).
+        This is the inverse of the _to_legacy_config_params() methods in model.py.
+        """
+        from letta.schemas.model import (
+            AnthropicModelSettings,
+            AnthropicThinking,
+            AzureModelSettings,
+            BedrockModelSettings,
+            DeepseekModelSettings,
+            GeminiThinkingConfig,
+            GoogleAIModelSettings,
+            GoogleVertexModelSettings,
+            GroqModelSettings,
+            Model,
+            OpenAIModelSettings,
+            OpenAIReasoning,
+            TogetherModelSettings,
+            XAIModelSettings,
+        )
+
+        if self.model_endpoint_type == "openai":
+            return OpenAIModelSettings(
+                model=self.model,
+                max_output_tokens=self.max_tokens or 4096,
+                temperature=self.temperature,
+                reasoning=OpenAIReasoning(reasoning_effort=self.reasoning_effort or "minimal"),
+            )
+        elif self.model_endpoint_type == "anthropic":
+            thinking_type = "enabled" if self.enable_reasoner else "disabled"
+            return AnthropicModelSettings(
+                model=self.model,
+                max_output_tokens=self.max_tokens or 4096,
+                temperature=self.temperature,
+                thinking=AnthropicThinking(type=thinking_type, budget_tokens=self.max_reasoning_tokens or 1024),
+                verbosity=self.verbosity,
+            )
+        elif self.model_endpoint_type == "google_ai":
+            return GoogleAIModelSettings(
+                model=self.model,
+                max_output_tokens=self.max_tokens or 65536,
+                temperature=self.temperature,
+                thinking_config=GeminiThinkingConfig(
+                    include_thoughts=self.max_reasoning_tokens > 0, thinking_budget=self.max_reasoning_tokens or 1024
+                ),
+            )
+        elif self.model_endpoint_type == "google_vertex":
+            return GoogleVertexModelSettings(
+                model=self.model,
+                max_output_tokens=self.max_tokens or 65536,
+                temperature=self.temperature,
+                thinking_config=GeminiThinkingConfig(
+                    include_thoughts=self.max_reasoning_tokens > 0, thinking_budget=self.max_reasoning_tokens or 1024
+                ),
+            )
+        elif self.model_endpoint_type == "azure":
+            return AzureModelSettings(
+                model=self.model,
+                max_output_tokens=self.max_tokens or 4096,
+                temperature=self.temperature,
+            )
+        elif self.model_endpoint_type == "xai":
+            return XAIModelSettings(
+                model=self.model,
+                max_output_tokens=self.max_tokens or 4096,
+                temperature=self.temperature,
+            )
+        elif self.model_endpoint_type == "groq":
+            return GroqModelSettings(
+                model=self.model,
+                max_output_tokens=self.max_tokens or 4096,
+                temperature=self.temperature,
+            )
+        elif self.model_endpoint_type == "deepseek":
+            return DeepseekModelSettings(
+                model=self.model,
+                max_output_tokens=self.max_tokens or 4096,
+                temperature=self.temperature,
+            )
+        elif self.model_endpoint_type == "together":
+            return TogetherModelSettings(
+                model=self.model,
+                max_output_tokens=self.max_tokens or 4096,
+                temperature=self.temperature,
+            )
+        elif self.model_endpoint_type == "bedrock":
+            return Model(model=self.model, max_output_tokens=self.max_tokens or 4096)
+        else:
+            # If we don't know the model type, use the default Model schema
+            return Model(model=self.model, max_output_tokens=self.max_tokens or 4096)
+
     @classmethod
     def is_openai_reasoning_model(cls, config: "LLMConfig") -> bool:
         from letta.llm_api.openai_client import is_openai_reasoning_model

letta/schemas/model.py

@@ -0,0 +1,265 @@
+from typing import Annotated, Literal, Optional, Union
+
+from pydantic import BaseModel, Field
+
+from letta.schemas.embedding_config import EmbeddingConfig
+from letta.schemas.enums import ProviderType
+from letta.schemas.llm_config import LLMConfig
+from letta.schemas.response_format import ResponseFormatUnion
+
+
+class ModelBase(BaseModel):
+    handle: str = Field(..., description="Unique handle for API reference (format: provider_display_name/model_display_name)")
+    name: str = Field(..., description="The actual model name used by the provider")
+    display_name: str = Field(..., description="Display name for the model shown in UI")
+    provider_type: ProviderType = Field(..., description="The type of the provider")
+    provider_name: str = Field(..., description="The name of the provider")
+    model_type: Literal["llm", "embedding"] = Field(..., description="Type of model (llm or embedding)")
+
+
+class Model(ModelBase):
+    model_type: Literal["llm"] = Field("llm", description="Type of model (llm or embedding)")
+    max_context_window: int = Field(..., description="The maximum context window for the model")
+    # supports_token_streaming: Optional[bool] = Field(None, description="Whether token streaming is supported")
+    # supports_tool_calling: Optional[bool] = Field(None, description="Whether tool calling is supported")
+
+    def _from_llm_config(self, llm_config: LLMConfig) -> "Model":
+        return self(
+            handle=llm_config.handle,
+            name=llm_config.model,
+            display_name=llm_config.display_name,
+            provider_type=llm_config.model_endpoint_type,
+            provider_name=llm_config.provider_name,
+        )
+
+
+class EmbeddingModel(ModelBase):
+    model_type: Literal["embedding"] = Field("embedding", description="Type of model (llm or embedding)")
+    embedding_dim: int = Field(..., description="The dimension of the embedding")
+
+    def _from_embedding_config(self, embedding_config: EmbeddingConfig) -> "Model":
+        return self(
+            handle=embedding_config.handle,
+            name=embedding_config.embedding_model,
+            display_name=embedding_config.embedding_model,
+            provider_type=embedding_config.embedding_endpoint_type,
+            provider_name=embedding_config.embedding_endpoint_type,
+        )
+
+
+class ModelSettings(BaseModel):
+    """Schema for defining settings for a model"""
+
+    model: str = Field(..., description="The name of the model.")
+    max_output_tokens: int = Field(4096, description="The maximum number of tokens the model can generate.")
+
+
+class OpenAIReasoning(BaseModel):
+    reasoning_effort: Literal["minimal", "low", "medium", "high"] = Field(
+        "minimal", description="The reasoning effort to use when generating text reasoning models"
+    )
+
+    # TODO: implement support for this
+    # summary: Optional[Literal["auto", "detailed"]] = Field(
+    #    None, description="The reasoning summary level to use when generating text reasoning models"
+    # )
+
+
+class OpenAIModelSettings(ModelSettings):
+    provider: Literal["openai"] = Field("openai", description="The provider of the model.")
+    temperature: float = Field(0.7, description="The temperature of the model.")
+    reasoning: OpenAIReasoning = Field(OpenAIReasoning(reasoning_effort="high"), description="The reasoning configuration for the model.")
+    response_format: Optional[ResponseFormatUnion] = Field(None, description="The response format for the model.")
+
+    # TODO: implement support for these
+    # reasoning_summary: Optional[Literal["none", "short", "detailed"]] = Field(
+    #    None, description="The reasoning summary level to use when generating text reasoning models"
+    # )
+    # max_tool_calls: int = Field(10, description="The maximum number of tool calls the model can make.")
+    # parallel_tool_calls: bool = Field(False, description="Whether the model supports parallel tool calls.")
+    # top_logprobs: int = Field(10, description="The number of top logprobs to return.")
+    # top_p: float = Field(1.0, description="The top-p value to use when generating text.")
+
+    def _to_legacy_config_params(self) -> dict:
+        return {
+            "temperature": self.temperature,
+            "max_tokens": self.max_output_tokens,
+            "reasoning_effort": self.reasoning.reasoning_effort,
+            "response_format": self.response_format,
+        }
+
+
+#    "thinking": {
+#        "type": "enabled",
+#        "budget_tokens": 10000
+#    }
+
+
+class AnthropicThinking(BaseModel):
+    type: Literal["enabled", "disabled"] = Field("enabled", description="The type of thinking to use.")
+    budget_tokens: int = Field(1024, description="The maximum number of tokens the model can use for extended thinking.")
+
+
+class AnthropicModelSettings(ModelSettings):
+    provider: Literal["anthropic"] = Field("anthropic", description="The provider of the model.")
+    temperature: float = Field(1.0, description="The temperature of the model.")
+    thinking: AnthropicThinking = Field(
+        AnthropicThinking(type="enabled", budget_tokens=1024), description="The thinking configuration for the model."
+    )
+
+    # gpt-5 models only
+    verbosity: Optional[Literal["low", "medium", "high"]] = Field(
+        None,
+        description="Soft control for how verbose model output should be, used for GPT-5 models.",
+    )
+
+    # TODO: implement support for these
+    # top_k: Optional[int] = Field(None, description="The number of top tokens to return.")
+    # top_p: Optional[float] = Field(None, description="The top-p value to use when generating text.")
+
+    def _to_legacy_config_params(self) -> dict:
+        return {
+            "temperature": self.temperature,
+            "max_tokens": self.max_output_tokens,
+            "extended_thinking": self.thinking.type == "enabled",
+            "thinking_budget_tokens": self.thinking.budget_tokens,
+            "verbosity": self.verbosity,
+        }
+
+
+class GeminiThinkingConfig(BaseModel):
+    include_thoughts: bool = Field(True, description="Whether to include thoughts in the model's response.")
+    thinking_budget: int = Field(1024, description="The thinking budget for the model.")
+
+
+class GoogleAIModelSettings(ModelSettings):
+    provider: Literal["google_ai"] = Field("google_ai", description="The provider of the model.")
+    temperature: float = Field(0.7, description="The temperature of the model.")
+    thinking_config: GeminiThinkingConfig = Field(
+        GeminiThinkingConfig(include_thoughts=True, thinking_budget=1024), description="The thinking configuration for the model."
+    )
+    response_schema: Optional[ResponseFormatUnion] = Field(None, description="The response schema for the model.")
+    max_output_tokens: int = Field(65536, description="The maximum number of tokens the model can generate.")
+
+    def _to_legacy_config_params(self) -> dict:
+        return {
+            "temperature": self.temperature,
+            "max_tokens": self.max_output_tokens,
+            "max_reasoning_tokens": self.thinking_config.thinking_budget if self.thinking_config.include_thoughts else 0,
+        }
+
+
+class GoogleVertexModelSettings(GoogleAIModelSettings):
+    provider: Literal["google_vertex"] = Field("google_vertex", description="The provider of the model.")
+
+
+class AzureModelSettings(ModelSettings):
+    """Azure OpenAI model configuration (OpenAI-compatible)."""
+
+    provider: Literal["azure"] = Field("azure", description="The provider of the model.")
+    temperature: float = Field(0.7, description="The temperature of the model.")
+    response_format: Optional[ResponseFormatUnion] = Field(None, description="The response format for the model.")
+
+    def _to_legacy_config_params(self) -> dict:
+        return {
+            "temperature": self.temperature,
+            "max_tokens": self.max_output_tokens,
+            "response_format": self.response_format,
+        }
+
+
+class XAIModelSettings(ModelSettings):
+    """xAI model configuration (OpenAI-compatible)."""
+
+    provider: Literal["xai"] = Field("xai", description="The provider of the model.")
+    temperature: float = Field(0.7, description="The temperature of the model.")
+    response_format: Optional[ResponseFormatUnion] = Field(None, description="The response format for the model.")
+
+    def _to_legacy_config_params(self) -> dict:
+        return {
+            "temperature": self.temperature,
+            "max_tokens": self.max_output_tokens,
+            "response_format": self.response_format,
+        }
+
+
+class GroqModelSettings(ModelSettings):
+    """Groq model configuration (OpenAI-compatible)."""
+
+    provider: Literal["groq"] = Field("groq", description="The provider of the model.")
+    temperature: float = Field(0.7, description="The temperature of the model.")
+    response_format: Optional[ResponseFormatUnion] = Field(None, description="The response format for the model.")
+
+    def _to_legacy_config_params(self) -> dict:
+        return {
+            "temperature": self.temperature,
+            "max_tokens": self.max_output_tokens,
+            "response_format": self.response_format,
+        }
+
+
+class DeepseekModelSettings(ModelSettings):
+    """Deepseek model configuration (OpenAI-compatible)."""
+
+    provider: Literal["deepseek"] = Field("deepseek", description="The provider of the model.")
+    temperature: float = Field(0.7, description="The temperature of the model.")
+    response_format: Optional[ResponseFormatUnion] = Field(None, description="The response format for the model.")
+
+    def _to_legacy_config_params(self) -> dict:
+        return {
+            "temperature": self.temperature,
+            "max_tokens": self.max_output_tokens,
+            "response_format": self.response_format,
+        }
+
+
+class TogetherModelSettings(ModelSettings):
+    """Together AI model configuration (OpenAI-compatible)."""
+
+    provider: Literal["together"] = Field("together", description="The provider of the model.")
+    temperature: float = Field(0.7, description="The temperature of the model.")
+    response_format: Optional[ResponseFormatUnion] = Field(None, description="The response format for the model.")
+
+    def _to_legacy_config_params(self) -> dict:
+        return {
+            "temperature": self.temperature,
+            "max_tokens": self.max_output_tokens,
+            "response_format": self.response_format,
+        }
+
+
+class BedrockModelSettings(ModelSettings):
+    """AWS Bedrock model configuration."""
+
+    provider: Literal["bedrock"] = Field("bedrock", description="The provider of the model.")
+    temperature: float = Field(0.7, description="The temperature of the model.")
+    response_format: Optional[ResponseFormatUnion] = Field(None, description="The response format for the model.")
+
+    def _to_legacy_config_params(self) -> dict:
+        return {
+            "temperature": self.temperature,
+            "max_tokens": self.max_output_tokens,
+            "response_format": self.response_format,
+        }
+
+
+ModelSettingsUnion = Annotated[
+    Union[
+        OpenAIModelSettings,
+        AnthropicModelSettings,
+        GoogleAIModelSettings,
+        GoogleVertexModelSettings,
+        AzureModelSettings,
+        XAIModelSettings,
+        GroqModelSettings,
+        DeepseekModelSettings,
+        TogetherModelSettings,
+        BedrockModelSettings,
+    ],
+    Field(discriminator="provider"),
+]
+
+
+class EmbeddingModelSettings(BaseModel):
+    model: str = Field(..., description="The name of the model.")
+    provider: Literal["openai", "ollama"] = Field(..., description="The provider of the model.")

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

@@ -7,6 +7,7 @@ from httpx import ConnectError, HTTPStatusError
 from pydantic import BaseModel, Field
 from starlette.responses import StreamingResponse
 
+from letta.constants import DEFAULT_GENERATE_TOOL_MODEL_HANDLE
 from letta.errors import (
     LettaInvalidArgumentError,
     LettaInvalidMCPSchemaError,
@@ -817,7 +818,7 @@ async def generate_tool_from_prompt(
     Generate a tool from the given user prompt.
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
-    llm_config = await server.get_cached_llm_config_async(actor=actor, handle=request.handle or "anthropic/claude-3-5-sonnet-20240620")
+    llm_config = await server.get_cached_llm_config_async(actor=actor, handle=request.handle or DEFAULT_GENERATE_TOOL_MODEL_HANDLE)
     formatted_prompt = (
         f"Generate a python function named {request.tool_name} using the instructions below "
         + (f"based on this starter code: \n\n```\n{request.starter_code}\n```\n\n" if request.starter_code else "\n")

letta/server/server.py

@@ -414,18 +414,31 @@ class SyncServer(object):
         actor: User,
     ) -> AgentState:
         if request.llm_config is None:
+            additional_config_params = {}
             if request.model is None:
                 if settings.default_llm_handle is None:
                     raise LettaInvalidArgumentError("Must specify either model or llm_config in request", argument_name="model")
                 else:
-                    request.model = settings.default_llm_handle
+                    handle = settings.default_llm_handle
+            else:
+                if isinstance(request.model, str):
+                    handle = request.model
+                elif isinstance(request.model, list):
+                    raise LettaInvalidArgumentError("Multiple models are not supported yet")
+                else:
+                    # EXTREMELEY HACKY, TEMPORARY WORKAROUND
+                    handle = f"{request.model.provider}/{request.model.model}"
+                    # TODO: figure out how to override various params
+                    additional_config_params = request.model._to_legacy_config_params()
+
             config_params = {
-                "handle": request.model,
+                "handle": handle,
                 "context_window_limit": request.context_window_limit,
                 "max_tokens": request.max_tokens,
                 "max_reasoning_tokens": request.max_reasoning_tokens,
                 "enable_reasoner": request.enable_reasoner,
             }
+            config_params.update(additional_config_params)
             log_event(name="start get_cached_llm_config", attributes=config_params)
             request.llm_config = await self.get_cached_llm_config_async(actor=actor, **config_params)
             log_event(name="end get_cached_llm_config", attributes=config_params)

letta/services/tool_sandbox/e2b_sandbox.py

@@ -102,7 +102,10 @@ class AsyncToolSandboxE2B(AsyncToolSandboxBase):
                     function_name=self.tool_name, exception_name=execution.error.name, exception_message=execution.error.value
                 )
                 execution.logs.stderr.append(execution.error.traceback)
-                logger.info(f"E2B execution failed for ID {e2b_sandbox.sandbox_id}: {self.tool_name}")
+                logger.info(
+                    f"E2B execution failed for ID {e2b_sandbox.sandbox_id}: {self.tool_name} - {execution.error.name}: {execution.error.value}"
+                )
+                logger.info(f"Traceback from e2b sandbox: \n{execution.error.traceback}")
                 log_event(
                     "e2b_execution_failed",
                     {

{letta_nightly-0.13.1.dev20251031234110.dist-info → letta_nightly-0.13.1.dev20251101010313.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: letta-nightly
-Version: 0.13.1.dev20251031234110
+Version: 0.13.1.dev20251101010313
 Summary: Create LLM agents with long-term memory and custom tools
 Author-email: Letta Team <contact@letta.com>
 License: Apache License

{letta_nightly-0.13.1.dev20251031234110.dist-info → letta_nightly-0.13.1.dev20251101010313.dist-info}/RECORD

@@ -1,6 +1,6 @@
 letta/__init__.py,sha256=YlR4nqIpZF60QUQkvQkraiAf38hf-XYQovJcX6p2dvg,1584
 letta/config.py,sha256=JFGY4TWW0Wm5fTbZamOwWqk5G8Nn-TXyhgByGoAqy2c,12375
-letta/constants.py,sha256=XAVJMQ4Vyhhgrz2zwZBXrT-D6NX8J-QaPnQvpfim-dE,17387
+letta/constants.py,sha256=yinedHPbuiMOssZk5fPEAYQi1aufNKp3JPjiHSLExJQ,17492
 letta/database_utils.py,sha256=D0lIbOkUQDBd2cJL1bmepyrsD5Rl29ZZLMkwnB7z8o0,4492
 letta/embeddings.py,sha256=d2o1nOVTaofBk6j-WwsE0_ugvxa1nIOcceqGuJ4w_pc,2045
 letta/errors.py,sha256=NYotz1OUZYFzn0IV6Koe8n3BcVqo0_wSEvQEL8x4LjI,12323
@@ -31,7 +31,7 @@ letta/agents/helpers.py,sha256=p50RU_zXs0Xejiqjc3sSrDgAnoUizwUBieFTicfo4kU,18339
 letta/agents/letta_agent.py,sha256=SJu7Ydwy8Bb_DYfd08XOXK_d2_uPb9GIV566Eb5cHDI,98308
 letta/agents/letta_agent_batch.py,sha256=NizNeIHvFtG4XpZCIplOSF8GohwHvNEkAUvsFBSdtSs,27950
 letta/agents/letta_agent_v2.py,sha256=CDTdlEWVhQj9nxQmXsavmB1e_Crm4UsnWeY0ORLd0-I,60937
-letta/agents/letta_agent_v3.py,sha256=Fg_fGcZFLvfXAIAYbkzeuKV5zBZonQRnklAwPyBIPFE,56600
+letta/agents/letta_agent_v3.py,sha256=JuNj_Wfkc8sv6X84LlbOA7H1hsqLqcz_R4JFA7-IC4A,57222
 letta/agents/voice_agent.py,sha256=4xhg4zU_2kTIC_WHe5cq5XP1JJ_PLmB2qPViq4iFuUI,23299
 letta/agents/voice_sleeptime_agent.py,sha256=9TyvhrqcmfCJFHQZCoYfkU1S9eRyTnHsFPm4Jq91xaA,8675
 letta/agents/temporal/constants.py,sha256=toRW2XGGCJVpW0Zeupw4tR4UCgsTrmqAAE5NwY2DPec,2600
@@ -114,7 +114,7 @@ letta/llm_api/bedrock_client.py,sha256=b1N5c7FCUMgrGN-KNZM7QWHE3sdNbQZ806ab5O64I
 letta/llm_api/deepseek_client.py,sha256=GOW_kHuZRuDmA6EntB6jq-6LIQhsV01T7r8dQg2QytE,17313
 letta/llm_api/google_ai_client.py,sha256=whFvP8kvPUBNzHGmpVdWGpgeE5pF4G6ziQMrIk57hEQ,7830
 letta/llm_api/google_constants.py,sha256=eOjOv-FImyJ4b4QGIaod-mEROMtrBFz0yhuYHqOEkwY,797
-letta/llm_api/google_vertex_client.py,sha256=t8LT5A_67f-iAgyISvd8u6ynqCaGErqBTaFhtMMFOrs,39585
+letta/llm_api/google_vertex_client.py,sha256=SzOSnESLkiK8_RTEEj0DAqXoyyLf3Pb2bt3D1w0CLXk,39711
 letta/llm_api/groq_client.py,sha256=-b1LehNEvAzQ5ZjrMaIANrosf-ZxGMbRbpPih82fzz0,3421
 letta/llm_api/helpers.py,sha256=GVUWBv3N1PYDi1m4GvKykQIcUCJAPjVUmYRC9XHmPTQ,18874
 letta/llm_api/llm_api_tools.py,sha256=AMF4q-eZsuT9aAkjPJmhiNFTxAEKIHjZZuvhfxQihWA,12747
@@ -168,7 +168,7 @@ letta/local_llm/webui/settings.py,sha256=gmLHfiOl1u4JmlAZU2d2O8YKF9lafdakyjwR_ft
 letta/openai_backcompat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/openai_backcompat/openai_object.py,sha256=GSzeCTwLpLD2fH4X8wVqzwdmoTjKK2I4PnriBY453lc,13505
 letta/orm/__init__.py,sha256=ZlnnsQu3PSzpHyGmXsBnHZCfRiiszUkND3G69Ma6fr0,1707
-letta/orm/agent.py,sha256=vZoMUyeIX_WfF0E08sUkhJ-rqOtWFO5ccTZ0VSyzg6c,18967
+letta/orm/agent.py,sha256=kWJf5VcHXIknM7CALyGFL5_q5rDVHk545JtkxaWSwL4,19132
 letta/orm/agents_tags.py,sha256=-rWR8DoEiHM4yc9vAHgHuvjIwgMXMWzKnTKFlBBu3TQ,1076
 letta/orm/archive.py,sha256=8O8k2gyoMi2EvG0P76WLOz1n1DPLm3VcZJlmKGWeVY8,4143
 letta/orm/archives_agents.py,sha256=hIhaIRQPuNv-etQVWnIQhEomiumLC1OWR-T_s0Y7snM,1273
@@ -254,7 +254,7 @@ letta/prompts/system_prompts/summary_system_prompt.py,sha256=-jy_PL6Cwxjs3p3AiTR
 letta/prompts/system_prompts/voice_chat.py,sha256=WLhjlVsVcQPc5S6y5hgw1SdVhdhtflNiwdpfSx3abwk,1871
 letta/prompts/system_prompts/voice_sleeptime.py,sha256=2rgZYqJEqSp5bcEAXNuqM1PVsvPF1vm8sAqmhoOfQow,3714
 letta/prompts/system_prompts/workflow.py,sha256=mth_46sY9JWx0rV-kqiGcu2IZGzZQfKY345qBUjvP-s,852
-letta/schemas/agent.py,sha256=8CFlsDUELHpFpDMtB3ABOGoH41tzBT_YBM_HvvzyA-Y,24402
+letta/schemas/agent.py,sha256=3GkplXD1sAfkevh4J9KgdFGK-YIvRdIJWhBKiaZFf8o,26681
 letta/schemas/agent_file.py,sha256=M2NcfC8HQFtZy3CGII3VQ5yqcpCEYTLNXoLxjDbzXKA,15746
 letta/schemas/archive.py,sha256=cWnncf8HXm2qMoPSbGP3kNn-X-FKfEkew3408OnKt50,2094
 letta/schemas/block.py,sha256=WzeHzeRpyCAz32zQPaHDO_UGbZZVuOHcj6P41Rc2xvY,9167
@@ -275,12 +275,13 @@ letta/schemas/letta_request.py,sha256=Y7UMuS4m8z9PNDbZY07FRM9WW_TpyPxDsiT-57Ron5
 letta/schemas/letta_response.py,sha256=2I525MuW3R05sPyfYtFLvuhn6nfdhLrfCwirFFTVc2A,8896
 letta/schemas/letta_stop_reason.py,sha256=nwqB0oeEDjmDYuN-tF23AKHVEAV3Snjv8NvnW8vS1ZE,1552
 letta/schemas/llm_batch_job.py,sha256=_WD_maJGsfUQzeDxJC1sbkac4yySbRh-7OZLh85euDE,3191
-letta/schemas/llm_config.py,sha256=3aME4W7tnG8Pl5UBRcD2p3Prj0vCdZxlHN4E-4ZqSK4,18019
+letta/schemas/llm_config.py,sha256=d8NvbBzgW0TdxKmpujhaK2O7TCm5QvoEzplC4Cabu38,22109
 letta/schemas/llm_config_overrides.py,sha256=E6qJuVA8TwAAy3VjGitJ5jSQo5PbN-6VPcZOF5qhP9A,1815
 letta/schemas/mcp.py,sha256=zCUvOxwuYk2goQ5A7JhYcmVrI7fnGqi_celO-vyKmcw,15282
 letta/schemas/mcp_server.py,sha256=EKAVV9eEBhuQMPFupZi_9nVxZ5DfU_VzDmUZc4VrROk,15557
 letta/schemas/memory.py,sha256=VWgSqhhNAqggM7U1-bygDo2uLrm4fM6XRyTXNE1JaiI,20851
 letta/schemas/message.py,sha256=ZfWCcgW2OOoAO8uDQNO0kRYmjQN3I1fMH9Tswpef26c,91437
+letta/schemas/model.py,sha256=jl0cqqzbu-L3YMPSWeOprqvamD--4hy3Lrx9aPO0134,11527
 letta/schemas/npm_requirement.py,sha256=HkvBF7KjHUH-MG-RAEYJHO2MLRS2rxFUcmbpbZVznLk,457
 letta/schemas/organization.py,sha256=VUBG83eRptIDtTuDuDdmIkxfOiQs9vDQRwN04YKA72g,1352
 letta/schemas/passage.py,sha256=lgIQu6pikQtQzRhaYPRtBvW8ooM4jFPkJWNL-nuK4Pk,4004
@@ -340,7 +341,7 @@ letta/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/constants.py,sha256=yAdGbLkzlOU_dLTx0lKDmAnj0ZgRXCEaIcPJWO69eaE,92
 letta/server/db.py,sha256=bh294tLdOQxOrO9jICDrXa_UXTAYFByu_47tPXlKrjs,3006
 letta/server/generate_openapi_schema.sh,sha256=14Q6r0fbNNVVdf4X3Z-H0ZtyrVw5zYLzL5Doom3kM9k,351
-letta/server/server.py,sha256=JkOO1313si2CfuovHEA2WWCji9CRRhmVjvMl8BJUa6I,80281
+letta/server/server.py,sha256=5xyWTgCEa1YW8rWxC-I2iHyVoVqDqr5idDuUcpEu7cs,80948
 letta/server/startup.sh,sha256=z-Fea-7LiuS_aG1tJqS8JAsDQaamwC_kuDhv9D3PPPY,2698
 letta/server/utils.py,sha256=rRvW6L1lzau4u9boamiyZH54lf5tQ91ypXzUW9cfSPA,1667
 letta/server/rest_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -386,7 +387,7 @@ letta/server/rest_api/routers/v1/sources.py,sha256=fAyjOnt9nWh6UHmuka3-rDoen8c3c
 letta/server/rest_api/routers/v1/steps.py,sha256=-2hL2le0m5a2UrAxk9XomDv51x2LPz_04s7vxD-eslo,7800
 letta/server/rest_api/routers/v1/tags.py,sha256=rGPO5GaVBn18hu7D3Ysyo45ka47g9DUir3UVh433DEc,1826
 letta/server/rest_api/routers/v1/telemetry.py,sha256=8rzSii17BK8BjRRfV4Yr6mrKrbZEHySlUaQBGBWhxwY,1124
-letta/server/rest_api/routers/v1/tools.py,sha256=CV3RWssZ_xLCjUA9K8Jgv9keKruUtu9lHt-uCGYafYo,38670
+letta/server/rest_api/routers/v1/tools.py,sha256=lkECxbhAlR1Nbh41khc1IoLkAGy3FdKpJdUw-AYqbbU,38729
 letta/server/rest_api/routers/v1/users.py,sha256=yOEO0uoPlBFnFCpEIKHcAXbllekbI659Q5snGDYaZgg,2012
 letta/server/rest_api/routers/v1/voice.py,sha256=9rscer9YnFm_UEk6ujUM9Sk9wZNAii-HdO4gpVG9WLE,1714
 letta/server/static_files/favicon.ico,sha256=DezhLdFSbM8o81wCOZcV3riq7tFUOGQD4h6-vr-HuU0,342
@@ -475,7 +476,7 @@ letta/services/tool_executor/tool_execution_sandbox.py,sha256=mDK8ZrtC-Fe8MY9gmh
 letta/services/tool_executor/tool_executor_base.py,sha256=1U3Jlfb3uzLOJcMb6jM05axpvO4LFrpKsOMXkiwIUFc,1566
 letta/services/tool_sandbox/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/tool_sandbox/base.py,sha256=3CsViUfv63ot5k0TY-VfGJhUEcsp7GlFlE2my-ySge8,16184
-letta/services/tool_sandbox/e2b_sandbox.py,sha256=a2M1Qxj_kCLQBrJ5vWItreJ2phPWT1Cq3j43d3yvo_A,11260
+letta/services/tool_sandbox/e2b_sandbox.py,sha256=48QDy94ftWVIFgW1ZCjfI8xdIHCWsxa2AocX-6hZo5Y,11438
 letta/services/tool_sandbox/local_sandbox.py,sha256=1WipHjp8f-QZaBYOKnwSc4ccwffeqMXAW0bP0S-7EME,11907
 letta/services/tool_sandbox/modal_constants.py,sha256=AaXPxSlCj2BhfY5DGwQvqHXfikpurhV2iFsN7zxM3Is,454
 letta/services/tool_sandbox/modal_deployment_manager.py,sha256=rNDcaHSC3ALA8gAgwAnMG-sbz67zqm6Oa8lgSku0Ah0,9157
@@ -488,8 +489,8 @@ letta/templates/sandbox_code_file.py.j2,sha256=eXga5J_04Z8-pGdwfOCDjcRnMceIqcF5i
 letta/templates/sandbox_code_file_async.py.j2,sha256=lb7nh_P2W9VZHzU_9TxSCEMUod7SDziPXgvT75xVds0,2748
 letta/templates/summary_request_text.j2,sha256=ZttQwXonW2lk4pJLYzLK0pmo4EO4EtUUIXjgXKiizuc,842
 letta/types/__init__.py,sha256=hokKjCVFGEfR7SLMrtZsRsBfsC7yTIbgKPLdGg4K1eY,147
-letta_nightly-0.13.1.dev20251031234110.dist-info/METADATA,sha256=WANw67-KRDs7pR_TuUEzaxrwm4uRME_Qba0IbBoYhl0,24544
-letta_nightly-0.13.1.dev20251031234110.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-letta_nightly-0.13.1.dev20251031234110.dist-info/entry_points.txt,sha256=m-94Paj-kxiR6Ktu0us0_2qfhn29DzF2oVzqBE6cu8w,41
-letta_nightly-0.13.1.dev20251031234110.dist-info/licenses/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.13.1.dev20251031234110.dist-info/RECORD,,
+letta_nightly-0.13.1.dev20251101010313.dist-info/METADATA,sha256=ZITsj59domKh92JEtvcy5vimGKdW9YDVZemDkVizRY4,24544
+letta_nightly-0.13.1.dev20251101010313.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+letta_nightly-0.13.1.dev20251101010313.dist-info/entry_points.txt,sha256=m-94Paj-kxiR6Ktu0us0_2qfhn29DzF2oVzqBE6cu8w,41
+letta_nightly-0.13.1.dev20251101010313.dist-info/licenses/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.13.1.dev20251101010313.dist-info/RECORD,,