letta-nightly 0.8.2.dev20250606215616__py3-none-any.whl → 0.8.3.dev20250607000559__py3-none-any.whl

letta/__init__.py

@@ -1,6 +1,6 @@
 import os
 
-__version__ = "0.8.2"
+__version__ = "0.8.3"
 
 if os.environ.get("LETTA_VERSION"):
     __version__ = os.environ["LETTA_VERSION"]

letta/agent.py

@@ -70,7 +70,7 @@ from letta.services.step_manager import StepManager
 from letta.services.telemetry_manager import NoopTelemetryManager, TelemetryManager
 from letta.services.tool_executor.tool_execution_sandbox import ToolExecutionSandbox
 from letta.services.tool_manager import ToolManager
-from letta.settings import settings, summarizer_settings, model_settings
+from letta.settings import settings, summarizer_settings
 from letta.streaming_interface import StreamingRefreshCLIInterface
 from letta.system import get_heartbeat, get_token_limit_warning, package_function_response, package_summarize_message, package_user_message
 from letta.utils import count_tokens, get_friendly_error_msg, get_tool_call_id, log_telemetry, parse_json, validate_function_response
@@ -503,7 +503,7 @@ class Agent(BaseAgent):
                 response_message.function_call if response_message.function_call is not None else response_message.tool_calls[0].function
             )
             function_name = function_call.name
-            self.logger.debug(f"Request to call function {function_name} with tool_call_id: {tool_call_id}")
+            self.logger.info(f"Request to call function {function_name} with tool_call_id: {tool_call_id}")
 
             # Failure case 1: function name is wrong (not in agent_state.tools)
             target_letta_tool = None
@@ -1282,7 +1282,7 @@ class Agent(BaseAgent):
         )
 
     async def get_context_window_async(self) -> ContextWindowOverview:
-        if os.getenv("LETTA_ENVIRONMENT") == "PRODUCTION" and model_settings.anthropic_api_key is not None:
+        if os.getenv("LETTA_ENVIRONMENT") == "PRODUCTION":
             return await self.get_context_window_from_anthropic_async()
         return await self.get_context_window_from_tiktoken_async()
 
@@ -1291,8 +1291,8 @@ class Agent(BaseAgent):
         # Grab the in-context messages
         # conversion of messages to OpenAI dict format, which is passed to the token counter
         (in_context_messages, passage_manager_size, message_manager_size) = await asyncio.gather(
-            self.agent_manager.get_in_context_messages_async(agent_id=self.agent_state.id, actor=self.user),
-            self.passage_manager.size_async(actor=self.user, agent_id=self.agent_state.id),
+            self.message_manager.get_messages_by_ids_async(message_ids=self.agent_state.message_ids, actor=self.user),
+            self.passage_manager.agent_passage_size_async(actor=self.user, agent_id=self.agent_state.id),
             self.message_manager.size_async(actor=self.user, agent_id=self.agent_state.id),
         )
         in_context_messages_openai = [m.to_openai_dict() for m in in_context_messages]
@@ -1315,11 +1315,13 @@ class Agent(BaseAgent):
                 core_memory = system_message[core_memory_marker_pos:].strip()
             else:
                 # if no markers found, put everything in system message
+                self.logger.info("No markers found in system message, core_memory and external_memory_summary will not be loaded")
                 system_prompt = system_message
                 external_memory_summary = ""
                 core_memory = ""
         else:
             # if no system message, fall back on agent's system prompt
+            self.logger.info("No system message found in history, core_memory and external_memory_summary will not be loaded")
             system_prompt = self.agent_state.system
             external_memory_summary = ""
             core_memory = ""
@@ -1411,8 +1413,8 @@ class Agent(BaseAgent):
         # Grab the in-context messages
         # conversion of messages to anthropic dict format, which is passed to the token counter
         (in_context_messages, passage_manager_size, message_manager_size) = await asyncio.gather(
-            self.agent_manager.get_in_context_messages_async(agent_id=self.agent_state.id, actor=self.user),
-            self.passage_manager.size_async(actor=self.user, agent_id=self.agent_state.id),
+            self.message_manager.get_messages_by_ids_async(message_ids=self.agent_state.message_ids, actor=self.user),
+            self.passage_manager.agent_passage_size_async(actor=self.user, agent_id=self.agent_state.id),
             self.message_manager.size_async(actor=self.user, agent_id=self.agent_state.id),
         )
         in_context_messages_anthropic = [m.to_anthropic_dict() for m in in_context_messages]
