letta-nightly 0.12.1.dev20251024104217__py3-none-any.whl → 0.13.0.dev20251024223017__py3-none-any.whl

letta/groups/sleeptime_multi_agent_v3.py

@@ -1,13 +1,13 @@
-import asyncio
 from collections.abc import AsyncGenerator
 from datetime import datetime, timezone
 
 from letta.agents.letta_agent_v2 import LettaAgentV2
+from letta.agents.letta_agent_v3 import LettaAgentV3
 from letta.constants import DEFAULT_MAX_STEPS
 from letta.groups.helpers import stringify_message
 from letta.otel.tracing import trace_method
 from letta.schemas.agent import AgentState
-from letta.schemas.enums import JobStatus, RunStatus
+from letta.schemas.enums import RunStatus
 from letta.schemas.group import Group, ManagerType
 from letta.schemas.job import JobUpdate
 from letta.schemas.letta_message import MessageType
@@ -59,7 +59,7 @@ class SleeptimeMultiAgentV3(LettaAgentV2):
             request_start_timestamp_ns=request_start_timestamp_ns,
         )
 
-        await self.run_sleeptime_agents(use_assistant_message=use_assistant_message)
+        await self.run_sleeptime_agents()
 
         response.usage.run_ids = self.run_ids
         return response
@@ -92,10 +92,10 @@ class SleeptimeMultiAgentV3(LettaAgentV2):
         ):
             yield chunk
 
-        await self.run_sleeptime_agents(use_assistant_message=use_assistant_message)
+        await self.run_sleeptime_agents()
 
     @trace_method
-    async def run_sleeptime_agents(self, use_assistant_message: bool = True):
+    async def run_sleeptime_agents(self):
         # Get response messages
         last_response_messages = self.response_messages
 
@@ -117,7 +117,6 @@ class SleeptimeMultiAgentV3(LettaAgentV2):
                         sleeptime_agent_id,
                         last_response_messages,
                         last_processed_message_id,
-                        use_assistant_message,
                     )
                     self.run_ids.append(sleeptime_run_id)
                 except Exception as e:
@@ -131,7 +130,6 @@ class SleeptimeMultiAgentV3(LettaAgentV2):
         sleeptime_agent_id: str,
         response_messages: list[Message],
         last_processed_message_id: str,
-        use_assistant_message: bool = True,
     ) -> str:
         run = Run(
             agent_id=sleeptime_agent_id,
@@ -150,7 +148,6 @@ class SleeptimeMultiAgentV3(LettaAgentV2):
                 response_messages=response_messages,
                 last_processed_message_id=last_processed_message_id,
                 run_id=run.id,
-                use_assistant_message=use_assistant_message,
             ),
             label=f"participant_agent_step_{sleeptime_agent_id}",
         )
@@ -164,7 +161,6 @@ class SleeptimeMultiAgentV3(LettaAgentV2):
         response_messages: list[Message],
         last_processed_message_id: str,
         run_id: str,
-        use_assistant_message: bool = True,
     ) -> LettaResponse:
         try:
             # Update run status
@@ -200,7 +196,7 @@ class SleeptimeMultiAgentV3(LettaAgentV2):
 
             # Load sleeptime agent
             sleeptime_agent_state = await self.agent_manager.get_agent_by_id_async(agent_id=sleeptime_agent_id, actor=self.actor)
