letta-nightly 0.6.35.dev20250304104154__tar.gz → 0.6.36.dev20250305104137__tar.gz

{letta_nightly-0.6.35.dev20250304104154 → letta_nightly-0.6.36.dev20250305104137}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.35.dev20250304104154
+Version: 0.6.36.dev20250305104137
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.6.35.dev20250304104154 → letta_nightly-0.6.36.dev20250305104137}/letta/__init__.py

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

{letta_nightly-0.6.35.dev20250304104154 → letta_nightly-0.6.36.dev20250305104137}/letta/client/client.py

@@ -1,4 +1,5 @@
 import logging
+import sys
 import time
 from typing import Callable, Dict, Generator, List, Optional, Union
 
@@ -40,6 +41,16 @@ from letta.schemas.tool_rule import BaseToolRule
 from letta.server.rest_api.interface import QueuingInterface
 from letta.utils import get_human_text, get_persona_text
 
+# Print deprecation notice in yellow when module is imported
+print(
+    "\n\n\033[93m"
+    + "DEPRECATION WARNING: This legacy Python client has been deprecated and will be removed in a future release.\n"
+    + "Please migrate to the new official python SDK by running: pip install letta-client\n"
+    + "For further documentation, visit: https://docs.letta.com/api-reference/overview#python-sdk"
+    + "\033[0m\n\n",
+    file=sys.stderr,
+)
+
 
 def create_client(base_url: Optional[str] = None, token: Optional[str] = None):
     if base_url is None:

{letta_nightly-0.6.35.dev20250304104154 → letta_nightly-0.6.36.dev20250305104137}/letta/constants.py

@@ -2,7 +2,7 @@ import os
 from logging import CRITICAL, DEBUG, ERROR, INFO, NOTSET, WARN, WARNING
 
 LETTA_DIR = os.path.join(os.path.expanduser("~"), ".letta")
-LETTA_DIR_TOOL_SANDBOX = os.path.join(LETTA_DIR, "tool_sandbox_dir")
+LETTA_TOOL_EXECUTION_DIR = os.path.join(LETTA_DIR, "tool_execution_dir")
 
 ADMIN_PREFIX = "/v1/admin"
 API_PREFIX = "/v1"
@@ -146,6 +146,9 @@ MESSAGE_SUMMARY_WARNING_STR = " ".join(
         # "Remember to pass request_heartbeat = true if you would like to send a message immediately after.",
     ]
 )
+DATA_SOURCE_ATTACH_ALERT = (
+    "[ALERT] New data was just uploaded to archival memory. You can view this data by calling the archival_memory_search tool."
+)
 
 # The ackknowledgement message used in the summarize sequence
 MESSAGE_SUMMARY_REQUEST_ACK = "Understood, I will respond with a summary of the message (and only the summary, nothing else) once I receive the conversation history. I'm ready."

{letta_nightly-0.6.35.dev20250304104154 → letta_nightly-0.6.36.dev20250305104137}/letta/log.py

@@ -54,7 +54,7 @@ DEVELOPMENT_LOGGING = {
             "propagate": True,  # Let logs bubble up to root
         },
         "uvicorn": {
-            "level": "DEBUG",
+            "level": "INFO",
             "handlers": ["console"],
             "propagate": True,
         },

{letta_nightly-0.6.35.dev20250304104154 → letta_nightly-0.6.36.dev20250305104137}/letta/schemas/letta_base.py

@@ -38,15 +38,15 @@ class LettaBase(BaseModel):
             description=cls._id_description(prefix),
             pattern=cls._id_regex_pattern(prefix),
             examples=[cls._id_example(prefix)],
-            default_factory=cls._generate_id,
+            default_factory=cls.generate_id,
         )
 
     @classmethod
-    def _generate_id(cls, prefix: Optional[str] = None) -> str:
+    def generate_id(cls, prefix: Optional[str] = None) -> str:
         prefix = prefix or cls.__id_prefix__
         return f"{prefix}-{uuid.uuid4()}"
 
-    # def _generate_id(self) -> str:
+    # def generate_id(self) -> str:
     #    return f"{self.__id_prefix__}-{uuid.uuid4()}"
 
     @classmethod