@@ -1435,14 +1437,16 @@ class Agent(BaseAgent):
                 core_memory = system_message[core_memory_marker_pos:].strip()
             else:
                 # if no markers found, put everything in system message
+                self.logger.info("No markers found in system message, core_memory and external_memory_summary will not be loaded")
                 system_prompt = system_message
-                external_memory_summary = None
-                core_memory = None
+                external_memory_summary = ""
+                core_memory = ""
         else:
             # if no system message, fall back on agent's system prompt
+            self.logger.info("No system message found in history, core_memory and external_memory_summary will not be loaded")
             system_prompt = self.agent_state.system
-            external_memory_summary = None
-            core_memory = None
+            external_memory_summary = ""
+            core_memory = ""
 
         num_tokens_system_coroutine = anthropic_client.count_tokens(model=model, messages=[{"role": "user", "content": system_prompt}])
         num_tokens_core_memory_coroutine = (

letta/agents/base_agent.py

@@ -104,7 +104,7 @@ class BaseAgent(ABC):
             if num_messages is None:
                 num_messages = await self.message_manager.size_async(actor=self.actor, agent_id=agent_state.id)
             if num_archival_memories is None:
-                num_archival_memories = await self.passage_manager.size_async(actor=self.actor, agent_id=agent_state.id)
+                num_archival_memories = await self.passage_manager.agent_passage_size_async(actor=self.actor, agent_id=agent_state.id)
 
             new_system_message_str = compile_system_message(
                 system_prompt=agent_state.system,

letta/agents/helpers.py

@@ -1,8 +1,9 @@
 import uuid
 import xml.etree.ElementTree as ET
-from typing import List, Tuple
+from typing import List, Optional, Tuple
 
 from letta.schemas.agent import AgentState
+from letta.schemas.letta_message import MessageType
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.message import Message, MessageCreate
 from letta.schemas.usage import LettaUsageStatistics
@@ -12,16 +13,26 @@ from letta.services.message_manager import MessageManager
 
 
 def _create_letta_response(
-    new_in_context_messages: list[Message], use_assistant_message: bool, usage: LettaUsageStatistics
+    new_in_context_messages: list[Message],
+    use_assistant_message: bool,
+    usage: LettaUsageStatistics,
+    include_return_message_types: Optional[List[MessageType]] = None,
 ) -> LettaResponse:
     """
     Converts the newly created/persisted messages into a LettaResponse.
     """
     # NOTE: hacky solution to avoid returning heartbeat messages and the original user message
     filter_user_messages = [m for m in new_in_context_messages if m.role != "user"]
+
+    # Convert to Letta messages first
     response_messages = Message.to_letta_messages_from_list(
         messages=filter_user_messages, use_assistant_message=use_assistant_message, reverse=False
     )
+
+    # Apply message type filtering if specified
+    if include_return_message_types is not None:
+        response_messages = [msg for msg in response_messages if msg.message_type in include_return_message_types]
+
     return LettaResponse(messages=response_messages, usage=usage)
 
 

letta/agents/letta_agent.py

@@ -30,6 +30,7 @@ from letta.otel.metric_registry import MetricRegistry
 from letta.otel.tracing import log_event, trace_method, tracer
 from letta.schemas.agent import AgentState
 from letta.schemas.enums import MessageRole, MessageStreamStatus
+from letta.schemas.letta_message import MessageType
 from letta.schemas.letta_message_content import OmittedReasoningContent, ReasoningContent, RedactedReasoningContent, TextContent
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.llm_config import LLMConfig
@@ -121,6 +122,7 @@ class LettaAgent(BaseAgent):
         max_steps: int = 10,
         use_assistant_message: bool = True,
         request_start_timestamp_ns: Optional[int] = None,
+        include_return_message_types: Optional[List[MessageType]] = None,
     ) -> LettaResponse:
         agent_state = await self.agent_manager.get_agent_by_id_async(
             agent_id=self.agent_id, include_relationships=["tools", "memory", "tool_exec_environment_variables"], actor=self.actor
@@ -132,7 +134,10 @@ class LettaAgent(BaseAgent):
             request_start_timestamp_ns=request_start_timestamp_ns,
         )
         return _create_letta_response(
-            new_in_context_messages=new_in_context_messages, use_assistant_message=use_assistant_message, usage=usage
+            new_in_context_messages=new_in_context_messages,
+            use_assistant_message=use_assistant_message,
+            usage=usage,
+            include_return_message_types=include_return_message_types,
         )
 
     @trace_method
@@ -142,6 +147,7 @@ class LettaAgent(BaseAgent):
         max_steps: int = 10,
         use_assistant_message: bool = True,
         request_start_timestamp_ns: Optional[int] = None,
+        include_return_message_types: Optional[List[MessageType]] = None,
     ):
         agent_state = await self.agent_manager.get_agent_by_id_async(
             agent_id=self.agent_id, include_relationships=["tools", "memory", "tool_exec_environment_variables"], actor=self.actor
@@ -250,8 +256,12 @@ class LettaAgent(BaseAgent):
             letta_messages = Message.to_letta_messages_from_list(
                 filter_user_messages, use_assistant_message=use_assistant_message, reverse=False
             )
+
             for message in letta_messages:
-                yield f"data: {message.model_dump_json()}\n\n"
+                if not include_return_message_types:
+                    yield f"data: {message.model_dump_json()}\n\n"
+                elif include_return_message_types and message.message_type in include_return_message_types:
+                    yield f"data: {message.model_dump_json()}\n\n"
 
             if not should_continue:
                 break
@@ -409,6 +419,7 @@ class LettaAgent(BaseAgent):
         max_steps: int = 10,
         use_assistant_message: bool = True,
         request_start_timestamp_ns: Optional[int] = None,
+        include_return_message_types: Optional[List[MessageType]] = None,
     ) -> AsyncGenerator[str, None]:
         """
         Carries out an invocation of the agent loop in a streaming fashion that yields partial tokens.
@@ -486,7 +497,12 @@ class LettaAgent(BaseAgent):
                     request_span.add_event(name="time_to_first_token_ms", attributes={"ttft_ms": ns_to_ms(ttft_ns)})
                     first_chunk = False
 
-                yield f"data: {chunk.model_dump_json()}\n\n"
+                if include_return_message_types is None:
+                    # return all data
+                    yield f"data: {chunk.model_dump_json()}\n\n"
+                elif include_return_message_types and chunk.message_type in include_return_message_types:
+                    # filter down returned data
+                    yield f"data: {chunk.model_dump_json()}\n\n"
 
             # update usage
             usage.step_count += 1
@@ -563,7 +579,9 @@ class LettaAgent(BaseAgent):
 
             tool_return = [msg for msg in persisted_messages if msg.role == "tool"][-1].to_letta_messages()[0]
             if not (use_assistant_message and tool_return.name == "send_message"):
-                yield f"data: {tool_return.model_dump_json()}\n\n"
+                # Apply message type filtering if specified
+                if include_return_message_types is None or tool_return.message_type in include_return_message_types:
+                    yield f"data: {tool_return.model_dump_json()}\n\n"
 
             if not should_continue:
                 break
@@ -763,7 +781,7 @@ class LettaAgent(BaseAgent):
                 else asyncio.sleep(0, result=self.num_messages)
             ),
             (
-                self.passage_manager.size_async(actor=self.actor, agent_id=agent_state.id)
+                self.passage_manager.agent_passage_size_async(actor=self.actor, agent_id=agent_state.id)
                 if self.num_archival_memories is None
                 else asyncio.sleep(0, result=self.num_archival_memories)
             ),

letta/agents/voice_agent.py

@@ -305,7 +305,7 @@ class VoiceAgent(BaseAgent):
                 else asyncio.sleep(0, result=self.num_messages)
             ),
             (
-                self.passage_manager.size_async(actor=self.actor, agent_id=agent_state.id)
+                self.passage_manager.agent_passage_size_async(actor=self.actor, agent_id=agent_state.id)
                 if self.num_archival_memories is None
                 else asyncio.sleep(0, result=self.num_archival_memories)
             ),

letta/agents/voice_sleeptime_agent.py

@@ -7,7 +7,7 @@ from letta.otel.tracing import trace_method
 from letta.schemas.agent import AgentState
 from letta.schemas.block import BlockUpdate
 from letta.schemas.enums import MessageStreamStatus
-from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage
+from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage, MessageType
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.message import MessageCreate
 from letta.schemas.tool_rule import ChildToolRule, ContinueToolRule, InitToolRule, TerminalToolRule
@@ -59,7 +59,13 @@ class VoiceSleeptimeAgent(LettaAgent):
     def update_message_transcript(self, message_transcripts: List[str]):
         self.message_transcripts = message_transcripts
 
-    async def step(self, input_messages: List[MessageCreate], max_steps: int = 20, use_assistant_message: bool = True) -> LettaResponse:
+    async def step(
+        self,
+        input_messages: List[MessageCreate],
+        max_steps: int = 20,
+        use_assistant_message: bool = True,
+        include_return_message_types: Optional[List[MessageType]] = None,
+    ) -> LettaResponse:
         """
         Process the user's input message, allowing the model to call memory-related tools
         until it decides to stop and provide a final response.
