letta-nightly 0.13.0.dev20251031104146__py3-none-any.whl → 0.13.1.dev20251031234110__py3-none-any.whl

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

@@ -1,3 +1,4 @@
+from datetime import datetime
 from typing import List, Literal, Optional
 
 from fastapi import APIRouter, Depends, Query
@@ -55,13 +56,25 @@ async def list_runs(
     order: Literal["asc", "desc"] = Query(
         "desc", description="Sort order for runs by creation time. 'asc' for oldest first, 'desc' for newest first"
     ),
-    order_by: Literal["created_at"] = Query("created_at", description="Field to sort by"),
+    order_by: Literal["created_at", "duration"] = Query("created_at", description="Field to sort by"),
     active: bool = Query(False, description="Filter for active runs."),
     ascending: bool = Query(
         False,
         description="Whether to sort agents oldest to newest (True) or newest to oldest (False, default). Deprecated in favor of order field.",
         deprecated=True,
     ),
+    project_id: Optional[str] = Query(None, description="Filter runs by project ID."),
+    duration_percentile: Optional[int] = Query(
+        None, description="Filter runs by duration percentile (1-100). Returns runs slower than this percentile."
+    ),
+    duration_value: Optional[int] = Query(
+        None, description="Duration value in nanoseconds for filtering. Must be used with duration_operator."
+    ),
+    duration_operator: Optional[Literal["gt", "lt", "eq"]] = Query(
+        None, description="Comparison operator for duration filter: 'gt' (greater than), 'lt' (less than), 'eq' (equals)."
+    ),
+    start_date: Optional[datetime] = Query(None, description="Filter runs created on or after this date (ISO 8601 format)."),
+    end_date: Optional[datetime] = Query(None, description="Filter runs created on or before this date (ISO 8601 format)."),
     headers: HeaderParams = Depends(get_headers),
 ):
     """
@@ -89,6 +102,11 @@ async def list_runs(
     # Convert string statuses to RunStatus enum
     parsed_statuses = convert_statuses_to_enum(statuses)
 
+    # Create duration filter dict if both parameters provided
+    duration_filter = None
+    if duration_value is not None and duration_operator is not None:
+        duration_filter = {"value": duration_value, "operator": duration_operator}
+
     runs = await runs_manager.list_runs(
         actor=actor,
         agent_ids=agent_ids,
@@ -103,5 +121,11 @@ async def list_runs(
         step_count=step_count,
         step_count_operator=step_count_operator,
         tools_used=tools_used,
+        project_id=project_id,
+        order_by=order_by,
+        duration_percentile=duration_percentile,
+        duration_filter=duration_filter,
+        start_date=start_date,
+        end_date=end_date,
     )
     return runs

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

@@ -23,7 +23,6 @@ from letta.server.rest_api.streaming_response import (
     cancellation_aware_stream_wrapper,
 )
 from letta.server.server import SyncServer
-from letta.services.lettuce import LettuceClient
 from letta.services.run_manager import RunManager
 from letta.settings import settings
 
@@ -150,26 +149,7 @@ async def retrieve_run(
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
     runs_manager = RunManager()
-
-    run = await runs_manager.get_run_by_id(run_id=run_id, actor=actor)
-
-    use_lettuce = run.metadata and run.metadata.get("lettuce")
-    if use_lettuce and run.status not in [RunStatus.completed, RunStatus.failed, RunStatus.cancelled]:
-        lettuce_client = await LettuceClient.create()
-        status = await lettuce_client.get_status(run_id=run_id)
-
-        # Map the status to our enum
-        run_status = run.status
-        if status == "RUNNING":
-            run_status = RunStatus.running
-        elif status == "COMPLETED":
-            run_status = RunStatus.completed
-        elif status == "FAILED":
-            run_status = RunStatus.failed
-        elif status == "CANCELLED":
-            run_status = RunStatus.cancelled
-        run.status = run_status
-    return run
+    return await runs_manager.get_run_with_status(run_id=run_id, actor=actor)
 
 
 RunMessagesResponse = Annotated[
@@ -276,7 +256,7 @@ async def delete_run(
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
     runs_manager = RunManager()
-    return await runs_manager.delete_run_by_id(run_id=run_id, actor=actor)
+    return await runs_manager.delete_run(run_id=run_id, actor=actor)
 
 
 @router.post(

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

@@ -867,12 +867,22 @@ async def generate_tool_from_prompt(
     response = llm_client.convert_response_to_chat_completion(response_data, input_messages, llm_config)
     output = json.loads(response.choices[0].message.tool_calls[0].function.arguments)
     pip_requirements = [PipRequirement(name=k, version=v or None) for k, v in json.loads(output["pip_requirements_json"]).items()]
+
+    # Derive JSON schema from the generated source code
+    try:
+        json_schema = derive_openai_json_schema(source_code=output["raw_source_code"])
+    except Exception as e:
+        raise LettaInvalidArgumentError(
+            message=f"Failed to generate JSON schema for tool '{request.tool_name}': {e}", argument_name="tool_name"
+        )
+
     return GenerateToolOutput(
         tool=Tool(
             name=request.tool_name,
             source_type="python",
             source_code=output["raw_source_code"],
             pip_requirements=pip_requirements,
+            json_schema=json_schema,
         ),
         sample_args=json.loads(output["sample_args_json"]),
         response=response.choices[0].message.content,

letta/server/server.py

@@ -304,9 +304,8 @@ class SyncServer(object):
         if model_settings.openrouter_api_key:
             self._enabled_providers.append(
                 OpenRouterProvider(
-                    name="openrouter",
+                    name=model_settings.openrouter_handle_base if model_settings.openrouter_handle_base else "openrouter",
                     api_key=model_settings.openrouter_api_key,
-                    handle_base=model_settings.openrouter_handle_base,
                 )
             )
 
@@ -430,6 +429,10 @@ class SyncServer(object):
             log_event(name="start get_cached_llm_config", attributes=config_params)
             request.llm_config = await self.get_cached_llm_config_async(actor=actor, **config_params)
             log_event(name="end get_cached_llm_config", attributes=config_params)
+            if request.model and isinstance(request.model, str):
+                assert request.llm_config.handle == request.model, (
+                    f"LLM config handle {request.llm_config.handle} does not match request handle {request.model}"
+                )
 
         if request.reasoning is None:
             request.reasoning = request.llm_config.enable_reasoner or request.llm_config.put_inner_thoughts_in_kwargs

letta/services/agent_manager.py

@@ -411,9 +411,6 @@ class AgentManager:
         if agent_create.include_multi_agent_tools:
             tool_names |= calculate_multi_agent_tools()
 
-        # take out the deprecated tool names
-        tool_names.difference_update(set(DEPRECATED_LETTA_TOOLS))
-
         supplied_ids = set(agent_create.tool_ids or [])
 
         source_ids = agent_create.source_ids or []
@@ -1568,7 +1565,7 @@ class AgentManager:
             actor: User performing the action
 
         Raises:
-            ValueError: If either agent or source doesn't exist
+            NoResultFound: If either agent or source doesn't exist or actor lacks permission to access them
             IntegrityError: If the source is already attached to the agent
         """
 
