letta-nightly 0.8.4.dev20250615104252__py3-none-any.whl → 0.8.4.dev20250616104355__py3-none-any.whl

letta/otel/metrics.py

@@ -5,18 +5,19 @@ from typing import List
 from fastapi import FastAPI, Request
 from opentelemetry import metrics
 from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter
-from opentelemetry.metrics import NoOpMeter
-from opentelemetry.sdk.metrics import MeterProvider
-from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
+from opentelemetry.metrics import Meter, NoOpMeter
+from opentelemetry.sdk.metrics import Counter, Histogram, MeterProvider
+from opentelemetry.sdk.metrics.export import AggregationTemporality, PeriodicExportingMetricReader
 
 from letta.helpers.datetime_helpers import ns_to_ms
 from letta.log import get_logger
 from letta.otel.context import add_ctx_attribute, get_ctx_attributes
 from letta.otel.resource import get_resource, is_pytest_environment
+from letta.settings import settings
 
 logger = get_logger(__name__)
 
-_meter: metrics.Meter = NoOpMeter("noop")
+_meter: Meter = NoOpMeter("noop")
 _is_metrics_initialized: bool = False
 
 # Endpoints to include in endpoint metrics tracking (opt-in) vs tracing.py opt-out
@@ -110,9 +111,17 @@ def setup_metrics(
     assert endpoint
 
     global _is_metrics_initialized, _meter
-
-    otlp_metric_exporter = OTLPMetricExporter(endpoint=endpoint)
+    preferred_temporality = AggregationTemporality(settings.otel_preferred_temporality)
+    otlp_metric_exporter = OTLPMetricExporter(
+        endpoint=endpoint,
+        preferred_temporality={
+            # Add more as needed here.
+            Counter: preferred_temporality,
+            Histogram: preferred_temporality,
+        },
+    )
     metric_reader = PeriodicExportingMetricReader(exporter=otlp_metric_exporter)
+
     meter_provider = MeterProvider(resource=get_resource(service_name), metric_readers=[metric_reader])
     metrics.set_meter_provider(meter_provider)
     _meter = metrics.get_meter(__name__)
@@ -123,7 +132,7 @@ def setup_metrics(
     _is_metrics_initialized = True
 
 
-def get_letta_meter() -> metrics.Meter | None:
+def get_letta_meter() -> Meter:
     """Returns the global letta meter if metrics are initialized."""
     if not _is_metrics_initialized or isinstance(_meter, NoOpMeter):
         logger.warning("Metrics are not initialized or meter is not available.")

letta/schemas/letta_response.py

@@ -9,6 +9,7 @@ from pydantic import BaseModel, Field
 from letta.helpers.json_helpers import json_dumps
 from letta.schemas.enums import JobStatus, MessageStreamStatus
 from letta.schemas.letta_message import LettaMessage, LettaMessageUnion
+from letta.schemas.letta_stop_reason import LettaStopReason
 from letta.schemas.message import Message
 from letta.schemas.usage import LettaUsageStatistics
 
@@ -34,6 +35,10 @@ class LettaResponse(BaseModel):
             }
         },
     )