@@ -86,7 +92,10 @@ class VoiceSleeptimeAgent(LettaAgent):
         )
 
         return _create_letta_response(
-            new_in_context_messages=new_in_context_messages, use_assistant_message=use_assistant_message, usage=usage
+            new_in_context_messages=new_in_context_messages,
+            use_assistant_message=use_assistant_message,
+            usage=usage,
+            include_return_message_types=include_return_message_types,
         )
 
     @trace_method

letta/groups/sleeptime_multi_agent_v2.py

@@ -9,6 +9,7 @@ from letta.otel.tracing import trace_method
 from letta.schemas.enums import JobStatus
 from letta.schemas.group import Group, ManagerType
 from letta.schemas.job import JobUpdate
+from letta.schemas.letta_message import MessageType
 from letta.schemas.letta_message_content import TextContent
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.message import Message, MessageCreate
@@ -63,6 +64,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
         max_steps: int = 10,
         use_assistant_message: bool = True,
         request_start_timestamp_ns: Optional[int] = None,
+        include_return_message_types: Optional[List[MessageType]] = None,
     ) -> LettaResponse:
         run_ids = []
 
@@ -87,7 +89,10 @@ class SleeptimeMultiAgentV2(BaseAgent):
         )
         # Perform foreground agent step
         response = await foreground_agent.step(
-            input_messages=new_messages, max_steps=max_steps, use_assistant_message=use_assistant_message
+            input_messages=new_messages,
+            max_steps=max_steps,
+            use_assistant_message=use_assistant_message,
+            include_return_message_types=include_return_message_types,
         )
 
         # Get last response messages
