letta-nightly 0.11.3.dev20250820104219__py3-none-any.whl → 0.11.4.dev20250820213507__py3-none-any.whl

letta/schemas/providers/azure.py

@@ -1,15 +1,29 @@
+from collections import defaultdict
 from typing import ClassVar, Literal
 
+import requests
+from openai import AzureOpenAI
 from pydantic import Field, field_validator
 
 from letta.constants import DEFAULT_EMBEDDING_CHUNK_SIZE, LLM_MAX_TOKENS
-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.errors import ErrorCode, LLMAuthenticationError
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import ProviderCategory, ProviderType
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.providers.base import Provider
 
+AZURE_MODEL_TO_CONTEXT_LENGTH = {
+    "babbage-002": 16384,
+    "davinci-002": 16384,
+    "gpt-35-turbo-0613": 4096,
+    "gpt-35-turbo-1106": 16385,
+    "gpt-35-turbo-0125": 16385,
+    "gpt-4-0613": 8192,
+    "gpt-4o-mini-2024-07-18": 128000,
+    "gpt-4o-mini": 128000,
+    "gpt-4o": 128000,
+}
+
 
 class AzureProvider(Provider):
     LATEST_API_VERSION: ClassVar[str] = "2024-09-01-preview"
@@ -29,16 +43,78 @@ class AzureProvider(Provider):
     def replace_none_with_default(cls, v):
         return v if v is not None else cls.LATEST_API_VERSION
 
+    def get_azure_chat_completions_endpoint(self, model: str):
+        return f"{self.base_url}/openai/deployments/{model}/chat/completions?api-version={self.api_version}"
+
+    def get_azure_embeddings_endpoint(self, model: str):
+        return f"{self.base_url}/openai/deployments/{model}/embeddings?api-version={self.api_version}"
+
+    def get_azure_model_list_endpoint(self):
+        return f"{self.base_url}/openai/models?api-version={self.api_version}"
+
+    def get_azure_deployment_list_endpoint(self):
+        # Please note that it has to be 2023-03-15-preview
+        # That's the only api version that works with this deployments endpoint
+        return f"{self.base_url}/openai/deployments?api-version=2023-03-15-preview"
+
+    def azure_openai_get_deployed_model_list(self) -> list:
+        """https://learn.microsoft.com/en-us/rest/api/azureopenai/models/list?view=rest-azureopenai-2023-05-15&tabs=HTTP"""
+
+        client = AzureOpenAI(api_key=self.api_key, api_version=self.api_version, azure_endpoint=self.base_url)
+
+        try:
+            models_list = client.models.list()
+        except Exception:
+            return []
+
+        all_available_models = [model.to_dict() for model in models_list.data]
+
+        # https://xxx.openai.azure.com/openai/models?api-version=xxx
+        headers = {"Content-Type": "application/json"}
+        if self.api_key is not None:
+            headers["api-key"] = f"{self.api_key}"
+
+        # 2. Get all the deployed models
+        url = self.get_azure_deployment_list_endpoint()
+        try:
+            response = requests.get(url, headers=headers)
+            response.raise_for_status()
+        except requests.RequestException as e:
+            raise RuntimeError(f"Failed to retrieve model list: {e}")
+
+        deployed_models = response.json().get("data", [])
+        deployed_model_names = set([m["id"] for m in deployed_models])
+
+        # 3. Only return the models in available models if they have been deployed
+        deployed_models = [m for m in all_available_models if m["id"] in deployed_model_names]
+
+        # 4. Remove redundant deployments, only include the ones with the latest deployment
+        # Create a dictionary to store the latest model for each ID
+        latest_models = defaultdict()
+
+        # Iterate through the models and update the dictionary with the most recent model
+        for model in deployed_models:
+            model_id = model["id"]
+            updated_at = model["created_at"]
+
+            # If the model ID is new or the current model has a more recent created_at, update the dictionary
+            if model_id not in latest_models or updated_at > latest_models[model_id]["created_at"]:
+                latest_models[model_id] = model
+
+        # Extract the unique models
+        return list(latest_models.values())
+
     async def list_llm_models_async(self) -> list[LLMConfig]:
         # TODO (cliandy): asyncify