+    stop_reason: LettaStopReason = Field(
+        ...,
+        description="The stop reason from Letta indicating why agent loop stopped execution.",
+    )
     usage: LettaUsageStatistics = Field(
         ...,
         description="The usage statistics of the agent.",
@@ -166,7 +171,7 @@ class LettaResponse(BaseModel):
 
 
 # The streaming response is either [DONE], [DONE_STEP], [DONE], an error, or a LettaMessage
-LettaStreamingResponse = Union[LettaMessage, MessageStreamStatus, LettaUsageStatistics]
+LettaStreamingResponse = Union[LettaMessage, MessageStreamStatus, LettaStopReason, LettaUsageStatistics]
 
 
 class LettaBatchResponse(BaseModel):

letta/schemas/letta_stop_reason.py

@@ -0,0 +1,22 @@
+from enum import Enum
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+class StopReasonType(str, Enum):
+    end_turn = "end_turn"
+    error = "error"
+    invalid_tool_call = "invalid_tool_call"
+    max_steps = "max_steps"
+    no_tool_call = "no_tool_call"
+    tool_rule = "tool_rule"
+
+
+class LettaStopReason(BaseModel):
+    """
+    The stop reason from Letta indicating why agent loop stopped execution.
+    """
+
+    message_type: Literal["stop_reason"] = Field("stop_reason", description="The type of the message.")
+    stop_reason: StopReasonType = Field(..., description="The reason why execution stopped.")

letta/schemas/mcp.py

@@ -2,7 +2,14 @@ from typing import Any, Dict, Optional, Union
 
 from pydantic import Field
 
-from letta.functions.mcp_client.types import MCPServerType, SSEServerConfig, StdioServerConfig
+from letta.functions.mcp_client.types import (
+    MCP_AUTH_HEADER_AUTHORIZATION,
+    MCP_AUTH_TOKEN_BEARER_PREFIX,
+    MCPServerType,
+    SSEServerConfig,
+    StdioServerConfig,
+    StreamableHTTPServerConfig,
+)
 from letta.schemas.letta_base import LettaBase
 
 
@@ -17,6 +24,7 @@ class MCPServer(BaseMCPServer):
 
     # sse config
     server_url: Optional[str] = Field(None, description="The URL of the server (MCP SSE client will connect to this URL)")
+    token: Optional[str] = Field(None, description="The access token or API key for the MCP server (used for SSE authentication)")
 
     # stdio config
     stdio_config: Optional[StdioServerConfig] = Field(
@@ -30,22 +38,38 @@ class MCPServer(BaseMCPServer):
     last_updated_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
     metadata_: Optional[Dict[str, Any]] = Field(default_factory=dict, description="A dictionary of additional metadata for the tool.")
 
-    # TODO: add tokens?
-
-    def to_config(self) -> Union[SSEServerConfig, StdioServerConfig]:
+    def to_config(self) -> Union[SSEServerConfig, StdioServerConfig, StreamableHTTPServerConfig]:
         if self.server_type == MCPServerType.SSE:
             return SSEServerConfig(
                 server_name=self.server_name,
                 server_url=self.server_url,
+                auth_header=MCP_AUTH_HEADER_AUTHORIZATION if self.token else None,
+                auth_token=f"{MCP_AUTH_TOKEN_BEARER_PREFIX} {self.token}" if self.token else None,
+                custom_headers=None,
             )
         elif self.server_type == MCPServerType.STDIO:
+            if self.stdio_config is None:
+                raise ValueError("stdio_config is required for STDIO server type")
             return self.stdio_config
+        elif self.server_type == MCPServerType.STREAMABLE_HTTP:
+            if self.server_url is None:
+                raise ValueError("server_url is required for STREAMABLE_HTTP server type")
+            return StreamableHTTPServerConfig(
+                server_name=self.server_name,
+                server_url=self.server_url,
+                auth_header=MCP_AUTH_HEADER_AUTHORIZATION if self.token else None,
+                auth_token=f"{MCP_AUTH_TOKEN_BEARER_PREFIX} {self.token}" if self.token else None,
+                custom_headers=None,
+            )
+        else:
+            raise ValueError(f"Unsupported server type: {self.server_type}")
 
 
 class RegisterSSEMCPServer(LettaBase):
     server_name: str = Field(..., description="The name of the server")
     server_type: MCPServerType = MCPServerType.SSE
     server_url: str = Field(..., description="The URL of the server (MCP SSE client will connect to this URL)")
+    token: Optional[str] = Field(None, description="The access token or API key for the MCP server used for authentication")
 
 
 class RegisterStdioMCPServer(LettaBase):
@@ -54,11 +78,20 @@ class RegisterStdioMCPServer(LettaBase):
     stdio_config: StdioServerConfig = Field(..., description="The configuration for the server (MCP 'local' client will run this command)")
 
 
+class RegisterStreamableHTTPMCPServer(LettaBase):
+    server_name: str = Field(..., description="The name of the server")
+    server_type: MCPServerType = MCPServerType.STREAMABLE_HTTP
+    server_url: str = Field(..., description="The URL path for the streamable HTTP server (e.g., 'example/mcp')")
+    auth_header: Optional[str] = Field(None, description="The name of the authentication header (e.g., 'Authorization')")
+    auth_token: Optional[str] = Field(None, description="The authentication token or API key value")
+
+
 class UpdateSSEMCPServer(LettaBase):
     """Update an SSE MCP server"""
 
     server_name: Optional[str] = Field(None, description="The name of the server")
     server_url: Optional[str] = Field(None, description="The URL of the server (MCP SSE client will connect to this URL)")
+    token: Optional[str] = Field(None, description="The access token or API key for the MCP server (used for SSE authentication)")
 
 
 class UpdateStdioMCPServer(LettaBase):
@@ -70,5 +103,14 @@ class UpdateStdioMCPServer(LettaBase):
     )
 
 
-UpdateMCPServer = Union[UpdateSSEMCPServer, UpdateStdioMCPServer]
-RegisterMCPServer = Union[RegisterSSEMCPServer, RegisterStdioMCPServer]
+class UpdateStreamableHTTPMCPServer(LettaBase):
+    """Update a Streamable HTTP MCP server"""
+
+    server_name: Optional[str] = Field(None, description="The name of the server")
+    server_url: Optional[str] = Field(None, description="The URL path for the streamable HTTP server (e.g., 'example/mcp')")
+    auth_header: Optional[str] = Field(None, description="The name of the authentication header (e.g., 'Authorization')")
+    auth_token: Optional[str] = Field(None, description="The authentication token or API key value")
+
+
+UpdateMCPServer = Union[UpdateSSEMCPServer, UpdateStdioMCPServer, UpdateStreamableHTTPMCPServer]
+RegisterMCPServer = Union[RegisterSSEMCPServer, RegisterStdioMCPServer, RegisterStreamableHTTPMCPServer]

letta/schemas/openai/chat_completion_request.py

@@ -123,7 +123,7 @@ class ChatCompletionRequest(BaseModel):
     logit_bias: Optional[Dict[str, int]] = None
     logprobs: Optional[bool] = False
     top_logprobs: Optional[int] = None
-    max_tokens: Optional[int] = None
+    max_completion_tokens: Optional[int] = None
     n: Optional[int] = 1
     presence_penalty: Optional[float] = 0
     response_format: Optional[ResponseFormat] = None

letta/schemas/openai/chat_completion_response.py

@@ -62,7 +62,7 @@ class Message(BaseModel):
     reasoning_content: Optional[str] = None  # Used in newer reasoning APIs, e.g. DeepSeek
     reasoning_content_signature: Optional[str] = None  # NOTE: for Anthropic
     redacted_reasoning_content: Optional[str] = None  # NOTE: for Anthropic
-    ommitted_reasoning_content: bool = False  # NOTE: for OpenAI o1/o3
+    omitted_reasoning_content: bool = False  # NOTE: for OpenAI o1/o3
 
 
 class Choice(BaseModel):

letta/schemas/pip_requirement.py

@@ -0,0 +1,14 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class PipRequirement(BaseModel):
+    name: str = Field(..., min_length=1, description="Name of the pip package.")
+    version: Optional[str] = Field(None, description="Optional version of the package, following semantic versioning.")
+
+    def __str__(self) -> str:
+        """Return a pip-installable string format."""
+        if self.version:
+            return f"{self.name}=={self.version}"
+        return self.name

letta/schemas/sandbox_config.py

@@ -1,6 +1,5 @@
 import hashlib
 import json
-import re
 from enum import Enum
 from typing import Any, Dict, List, Literal, Optional, Union
 
@@ -9,6 +8,7 @@ from pydantic import BaseModel, Field, model_validator
 from letta.constants import LETTA_TOOL_EXECUTION_DIR
 from letta.schemas.agent import AgentState
 from letta.schemas.letta_base import LettaBase, OrmMetadataBase
+from letta.schemas.pip_requirement import PipRequirement
 from letta.settings import tool_settings
 
 
@@ -27,24 +27,6 @@ class SandboxRunResult(BaseModel):
     sandbox_config_fingerprint: str = Field(None, description="The fingerprint of the config for the sandbox")
 
 
-class PipRequirement(BaseModel):
-    name: str = Field(..., min_length=1, description="Name of the pip package.")
-    version: Optional[str] = Field(None, description="Optional version of the package, following semantic versioning.")
-
-    @classmethod
-    def validate_version(cls, version: Optional[str]) -> Optional[str]:
-        if version is None:
-            return None
-        semver_pattern = re.compile(r"^\d+(\.\d+){0,2}(-[a-zA-Z0-9.]+)?$")
-        if not semver_pattern.match(version):
-            raise ValueError(f"Invalid version format: {version}. Must follow semantic versioning (e.g., 1.2.3, 2.0, 1.5.0-alpha).")
-        return version
-
-    def __init__(self, **data):
-        super().__init__(**data)
-        self.version = self.validate_version(self.version)
-
-
 class LocalSandboxConfig(BaseModel):
     sandbox_dir: Optional[str] = Field(None, description="Directory for the sandbox environment.")
     use_venv: bool = Field(False, description="Whether or not to use the venv, or run directly in the same run loop.")

letta/schemas/tool.py

@@ -24,6 +24,7 @@ from letta.functions.schema_generator import (
 from letta.log import get_logger
 from letta.orm.enums import ToolType
 from letta.schemas.letta_base import LettaBase
+from letta.schemas.pip_requirement import PipRequirement
 
 logger = get_logger(__name__)
 
@@ -60,6 +61,7 @@ class Tool(BaseTool):
 
     # tool configuration
     return_char_limit: int = Field(FUNCTION_RETURN_CHAR_LIMIT, description="The maximum number of characters in the response.")
+    pip_requirements: Optional[List[PipRequirement]] = Field(None, description="Optional list of pip packages required by this tool.")
 
     # metadata fields
     created_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
@@ -145,6 +147,7 @@ class ToolCreate(LettaBase):
     )
     args_json_schema: Optional[Dict] = Field(None, description="The args JSON schema of the function.")
     return_char_limit: int = Field(FUNCTION_RETURN_CHAR_LIMIT, description="The maximum number of characters in the response.")
+    pip_requirements: Optional[List[PipRequirement]] = Field(None, description="Optional list of pip packages required by this tool.")
 
     # TODO should we put the HTTP / API fetch inside from_mcp?
     # async def from_mcp(cls, mcp_server: str, mcp_tool_name: str) -> "ToolCreate":
@@ -253,6 +256,7 @@ class ToolUpdate(LettaBase):
     )
     args_json_schema: Optional[Dict] = Field(None, description="The args JSON schema of the function.")
     return_char_limit: Optional[int] = Field(None, description="The maximum number of characters in the response.")