@@ -129,8 +134,11 @@ class SleeptimeMultiAgentV2(BaseAgent):
         max_steps: int = 10,
         use_assistant_message: bool = True,
         request_start_timestamp_ns: Optional[int] = None,
+        include_return_message_types: Optional[List[MessageType]] = None,
     ):
-        response = await self.step(input_messages, max_steps, use_assistant_message)
+        response = await self.step(
+            input_messages, max_steps, use_assistant_message, request_start_timestamp_ns, include_return_message_types
+        )
 
         for message in response.messages:
             yield f"data: {message.model_dump_json()}\n\n"
@@ -144,6 +152,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
         max_steps: int = 10,
         use_assistant_message: bool = True,
         request_start_timestamp_ns: Optional[int] = None,
+        include_return_message_types: Optional[List[MessageType]] = None,
     ) -> AsyncGenerator[str, None]:
         # Prepare new messages
         new_messages = []
@@ -170,6 +179,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
             max_steps=max_steps,
             use_assistant_message=use_assistant_message,
             request_start_timestamp_ns=request_start_timestamp_ns,
+            include_return_message_types=include_return_message_types,
         ):
             yield chunk
 

letta/llm_api/anthropic_client.py

@@ -427,10 +427,16 @@ class AnthropicClient(LLMClientBase):
                 if content_part.type == "text":
                     content = strip_xml_tags(string=content_part.text, tag="thinking")
                 if content_part.type == "tool_use":
-                    # hack for tool rules
+                    # hack for incorrect tool format
                     tool_input = json.loads(json.dumps(content_part.input))
                     if "id" in tool_input and tool_input["id"].startswith("toolu_") and "function" in tool_input:
