letta-nightly 0.6.48.dev20250406104033__py3-none-any.whl → 0.6.49.dev20250408030511__py3-none-any.whl

letta/functions/mcp_client/base_client.py

@@ -2,6 +2,7 @@ import asyncio
 from typing import List, Optional, Tuple
 
 from mcp import ClientSession
+from mcp.types import TextContent
 
 from letta.functions.mcp_client.exceptions import MCPTimeoutError
 from letta.functions.mcp_client.types import BaseServerConfig, MCPTool
@@ -60,7 +61,23 @@ class BaseMCPClient:
             result = self.loop.run_until_complete(
                 asyncio.wait_for(self.session.call_tool(tool_name, tool_args), timeout=tool_settings.mcp_execute_tool_timeout)
             )
-            return str(result.content), result.isError
+
+            parsed_content = []
+            for content_piece in result.content:
+                if isinstance(content_piece, TextContent):
+                    parsed_content.append(content_piece.text)
+                    print("parsed_content (text)", parsed_content)
+                else:
+                    parsed_content.append(str(content_piece))
+                    print("parsed_content (other)", parsed_content)
+
+            if len(parsed_content) > 0:
+                final_content = " ".join(parsed_content)
+            else:
+                # TODO move hardcoding to constants
+                final_content = "Empty response from tool"
+
+            return final_content, result.isError
         except asyncio.TimeoutError:
             logger.error(
                 f"Timed out while executing tool '{tool_name}' for MCP server {self.server_config.server_name} (timeout={tool_settings.mcp_execute_tool_timeout}s)."

letta/{dynamic_multi_agent.py → groups/dynamic_multi_agent.py}

@@ -99,6 +99,7 @@ class DynamicMultiAgent(Agent):
                             tool_calls=None,
                             tool_call_id=None,
                             group_id=self.group_id,
+                            otid=message.otid,
                         )
                     )
 
@@ -125,6 +126,7 @@ class DynamicMultiAgent(Agent):
                         role="system",
                         content=message.content,
                         name=participant_agent.agent_state.name,
+                        otid=message.otid,
                     )
                     for message in assistant_messages
                 ]
@@ -271,4 +273,5 @@ class DynamicMultiAgent(Agent):
             tool_calls=None,
             tool_call_id=None,
             group_id=self.group_id,
+            otid=Message.generate_otid(),
         )

letta/groups/helpers.py

