letta-nightly 0.8.15.dev20250720104313__py3-none-any.whl → 0.8.16.dev20250721104533__py3-none-any.whl

letta/otel/tracing.py

@@ -143,7 +143,43 @@ def setup_tracing(
     if settings.sqlalchemy_tracing:
         from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
 
-        SQLAlchemyInstrumentor().instrument()
+        from letta.server.db import db_registry
+
+        # For OpenTelemetry SQLAlchemy instrumentation, we need to use the sync_engine
+        async_engine = db_registry.get_async_engine()
+        if async_engine:
+            # Access the sync_engine attribute safely
+            try:
+                SQLAlchemyInstrumentor().instrument(
+                    engine=async_engine.sync_engine,
+                    enable_commenter=True,
+                    commenter_options={},
+                    enable_attribute_commenter=True,
+                )
+            except Exception:
+                # Fall back to instrumenting without specifying an engine
+                # This will still capture some SQL operations
+                SQLAlchemyInstrumentor().instrument(
+                    enable_commenter=True,
+                    commenter_options={},
+                    enable_attribute_commenter=True,
+                )
+        else:
+            # If no async engine is available, instrument without an engine
+            SQLAlchemyInstrumentor().instrument(
+                enable_commenter=True,
+                commenter_options={},
+                enable_attribute_commenter=True,
+            )
+
+        # Additionally set up our custom instrumentation
+        try:
+            from letta.otel.sqlalchemy_instrumentation_integration import setup_letta_db_instrumentation
+
+            setup_letta_db_instrumentation(enable_joined_monitoring=True)
+        except Exception as e:
+            # Log but continue if our custom instrumentation fails
+            logger.warning(f"Failed to setup Letta DB instrumentation: {e}")
 
     if app:
         # Add middleware first

letta/schemas/agent.py

@@ -78,8 +78,6 @@ class AgentState(OrmMetadataBase, validate_assignment=True):
 
     # This is an object representing the in-process state of a running `Agent`
     # Field in this object can be theoretically edited by tools, and will be persisted by the ORM
-    organization_id: Optional[str] = Field(None, description="The unique identifier of the organization associated with the agent.")
-
     description: Optional[str] = Field(None, description="The description of the agent.")
     metadata: Optional[Dict] = Field(None, description="The metadata of the agent.")
 
@@ -309,7 +307,6 @@ class AgentStepResponse(BaseModel):
 
 
 def get_prompt_template_for_agent_type(agent_type: Optional[AgentType] = None):
-
     # Workflow agents and ReAct agents don't use memory blocks
     # However, they still allow files to be injected into the context
     if agent_type == AgentType.react_agent or agent_type == AgentType.workflow_agent:

letta/schemas/agent_file.py

@@ -0,0 +1,283 @@
+from datetime import datetime
+from typing import Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+from letta.schemas.agent import AgentState, CreateAgent
+from letta.schemas.block import Block, CreateBlock
+from letta.schemas.enums import MessageRole
+from letta.schemas.file import FileAgent, FileAgentBase, FileMetadata, FileMetadataBase
+from letta.schemas.group import GroupCreate
+from letta.schemas.message import Message, MessageCreate
+from letta.schemas.source import Source, SourceCreate
+from letta.schemas.tool import Tool
+from letta.schemas.user import User
+from letta.services.message_manager import MessageManager
+
+
+class ImportResult:
+    """Result of an agent file import operation"""
+
+    def __init__(
+        self,
+        success: bool,
+        message: str = "",
+        imported_count: int = 0,
+        errors: Optional[List[str]] = None,
+        id_mappings: Optional[Dict[str, str]] = None,
+    ):
+        self.success = success
+        self.message = message
+        self.imported_count = imported_count
+        self.errors = errors or []
+        self.id_mappings = id_mappings or {}
+
+
+class MessageSchema(MessageCreate):
+    """Message with human-readable ID for agent file"""
+
+    __id_prefix__ = "message"
+    id: str = Field(..., description="Human-readable identifier for this message in the file")
+
+    # Override the role field to accept all message roles, not just user/system/assistant
+    role: MessageRole = Field(..., description="The role of the participant.")
+    model: Optional[str] = Field(None, description="The model used to make the function call")
+    agent_id: Optional[str] = Field(None, description="The unique identifier of the agent")
+
+    @classmethod
+    def from_message(cls, message: Message) -> "MessageSchema":
+        """Convert Message to MessageSchema"""
+
+        # Create MessageSchema directly without going through MessageCreate
+        # to avoid role validation issues
+        return cls(
+            id=message.id,
+            role=message.role,
+            content=message.content,
+            name=message.name,
+            otid=None,  # TODO
+            sender_id=None,  # TODO
+            batch_item_id=message.batch_item_id,
+            group_id=message.group_id,
+            model=message.model,
+            agent_id=message.agent_id,
+        )
+
+
+class FileAgentSchema(FileAgentBase):
+    """File-Agent relationship with human-readable ID for agent file"""
+
+    __id_prefix__ = "file_agent"
+    id: str = Field(..., description="Human-readable identifier for this file-agent relationship in the file")
+
+    @classmethod
+    def from_file_agent(cls, file_agent: FileAgent) -> "FileAgentSchema":
+        """Convert FileAgent to FileAgentSchema"""
+
+        create_file_agent = FileAgentBase(
+            agent_id=file_agent.agent_id,
+            file_id=file_agent.file_id,
+            source_id=file_agent.source_id,
+            file_name=file_agent.file_name,
+            is_open=file_agent.is_open,
+            visible_content=file_agent.visible_content,
+            last_accessed_at=file_agent.last_accessed_at,
+        )
+
+        # Create FileAgentSchema with the file_agent's ID (will be remapped later)
+        return cls(id=file_agent.id, **create_file_agent.model_dump())
+
+
+class AgentSchema(CreateAgent):
+    """Agent with human-readable ID for agent file"""
+
+    __id_prefix__ = "agent"
+    id: str = Field(..., description="Human-readable identifier for this agent in the file")
+    in_context_message_ids: List[str] = Field(
+        default_factory=list, description="List of message IDs that are currently in the agent's context"
+    )
+    messages: List[MessageSchema] = Field(default_factory=list, description="List of messages in the agent's conversation history")
+    files_agents: List[FileAgentSchema] = Field(default_factory=list, description="List of file-agent relationships for this agent")
+
+    @classmethod
+    async def from_agent_state(
+        cls, agent_state: AgentState, message_manager: MessageManager, files_agents: List[FileAgent], actor: User
+    ) -> "AgentSchema":
+        """Convert AgentState to AgentSchema"""
+
+        create_agent = CreateAgent(
+            name=agent_state.name,
+            memory_blocks=[],  # TODO: Convert from agent_state.memory if needed
+            tools=[],
+            tool_ids=[tool.id for tool in agent_state.tools] if agent_state.tools else [],
+            source_ids=[],  # [source.id for source in agent_state.sources] if agent_state.sources else [],
+            block_ids=[block.id for block in agent_state.memory.blocks],
+            tool_rules=agent_state.tool_rules,
+            tags=agent_state.tags,
+            system=agent_state.system,
+            agent_type=agent_state.agent_type,
+            llm_config=agent_state.llm_config,
+            embedding_config=agent_state.embedding_config,
+            initial_message_sequence=None,
+            include_base_tools=False,
+            include_multi_agent_tools=False,
+            include_base_tool_rules=False,
+            include_default_source=False,
+            description=agent_state.description,
+            metadata=agent_state.metadata,
+            model=None,
+            embedding=None,
+            context_window_limit=None,
+            embedding_chunk_size=None,
+            max_tokens=None,
+            max_reasoning_tokens=None,
+            enable_reasoner=False,
+            from_template=None,  # TODO: Need to get passed in
+            template=False,  # TODO: Need to get passed in
+            project=None,  # TODO: Need to get passed in
+            tool_exec_environment_variables=agent_state.get_agent_env_vars_as_dict(),
+            memory_variables=None,  # TODO: Need to get passed in
+            project_id=None,  # TODO: Need to get passed in
+            template_id=None,  # TODO: Need to get passed in
+            base_template_id=None,  # TODO: Need to get passed in
+            identity_ids=None,  # TODO: Need to get passed in
+            message_buffer_autoclear=agent_state.message_buffer_autoclear,
+            enable_sleeptime=False,  # TODO: Need to figure out how to patch this
+            response_format=agent_state.response_format,
+            timezone=agent_state.timezone or "UTC",
+        )
+
+        messages = await message_manager.list_messages_for_agent_async(
+            agent_id=agent_state.id, actor=actor, limit=50
+        )  # TODO: Expand to get more messages
+
+        # Convert messages to MessageSchema objects
+        message_schemas = [MessageSchema.from_message(msg) for msg in messages]
+
+        # Create AgentSchema with agent state ID (remapped later)
+        return cls(
+            id=agent_state.id,
+            in_context_message_ids=agent_state.message_ids or [],
+            messages=message_schemas,  # Messages will be populated separately by the manager
+            files_agents=[FileAgentSchema.from_file_agent(f) for f in files_agents],
+            **create_agent.model_dump(),
+        )
+
+
+class GroupSchema(GroupCreate):
+    """Group with human-readable ID for agent file"""
+
+    __id_prefix__ = "group"
+    id: str = Field(..., description="Human-readable identifier for this group in the file")
+
+
+class BlockSchema(CreateBlock):
+    """Block with human-readable ID for agent file"""
+
+    __id_prefix__ = "block"
+    id: str = Field(..., description="Human-readable identifier for this block in the file")
+
+    @classmethod
+    def from_block(cls, block: Block) -> "BlockSchema":
+        """Convert Block to BlockSchema"""
+
+        create_block = CreateBlock(
+            value=block.value,
+            limit=block.limit,
+            template_name=block.template_name,
+            is_template=block.is_template,
+            preserve_on_migration=block.preserve_on_migration,
+            label=block.label,
+            read_only=block.read_only,
+            description=block.description,
+            metadata=block.metadata or {},
+        )
+
+        # Create BlockSchema with the block's ID (will be remapped later)
+        return cls(id=block.id, **create_block.model_dump())
+
+
+class FileSchema(FileMetadataBase):
+    """File with human-readable ID for agent file"""
+
+    __id_prefix__ = "file"
+    id: str = Field(..., description="Human-readable identifier for this file in the file")
+
+    @classmethod
+    def from_file_metadata(cls, file_metadata: FileMetadata) -> "FileSchema":
+        """Convert FileMetadata to FileSchema"""
+
+        create_file = FileMetadataBase(
+            source_id=file_metadata.source_id,
+            file_name=file_metadata.file_name,
+            original_file_name=file_metadata.original_file_name,
+            file_path=file_metadata.file_path,
+            file_type=file_metadata.file_type,
+            file_size=file_metadata.file_size,
+            file_creation_date=file_metadata.file_creation_date,
+            file_last_modified_date=file_metadata.file_last_modified_date,
+            processing_status=file_metadata.processing_status,
+            error_message=file_metadata.error_message,
+            total_chunks=file_metadata.total_chunks,
+            chunks_embedded=file_metadata.chunks_embedded,
+            content=file_metadata.content,
+        )
+
+        # Create FileSchema with the file's ID (will be remapped later)
+        return cls(id=file_metadata.id, **create_file.model_dump())
+
+
+class SourceSchema(SourceCreate):
+    """Source with human-readable ID for agent file"""
+
+    __id_prefix__ = "source"
+    id: str = Field(..., description="Human-readable identifier for this source in the file")
+
+    @classmethod
+    def from_source(cls, source: Source) -> "SourceSchema":
+        """Convert Block to BlockSchema"""
+
+        create_block = SourceCreate(
+            name=source.name,
+            description=source.description,
+            instructions=source.instructions,
+            metadata=source.metadata,
+            embedding_config=source.embedding_config,
+        )
+
+        # Create SourceSchema with the block's ID (will be remapped later)
+        return cls(id=source.id, **create_block.model_dump())
+
+
+# TODO: This one is quite thin, just a wrapper over Tool
+class ToolSchema(Tool):
+    """Tool with human-readable ID for agent file"""
+
+    __id_prefix__ = "tool"
+    id: str = Field(..., description="Human-readable identifier for this tool in the file")
+
+    @classmethod
+    def from_tool(cls, tool: Tool) -> "ToolSchema":
+        """Convert Tool to ToolSchema"""
+        return cls(**tool.model_dump())
+
+
+# class MCPServerSchema(RegisterMCPServer):
+#     """MCP Server with human-readable ID for agent file"""
+#     id: str = Field(..., description="Human-readable identifier for this MCP server in the file")
+
+
+class AgentFileSchema(BaseModel):
+    """Schema for serialized agent file that can be exported to JSON and imported into agent server."""
+
+    agents: List[AgentSchema] = Field(..., description="List of agents in this agent file")
+    groups: List[GroupSchema] = Field(..., description="List of groups in this agent file")
+    blocks: List[BlockSchema] = Field(..., description="List of memory blocks in this agent file")
+    files: List[FileSchema] = Field(..., description="List of files in this agent file")
+    sources: List[SourceSchema] = Field(..., description="List of sources in this agent file")
+    tools: List[ToolSchema] = Field(..., description="List of tools in this agent file")
+    # mcp_servers: List[MCPServerSchema] = Field(..., description="List of MCP servers in this agent file")
+    metadata: Dict[str, str] = Field(
+        default_factory=dict, description="Metadata for this agent file, including revision_id and other export information."
+    )
+    created_at: Optional[datetime] = Field(default=None, description="The timestamp when the object was created.")

letta/schemas/block.py

@@ -74,9 +74,6 @@ class Block(BaseBlock):
 
     id: str = BaseBlock.generate_id_field()
 
-    # associated user/agent
-    organization_id: Optional[str] = Field(None, description="The unique identifier of the organization associated with the block.")
-
     # default orm fields
     created_by_id: Optional[str] = Field(None, description="The id of the user that made this Block.")
     last_updated_by_id: Optional[str] = Field(None, description="The id of the user that last updated this Block.")

letta/schemas/file.py

@@ -22,12 +22,7 @@ class FileMetadataBase(LettaBase):
 
     __id_prefix__ = "file"
 
-
-class FileMetadata(FileMetadataBase):
-    """Representation of a single FileMetadata"""
-
-    id: str = FileMetadataBase.generate_id_field()
-    organization_id: Optional[str] = Field(None, description="The unique identifier of the organization associated with the document.")
+    # Core file metadata fields
     source_id: str = Field(..., description="The unique identifier of the source associated with the document.")
     file_name: Optional[str] = Field(None, description="The name of the file.")
     original_file_name: Optional[str] = Field(None, description="The original name of the file as uploaded.")
@@ -43,13 +38,6 @@ class FileMetadata(FileMetadataBase):
     error_message: Optional[str] = Field(default=None, description="Optional error message if the file failed processing.")
     total_chunks: Optional[int] = Field(default=None, description="Total number of chunks for the file.")
     chunks_embedded: Optional[int] = Field(default=None, description="Number of chunks that have been embedded.")
-
-    # orm metadata, optional fields
-    created_at: Optional[datetime] = Field(default_factory=datetime.utcnow, description="The creation date of the file.")
-    updated_at: Optional[datetime] = Field(default_factory=datetime.utcnow, description="The update date of the file.")
-    is_deleted: bool = Field(False, description="Whether this file is deleted or not.")
-
-    # This is optional, and only occasionally pulled in since it can be very large
     content: Optional[str] = Field(
         default=None, description="Optional full-text content of the file; only populated on demand due to its size."
     )
@@ -59,11 +47,38 @@ class FileMetadata(FileMetadataBase):
         return self.processing_status in (FileProcessingStatus.COMPLETED, FileProcessingStatus.ERROR)
 
 
+class FileMetadata(FileMetadataBase):
+    """Representation of a single FileMetadata"""
+
+    id: str = FileMetadataBase.generate_id_field()
+    organization_id: Optional[str] = Field(None, description="The unique identifier of the organization associated with the document.")
+
+    # orm metadata, optional fields
+    created_at: Optional[datetime] = Field(default_factory=datetime.utcnow, description="The creation date of the file.")
+    updated_at: Optional[datetime] = Field(default_factory=datetime.utcnow, description="The update date of the file.")
+    is_deleted: bool = Field(False, description="Whether this file is deleted or not.")
+
+
 class FileAgentBase(LettaBase):
     """Base class for the FileMetadata-⇄-Agent association schemas"""
 
     __id_prefix__ = "file_agent"
 
+    # Core file-agent association fields
+    agent_id: str = Field(..., description="Unique identifier of the agent.")
+    file_id: str = Field(..., description="Unique identifier of the file.")
+    source_id: str = Field(..., description="Unique identifier of the source (denormalized from files.source_id).")
+    file_name: str = Field(..., description="Name of the file.")
+    is_open: bool = Field(True, description="True if the agent currently has the file open.")
+    visible_content: Optional[str] = Field(
+        None,
+        description="Portion of the file the agent is focused on (may be large).",
+    )
+    last_accessed_at: Optional[datetime] = Field(
+        default_factory=datetime.utcnow,
+        description="UTC timestamp of the agent’s most recent access to this file.",
+    )
+
 
 class FileAgent(FileAgentBase):
     """
@@ -83,19 +98,6 @@ class FileAgent(FileAgentBase):
         None,
         description="Org ID this association belongs to (inherited from both agent and file).",
     )
-    agent_id: str = Field(..., description="Unique identifier of the agent.")
-    file_id: str = Field(..., description="Unique identifier of the file.")
-    source_id: str = Field(..., description="Unique identifier of the source (denormalized from files.source_id).")
-    file_name: str = Field(..., description="Name of the file.")
-    is_open: bool = Field(True, description="True if the agent currently has the file open.")
-    visible_content: Optional[str] = Field(
-        None,
-        description="Portion of the file the agent is focused on (may be large).",
-    )
-    last_accessed_at: Optional[datetime] = Field(
-        default_factory=datetime.utcnow,
-        description="UTC timestamp of the agent’s most recent access to this file.",
-    )
 
     created_at: Optional[datetime] = Field(
         default_factory=datetime.utcnow,

letta/schemas/letta_message.py

@@ -40,15 +40,18 @@ class LettaMessage(BaseModel):
         message_type (MessageType): The type of the message
         otid (Optional[str]): The offline threading id associated with this message
         sender_id (Optional[str]): The id of the sender of the message, can be an identity id or agent id
+        step_id (Optional[str]): The step id associated with the message
+        is_err (Optional[bool]): Whether the message is an errored message or not. Used for debugging purposes only.
     """
 
     id: str
     date: datetime
-    name: Optional[str] = None
+    name: str | None = None
     message_type: MessageType = Field(..., description="The type of the message.")
-    otid: Optional[str] = None
-    sender_id: Optional[str] = None
-    step_id: Optional[str] = None
+    otid: str | None = None
+    sender_id: str | None = None
+    step_id: str | None = None
+    is_err: bool | None = None
 
     @field_serializer("date")
     def serialize_datetime(self, dt: datetime, _info):
@@ -60,6 +63,14 @@ class LettaMessage(BaseModel):
             dt = dt.replace(tzinfo=timezone.utc)
         return dt.isoformat(timespec="seconds")
 
+    @field_serializer("is_err", when_used="unless-none")
+    def serialize_is_err(self, value: bool | None, _info):
+        """
+        Only serialize is_err field when it's True (for debugging purposes).
+        When is_err is None or False, this field will be excluded from the JSON output.
+        """
+        return value if value is True else None
+
 
 class SystemMessage(LettaMessage):
     """

letta/schemas/memory.py

@@ -174,7 +174,7 @@ class Memory(BaseModel, validate_assignment=True):
     def update_block_value(self, label: str, value: str):
         """Update the value of a block"""
         if not isinstance(value, str):
-            raise ValueError(f"Provided value must be a string")
+            raise ValueError("Provided value must be a string")
 
         for block in self.blocks:
             if block.label == label:

letta/schemas/message.py

@@ -128,29 +128,28 @@ class MessageUpdate(BaseModel):
 
 class Message(BaseMessage):
     """
-    Letta's internal representation of a message. Includes methods to convert to/from LLM provider formats.
-
-    Attributes:
-        id (str): The unique identifier of the message.
-        role (MessageRole): The role of the participant.
-        text (str): The text of the message.
-        user_id (str): The unique identifier of the user.
-        agent_id (str): The unique identifier of the agent.
-        model (str): The model used to make the function call.
-        name (str): The name of the participant.
-        created_at (datetime): The time the message was created.
-        tool_calls (List[OpenAIToolCall,]): The list of tool calls requested.
-        tool_call_id (str): The id of the tool call.
-        step_id (str): The id of the step that this message was created in.
-        otid (str): The offline threading id associated with this message.
-        tool_returns (List[ToolReturn]): The list of tool returns requested.
-        group_id (str): The multi-agent group that the message was sent in.
-        sender_id (str): The id of the sender of the message, can be an identity id or agent id.
-
+        Letta's internal representation of a message. Includes methods to convert to/from LLM provider formats.
+
+        Attributes:
+            id (str): The unique identifier of the message.
+            role (MessageRole): The role of the participant.
+            text (str): The text of the message.
+            user_id (str): The unique identifier of the user.
+            agent_id (str): The unique identifier of the agent.
+            model (str): The model used to make the function call.
+            name (str): The name of the participant.
+            created_at (datetime): The time the message was created.
+            tool_calls (List[OpenAIToolCall,]): The list of tool calls requested.
+            tool_call_id (str): The id of the tool call.
+            step_id (str): The id of the step that this message was created in.
+            otid (str): The offline threading id associated with this message.
+            tool_returns (List[ToolReturn]): The list of tool returns requested.
+            group_id (str): The multi-agent group that the message was sent in.
+            sender_id (str): The id of the sender of the message, can be an identity id or agent id.
+    t
     """
 
     id: str = BaseMessage.generate_id_field()
-    organization_id: Optional[str] = Field(default=None, description="The unique identifier of the organization.")
     agent_id: Optional[str] = Field(default=None, description="The unique identifier of the agent.")
     model: Optional[str] = Field(default=None, description="The model used to make the function call.")
     # Basic OpenAI-style fields
@@ -172,6 +171,9 @@ class Message(BaseMessage):
     group_id: Optional[str] = Field(default=None, description="The multi-agent group that the message was sent in")
     sender_id: Optional[str] = Field(default=None, description="The id of the sender of the message, can be an identity id or agent id")
     batch_item_id: Optional[str] = Field(default=None, description="The id of the LLMBatchItem that this message is associated with")
+    is_err: Optional[bool] = Field(
+        default=None, description="Whether this message is part of an error step. Used only for debugging purposes."
+    )
     # This overrides the optional base orm schema, created_at MUST exist on all messages objects
     created_at: datetime = Field(default_factory=get_utc_time, description="The timestamp when the object was created.")
 
@@ -191,6 +193,7 @@ class Message(BaseMessage):
         if not is_utc_datetime(self.created_at):
             self.created_at = self.created_at.replace(tzinfo=timezone.utc)
         json_message["created_at"] = self.created_at.isoformat()
+        json_message.pop("is_err", None)  # make sure we don't include this debugging information
         return json_message
 
     @staticmethod
@@ -204,6 +207,7 @@ class Message(BaseMessage):
         assistant_message_tool_name: str = DEFAULT_MESSAGE_TOOL,
         assistant_message_tool_kwarg: str = DEFAULT_MESSAGE_TOOL_KWARG,
         reverse: bool = True,
+        include_err: Optional[bool] = None,
     ) -> List[LettaMessage]:
         if use_assistant_message:
             message_ids_to_remove = []
@@ -234,6 +238,7 @@ class Message(BaseMessage):
                 assistant_message_tool_name=assistant_message_tool_name,
                 assistant_message_tool_kwarg=assistant_message_tool_kwarg,
                 reverse=reverse,
+                include_err=include_err,
             )
         ]
 
@@ -243,6 +248,7 @@ class Message(BaseMessage):
         assistant_message_tool_name: str = DEFAULT_MESSAGE_TOOL,
         assistant_message_tool_kwarg: str = DEFAULT_MESSAGE_TOOL_KWARG,
         reverse: bool = True,
+        include_err: Optional[bool] = None,
     ) -> List[LettaMessage]:
         """Convert message object (in DB format) to the style used by the original Letta API"""
         messages = []
@@ -682,14 +688,13 @@ class Message(BaseMessage):
         # since the only "parts" we have are for supporting various COT
 
         if self.role == "system":
-            assert all([v is not None for v in [self.role]]), vars(self)
             openai_message = {
                 "content": text_content,
                 "role": "developer" if use_developer_message else self.role,
             }
 
         elif self.role == "user":
-            assert all([v is not None for v in [text_content, self.role]]), vars(self)
+            assert text_content is not None, vars(self)
             openai_message = {
                 "content": text_content,
                 "role": self.role,
@@ -720,7 +725,7 @@ class Message(BaseMessage):
                         tool_call_dict["id"] = tool_call_dict["id"][:max_tool_id_length]
 
         elif self.role == "tool":
-            assert all([v is not None for v in [self.role, self.tool_call_id]]), vars(self)
+            assert self.tool_call_id is not None, vars(self)
             openai_message = {
                 "content": text_content,
                 "role": self.role,
@@ -776,7 +781,7 @@ class Message(BaseMessage):
         if self.role == "system":
             # NOTE: this is not for system instructions, but instead system "events"
 
-            assert all([v is not None for v in [text_content, self.role]]), vars(self)
+            assert text_content is not None, vars(self)
             # Two options here, we would use system.package_system_message,
             # or use a more Anthropic-specific packaging ie xml tags
             user_system_event = add_xml_tag(string=f"SYSTEM ALERT: {text_content}", xml_tag="event")
@@ -875,7 +880,7 @@ class Message(BaseMessage):
 
         elif self.role == "tool":
             # NOTE: Anthropic uses role "user" for "tool" responses
-            assert all([v is not None for v in [self.role, self.tool_call_id]]), vars(self)
+            assert self.tool_call_id is not None, vars(self)
             anthropic_message = {
                 "role": "user",  # NOTE: diff
                 "content": [
@@ -988,7 +993,7 @@ class Message(BaseMessage):
 
         elif self.role == "tool":
             # NOTE: Significantly different tool calling format, more similar to function calling format
-            assert all([v is not None for v in [self.role, self.tool_call_id]]), vars(self)
+            assert self.tool_call_id is not None, vars(self)
 
             if self.name is None:
                 warnings.warn(f"Couldn't find function name on tool call, defaulting to tool ID instead.")

letta/schemas/openai/chat_completion_response.py

@@ -106,7 +106,6 @@ class UsageStatistics(BaseModel):
     completion_tokens_details: Optional[UsageStatisticsCompletionTokenDetails] = None
 
     def __add__(self, other: "UsageStatistics") -> "UsageStatistics":
-
         if self.prompt_tokens_details is None and other.prompt_tokens_details is None:
             total_prompt_tokens_details = None
         elif self.prompt_tokens_details is None:

letta/schemas/providers.py

@@ -1536,6 +1536,26 @@ 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")
 
+    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
+
+        try:
+            # For BYOK providers, use the custom credentials
+            if self.provider_category == ProviderCategory.byok:
+                # If we can list models, the credentials are valid
+                bedrock_get_model_list(
+                    region_name=self.region,
+                    access_key_id=self.access_key,
+                    secret_access_key=self.api_key,  # api_key stores the secret access key
+                )
+            else:
+                # For base providers, use default credentials
+                bedrock_get_model_list(region_name=self.region)
+        except Exception as e:
+            raise LLMAuthenticationError(message=f"Failed to authenticate with Bedrock: {e}")
+
     def list_llm_models(self):
         from letta.llm_api.aws_bedrock import bedrock_get_model_list