-                        arguments = str(tool_input["function"]["arguments"])
+                        arguments = json.dumps(tool_input["function"]["arguments"], indent=2)
+                        try:
+                            args_json = json.loads(arguments)
+                            if not isinstance(args_json, dict):
+                                raise ValueError("Expected parseable json object for arguments")
+                        except:
+                            arguments = str(tool_input["function"]["arguments"])
                     else:
                         arguments = json.dumps(tool_input, indent=2)
                     tool_calls = [

letta/orm/passage.py

@@ -47,6 +47,8 @@ class SourcePassage(BasePassage, FileMixin, SourceMixin):
 
     __tablename__ = "source_passages"
 
+    file_name: Mapped[str] = mapped_column(doc="The name of the file that this passage was derived from")
+
     @declared_attr
     def file(cls) -> Mapped["FileMetadata"]:
         """Relationship to file"""

letta/schemas/letta_request.py

@@ -3,6 +3,7 @@ from typing import List, Optional
 from pydantic import BaseModel, Field, HttpUrl
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
+from letta.schemas.letta_message import MessageType
 from letta.schemas.message import MessageCreate
 
 
@@ -21,6 +22,11 @@ class LettaRequest(BaseModel):
         description="The name of the message argument in the designated message tool.",
     )
 
+    # filter to only return specific message types
+    include_return_message_types: Optional[List[MessageType]] = Field(
+        default=None, description="Only return specified message types in the response. If `None` (default) returns all messages."
+    )
+
 
 class LettaStreamingRequest(LettaRequest):
     stream_tokens: bool = Field(

letta/schemas/passage.py

@@ -23,6 +23,7 @@ class PassageBase(OrmMetadataBase):
 
     # file association
     file_id: Optional[str] = Field(None, description="The unique identifier of the file associated with the passage.")
+    file_name: Optional[str] = Field(None, description="The name of the file (only for source passages).")
     metadata: Optional[Dict] = Field({}, validation_alias="metadata_", description="The metadata of the passage.")
 
 

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

@@ -23,7 +23,7 @@ from letta.schemas.agent import AgentState, AgentType, CreateAgent, UpdateAgent
 from letta.schemas.block import Block, BlockUpdate
 from letta.schemas.group import Group
 from letta.schemas.job import JobStatus, JobUpdate, LettaRequestConfig
-from letta.schemas.letta_message import LettaMessageUnion, LettaMessageUpdateUnion
+from letta.schemas.letta_message import LettaMessageUnion, LettaMessageUpdateUnion, MessageType
 from letta.schemas.letta_request import LettaRequest, LettaStreamingRequest
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.memory import ContextWindowOverview, CreateArchivalMemory, Memory
@@ -704,6 +704,7 @@ async def send_message(
             max_steps=10,
             use_assistant_message=request.use_assistant_message,
             request_start_timestamp_ns=request_start_timestamp_ns,
+            include_return_message_types=request.include_return_message_types,
         )
     else:
         result = await server.send_message_to_agent(
@@ -716,6 +717,7 @@ async def send_message(
             use_assistant_message=request.use_assistant_message,
             assistant_message_tool_name=request.assistant_message_tool_name,
             assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
+            include_return_message_types=request.include_return_message_types,
         )
     return result
 
@@ -791,6 +793,7 @@ async def send_message_streaming(
                     max_steps=10,
                     use_assistant_message=request.use_assistant_message,
                     request_start_timestamp_ns=request_start_timestamp_ns,
+                    include_return_message_types=request.include_return_message_types,
                 ),
                 media_type="text/event-stream",
             )
@@ -801,6 +804,7 @@ async def send_message_streaming(
                     max_steps=10,
                     use_assistant_message=request.use_assistant_message,
                     request_start_timestamp_ns=request_start_timestamp_ns,
+                    include_return_message_types=request.include_return_message_types,
                 ),
                 media_type="text/event-stream",
             )
@@ -816,6 +820,7 @@ async def send_message_streaming(
             assistant_message_tool_name=request.assistant_message_tool_name,
             assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
             request_start_timestamp_ns=request_start_timestamp_ns,
+            include_return_message_types=request.include_return_message_types,
         )
 
     return result
@@ -830,6 +835,7 @@ async def process_message_background(
     use_assistant_message: bool,
     assistant_message_tool_name: str,
     assistant_message_tool_kwarg: str,
+    include_return_message_types: Optional[List[MessageType]] = None,
 ) -> None:
     """Background task to process the message and update job status."""
     try:
@@ -845,6 +851,7 @@ async def process_message_background(
             assistant_message_tool_kwarg=assistant_message_tool_kwarg,
             metadata={"job_id": job_id},  # Pass job_id through metadata
             request_start_timestamp_ns=request_start_timestamp_ns,
+            include_return_message_types=include_return_message_types,
         )
 
         # Update job status to completed