@@ -0,0 +1,113 @@
+import json
+from typing import Dict, Optional, Union
+
+from letta.agent import Agent
+from letta.functions.mcp_client.base_client import BaseMCPClient
+from letta.interface import AgentInterface
+from letta.orm.group import Group
+from letta.orm.user import User
+from letta.schemas.agent import AgentState
+from letta.schemas.group import ManagerType
+from letta.schemas.message import Message
+
+
+def load_multi_agent(
+    group: Group,
+    agent_state: Optional[AgentState],
+    actor: User,
+    interface: Union[AgentInterface, None] = None,
+    mcp_clients: Optional[Dict[str, BaseMCPClient]] = None,
+) -> Agent:
+    if len(group.agent_ids) == 0:
+        raise ValueError("Empty group: group must have at least one agent")
+
+    if not agent_state:
+        raise ValueError("Empty manager agent state: manager agent state must be provided")
+
+    match group.manager_type:
+        case ManagerType.round_robin:
+            from letta.groups.round_robin_multi_agent import RoundRobinMultiAgent
+
+            return RoundRobinMultiAgent(
+                agent_state=agent_state,
+                interface=interface,
+                user=actor,
+                group_id=group.id,
+                agent_ids=group.agent_ids,
+                description=group.description,
+                max_turns=group.max_turns,
+            )
+        case ManagerType.dynamic:
+            from letta.groups.dynamic_multi_agent import DynamicMultiAgent
+
+            return DynamicMultiAgent(
+                agent_state=agent_state,
+                interface=interface,
+                user=actor,
+                group_id=group.id,
+                agent_ids=group.agent_ids,
+                description=group.description,
+                max_turns=group.max_turns,
+                termination_token=group.termination_token,
+            )
+        case ManagerType.supervisor:
+            from letta.groups.supervisor_multi_agent import SupervisorMultiAgent
+
+            return SupervisorMultiAgent(
+                agent_state=agent_state,
+                interface=interface,
+                user=actor,
+                group_id=group.id,
+                agent_ids=group.agent_ids,
+                description=group.description,
+            )
+        case ManagerType.sleeptime:
+            if not agent_state.enable_sleeptime:
+                return Agent(
+                    agent_state=agent_state,
+                    interface=interface,
+                    user=actor,
+                    mcp_clients=mcp_clients,
+                )
+
+            from letta.groups.sleeptime_multi_agent import SleeptimeMultiAgent
+
+            return SleeptimeMultiAgent(
+                agent_state=agent_state,
+                interface=interface,
+                user=actor,
+                group_id=group.id,
+                agent_ids=group.agent_ids,
+                description=group.description,
+                sleeptime_agent_frequency=group.sleeptime_agent_frequency,
+            )
+        case _:
+            raise ValueError(f"Type {group.manager_type} is not supported.")
+
+
+def stringify_message(message: Message, use_assistant_name: bool = False) -> str | None:
+    assistant_name = message.name or "assistant" if use_assistant_name else "assistant"
+    if message.role == "user":
+        content = json.loads(message.content[0].text)
+        if content["type"] == "user_message":
+            return f"{message.name or 'user'}: {content['message']}"
+        else:
+            return None
+    elif message.role == "assistant":
+        messages = []
+        if message.tool_calls:
+            if message.tool_calls[0].function.name == "send_message":
+                messages.append(f"{assistant_name}: {json.loads(message.tool_calls[0].function.arguments)['message']}")
+            else:
+                messages.append(f"{assistant_name}: Calling tool {message.tool_calls[0].function.name}")
+        return "\n".join(messages)
+    elif message.role == "tool":
+        if message.content:
+            content = json.loads(message.content[0].text)
+            if content["message"] != "None" and content["message"] != None:
+                return f"{assistant_name}: Tool call returned {content['message']}"
+        return None
+    elif message.role == "system":
+        return None
+    else:
+        return f"{message.name or 'user'}: {message.content[0].text}"

letta/{round_robin_multi_agent.py → groups/round_robin_multi_agent.py}

@@ -69,6 +69,7 @@ class RoundRobinMultiAgent(Agent):
                             tool_calls=None,
                             tool_call_id=None,
                             group_id=self.group_id,
+                            otid=message.otid,
                         )
                     )
 
@@ -92,6 +93,7 @@ class RoundRobinMultiAgent(Agent):
                         role="system",
                         content=message.content,
                         name=message.name,
+                        otid=message.otid,
                     )
                     for message in assistant_messages
                 ]

letta/groups/sleeptime_multi_agent.py

