letta-nightly 0.8.3.dev20250612104349__py3-none-any.whl → 0.8.4.dev20250614104137__py3-none-any.whl

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

@@ -12,7 +12,7 @@ from sqlalchemy.exc import IntegrityError, OperationalError
 from starlette.responses import Response, StreamingResponse
 
 from letta.agents.letta_agent import LettaAgent
-from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
+from letta.constants import DEFAULT_MAX_STEPS, DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.groups.sleeptime_multi_agent_v2 import SleeptimeMultiAgentV2
 from letta.helpers.datetime_helpers import get_utc_timestamp_ns
 from letta.log import get_logger
@@ -316,7 +316,7 @@ async def attach_source(
     # Check if the agent is missing any files tools
     agent_state = await server.agent_manager.attach_missing_files_tools_async(agent_state=agent_state, actor=actor)
 
-    files = await server.source_manager.list_files(source_id, actor, include_content=True)
+    files = await server.file_manager.list_files(source_id, actor, include_content=True)
     texts = []
     file_ids = []
     file_names = []
@@ -354,7 +354,7 @@ async def detach_source(
     if not agent_state.sources:
         agent_state = await server.agent_manager.detach_all_files_tools_async(agent_state=agent_state, actor=actor)
 
-    files = await server.source_manager.list_files(source_id, actor)
+    files = await server.file_manager.list_files(source_id, actor)
     file_ids = [f.id for f in files]
     await server.remove_files_from_context_window(agent_state=agent_state, file_ids=file_ids, actor=actor)
 
@@ -371,6 +371,14 @@ async def detach_source(
 @router.get("/{agent_id}", response_model=AgentState, operation_id="retrieve_agent")
 async def retrieve_agent(
     agent_id: str,
+    include_relationships: Optional[List[str]] = Query(
+        None,
+        description=(
+            "Specify which relational fields (e.g., 'tools', 'sources', 'memory') to include in the response. "
+            "If not provided, all relationships are loaded by default. "
+            "Using this can optimize performance by reducing unnecessary joins."
+        ),
+    ),
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
@@ -380,7 +388,7 @@ async def retrieve_agent(
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     try:
-        return await server.agent_manager.get_agent_by_id_async(agent_id=agent_id, actor=actor)
+        return await server.agent_manager.get_agent_by_id_async(agent_id=agent_id, include_relationships=include_relationships, actor=actor)
     except NoResultFound as e:
         raise HTTPException(status_code=404, detail=str(e))
 
@@ -665,13 +673,13 @@ async def send_message(
     Process a user message and return the agent's response.
     This endpoint accepts a message from a user and processes it through the agent.
     """
+    request_start_timestamp_ns = get_utc_timestamp_ns()
     MetricRegistry().user_message_counter.add(1, get_ctx_attributes())
 
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
-    request_start_timestamp_ns = get_utc_timestamp_ns()
     # TODO: This is redundant, remove soon
     agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor, include_relationships=["multi_agent_group"])
-    agent_eligible = agent.enable_sleeptime or agent.agent_type == AgentType.sleeptime_agent or not agent.multi_agent_group
+    agent_eligible = agent.multi_agent_group is None or agent.multi_agent_group.manager_type in ["sleeptime", "voice_sleeptime"]
     model_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai", "together", "google_ai", "google_vertex"]
 
     if agent_eligible and model_compatible:
@@ -701,7 +709,7 @@ async def send_message(
 
         result = await agent_loop.step(
             request.messages,
-            max_steps=10,
+            max_steps=request.max_steps,
             use_assistant_message=request.use_assistant_message,
             request_start_timestamp_ns=request_start_timestamp_ns,
             include_return_message_types=request.include_return_message_types,
@@ -747,16 +755,16 @@ async def send_message_streaming(
     This endpoint accepts a message from a user and processes it through the agent.
     It will stream the steps of the response always, and stream the tokens if 'stream_tokens' is set to True.
     """
+    request_start_timestamp_ns = get_utc_timestamp_ns()
     MetricRegistry().user_message_counter.add(1, get_ctx_attributes())
 
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     # TODO: This is redundant, remove soon
     agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor, include_relationships=["multi_agent_group"])
-    agent_eligible = agent.enable_sleeptime or agent.agent_type == AgentType.sleeptime_agent or not agent.multi_agent_group
+    agent_eligible = agent.multi_agent_group is None or agent.multi_agent_group.manager_type in ["sleeptime", "voice_sleeptime"]
     model_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai", "together", "google_ai", "google_vertex"]
     model_compatible_token_streaming = agent.llm_config.model_endpoint_type in ["anthropic", "openai"]
     not_letta_endpoint = not ("inference.letta.com" in agent.llm_config.model_endpoint)
-    request_start_timestamp_ns = get_utc_timestamp_ns()
 
     if agent_eligible and model_compatible:
         if agent.enable_sleeptime and agent.agent_type != AgentType.voice_convo_agent:
@@ -790,7 +798,7 @@ async def send_message_streaming(
             result = StreamingResponseWithStatusCode(
                 agent_loop.step_stream(
                     input_messages=request.messages,
-                    max_steps=10,
+                    max_steps=request.max_steps,
                     use_assistant_message=request.use_assistant_message,
                     request_start_timestamp_ns=request_start_timestamp_ns,
                     include_return_message_types=request.include_return_message_types,
@@ -801,7 +809,7 @@ async def send_message_streaming(
             result = StreamingResponseWithStatusCode(
                 agent_loop.step_stream_no_tokens(
                     request.messages,
-                    max_steps=10,
+                    max_steps=request.max_steps,
                     use_assistant_message=request.use_assistant_message,
                     request_start_timestamp_ns=request_start_timestamp_ns,
                     include_return_message_types=request.include_return_message_types,
@@ -835,6 +843,7 @@ async def process_message_background(
     use_assistant_message: bool,
     assistant_message_tool_name: str,
     assistant_message_tool_kwarg: str,
+    max_steps: int = DEFAULT_MAX_STEPS,
     include_return_message_types: Optional[List[MessageType]] = None,
 ) -> None:
     """Background task to process the message and update job status."""
@@ -919,6 +928,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,
+        max_steps=request.max_steps,
         include_return_message_types=request.include_return_message_types,
     )
 
@@ -969,7 +979,7 @@ async def summarize_agent_conversation(
 
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor, include_relationships=["multi_agent_group"])
-    agent_eligible = agent.enable_sleeptime or agent.agent_type == AgentType.sleeptime_agent or not agent.multi_agent_group
+    agent_eligible = agent.multi_agent_group is None or agent.multi_agent_group.manager_type in ["sleeptime", "voice_sleeptime"]
     model_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai", "together", "google_ai", "google_vertex"]
 
     if agent_eligible and model_compatible:

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

@@ -21,16 +21,15 @@ from letta.server.server import SyncServer
 from letta.services.file_processor.chunker.llama_index_chunker import LlamaIndexChunker
 from letta.services.file_processor.embedder.openai_embedder import OpenAIEmbedder
 from letta.services.file_processor.file_processor import FileProcessor
+from letta.services.file_processor.file_types import get_allowed_media_types, get_extension_to_mime_type_map, register_mime_types
 from letta.services.file_processor.parser.mistral_parser import MistralFileParser
 from letta.settings import model_settings, settings
 from letta.utils import safe_create_task, sanitize_filename
 
 logger = get_logger(__name__)
 
-mimetypes.add_type("text/markdown", ".md")
-mimetypes.add_type("text/markdown", ".markdown")
-mimetypes.add_type("application/jsonl", ".jsonl")
-mimetypes.add_type("application/x-jsonlines", ".jsonl")
+# Register all supported file types with Python's mimetypes module
+register_mime_types()
 
 
 router = APIRouter(prefix="/sources", tags=["sources"])
@@ -154,7 +153,7 @@ async def delete_source(
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     source = await server.source_manager.get_source_by_id(source_id=source_id, actor=actor)
     agent_states = await server.source_manager.list_attached_agents(source_id=source_id, actor=actor)
-    files = await server.source_manager.list_files(source_id, actor)
+    files = await server.file_manager.list_files(source_id, actor)
     file_ids = [f.id for f in files]
 
     for agent_state in agent_states:
@@ -179,15 +178,7 @@ async def upload_file_to_source(
     """
     Upload a file to a data source.
     """
-    allowed_media_types = {
-        "application/pdf",
-        "text/plain",
-        "text/markdown",
-        "text/x-markdown",
-        "application/json",
-        "application/jsonl",
-        "application/x-jsonlines",
-    }
+    allowed_media_types = get_allowed_media_types()
 
     # Normalize incoming Content-Type header (strip charset or any parameters).
     raw_ct = file.content_type or ""
@@ -201,21 +192,18 @@ async def upload_file_to_source(
 
         if media_type not in allowed_media_types:
             ext = Path(file.filename).suffix.lower()
-            ext_map = {
-                ".pdf": "application/pdf",
-                ".txt": "text/plain",
-                ".json": "application/json",
-                ".md": "text/markdown",
-                ".markdown": "text/markdown",
-                ".jsonl": "application/jsonl",
-            }
+            ext_map = get_extension_to_mime_type_map()
             media_type = ext_map.get(ext, media_type)
 
     # If still not allowed, reject with 415.
     if media_type not in allowed_media_types:
         raise HTTPException(
             status_code=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
-            detail=(f"Unsupported file type: {media_type or 'unknown'} " f"(filename: {file.filename}). Only PDF, .txt, or .json allowed."),
+            detail=(
+                f"Unsupported file type: {media_type or 'unknown'} "
+                f"(filename: {file.filename}). "
+                f"Supported types: PDF, text files (.txt, .md), JSON, and code files (.py, .js, .java, etc.)."
+            ),
         )
 
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
@@ -294,7 +282,7 @@ async def list_source_files(
     List paginated files associated with a data source.
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
-    return await server.source_manager.list_files(
+    return await server.file_manager.list_files(
         source_id=source_id,
         limit=limit,
         after=after,
@@ -317,7 +305,7 @@ async def delete_file_from_source(
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
-    deleted_file = await server.source_manager.delete_file(file_id=file_id, actor=actor)
+    deleted_file = await server.file_manager.delete_file(file_id=file_id, actor=actor)
 
     await server.remove_file_from_context_windows(source_id=source_id, file_id=deleted_file.id, actor=actor)
 

letta/server/server.py

@@ -80,6 +80,7 @@ from letta.server.rest_api.interface import StreamingServerInterface
 from letta.server.rest_api.utils import sse_async_generator
 from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
+from letta.services.file_manager import FileManager
 from letta.services.files_agents_manager import FileAgentManager
 from letta.services.group_manager import GroupManager
 from letta.services.helpers.tool_execution_helper import prepare_local_sandbox
@@ -219,6 +220,7 @@ class SyncServer(Server):
         self.batch_manager = LLMBatchManager()
         self.telemetry_manager = TelemetryManager()
         self.file_agent_manager = FileAgentManager()
+        self.file_manager = FileManager()
 
         # A resusable httpx client
         timeout = httpx.Timeout(connect=10.0, read=20.0, write=10.0, pool=10.0)
@@ -1507,7 +1509,7 @@ class SyncServer(Server):
             raise ValueError(f"Data source {source_name} does not exist for user {user_id}")
 
         # load data into the document store
-        passage_count, document_count = await load_data(connector, source, self.passage_manager, self.source_manager, actor=actor)
+        passage_count, document_count = await load_data(connector, source, self.passage_manager, self.file_manager, actor=actor)
         return passage_count, document_count
 
     def list_data_source_passages(self, user_id: str, source_id: str) -> List[Passage]:
@@ -2026,7 +2028,8 @@ class SyncServer(Server):
             )
 
     # Composio wrappers
-    def get_composio_client(self, api_key: Optional[str] = None):
+    @staticmethod
+    def get_composio_client(api_key: Optional[str] = None):
         if api_key:
             return Composio(api_key=api_key)
         elif tool_settings.composio_api_key:
@@ -2034,9 +2037,10 @@ class SyncServer(Server):
         else:
             return Composio()
 
-    def get_composio_apps(self, api_key: Optional[str] = None) -> List["AppModel"]:
+    @staticmethod
+    def get_composio_apps(api_key: Optional[str] = None) -> List["AppModel"]:
         """Get a list of all Composio apps with actions"""
-        apps = self.get_composio_client(api_key=api_key).apps.get()
+        apps = SyncServer.get_composio_client(api_key=api_key).apps.get()
         apps_with_actions = []
         for app in apps:
             # A bit of hacky logic until composio patches this
@@ -2047,7 +2051,8 @@ class SyncServer(Server):
 
     def get_composio_actions_from_app_name(self, composio_app_name: str, api_key: Optional[str] = None) -> List["ActionModel"]:
         actions = self.get_composio_client(api_key=api_key).actions.get(apps=[composio_app_name])
-        return actions
+        # Filter out deprecated composio actions
+        return [action for action in actions if "deprecated" not in action.description.lower()]
 
     # MCP wrappers
     # TODO support both command + SSE servers (via config)

letta/services/agent_manager.py

@@ -19,6 +19,7 @@ from letta.constants import (
     FILES_TOOLS,
     MULTI_AGENT_TOOLS,
 )
+from letta.helpers import ToolRulesSolver
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.llm_api.llm_client import LLMClient
 from letta.log import get_logger
@@ -1444,7 +1445,7 @@ class AgentManager:
     @trace_method
     @enforce_types
     async def rebuild_system_prompt_async(
-        self, agent_id: str, actor: PydanticUser, force=False, update_timestamp=True
+        self, agent_id: str, actor: PydanticUser, force=False, update_timestamp=True, tool_rules_solver: Optional[ToolRulesSolver] = None
     ) -> PydanticAgentState:
         """Rebuilds the system message with the latest memory object and any shared memory block updates
 
@@ -1453,6 +1454,8 @@ class AgentManager:
         Updates to the memory header should *not* trigger a rebuild, since that will simply flood recall storage with excess messages
         """
         agent_state = await self.get_agent_by_id_async(agent_id=agent_id, include_relationships=["memory"], actor=actor)
+        if not tool_rules_solver:
+            tool_rules_solver = ToolRulesSolver(agent_state.tool_rules)
 
         curr_system_message = await self.get_system_message_async(
             agent_id=agent_id, actor=actor
@@ -1492,6 +1495,7 @@ class AgentManager:
             in_context_memory_last_edit=memory_edit_timestamp,
             previous_message_count=num_messages,
             archival_memory_size=num_archival_memories,
+            tool_rules_solver=tool_rules_solver,
         )
 
         diff = united_diff(curr_system_message_openai["content"], new_system_message_str)

letta/services/file_manager.py

@@ -0,0 +1,219 @@
+from datetime import datetime
+from typing import List, Optional
+
+from sqlalchemy import select, update
+from sqlalchemy.dialects.postgresql import insert as pg_insert
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.orm import selectinload
+
+from letta.orm.errors import NoResultFound
+from letta.orm.file import FileContent as FileContentModel
+from letta.orm.file import FileMetadata as FileMetadataModel
+from letta.orm.sqlalchemy_base import AccessType
+from letta.otel.tracing import trace_method
+from letta.schemas.enums import FileProcessingStatus
+from letta.schemas.file import FileMetadata as PydanticFileMetadata
+from letta.schemas.user import User as PydanticUser
+from letta.server.db import db_registry
+from letta.utils import enforce_types
+
+
+class FileManager:
+    """Manager class to handle business logic related to files."""
+
+    @enforce_types
+    @trace_method
+    async def create_file(
+        self,
+        file_metadata: PydanticFileMetadata,
+        actor: PydanticUser,
+        *,
+        text: Optional[str] = None,
+    ) -> PydanticFileMetadata:
+
+        # short-circuit if it already exists
+        existing = await self.get_file_by_id(file_metadata.id, actor=actor)
+        if existing:
+            return existing
+
+        async with db_registry.async_session() as session:
+            try:
+                file_metadata.organization_id = actor.organization_id
+                file_orm = FileMetadataModel(**file_metadata.model_dump(to_orm=True, exclude_none=True))
+                await file_orm.create_async(session, actor=actor, no_commit=True)
+
+                if text is not None:
+                    content_orm = FileContentModel(file_id=file_orm.id, text=text)
+                    await content_orm.create_async(session, actor=actor, no_commit=True)
+
+                await session.commit()
+                await session.refresh(file_orm)
+                return await file_orm.to_pydantic_async()
+
+            except IntegrityError:
+                await session.rollback()
+                return await self.get_file_by_id(file_metadata.id, actor=actor)
+
+    # TODO: We make actor optional for now, but should most likely be enforced due to security reasons
+    @enforce_types
+    @trace_method
+    async def get_file_by_id(
+        self,
+        file_id: str,
+        actor: Optional[PydanticUser] = None,
+        *,
+        include_content: bool = False,
+    ) -> Optional[PydanticFileMetadata]:
+        """Retrieve a file by its ID.
+
+        If `include_content=True`, the FileContent relationship is eagerly
+        loaded so `to_pydantic(include_content=True)` never triggers a
+        lazy SELECT (avoids MissingGreenlet).
+        """
+        async with db_registry.async_session() as session:
+            try:
+                if include_content:
+                    # explicit eager load
+                    query = (
+                        select(FileMetadataModel).where(FileMetadataModel.id == file_id).options(selectinload(FileMetadataModel.content))
+                    )
+                    # apply org-scoping if actor provided
+                    if actor:
+                        query = FileMetadataModel.apply_access_predicate(
+                            query,
+                            actor,
+                            access=["read"],
+                            access_type=AccessType.ORGANIZATION,
+                        )
+
+                    result = await session.execute(query)
+                    file_orm = result.scalar_one()
+                else:
+                    # fast path (metadata only)
+                    file_orm = await FileMetadataModel.read_async(
+                        db_session=session,
+                        identifier=file_id,
+                        actor=actor,
+                    )
+
+                return await file_orm.to_pydantic_async(include_content=include_content)
+
+            except NoResultFound:
+                return None
+
+    @enforce_types
+    @trace_method
+    async def update_file_status(
+        self,
+        *,
+        file_id: str,
+        actor: PydanticUser,
+        processing_status: Optional[FileProcessingStatus] = None,
+        error_message: Optional[str] = None,
+    ) -> PydanticFileMetadata:
+        """
+        Update processing_status and/or error_message on a FileMetadata row.
+
+        * 1st round-trip → UPDATE
+        * 2nd round-trip → SELECT fresh row (same as read_async)
+        """
+
+        if processing_status is None and error_message is None:
+            raise ValueError("Nothing to update")
+
+        values: dict[str, object] = {"updated_at": datetime.utcnow()}
+        if processing_status is not None:
+            values["processing_status"] = processing_status
+        if error_message is not None:
+            values["error_message"] = error_message
+
+        async with db_registry.async_session() as session:
+            # Fast in-place update – no ORM hydration
+            stmt = (
+                update(FileMetadataModel)
+                .where(
+                    FileMetadataModel.id == file_id,
+                    FileMetadataModel.organization_id == actor.organization_id,
+                )
+                .values(**values)
+            )
+            await session.execute(stmt)
+            await session.commit()
+
+            # Reload via normal accessor so we return a fully-attached object
+            file_orm = await FileMetadataModel.read_async(
+                db_session=session,
+                identifier=file_id,
+                actor=actor,
+            )
+            return await file_orm.to_pydantic_async()
+
+    @enforce_types
+    @trace_method
+    async def upsert_file_content(
+        self,
+        *,
+        file_id: str,
+        text: str,
+        actor: PydanticUser,
+    ) -> PydanticFileMetadata:
+        async with db_registry.async_session() as session:
+            await FileMetadataModel.read_async(session, file_id, actor)
+
+            dialect_name = session.bind.dialect.name
+
+            if dialect_name == "postgresql":
+                stmt = (
+                    pg_insert(FileContentModel)
+                    .values(file_id=file_id, text=text)
+                    .on_conflict_do_update(
+                        index_elements=[FileContentModel.file_id],
+                        set_={"text": text},
+                    )
+                )
+                await session.execute(stmt)
+            else:
+                # Emulate upsert for SQLite and others
+                stmt = select(FileContentModel).where(FileContentModel.file_id == file_id)
+                result = await session.execute(stmt)
+                existing = result.scalar_one_or_none()
+
+                if existing:
+                    await session.execute(update(FileContentModel).where(FileContentModel.file_id == file_id).values(text=text))
+                else:
+                    session.add(FileContentModel(file_id=file_id, text=text))
+
+            await session.commit()
+
+            # Reload with content
+            query = select(FileMetadataModel).options(selectinload(FileMetadataModel.content)).where(FileMetadataModel.id == file_id)
+            result = await session.execute(query)
+            return await result.scalar_one().to_pydantic_async(include_content=True)
+
+    @enforce_types
+    @trace_method
+    async def list_files(
+        self, source_id: str, actor: PydanticUser, after: Optional[str] = None, limit: Optional[int] = 50, include_content: bool = False
+    ) -> List[PydanticFileMetadata]:
+        """List all files with optional pagination."""
+        async with db_registry.async_session() as session:
+            options = [selectinload(FileMetadataModel.content)] if include_content else None
+
+            files = await FileMetadataModel.list_async(
+                db_session=session,
+                after=after,
+                limit=limit,
+                organization_id=actor.organization_id,
+                source_id=source_id,
+                query_options=options,
+            )
+            return [await file.to_pydantic_async(include_content=include_content) for file in files]
+
+    @enforce_types
+    @trace_method
+    async def delete_file(self, file_id: str, actor: PydanticUser) -> PydanticFileMetadata:
+        """Delete a file by its ID."""
+        async with db_registry.async_session() as session:
+            file = await FileMetadataModel.read_async(db_session=session, identifier=file_id)
+            await file.hard_delete_async(db_session=session, actor=actor)
+            return await file.to_pydantic_async()