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

letta/agents/temporal/types.py

@@ -0,0 +1,275 @@
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+from letta.helpers import ToolRulesSolver
+from letta.schemas.agent import AgentState
+from letta.schemas.enums import RunStatus
+from letta.schemas.letta_message import LettaMessageUnion, MessageType
+from letta.schemas.letta_message_content import (
+    OmittedReasoningContent,
+    ReasoningContent,
+    RedactedReasoningContent,
+    TextContent,
+)
+from letta.schemas.letta_stop_reason import LettaStopReason, StopReasonType
+from letta.schemas.message import Message, MessageCreate
+from letta.schemas.openai.chat_completion_response import ToolCall, UsageStatistics
+from letta.schemas.step import Step
+from letta.schemas.tool_execution_result import ToolExecutionResult
+from letta.schemas.usage import LettaUsageStatistics
+from letta.schemas.user import User
+
+
+@dataclass
+class WorkflowInputParams:
+    agent_state: AgentState
+    messages: list[MessageCreate]
+    actor: User
+    max_steps: int
+    run_id: str
+    use_assistant_message: bool = True
+    include_return_message_types: list[MessageType] | None = None
+
+
+@dataclass
+class PreparedMessages:
+    in_context_messages: List[Message]
+    input_messages_to_persist: List[Message]
+
+
+@dataclass
+class FinalResult:
+    messages: List[LettaMessageUnion]
+    stop_reason: str
+    usage: LettaUsageStatistics
+
+
+@dataclass
+class InnerStepResult:
+    """Result from a single inner_step execution."""
+
+    stop_reason: StopReasonType
+    usage: LettaUsageStatistics
+    should_continue: bool
+    response_messages: List[Message]
+    agent_state: AgentState
+
+
+# ===== Additional types for activities up to _handle_ai_response =====
+
+
+@dataclass
+class RefreshContextParams:
+    """Input to refresh_context_and_system_message activity.
+
+    - agent_state: Current agent state (memory, sources, tools, etc.)
+    - in_context_messages: Current message history to potentially rebuild/scrub
+    - actor: Requesting user (for DB access control)
+    """
+
+    agent_state: AgentState
+    in_context_messages: List[Message]
+    tool_rules_solver: ToolRulesSolver
+    actor: User
+
+
+@dataclass
+class RefreshContextResult:
+    """Output from refresh_context_and_system_message activity.
+
+    - messages: Updated in-context messages with refreshed system message
+    - agent_state: Updated agent state with refreshed memory
+    """
+
+    messages: List[Message]
+    agent_state: AgentState
+
+
+@dataclass
+class LLMRequestParams:
+    """Input to llm_request activity.
+
+    - agent_state: Needed primarily for llm_config (model, endpoint, etc.)
+    - messages: Full prompt messages (context + input + responses if any)
+    - allowed_tools: Tools JSON schema list after rules + strict mode + runtime overrides
+    - force_tool_call: Optional tool name to force call when only one valid tool exists
+    - requires_approval_tools: Optional list of tool names that require approval
+    - actor: Requesting user (for audit/tenant context)
+    - step_id: Current step id for tracing/telemetry correlation
+    - use_assistant_message: Whether to use assistant message format for responses
+    """
+
+    agent_state: AgentState
+    messages: List[Message]
+    allowed_tools: List[dict]
+    force_tool_call: Optional[str] = None
+    requires_approval_tools: Optional[List[str]] = None
+    actor: Optional[User] = None
+    step_id: Optional[str] = None
+    use_assistant_message: bool = True
+
+
+@dataclass
+class LLMCallResult:
+    """Output from llm_request activity.
+
+    - tool_call: Parsed tool call from LLM (None for stub/approval paths)
+    - reasoning_content: Optional reasoning/assistant content stream collected
+    - assistant_message_id: Optional precomputed assistant message id (if adapter sets)
+    - usage: Provider usage statistics for this call
+    - request_finish_ns: Provider request finish time (ns) for metrics, if available
+    - llm_request_start_ns: Start time of LLM request in nanoseconds
+    - llm_request_ns: Duration of LLM request in nanoseconds
+    """
+
+    tool_call: Optional[ToolCall]
+    reasoning_content: Optional[List[TextContent | ReasoningContent | RedactedReasoningContent | OmittedReasoningContent]]
+    assistant_message_id: Optional[str]
+    usage: UsageStatistics
+    request_finish_ns: Optional[int]
+    llm_request_start_ns: Optional[int] = None
+    llm_request_ns: Optional[int] = None
+
+
+@dataclass
+class SummarizeParams:
+    """Input to summarize_conversation_history activity.
+
+    - agent_state: Current agent state (summarizer config, ids)
+    - in_context_messages: Current context window
+    - new_letta_messages: Newly generated/persisted messages to consider
+    - actor: Requesting user
+    - force: Whether to force summarization + clear
+    """
+
+    agent_state: AgentState
+    in_context_messages: List[Message]
+    new_letta_messages: List[Message]
+    actor: User
+    force: bool = True
+
+
+# ===== Tool execution and message handling types =====
+
+
+@dataclass
+class ExecuteToolParams:
+    """Input to execute_tool_activity.
+
+    - tool_name: Name of the tool to execute
+    - tool_args: Arguments to pass to the tool
+    - agent_state: Current agent state containing tools and configuration
+    - actor: Requesting user for access control
+    - step_id: Current step ID for tracing
+    """
+
+    tool_name: str
+    tool_args: Dict
+    agent_state: AgentState
+    actor: User
+    step_id: Optional[str]
+
+
+@dataclass
+class ExecuteToolResult:
+    """Output from execute_tool_activity."""
+
+    tool_execution_result: ToolExecutionResult
+    execution_time_ns: int
+
+
+@dataclass
+class CreateStepParams:
+    """Input to create_step_activity."""
+
+    agent_state: AgentState
+    messages: List[Message]
+    actor: User
+    run_id: str
+    step_id: Optional[str]
+    usage: UsageStatistics
+    step_ns: Optional[int] = None
+    llm_request_ns: Optional[int] = None
+    tool_execution_ns: Optional[int] = None
+    stop_reason: Optional[str] = None
+
+
+@dataclass
+class CreateStepResult:
+    """Output from create_step_activity."""
+
+    step: Step
+
+
+@dataclass
+class CreateMessagesParams:
+    """Input to create_messages_activity.
+
+    Persists messages to the database.
+    """
+
+    messages: List[Message]
+    actor: User
+    project_id: Optional[str]
+    template_id: Optional[str]
+
+
+@dataclass
+class CreateMessagesResult:
+    """Output from create_messages_activity."""
+
+    messages: List[Message]
+
+
+@dataclass
+class PersistMessagesParams:
+    """Input to persist_messages_activity.
+
+    Persists messages to database and optionally updates job messages.
+    """
+
+    messages: List[Message]
+    actor: User
+    project_id: Optional[str]
+    template_id: Optional[str]
+    run_id: Optional[str]
+
+
+@dataclass
+class PersistMessagesResult:
+    """Output from persist_messages_activity."""
+
+
+@dataclass
+class UpdateRunParams:
+    """Input to update_run_activity."""
+
+    run_id: str
+    actor: User
+    run_status: RunStatus
+    stop_reason: LettaStopReason | None
+    persisted_messages: List[Message]
+    usage: LettaUsageStatistics
+    total_duration_ns: int | None
+
+
+@dataclass
+class UpdateMessageIdsParams:
+    """Input to update_message_ids_activity.
+
+    Updates the agent's message IDs in the database.
+    Used for immediate approval persistence to prevent bad state.
+    """
+
+    agent_id: str
+    message_ids: List[str]
+    actor: User
+
+
+@dataclass
+class UpdateMessageIdsResult:
+    """Output from update_message_ids_activity."""
+
+    success: bool
+    agent_state: AgentState
+    persisted_messages: List[Message]