@@ -0,0 +1,259 @@
+import asyncio
+import threading
+from datetime import datetime
+from typing import List, Optional
+
+from letta.agent import Agent, AgentState
+from letta.groups.helpers import stringify_message
+from letta.interface import AgentInterface
+from letta.orm import User
+from letta.schemas.enums import JobStatus
+from letta.schemas.job import JobUpdate
+from letta.schemas.letta_message_content import TextContent
+from letta.schemas.message import Message, MessageCreate
+from letta.schemas.run import Run
+from letta.schemas.usage import LettaUsageStatistics
+from letta.server.rest_api.interface import StreamingServerInterface
+from letta.services.group_manager import GroupManager
+from letta.services.job_manager import JobManager
+from letta.services.message_manager import MessageManager
+
+
+class SleeptimeMultiAgent(Agent):
+
+    def __init__(
+        self,
+        interface: AgentInterface,
+        agent_state: AgentState,
+        user: User,
+        # custom
+        group_id: str = "",
+        agent_ids: List[str] = [],
+        description: str = "",
+        sleeptime_agent_frequency: Optional[int] = None,
+    ):
+        super().__init__(interface, agent_state, user)
+        self.group_id = group_id
+        self.agent_ids = agent_ids
+        self.description = description
+        self.sleeptime_agent_frequency = sleeptime_agent_frequency
+        self.group_manager = GroupManager()
+        self.message_manager = MessageManager()
+        self.job_manager = JobManager()
+
+    def _run_async_in_new_thread(self, coro):
+        """Run an async coroutine in a new thread with its own event loop"""
+        result = None
+
+        def run_async():
+            nonlocal result
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                result = loop.run_until_complete(coro)
+            finally:
+                loop.close()
+                asyncio.set_event_loop(None)
+
+        thread = threading.Thread(target=run_async)
+        thread.start()
+        thread.join()
+        return result
+
+    async def _issue_background_task(
+        self,
+        participant_agent_id: str,
+        messages: List[Message],
+        chaining: bool,
+        max_chaining_steps: Optional[int],
+        token_streaming: bool,
+        metadata: Optional[dict],
+        put_inner_thoughts_first: bool,
+        last_processed_message_id: str,
+    ) -> str:
+        run = Run(
+            user_id=self.user.id,
+            status=JobStatus.created,
+            metadata={
+                "job_type": "background_agent_send_message_async",
+                "agent_id": participant_agent_id,
+            },
+        )
+        run = self.job_manager.create_job(pydantic_job=run, actor=self.user)
+
+        asyncio.create_task(
+            self._perform_background_agent_step(
+                participant_agent_id=participant_agent_id,
+                messages=messages,
+                chaining=chaining,
+                max_chaining_steps=max_chaining_steps,
+                token_streaming=token_streaming,
+                metadata=metadata,
+                put_inner_thoughts_first=put_inner_thoughts_first,
+                last_processed_message_id=last_processed_message_id,
+                run_id=run.id,
+            )
+        )
+
+        return run.id
+
+    async def _perform_background_agent_step(
+        self,
+        participant_agent_id: str,
+        messages: List[Message],
+        chaining: bool,
+        max_chaining_steps: Optional[int],
+        token_streaming: bool,
+        metadata: Optional[dict],
+        put_inner_thoughts_first: bool,
+        last_processed_message_id: str,
+        run_id: str,
+    ) -> LettaUsageStatistics:
+        try:
+            participant_agent_state = self.agent_manager.get_agent_by_id(participant_agent_id, actor=self.user)
+            participant_agent = Agent(
+                agent_state=participant_agent_state,
+                interface=StreamingServerInterface(),
+                user=self.user,
+            )
+
+            prior_messages = []
+            if self.sleeptime_agent_frequency:
+                try:
+                    prior_messages = self.message_manager.list_messages_for_agent(
+                        agent_id=self.agent_state.id,
+                        actor=self.user,
+                        after=last_processed_message_id,
+                        before=messages[0].id,
+                    )
+                except Exception as e:
+                    print(f"Error fetching prior messages: {str(e)}")
+                    # continue with just latest messages
+
+            transcript_summary = [stringify_message(message) for message in prior_messages + messages]
+            transcript_summary = [summary for summary in transcript_summary if summary is not None]
+            message_text = "\n".join(transcript_summary)
+
+            participant_agent_messages = [
+                Message(
+                    id=Message.generate_id(),
+                    agent_id=participant_agent.agent_state.id,
+                    role="user",
+                    content=[TextContent(text=message_text)],
+                    group_id=self.group_id,
+                )
+            ]
+            result = participant_agent.step(
+                messages=participant_agent_messages,
+                chaining=chaining,
+                max_chaining_steps=max_chaining_steps,
+                stream=token_streaming,
+                skip_verify=True,
+                metadata=metadata,
+                put_inner_thoughts_first=put_inner_thoughts_first,
+            )
+            job_update = JobUpdate(
+                status=JobStatus.completed,
+                completed_at=datetime.utcnow(),
+                metadata={
+                    "result": result.model_dump(mode="json"),
+                    "agent_id": participant_agent.agent_state.id,
+                },
+            )
+            self.job_manager.update_job_by_id(job_id=run_id, job_update=job_update, actor=self.user)
+            return result
+        except Exception as e:
+            job_update = JobUpdate(
+                status=JobStatus.failed,
+                completed_at=datetime.utcnow(),
+                metadata={"error": str(e)},
+            )
+            self.job_manager.update_job_by_id(job_id=run_id, job_update=job_update, actor=self.user)
+            raise
+
+    def step(
+        self,
+        messages: List[MessageCreate],
+        chaining: bool = True,
+        max_chaining_steps: Optional[int] = None,
+        put_inner_thoughts_first: bool = True,
+        **kwargs,
+    ) -> LettaUsageStatistics:
+        run_ids = []
+
+        token_streaming = self.interface.streaming_mode if hasattr(self.interface, "streaming_mode") else False
+        metadata = self.interface.metadata if hasattr(self.interface, "metadata") else None
+
+        messages = [
+            Message(
+                id=Message.generate_id(),
+                agent_id=self.agent_state.id,
+                role=message.role,
+                content=[TextContent(text=message.content)] if isinstance(message.content, str) else message.content,
+                name=message.name,
+                model=None,
+                tool_calls=None,
+                tool_call_id=None,
+                group_id=self.group_id,
+                otid=message.otid,
+            )
+            for message in messages
+        ]
+
+        try:
+            main_agent = Agent(
+                agent_state=self.agent_state,
+                interface=self.interface,
+                user=self.user,
+            )
+            usage_stats = main_agent.step(
+                messages=messages,
+                chaining=chaining,
+                max_chaining_steps=max_chaining_steps,
+                stream=token_streaming,
+                skip_verify=True,
+                metadata=metadata,
+                put_inner_thoughts_first=put_inner_thoughts_first,
+            )
+
+            turns_counter = None
+            if self.sleeptime_agent_frequency is not None and self.sleeptime_agent_frequency > 0:
+                turns_counter = self.group_manager.bump_turns_counter(group_id=self.group_id, actor=self.user)
+
+            if self.sleeptime_agent_frequency is None or (
+                turns_counter is not None and turns_counter % self.sleeptime_agent_frequency == 0
+            ):
+                last_response_messages = [message for sublist in usage_stats.steps_messages for message in sublist]
+                last_processed_message_id = self.group_manager.get_last_processed_message_id_and_update(
+                    group_id=self.group_id, last_processed_message_id=last_response_messages[-1].id, actor=self.user
+                )
+                for participant_agent_id in self.agent_ids:
+                    try:
+                        run_id = self._run_async_in_new_thread(
+                            self._issue_background_task(
+                                participant_agent_id,
+                                last_response_messages,
+                                chaining,
+                                max_chaining_steps,
+                                token_streaming,
+                                metadata,
+                                put_inner_thoughts_first,
+                                last_processed_message_id,
+                            )
+                        )
+                        run_ids.append(run_id)
+
+                    except Exception as e:
+                        # Handle individual task failures
+                        print(f"Agent processing failed: {str(e)}")
+                        raise e
+
+        except Exception as e:
+            raise e
+        finally:
+            self.interface.step_yield()
+
+        self.interface.step_complete()
+
+        usage_stats.run_ids = run_ids
+        return LettaUsageStatistics(**usage_stats.model_dump())