+    pip_requirements: Optional[List[PipRequirement]] = Field(None, description="Optional list of pip packages required by this tool.")
 
     class Config:
         extra = "ignore"  # Allows extra fields without validation errors
@@ -269,3 +273,4 @@ class ToolRunFromSource(LettaBase):
     json_schema: Optional[Dict] = Field(
         None, description="The JSON schema of the function (auto-generated from source_code if not provided)"
     )
+    pip_requirements: Optional[List[PipRequirement]] = Field(None, description="Optional list of pip packages required by this tool.")

letta/server/rest_api/json_parser.py

@@ -32,9 +32,14 @@ class PydanticJSONParser(JSONParser):
             return {}
         try:
             return from_json(input_str, allow_partial="trailing-strings" if not self.strict else False)
-        except ValueError as e:
-            logger.error(f"Failed to parse JSON: {e}")
-            raise
+        except Exception as e:
+            logger.warning(f"PydanticJSONParser failed: {e} | input_str={input_str!r}, falling back to OptimisticJSONParser")
+            try:
+                fallback_parser = OptimisticJSONParser(strict=self.strict)
+                return fallback_parser.parse(input_str)
+            except Exception as fallback_e:
+                logger.error(f"Both parsers failed. Pydantic: {e}, Optimistic: {fallback_e} | input_str={input_str!r}")
+                raise fallback_e
 
 
 class OptimisticJSONParser(JSONParser):