letta/constants.py

@@ -51,6 +51,11 @@ DEFAULT_MAX_STEPS = 50
 MIN_CONTEXT_WINDOW = 4096
 DEFAULT_CONTEXT_WINDOW = 32000
 
+# Summarization trigger threshold (multiplier of context_window limit)
+# Summarization triggers when step usage > context_window * SUMMARIZATION_TRIGGER_MULTIPLIER
+# Set to 0.9 (90%) to provide buffer before hitting hard limit
+SUMMARIZATION_TRIGGER_MULTIPLIER = 0.9
+
 # number of concurrent embedding requests to sent
 EMBEDDING_BATCH_SIZE = 200
 
@@ -373,6 +378,9 @@ FUNCTION_RETURN_CHAR_LIMIT = 50000  # ~300 words
 BASE_FUNCTION_RETURN_CHAR_LIMIT = 50000  # same as regular function limit
 FILE_IS_TRUNCATED_WARNING = "# NOTE: This block is truncated, use functions to view the full content."
 
+# Tool return truncation limit for LLM context window management
+TOOL_RETURN_TRUNCATION_CHARS = 5000
+
 MAX_PAUSE_HEARTBEATS = 360  # in min
 
 MESSAGE_CHATGPT_FUNCTION_MODEL = "gpt-3.5-turbo"