@@ -1576,6 +1573,9 @@ class AgentManager:
             # Verify both agent and source exist and user has permission to access them
             agent = await AgentModel.read_async(db_session=session, identifier=agent_id, actor=actor)
 
+            # Verify the actor has permission to access the source
+            await SourceModel.read_async(db_session=session, identifier=source_id, actor=actor)
+
             # The _process_relationship helper already handles duplicate checking via unique constraint
             await _process_relationship_async(
                 session=session,

letta/services/archive_manager.py

@@ -14,6 +14,7 @@ from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import PrimitiveType, VectorDBProvider
 from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry
+from letta.services.helpers.agent_manager_helper import validate_agent_exists_async
 from letta.settings import DatabaseChoice, settings
 from letta.utils import enforce_types
 from letta.validators import raise_on_invalid_id
@@ -130,6 +131,9 @@ class ArchiveManager:
             ]
 
         async with db_registry.async_session() as session:
+            if agent_id:
+                await validate_agent_exists_async(session, agent_id, actor)
+
             archives = await ArchiveModel.list_async(
                 db_session=session,
                 before=before,
@@ -157,6 +161,12 @@ class ArchiveManager:
     ) -> None:
         """Attach an agent to an archive."""
         async with db_registry.async_session() as session:
+            # Verify agent exists and user has access to it
+            await validate_agent_exists_async(session, agent_id, actor)
+
+            # Verify archive exists and user has access to it
+            await ArchiveModel.read_async(db_session=session, identifier=archive_id, actor=actor)
+
             # Check if relationship already exists
             existing = await session.execute(
                 select(ArchivesAgents).where(
@@ -194,6 +204,12 @@ class ArchiveManager:
     ) -> None:
         """Detach an agent from an archive."""
         async with db_registry.async_session() as session:
+            # Verify agent exists and user has access to it
+            await validate_agent_exists_async(session, agent_id, actor)
+
+            # Verify archive exists and user has access to it
+            await ArchiveModel.read_async(db_session=session, identifier=archive_id, actor=actor)
+
             # Delete the relationship directly
             result = await session.execute(
                 delete(ArchivesAgents).where(

letta/services/group_manager.py

@@ -5,8 +5,10 @@ from sqlalchemy import and_, asc, delete, desc, or_, select
 from sqlalchemy.orm import Session
 
 from letta.orm.agent import Agent as AgentModel
+from letta.orm.block import Block
 from letta.orm.errors import NoResultFound
 from letta.orm.group import Group as GroupModel
+from letta.orm.groups_blocks import GroupsBlocks
 from letta.orm.message import Message as MessageModel
 from letta.otel.tracing import trace_method
 from letta.schemas.enums import PrimitiveType
@@ -410,6 +412,48 @@ class GroupManager:
                 for block in blocks:
                     session.add(BlocksAgents(agent_id=manager_agent.id, block_id=block.id, block_label=block.label))
 
+    @enforce_types
+    @trace_method
+    @raise_on_invalid_id(param_name="group_id", expected_prefix=PrimitiveType.GROUP)
+    @raise_on_invalid_id(param_name="block_id", expected_prefix=PrimitiveType.BLOCK)
+    async def attach_block_async(self, group_id: str, block_id: str, actor: PydanticUser) -> None:
+        """Attach a block to a group."""
+        async with db_registry.async_session() as session:
+            # Verify group exists and user has access
+            await GroupModel.read_async(db_session=session, identifier=group_id, actor=actor)
+
+            # Verify block exists AND user has access to it
+            await Block.read_async(db_session=session, identifier=block_id, actor=actor)
+
+            # Check if block is already attached to the group
+            check_query = select(GroupsBlocks).where(and_(GroupsBlocks.group_id == group_id, GroupsBlocks.block_id == block_id))
+            result = await session.execute(check_query)
+            if result.scalar_one_or_none():
+                # Block already attached, no-op
+                return
+
+            # Add block to group
+            session.add(GroupsBlocks(group_id=group_id, block_id=block_id))
+            await session.commit()
+
+    @enforce_types
+    @trace_method
+    @raise_on_invalid_id(param_name="group_id", expected_prefix=PrimitiveType.GROUP)
+    @raise_on_invalid_id(param_name="block_id", expected_prefix=PrimitiveType.BLOCK)
+    async def detach_block_async(self, group_id: str, block_id: str, actor: PydanticUser) -> None:
+        """Detach a block from a group."""
+        async with db_registry.async_session() as session:
+            # Verify group exists and user has access
+            await GroupModel.read_async(db_session=session, identifier=group_id, actor=actor)
+
+            # Verify block exists AND user has access to it
+            await Block.read_async(db_session=session, identifier=block_id, actor=actor)
+
+            # Remove block from group
+            delete_group_block = delete(GroupsBlocks).where(and_(GroupsBlocks.group_id == group_id, GroupsBlocks.block_id == block_id))
+            await session.execute(delete_group_block)
+            await session.commit()
+
     @staticmethod
     def ensure_buffer_length_range_valid(
         max_value: Optional[int],

letta/services/helpers/run_manager_helper.py

@@ -37,7 +37,7 @@ async def _apply_pagination_async(
                     RunModel.id,
                     after_sort_value,
                     after_id,
-                    forward=ascending,
+                    forward=not ascending,
                     nulls_last=sort_nulls_last,
                 )
             )
@@ -55,7 +55,7 @@ async def _apply_pagination_async(
                     RunModel.id,
                     before_sort_value,
                     before_id,
-                    forward=not ascending,
+                    forward=ascending,
                     nulls_last=sort_nulls_last,
                 )
             )

letta/services/lettuce/lettuce_client.py

@@ -0,0 +1,148 @@
+import os
+
+from temporalio.client import Client
+from temporalio.common import SearchAttributeKey, SearchAttributePair, TypedSearchAttributes
+
+from letta.agents.temporal.temporal_agent_workflow import TemporalAgentWorkflow
+from letta.agents.temporal.types import WorkflowInputParams
+from letta.constants import DEFAULT_MAX_STEPS
+from letta.schemas.agent import AgentState
+from letta.schemas.letta_message import MessageType
+from letta.schemas.message import MessageCreate
+from letta.schemas.user import User
+
+
+class LettuceClient:
+    """Client class for Lettuce service."""
+
+    def __init__(self):
+        """Initialize the LettuceClient."""
+        self.temporal_tls = os.getenv("LETTA_TEMPORAL_TLS", "true").lower() in (
+            "true",
+            "1",
+        )
+        self.temporal_api_key = os.getenv("LETTA_TEMPORAL_API_KEY")
+        self.temporal_namespace = os.getenv("LETTA_TEMPORAL_NAMESPACE")
+        self.temporal_endpoint = os.getenv("LETTA_TEMPORAL_ENDPOINT")
+        self.temporal_task_queue = os.getenv("LETTA_TEMPORAL_TASK_QUEUE", "agent_loop_async_task_queue")
+        self.temporal_skip_custom_sa = os.getenv("LETTA_TEMPORAL_SKIP_CUSTOM_SA")
+        self.client: Client | None = None
+
+    @classmethod
+    async def create(cls) -> "LettuceClient":
+        """
+        Asynchronously creates and connects the temporal client.
+
+        Returns:
+            LettuceClient: The created LettuceClient instance.
+        """
+        instance = cls()
+        if instance.temporal_api_key and instance.temporal_endpoint:
+            instance.client = await Client.connect(
+                instance.temporal_endpoint,
+                namespace=instance.temporal_namespace,
+                api_key=instance.temporal_api_key,
+                tls=instance.temporal_tls,
+            )
+        return instance
+
+    def get_client(self) -> Client | None:
+        """
+        Get the temporal client, if connected.
+
+        Returns:
+            Client | None: The temporal client, if connected.
+        """
+        return self.client
+
+    async def get_status(self, run_id: str) -> str | None:
+        """
+        Get the status of a run.
+
+        Args:
+            run_id (str): The ID of the run.
+
+        Returns:
+            str | None: The status of the run or None if not available.
+        """
+        if not self.client:
+            return None
+
+        handle = self.client.get_workflow_handle(run_id)
+        desc = await handle.describe()
+        return desc.status.name
+
+    async def cancel(self, run_id: str) -> str | None:
+        """
+        Cancel a run.
+
+        Args:
+            run_id (str): The ID of the run to cancel.
+
+        Returns:
+            str | None: The ID of the canceled run or None if not available.
+        """
+        if not self.client:
+            return None
+
+        await self.client.cancel_workflow(run_id)
+
+    async def step(
+        self,
+        agent_state: AgentState,
+        actor: User,
+        input_messages: list[MessageCreate],
+        max_steps: int = DEFAULT_MAX_STEPS,
+        run_id: str | None = None,
+        use_assistant_message: bool = True,
+        include_return_message_types: list[MessageType] | None = None,
+        request_start_timestamp_ns: int | None = None,
+    ) -> str | None:
+        """
+        Execute the agent loop on temporal.
+
+        Args:
+            agent_state (AgentState): The state of the agent.
+            actor (User): The actor.
+            input_messages (list[MessageCreate]): The input messages.
+            max_steps (int, optional): The maximum number of steps. Defaults to DEFAULT_MAX_STEPS.
+            run_id (str | None, optional): The ID of the run. Defaults to None.
+            use_assistant_message (bool, optional): Whether to use the assistant message. Defaults to True.
+            include_return_message_types (list[MessageType] | None, optional): The message types to include in the return. Defaults to None.
+            request_start_timestamp_ns (int | None, optional): The start timestamp of the request. Defaults to None.
+
+        Returns:
+            str | None: The ID of the run or None if client is not available.
+        """
+        if not self.client:
+            return None
+
+        workflow_input = WorkflowInputParams(
+            agent_state=agent_state,
+            messages=input_messages,
+            actor=actor,
+            max_steps=max_steps,
+            run_id=run_id,
+        )
+
+        #
+        custom_search_attributes = []
+        if not self.temporal_skip_custom_sa:
+            organization_id = actor.organization_id
+            user_id = actor.id
+            agent_id = agent_state.id
+            custom_search_attributes = [
+                SearchAttributePair(SearchAttributeKey.for_keyword("OrganizationId"), organization_id),
+                SearchAttributePair(SearchAttributeKey.for_keyword("AgentId"), agent_id),
+                SearchAttributePair(SearchAttributeKey.for_keyword("UserId"), user_id),
+            ]
+
+        await self.client.start_workflow(
+            TemporalAgentWorkflow.run,
+            workflow_input,
+            id=run_id,
+            task_queue=self.temporal_task_queue,
+            search_attributes=TypedSearchAttributes(custom_search_attributes),
+        )
+
+        return run_id

letta/services/mcp/base_client.py

@@ -38,8 +38,8 @@ class AsyncBaseMCPClient:
             raise e
         except Exception as e:
             # MCP connection failures are often due to user misconfiguration, not system errors
-            # Log at info level to help with debugging without triggering Sentry alerts
-            logger.info(
+            # Log as warning for visibility in monitoring
+            logger.warning(
                 f"Connecting to MCP server failed. Please review your server config: {self.server_config.model_dump_json(indent=4)}. Error: {str(e)}"
             )
             if hasattr(self.server_config, "server_url") and self.server_config.server_url:
@@ -78,7 +78,13 @@ class AsyncBaseMCPClient:
 
     async def execute_tool(self, tool_name: str, tool_args: dict) -> Tuple[str, bool]:
         self._check_initialized()
-        result = await self.session.call_tool(tool_name, tool_args)
+        try:
+            result = await self.session.call_tool(tool_name, tool_args)
+        except Exception as e:
+            if e.__class__.__name__ == "McpError":
+                logger.warning(f"MCP tool '{tool_name}' execution failed: {str(e)}")
+            raise
+
         parsed_content = []
         for content_piece in result.content:
             if isinstance(content_piece, TextContent):