letta-nightly 0.8.15.dev20250719104256__py3-none-any.whl → 0.8.16.dev20250721070720__py3-none-any.whl

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

@@ -20,11 +20,12 @@ from letta.helpers.composio_helpers import get_composio_api_key
 from letta.log import get_logger
 from letta.orm.errors import UniqueConstraintViolationError
 from letta.schemas.letta_message import ToolReturnMessage
-from letta.schemas.mcp import UpdateSSEMCPServer, UpdateStreamableHTTPMCPServer
+from letta.schemas.mcp import UpdateSSEMCPServer, UpdateStdioMCPServer, UpdateStreamableHTTPMCPServer
 from letta.schemas.tool import Tool, ToolCreate, ToolRunFromSource, ToolUpdate
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
 from letta.services.mcp.sse_client import AsyncSSEMCPClient
+from letta.services.mcp.stdio_client import AsyncStdioMCPClient
 from letta.services.mcp.streamable_http_client import AsyncStreamableHTTPMCPClient
 from letta.settings import tool_settings
 
@@ -136,7 +137,7 @@ async def create_tool(
     except UniqueConstraintViolationError as e:
         # Log or print the full exception here for debugging
         print(f"Error occurred: {e}")
-        clean_error_message = f"Tool with this name already exists."
+        clean_error_message = "Tool with this name already exists."
         raise HTTPException(status_code=409, detail=clean_error_message)
     except LettaToolCreateError as e:
         # HTTP 400 == Bad Request
@@ -234,6 +235,7 @@ async def run_tool_from_source(
             tool_name=request.name,
             tool_args_json_schema=request.args_json_schema,
             tool_json_schema=request.json_schema,
+            pip_requirements=request.pip_requirements,
             actor=actor,
         )
     except LettaToolCreateError as e:
@@ -262,7 +264,7 @@ def list_composio_apps(server: SyncServer = Depends(get_letta_server), user_id:
     if not composio_api_key:
         raise HTTPException(
             status_code=400,  # Bad Request
-            detail=f"No API keys found for Composio. Please add your Composio API Key as an environment variable for your sandbox configuration, or set it as environment variable COMPOSIO_API_KEY.",
+            detail="No API keys found for Composio. Please add your Composio API Key as an environment variable for your sandbox configuration, or set it as environment variable COMPOSIO_API_KEY.",
         )
     return server.get_composio_apps(api_key=composio_api_key)
 
@@ -281,7 +283,7 @@ def list_composio_actions_by_app(
     if not composio_api_key:
         raise HTTPException(
             status_code=400,  # Bad Request
-            detail=f"No API keys found for Composio. Please add your Composio API Key as an environment variable for your sandbox configuration, or set it as environment variable COMPOSIO_API_KEY.",
+            detail="No API keys found for Composio. Please add your Composio API Key as an environment variable for your sandbox configuration, or set it as environment variable COMPOSIO_API_KEY.",
         )
     return server.get_composio_actions_from_app_name(composio_app_name=composio_app_name, api_key=composio_api_key)
 
@@ -444,7 +446,6 @@ async def add_mcp_tool(
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
 
     if tool_settings.mcp_read_from_config:
-
         try:
             available_tools = await server.get_tools_from_mcp_server(mcp_server_name=mcp_server_name)
         except ValueError as e:
@@ -565,7 +566,7 @@ async def add_mcp_server_to_config(
 )
 async def update_mcp_server(
     mcp_server_name: str,
-    request: Union[UpdateSSEMCPServer, UpdateStreamableHTTPMCPServer] = Body(...),
+    request: Union[UpdateStdioMCPServer, UpdateSSEMCPServer, UpdateStreamableHTTPMCPServer] = Body(...),
     server: SyncServer = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
@@ -627,12 +628,6 @@ async def test_mcp_server(
     """
     client = None
     try:
-        if isinstance(request, StdioServerConfig):
-            raise HTTPException(
-                status_code=400,
-                detail="stdio is not supported currently for testing connection",
-            )
-
         # create a temporary MCP client based on the server type
         if request.type == MCPServerType.SSE:
             if not isinstance(request, SSEServerConfig):
@@ -642,6 +637,10 @@ async def test_mcp_server(
             if not isinstance(request, StreamableHTTPServerConfig):
                 request = StreamableHTTPServerConfig(**request.model_dump())
             client = AsyncStreamableHTTPMCPClient(request)
+        elif request.type == MCPServerType.STDIO:
+            if not isinstance(request, StdioServerConfig):
+                request = StdioServerConfig(**request.model_dump())
+            client = AsyncStdioMCPClient(request)
         else:
             raise ValueError(f"Invalid MCP server type: {request.type}")
 

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

@@ -65,7 +65,7 @@ async def delete_user(
     try:
         user = await server.user_manager.get_actor_by_id_async(actor_id=user_id)
         if user is None:
-            raise HTTPException(status_code=404, detail=f"User does not exist")
+            raise HTTPException(status_code=404, detail="User does not exist")
         await server.user_manager.delete_actor_by_id_async(user_id=user_id)
     except HTTPException:
         raise

letta/server/rest_api/streaming_response.py

@@ -12,6 +12,7 @@ from starlette.types import Send
 from letta.log import get_logger
 from letta.schemas.enums import JobStatus
 from letta.schemas.user import User
+from letta.server.rest_api.utils import capture_sentry_exception
 from letta.services.job_manager import JobManager
 
 logger = get_logger(__name__)
@@ -92,6 +93,7 @@ class StreamingResponseWithStatusCode(StreamingResponse):
         more_body = True
         try:
             first_chunk = await self.body_iterator.__anext__()
+            logger.debug("stream_response first chunk:", first_chunk)
             if isinstance(first_chunk, tuple):
                 first_chunk_content, self.status_code = first_chunk
             else:
@@ -130,7 +132,7 @@ class StreamingResponseWithStatusCode(StreamingResponse):
                                 "more_body": more_body,
                             }
                         )
-                        return
+                        raise Exception(f"An exception occurred mid-stream with status code {status_code}", detail={"content": content})
                 else:
                     content = chunk
 
@@ -146,8 +148,8 @@ class StreamingResponseWithStatusCode(StreamingResponse):
                 )
 
         # This should be handled properly upstream?
-        except asyncio.CancelledError:
-            logger.info("Stream was cancelled by client or job cancellation")
+        except asyncio.CancelledError as exc:
+            logger.warning("Stream was cancelled by client or job cancellation")
             # Handle cancellation gracefully
             more_body = False
             cancellation_resp = {"error": {"message": "Stream cancelled"}}
@@ -160,6 +162,7 @@ class StreamingResponseWithStatusCode(StreamingResponse):
                         "headers": self.raw_headers,
                     }
                 )
+                raise
             await send(
                 {
                     "type": "http.response.body",
@@ -167,13 +170,15 @@ class StreamingResponseWithStatusCode(StreamingResponse):
                     "more_body": more_body,
                 }
             )
+            capture_sentry_exception(exc)
             return
 
-        except Exception:
-            logger.exception("unhandled_streaming_error")
+        except Exception as exc:
+            logger.exception("Unhandled Streaming Error")
             more_body = False
             error_resp = {"error": {"message": "Internal Server Error"}}
             error_event = f"event: error\ndata: {json.dumps(error_resp)}\n\n".encode(self.charset)
+            logger.debug("response_started:", self.response_started)
             if not self.response_started:
                 await send(
                     {
@@ -182,6 +187,7 @@ class StreamingResponseWithStatusCode(StreamingResponse):
                         "headers": self.raw_headers,
                     }
                 )
+                raise
             await send(
                 {
                     "type": "http.response.body",
@@ -189,5 +195,7 @@ class StreamingResponseWithStatusCode(StreamingResponse):
                     "more_body": more_body,
                 }
             )
+            capture_sentry_exception(exc)
+            return
         if more_body:
             await send({"type": "http.response.body", "body": b"", "more_body": False})

letta/server/rest_api/utils.py

@@ -2,7 +2,6 @@ import asyncio
 import json
 import os
 import uuid
-import warnings
 from enum import Enum
 from typing import TYPE_CHECKING, AsyncGenerator, Dict, Iterable, List, Optional, Union, cast
 
@@ -34,12 +33,15 @@ from letta.schemas.message import Message, MessageCreate, ToolReturn
 from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
-from letta.server.rest_api.interface import StreamingServerInterface
 from letta.system import get_heartbeat, package_function_response
 
 if TYPE_CHECKING:
     from letta.server.server import SyncServer
 
+SENTRY_ENABLED = bool(os.getenv("SENTRY_DSN"))
+
+if SENTRY_ENABLED:
+    import sentry_sdk
 
 SSE_PREFIX = "data: "
 SSE_SUFFIX = "\n\n"
@@ -130,7 +132,7 @@ async def sse_async_generator(
             except Exception as e:
                 log_error_to_sentry(e)
                 logger.error(f"Caught unexpected Exception: {e}")
-                yield sse_formatter({"error": f"Stream failed (internal error occurred)"})
+                yield sse_formatter({"error": "Stream failed (internal error occurred)"})
 
     except Exception as e:
         log_error_to_sentry(e)
@@ -157,21 +159,9 @@ def get_user_id(user_id: Optional[str] = Header(None, alias="user_id")) -> Optio
     return user_id
 
 
-def get_current_interface() -> StreamingServerInterface:
-    return StreamingServerInterface
-
-
-def log_error_to_sentry(e):
-    import traceback
-
-    traceback.print_exc()
-    warnings.warn(f"SSE stream generator failed: {e}")
-
-    # Log the error, since the exception handler upstack (in FastAPI) won't catch it, because this may be a 200 response
-    # Print the stack trace
-    if (os.getenv("SENTRY_DSN") is not None) and (os.getenv("SENTRY_DSN") != ""):
-        import sentry_sdk
-
+def capture_sentry_exception(e: BaseException):
+    """This will capture the exception in sentry, since the exception handler upstack (in FastAPI) won't catch it, because this may be a 200 response"""
+    if SENTRY_ENABLED:
         sentry_sdk.capture_exception(e)
 
 
@@ -184,8 +174,6 @@ def create_input_messages(input_messages: List[MessageCreate], agent_id: str, ti
     """
 
     messages = convert_message_creates_to_messages(input_messages, agent_id, timezone, wrap_user_message=False, wrap_system_message=False)
-    for message in messages:
-        message.organization_id = actor.organization_id
     return messages
 
 
@@ -224,7 +212,6 @@ def create_letta_messages_from_llm_response(
     assistant_message = Message(
         role=MessageRole.assistant,
         content=reasoning_content if reasoning_content else [],
-        organization_id=actor.organization_id,
         agent_id=agent_id,
         model=model,
         tool_calls=[tool_call],
@@ -241,7 +228,6 @@ def create_letta_messages_from_llm_response(
     tool_message = Message(
         role=MessageRole.tool,
         content=[TextContent(text=package_function_response(function_call_success, function_response, timezone))],
-        organization_id=actor.organization_id,
         agent_id=agent_id,
         model=model,
         tool_calls=[],
@@ -294,7 +280,6 @@ def create_heartbeat_system_message(
     heartbeat_system_message = Message(
         role=MessageRole.user,
         content=[TextContent(text=get_heartbeat(timezone, text_content))],
-        organization_id=actor.organization_id,
         agent_id=agent_id,
         model=model,
         tool_calls=[],
@@ -370,7 +355,6 @@ def convert_in_context_letta_messages_to_openai(in_context_messages: List[Messag
                     id=msg.id,
                     role=msg.role,
                     content=[TextContent(text=extracted_text)],
-                    organization_id=msg.organization_id,
                     agent_id=msg.agent_id,
                     model=msg.model,
                     name=msg.name,
@@ -399,7 +383,6 @@ def convert_in_context_letta_messages_to_openai(in_context_messages: List[Messag
                             id=msg.id,
                             role=msg.role,
                             content=[TextContent(text=actual_user_text)],
-                            organization_id=msg.organization_id,
                             agent_id=msg.agent_id,
                             model=msg.model,
                             name=msg.name,

letta/server/server.py

@@ -53,6 +53,7 @@ from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import ArchivalMemorySummary, Memory, RecallMemorySummary
 from letta.schemas.message import Message, MessageCreate, MessageUpdate
 from letta.schemas.passage import Passage, PassageUpdate
+from letta.schemas.pip_requirement import PipRequirement
 from letta.schemas.providers import (
     AnthropicProvider,
     AzureProvider,
@@ -104,7 +105,8 @@ from letta.services.telemetry_manager import TelemetryManager
 from letta.services.tool_executor.tool_execution_manager import ToolExecutionManager
 from letta.services.tool_manager import ToolManager
 from letta.services.user_manager import UserManager
-from letta.settings import model_settings, settings, tool_settings
+from letta.settings import DatabaseChoice, model_settings, settings, tool_settings
+from letta.streaming_interface import AgentChunkStreamingInterface
 from letta.utils import get_friendly_error_msg, get_persona_text, make_key
 
 config = LettaConfig.load()
@@ -176,7 +178,7 @@ class SyncServer(Server):
         self,
         chaining: bool = True,
         max_chaining_steps: Optional[int] = 100,
-        default_interface_factory: Callable[[], AgentInterface] = lambda: CLIInterface(),
+        default_interface_factory: Callable[[], AgentChunkStreamingInterface] = lambda: CLIInterface(),
         init_with_default_org_and_user: bool = True,
         # default_interface: AgentInterface = CLIInterface(),
         # default_persistence_manager_cls: PersistenceManager = LocalStateManager,
@@ -195,7 +197,7 @@ class SyncServer(Server):
 
         # Initialize the metadata store
         config = LettaConfig.load()
-        if settings.letta_pg_uri_no_default:
+        if settings.database_engine is DatabaseChoice.POSTGRES:
             config.recall_storage_type = "postgres"
             config.recall_storage_uri = settings.letta_pg_uri_no_default
             config.archival_storage_type = "postgres"
@@ -1244,6 +1246,7 @@ class SyncServer(Server):
         use_assistant_message: bool = True,
         assistant_message_tool_name: str = constants.DEFAULT_MESSAGE_TOOL,
         assistant_message_tool_kwarg: str = constants.DEFAULT_MESSAGE_TOOL_KWARG,
+        include_err: Optional[bool] = None,
     ) -> Union[List[Message], List[LettaMessage]]:
         records = await self.message_manager.list_messages_for_agent_async(
             agent_id=agent_id,
@@ -1253,6 +1256,7 @@ class SyncServer(Server):
             limit=limit,
             ascending=not reverse,
             group_id=group_id,
+            include_err=include_err,
         )
 
         if not return_message_object:
@@ -1262,6 +1266,7 @@ class SyncServer(Server):
                 assistant_message_tool_name=assistant_message_tool_name,
                 assistant_message_tool_kwarg=assistant_message_tool_kwarg,
                 reverse=reverse,
+                include_err=include_err,
             )
 
         if reverse:
@@ -2001,6 +2006,7 @@ class SyncServer(Server):
         tool_name: Optional[str] = None,
         tool_args_json_schema: Optional[Dict[str, Any]] = None,
         tool_json_schema: Optional[Dict[str, Any]] = None,
+        pip_requirements: Optional[List[PipRequirement]] = None,
     ) -> ToolReturnMessage:
         """Run a tool from source code"""
         if tool_source_type is not None and tool_source_type != "python":
@@ -2008,13 +2014,14 @@ class SyncServer(Server):
 
         # If tools_json_schema is explicitly passed in, override it on the created Tool object
         if tool_json_schema:
-            tool = Tool(name=tool_name, source_code=tool_source, json_schema=tool_json_schema)
+            tool = Tool(name=tool_name, source_code=tool_source, json_schema=tool_json_schema, pip_requirements=pip_requirements)
         else:
             # NOTE: we're creating a floating Tool object and NOT persisting to DB
             tool = Tool(
                 name=tool_name,
                 source_code=tool_source,
                 args_json_schema=tool_args_json_schema,
+                pip_requirements=pip_requirements,
             )
 
         assert tool.name is not None, "Failed to create tool object"

letta/server/ws_api/server.py

@@ -21,7 +21,7 @@ class WebSocketServer:
     def shutdown_server(self):
         try:
             self.interface.close()
-            print(f"Closed the WS interface")
+            print("Closed the WS interface")
         except Exception as e:
             print(f"Closing the WS interface failed with: {e}")
 
@@ -100,7 +100,7 @@ class WebSocketServer:
                     await websocket.send(protocol.server_error(f"unrecognized client package data type: {data}"))
 
         except websockets.exceptions.ConnectionClosed:
-            print(f"[server] connection with client was closed")
+            print("[server] connection with client was closed")
         finally:
             self.interface.unregister_client(websocket)