@@ -219,3 +224,34 @@ class OptimisticJSONParser(JSONParser):
         if input_str.startswith("n"):
             return None, input_str[4:]
         raise decode_error
+
+
+# TODO: Keeping this around for posterity
+# def main():
+#     test_string = '{"inner_thoughts":}'
+#
+#     print(f"Testing string: {test_string!r}")
+#     print("=" * 50)
+#
+#     print("OptimisticJSONParser (strict=False):")
+#     try:
+#         optimistic_parser = OptimisticJSONParser(strict=False)
+#         result = optimistic_parser.parse(test_string)
+#         print(f"  Result: {result}")
+#         print(f"  Remaining: {optimistic_parser.last_parse_reminding!r}")
+#     except Exception as e:
+#         print(f"  Error: {e}")
+#
+#     print()
+#
+#     print("PydanticJSONParser (strict=False):")
+#     try:
+#         pydantic_parser = PydanticJSONParser(strict=False)
+#         result = pydantic_parser.parse(test_string)
+#         print(f"  Result: {result}")
+#     except Exception as e:
+#         print(f"  Error: {e}")
+#
+#
+# if __name__ == "__main__":
+#     main()

letta/server/rest_api/routers/v1/tools.py

@@ -504,7 +504,9 @@ async def add_mcp_server_to_config(
             if tool_settings.mcp_disable_stdio:  # protected server
                 raise HTTPException(status_code=400, detail="StdioServerConfig is not supported")
         elif isinstance(request, SSEServerConfig):
-            mapped_request = MCPServer(server_name=request.server_name, server_type=request.type, server_url=request.server_url)
+            mapped_request = MCPServer(
+                server_name=request.server_name, server_type=request.type, server_url=request.server_url, token=request.resolve_token()
+            )
         # TODO: add HTTP streaming
         mcp_server = await server.mcp_manager.create_or_update_mcp_server(mapped_request, actor=actor)
 

letta/server/rest_api/routers/v1/voice.py

@@ -1,9 +1,8 @@
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Any, Dict, Optional
 
 import openai
 from fastapi import APIRouter, Body, Depends, Header
 from fastapi.responses import StreamingResponse
-from openai.types.chat.completion_create_params import CompletionCreateParams
 
 from letta.agents.voice_agent import VoiceAgent
 from letta.log import get_logger
@@ -32,7 +31,7 @@ logger = get_logger(__name__)
 )
 async def create_voice_chat_completions(
     agent_id: str,
-    completion_request: CompletionCreateParams = Body(...),
+    completion_request: Dict[str, Any] = Body(...),  # The validation is soft in case providers like VAPI send extra params
     server: "SyncServer" = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),
 ):

