letta-nightly 0.8.0.dev20250606195656__py3-none-any.whl → 0.8.3.dev20250607000559__py3-none-any.whl

letta/services/per_agent_lock_manager.py

@@ -1,7 +1,7 @@
 import threading
 from collections import defaultdict
 
-from letta.tracing import trace_method
+from letta.otel.tracing import trace_method
 
 
 class PerAgentLockManager:

letta/services/provider_manager.py

@@ -1,12 +1,12 @@
 from typing import List, Optional, Union
 
 from letta.orm.provider import Provider as ProviderModel
+from letta.otel.tracing import trace_method
 from letta.schemas.enums import ProviderCategory, ProviderType
 from letta.schemas.providers import Provider as PydanticProvider
 from letta.schemas.providers import ProviderCheck, ProviderCreate, ProviderUpdate
 from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry
-from letta.tracing import trace_method
 from letta.utils import enforce_types
 
 

letta/services/sandbox_config_manager.py

@@ -5,6 +5,7 @@ from letta.log import get_logger
 from letta.orm.errors import NoResultFound
 from letta.orm.sandbox_config import SandboxConfig as SandboxConfigModel
 from letta.orm.sandbox_config import SandboxEnvironmentVariable as SandboxEnvVarModel
+from letta.otel.tracing import trace_method
 from letta.schemas.environment_variables import SandboxEnvironmentVariable as PydanticEnvVar
 from letta.schemas.environment_variables import SandboxEnvironmentVariableCreate, SandboxEnvironmentVariableUpdate
 from letta.schemas.sandbox_config import LocalSandboxConfig
@@ -12,7 +13,6 @@ from letta.schemas.sandbox_config import SandboxConfig as PydanticSandboxConfig
 from letta.schemas.sandbox_config import SandboxConfigCreate, SandboxConfigUpdate, SandboxType
 from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry
-from letta.tracing import trace_method
 from letta.utils import enforce_types, printd
 
 logger = get_logger(__name__)

letta/services/source_manager.py

@@ -1,16 +1,25 @@
 import asyncio
+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.source import Source as SourceModel
+from letta.orm.sqlalchemy_base import AccessType
+from letta.otel.tracing import trace_method
 from letta.schemas.agent import AgentState as PydanticAgentState
+from letta.schemas.enums import FileProcessingStatus
 from letta.schemas.file import FileMetadata as PydanticFileMetadata
 from letta.schemas.source import Source as PydanticSource
 from letta.schemas.source import SourceUpdate
 from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry
-from letta.tracing import trace_method
 from letta.utils import enforce_types, printd
 
 
@@ -142,41 +151,191 @@ class SourceManager:
 
     @enforce_types
     @trace_method
-    async def create_file(self, file_metadata: PydanticFileMetadata, actor: PydanticUser) -> PydanticFileMetadata:
-        """Create a new file based on the PydanticFileMetadata schema."""
-        db_file = await self.get_file_by_id(file_metadata.id, actor=actor)
-        if db_file:
-            return db_file
-        else:
-            async with db_registry.async_session() as session:
+    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_metadata = FileMetadataModel(**file_metadata.model_dump(to_orm=True, exclude_none=True))
-                await file_metadata.create_async(session, actor=actor)
-                return file_metadata.to_pydantic()
+                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) -> Optional[PydanticFileMetadata]:
-        """Retrieve a file by its ID."""
+    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:
-                file = await FileMetadataModel.read_async(db_session=session, identifier=file_id, actor=actor)
-                return file.to_pydantic()
+                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
+        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
+                db_session=session,
+                after=after,
+                limit=limit,
+                organization_id=actor.organization_id,
+                source_id=source_id,
+                query_options=options,
             )
-            return [file.to_pydantic() for file in files]
+            return [await file.to_pydantic_async(include_content=include_content) for file in files]
 
     @enforce_types
     @trace_method
@@ -185,4 +344,4 @@ class SourceManager:
         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 file.to_pydantic()
+            return await file.to_pydantic_async()

letta/services/step_manager.py

@@ -5,16 +5,16 @@ from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
 
+from letta.helpers.singleton import singleton
 from letta.orm.errors import NoResultFound
 from letta.orm.job import Job as JobModel
 from letta.orm.sqlalchemy_base import AccessType
 from letta.orm.step import Step as StepModel