{letta_nightly-0.6.35.dev20250304104154 → letta_nightly-0.6.36.dev20250305104137}/letta/schemas/providers.py

@@ -27,7 +27,7 @@ class Provider(ProviderBase):
 
     def resolve_identifier(self):
         if not self.id:
-            self.id = ProviderBase._generate_id(prefix=ProviderBase.__id_prefix__)
+            self.id = ProviderBase.generate_id(prefix=ProviderBase.__id_prefix__)
 
     def list_llm_models(self) -> List[LLMConfig]:
         return []

{letta_nightly-0.6.35.dev20250304104154 → letta_nightly-0.6.36.dev20250305104137}/letta/schemas/sandbox_config.py

@@ -6,6 +6,7 @@ from typing import Any, Dict, List, Literal, Optional, Union
 
 from pydantic import BaseModel, Field, model_validator
 
+from letta.constants import LETTA_TOOL_EXECUTION_DIR
 from letta.schemas.agent import AgentState
 from letta.schemas.letta_base import LettaBase, OrmMetadataBase
 from letta.settings import tool_settings
@@ -71,7 +72,7 @@ class LocalSandboxConfig(BaseModel):
             if tool_settings.local_sandbox_dir:
                 data["sandbox_dir"] = tool_settings.local_sandbox_dir
             else:
-                data["sandbox_dir"] = "~/.letta"
+                data["sandbox_dir"] = LETTA_TOOL_EXECUTION_DIR
 
         return data
 

letta_nightly-0.6.36.dev20250305104137/letta/serialize_schemas/agent.py

@@ -0,0 +1,69 @@
+from typing import Dict
+
+from marshmallow import fields, post_dump
+
+from letta.orm import Agent
+from letta.schemas.agent import AgentState as PydanticAgentState
+from letta.schemas.user import User
+from letta.serialize_schemas.base import BaseSchema
+from letta.serialize_schemas.block import SerializedBlockSchema
+from letta.serialize_schemas.custom_fields import EmbeddingConfigField, LLMConfigField, ToolRulesField
+from letta.serialize_schemas.message import SerializedMessageSchema
+from letta.serialize_schemas.tool import SerializedToolSchema
+from letta.server.db import SessionLocal
+
+
+class SerializedAgentSchema(BaseSchema):
+    """
+    Marshmallow schema for serializing/deserializing Agent objects.
+    Excludes relational fields.
+    """
+
+    __pydantic_model__ = PydanticAgentState
+
+    llm_config = LLMConfigField()
+    embedding_config = EmbeddingConfigField()
+    tool_rules = ToolRulesField()
+
+    messages = fields.List(fields.Nested(SerializedMessageSchema))
+    core_memory = fields.List(fields.Nested(SerializedBlockSchema))
+    tools = fields.List(fields.Nested(SerializedToolSchema))
+
+    def __init__(self, *args, session: SessionLocal, actor: User, **kwargs):
+        super().__init__(*args, actor=actor, **kwargs)
+        self.session = session
+
+        # Propagate session and actor to nested schemas automatically
+        for field in self.fields.values():
+            if isinstance(field, fields.List) and isinstance(field.inner, fields.Nested):
+                field.inner.schema.session = session
+                field.inner.schema.actor = actor
+            elif isinstance(field, fields.Nested):
+                field.schema.session = session
+                field.schema.actor = actor
+
+    @post_dump
+    def sanitize_ids(self, data: Dict, **kwargs):
+        data = super().sanitize_ids(data, **kwargs)
+
+        # Remap IDs of messages
+        # Need to do this in post, so we can correctly map the in-context message IDs
+        # TODO: Remap message_ids to reference objects, not just be a list
+        id_remapping = dict()
+        for message in data.get("messages"):
+            message_id = message.get("id")
+            if message_id not in id_remapping:
+                id_remapping[message_id] = SerializedMessageSchema.__pydantic_model__.generate_id()
+                message["id"] = id_remapping[message_id]
+            else:
+                raise ValueError(f"Duplicate message IDs in agent.messages: {message_id}")
+
+        # Remap in context message ids
+        data["message_ids"] = [id_remapping[message_id] for message_id in data.get("message_ids")]
+
+        return data
+
+    class Meta(BaseSchema.Meta):
+        model = Agent
+        # TODO: Serialize these as well...
+        exclude = BaseSchema.Meta.exclude + ("sources", "tags", "source_passages", "agent_passages")