letta/errors.py

@@ -202,6 +202,10 @@ class LLMTimeoutError(LLMError):
     """Error when LLM request times out"""
 
 
+class LLMProviderOverloaded(LLMError):
+    """Error when LLM provider is overloaded"""
+
+
 class BedrockPermissionError(LettaError):
     """Exception raised for errors in the Bedrock permission process."""
 

letta/functions/function_sets/base.py

@@ -24,7 +24,6 @@ def memory(
 
     Args:
         command (str): The sub-command to execute. Supported commands:
-            - "view": List memory blocks or view specific block content
             - "create": Create a new memory block
             - "str_replace": Replace text in a memory block
             - "insert": Insert text at a specific line in a memory block
@@ -39,21 +38,11 @@ def memory(
         insert_text (Optional[str]): Text to insert (for insert)
         old_path (Optional[str]): Old path for rename operation
         new_path (Optional[str]): New path for rename operation
-        view_range (Optional[int]): Range of lines to view (for view)
 
     Returns:
         Optional[str]: Success message or error description
 
     Examples:
-        # List all memory blocks
-        memory(agent_state, "view", path="/memories")
-
-        # View specific memory block content
-        memory(agent_state, "view", path="/memories/user_preferences")
-
-        # View first 10 lines of a memory block
-        memory(agent_state, "view", path="/memories/user_preferences", view_range=10)
-
         # Replace text in a memory block
         memory(agent_state, "str_replace", path="/memories/user_preferences", old_str="theme: dark", new_str="theme: light")
 

letta/groups/helpers.py

@@ -6,7 +6,7 @@ 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.letta_message_content import ImageContent, TextContent
+from letta.schemas.letta_message_content import ImageContent, ReasoningContent, TextContent
 from letta.schemas.message import Message
 from letta.services.mcp.base_client import AsyncBaseMCPClient
 
@@ -100,6 +100,12 @@ def stringify_message(message: Message, use_assistant_name: bool = False) -> str
             return f"{message.name or 'user'}: {message.content[0].text}"
     elif message.role == "assistant":
         messages = []
+        if message.content:
+            for content in message.content:
+                if isinstance(content, TextContent):
+                    messages.append(f"{assistant_name}: {content.text}")
+                elif isinstance(content, ReasoningContent):
+                    messages.append(f"{assistant_name}: *thinking* {content.reasoning}")
         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']}")

letta/groups/sleeptime_multi_agent_v4.py

@@ -59,8 +59,8 @@ class SleeptimeMultiAgentV4(LettaAgentV3):
             request_start_timestamp_ns=request_start_timestamp_ns,
         )
 
-        await self.run_sleeptime_agents()
-        response.usage.run_ids = self.run_ids
+        run_ids = await self.run_sleeptime_agents()
+        response.usage.run_ids = run_ids
         return response
 
     @trace_method
@@ -94,7 +94,7 @@ class SleeptimeMultiAgentV4(LettaAgentV3):
         await self.run_sleeptime_agents()
 
     @trace_method
-    async def run_sleeptime_agents(self):
+    async def run_sleeptime_agents(self) -> list[str]:
         # Get response messages
         last_response_messages = self.response_messages
 
@@ -122,6 +122,7 @@ class SleeptimeMultiAgentV4(LettaAgentV3):
                     # Individual task failures
                     print(f"Sleeptime agent processing failed: {e!s}")
                     raise e
+            return self.run_ids
 
     @trace_method
     async def _issue_background_task(

letta/interfaces/anthropic_streaming_interface.py

@@ -23,7 +23,6 @@ from anthropic.types.beta import (
     BetaThinkingDelta,
     BetaToolUseBlock,
 )
-from letta_client.types import assistant_message
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG

letta/interfaces/openai_streaming_interface.py

@@ -6,6 +6,7 @@ from typing import Optional
 from openai import AsyncStream
 from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
 from openai.types.responses import (
+    ParsedResponse,
     ResponseCompletedEvent,
     ResponseContentPartAddedEvent,
     ResponseContentPartDoneEvent,
@@ -524,10 +525,9 @@ class SimpleOpenAIStreamingInterface:
         self.messages = messages or []
         self.tools = tools or []
 
-        # Buffers to hold accumulating tools
-        self.tool_call_name = ""
-        self.tool_call_args = ""
-        self.tool_call_id = ""
+        # Accumulate per-index tool call fragments and preserve order
+        self._tool_calls_acc: dict[int, dict[str, str]] = {}
+        self._tool_call_start_order: list[int] = []
 
         self.content_messages = []
         self.emitted_hidden_reasoning = False  # Track if we've emitted hidden reasoning message
@@ -561,19 +561,27 @@ class SimpleOpenAIStreamingInterface:
 
         return merged_messages
 
-    def get_tool_call_object(self) -> ToolCall:
-        """Useful for agent loop"""
-        if not self.tool_call_name:
-            raise ValueError("No tool call name available")
-        if not self.tool_call_args:
-            raise ValueError("No tool call arguments available")
-        if not self.tool_call_id:
-            raise ValueError("No tool call ID available")
+    def get_tool_call_objects(self) -> list[ToolCall]:
+        """Return finalized tool calls (parallel supported)."""
+        if not self._tool_calls_acc:
+            return []
+        ordered_indices = [i for i in self._tool_call_start_order if i in self._tool_calls_acc]
+        result: list[ToolCall] = []
+        for idx in ordered_indices:
+            ctx = self._tool_calls_acc[idx]
+            name = ctx.get("name", "")
+            args = ctx.get("arguments", "")
+            call_id = ctx.get("id", "")
+            if call_id and name:
+                result.append(ToolCall(id=call_id, function=FunctionCall(arguments=args or "", name=name)))
+        return result
 
-        return ToolCall(
-            id=self.tool_call_id,
-            function=FunctionCall(arguments=self.tool_call_args, name=self.tool_call_name),
-        )
+    def get_tool_call_object(self) -> ToolCall:
+        """Backwards-compatible single tool call accessor (first tool if multiple)."""
+        calls = self.get_tool_call_objects()
+        if not calls:
+            raise ValueError("No tool calls available")
+        return calls[0]
 
     async def process(
         self,
@@ -718,70 +726,61 @@ class SimpleOpenAIStreamingInterface:
                     yield reasoning_msg
 
             if message_delta.tool_calls is not None and len(message_delta.tool_calls) > 0:
-                tool_call = message_delta.tool_calls[0]
-
-                # For OpenAI reasoning models, emit a hidden reasoning message before the first tool call
-                # if not self.emitted_hidden_reasoning and is_openai_reasoning_model(self.model):
-                #     self.emitted_hidden_reasoning = True
-                #     if prev_message_type and prev_message_type != "hidden_reasoning_message":
-                #         message_index += 1
-                #     hidden_message = HiddenReasoningMessage(
-                #         id=self.letta_message_id,
-                #         date=datetime.now(timezone.utc),
-                #         state="omitted",
-                #         hidden_reasoning=None,
-                #         otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
-                #     )
-                #     self.content_messages.append(hidden_message)
-                #     prev_message_type = hidden_message.message_type
-                #     message_index += 1  # Increment for the next message
-                #     yield hidden_message
-
-                if not tool_call.function.name and not tool_call.function.arguments and not tool_call.id:
-                    # No chunks to process, exit
-                    return
-
-                if tool_call.function.name:
-                    self.tool_call_name += tool_call.function.name
-                if tool_call.function.arguments:
-                    self.tool_call_args += tool_call.function.arguments
-                if tool_call.id:
-                    self.tool_call_id += tool_call.id
+                # Accumulate per-index tool call fragments and emit deltas
+                for tool_call in message_delta.tool_calls:
+                    if (
+                        not (tool_call.function and (tool_call.function.name or tool_call.function.arguments))
+                        and not tool_call.id
+                        and getattr(tool_call, "index", None) is None
+                    ):
+                        continue
 
-                if self.requires_approval_tools:
-                    tool_call_msg = ApprovalRequestMessage(
-                        id=decrement_message_uuid(self.letta_message_id),
-                        date=datetime.now(timezone.utc),
-                        tool_call=ToolCallDelta(
-                            name=tool_call.function.name,
-                            arguments=tool_call.function.arguments,
-                            tool_call_id=tool_call.id,
-                        ),
-                        # name=name,
-                        otid=Message.generate_otid_from_id(decrement_message_uuid(self.letta_message_id), -1),
-                        run_id=self.run_id,
-                        step_id=self.step_id,
-                    )
-                else:
-                    if prev_message_type and prev_message_type != "tool_call_message":
-                        message_index += 1
-                    tool_call_delta = ToolCallDelta(
-                        name=tool_call.function.name,
-                        arguments=tool_call.function.arguments,
-                        tool_call_id=tool_call.id,
-                    )
-                    tool_call_msg = ToolCallMessage(
-                        id=self.letta_message_id,
-                        date=datetime.now(timezone.utc),
-                        tool_call=tool_call_delta,
-                        tool_calls=tool_call_delta,
-                        # name=name,
-                        otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
-                        run_id=self.run_id,
-                        step_id=self.step_id,
+                    idx = getattr(tool_call, "index", None)
+                    if idx is None:
+                        idx = 0
+
+                    if idx not in self._tool_call_start_order:
+                        self._tool_call_start_order.append(idx)
+                    if idx not in self._tool_calls_acc:
+                        self._tool_calls_acc[idx] = {"name": "", "arguments": "", "id": ""}
+                    acc = self._tool_calls_acc[idx]
+
+                    if tool_call.function and tool_call.function.name:
+                        acc["name"] += tool_call.function.name
+                    if tool_call.function and tool_call.function.arguments:
+                        acc["arguments"] += tool_call.function.arguments
+                    if tool_call.id:
+                        acc["id"] += tool_call.id
+
+                    delta = ToolCallDelta(
+                        name=tool_call.function.name if (tool_call.function and tool_call.function.name) else None,
+                        arguments=tool_call.function.arguments if (tool_call.function and tool_call.function.arguments) else None,
+                        tool_call_id=tool_call.id if tool_call.id else None,
                     )
-                    prev_message_type = tool_call_msg.message_type
-                yield tool_call_msg
+
+                    if acc.get("name") and acc["name"] in self.requires_approval_tools:
+                        tool_call_msg = ApprovalRequestMessage(
+                            id=decrement_message_uuid(self.letta_message_id),
+                            date=datetime.now(timezone.utc),
+                            tool_call=delta,
+                            otid=Message.generate_otid_from_id(decrement_message_uuid(self.letta_message_id), -1),
+                            run_id=self.run_id,
+                            step_id=self.step_id,
+                        )
+                    else:
+                        if prev_message_type and prev_message_type != "tool_call_message":
+                            message_index += 1
+                        tool_call_msg = ToolCallMessage(
+                            id=self.letta_message_id,
+                            date=datetime.now(timezone.utc),
+                            tool_call=delta,
+                            tool_calls=delta,
+                            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
 
 
 class SimpleOpenAIResponsesStreamingInterface:
@@ -813,7 +812,7 @@ class SimpleOpenAIResponsesStreamingInterface:
         # Premake IDs for database writes
         self.letta_message_id = Message.generate_id()
         self.model = model
-        self.final_response = None
+        self.final_response: Optional[ParsedResponse] = None
 
     def get_content(self) -> list[TextContent | SummarizedReasoningContent]:
         """This includes both SummarizedReasoningContent and TextContent"""
@@ -844,31 +843,35 @@ class SimpleOpenAIResponsesStreamingInterface:
 
         return content
 
-    def get_tool_call_object(self) -> ToolCall:
-        """Useful for agent loop"""
+    def get_tool_call_objects(self) -> list[ToolCall]:
+        """Return finalized tool calls (parallel supported) from final response."""
         if self.final_response is None:
-            raise ValueError("No final response available")
-
-        tool_calls = []
-        for response in self.final_response.output:
-            # TODO make sure this shouldn't be ResponseCustomToolCall?
-            if isinstance(response, ResponseFunctionToolCall):
-                tool_calls.append(
-                    ToolCall(
-                        id=response.call_id,
-                        function=FunctionCall(
-                            name=response.name,
-                            arguments=response.arguments,
-                        ),
+            return []
+
+        tool_calls: list[ToolCall] = []
+        for item in self.final_response.output:
+            if isinstance(item, ResponseFunctionToolCall):
+                call_id = item.call_id
+                name = item.name
+                arguments = item.arguments
+                if call_id and name is not None:
+                    tool_calls.append(
+                        ToolCall(
+                            id=call_id,
+                            function=FunctionCall(
+                                name=name,
+                                arguments=arguments,
+                            ),
+                        )
                     )
-                )
 
-        if len(tool_calls) == 0:
-            raise ValueError("No tool calls available")
-        if len(tool_calls) > 1:
-            raise ValueError(f"Got {len(tool_calls)} tool calls, expected 1")
+        return tool_calls
 
-        return tool_calls[0]
+    def get_tool_call_object(self) -> ToolCall:
+        calls = self.get_tool_call_objects()
+        if not calls:
+            raise ValueError("No tool calls available")
+        return calls[0]
 
     async def process(
         self,