+from letta.otel.tracing import get_trace_id, trace_method
 from letta.schemas.openai.chat_completion_response import UsageStatistics
 from letta.schemas.step import Step as PydanticStep
 from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry
-from letta.services.helpers.noop_helper import singleton
-from letta.tracing import get_trace_id, trace_method
 from letta.utils import enforce_types
 
 

letta/services/summarizer/summarizer.py

@@ -6,11 +6,11 @@ from typing import List, Optional, Tuple, Union
 from letta.agents.ephemeral_summary_agent import EphemeralSummaryAgent
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.log import get_logger
+from letta.otel.tracing import trace_method
 from letta.schemas.enums import MessageRole
 from letta.schemas.letta_message_content import TextContent
 from letta.schemas.message import Message, MessageCreate
 from letta.services.summarizer.enums import SummarizationMode
-from letta.tracing import trace_method
 
 logger = get_logger(__name__)
 

letta/services/telemetry_manager.py

@@ -1,11 +1,11 @@
 from letta.helpers.json_helpers import json_dumps, json_loads
+from letta.helpers.singleton import singleton
 from letta.orm.provider_trace import ProviderTrace as ProviderTraceModel
 from letta.schemas.provider_trace import ProviderTrace as PydanticProviderTrace
 from letta.schemas.provider_trace import ProviderTraceCreate
 from letta.schemas.step import Step as PydanticStep
 from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry
-from letta.services.helpers.noop_helper import singleton
 from letta.utils import enforce_types
 
 

letta/services/tool_executor/builtin_tool_executor.py

@@ -0,0 +1,117 @@
+import json
+from textwrap import shorten
+from typing import Any, Dict, Literal, Optional
+
+from letta.constants import WEB_SEARCH_CLIP_CONTENT, WEB_SEARCH_INCLUDE_SCORE, WEB_SEARCH_SEPARATOR
+from letta.otel.tracing import trace_method
+from letta.schemas.agent import AgentState
+from letta.schemas.sandbox_config import SandboxConfig
+from letta.schemas.tool import Tool
+from letta.schemas.tool_execution_result import ToolExecutionResult
+from letta.schemas.user import User
+from letta.services.tool_executor.tool_executor_base import ToolExecutor
+from letta.settings import tool_settings
+
+
+class LettaBuiltinToolExecutor(ToolExecutor):
+    """Executor for built in Letta tools."""
+
+    @trace_method
+    async def execute(
+        self,
+        function_name: str,
+        function_args: dict,
+        tool: Tool,
+        actor: User,
+        agent_state: Optional[AgentState] = None,
+        sandbox_config: Optional[SandboxConfig] = None,
+        sandbox_env_vars: Optional[Dict[str, Any]] = None,
+    ) -> ToolExecutionResult:
+        function_map = {"run_code": self.run_code, "web_search": self.web_search}
+
+        if function_name not in function_map:
+            raise ValueError(f"Unknown function: {function_name}")
+
+        # Execute the appropriate function
+        function_args_copy = function_args.copy()  # Make a copy to avoid modifying the original
+        function_response = await function_map[function_name](**function_args_copy)
+
+        return ToolExecutionResult(
+            status="success",
+            func_return=function_response,
+            agent_state=agent_state,
+        )
+
+    async def run_code(self, code: str, language: Literal["python", "js", "ts", "r", "java"]) -> str:
+        from e2b_code_interpreter import AsyncSandbox
+
+        if tool_settings.e2b_api_key is None:
+            raise ValueError("E2B_API_KEY is not set")
+
+        sbx = await AsyncSandbox.create(api_key=tool_settings.e2b_api_key)
+        params = {"code": code}
+        if language != "python":
+            # Leave empty for python
+            params["language"] = language
+
+        res = self._llm_friendly_result(await sbx.run_code(**params))
+        return json.dumps(res, ensure_ascii=False)
+
+    def _llm_friendly_result(self, res):
+        out = {
+            "results": [r.text if hasattr(r, "text") else str(r) for r in res.results],
+            "logs": {
+                "stdout": getattr(res.logs, "stdout", []),
+                "stderr": getattr(res.logs, "stderr", []),
+            },
+        }
+        err = getattr(res, "error", None)
+        if err is not None:
+            out["error"] = err
+        return out
+
+    async def web_search(agent_state: "AgentState", query: str) -> str:
+        """
+        Search the web for information.
+        Args:
+            query (str): The query to search the web for.
+        Returns:
+            str: The search results.
+        """
+
+        try:
+            from tavily import AsyncTavilyClient
+        except ImportError:
+            raise ImportError("tavily is not installed in the tool execution environment")
+
+        # Check if the API key exists
+        if tool_settings.tavily_api_key is None:
+            raise ValueError("TAVILY_API_KEY is not set")
+
+        # Instantiate client and search
+        tavily_client = AsyncTavilyClient(api_key=tool_settings.tavily_api_key)
+        search_results = await tavily_client.search(query=query, auto_parameters=True)
+
+        results = search_results.get("results", [])
+        if not results:
+            return "No search results found."
+
+        # ---- format for the LLM -------------------------------------------------
+        formatted_blocks = []
+        for idx, item in enumerate(results, start=1):
+            title = item.get("title") or "Untitled"
+            url = item.get("url") or "Unknown URL"
+            # keep each content snippet reasonably short so you don’t blow up context
+            content = (
+                shorten(item.get("content", "").strip(), width=600, placeholder=" …")
+                if WEB_SEARCH_CLIP_CONTENT
+                else item.get("content", "").strip()
+            )
+            score = item.get("score")
+            if WEB_SEARCH_INCLUDE_SCORE:
+                block = f"\nRESULT {idx}:\n" f"Title: {title}\n" f"URL: {url}\n" f"Relevance score: {score:.4f}\n" f"Content: {content}\n"
+            else:
+                block = f"\nRESULT {idx}:\n" f"Title: {title}\n" f"URL: {url}\n" f"Content: {content}\n"
+            formatted_blocks.append(block)
+
+        return WEB_SEARCH_SEPARATOR.join(formatted_blocks)

