letta-nightly 0.12.1.dev20251024104217__py3-none-any.whl → 0.13.0.dev20251025104015__py3-none-any.whl

letta/schemas/providers/google_gemini.py

@@ -1,6 +1,10 @@
 import asyncio
 from typing import Literal
 
+from letta.log import get_logger
+
+logger = get_logger(__name__)
+
 from pydantic import Field
 
 from letta.constants import DEFAULT_EMBEDDING_CHUNK_SIZE, LLM_MAX_TOKENS
@@ -19,13 +23,15 @@ class GoogleAIProvider(Provider):
     async def check_api_key(self):
         from letta.llm_api.google_ai_client import google_ai_check_valid_api_key
 
-        google_ai_check_valid_api_key(self.api_key)
+        api_key = self.get_api_key_secret().get_plaintext()
+        google_ai_check_valid_api_key(api_key)
 
     async def list_llm_models_async(self):
         from letta.llm_api.google_ai_client import google_ai_get_model_list_async
 
         # Get and filter the model list
-        model_options = await google_ai_get_model_list_async(base_url=self.base_url, api_key=self.api_key)
+        api_key = self.get_api_key_secret().get_plaintext()
+        model_options = await google_ai_get_model_list_async(base_url=self.base_url, api_key=api_key)
         model_options = [mo for mo in model_options if "generateContent" in mo["supportedGenerationMethods"]]
         model_options = [str(m["name"]) for m in model_options]
 
@@ -58,7 +64,8 @@ class GoogleAIProvider(Provider):
         from letta.llm_api.google_ai_client import google_ai_get_model_list_async
 
         # TODO: use base_url instead
-        model_options = await google_ai_get_model_list_async(base_url=self.base_url, api_key=self.api_key)
+        api_key = self.get_api_key_secret().get_plaintext()
+        model_options = await google_ai_get_model_list_async(base_url=self.base_url, api_key=api_key)
         return self._list_embedding_models(model_options)
 
     def _list_embedding_models(self, model_options):
@@ -85,13 +92,14 @@ class GoogleAIProvider(Provider):
     def get_model_context_window(self, model_name: str) -> int | None:
         import warnings
 
-        warnings.warn("This is deprecated, use get_model_context_window_async when possible.", DeprecationWarning)
+        logger.warning("This is deprecated, use get_model_context_window_async when possible.")
         from letta.llm_api.google_ai_client import google_ai_get_model_context_window
 
         if model_name in LLM_MAX_TOKENS:
             return LLM_MAX_TOKENS[model_name]
         else:
-            return google_ai_get_model_context_window(self.base_url, self.api_key, model_name)
+            api_key = self.get_api_key_secret().get_plaintext()
+            return google_ai_get_model_context_window(self.base_url, api_key, model_name)
 
     async def get_model_context_window_async(self, model_name: str) -> int | None:
         from letta.llm_api.google_ai_client import google_ai_get_model_context_window_async
@@ -99,4 +107,5 @@ class GoogleAIProvider(Provider):
         if model_name in LLM_MAX_TOKENS:
             return LLM_MAX_TOKENS[model_name]
         else:
-            return await google_ai_get_model_context_window_async(self.base_url, self.api_key, model_name)
+            api_key = self.get_api_key_secret().get_plaintext()
+            return await google_ai_get_model_context_window_async(self.base_url, api_key, model_name)

letta/schemas/providers/groq.py

@@ -16,7 +16,8 @@ class GroqProvider(OpenAIProvider):
     async def list_llm_models_async(self) -> list[LLMConfig]:
         from letta.llm_api.openai import openai_get_model_list_async
 
-        response = await openai_get_model_list_async(self.base_url, api_key=self.api_key)
+        api_key = self.get_api_key_secret().get_plaintext()
+        response = await openai_get_model_list_async(self.base_url, api_key=api_key)
         configs = []
         for model in response["data"]:
             if "context_window" not in model:

letta/schemas/providers/lmstudio.py

@@ -1,6 +1,9 @@
-import warnings
 from typing import Literal
 
+from letta.log import get_logger
+
+logger = get_logger(__name__)
+
 from pydantic import Field
 
 from letta.constants import DEFAULT_EMBEDDING_CHUNK_SIZE
@@ -27,14 +30,14 @@ class LMStudioOpenAIProvider(OpenAIProvider):
         response = await openai_get_model_list_async(self.model_endpoint_url)
 
         if "data" not in response:
-            warnings.warn(f"LMStudio OpenAI model query response missing 'data' field: {response}")
+            logger.warning(f"LMStudio OpenAI model query response missing 'data' field: {response}")
             return []
 
         configs = []
         for model in response["data"]:
             model_type = model.get("type")
             if not model_type:
-                warnings.warn(f"LMStudio OpenAI model missing 'type' field: {model}")
+                logger.warning(f"LMStudio OpenAI model missing 'type' field: {model}")
                 continue
             if model_type not in ("vlm", "llm"):
                 continue
@@ -48,7 +51,7 @@ class LMStudioOpenAIProvider(OpenAIProvider):
             if "compatibility_type" in model:
                 compatibility_type = model["compatibility_type"]
             else:
-                warnings.warn(f"LMStudio OpenAI model missing 'compatibility_type' field: {model}")
+                logger.warning(f"LMStudio OpenAI model missing 'compatibility_type' field: {model}")
                 continue
 
             configs.append(
@@ -72,14 +75,14 @@ class LMStudioOpenAIProvider(OpenAIProvider):
         response = await openai_get_model_list_async(self.model_endpoint_url)
 
         if "data" not in response:
-            warnings.warn(f"LMStudio OpenAI model query response missing 'data' field: {response}")
+            logger.warning(f"LMStudio OpenAI model query response missing 'data' field: {response}")
             return []
 
         configs = []
         for model in response["data"]:
             model_type = model.get("type")
             if not model_type:
-                warnings.warn(f"LMStudio OpenAI model missing 'type' field: {model}")
+                logger.warning(f"LMStudio OpenAI model missing 'type' field: {model}")
                 continue
             if model_type not in ("embeddings"):
                 continue

letta/schemas/providers/mistral.py

@@ -18,7 +18,8 @@ class MistralProvider(Provider):
 
         # Some hardcoded support for OpenRouter (so that we only get models with tool calling support)...
         # See: https://openrouter.ai/docs/requests
-        response = await mistral_get_model_list_async(self.base_url, api_key=self.api_key)
+        api_key = self.get_api_key_secret().get_plaintext()
+        response = await mistral_get_model_list_async(self.base_url, api_key=api_key)
 
         assert "data" in response, f"Mistral model query response missing 'data' field: {response}"
 

letta/schemas/providers/openai.py

@@ -25,7 +25,9 @@ class OpenAIProvider(Provider):
     async def check_api_key(self):
         from letta.llm_api.openai import openai_check_valid_api_key  # TODO: DO NOT USE THIS - old code path
 
-        openai_check_valid_api_key(self.base_url, self.api_key)
+        # Decrypt API key before using
+        api_key = self.get_api_key_secret().get_plaintext()
+        openai_check_valid_api_key(self.base_url, api_key)
 
     async def _get_models_async(self) -> list[dict]:
         from letta.llm_api.openai import openai_get_model_list_async
@@ -37,9 +39,12 @@ class OpenAIProvider(Provider):
         # Similar to Nebius
         extra_params = {"verbose": True} if "nebius.com" in self.base_url else None
 
+        # Decrypt API key before using
+        api_key = self.get_api_key_secret().get_plaintext()
+
         response = await openai_get_model_list_async(
             self.base_url,
-            api_key=self.api_key,
+            api_key=api_key,
             extra_params=extra_params,
             # fix_url=True,  # NOTE: make sure together ends with /v1
         )

letta/schemas/providers/together.py

@@ -4,6 +4,10 @@ Note: this supports completions (deprecated by openai) and chat completions via
 
 from typing import Literal, Optional
 
+from letta.log import get_logger
+
+logger = get_logger(__name__)
+
 from pydantic import Field
 
 from letta.constants import MIN_CONTEXT_WINDOW
@@ -26,13 +30,14 @@ class TogetherProvider(OpenAIProvider):
     async def list_llm_models_async(self) -> list[LLMConfig]:
         from letta.llm_api.openai import openai_get_model_list_async
 
-        models = await openai_get_model_list_async(self.base_url, api_key=self.api_key)
+        api_key = self.get_api_key_secret().get_plaintext()
+        models = await openai_get_model_list_async(self.base_url, api_key=api_key)
         return self._list_llm_models(models)
 
     async def list_embedding_models_async(self) -> list[EmbeddingConfig]:
         import warnings
 
-        warnings.warn(
+        logger.warning(
             "Letta does not currently support listing embedding models for Together. Please "
             "contact support or reach out via GitHub or Discord to get support."
         )
@@ -88,7 +93,8 @@ class TogetherProvider(OpenAIProvider):
         return configs
 
     async def check_api_key(self):
-        if not self.api_key:
+        api_key = self.get_api_key_secret().get_plaintext()
+        if not api_key:
             raise ValueError("No API key provided")
 
         try:

letta/schemas/providers/xai.py

@@ -1,6 +1,9 @@
-import warnings
 from typing import Literal
 
+from letta.log import get_logger
+
+logger = get_logger(__name__)
+
 from pydantic import Field
 
 from letta.schemas.enums import ProviderCategory, ProviderType
@@ -32,7 +35,8 @@ class XAIProvider(OpenAIProvider):
     async def list_llm_models_async(self) -> list[LLMConfig]:
         from letta.llm_api.openai import openai_get_model_list_async
 
-        response = await openai_get_model_list_async(self.base_url, api_key=self.api_key)
+        api_key = self.get_api_key_secret().get_plaintext()
+        response = await openai_get_model_list_async(self.base_url, api_key=api_key)
 
         data = response.get("data", response)
 
@@ -48,7 +52,7 @@ class XAIProvider(OpenAIProvider):
                 context_window_size = self.get_model_context_window_size(model_name)
 
             if not context_window_size:
-                warnings.warn(f"Couldn't find context window size for model {model_name}")
+                logger.warning(f"Couldn't find context window size for model {model_name}")
                 continue
 
             configs.append(

letta/schemas/run.py

@@ -4,14 +4,14 @@ from typing import Optional
 from pydantic import ConfigDict, Field
 
 from letta.helpers.datetime_helpers import get_utc_time
-from letta.schemas.enums import RunStatus
+from letta.schemas.enums import PrimitiveType, RunStatus
 from letta.schemas.job import LettaRequestConfig
 from letta.schemas.letta_base import LettaBase
 from letta.schemas.letta_stop_reason import StopReasonType
 
 
 class RunBase(LettaBase):
-    __id_prefix__ = "run"
+    __id_prefix__ = PrimitiveType.RUN.value
 
 
 class Run(RunBase):
@@ -25,6 +25,7 @@ class Run(RunBase):
         created_at (datetime): The timestamp when the run was created.
         completed_at (datetime): The timestamp when the run was completed.
         agent_id (str): The unique identifier of the agent associated with the run.
+        base_template_id (str): The base template ID that the run belongs to.
         stop_reason (StopReasonType): The reason why the run was stopped.
         background (bool): Whether the run was created in background mode.
         metadata (dict): Additional metadata for the run.
@@ -41,6 +42,9 @@ class Run(RunBase):
     # Agent relationship
     agent_id: str = Field(..., description="The unique identifier of the agent associated with the run.")
 
+    # Template fields
+    base_template_id: Optional[str] = Field(None, description="The base template ID that the run belongs to.")
+
     # Run configuration
     background: Optional[bool] = Field(None, description="Whether the run was created in background mode.")
     metadata: Optional[dict] = Field(None, validation_alias="metadata_", description="Additional metadata for the run.")
@@ -65,4 +69,5 @@ class RunUpdate(RunBase):
     completed_at: Optional[datetime] = Field(None, description="The timestamp when the run was completed.")
     stop_reason: Optional[StopReasonType] = Field(None, description="The reason why the run was stopped.")
     metadata: Optional[dict] = Field(None, validation_alias="metadata_", description="Additional metadata for the run.")
+    total_duration_ns: Optional[int] = Field(None, description="Total run duration in nanoseconds")
     model_config = ConfigDict(extra="ignore")  # Ignores extra fields

letta/schemas/run_metrics.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import List, Optional
 
 from pydantic import Field
 
@@ -17,5 +17,6 @@ class RunMetrics(RunMetricsBase):
     run_start_ns: Optional[int] = Field(None, description="The timestamp of the start of the run in nanoseconds.")
     run_ns: Optional[int] = Field(None, description="Total time for the run in nanoseconds.")
     num_steps: Optional[int] = Field(None, description="The number of steps in the run.")
+    tools_used: Optional[List[str]] = Field(None, description="List of tool IDs that were used in this run.")
     template_id: Optional[str] = Field(None, description="The template ID that the run belongs to (cloud only).")
     base_template_id: Optional[str] = Field(None, description="The base template ID that the run belongs to (cloud only).")

letta/schemas/sandbox_config.py

@@ -6,7 +6,7 @@ from pydantic import BaseModel, Field, model_validator
 
 from letta.constants import LETTA_TOOL_EXECUTION_DIR
 from letta.schemas.agent import AgentState
-from letta.schemas.enums import SandboxType
+from letta.schemas.enums import PrimitiveType, SandboxType
 from letta.schemas.letta_base import LettaBase, OrmMetadataBase
 from letta.schemas.pip_requirement import PipRequirement
 from letta.services.tool_sandbox.modal_constants import DEFAULT_MODAL_TIMEOUT
@@ -92,7 +92,7 @@ class ModalSandboxConfig(BaseModel):
 
 
 class SandboxConfigBase(OrmMetadataBase):
-    __id_prefix__ = "sandbox"
+    __id_prefix__ = PrimitiveType.SANDBOX_CONFIG.value
 
 
 class SandboxConfig(SandboxConfigBase):

letta/schemas/secret.py

@@ -271,11 +271,14 @@ class Secret(BaseModel):
     def __get_pydantic_json_schema__(cls, core_schema: core_schema.CoreSchema, handler) -> Dict[str, Any]:
         """
         Define JSON schema representation for Secret fields.
+
         In JSON schema (OpenAPI docs), Secret fields appear as nullable strings.
         The actual encryption/decryption happens at runtime via __get_pydantic_core_schema__.
+
         Args:
             core_schema: The core schema for this type
             handler: Handler for generating JSON schema
+
         Returns:
             A JSON schema dict representing this type as a nullable string
         """
@@ -285,161 +288,3 @@ class Secret(BaseModel):
             "nullable": True,
             "description": "Encrypted secret value (stored as encrypted string)",
         }
-
-
-class SecretDict(BaseModel):
-    """
-    A wrapper for dictionaries containing sensitive key-value pairs.
-
-    Used for custom headers and other key-value configurations.
-
-    TODO: Once we deprecate plaintext columns in the database:
-    - Remove the dual-write logic in to_dict()
-    - Remove the from_db() method's plaintext_value parameter
-    - Remove the _was_encrypted flag (no longer needed for migration)
-    - Simplify get_plaintext() to only handle encrypted JSON values
-    """
-
-    _encrypted_value: Optional[str] = PrivateAttr(default=None)
-    _plaintext_cache: Optional[Dict[str, str]] = PrivateAttr(default=None)
-    _was_encrypted: bool = PrivateAttr(default=False)
-
-    model_config = ConfigDict(frozen=True)
-
-    @classmethod
-    def from_plaintext(cls, value: Optional[Dict[str, str]]) -> "SecretDict":
-        """Create a SecretDict from a plaintext dictionary."""
-        if value is None:
-            instance = cls()
-            instance._encrypted_value = None
-            instance._was_encrypted = False
-            return instance
-
-        # Serialize to JSON then try to encrypt
-        json_str = json.dumps(value)
-        try:
-            encrypted = CryptoUtils.encrypt(json_str)
-            instance = cls()
-            instance._encrypted_value = encrypted
-            instance._was_encrypted = False
-            return instance
-        except ValueError as e:
-            # No encryption key available, store as plaintext JSON
-            if "No encryption key configured" in str(e):
-                logger.warning(
-                    "No encryption key configured. Storing SecretDict value as plaintext JSON. "
-                    "Set LETTA_ENCRYPTION_KEY environment variable to enable encryption."
-                )
-                instance = cls()
-                instance._encrypted_value = json_str  # Store JSON string
-                instance._plaintext_cache = value  # Cache the dict
-                instance._was_encrypted = False
-                return instance
-            raise  # Re-raise if it's a different error
-
-    @classmethod
-    def from_encrypted(cls, encrypted_value: Optional[str]) -> "SecretDict":
-        """Create a SecretDict from an encrypted value."""
-        instance = cls()
-        instance._encrypted_value = encrypted_value
-        instance._was_encrypted = True
-        return instance
-
-    @classmethod
-    def from_db(cls, encrypted_value: Optional[str], plaintext_value: Optional[Dict[str, str]]) -> "SecretDict":
-        """Create a SecretDict from database values during migration phase."""
-        if encrypted_value is not None:
-            return cls.from_encrypted(encrypted_value)
-        elif plaintext_value is not None:
-            return cls.from_plaintext(plaintext_value)
-        else:
-            return cls.from_plaintext(None)
-
-    def get_encrypted(self) -> Optional[str]:
-        """Get the encrypted value."""
-        return self._encrypted_value
-
-    def get_plaintext(self) -> Optional[Dict[str, str]]:
-        """Get the decrypted dictionary."""
-        if self._encrypted_value is None:
-            return None
-
-        # Use cached value if available, but only if it looks like plaintext
-        # or we're confident we can decrypt it
-        if self._plaintext_cache is not None:
-            # If we have a cache but the stored value looks encrypted and we have no key,
-            # we should not use the cache
-            if CryptoUtils.is_encrypted(self._encrypted_value) and not CryptoUtils.is_encryption_available():
-                self._plaintext_cache = None  # Clear invalid cache
-            else:
-                return self._plaintext_cache
-
-        try:
-            decrypted_json = CryptoUtils.decrypt(self._encrypted_value)
-            plaintext_dict = json.loads(decrypted_json)
-            # Cache the decrypted value (PrivateAttr fields can be mutated even with frozen=True)
-            self._plaintext_cache = plaintext_dict
-            return plaintext_dict
-        except ValueError as e:
-            error_msg = str(e)
-
-            # Handle missing encryption key
-            if "No encryption key configured" in error_msg:
-                # Check if the value looks encrypted
-                if CryptoUtils.is_encrypted(self._encrypted_value):
-                    # Value was encrypted, but now we have no key - can't decrypt
-                    logger.warning(
-                        "Cannot decrypt SecretDict value - no encryption key configured. "
-                        "The value was encrypted and requires the original key to decrypt."
-                    )
-                    # Return None to indicate we can't get the plaintext
-                    return None
-                else:
-                    # Value is plaintext JSON (stored when no key was available)
-                    logger.debug("SecretDict value is plaintext JSON (stored without encryption)")
-                    try:
-                        plaintext_dict = json.loads(self._encrypted_value)
-                        self._plaintext_cache = plaintext_dict
-                        return plaintext_dict
-                    except json.JSONDecodeError:
-                        logger.error("Failed to parse SecretDict plaintext as JSON")
-                        return None
-
-            # Handle decryption failure (might be plaintext JSON)
-            elif "Failed to decrypt data" in error_msg:
-                # Check if it might be plaintext JSON
-                if not CryptoUtils.is_encrypted(self._encrypted_value):
-                    # It's plaintext JSON that was stored when no key was available
-                    logger.debug("SecretDict value appears to be plaintext JSON (stored without encryption)")
-                    try:
-                        plaintext_dict = json.loads(self._encrypted_value)
-                        self._plaintext_cache = plaintext_dict
-                        return plaintext_dict
-                    except json.JSONDecodeError:
-                        logger.error("Failed to parse SecretDict plaintext as JSON")
-                        return None
-                # Otherwise, it's corrupted or wrong key
-                logger.error("Failed to decrypt SecretDict value - data may be corrupted or wrong key")
-                raise
-
-            # Migration case: handle legacy plaintext
-            elif not self._was_encrypted:
-                if self._encrypted_value:
-                    try:
-                        plaintext_dict = json.loads(self._encrypted_value)
-                        self._plaintext_cache = plaintext_dict
-                        return plaintext_dict
-                    except json.JSONDecodeError:
-                        pass
-                return None
-
-            # Re-raise for other errors
-            raise
-
-    def is_empty(self) -> bool:
-        """Check if the secret dict is empty/None."""
-        return self._encrypted_value is None
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dictionary for database storage."""
-        return {"encrypted": self.get_encrypted(), "plaintext": self.get_plaintext() if not self._was_encrypted else None}

letta/schemas/source.py

@@ -5,7 +5,7 @@ from pydantic import Field
 
 from letta.helpers.tpuf_client import should_use_tpuf
 from letta.schemas.embedding_config import EmbeddingConfig
-from letta.schemas.enums import VectorDBProvider
+from letta.schemas.enums import PrimitiveType, VectorDBProvider
 from letta.schemas.letta_base import LettaBase
 
 
@@ -14,7 +14,7 @@ class BaseSource(LettaBase):
     Shared attributes across all source schemas.
     """
 
-    __id_prefix__ = "source"
+    __id_prefix__ = PrimitiveType.SOURCE.value
 
     # Core source fields
     name: str = Field(..., description="The name of the source.")

letta/schemas/step.py

@@ -3,14 +3,14 @@ from typing import Dict, List, Literal, Optional
 
 from pydantic import Field
 
-from letta.schemas.enums import StepStatus
+from letta.schemas.enums import PrimitiveType, StepStatus
 from letta.schemas.letta_base import LettaBase
 from letta.schemas.letta_stop_reason import StopReasonType
 from letta.schemas.message import Message
 
 
 class StepBase(LettaBase):
-    __id_prefix__ = "step"
+    __id_prefix__ = PrimitiveType.STEP.value
 
 
 class Step(StepBase):

letta/schemas/tool.py

@@ -11,6 +11,7 @@ from letta.constants import (
     LETTA_VOICE_TOOL_MODULE_NAME,
     MCP_TOOL_TAG_NAME_PREFIX,
 )
+from letta.schemas.enums import PrimitiveType
 
 # MCP Tool metadata constants for schema health status
 MCP_TOOL_METADATA_SCHEMA_STATUS = f"{MCP_TOOL_TAG_NAME_PREFIX}:SCHEMA_STATUS"
@@ -28,7 +29,7 @@ logger = get_logger(__name__)
 
 
 class BaseTool(LettaBase):
-    __id_prefix__ = "tool"
+    __id_prefix__ = PrimitiveType.TOOL.value
 
 
 class Tool(BaseTool):
@@ -63,6 +64,9 @@ class Tool(BaseTool):
     default_requires_approval: Optional[bool] = Field(
         None, description="Default value for whether or not executing this tool requires approval."
     )
+    enable_parallel_execution: Optional[bool] = Field(
+        False, description="If set to True, then this tool will potentially be executed concurrently with other tools. Default False."
+    )
 
     # metadata fields
     created_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
@@ -118,6 +122,9 @@ class ToolCreate(LettaBase):
     pip_requirements: list[PipRequirement] | None = Field(None, description="Optional list of pip packages required by this tool.")
     npm_requirements: list[NpmRequirement] | None = Field(None, description="Optional list of npm packages required by this tool.")
     default_requires_approval: Optional[bool] = Field(None, description="Whether or not to require approval before executing this tool.")
+    enable_parallel_execution: Optional[bool] = Field(
+        False, description="If set to True, then this tool will potentially be executed concurrently with other tools. Default False."
+    )
 
     @classmethod
     def from_mcp(cls, mcp_server_name: str, mcp_tool: MCPTool) -> "ToolCreate":
@@ -145,6 +152,19 @@ class ToolCreate(LettaBase):
             json_schema=json_schema,
         )
 
+    def model_dump(self, to_orm: bool = False, **kwargs):
+        """
+        Override LettaBase.model_dump to explicitly handle 'tags' being None,
+        ensuring that the output includes 'tags' as None (or any current value).
+        """
+        data = super().model_dump(**kwargs)
+        # TODO: consider making tags itself optional in the ORM
+        # Ensure 'tags' is included even when None, but only if tags is in the dict
+        # (i.e., don't add tags if exclude_unset=True was used and tags wasn't set)
+        if "tags" in data and data["tags"] is None:
+            data["tags"] = []
+        return data
+
 
 class ToolUpdate(LettaBase):
     description: Optional[str] = Field(None, description="The description of the tool.")
@@ -160,6 +180,9 @@ class ToolUpdate(LettaBase):
     npm_requirements: list[NpmRequirement] | None = Field(None, description="Optional list of npm packages required by this tool.")
     metadata_: Optional[Dict[str, Any]] = Field(None, description="A dictionary of additional metadata for the tool.")
     default_requires_approval: Optional[bool] = Field(None, description="Whether or not to require approval before executing this tool.")
+    enable_parallel_execution: Optional[bool] = Field(
+        False, description="If set to True, then this tool will potentially be executed concurrently with other tools. Default False."
+    )
     # name: Optional[str] = Field(None, description="The name of the tool (must match the JSON schema name and source code function name).")
 
     model_config = ConfigDict(extra="ignore")  # Allows extra fields without validation errors

letta/schemas/usage.py

@@ -22,5 +22,4 @@ class LettaUsageStatistics(BaseModel):
     total_tokens: int = Field(0, description="The total number of tokens processed by the agent.")
     step_count: int = Field(0, description="The number of steps taken by the agent.")
     # TODO: Optional for now. This field makes everyone's lives easier
-    steps_messages: Optional[List[List[Message]]] = Field(None, description="The messages generated per step")
     run_ids: Optional[List[str]] = Field(None, description="The background task run IDs associated with the agent interaction")