-        from letta.llm_api.azure_openai import azure_openai_get_chat_completion_model_list
+        model_list = self.azure_openai_get_deployed_model_list()
+        # Extract models that support text generation
+        model_options = [m for m in model_list if m.get("capabilities").get("chat_completion") == True]
 
-        model_options = azure_openai_get_chat_completion_model_list(self.base_url, api_key=self.api_key, api_version=self.api_version)
         configs = []
         for model_option in model_options:
             model_name = model_option["id"]
             context_window_size = self.get_model_context_window(model_name)
-            model_endpoint = get_azure_chat_completions_endpoint(self.base_url, model_name, self.api_version)
+            model_endpoint = self.get_azure_chat_completions_endpoint(model_name)
             configs.append(
                 LLMConfig(
                     model=model_name,
@@ -54,13 +130,22 @@ class AzureProvider(Provider):
 
     async def list_embedding_models_async(self) -> list[EmbeddingConfig]:
         # TODO (cliandy): asyncify dependent function calls
-        from letta.llm_api.azure_openai import azure_openai_get_embeddings_model_list
+        def valid_embedding_model(m: dict, require_embedding_in_name: bool = True):
+            valid_name = True
+            if require_embedding_in_name:
+                valid_name = "embedding" in m["id"]
+
+            return m.get("capabilities").get("embeddings") == True and valid_name
+
+        model_list = self.azure_openai_get_deployed_model_list()
+        # Extract models that support embeddings
+
+        model_options = [m for m in model_list if valid_embedding_model(m)]
 
-        model_options = azure_openai_get_embeddings_model_list(self.base_url, api_key=self.api_key, api_version=self.api_version)
         configs = []
         for model_option in model_options:
             model_name = model_option["id"]
-            model_endpoint = get_azure_embeddings_endpoint(self.base_url, model_name, self.api_version)
+            model_endpoint = self.get_azure_embeddings_endpoint(model_name)
             configs.append(
                 EmbeddingConfig(
                     embedding_model=model_name,
@@ -78,3 +163,12 @@ class AzureProvider(Provider):
         # Hard coded as there are no API endpoints for this
         llm_default = LLM_MAX_TOKENS.get(model_name, 4096)
         return AZURE_MODEL_TO_CONTEXT_LENGTH.get(model_name, llm_default)
+
+    async def check_api_key(self):
+        if not self.api_key:
+            raise ValueError("No API key provided")
+
+        try:
+            await self.list_llm_models_async()
+        except Exception as e:
+            raise LLMAuthenticationError(message=f"Failed to authenticate with Azure: {e}", code=ErrorCode.UNAUTHENTICATED)

letta/schemas/providers/base.py

@@ -24,6 +24,7 @@ class Provider(ProviderBase):
     base_url: str | None = Field(None, description="Base URL for the provider.")
     access_key: str | None = Field(None, description="Access key used for requests to the provider.")
     region: str | None = Field(None, description="Region used for requests to the provider.")
+    api_version: str | None = Field(None, description="API version used for requests to the provider.")
     organization_id: str | None = Field(None, description="The organization id of the user")
     updated_at: datetime | None = Field(None, description="The last update timestamp of the provider.")
 
@@ -126,7 +127,6 @@ class Provider(ProviderBase):
             AzureProvider,
             BedrockProvider,
             CerebrasProvider,
-            CohereProvider,
             DeepSeekProvider,
             GoogleAIProvider,
             GoogleVertexProvider,
@@ -141,6 +141,9 @@ class Provider(ProviderBase):
             XAIProvider,
         )
 
+        if self.base_url == "":
+            self.base_url = None
+
         match self.provider_type:
             case ProviderType.letta:
                 return LettaProvider(**self.model_dump(exclude_none=True))
@@ -174,8 +177,6 @@ class Provider(ProviderBase):
                 return LMStudioOpenAIProvider(**self.model_dump(exclude_none=True))
             case ProviderType.bedrock:
                 return BedrockProvider(**self.model_dump(exclude_none=True))
-            case ProviderType.cohere:
-                return CohereProvider(**self.model_dump(exclude_none=True))
             case _:
                 raise ValueError(f"Unknown provider type: {self.provider_type}")
 
@@ -186,12 +187,16 @@ class ProviderCreate(ProviderBase):
     api_key: str = Field(..., description="API key or secret key used for requests to the provider.")
     access_key: str | None = Field(None, description="Access key used for requests to the provider.")
     region: str | None = Field(None, description="Region used for requests to the provider.")
+    base_url: str | None = Field(None, description="Base URL used for requests to the provider.")
+    api_version: str | None = Field(None, description="API version used for requests to the provider.")
 
 
 class ProviderUpdate(ProviderBase):
     api_key: str = Field(..., description="API key or secret key used for requests to the provider.")
     access_key: str | None = Field(None, description="Access key used for requests to the provider.")
     region: str | None = Field(None, description="Region used for requests to the provider.")
+    base_url: str | None = Field(None, description="Base URL used for requests to the provider.")
+    api_version: str | None = Field(None, description="API version used for requests to the provider.")
 
 
 class ProviderCheck(BaseModel):
@@ -199,3 +204,5 @@ class ProviderCheck(BaseModel):
     api_key: str = Field(..., description="API key or secret key used for requests to the provider.")
     access_key: str | None = Field(None, description="Access key used for requests to the provider.")
     region: str | None = Field(None, description="Region used for requests to the provider.")
+    base_url: str | None = Field(None, description="Base URL used for requests to the provider.")
+    api_version: str | None = Field(None, description="API version used for requests to the provider.")

letta/schemas/providers/bedrock.py

@@ -20,20 +20,32 @@ class BedrockProvider(Provider):
     provider_category: ProviderCategory = Field(ProviderCategory.base, description="The category of the provider (base or byok)")
     region: str = Field(..., description="AWS region for Bedrock")
 
+    async def bedrock_get_model_list_async(self) -> list[dict]:
+        from aioboto3.session import Session
+
+        try:
+            session = Session()
+            async with session.client(
+                "bedrock",
+                aws_access_key_id=self.access_key,
+                aws_secret_access_key=self.api_key,
+                region_name=self.region,
+            ) as bedrock:
+                response = await bedrock.list_inference_profiles()
+                return response["inferenceProfileSummaries"]
+        except Exception as e:
+            logger.error(f"Error getting model list for bedrock: %s", e)
+            raise e
+
     async def check_api_key(self):
         """Check if the Bedrock credentials are valid"""
         from letta.errors import LLMAuthenticationError
-        from letta.llm_api.aws_bedrock import bedrock_get_model_list_async
 
         try:
             # For BYOK providers, use the custom credentials
             if self.provider_category == ProviderCategory.byok:
                 # If we can list models, the credentials are valid
-                await bedrock_get_model_list_async(
-                    access_key_id=self.access_key,
-                    secret_access_key=self.api_key,  # api_key stores the secret access key
-                    region_name=self.region,
-                )
+                await self.bedrock_get_model_list_async()
             else:
                 # For base providers, use default credentials
                 bedrock_get_model_list(region_name=self.region)
@@ -41,13 +53,7 @@ class BedrockProvider(Provider):
             raise LLMAuthenticationError(message=f"Failed to authenticate with Bedrock: {e}")
 
     async def list_llm_models_async(self) -> list[LLMConfig]:
-        from letta.llm_api.aws_bedrock import bedrock_get_model_list_async
-
-        models = await bedrock_get_model_list_async(
-            self.access_key,
-            self.api_key,
-            self.region,
-        )
+        models = await self.bedrock_get_model_list_async()
 
         configs = []
         for model_summary in models:
@@ -67,10 +73,16 @@ class BedrockProvider(Provider):
         return configs
 
     def get_model_context_window(self, model_name: str) -> int | None:
-        # Context windows for Claude models
-        from letta.llm_api.aws_bedrock import bedrock_get_model_context_window
+        """
+        Get context window size for a specific model.
 
-        return bedrock_get_model_context_window(model_name)
+        Bedrock doesn't provide this via API, so we maintain a mapping
+        200k for anthropic: https://aws.amazon.com/bedrock/anthropic/
+        """
+        if model_name.startswith("anthropic"):
+            return 200_000
+        else:
+            return 100_000  # default to 100k if unknown
 
     def get_handle(self, model_name: str, is_embedding: bool = False, base_name: str | None = None) -> str:
         logger.debug("Getting handle for model_name: %s", model_name)

letta/schemas/providers/letta.py

@@ -30,9 +30,9 @@ class LettaProvider(Provider):
         return [
             EmbeddingConfig(
                 embedding_model="letta-free",  # NOTE: renamed
-                embedding_endpoint_type="hugging-face",
-                embedding_endpoint="https://bun-function-production-e310.up.railway.app/v1",
-                embedding_dim=1024,
+                embedding_endpoint_type="openai",
+                embedding_endpoint="https://embeddings.letta.com/",
+                embedding_dim=1536,
                 embedding_chunk_size=DEFAULT_EMBEDDING_CHUNK_SIZE,
                 handle=self.get_handle("letta-free", is_embedding=True),
             )

letta/schemas/providers/ollama.py

@@ -82,18 +82,8 @@ class OllamaProvider(OpenAIProvider):
                 response_json = await response.json()
 
         configs = []
-        for model in response_json.get("models", []):
-            model_name = model["name"]
-            model_details = await self._get_model_details_async(model_name)
-            if not model_details or "embedding" not in model_details.get("capabilities", []):
-                continue
-
-            embedding_dim = None
-            model_info = model_details.get("model_info", {})
-            if architecture := model_info.get("general.architecture"):
-                if embedding_length := model_info.get(f"{architecture}.embedding_length"):
-                    embedding_dim = int(embedding_length)
-
+        for model in response_json["models"]:
+            embedding_dim = await self._get_model_embedding_dim(model["name"])
             if not embedding_dim:
                 logger.warning(f"Ollama model {model_name} has no embedding dimension, using default {DEFAULT_EMBEDDING_DIM}")
                 embedding_dim = DEFAULT_EMBEDDING_DIM

letta/schemas/providers/openai.py

@@ -12,7 +12,7 @@ from letta.schemas.providers.base import Provider
 logger = get_logger(__name__)
 
 ALLOWED_PREFIXES = {"gpt-4", "gpt-5", "o1", "o3", "o4"}
-DISALLOWED_KEYWORDS = {"transcribe", "search", "realtime", "tts", "audio", "computer", "o1-mini", "o1-preview", "o1-pro"}
+DISALLOWED_KEYWORDS = {"transcribe", "search", "realtime", "tts", "audio", "computer", "o1-mini", "o1-preview", "o1-pro", "chat"}
 DEFAULT_EMBEDDING_BATCH_SIZE = 1024
 
 
@@ -20,10 +20,10 @@ class OpenAIProvider(Provider):
     provider_type: Literal[ProviderType.openai] = Field(ProviderType.openai, description="The type of the provider.")
     provider_category: ProviderCategory = Field(ProviderCategory.base, description="The category of the provider (base or byok)")
     api_key: str = Field(..., description="API key for the OpenAI API.")
-    base_url: str = Field(..., description="Base URL for the OpenAI API.")
+    base_url: str = Field("https://api.openai.com/v1", description="Base URL for the OpenAI API.")
 
     async def check_api_key(self):
-        from letta.llm_api.openai import openai_check_valid_api_key
+        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)
 
@@ -142,7 +142,7 @@ class OpenAIProvider(Provider):
         """This function is used to tune LLMConfig parameters to improve model performance."""
 
         # gpt-4o-mini has started to regress with pretty bad emoji spam loops (2025-07)
-        if "gpt-4o-mini" in model_name or "gpt-4.1-mini" in model_name:
+        if "gpt-4o" in model_name or "gpt-4.1-mini" in model_name or model_name == "letta-free":
             llm_config.frequency_penalty = 1.0
         return llm_config
 

letta/schemas/providers/together.py

@@ -2,11 +2,12 @@
 Note: this supports completions (deprecated by openai) and chat completions via the OpenAI API.
 """
 
-from typing import Literal
+from typing import Literal, Optional
 
 from pydantic import Field
 
 from letta.constants import MIN_CONTEXT_WINDOW
+from letta.errors import ErrorCode, LLMAuthenticationError
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import ProviderCategory, ProviderType
 from letta.schemas.llm_config import LLMConfig
@@ -18,7 +19,9 @@ class TogetherProvider(OpenAIProvider):
     provider_category: ProviderCategory = Field(ProviderCategory.base, description="The category of the provider (base or byok)")
     base_url: str = "https://api.together.xyz/v1"
     api_key: str = Field(..., description="API key for the Together API.")
-    default_prompt_formatter: str = Field(..., description="Default prompt formatter (aka model wrapper) to use on vLLM /completions API.")
+    default_prompt_formatter: Optional[str] = Field(
+        None, description="Default prompt formatter (aka model wrapper) to use on vLLM /completions API."
+    )
 
     async def list_llm_models_async(self) -> list[LLMConfig]:
         from letta.llm_api.openai import openai_get_model_list_async
@@ -83,3 +86,12 @@ class TogetherProvider(OpenAIProvider):
             )
 
         return configs
+
+    async def check_api_key(self):
+        if not self.api_key:
+            raise ValueError("No API key provided")
+
+        try:
+            await self.list_llm_models_async()
+        except Exception as e:
+            raise LLMAuthenticationError(message=f"Failed to authenticate with Together: {e}", code=ErrorCode.UNAUTHENTICATED)

letta/schemas/sandbox_config.py

@@ -9,6 +9,7 @@ from letta.schemas.agent import AgentState
 from letta.schemas.enums import 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
 from letta.settings import tool_settings
 
 # Sandbox Config
@@ -80,7 +81,7 @@ class E2BSandboxConfig(BaseModel):
 
 
 class ModalSandboxConfig(BaseModel):
-    timeout: int = Field(5 * 60, description="Time limit for the sandbox (in seconds).")
+    timeout: int = Field(DEFAULT_MODAL_TIMEOUT, description="Time limit for the sandbox (in seconds).")
     pip_requirements: list[str] | None = Field(None, description="A list of pip packages to install in the Modal sandbox")
     npm_requirements: list[str] | None = Field(None, description="A list of npm packages to install in the Modal sandbox")
     language: Literal["python", "typescript"] = "python"

letta/schemas/tool.py

@@ -1,6 +1,6 @@
 from typing import Any, Dict, List, Optional
 
-from pydantic import Field, model_validator
+from pydantic import ConfigDict, Field, model_validator
 
 from letta.constants import (
     COMPOSIO_TOOL_TAG_NAME,
@@ -12,6 +12,10 @@ from letta.constants import (
     LETTA_VOICE_TOOL_MODULE_NAME,
     MCP_TOOL_TAG_NAME_PREFIX,
 )
+
+# MCP Tool metadata constants for schema health status
+MCP_TOOL_METADATA_SCHEMA_STATUS = f"{MCP_TOOL_TAG_NAME_PREFIX}:SCHEMA_STATUS"
+MCP_TOOL_METADATA_SCHEMA_WARNINGS = f"{MCP_TOOL_TAG_NAME_PREFIX}:SCHEMA_WARNINGS"
 from letta.functions.ast_parsers import get_function_name_and_docstring
 from letta.functions.composio_helpers import generate_composio_tool_wrapper
 from letta.functions.functions import derive_openai_json_schema, get_json_schema_from_module
@@ -22,7 +26,7 @@ from letta.functions.schema_generator import (
     generate_tool_schema_for_mcp,
 )
 from letta.log import get_logger
-from letta.schemas.enums import ToolType
+from letta.schemas.enums import ToolSourceType, ToolType
 from letta.schemas.letta_base import LettaBase
 from letta.schemas.npm_requirement import NpmRequirement
 from letta.schemas.pip_requirement import PipRequirement
@@ -76,27 +80,42 @@ class Tool(BaseTool):
         """
         from letta.functions.helpers import generate_model_from_args_json_schema
 
-        if self.tool_type is ToolType.CUSTOM:
+        if self.tool_type == ToolType.CUSTOM:
             if not self.source_code:
                 logger.error("Custom tool with id=%s is missing source_code field", self.id)
                 raise ValueError(f"Custom tool with id={self.id} is missing source_code field.")
 
-            # Always derive json_schema for freshest possible json_schema
-            if self.args_json_schema is not None:
-                name, description = get_function_name_and_docstring(self.source_code, self.name)
-                args_schema = generate_model_from_args_json_schema(self.args_json_schema)
-                self.json_schema = generate_schema_from_args_schema_v2(
-                    args_schema=args_schema,
-                    name=name,
-                    description=description,
-                    append_heartbeat=False,
-                )
-            else:  # elif not self.json_schema: # TODO: JSON schema is not being derived correctly the first time?
-                # If there's not a json_schema provided, then we need to re-derive
-                try:
-                    self.json_schema = derive_openai_json_schema(source_code=self.source_code)
-                except Exception as e:
-                    logger.error("Failed to derive json schema for tool with id=%s name=%s: %s", self.id, self.name, e)
+            if self.source_type == ToolSourceType.typescript:
+                # TypeScript tools don't support args_json_schema, only direct schema generation
+                if not self.json_schema:
+                    try:
+                        from letta.functions.typescript_parser import derive_typescript_json_schema
+
+                        self.json_schema = derive_typescript_json_schema(source_code=self.source_code)
+                    except Exception as e:
+                        logger.error("Failed to derive TypeScript json schema for tool with id=%s name=%s: %s", self.id, self.name, e)
+            elif (
+                self.source_type == ToolSourceType.python or self.source_type is None
+            ):  # default to python if not provided for backwards compatability
+                # Python tool handling
+                # Always derive json_schema for freshest possible json_schema
+                if self.args_json_schema is not None:
+                    name, description = get_function_name_and_docstring(self.source_code, self.name)
+                    args_schema = generate_model_from_args_json_schema(self.args_json_schema)
+                    self.json_schema = generate_schema_from_args_schema_v2(
+                        args_schema=args_schema,
+                        name=name,
+                        description=description,
+                        append_heartbeat=False,
+                    )
+                else:  # elif not self.json_schema: # TODO: JSON schema is not being derived correctly the first time?
+                    # If there's not a json_schema provided, then we need to re-derive
+                    try:
+                        self.json_schema = derive_openai_json_schema(source_code=self.source_code)
+                    except Exception as e:
+                        logger.error("Failed to derive json schema for tool with id=%s name=%s: %s", self.id, self.name, e)
+            else:
+                raise ValueError(f"Unknown tool source type: {self.source_type}")
         elif self.tool_type in {ToolType.LETTA_CORE, ToolType.LETTA_MEMORY_CORE, ToolType.LETTA_SLEEPTIME_CORE}:
             # If it's letta core tool, we generate the json_schema on the fly here
             self.json_schema = get_json_schema_from_module(module_name=LETTA_CORE_TOOL_MODULE_NAME, function_name=self.name)
@@ -156,6 +175,11 @@ class ToolCreate(LettaBase):
         # Pass the MCP tool to the schema generator
         json_schema = generate_tool_schema_for_mcp(mcp_tool=mcp_tool)
 
+        # Store health status in json_schema metadata if available
+        if mcp_tool.health:
+            json_schema[MCP_TOOL_METADATA_SCHEMA_STATUS] = mcp_tool.health.status
+            json_schema[MCP_TOOL_METADATA_SCHEMA_WARNINGS] = mcp_tool.health.reasons
+
         # Return a ToolCreate instance
         description = mcp_tool.description
         source_type = "python"
@@ -222,10 +246,10 @@ class ToolUpdate(LettaBase):
     return_char_limit: Optional[int] = Field(None, description="The maximum number of characters in the response.")
     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.")
+    metadata_: Optional[Dict[str, Any]] = Field(None, description="A dictionary of additional metadata for the tool.")
 
-    class Config:
-        extra = "ignore"  # Allows extra fields without validation errors
-        # TODO: Remove this, and clean usage of ToolUpdate everywhere else
+    model_config = ConfigDict(extra="ignore")  # Allows extra fields without validation errors
+    # TODO: Remove this, and clean usage of ToolUpdate everywhere else
 
 
 class ToolRunFromSource(LettaBase):