letta/services/tool_executor/composio_tool_executor.py

@@ -0,0 +1,53 @@
+from typing import Any, Dict, Optional
+
+from letta.constants import COMPOSIO_ENTITY_ENV_VAR_KEY
+from letta.functions.composio_helpers import execute_composio_action_async, generate_composio_action_from_func_name
+from letta.helpers.composio_helpers import get_composio_api_key_async
+from letta.otel.tracing import trace_method
+from letta.schemas.agent import AgentState
+from letta.schemas.sandbox_config import SandboxConfig
+from letta.schemas.tool import Tool
+from letta.schemas.tool_execution_result import ToolExecutionResult
+from letta.schemas.user import User
+from letta.services.tool_executor.tool_executor_base import ToolExecutor
+
+
+class ExternalComposioToolExecutor(ToolExecutor):
+    """Executor for external Composio tools."""
+
+    @trace_method
+    async def execute(
+        self,
+        function_name: str,
+        function_args: dict,
+        tool: Tool,
+        actor: User,
+        agent_state: Optional[AgentState] = None,
+        sandbox_config: Optional[SandboxConfig] = None,
+        sandbox_env_vars: Optional[Dict[str, Any]] = None,
+    ) -> ToolExecutionResult:
+        assert agent_state is not None, "Agent state is required for external Composio tools"
+        action_name = generate_composio_action_from_func_name(tool.name)
+
+        # Get entity ID from the agent_state
+        entity_id = self._get_entity_id(agent_state)
+
+        # Get composio_api_key
+        composio_api_key = await get_composio_api_key_async(actor=actor)
+
+        # TODO (matt): Roll in execute_composio_action into this class
+        function_response = await execute_composio_action_async(
+            action_name=action_name, args=function_args, api_key=composio_api_key, entity_id=entity_id
+        )
+
+        return ToolExecutionResult(
+            status="success",
+            func_return=function_response,
+        )
+
+    def _get_entity_id(self, agent_state: AgentState) -> Optional[str]:
+        """Extract the entity ID from environment variables."""
+        for env_var in agent_state.tool_exec_environment_variables:
+            if env_var.key == COMPOSIO_ENTITY_ENV_VAR_KEY:
+                return env_var.value
+        return None