@@ -912,6 +919,7 @@ async def send_message_async(
         use_assistant_message=request.use_assistant_message,
         assistant_message_tool_name=request.assistant_message_tool_name,
         assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
+        include_return_message_types=request.include_return_message_types,
     )
 
     return run

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

@@ -501,7 +501,8 @@ async def add_mcp_server_to_config(
         if isinstance(request, StdioServerConfig):
             mapped_request = MCPServer(server_name=request.server_name, server_type=request.type, stdio_config=request)
             # don't allow stdio servers
-            raise HTTPException(status_code=400, detail="StdioServerConfig is not supported")
+            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)
         # TODO: add HTTP streaming
@@ -530,4 +531,8 @@ async def delete_mcp_server_from_config(
         # log to DB
         actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
         mcp_server_id = await server.mcp_manager.get_mcp_server_id_by_name(mcp_server_name, actor)
-        return server.mcp_manager.delete_mcp_server_by_id(mcp_server_id, actor=actor)
+        await server.mcp_manager.delete_mcp_server_by_id(mcp_server_id, actor=actor)
+
+        # TODO: don't do this in the future (just return MCPServer)
+        all_servers = await server.mcp_manager.list_mcp_servers(actor=actor)
+        return [server.to_config() for server in all_servers]

letta/server/server.py

@@ -45,7 +45,7 @@ from letta.schemas.enums import JobStatus, MessageStreamStatus, ProviderCategory
 from letta.schemas.environment_variables import SandboxEnvironmentVariableCreate
 from letta.schemas.group import GroupCreate, ManagerType, SleeptimeManager, VoiceSleeptimeManager
 from letta.schemas.job import Job, JobUpdate
-from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage, ToolReturnMessage
+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.llm_config import LLMConfig
@@ -2237,6 +2237,7 @@ class SyncServer(Server):
         assistant_message_tool_kwarg: str = constants.DEFAULT_MESSAGE_TOOL_KWARG,
         metadata: Optional[dict] = None,
         request_start_timestamp_ns: Optional[int] = None,
+        include_return_message_types: Optional[List[MessageType]] = None,
     ) -> Union[StreamingResponse, LettaResponse]:
         """Split off into a separate function so that it can be imported in the /chat/completion proxy."""
         # TODO: @charles is this the correct way to handle?
@@ -2342,6 +2343,11 @@ class SyncServer(Server):
 
                 # Get rid of the stream status messages
                 filtered_stream = [d for d in generated_stream if not isinstance(d, MessageStreamStatus)]
+
+                # Apply message type filtering if specified
+                if include_return_message_types is not None:
+                    filtered_stream = [msg for msg in filtered_stream if msg.message_type in include_return_message_types]
+
                 usage = await task
 
                 # By default the stream will be messages of type LettaMessage or LettaLegacyMessage

letta/services/agent_manager.py

@@ -1483,7 +1483,7 @@ class AgentManager:
             memory_edit_timestamp = curr_system_message.created_at
 
         num_messages = await self.message_manager.size_async(actor=actor, agent_id=agent_id)
-        num_archival_memories = await self.passage_manager.size_async(actor=actor, agent_id=agent_id)
+        num_archival_memories = await self.passage_manager.agent_passage_size_async(actor=actor, agent_id=agent_id)
 
         # update memory (TODO: potentially update recall/archival stats separately)
         new_system_message_str = compile_system_message(
@@ -2075,6 +2075,7 @@ class AgentManager:
                     # This is an AgentPassage - remove source fields
                     data.pop("source_id", None)
                     data.pop("file_id", None)
+                    data.pop("file_name", None)
                     passage = AgentPassage(**data)
                 else:
                     # This is a SourcePassage - remove agent field
@@ -2135,6 +2136,7 @@ class AgentManager:
                     # This is an AgentPassage - remove source fields
                     data.pop("source_id", None)
                     data.pop("file_id", None)
+                    data.pop("file_name", None)
                     passage = AgentPassage(**data)
                 else:
                     # This is a SourcePassage - remove agent field
@@ -2198,14 +2200,12 @@ class AgentManager:
         self,
         actor: PydanticUser,
         agent_id: Optional[str] = None,
-        file_id: Optional[str] = None,
         limit: Optional[int] = 50,
         query_text: Optional[str] = None,
         start_date: Optional[datetime] = None,
         end_date: Optional[datetime] = None,
         before: Optional[str] = None,
         after: Optional[str] = None,
-        source_id: Optional[str] = None,
         embed_query: bool = False,
         ascending: bool = True,
         embedding_config: Optional[EmbeddingConfig] = None,

letta/services/context_window_calculator/context_window_calculator.py

@@ -63,7 +63,7 @@ class ContextWindowCalculator:
         # Fetch data concurrently
         (in_context_messages, passage_manager_size, message_manager_size) = await asyncio.gather(
             message_manager.get_messages_by_ids_async(message_ids=agent_state.message_ids, actor=actor),
-            passage_manager.size_async(actor=actor, agent_id=agent_state.id),
+            passage_manager.agent_passage_size_async(actor=actor, agent_id=agent_state.id),
             message_manager.size_async(actor=actor, agent_id=agent_state.id),
         )
 

letta/services/file_processor/file_processor.py

@@ -111,7 +111,9 @@ class FileProcessor:
                 )
                 all_passages.extend(passages)
 