letta/server/rest_api/utils.py

@@ -88,7 +88,7 @@ async def sse_async_generator(
                 metric_attributes = get_ctx_attributes()
                 if llm_config:
                     metric_attributes["model.name"] = llm_config.model
-                    MetricRegistry().ttft_ms_histogram.record(ns_to_ms(ttft_ns), metric_attributes)
+                MetricRegistry().ttft_ms_histogram.record(ns_to_ms(ttft_ns), metric_attributes)
                 first_chunk = False
 
             # yield f"data: {json.dumps(chunk)}\n\n"

letta/server/server.py

@@ -48,6 +48,7 @@ from letta.schemas.job import Job, JobUpdate
 from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage, MessageType, ToolReturnMessage
 from letta.schemas.letta_message_content import TextContent
 from letta.schemas.letta_response import LettaResponse
+from letta.schemas.letta_stop_reason import LettaStopReason, StopReasonType
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import ArchivalMemorySummary, Memory, RecallMemorySummary
 from letta.schemas.message import Message, MessageCreate, MessageUpdate
@@ -2359,7 +2360,11 @@ class SyncServer(Server):
                 # If we want to convert these to Message, we can use the attached IDs
                 # NOTE: we will need to de-duplicate the Messsage IDs though (since Assistant->Inner+Func_Call)
                 # TODO: eventually update the interface to use `Message` and `MessageChunk` (new) inside the deque instead
-                return LettaResponse(messages=filtered_stream, usage=usage)
+                return LettaResponse(
+                    messages=filtered_stream,
+                    stop_reason=LettaStopReason(stop_reason=StopReasonType.end_turn.value),
+                    usage=usage,
+                )
 
         except HTTPException:
             raise
@@ -2461,4 +2466,8 @@ class SyncServer(Server):
             # If we want to convert these to Message, we can use the attached IDs
             # NOTE: we will need to de-duplicate the Messsage IDs though (since Assistant->Inner+Func_Call)
             # TODO: eventually update the interface to use `Message` and `MessageChunk` (new) inside the deque instead
-            return LettaResponse(messages=filtered_stream, usage=usage)
+            return LettaResponse(
+                messages=filtered_stream,
+                stop_reason=LettaStopReason(stop_reason=StopReasonType.end_turn.value),
+                usage=usage,
+            )

letta/services/agent_manager.py

@@ -15,7 +15,6 @@ from letta.constants import (
     BASE_TOOLS,
     BASE_VOICE_SLEEPTIME_CHAT_TOOLS,
     BASE_VOICE_SLEEPTIME_TOOLS,
-    DATA_SOURCE_ATTACH_ALERT,
     FILES_TOOLS,
     MULTI_AGENT_TOOLS,
 )
@@ -1419,7 +1418,7 @@ class AgentManager:
             system_prompt=agent_state.system,
             in_context_memory=agent_state.memory,
             in_context_memory_last_edit=memory_edit_timestamp,
-            previous_message_count=num_messages,
+            previous_message_count=num_messages - len(agent_state.message_ids),
             archival_memory_size=num_archival_memories,
         )
 
