letta-nightly 0.6.36.dev20250305002337__tar.gz → 0.6.37.dev20250306002740__tar.gz

{letta_nightly-0.6.36.dev20250305002337 → letta_nightly-0.6.37.dev20250306002740}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.36.dev20250305002337
+Version: 0.6.37.dev20250306002740
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -25,7 +25,7 @@ Requires-Dist: alembic (>=1.13.3,<2.0.0)
 Requires-Dist: anthropic (>=0.43.0,<0.44.0)
 Requires-Dist: autoflake (>=2.3.0,<3.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: black[jupyter] (>=24.2.0,<25.0.0) ; extra == "dev" or extra == "all"
-Requires-Dist: boto3 (>=1.36.24,<2.0.0) ; extra == "bedrock" or extra == "all"
+Requires-Dist: boto3 (>=1.36.24,<2.0.0) ; extra == "bedrock"
 Requires-Dist: brotli (>=1.1.0,<2.0.0)
 Requires-Dist: colorama (>=0.4.6,<0.5.0)
 Requires-Dist: composio-core (>=0.7.2,<0.8.0)
@@ -39,7 +39,7 @@ Requires-Dist: docx2txt (>=0.8,<0.9)
 Requires-Dist: e2b-code-interpreter (>=1.0.3,<2.0.0) ; extra == "cloud-tool-sandbox"
 Requires-Dist: faker (>=36.1.0,<37.0.0)
 Requires-Dist: fastapi (>=0.115.6,<0.116.0) ; extra == "server" or extra == "all"
-Requires-Dist: google-genai (>=1.1.0,<2.0.0) ; extra == "google" or extra == "all"
+Requires-Dist: google-genai (>=1.1.0,<2.0.0) ; extra == "google"
 Requires-Dist: grpcio (>=1.68.1,<2.0.0)
 Requires-Dist: grpcio-tools (>=1.68.1,<2.0.0)
 Requires-Dist: html2text (>=2020.1.16,<2021.0.0)
@@ -49,7 +49,7 @@ Requires-Dist: isort (>=5.13.2,<6.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: jinja2 (>=3.1.5,<4.0.0)
 Requires-Dist: langchain (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "all"
 Requires-Dist: langchain-community (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "all"
-Requires-Dist: letta_client (>=0.1.23,<0.2.0)
+Requires-Dist: letta_client (>=0.1.54,<0.2.0)
 Requires-Dist: llama-index (>=0.12.2,<0.13.0)
 Requires-Dist: llama-index-embeddings-openai (>=0.3.1,<0.4.0)
 Requires-Dist: locust (>=2.31.5,<3.0.0) ; extra == "dev" or extra == "all"
@@ -89,7 +89,7 @@ Requires-Dist: sqlalchemy-json (>=0.7.0,<0.8.0)
 Requires-Dist: sqlalchemy-utils (>=0.41.2,<0.42.0)
 Requires-Dist: sqlmodel (>=0.0.16,<0.0.17)
 Requires-Dist: tqdm (>=4.66.1,<5.0.0)
-Requires-Dist: typer (>=0.12,<1.0)
+Requires-Dist: typer[all] (>=0.9.0,<0.10.0)
 Requires-Dist: uvicorn (>=0.24.0.post1,<0.25.0) ; extra == "server" or extra == "all"
 Requires-Dist: wikipedia (>=1.4.0,<2.0.0) ; extra == "external-tools" or extra == "tests" or extra == "all"
 Description-Content-Type: text/markdown

{letta_nightly-0.6.36.dev20250305002337 → letta_nightly-0.6.37.dev20250306002740}/letta/__init__.py

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

{letta_nightly-0.6.36.dev20250305002337 → letta_nightly-0.6.37.dev20250306002740}/letta/agent.py

@@ -39,7 +39,7 @@ from letta.schemas.block import BlockUpdate
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import MessageRole
 from letta.schemas.memory import ContextWindowOverview, Memory
-from letta.schemas.message import Message
+from letta.schemas.message import Message, ToolReturn
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse
 from letta.schemas.openai.chat_completion_response import Message as ChatCompletionMessage
 from letta.schemas.openai.chat_completion_response import UsageStatistics
@@ -277,6 +277,7 @@ class Agent(BaseAgent):
         function_args: dict,
         function_response: str,
         messages: List[Message],
+        tool_returns: Optional[List[ToolReturn]] = None,
         include_function_failed_message: bool = False,
     ) -> List[Message]:
         """
@@ -298,6 +299,7 @@ class Agent(BaseAgent):
                 "content": function_response,
                 "tool_call_id": tool_call_id,
             },
+            tool_returns=tool_returns,
         )
         messages.append(new_message)
         self.interface.function_message(f"Error: {error_msg}", msg_obj=new_message)
@@ -561,8 +563,17 @@ class Agent(BaseAgent):
                 )
 
                 if sandbox_run_result and sandbox_run_result.status == "error":
+                    tool_return = ToolReturn(
+                        status=sandbox_run_result.status, stdout=sandbox_run_result.stdout, stderr=sandbox_run_result.stderr
+                    )
                     messages = self._handle_function_error_response(
-                        function_response, tool_call_id, function_name, function_args, function_response, messages
+                        function_response,
+                        tool_call_id,
+                        function_name,
+                        function_args,
+                        function_response,
+                        messages,
+                        [tool_return],
                     )
                     return messages, False, True  # force a heartbeat to allow agent to handle error
 
@@ -591,20 +602,52 @@ class Agent(BaseAgent):
                 error_msg_user = f"{error_msg}\n{traceback.format_exc()}"
                 self.logger.error(error_msg_user)
                 messages = self._handle_function_error_response(
-                    error_msg, tool_call_id, function_name, function_args, function_response, messages, include_function_failed_message=True
+                    error_msg,
+                    tool_call_id,
+                    function_name,
+                    function_args,
+                    function_response,
+                    messages,
+                    [ToolReturn(status="error", stderr=[error_msg_user])],
+                    include_function_failed_message=True,
                 )
                 return messages, False, True  # force a heartbeat to allow agent to handle error
 
             # Step 4: check if function response is an error
             if function_response_string.startswith(ERROR_MESSAGE_PREFIX):
                 error_msg = function_response_string
+                tool_return = (
+                    ToolReturn(
+                        status=sandbox_run_result.status,
+                        stdout=sandbox_run_result.stdout,
+                        stderr=sandbox_run_result.stderr,
+                    )
+                    if sandbox_run_result
+                    else None
+                )
                 messages = self._handle_function_error_response(
-                    error_msg, tool_call_id, function_name, function_args, function_response, messages, include_function_failed_message=True
+                    error_msg,
+                    tool_call_id,
+                    function_name,
+                    function_args,
+                    function_response,
+                    messages,
+                    [tool_return] if tool_return else None,
+                    include_function_failed_message=True,
                 )
                 return messages, False, True  # force a heartbeat to allow agent to handle error
 
             # If no failures happened along the way: ...
             # Step 5: send the info on the function call and function response to GPT
+            tool_return = (
+                ToolReturn(
+                    status=sandbox_run_result.status,
+                    stdout=sandbox_run_result.stdout,
+                    stderr=sandbox_run_result.stderr,
+                )
+                if sandbox_run_result
+                else None
+            )
             messages.append(
                 Message.dict_to_message(
                     agent_id=self.agent_state.id,
@@ -616,6 +659,7 @@ class Agent(BaseAgent):
                         "content": function_response,
                         "tool_call_id": tool_call_id,
                     },
+                    tool_returns=[tool_return] if tool_return else None,
                 )
             )  # extend conversation with function response
             self.interface.function_message(f"Ran {function_name}({function_args})", msg_obj=messages[-1])

{letta_nightly-0.6.36.dev20250305002337 → letta_nightly-0.6.37.dev20250306002740}/letta/helpers/converters.py

@@ -9,6 +9,7 @@ from sqlalchemy import Dialect
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import ToolRuleType
 from letta.schemas.llm_config import LLMConfig
+from letta.schemas.message import ToolReturn
 from letta.schemas.tool_rule import ChildToolRule, ConditionalToolRule, ContinueToolRule, InitToolRule, TerminalToolRule, ToolRule
 
 # --------------------------
@@ -127,6 +128,41 @@ def deserialize_tool_calls(data: Optional[List[Dict]]) -> List[OpenAIToolCall]:
     return calls
 
 
+# --------------------------
+# ToolReturn Serialization
+# --------------------------
+
+
+def serialize_tool_returns(tool_returns: Optional[List[Union[ToolReturn, dict]]]) -> List[Dict]:
+    """Convert a list of ToolReturn objects into JSON-serializable format."""
+    if not tool_returns:
+        return []
+
+    serialized_tool_returns = []
+    for tool_return in tool_returns:
+        if isinstance(tool_return, ToolReturn):
+            serialized_tool_returns.append(tool_return.model_dump())
+        elif isinstance(tool_return, dict):
+            serialized_tool_returns.append(tool_return)  # Already a dictionary, leave it as-is
+        else:
+            raise TypeError(f"Unexpected tool return type: {type(tool_return)}")
+
+    return serialized_tool_returns
+
+
+def deserialize_tool_returns(data: Optional[List[Dict]]) -> List[ToolReturn]:
+    """Convert a JSON list back into ToolReturn objects."""
+    if not data:
+        return []
+
+    tool_returns = []
+    for item in data:
+        tool_return = ToolReturn(**item)
+        tool_returns.append(tool_return)
+
+    return tool_returns
+
+
 # --------------------------
 # Vector Serialization
 # --------------------------

{letta_nightly-0.6.36.dev20250305002337 → letta_nightly-0.6.37.dev20250306002740}/letta/orm/custom_columns.py

@@ -5,11 +5,13 @@ from letta.helpers.converters import (
     deserialize_embedding_config,
     deserialize_llm_config,
     deserialize_tool_calls,
+    deserialize_tool_returns,
     deserialize_tool_rules,
     deserialize_vector,
     serialize_embedding_config,
     serialize_llm_config,
     serialize_tool_calls,
+    serialize_tool_returns,
     serialize_tool_rules,
     serialize_vector,
 )
@@ -67,6 +69,19 @@ class ToolCallColumn(TypeDecorator):
         return deserialize_tool_calls(value)
 
 
+class ToolReturnColumn(TypeDecorator):
+    """Custom SQLAlchemy column type for storing the return value of a tool call as JSON."""
+
+    impl = JSON
+    cache_ok = True
+
+    def process_bind_param(self, value, dialect):
+        return serialize_tool_returns(value)
+
+    def process_result_value(self, value, dialect):
+        return deserialize_tool_returns(value)
+
+
 class CommonVector(TypeDecorator):
     """Custom SQLAlchemy column type for storing vectors in SQLite."""
 

{letta_nightly-0.6.36.dev20250305002337 → letta_nightly-0.6.37.dev20250306002740}/letta/orm/message.py

@@ -1,14 +1,15 @@
-from typing import Optional
+from typing import List, Optional
 
 from openai.types.chat.chat_completion_message_tool_call import ChatCompletionMessageToolCall as OpenAIToolCall
 from sqlalchemy import ForeignKey, Index
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
-from letta.orm.custom_columns import ToolCallColumn
+from letta.orm.custom_columns import ToolCallColumn, ToolReturnColumn
 from letta.orm.mixins import AgentMixin, OrganizationMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.message import Message as PydanticMessage
 from letta.schemas.message import TextContent as PydanticTextContent
+from letta.schemas.message import ToolReturn
 
 
 class Message(SqlalchemyBase, OrganizationMixin, AgentMixin):
@@ -26,11 +27,15 @@ class Message(SqlalchemyBase, OrganizationMixin, AgentMixin):
     text: Mapped[Optional[str]] = mapped_column(nullable=True, doc="Message content")
     model: Mapped[Optional[str]] = mapped_column(nullable=True, doc="LLM model used")
     name: Mapped[Optional[str]] = mapped_column(nullable=True, doc="Name for multi-agent scenarios")
-    tool_calls: Mapped[OpenAIToolCall] = mapped_column(ToolCallColumn, doc="Tool call information")
+    tool_calls: Mapped[List[OpenAIToolCall]] = mapped_column(ToolCallColumn, doc="Tool call information")
     tool_call_id: Mapped[Optional[str]] = mapped_column(nullable=True, doc="ID of the tool call")
     step_id: Mapped[Optional[str]] = mapped_column(
         ForeignKey("steps.id", ondelete="SET NULL"), nullable=True, doc="ID of the step that this message belongs to"
     )
+    otid: Mapped[Optional[str]] = mapped_column(nullable=True, doc="The offline threading ID associated with this message")
+    tool_returns: Mapped[List[ToolReturn]] = mapped_column(
+        ToolReturnColumn, nullable=True, doc="Tool execution return information for prior tool calls"
+    )
 
     # Relationships
     agent: Mapped["Agent"] = relationship("Agent", back_populates="messages", lazy="selectin")

{letta_nightly-0.6.36.dev20250305002337 → letta_nightly-0.6.37.dev20250306002740}/letta/schemas/agent.py

@@ -175,11 +175,6 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
             # don't check if not provided
             return name
 
-        # TODO: this check should also be added to other model (e.g. User.name)
-        # Length check
-        if not (1 <= len(name) <= 50):
-            raise ValueError("Name length must be between 1 and 50 characters.")
-
         # Regex for allowed characters (alphanumeric, spaces, hyphens, underscores)
         if not re.match("^[A-Za-z0-9 _-]+$", name):
             raise ValueError("Name contains invalid characters.")

{letta_nightly-0.6.36.dev20250305002337 → letta_nightly-0.6.37.dev20250306002740}/letta/schemas/message.py

@@ -124,9 +124,11 @@ class Message(BaseMessage):
     agent_id: Optional[str] = Field(None, description="The unique identifier of the agent.")
     model: Optional[str] = Field(None, description="The model used to make the function call.")
     name: Optional[str] = Field(None, description="The name of the participant.")
-    tool_calls: Optional[List[OpenAIToolCall,]] = Field(None, description="The list of tool calls requested.")
+    tool_calls: Optional[List[OpenAIToolCall]] = Field(None, description="The list of tool calls requested.")
     tool_call_id: Optional[str] = Field(None, description="The id of the tool call.")
     step_id: Optional[str] = Field(None, description="The id of the step that this message was created in.")
+    otid: Optional[str] = Field(None, description="The offline threading id associated with this message")
+    tool_returns: Optional[List[ToolReturn]] = Field(None, description="Tool execution return information for prior tool calls")
 
     # 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.")
@@ -299,8 +301,10 @@ class Message(BaseMessage):
                     id=self.id,
                     date=self.created_at,
                     tool_return=self.text,
-                    status=status_enum,
+                    status=self.tool_returns[0].status if self.tool_returns else status_enum,
                     tool_call_id=self.tool_call_id,
+                    stdout=self.tool_returns[0].stdout if self.tool_returns else None,
+                    stderr=self.tool_returns[0].stderr if self.tool_returns else None,
                 )
             )
         elif self.role == MessageRole.user:
@@ -338,6 +342,7 @@ class Message(BaseMessage):
         allow_functions_style: bool = False,  # allow deprecated functions style?
         created_at: Optional[datetime] = None,
         id: Optional[str] = None,
+        tool_returns: Optional[List[ToolReturn]] = None,
     ):
         """Convert a ChatCompletion message object into a Message object (synced to DB)"""
         if not created_at:
@@ -366,6 +371,7 @@ class Message(BaseMessage):
                     tool_call_id=openai_message_dict["tool_call_id"] if "tool_call_id" in openai_message_dict else None,
                     created_at=created_at,
                     id=str(id),
+                    tool_returns=tool_returns,
                 )
             else:
                 return Message(
@@ -378,6 +384,7 @@ class Message(BaseMessage):
                     tool_calls=openai_message_dict["tool_calls"] if "tool_calls" in openai_message_dict else None,
                     tool_call_id=openai_message_dict["tool_call_id"] if "tool_call_id" in openai_message_dict else None,
                     created_at=created_at,
+                    tool_returns=tool_returns,
                 )
 
         elif "function_call" in openai_message_dict and openai_message_dict["function_call"] is not None:
@@ -411,6 +418,7 @@ class Message(BaseMessage):
                     tool_call_id=None,  # NOTE: None, since this field is only non-null for role=='tool'
                     created_at=created_at,
                     id=str(id),
+                    tool_returns=tool_returns,
                 )
             else:
                 return Message(
@@ -423,6 +431,7 @@ class Message(BaseMessage):
                     tool_calls=tool_calls,
                     tool_call_id=None,  # NOTE: None, since this field is only non-null for role=='tool'
                     created_at=created_at,
+                    tool_returns=tool_returns,
                 )
 
         else:
@@ -456,6 +465,7 @@ class Message(BaseMessage):
                     tool_call_id=openai_message_dict["tool_call_id"] if "tool_call_id" in openai_message_dict else None,
                     created_at=created_at,
                     id=str(id),
+                    tool_returns=tool_returns,
                 )
             else:
                 return Message(
@@ -468,6 +478,7 @@ class Message(BaseMessage):
                     tool_calls=tool_calls,
                     tool_call_id=openai_message_dict["tool_call_id"] if "tool_call_id" in openai_message_dict else None,
                     created_at=created_at,
+                    tool_returns=tool_returns,
                 )
 
     def to_openai_dict_search_results(self, max_tool_id_length: int = TOOL_CALL_ID_MAX_LEN) -> dict:
@@ -844,3 +855,9 @@ class Message(BaseMessage):
             raise ValueError(self.role)
 
         return cohere_message
+
+
+class ToolReturn(BaseModel):
+    status: Literal["success", "error"] = Field(..., description="The status of the tool call")
+    stdout: Optional[List[str]] = Field(None, description="Captured stdout (e.g. prints, logs) from the tool invocation")
+    stderr: Optional[List[str]] = Field(None, description="Captured stderr from the tool invocation")

{letta_nightly-0.6.36.dev20250305002337 → letta_nightly-0.6.37.dev20250306002740}/letta/serialize_schemas/agent.py

@@ -5,10 +5,12 @@ 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.agent_environment_variable import SerializedAgentEnvironmentVariableSchema
 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.tag import SerializedAgentTagSchema
 from letta.serialize_schemas.tool import SerializedToolSchema
 from letta.server.db import SessionLocal
 
@@ -28,6 +30,8 @@ class SerializedAgentSchema(BaseSchema):
     messages = fields.List(fields.Nested(SerializedMessageSchema))
     core_memory = fields.List(fields.Nested(SerializedBlockSchema))
     tools = fields.List(fields.Nested(SerializedToolSchema))
+    tool_exec_environment_variables = fields.List(fields.Nested(SerializedAgentEnvironmentVariableSchema))
+    tags = fields.List(fields.Nested(SerializedAgentTagSchema))
 
     def __init__(self, *args, session: SessionLocal, actor: User, **kwargs):
         super().__init__(*args, actor=actor, **kwargs)
@@ -66,4 +70,4 @@ class SerializedAgentSchema(BaseSchema):
     class Meta(BaseSchema.Meta):
         model = Agent
         # TODO: Serialize these as well...
-        exclude = BaseSchema.Meta.exclude + ("sources", "tags", "source_passages", "agent_passages")
+        exclude = BaseSchema.Meta.exclude + ("sources", "source_passages", "agent_passages")

letta_nightly-0.6.37.dev20250306002740/letta/serialize_schemas/agent_environment_variable.py

@@ -0,0 +1,21 @@
+import uuid
+from typing import Optional
+
+from letta.orm.sandbox_config import AgentEnvironmentVariable
+from letta.serialize_schemas.base import BaseSchema
+
+
+class SerializedAgentEnvironmentVariableSchema(BaseSchema):
+    """
+    Marshmallow schema for serializing/deserializing AgentEnvironmentVariable objects.
+    """
+
+    __pydantic_model__ = None
+
+    def generate_id(self) -> Optional[str]:
+        # TODO: This is brittle and duplicated in orm/sandbox_config.py
+        return f"agent-env-{uuid.uuid4()}"
+
+    class Meta(BaseSchema.Meta):
+        model = AgentEnvironmentVariable
+        exclude = BaseSchema.Meta.exclude + ("agent",)

{letta_nightly-0.6.36.dev20250305002337 → letta_nightly-0.6.37.dev20250306002740}/letta/serialize_schemas/base.py

@@ -22,9 +22,20 @@ class BaseSchema(SQLAlchemyAutoSchema):
         super().__init__(*args, **kwargs)
         self.actor = actor
 
+    def generate_id(self) -> Optional[str]:
+        if self.__pydantic_model__:
+            return self.__pydantic_model__.generate_id()
+
+        return None
+
     @post_dump
-    def sanitize_ids(self, data: Dict, **kwargs):
-        data["id"] = self.__pydantic_model__.generate_id()
+    def sanitize_ids(self, data: Dict, **kwargs) -> Dict:
+        if self.Meta.model:
+            mapper = inspect(self.Meta.model)
+            if "id" in mapper.columns:
+                generated_id = self.generate_id()
+                if generated_id:
+                    data["id"] = generated_id
 
         for sensitive_id in BaseSchema.sensitive_ids.union(BaseSchema.sensitive_relationships):
             if sensitive_id in data:
@@ -33,7 +44,7 @@ class BaseSchema(SQLAlchemyAutoSchema):
         return data
 
     @pre_load
-    def regenerate_ids(self, data: Dict, **kwargs):
+    def regenerate_ids(self, data: Dict, **kwargs) -> Dict:
         if self.Meta.model:
             mapper = inspect(self.Meta.model)
             for sensitive_id in BaseSchema.sensitive_ids:

letta_nightly-0.6.37.dev20250306002740/letta/serialize_schemas/tag.py

@@ -0,0 +1,18 @@
+from marshmallow import fields
+
+from letta.orm.agents_tags import AgentsTags
+from letta.serialize_schemas.base import BaseSchema
+
+
+class SerializedAgentTagSchema(BaseSchema):
+    """
+    Marshmallow schema for serializing/deserializing Agent Tags.
+    """
+
+    __pydantic_model__ = None
+
+    tag = fields.String(required=True)
+
+    class Meta(BaseSchema.Meta):
+        model = AgentsTags
+        exclude = BaseSchema.Meta.exclude + ("agent",)

{letta_nightly-0.6.36.dev20250305002337 → letta_nightly-0.6.37.dev20250306002740}/letta/server/rest_api/app.py

@@ -235,12 +235,14 @@ def create_application() -> "FastAPI":
     endpoint = os.getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
     if endpoint:
         print(f"▶ Using OTLP tracing with endpoint: {endpoint}")
+        env_name_suffix = os.getenv("ENV_NAME")
+        service_name = f"letta-server-{env_name_suffix.lower()}" if env_name_suffix else "letta-server"
         from letta.tracing import setup_tracing
 
         setup_tracing(
             endpoint=endpoint,
             app=app,
-            service_name="memgpt-server",
+            service_name=service_name,
         )
 
     for route in v1_routes:

{letta_nightly-0.6.36.dev20250305002337 → letta_nightly-0.6.37.dev20250306002740}/letta/server/rest_api/interface.py

@@ -1169,8 +1169,10 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                     id=msg_obj.id,
                     date=msg_obj.created_at,
                     tool_return=msg,
-                    status="success",
+                    status=msg_obj.tool_returns[0].status if msg_obj.tool_returns else "success",
                     tool_call_id=msg_obj.tool_call_id,
+                    stdout=msg_obj.tool_returns[0].stdout if msg_obj.tool_returns else None,
+                    stderr=msg_obj.tool_returns[0].stderr if msg_obj.tool_returns else None,
                 )
 
         elif msg.startswith("Error: "):
@@ -1181,8 +1183,10 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                 id=msg_obj.id,
                 date=msg_obj.created_at,
                 tool_return=msg,
-                status="error",
+                status=msg_obj.tool_returns[0].status if msg_obj.tool_returns else "error",
                 tool_call_id=msg_obj.tool_call_id,
+                stdout=msg_obj.tool_returns[0].stdout if msg_obj.tool_returns else None,
+                stderr=msg_obj.tool_returns[0].stderr if msg_obj.tool_returns else None,
             )
 
         else:

{letta_nightly-0.6.36.dev20250305002337 → letta_nightly-0.6.37.dev20250306002740}/letta/server/rest_api/routers/v1/agents.py

@@ -1,10 +1,13 @@
+import json
 import traceback
 from datetime import datetime
 from typing import Annotated, List, Optional
 
-from fastapi import APIRouter, BackgroundTasks, Body, Depends, Header, HTTPException, Query, status
+from fastapi import APIRouter, BackgroundTasks, Body, Depends, File, Header, HTTPException, Query, UploadFile, status
 from fastapi.responses import JSONResponse
+from marshmallow import ValidationError
 from pydantic import Field
+from sqlalchemy.exc import IntegrityError, OperationalError
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.log import get_logger
@@ -88,6 +91,65 @@ def list_agents(
     return agents
 
 
+@router.get("/{agent_id}/download", operation_id="download_agent_serialized")
+def download_agent_serialized(
+    agent_id: str,
+    server: "SyncServer" = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+):
+    """
+    Download the serialized JSON representation of an agent.
+    """
+    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+
+    try:
+        serialized_agent = server.agent_manager.serialize(agent_id=agent_id, actor=actor)
+        return JSONResponse(content=serialized_agent, media_type="application/json")
+    except NoResultFound:
+        raise HTTPException(status_code=404, detail=f"Agent with id={agent_id} not found for user_id={actor.id}.")
+
+
+@router.post("/upload", response_model=AgentState, operation_id="upload_agent_serialized")
+async def upload_agent_serialized(
+    file: UploadFile = File(...),
+    server: "SyncServer" = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+    append_copy_suffix: bool = Query(True, description='If set to True, appends "_copy" to the end of the agent name.'),
+    override_existing_tools: bool = Query(
+        True,
+        description="If set to True, existing tools can get their source code overwritten by the uploaded tool definitions. Note that Letta core tools can never be updated externally.",
+    ),
+):
+    """
+    Upload a serialized agent JSON file and recreate the agent in the system.
+    """
+    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+
+    try:
+        serialized_data = await file.read()
+        agent_json = json.loads(serialized_data)
+        new_agent = server.agent_manager.deserialize(
+            serialized_agent=agent_json, actor=actor, append_copy_suffix=append_copy_suffix, override_existing_tools=override_existing_tools
+        )
+        return new_agent
+
+    except json.JSONDecodeError:
+        raise HTTPException(status_code=400, detail="Corrupted agent file format.")
+
+    except ValidationError as e:
+        raise HTTPException(status_code=422, detail=f"Invalid agent schema: {str(e)}")
+
+    except IntegrityError as e:
+        raise HTTPException(status_code=409, detail=f"Database integrity error: {str(e)}")
+
+    except OperationalError as e:
+        raise HTTPException(status_code=503, detail=f"Database connection error. Please try again later: {str(e)}")
+
+    except Exception:
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail="An unexpected error occurred while uploading the agent.")
+
+
 @router.get("/{agent_id}/context", response_model=ContextWindowOverview, operation_id="retrieve_agent_context_window")
 def retrieve_agent_context_window(
     agent_id: str,

{letta_nightly-0.6.36.dev20250305002337 → letta_nightly-0.6.37.dev20250306002740}/letta/services/agent_manager.py

@@ -15,6 +15,7 @@ from letta.orm import Identity as IdentityModel
 from letta.orm import Source as SourceModel
 from letta.orm import SourcePassage, SourcesAgents
 from letta.orm import Tool as ToolModel
+from letta.orm.enums import ToolType
 from letta.orm.errors import NoResultFound
 from letta.orm.sandbox_config import AgentEnvironmentVariable as AgentEnvironmentVariableModel
 from letta.orm.sqlite_functions import adapt_array
@@ -399,13 +400,15 @@ class AgentManager:
             return schema.dump(agent)
 
     @enforce_types
-    def deserialize(self, serialized_agent: dict, actor: PydanticUser, mark_as_copy: bool = True) -> PydanticAgentState:
+    def deserialize(
+        self, serialized_agent: dict, actor: PydanticUser, append_copy_suffix: bool = True, override_existing_tools: bool = True
+    ) -> PydanticAgentState:
         tool_data_list = serialized_agent.pop("tools", [])
 
         with self.session_maker() as session:
             schema = SerializedAgentSchema(session=session, actor=actor)
             agent = schema.load(serialized_agent, session=session)
-            if mark_as_copy:
+            if append_copy_suffix:
                 agent.name += "_copy"
             agent.create(session, actor=actor)
             pydantic_agent = agent.to_pydantic()
@@ -413,7 +416,20 @@ class AgentManager:
         # 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)
+
+            existing_pydantic_tool = self.tool_manager.get_tool_by_name(pydantic_tool.name, actor=actor)
+            # If the tool exists
+            # AND EITHER:
+            # 1) override_existing_tools is set to False
+            # 2) existing_pydantic_tool is NOT any type of Letta core tool
+            if existing_pydantic_tool and (
+                existing_pydantic_tool.tool_type in {ToolType.LETTA_CORE, ToolType.LETTA_MULTI_AGENT_CORE, ToolType.LETTA_MEMORY_CORE}
+                or not override_existing_tools
+            ):
+                pydantic_tool = existing_pydantic_tool
+            else:
+                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
@@ -461,6 +477,8 @@ class AgentManager:
                             value=value,
                             agent_id=agent_id,
                             organization_id=actor.organization_id,
+                            created_by_id=actor.id,
+                            last_updated_by_id=actor.id,
                         )
                     )