-            all_passages = await self.passage_manager.create_many_passages_async(all_passages, self.actor)
+            all_passages = await self.passage_manager.create_many_source_passages_async(
+                passages=all_passages, file_metadata=file_metadata, actor=self.actor
+            )
 
             logger.info(f"Successfully processed {filename}: {len(all_passages)} passages")
 

letta/services/helpers/agent_manager_helper.py

@@ -607,15 +607,45 @@ def build_passage_query(
     if not agent_only:  # Include source passages
         if agent_id is not None:
             source_passages = (
-                select(SourcePassage, literal(None).label("agent_id"))
+                select(
+                    SourcePassage.file_name,
+                    SourcePassage.id,
+                    SourcePassage.text,
+                    SourcePassage.embedding_config,
+                    SourcePassage.metadata_,
+                    SourcePassage.embedding,
+                    SourcePassage.created_at,
+                    SourcePassage.updated_at,
+                    SourcePassage.is_deleted,
+                    SourcePassage._created_by_id,
+                    SourcePassage._last_updated_by_id,
+                    SourcePassage.organization_id,
+                    SourcePassage.file_id,
+                    SourcePassage.source_id,
+                    literal(None).label("agent_id"),
+                )
                 .join(SourcesAgents, SourcesAgents.source_id == SourcePassage.source_id)
                 .where(SourcesAgents.agent_id == agent_id)
                 .where(SourcePassage.organization_id == actor.organization_id)
             )
         else:
-            source_passages = select(SourcePassage, literal(None).label("agent_id")).where(
-                SourcePassage.organization_id == actor.organization_id
-            )
+            source_passages = select(
+                SourcePassage.file_name,
+                SourcePassage.id,
+                SourcePassage.text,
+                SourcePassage.embedding_config,
+                SourcePassage.metadata_,
+                SourcePassage.embedding,
+                SourcePassage.created_at,
+                SourcePassage.updated_at,
+                SourcePassage.is_deleted,
+                SourcePassage._created_by_id,
+                SourcePassage._last_updated_by_id,
+                SourcePassage.organization_id,
+                SourcePassage.file_id,
+                SourcePassage.source_id,
+                literal(None).label("agent_id"),
+            ).where(SourcePassage.organization_id == actor.organization_id)
 
         if source_id:
             source_passages = source_passages.where(SourcePassage.source_id == source_id)
@@ -627,6 +657,7 @@ def build_passage_query(
     if agent_id is not None:
         agent_passages = (
             select(
+                literal(None).label("file_name"),
                 AgentPassage.id,
                 AgentPassage.text,
                 AgentPassage.embedding_config,

letta/services/mcp/stdio_client.py

@@ -11,7 +11,11 @@ logger = get_logger(__name__)
 # TODO: Get rid of Async prefix on this class name once we deprecate old sync code
 class AsyncStdioMCPClient(AsyncBaseMCPClient):
     async def _initialize_connection(self, server_config: StdioServerConfig) -> None:
-        server_params = StdioServerParameters(command=server_config.command, args=server_config.args)
+
+        args = [arg.split() for arg in server_config.args]
+        # flatten
+        args = [arg for sublist in args for arg in sublist]
+        server_params = StdioServerParameters(command=server_config.command, args=args)
         stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
         self.stdio, self.write = stdio_transport
         self.session = await self.exit_stack.enter_async_context(ClientSession(self.stdio, self.write))