@@ -1493,7 +1492,7 @@ class AgentManager:
             system_prompt=agent_state.system,
             in_context_memory=agent_state.memory,
             in_context_memory_last_edit=memory_edit_timestamp,
-            previous_message_count=num_messages,
+            previous_message_count=num_messages - len(agent_state.message_ids),
             archival_memory_size=num_archival_memories,
             tool_rules_solver=tool_rules_solver,
         )
@@ -1575,10 +1574,11 @@ class AgentManager:
         self, agent_id: str, actor: PydanticUser, add_default_initial_messages: bool = False
     ) -> PydanticAgentState:
         """
-        Removes all in-context messages for the specified agent by:
-          1) Clearing the agent.messages relationship (which cascades delete-orphans).
-          2) Resetting the message_ids list to empty.
-          3) Committing the transaction.
+        Removes all in-context messages for the specified agent except the original system message by:
+          1) Preserving the first message ID (original system message).
+          2) Deleting all other messages for the agent.
+          3) Updating the agent's message_ids to only contain the system message.
+          4) Optionally adding default initial messages after the system message.
 
         This action is destructive and cannot be undone once committed.
 
@@ -1588,35 +1588,49 @@ class AgentManager:
             actor (PydanticUser): The user performing this action.
 
         Returns:
-            PydanticAgentState: The updated agent state with no linked messages.
+            PydanticAgentState: The updated agent state with only the original system message preserved.
         """
         async with db_registry.async_session() as session:
             # Retrieve the existing agent (will raise NoResultFound if invalid)
             agent = await AgentModel.read_async(db_session=session, identifier=agent_id, actor=actor)
 
-            # Also clear out the message_ids field to keep in-context memory consistent
-            agent.message_ids = []
+            # Ensure agent has message_ids with at least one message
+            if not agent.message_ids or len(agent.message_ids) == 0:
+                logger.error(
+                    f"Agent {agent_id} has no message_ids. Agent details: "
+                    f"name={agent.name}, created_at={agent.created_at}, "
+                    f"message_ids={agent.message_ids}, organization_id={agent.organization_id}"
+                )
+                raise ValueError(f"Agent {agent_id} has no message_ids - cannot preserve system message")
 
-            # Commit the update
-            await agent.update_async(db_session=session, actor=actor)
+            # Get the system message ID (first message)
+            system_message_id = agent.message_ids[0]
 
-            agent_state = await agent.to_pydantic_async()
+            # Delete all messages for the agent except the system message
+            await self.message_manager.delete_all_messages_for_agent_async(agent_id=agent_id, actor=actor, exclude_ids=[system_message_id])
 
-        await self.message_manager.delete_all_messages_for_agent_async(agent_id=agent_id, actor=actor)
+            # Update agent to only keep the system message
+            agent.message_ids = [system_message_id]
+            await agent.update_async(db_session=session, actor=actor)
+            agent_state = await agent.to_pydantic_async()
 
+        # Optionally add default initial messages after the system message
         if add_default_initial_messages:
-            return await self.append_initial_message_sequence_to_in_context_messages_async(actor, agent_state)
-        else:
-            # We still want to always have a system message
             init_messages = initialize_message_sequence(
                 agent_state=agent_state, memory_edit_timestamp=get_utc_time(), include_initial_boot_message=True
             )
-            system_message = PydanticMessage.dict_to_message(
-                agent_id=agent_state.id,
-                model=agent_state.llm_config.model,
-                openai_message_dict=init_messages[0],
-            )
-            return await self.append_to_in_context_messages_async([system_message], agent_id=agent_state.id, actor=actor)
+            # Skip index 0 (system message) since we preserved the original
+            non_system_messages = [
+                PydanticMessage.dict_to_message(
+                    agent_id=agent_state.id,
+                    model=agent_state.llm_config.model,
+                    openai_message_dict=msg,
+                )
+                for msg in init_messages[1:]
+            ]
+            return await self.append_to_in_context_messages_async(non_system_messages, agent_id=agent_state.id, actor=actor)
+        else:
+            return agent_state
 
     @trace_method
     @enforce_types