letta_nightly-0.6.36.dev20250305104137/letta/serialize_schemas/base.py

@@ -0,0 +1,53 @@
+from typing import Dict, Optional
+
+from marshmallow import post_dump, pre_load
+from marshmallow_sqlalchemy import SQLAlchemyAutoSchema
+from sqlalchemy.inspection import inspect
+
+from letta.schemas.user import User
+
+
+class BaseSchema(SQLAlchemyAutoSchema):
+    """
+    Base schema for all SQLAlchemy models.
+    This ensures all schemas share the same session.
+    """
+
+    __pydantic_model__ = None
+    sensitive_ids = {"_created_by_id", "_last_updated_by_id"}
+    sensitive_relationships = {"organization"}
+    id_scramble_placeholder = "xxx"
+
+    def __init__(self, *args, actor: Optional[User] = None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.actor = actor
+
+    @post_dump
+    def sanitize_ids(self, data: Dict, **kwargs):
+        data["id"] = self.__pydantic_model__.generate_id()
+
+        for sensitive_id in BaseSchema.sensitive_ids.union(BaseSchema.sensitive_relationships):
+            if sensitive_id in data:
+                data[sensitive_id] = BaseSchema.id_scramble_placeholder
+
+        return data
+
+    @pre_load
+    def regenerate_ids(self, data: Dict, **kwargs):
+        if self.Meta.model:
+            mapper = inspect(self.Meta.model)
+            for sensitive_id in BaseSchema.sensitive_ids:
+                if sensitive_id in mapper.columns:
+                    data[sensitive_id] = self.actor.id
+
+            for relationship in BaseSchema.sensitive_relationships:
+                if relationship in mapper.relationships:
+                    data[relationship] = self.actor.organization_id
+
+        return data
+
+    class Meta:
+        model = None
+        include_relationships = True
+        load_instance = True
+        exclude = ()

letta_nightly-0.6.36.dev20250305104137/letta/serialize_schemas/block.py

@@ -0,0 +1,15 @@
+from letta.orm.block import Block
+from letta.schemas.block import Block as PydanticBlock
+from letta.serialize_schemas.base import BaseSchema
+
+
+class SerializedBlockSchema(BaseSchema):
+    """
+    Marshmallow schema for serializing/deserializing Block objects.
+    """
+
+    __pydantic_model__ = PydanticBlock
+
+    class Meta(BaseSchema.Meta):
+        model = Block
+        exclude = BaseSchema.Meta.exclude + ("agents",)

letta_nightly-0.6.36.dev20250305104137/letta/serialize_schemas/message.py

@@ -0,0 +1,29 @@
+from typing import Dict
+
+from marshmallow import post_dump
+
+from letta.orm.message import Message
+from letta.schemas.message import Message as PydanticMessage
+from letta.serialize_schemas.base import BaseSchema
+from letta.serialize_schemas.custom_fields import ToolCallField
+
+
+class SerializedMessageSchema(BaseSchema):
+    """
+    Marshmallow schema for serializing/deserializing Message objects.
+    """
+
+    __pydantic_model__ = PydanticMessage
+
+    tool_calls = ToolCallField()
+
+    @post_dump
+    def sanitize_ids(self, data: Dict, **kwargs):
+        # We don't want to remap here
+        # Because of the way that message_ids is just a JSON field on agents
+        # We need to wait for the agent dumps, and then keep track of all the message IDs we remapped
+        return data
+
+    class Meta(BaseSchema.Meta):
+        model = Message
+        exclude = BaseSchema.Meta.exclude + ("step", "job_message", "agent")

letta_nightly-0.6.36.dev20250305104137/letta/serialize_schemas/tool.py

@@ -0,0 +1,15 @@
+from letta.orm import Tool
+from letta.schemas.tool import Tool as PydanticTool
+from letta.serialize_schemas.base import BaseSchema
+
+
+class SerializedToolSchema(BaseSchema):
+    """
+    Marshmallow schema for serializing/deserializing Tool objects.
+    """
+
+    __pydantic_model__ = PydanticTool
+
+    class Meta(BaseSchema.Meta):
+        model = Tool
+        exclude = BaseSchema.Meta.exclude

{letta_nightly-0.6.35.dev20250304104154 → letta_nightly-0.6.36.dev20250305104137}/letta/server/rest_api/routers/v1/identities.py

@@ -42,6 +42,8 @@ def list_identities(
         )
     except HTTPException:
         raise
+    except NoResultFound as e:
+        raise HTTPException(status_code=404, detail=str(e))
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"{e}")
     return identities