-            sleeptime_agent = LettaAgentV2(
+            sleeptime_agent = LettaAgentV3(
                 agent_state=sleeptime_agent_state,
                 actor=self.actor,
             )
@@ -209,7 +205,6 @@ class SleeptimeMultiAgentV3(LettaAgentV2):
             result = await sleeptime_agent.step(
                 input_messages=sleeptime_agent_messages,
                 run_id=run_id,
-                use_assistant_message=use_assistant_message,
             )
 
             # Update run status

letta/groups/sleeptime_multi_agent_v4.py

@@ -0,0 +1,227 @@
+import asyncio
+from collections.abc import AsyncGenerator
+from datetime import datetime, timezone
+
+from letta.agents.letta_agent_v3 import LettaAgentV3
+from letta.constants import DEFAULT_MAX_STEPS
+from letta.groups.helpers import stringify_message
+from letta.otel.tracing import trace_method
+from letta.schemas.agent import AgentState
+from letta.schemas.enums import JobStatus, RunStatus
+from letta.schemas.group import Group, ManagerType
+from letta.schemas.job import JobUpdate
+from letta.schemas.letta_message import MessageType
+from letta.schemas.letta_message_content import TextContent
+from letta.schemas.letta_response import LettaResponse
+from letta.schemas.message import Message, MessageCreate
+from letta.schemas.run import Run, RunUpdate
+from letta.schemas.user import User
+from letta.services.group_manager import GroupManager
+from letta.utils import safe_create_task
+
+
+class SleeptimeMultiAgentV4(LettaAgentV3):
+    def __init__(
+        self,
+        agent_state: AgentState,
+        actor: User,
+        group: Group,
+    ):
+        super().__init__(agent_state, actor)
+        assert group.manager_type == ManagerType.sleeptime, f"Expected group type to be 'sleeptime', got {group.manager_type}"
+        self.group = group
+        self.run_ids = []
+
+        # Additional manager classes
+        self.group_manager = GroupManager()
+
+    @trace_method
+    async def step(
+        self,
+        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,
+    ) -> LettaResponse:
+        self.run_ids = []
+
+        for i in range(len(input_messages)):
+            input_messages[i].group_id = self.group.id
+
+        response = await super().step(
+            input_messages=input_messages,
+            max_steps=max_steps,
+            run_id=run_id,
+            use_assistant_message=use_assistant_message,
+            include_return_message_types=include_return_message_types,
+            request_start_timestamp_ns=request_start_timestamp_ns,
+        )
+
+        await self.run_sleeptime_agents()
+        response.usage.run_ids = self.run_ids
+        return response
+
+    @trace_method
+    async def stream(
+        self,
+        input_messages: list[MessageCreate],
+        max_steps: int = DEFAULT_MAX_STEPS,
+        stream_tokens: bool = True,
+        run_id: str | None = None,
+        use_assistant_message: bool = True,
+        request_start_timestamp_ns: int | None = None,
+        include_return_message_types: list[MessageType] | None = None,
+    ) -> AsyncGenerator[str, None]:
+        self.run_ids = []
+
+        for i in range(len(input_messages)):
+            input_messages[i].group_id = self.group.id
+
+        # Perform foreground agent step
+        async for chunk in super().stream(
+            input_messages=input_messages,
+            max_steps=max_steps,
+            stream_tokens=stream_tokens,
+            run_id=run_id,
+            use_assistant_message=use_assistant_message,
+            include_return_message_types=include_return_message_types,
+            request_start_timestamp_ns=request_start_timestamp_ns,
+        ):
+            yield chunk
+
+        await self.run_sleeptime_agents()
+
+    @trace_method
+    async def run_sleeptime_agents(self):
+        # Get response messages
+        last_response_messages = self.response_messages
+
+        # Update turns counter
+        turns_counter = None
+        if self.group.sleeptime_agent_frequency is not None and self.group.sleeptime_agent_frequency > 0:
+            turns_counter = await self.group_manager.bump_turns_counter_async(group_id=self.group.id, actor=self.actor)
+
+        # Perform participant steps
+        if self.group.sleeptime_agent_frequency is None or (
+            turns_counter is not None and turns_counter % self.group.sleeptime_agent_frequency == 0
+        ):
+            last_processed_message_id = await self.group_manager.get_last_processed_message_id_and_update_async(
+                group_id=self.group.id, last_processed_message_id=last_response_messages[-1].id, actor=self.actor
+            )
+            for sleeptime_agent_id in self.group.agent_ids:
+                try:
+                    sleeptime_run_id = await self._issue_background_task(
+                        sleeptime_agent_id,
+                        last_response_messages,
+                        last_processed_message_id,
+                    )
+                    self.run_ids.append(sleeptime_run_id)
+                except Exception as e:
+                    # Individual task failures
+                    print(f"Sleeptime agent processing failed: {e!s}")
+                    raise e
+
+    @trace_method
+    async def _issue_background_task(
+        self,
+        sleeptime_agent_id: str,
+        response_messages: list[Message],
+        last_processed_message_id: str,
+    ) -> str:
+        run = Run(
+            agent_id=sleeptime_agent_id,
+            status=RunStatus.created,
+            metadata={
+                "run_type": "sleeptime_agent_send_message_async",  # is this right?
+                "agent_id": sleeptime_agent_id,
+            },
+        )
+        run = await self.run_manager.create_run(pydantic_run=run, actor=self.actor)
+
+        safe_create_task(
+            self._participant_agent_step(
+                foreground_agent_id=self.agent_state.id,
+                sleeptime_agent_id=sleeptime_agent_id,
+                response_messages=response_messages,
+                last_processed_message_id=last_processed_message_id,
+                run_id=run.id,
+            ),
+            label=f"participant_agent_step_{sleeptime_agent_id}",
+        )
+        return run.id
+
+    @trace_method
+    async def _participant_agent_step(
+        self,
+        foreground_agent_id: str,
+        sleeptime_agent_id: str,
+        response_messages: list[Message],
+        last_processed_message_id: str,
+        run_id: str,
+    ) -> LettaResponse:
+        try:
+            # Update run status
+            run_update = RunUpdate(status=RunStatus.running)
+            await self.run_manager.update_run_by_id_async(run_id=run_id, update=run_update, actor=self.actor)
+
+            # Create conversation transcript
+            prior_messages = []
+            if self.group.sleeptime_agent_frequency:
+                try:
+                    prior_messages = await self.message_manager.list_messages(
+                        agent_id=foreground_agent_id,
+                        actor=self.actor,
+                        after=last_processed_message_id,
+                        before=response_messages[0].id,
+                    )
+                except Exception:
+                    pass  # continue with just latest messages
+
+            transcript_summary = [stringify_message(message) for message in prior_messages + response_messages]
+            transcript_summary = [summary for summary in transcript_summary if summary is not None]
+            message_text = "\n".join(transcript_summary)
+
+            sleeptime_agent_messages = [
+                MessageCreate(
+                    role="user",
+                    content=[TextContent(text=message_text)],
+                    id=Message.generate_id(),
+                    agent_id=sleeptime_agent_id,
+                    group_id=self.group.id,
+                )
+            ]
+
+            # Load sleeptime agent
+            sleeptime_agent_state = await self.agent_manager.get_agent_by_id_async(agent_id=sleeptime_agent_id, actor=self.actor)
+            sleeptime_agent = LettaAgentV3(
+                agent_state=sleeptime_agent_state,
+                actor=self.actor,
+            )
+
+            # Perform sleeptime agent step
+            result = await sleeptime_agent.step(
+                input_messages=sleeptime_agent_messages,
+                run_id=run_id,
+            )
+
+            # Update run status
+            run_update = RunUpdate(
+                status=RunStatus.completed,
+                completed_at=datetime.now(timezone.utc).replace(tzinfo=None),
+                metadata={
+                    "result": result.model_dump(mode="json"),
+                    "agent_id": sleeptime_agent_state.id,
+                },
+            )
+            await self.run_manager.update_run_by_id_async(run_id=run_id, update=run_update, actor=self.actor)
+            return result
+        except Exception as e:
+            run_update = RunUpdate(
+                status=RunStatus.failed,
+                completed_at=datetime.now(timezone.utc).replace(tzinfo=None),
+                metadata={"error": str(e)},
+            )
+            await self.run_manager.update_run_by_id_async(run_id=run_id, update=run_update, actor=self.actor)
+            raise

letta/helpers/converters.py

@@ -8,6 +8,7 @@ from sqlalchemy import Dialect
 from letta.functions.mcp_client.types import StdioServerConfig
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import ProviderType, ToolRuleType
+from letta.schemas.letta_message import ApprovalReturn, MessageReturnType
 from letta.schemas.letta_message_content import (
     ImageContent,
     ImageSourceType,
@@ -180,6 +181,7 @@ def deserialize_tool_calls(data: Optional[List[Dict]]) -> List[OpenAIToolCall]:
 
     calls = []
     for item in data:
+        item.pop("requires_approval", None)  # legacy field
         func_data = item.pop("function", None)
         tool_call_function = OpenAIFunction(**func_data)
         calls.append(OpenAIToolCall(function=tool_call_function, **item))
@@ -222,6 +224,49 @@ def deserialize_tool_returns(data: Optional[List[Dict]]) -> List[ToolReturn]:
     return tool_returns
 
 
+# --------------------------
+# Approvals Serialization
+# --------------------------
+
+
+def serialize_approvals(approvals: Optional[List[Union[ApprovalReturn, ToolReturn, dict]]]) -> List[Dict]:
+    """Convert a list of ToolReturn objects into JSON-serializable format."""
+    if not approvals:
+        return []
+
+    serialized_approvals = []
+    for approval in approvals:
+        if isinstance(approval, ApprovalReturn):
+            serialized_approvals.append(approval.model_dump(mode="json"))
+        elif isinstance(approval, ToolReturn):
+            serialized_approvals.append(approval.model_dump(mode="json"))
+        elif isinstance(approval, dict):
+            serialized_approvals.append(approval)  # Already a dictionary, leave it as-is
+        else:
+            raise TypeError(f"Unexpected approval type: {type(approval)}")
+
+    return serialized_approvals
+
+
+def deserialize_approvals(data: Optional[List[Dict]]) -> List[Union[ApprovalReturn, ToolReturn]]:
+    """Convert a JSON list back into ApprovalReturn and ToolReturn objects."""
+    if not data:
+        return []
+
+    approvals = []
+    for item in data:
+        if "type" in item and item.get("type") == MessageReturnType.approval:
+            approval_return = ApprovalReturn(**item)
+            approvals.append(approval_return)
+        elif "status" in item:
+            tool_return = ToolReturn(**item)
+            approvals.append(tool_return)
+        else:
+            continue
+
+    return approvals
+
+
 # ----------------------------
 # MessageContent Serialization
 # ----------------------------
@@ -459,14 +504,43 @@ def deserialize_response_format(data: Optional[Dict]) -> Optional[ResponseFormat
 
 
 def serialize_mcp_stdio_config(config: Union[Optional[StdioServerConfig], Dict]) -> Optional[Dict]:
-    """Convert an StdioServerConfig object into a JSON-serializable dictionary."""
+    """Convert an StdioServerConfig object into a JSON-serializable dictionary.
+
+    Persist required fields for successful deserialization back into a
+    StdioServerConfig model (namely `server_name` and `type`). The
+    `to_dict()` helper intentionally omits these since they're not needed
+    by MCP transport, but our ORM deserializer reconstructs the pydantic
+    model and requires them.
+    """
     if config and isinstance(config, StdioServerConfig):
-        return config.to_dict()
+        data = config.to_dict()
+        # Preserve required fields for pydantic reconstruction
+        data["server_name"] = config.server_name
+        # Store enum as its value; pydantic will coerce on load
+        data["type"] = config.type.value if hasattr(config.type, "value") else str(config.type)
+        return data
     return config
 
 
 def deserialize_mcp_stdio_config(data: Optional[Dict]) -> Optional[StdioServerConfig]:
-    """Convert a dictionary back into an StdioServerConfig object."""
+    """Convert a dictionary back into an StdioServerConfig object.
+
+    Backwards-compatibility notes:
+    - Older rows may only include `transport`, `command`, `args`, `env`.
+      In that case, provide defaults for `server_name` and `type` to
+      satisfy the pydantic model requirements.
+    - If both `type` and `transport` are present, prefer `type`.
+    """
     if not data:
         return None
-    return StdioServerConfig(**data)
+
+    payload = dict(data)
+    # Map legacy `transport` field to required `type` if missing
+    if "type" not in payload and "transport" in payload:
+        payload["type"] = payload["transport"]
+
+    # Ensure required field exists; use a sensible placeholder when unknown
+    if "server_name" not in payload:
+        payload["server_name"] = payload.get("name", "unknown")
+
+    return StdioServerConfig(**payload)

letta/helpers/crypto_utils.py

@@ -47,7 +47,9 @@ class CryptoUtils:
             master_key = settings.encryption_key
 
         if not master_key:
-            raise ValueError("No encryption key configured. Set LETTA_ENCRYPTION_KEY environment variable.")
+            raise ValueError(
+                "No encryption key configured. Please set the LETTA_ENCRYPTION_KEY environment variable (not fully supported yet for Letta v0.12.1 and below)."
+            )
 
         # Generate random salt and IV
         salt = os.urandom(cls.SALT_SIZE)
@@ -91,7 +93,9 @@ class CryptoUtils:
             master_key = settings.encryption_key
 
         if not master_key:
-            raise ValueError("No encryption key configured. Set LETTA_ENCRYPTION_KEY environment variable.")
+            raise ValueError(
+                "No encryption key configured. Please set the LETTA_ENCRYPTION_KEY environment variable (not fully supported yet for Letta v0.12.1 and below)."
+            )
 
         try:
             # Decode from base64

letta/interfaces/anthropic_parallel_tool_call_streaming_interface.py

@@ -39,6 +39,7 @@ from letta.schemas.letta_stop_reason import LettaStopReason, StopReasonType
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_response import FunctionCall, ToolCall
 from letta.server.rest_api.json_parser import JSONParser, PydanticJSONParser
+from letta.server.rest_api.utils import decrement_message_uuid
 
 logger = get_logger(__name__)
 
@@ -282,14 +283,12 @@ class SimpleAnthropicStreamingInterface:
                 call_id = content.id
                 # Initialize arguments from the start event's input (often {}) to avoid undefined in UIs
                 if name in self.requires_approval_tools:
-                    if prev_message_type and prev_message_type != "approval_request_message":
-                        message_index += 1
                     tool_call_msg = ApprovalRequestMessage(
-                        id=self.letta_message_id,
+                        id=decrement_message_uuid(self.letta_message_id),
                         # Do not emit placeholder arguments here to avoid UI duplicates
                         tool_call=ToolCallDelta(name=name, tool_call_id=call_id),
                         date=datetime.now(timezone.utc).isoformat(),
-                        otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                        otid=Message.generate_otid_from_id(decrement_message_uuid(self.letta_message_id), -1),
                         run_id=self.run_id,
                         step_id=self.step_id,
                     )
@@ -300,12 +299,13 @@ class SimpleAnthropicStreamingInterface:
                         id=self.letta_message_id,
                         # Do not emit placeholder arguments here to avoid UI duplicates
                         tool_call=ToolCallDelta(name=name, tool_call_id=call_id),
+                        tool_calls=ToolCallDelta(name=name, tool_call_id=call_id),
                         date=datetime.now(timezone.utc).isoformat(),
                         otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                         run_id=self.run_id,
                         step_id=self.step_id,
                     )
-                prev_message_type = tool_call_msg.message_type
+                    prev_message_type = tool_call_msg.message_type
                 yield tool_call_msg
 
             elif isinstance(content, BetaThinkingBlock):
@@ -345,7 +345,6 @@ class SimpleAnthropicStreamingInterface:
 
                 assistant_msg = AssistantMessage(
                     id=self.letta_message_id,
-                    # content=[TextContent(text=delta.text)],
                     content=delta.text,
                     date=datetime.now(timezone.utc).isoformat(),
                     otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
@@ -381,13 +380,11 @@ class SimpleAnthropicStreamingInterface:
                 call_id = ctx.get("id")
 
                 if name in self.requires_approval_tools:
-                    if prev_message_type and prev_message_type != "approval_request_message":
-                        message_index += 1
                     tool_call_msg = ApprovalRequestMessage(
-                        id=self.letta_message_id,
+                        id=decrement_message_uuid(self.letta_message_id),
                         tool_call=ToolCallDelta(name=name, tool_call_id=call_id, arguments=delta.partial_json),
                         date=datetime.now(timezone.utc).isoformat(),
-                        otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                        otid=Message.generate_otid_from_id(decrement_message_uuid(self.letta_message_id), -1),
                         run_id=self.run_id,
                         step_id=self.step_id,
                     )
@@ -397,12 +394,13 @@ class SimpleAnthropicStreamingInterface:
                     tool_call_msg = ToolCallMessage(
                         id=self.letta_message_id,
                         tool_call=ToolCallDelta(name=name, tool_call_id=call_id, arguments=delta.partial_json),
+                        tool_calls=ToolCallDelta(name=name, tool_call_id=call_id, arguments=delta.partial_json),
                         date=datetime.now(timezone.utc).isoformat(),
                         otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                         run_id=self.run_id,
                         step_id=self.step_id,
                     )
-
+                    prev_message_type = tool_call_msg.message_type
                 yield tool_call_msg
 
             elif isinstance(delta, BetaThinkingDelta):

letta/interfaces/anthropic_streaming_interface.py

@@ -235,7 +235,7 @@ class AnthropicStreamingInterface:
         except Exception as e:
             import traceback
 
-            logger.error("Error processing stream: %s\n%s", e, traceback.format_exc())
+            logger.exception("Error processing stream: %s", e)
             if ttft_span:
                 ttft_span.add_event(
                     name="stop_reason",
@@ -454,7 +454,7 @@ class AnthropicStreamingInterface:
                             message_index += 1
                         assistant_msg = AssistantMessage(
                             id=self.letta_message_id,
-                            content=[TextContent(text=send_message_diff)],
+                            content=send_message_diff,
                             date=datetime.now(timezone.utc).isoformat(),
                             otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                             run_id=self.run_id,
@@ -734,7 +734,7 @@ class SimpleAnthropicStreamingInterface:
         except Exception as e:
             import traceback
 
-            logger.error("Error processing stream: %s\n%s", e, traceback.format_exc())
+            logger.exception("Error processing stream: %s", e)
             if ttft_span:
                 ttft_span.add_event(
                     name="stop_reason",
@@ -836,7 +836,6 @@ class SimpleAnthropicStreamingInterface:
 
                 assistant_msg = AssistantMessage(
                     id=self.letta_message_id,
-                    # content=[TextContent(text=delta.text)],
                     content=delta.text,
                     date=datetime.now(timezone.utc).isoformat(),
                     otid=Message.generate_otid_from_id(self.letta_message_id, message_index),

letta/interfaces/gemini_streaming_interface.py

@@ -26,6 +26,7 @@ from letta.schemas.letta_message_content import (
 from letta.schemas.letta_stop_reason import LettaStopReason, StopReasonType
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_response import FunctionCall, ToolCall
+from letta.server.rest_api.utils import decrement_message_uuid
 from letta.utils import get_tool_call_id
 
 logger = get_logger(__name__)
@@ -138,7 +139,7 @@ class SimpleGeminiStreamingInterface:
         except Exception as e:
             import traceback
 
-            logger.error("Error processing stream: %s\n%s", e, traceback.format_exc())
+            logger.exception("Error processing stream: %s", e)
             if ttft_span:
                 ttft_span.add_event(
                     name="stop_reason",
@@ -255,11 +256,9 @@ class SimpleGeminiStreamingInterface:
                 self.tool_call_args = arguments
 
                 if self.tool_call_name and self.tool_call_name in self.requires_approval_tools:
-                    if prev_message_type and prev_message_type != "approval_request_message":
-                        message_index += 1
                     yield ApprovalRequestMessage(
-                        id=self.letta_message_id,
-                        otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                        id=decrement_message_uuid(self.letta_message_id),
+                        otid=Message.generate_otid_from_id(decrement_message_uuid(self.letta_message_id), -1),
                         date=datetime.now(timezone.utc),
                         tool_call=ToolCallDelta(
                             name=name,
@@ -269,7 +268,6 @@ class SimpleGeminiStreamingInterface:
                         run_id=self.run_id,
                         step_id=self.step_id,
                     )
-                    prev_message_type = "approval_request_message"
                 else:
                     if prev_message_type and prev_message_type != "tool_call_message":
                         message_index += 1