@@ -1717,13 +1731,7 @@ class AgentManager:
             await agent.update_async(session, actor=actor)
 
         # Force rebuild of system prompt so that the agent is updated with passage count
-        # and recent passages and add system message alert to agent
         pydantic_agent = await self.rebuild_system_prompt_async(agent_id=agent_id, actor=actor, force=True)
-        await self.append_system_message_async(
-            agent_id=agent_id,
-            content=DATA_SOURCE_ATTACH_ALERT,
-            actor=actor,
-        )
 
         return pydantic_agent
 

letta/services/helpers/tool_execution_helper.py

@@ -2,7 +2,7 @@ import os
 import platform
 import subprocess
 import venv
-from typing import Dict, Optional
+from typing import TYPE_CHECKING, Dict, Optional
 
 from datamodel_code_generator import DataModelType, PythonVersion
 from datamodel_code_generator.model import get_data_model_types
@@ -11,6 +11,9 @@ from datamodel_code_generator.parser.jsonschema import JsonSchemaParser
 from letta.log import get_logger
 from letta.schemas.sandbox_config import LocalSandboxConfig
 
+if TYPE_CHECKING:
+    from letta.schemas.tool import Tool
+
 logger = get_logger(__name__)
 
 
@@ -85,14 +88,12 @@ def install_pip_requirements_for_sandbox(
     upgrade: bool = True,
     user_install_if_no_venv: bool = False,
     env: Optional[Dict[str, str]] = None,
+    tool: Optional["Tool"] = None,
 ):
     """
     Installs the specified pip requirements inside the correct environment (venv or system).
+    Installs both sandbox-level and tool-specific pip requirements.
     """
-    if not local_configs.pip_requirements:
-        logger.debug("No pip requirements specified; skipping installation.")
-        return
-
     sandbox_dir = os.path.expanduser(local_configs.sandbox_dir)  # Expand tilde
     local_configs.sandbox_dir = sandbox_dir  # Update the object to store the absolute path
 
@@ -102,19 +103,48 @@ def install_pip_requirements_for_sandbox(
     if local_configs.use_venv:
         ensure_pip_is_up_to_date(python_exec, env=env)
 
-    # Construct package list
-    packages = [f"{req.name}=={req.version}" if req.version else req.name for req in local_configs.pip_requirements]
+    # Collect all pip requirements
+    all_packages = []
+
+    # Add sandbox-level pip requirements
+    if local_configs.pip_requirements:
+        packages = [f"{req.name}=={req.version}" if req.version else req.name for req in local_configs.pip_requirements]
+        all_packages.extend(packages)
+        logger.debug(f"Added sandbox pip requirements: {packages}")
+
+    # Add tool-specific pip requirements
+    if tool and tool.pip_requirements:
+        tool_packages = [str(req) for req in tool.pip_requirements]
+        all_packages.extend(tool_packages)
+        logger.debug(f"Added tool pip requirements for {tool.name}: {tool_packages}")
+
+    if not all_packages:
+        logger.debug("No pip requirements specified; skipping installation.")
+        return
 
     # Construct pip install command
     pip_cmd = [python_exec, "-m", "pip", "install"]
     if upgrade:
         pip_cmd.append("--upgrade")
-    pip_cmd += packages
+    pip_cmd += all_packages
 
     if user_install_if_no_venv and not local_configs.use_venv:
         pip_cmd.append("--user")
 
-    run_subprocess(pip_cmd, env=env, fail_msg=f"Failed to install packages: {', '.join(packages)}")
+    # Enhanced error message for better debugging
+    sandbox_packages = [f"{req.name}=={req.version}" if req.version else req.name for req in (local_configs.pip_requirements or [])]
+    tool_packages = [str(req) for req in (tool.pip_requirements if tool and tool.pip_requirements else [])]
+
+    error_details = []
+    if sandbox_packages:
+        error_details.append(f"sandbox requirements: {', '.join(sandbox_packages)}")
+    if tool_packages:
+        error_details.append(f"tool requirements: {', '.join(tool_packages)}")
+
+    context = f" ({'; '.join(error_details)})" if error_details else ""
+    fail_msg = f"Failed to install pip packages{context}. This may be due to package version incompatibility. Consider updating package versions or removing version constraints."
+
+    run_subprocess(pip_cmd, env=env, fail_msg=fail_msg)
 
 
 def create_venv_for_local_sandbox(sandbox_dir_path: str, venv_path: str, env: Dict[str, str], force_recreate: bool):