@@ -75,11 +77,11 @@ def create_identity(
     except UniqueConstraintViolationError:
         if identity.project_id:
             raise HTTPException(
-                status_code=400,
+                status_code=409,
                 detail=f"An identity with identifier key {identity.identifier_key} already exists for project {identity.project_id}",
             )
         else:
-            raise HTTPException(status_code=400, detail=f"An identity with identifier key {identity.identifier_key} already exists")
+            raise HTTPException(status_code=409, detail=f"An identity with identifier key {identity.identifier_key} already exists")
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"{e}")
 
@@ -96,6 +98,8 @@ def upsert_identity(
         return server.identity_manager.upsert_identity(identity=identity, actor=actor)
     except HTTPException:
         raise
+    except NoResultFound as e:
+        raise HTTPException(status_code=404, detail=str(e))
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"{e}")
 
@@ -112,6 +116,8 @@ def modify_identity(
         return server.identity_manager.update_identity(identity_id=identity_id, identity=identity, actor=actor)
     except HTTPException:
         raise
+    except NoResultFound as e:
+        raise HTTPException(status_code=404, detail=str(e))
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"{e}")
 
@@ -125,5 +131,12 @@ def delete_identity(
     """
     Delete an identity by its identifier key
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    server.identity_manager.delete_identity(identity_id=identity_id, actor=actor)
+    try:
+        actor = server.user_manager.get_user_or_default(user_id=actor_id)
+        server.identity_manager.delete_identity(identity_id=identity_id, actor=actor)
+    except HTTPException:
+        raise
+    except NoResultFound as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"{e}")

{letta_nightly-0.6.35.dev20250304104154 → letta_nightly-0.6.36.dev20250305104137}/letta/server/startup.sh

@@ -38,6 +38,15 @@ if ! alembic upgrade head; then
 fi
 echo "Database migration completed successfully."
 
+# Set permissions for tool execution directory if configured
+if [ -n "$LETTA_SANDBOX_MOUNT_PATH" ]; then
+    if ! chmod 777 "$LETTA_SANDBOX_MOUNT_PATH"; then
+        echo "ERROR: Failed to set permissions for tool execution directory at: $LETTA_SANDBOX_MOUNT_PATH"
+        echo "Please check that the directory exists and is accessible"
+        exit 1
+    fi
+fi
+
 # If ADE is enabled, add the --ade flag to the command
 CMD="letta server --host $HOST --port $PORT"
 if [ "${SECURE:-false}" = "true" ]; then

{letta_nightly-0.6.35.dev20250304104154 → letta_nightly-0.6.36.dev20250305104137}/letta/services/agent_manager.py

@@ -4,7 +4,7 @@ from typing import Dict, List, Optional
 import numpy as np
 from sqlalchemy import Select, and_, func, literal, or_, select, union_all
 
-from letta.constants import BASE_MEMORY_TOOLS, BASE_TOOLS, MAX_EMBEDDING_DIM, MULTI_AGENT_TOOLS
+from letta.constants import BASE_MEMORY_TOOLS, BASE_TOOLS, DATA_SOURCE_ATTACH_ALERT, MAX_EMBEDDING_DIM, MULTI_AGENT_TOOLS
 from letta.embeddings import embedding_model
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.log import get_logger
@@ -35,6 +35,7 @@ from letta.schemas.tool_rule import TerminalToolRule as PydanticTerminalToolRule
 from letta.schemas.tool_rule import ToolRule as PydanticToolRule
 from letta.schemas.user import User as PydanticUser
 from letta.serialize_schemas import SerializedAgentSchema
+from letta.serialize_schemas.tool import SerializedToolSchema
 from letta.services.block_manager import BlockManager
 from letta.services.helpers.agent_manager_helper import (
     _process_relationship,
@@ -394,18 +395,28 @@ class AgentManager:
         with self.session_maker() as session:
             # Retrieve the agent
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
-            schema = SerializedAgentSchema(session=session)
+            schema = SerializedAgentSchema(session=session, actor=actor)
             return schema.dump(agent)
 
     @enforce_types
-    def deserialize(self, serialized_agent: dict, actor: PydanticUser) -> PydanticAgentState:
-        # TODO: Use actor to override fields
+    def deserialize(self, serialized_agent: dict, actor: PydanticUser, mark_as_copy: bool = True) -> PydanticAgentState:
+        tool_data_list = serialized_agent.pop("tools", [])
+
         with self.session_maker() as session:
-            schema = SerializedAgentSchema(session=session)
+            schema = SerializedAgentSchema(session=session, actor=actor)
             agent = schema.load(serialized_agent, session=session)
-            agent.organization_id = actor.organization_id
-            agent = agent.create(session, actor=actor)
-            return agent.to_pydantic()
+            if mark_as_copy:
+                agent.name += "_copy"
+            agent.create(session, actor=actor)
+            pydantic_agent = agent.to_pydantic()
+
+        # Need to do this separately as there's some fancy upsert logic that SqlAlchemy cannot handle
+        for tool_data in tool_data_list:
+            pydantic_tool = SerializedToolSchema(actor=actor).load(tool_data, transient=True).to_pydantic()
+            pydantic_tool = self.tool_manager.create_or_update_tool(pydantic_tool, actor=actor)
+            pydantic_agent = self.attach_tool(agent_id=pydantic_agent.id, tool_id=pydantic_tool.id, actor=actor)
+
+        return pydantic_agent
 
     # ======================================================================================================================
     # Per Agent Environment Variable Management
@@ -670,6 +681,7 @@ class AgentManager:
             ValueError: If either agent or source doesn't exist
             IntegrityError: If the source is already attached to the agent
         """
+
         with self.session_maker() as session:
             # Verify both agent and source exist and user has permission to access them
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
@@ -687,7 +699,27 @@ class AgentManager:
 
             # Commit the changes
             agent.update(session, actor=actor)
-            return agent.to_pydantic()
+
+        # Add system messsage alert to agent
+        self.append_system_message(
+            agent_id=agent_id,
+            content=DATA_SOURCE_ATTACH_ALERT,
+            actor=actor,
+        )
+
+        return agent.to_pydantic()
+
+    @enforce_types
+    def append_system_message(self, agent_id: str, content: str, actor: PydanticUser):
+
+        # get the agent
+        agent = self.get_agent_by_id(agent_id=agent_id, actor=actor)
+        message = PydanticMessage.dict_to_message(
+            agent_id=agent.id, user_id=actor.id, model=agent.llm_config.model, openai_message_dict={"role": "system", "content": content}
+        )
+
+        # update agent in-context message IDs
+        self.append_to_in_context_messages(messages=[message], agent_id=agent_id, actor=actor)
 
     @enforce_types
     def list_attached_sources(self, agent_id: str, actor: PydanticUser) -> List[PydanticSource]:

{letta_nightly-0.6.35.dev20250304104154 → letta_nightly-0.6.36.dev20250305104137}/letta/services/message_manager.py

@@ -46,7 +46,7 @@ class MessageManager:
 
             # Sort results directly based on message_ids
             result_dict = {msg.id: msg.to_pydantic() for msg in results}
-            return [result_dict[msg_id] for msg_id in message_ids]
+            return list(filter(lambda x: x is not None, [result_dict.get(msg_id, None) for msg_id in message_ids]))
 
     @enforce_types
     def create_message(self, pydantic_msg: PydanticMessage, actor: PydanticUser) -> PydanticMessage:

{letta_nightly-0.6.35.dev20250304104154 → letta_nightly-0.6.36.dev20250305104137}/letta/services/sandbox_config_manager.py

@@ -1,6 +1,6 @@
 from typing import Dict, List, Optional
 
-from letta.constants import LETTA_DIR_TOOL_SANDBOX
+from letta.constants import LETTA_TOOL_EXECUTION_DIR
 from letta.log import get_logger
 from letta.orm.errors import NoResultFound
 from letta.orm.sandbox_config import SandboxConfig as SandboxConfigModel
@@ -35,7 +35,7 @@ class SandboxConfigManager:
                 default_config = {}  # Empty
             else:
                 # TODO: May want to move this to environment variables v.s. persisting in database
-                default_local_sandbox_path = LETTA_DIR_TOOL_SANDBOX
+                default_local_sandbox_path = LETTA_TOOL_EXECUTION_DIR
                 default_config = LocalSandboxConfig(sandbox_dir=default_local_sandbox_path).model_dump(exclude_none=True)
 
             sandbox_config = self.create_or_update_sandbox_config(SandboxConfigCreate(config=default_config), actor=actor)

{letta_nightly-0.6.35.dev20250304104154 → letta_nightly-0.6.36.dev20250305104137}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "letta-nightly"
-version = "0.6.35.dev20250304104154"
+version = "0.6.36.dev20250305104137"
 packages = [
     {include = "letta"},
 ]

letta_nightly-0.6.35.dev20250304104154/letta/serialize_schemas/agent.py

@@ -1,36 +0,0 @@
-from marshmallow import fields
-
-from letta.orm import Agent
-from letta.serialize_schemas.base import BaseSchema
-from letta.serialize_schemas.custom_fields import EmbeddingConfigField, LLMConfigField, ToolRulesField
-from letta.serialize_schemas.message import SerializedMessageSchema
-
-
-class SerializedAgentSchema(BaseSchema):
-    """
-    Marshmallow schema for serializing/deserializing Agent objects.
-    Excludes relational fields.
-    """
-
-    llm_config = LLMConfigField()
-    embedding_config = EmbeddingConfigField()
-    tool_rules = ToolRulesField()
-
-    messages = fields.List(fields.Nested(SerializedMessageSchema))
-
-    def __init__(self, *args, session=None, **kwargs):
-        super().__init__(*args, **kwargs)
-        if session:
-            self.session = session
-
-            # propagate session to nested schemas
-            for field_name, field_obj in self.fields.items():
-                if isinstance(field_obj, fields.List) and hasattr(field_obj.inner, "schema"):
-                    field_obj.inner.schema.session = session
-                elif hasattr(field_obj, "schema"):
-                    field_obj.schema.session = session
-
-    class Meta(BaseSchema.Meta):
-        model = Agent
-        # TODO: Serialize these as well...
-        exclude = ("tools", "sources", "core_memory", "tags", "source_passages", "agent_passages", "organization")

letta_nightly-0.6.35.dev20250304104154/letta/serialize_schemas/base.py

@@ -1,12 +0,0 @@
-from marshmallow_sqlalchemy import SQLAlchemyAutoSchema
-
-
-class BaseSchema(SQLAlchemyAutoSchema):
-    """
-    Base schema for all SQLAlchemy models.
-    This ensures all schemas share the same session.
-    """
-
-    class Meta:
-        include_relationships = True
-        load_instance = True

letta_nightly-0.6.35.dev20250304104154/letta/serialize_schemas/message.py

@@ -1,15 +0,0 @@
-from letta.orm.message import Message
-from letta.serialize_schemas.base import BaseSchema
-from letta.serialize_schemas.custom_fields import ToolCallField
-
-
-class SerializedMessageSchema(BaseSchema):
-    """
-    Marshmallow schema for serializing/deserializing Message objects.
-    """
-
-    tool_calls = ToolCallField()
-
-    class Meta(BaseSchema.Meta):
-        model = Message
-        exclude = ("step", "job_message")