letta/{supervisor_multi_agent.py → groups/supervisor_multi_agent.py}

@@ -89,6 +89,7 @@ class SupervisorMultiAgent(Agent):
                 tool_calls=None,
                 tool_call_id=None,
                 group_id=self.group_id,
+                otid=message.otid,
             )
             for message in messages
         ]

letta/helpers/converters.py

@@ -2,12 +2,14 @@ import base64
 from typing import Any, Dict, List, Optional, Union
 
 import numpy as np
+from anthropic.types.beta.messages import BetaMessageBatch, BetaMessageBatchIndividualResponse
 from openai.types.chat.chat_completion_message_tool_call import ChatCompletionMessageToolCall as OpenAIToolCall
 from openai.types.chat.chat_completion_message_tool_call import Function as OpenAIFunction
 from sqlalchemy import Dialect
 
+from letta.schemas.agent import AgentStepState
 from letta.schemas.embedding_config import EmbeddingConfig
-from letta.schemas.enums import ToolRuleType
+from letta.schemas.enums import ProviderType, ToolRuleType
 from letta.schemas.letta_message_content import (
     MessageContent,
     MessageContentType,
@@ -38,7 +40,7 @@ from letta.schemas.tool_rule import (
 def serialize_llm_config(config: Union[Optional[LLMConfig], Dict]) -> Optional[Dict]:
     """Convert an LLMConfig object into a JSON-serializable dictionary."""
     if config and isinstance(config, LLMConfig):
-        return config.model_dump()
+        return config.model_dump(mode="json")
     return config
 
 
@@ -55,7 +57,7 @@ def deserialize_llm_config(data: Optional[Dict]) -> Optional[LLMConfig]:
 def serialize_embedding_config(config: Union[Optional[EmbeddingConfig], Dict]) -> Optional[Dict]:
     """Convert an EmbeddingConfig object into a JSON-serializable dictionary."""
     if config and isinstance(config, EmbeddingConfig):
-        return config.model_dump()
+        return config.model_dump(mode="json")
     return config
 
 
@@ -75,7 +77,9 @@ def serialize_tool_rules(tool_rules: Optional[List[ToolRule]]) -> List[Dict[str,
     if not tool_rules:
         return []
 
-    data = [{**rule.model_dump(), "type": rule.type.value} for rule in tool_rules]  # Convert Enum to string for JSON compatibility
+    data = [
+        {**rule.model_dump(mode="json"), "type": rule.type.value} for rule in tool_rules
+    ]  # Convert Enum to string for JSON compatibility
 
     # Validate ToolRule structure
     for rule_data in data:
@@ -130,7 +134,7 @@ def serialize_tool_calls(tool_calls: Optional[List[Union[OpenAIToolCall, dict]]]
     serialized_calls = []
     for call in tool_calls:
         if isinstance(call, OpenAIToolCall):
-            serialized_calls.append(call.model_dump())
+            serialized_calls.append(call.model_dump(mode="json"))
         elif isinstance(call, dict):
             serialized_calls.append(call)  # Already a dictionary, leave it as-is
         else:
@@ -166,7 +170,7 @@ def serialize_tool_returns(tool_returns: Optional[List[Union[ToolReturn, dict]]]
     serialized_tool_returns = []
     for tool_return in tool_returns:
         if isinstance(tool_return, ToolReturn):
-            serialized_tool_returns.append(tool_return.model_dump())
+            serialized_tool_returns.append(tool_return.model_dump(mode="json"))
         elif isinstance(tool_return, dict):
             serialized_tool_returns.append(tool_return)  # Already a dictionary, leave it as-is
         else:
@@ -201,7 +205,7 @@ def serialize_message_content(message_content: Optional[List[Union[MessageConten
     serialized_message_content = []
     for content in message_content:
         if isinstance(content, MessageContent):
-            serialized_message_content.append(content.model_dump())
+            serialized_message_content.append(content.model_dump(mode="json"))
         elif isinstance(content, dict):
             serialized_message_content.append(content)  # Already a dictionary, leave it as-is
         else:
@@ -266,3 +270,101 @@ def deserialize_vector(data: Optional[bytes], dialect: Dialect) -> Optional[np.n
         data = base64.b64decode(data)
 
     return np.frombuffer(data, dtype=np.float32)
+
+
+# --------------------------
+# Batch Request Serialization
+# --------------------------
+
+
+def serialize_create_batch_response(create_batch_response: Union[BetaMessageBatch]) -> Dict[str, Any]:
+    """Convert a list of ToolRules into a JSON-serializable format."""
+    llm_provider_type = None
+    if isinstance(create_batch_response, BetaMessageBatch):
+        llm_provider_type = ProviderType.anthropic.value
+
+    if not llm_provider_type:
+        raise ValueError(f"Could not determine llm provider from create batch response object type: {create_batch_response}")
+
+    return {"data": create_batch_response.model_dump(mode="json"), "type": llm_provider_type}
+
+
+def deserialize_create_batch_response(data: Dict) -> Union[BetaMessageBatch]:
+    provider_type = ProviderType(data.get("type"))
+
+    if provider_type == ProviderType.anthropic:
+        return BetaMessageBatch(**data.get("data"))
+
+    raise ValueError(f"Unknown ProviderType type: {provider_type}")
+
+
+# TODO: Note that this is the same as above for Anthropic, but this is not the case for all providers
+# TODO: Some have different types based on the create v.s. poll requests
+def serialize_poll_batch_response(poll_batch_response: Optional[Union[BetaMessageBatch]]) -> Optional[Dict[str, Any]]:
+    """Convert a list of ToolRules into a JSON-serializable format."""
+    if not poll_batch_response:
+        return None
+
+    llm_provider_type = None
+    if isinstance(poll_batch_response, BetaMessageBatch):
+        llm_provider_type = ProviderType.anthropic.value
+
+    if not llm_provider_type:
+        raise ValueError(f"Could not determine llm provider from poll batch response object type: {poll_batch_response}")
+
+    return {"data": poll_batch_response.model_dump(mode="json"), "type": llm_provider_type}
+
+
+def deserialize_poll_batch_response(data: Optional[Dict]) -> Optional[Union[BetaMessageBatch]]:
+    if not data:
+        return None
+
+    provider_type = ProviderType(data.get("type"))
+
+    if provider_type == ProviderType.anthropic:
+        return BetaMessageBatch(**data.get("data"))
+
+    raise ValueError(f"Unknown ProviderType type: {provider_type}")
+
+
+def serialize_batch_request_result(
+    batch_individual_response: Optional[Union[BetaMessageBatchIndividualResponse]],
+) -> Optional[Dict[str, Any]]:
+    """Convert a list of ToolRules into a JSON-serializable format."""
+    if not batch_individual_response:
+        return None
+
+    llm_provider_type = None
+    if isinstance(batch_individual_response, BetaMessageBatchIndividualResponse):
+        llm_provider_type = ProviderType.anthropic.value
+
+    if not llm_provider_type:
+        raise ValueError(f"Could not determine llm provider from batch result object type: {batch_individual_response}")
+
+    return {"data": batch_individual_response.model_dump(mode="json"), "type": llm_provider_type}
+
+
+def deserialize_batch_request_result(data: Optional[Dict]) -> Optional[Union[BetaMessageBatchIndividualResponse]]:
+    if not data:
+        return None
+    provider_type = ProviderType(data.get("type"))
+
+    if provider_type == ProviderType.anthropic:
+        return BetaMessageBatchIndividualResponse(**data.get("data"))
+
+    raise ValueError(f"Unknown ProviderType type: {provider_type}")
+
+
+def serialize_agent_step_state(agent_step_state: Optional[AgentStepState]) -> Optional[Dict[str, Any]]:
+    """Convert a list of ToolRules into a JSON-serializable format."""
+    if not agent_step_state:
+        return None
+
+    return agent_step_state.model_dump(mode="json")
+
+
+def deserialize_agent_step_state(data: Optional[Dict]) -> Optional[AgentStepState]:
+    if not data:
+        return None
+
+    return AgentStepState(**data)

letta/helpers/message_helper.py

@@ -38,4 +38,5 @@ def prepare_input_message_create(
         model=None,  # assigned later?
         tool_calls=None,  # irrelevant
         tool_call_id=None,
+        otid=message.otid,
     )