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

letta/__init__.py

@@ -5,7 +5,7 @@ try:
     __version__ = version("letta")
 except PackageNotFoundError:
     # Fallback for development installations
-    __version__ = "0.13.0"
+    __version__ = "0.11.7"
 
 if os.environ.get("LETTA_VERSION"):
     __version__ = os.environ["LETTA_VERSION"]

letta/adapters/simple_llm_stream_adapter.py

@@ -78,6 +78,7 @@ class SimpleLLMStreamAdapter(LettaLLMStreamAdapter):
             use_responses = "input" in request_data and "messages" not in request_data
             # No support for Responses API proxy
             is_proxy = self.llm_config.provider_name == "lmstudio_openai"
+
             if use_responses and not is_proxy:
                 self.interface = SimpleOpenAIResponsesStreamingInterface(
                     is_openai_proxy=False,

letta/agents/letta_agent_v2.py

@@ -911,6 +911,10 @@ class LettaAgentV2(BaseAgentV2):
             )
             messages_to_persist = (initial_messages or []) + tool_call_messages
 
+            for message in messages_to_persist:
+                message.step_id = step_id
+                message.run_id = run_id
+
             persisted_messages = await self.message_manager.create_many_messages_async(
                 messages_to_persist,
                 actor=self.actor,
@@ -1028,6 +1032,10 @@ class LettaAgentV2(BaseAgentV2):
             )
             messages_to_persist = (initial_messages or []) + tool_call_messages
 
+        for message in messages_to_persist:
+            message.step_id = step_id
+            message.run_id = run_id
+
         persisted_messages = await self.message_manager.create_many_messages_async(
             messages_to_persist, actor=self.actor, run_id=run_id, project_id=agent_state.project_id, template_id=agent_state.template_id
         )

letta/agents/letta_agent_v3.py

@@ -19,7 +19,7 @@ from letta.agents.helpers import (
     merge_and_validate_prefilled_args,
 )
 from letta.agents.letta_agent_v2 import LettaAgentV2
-from letta.constants import DEFAULT_MAX_STEPS, NON_USER_MSG_PREFIX, REQUEST_HEARTBEAT_PARAM
+from letta.constants import DEFAULT_MAX_STEPS, NON_USER_MSG_PREFIX, REQUEST_HEARTBEAT_PARAM, SUMMARIZATION_TRIGGER_MULTIPLIER
 from letta.errors import ContextWindowExceededError, LLMError
 from letta.helpers import ToolRulesSolver
 from letta.helpers.datetime_helpers import get_utc_time, get_utc_timestamp_ns
@@ -37,6 +37,7 @@ from letta.schemas.openai.chat_completion_response import FunctionCall, ToolCall
 from letta.schemas.step import StepProgression
 from letta.schemas.step_metrics import StepMetrics
 from letta.schemas.tool_execution_result import ToolExecutionResult
+from letta.schemas.usage import LettaUsageStatistics
 from letta.server.rest_api.utils import (
     create_approval_request_message_from_llm_response,
     create_letta_messages_from_llm_response,
@@ -67,6 +68,13 @@ class LettaAgentV3(LettaAgentV2):
     def _initialize_state(self):
         super()._initialize_state()
         self._require_tool_call = False
+        self.last_step_usage = None
+        self.response_messages_for_metadata = []  # Separate accumulator for streaming job metadata
+
+    def _update_global_usage_stats(self, step_usage_stats: LettaUsageStatistics):
+        """Override to track per-step usage for context limit checks"""
+        self.last_step_usage = step_usage_stats
+        super()._update_global_usage_stats(step_usage_stats)
 
     @trace_method
     async def step(
@@ -115,19 +123,46 @@ class LettaAgentV3(LettaAgentV2):
             async for chunk in response:
                 response_letta_messages.append(chunk)
 
+            # Proactive summarization if approaching context limit
+            if (
+                self.last_step_usage
+                and self.last_step_usage.total_tokens > self.agent_state.llm_config.context_window * SUMMARIZATION_TRIGGER_MULTIPLIER
+                and not self.agent_state.message_buffer_autoclear
+            ):
+                self.logger.warning(
+                    f"Step usage ({self.last_step_usage.total_tokens} tokens) approaching "
+                    f"context limit ({self.agent_state.llm_config.context_window}), triggering summarization."
+                )
+
+                in_context_messages = await self.summarize_conversation_history(
+                    in_context_messages=in_context_messages,
+                    new_letta_messages=self.response_messages,
+                    total_tokens=self.last_step_usage.total_tokens,
+                    force=True,
+                )
+
+                # Clear to avoid duplication in next iteration
+                self.response_messages = []
+
             if not self.should_continue:
                 break
 
             input_messages_to_persist = []
 
-        # Rebuild context window after stepping
+        # Rebuild context window after stepping (safety net)
         if not self.agent_state.message_buffer_autoclear:
-            await self.summarize_conversation_history(
-                in_context_messages=in_context_messages,
-                new_letta_messages=self.response_messages,
-                total_tokens=self.usage.total_tokens,
-                force=False,
-            )
+            if self.last_step_usage:
+                await self.summarize_conversation_history(
+                    in_context_messages=in_context_messages,
+                    new_letta_messages=self.response_messages,
+                    total_tokens=self.last_step_usage.total_tokens,
+                    force=False,
+                )
+            else:
+                self.logger.warning(
+                    "Post-loop summarization skipped: last_step_usage is None. "
+                    "No step completed successfully or usage stats were not updated."
+                )
 
         if self.stop_reason is None:
             self.stop_reason = LettaStopReason(stop_reason=StopReasonType.end_turn.value)
@@ -211,18 +246,45 @@ class LettaAgentV3(LettaAgentV2):
                     yield f"data: {chunk.model_dump_json()}\n\n"
                     first_chunk = False
 
+                # Proactive summarization if approaching context limit
+                if (
+                    self.last_step_usage
+                    and self.last_step_usage.total_tokens > self.agent_state.llm_config.context_window * SUMMARIZATION_TRIGGER_MULTIPLIER
+                    and not self.agent_state.message_buffer_autoclear
+                ):
+                    self.logger.warning(
+                        f"Step usage ({self.last_step_usage.total_tokens} tokens) approaching "
+                        f"context limit ({self.agent_state.llm_config.context_window}), triggering summarization."
+                    )
+
+                    in_context_messages = await self.summarize_conversation_history(
+                        in_context_messages=in_context_messages,
+                        new_letta_messages=self.response_messages,
+                        total_tokens=self.last_step_usage.total_tokens,
+                        force=True,
+                    )
+
+                    # Clear to avoid duplication in next iteration
+                    self.response_messages = []
+
                 if not self.should_continue:
                     break
 
                 input_messages_to_persist = []
 
             if not self.agent_state.message_buffer_autoclear:
-                await self.summarize_conversation_history(
-                    in_context_messages=in_context_messages,
-                    new_letta_messages=self.response_messages,
-                    total_tokens=self.usage.total_tokens,
-                    force=False,
-                )
+                if self.last_step_usage:
+                    await self.summarize_conversation_history(
+                        in_context_messages=in_context_messages,
+                        new_letta_messages=self.response_messages,
+                        total_tokens=self.last_step_usage.total_tokens,
+                        force=False,
+                    )
+                else:
+                    self.logger.warning(
+                        "Post-loop summarization skipped: last_step_usage is None. "
+                        "No step completed successfully or usage stats were not updated."
+                    )
 
         except Exception as e:
             self.logger.warning(f"Error during agent stream: {e}", exc_info=True)
@@ -231,7 +293,7 @@ class LettaAgentV3(LettaAgentV2):
 
         if run_id:
             letta_messages = Message.to_letta_messages_from_list(
-                self.response_messages,
+                self.response_messages_for_metadata,  # Use separate accumulator to preserve all messages
                 use_assistant_message=False,  # NOTE: set to false
                 reverse=False,
                 # text_is_assistant_message=(self.agent_state.agent_type == AgentType.react_agent),
@@ -364,13 +426,15 @@ class LettaAgentV3(LettaAgentV2):
                             requires_subsequent_tool_call=self._require_tool_call,
                         )
                         # TODO: Extend to more providers, and also approval tool rules
-                        # Enable Anthropic parallel tool use when no tool rules are attached
+                        # Enable parallel tool use when no tool rules are attached
                         try:
+                            no_tool_rules = (
+                                not self.agent_state.tool_rules
+                                or len([t for t in self.agent_state.tool_rules if t.type != "requires_approval"]) == 0
+                            )
+
+                            # Anthropic/Bedrock parallel tool use
                             if self.agent_state.llm_config.model_endpoint_type in ["anthropic", "bedrock"]:
-                                no_tool_rules = (
-                                    not self.agent_state.tool_rules
-                                    or len([t for t in self.agent_state.tool_rules if t.type != "requires_approval"]) == 0
-                                )
                                 if (
                                     isinstance(request_data.get("tool_choice"), dict)
                                     and "disable_parallel_tool_use" in request_data["tool_choice"]
@@ -381,6 +445,16 @@ class LettaAgentV3(LettaAgentV2):
                                     else:
                                         # Explicitly disable when tool rules present or llm_config toggled off
                                         request_data["tool_choice"]["disable_parallel_tool_use"] = True
+
+                            # OpenAI parallel tool use
+                            elif self.agent_state.llm_config.model_endpoint_type == "openai":
+                                # For OpenAI, we control parallel tool calling via parallel_tool_calls field
+                                # Only allow parallel tool calls when no tool rules and enabled in config
+                                if "parallel_tool_calls" in request_data:
+                                    if no_tool_rules and self.agent_state.llm_config.parallel_tool_calls:
+                                        request_data["parallel_tool_calls"] = True
+                                    else:
+                                        request_data["parallel_tool_calls"] = False
                         except Exception:
                             # if this fails, we simply don't enable parallel tool use
                             pass
@@ -420,11 +494,11 @@ class LettaAgentV3(LettaAgentV2):
                             messages = await self.summarize_conversation_history(
                                 in_context_messages=messages,
                                 new_letta_messages=self.response_messages,
-                                llm_config=self.agent_state.llm_config,
                                 force=True,
                             )
                         else:
-                            self.stop_reason = LettaStopReason(stop_reason=StopReasonType.llm_api_error.value)
+                            self.stop_reason = LettaStopReason(stop_reason=StopReasonType.error.value)
+                            self.logger.error(f"Unknown error occured for run {run_id}: {e}")
                             raise e
 
                 step_progression, step_metrics = self._step_checkpoint_llm_request_finish(
@@ -434,11 +508,13 @@ class LettaAgentV3(LettaAgentV2):
                 self._update_global_usage_stats(llm_adapter.usage)
 
                 # Handle the AI response with the extracted data (supports multiple tool calls)
-                # Gather tool calls. Approval paths specify a single tool call.
+                # Gather tool calls - check for multi-call API first, then fall back to single
                 if hasattr(llm_adapter, "tool_calls") and llm_adapter.tool_calls:
                     tool_calls = llm_adapter.tool_calls
                 elif llm_adapter.tool_call is not None:
                     tool_calls = [llm_adapter.tool_call]
+                else:
+                    tool_calls = []
 
             aggregated_persisted: list[Message] = []
             persisted_messages, self.should_continue, self.stop_reason = await self._handle_ai_response(
@@ -468,6 +544,7 @@ class LettaAgentV3(LettaAgentV2):
 
             new_message_idx = len(input_messages_to_persist) if input_messages_to_persist else 0
             self.response_messages.extend(aggregated_persisted[new_message_idx:])
+            self.response_messages_for_metadata.extend(aggregated_persisted[new_message_idx:])  # Track for job metadata
 
             if llm_adapter.supports_token_streaming():
                 # Stream each tool return if tools were executed
@@ -673,6 +750,8 @@ class LettaAgentV3(LettaAgentV2):
             for message in messages_to_persist:
                 if message.run_id is None:
                     message.run_id = run_id
+                if message.step_id is None:
+                    message.step_id = step_id
 
             persisted_messages = await self.message_manager.create_many_messages_async(
                 messages_to_persist, actor=self.actor, run_id=run_id, project_id=agent_state.project_id, template_id=agent_state.template_id
@@ -699,6 +778,8 @@ class LettaAgentV3(LettaAgentV2):
                 for message in messages_to_persist:
                     if message.run_id is None:
                         message.run_id = run_id
+                    if message.step_id is None:
+                        message.step_id = step_id
 
                 persisted_messages = await self.message_manager.create_many_messages_async(
                     messages_to_persist,
@@ -909,10 +990,12 @@ class LettaAgentV3(LettaAgentV2):
 
         messages_to_persist: list[Message] = (initial_messages or []) + parallel_messages
 
-        # Set run_id on all messages before persisting
+        # Set run_id and step_id on all messages before persisting
         for message in messages_to_persist:
             if message.run_id is None:
                 message.run_id = run_id
+            if message.step_id is None:
+                message.step_id = step_id
 
         # Persist all messages
         persisted_messages = await self.message_manager.create_many_messages_async(
@@ -924,15 +1007,25 @@ class LettaAgentV3(LettaAgentV2):
         )
 
         # 5g. Aggregate continuation decisions
-        # For multiple tools: continue if ANY says continue, use last non-None stop_reason
-        # For single tool: use its decision directly
         aggregate_continue = any(persisted_continue_flags) if persisted_continue_flags else False
-        aggregate_continue = aggregate_continue or tool_call_denials or tool_returns  # continue if any tool call was denied or returned
+        aggregate_continue = aggregate_continue or tool_call_denials or tool_returns
+
+        # Determine aggregate stop reason
         aggregate_stop_reason = None
         for sr in persisted_stop_reasons:
             if sr is not None:
                 aggregate_stop_reason = sr
 
+        # For parallel tool calls, always continue to allow the agent to process/summarize results
+        # unless a terminal tool was called or we hit max steps
+        if len(exec_specs) > 1:
+            has_terminal = any(sr and sr.stop_reason == StopReasonType.tool_rule.value for sr in persisted_stop_reasons)
+            is_max_steps = any(sr and sr.stop_reason == StopReasonType.max_steps.value for sr in persisted_stop_reasons)
+
+            if not has_terminal and not is_max_steps:
+                # Force continuation for parallel tool execution
+                aggregate_continue = True
+                aggregate_stop_reason = None
         return persisted_messages, aggregate_continue, aggregate_stop_reason
 
     @trace_method

letta/agents/temporal/activities/__init__.py

@@ -0,0 +1,25 @@
+from letta.agents.temporal.activities.create_messages import create_messages
+from letta.agents.temporal.activities.create_step import create_step
+from letta.agents.temporal.activities.example_activity import example_activity
+from letta.agents.temporal.activities.execute_tool import execute_tool
+from letta.agents.temporal.activities.llm_request import llm_request
+from letta.agents.temporal.activities.prepare_messages import prepare_messages
+from letta.agents.temporal.activities.refresh_context import refresh_context_and_system_message
+from letta.agents.temporal.activities.summarize_conversation_history import summarize_conversation_history
+from letta.agents.temporal.activities.update_message_ids import update_message_ids
+from letta.agents.temporal.activities.update_run import update_run
+
+__all__ = [
+    "prepare_messages",
+    "refresh_context_and_system_message",
+    "llm_request",
+    "summarize_conversation_history",
+    "example_activity",
+    "execute_tool",
+    "create_messages",
+    "create_step",
+    "prepare_messages",
+    "refresh_context_and_system_message",
+    "update_message_ids",
+    "update_run",
+]

letta/agents/temporal/activities/create_messages.py

@@ -0,0 +1,26 @@
+from temporalio import activity
+
+from letta.agents.temporal.types import CreateMessagesParams, CreateMessagesResult
+from letta.services.message_manager import MessageManager
+
+
+@activity.defn(name="create_messages")
+async def create_messages(params: CreateMessagesParams) -> CreateMessagesResult:
+    """
+    Persist messages to the database.
+
+    This activity saves the messages to the database and returns the persisted messages
+    with their assigned IDs and timestamps.
+    """
+    message_manager = MessageManager()
+
+    # Persist messages to database
+    persisted_messages = await message_manager.create_many_messages_async(
+        params.messages,
+        actor=params.actor,
+        project_id=params.project_id,
+        template_id=params.template_id,
+        allow_partial=True,  # always allow partial to handle retries gracefully
+    )
+
+    return CreateMessagesResult(messages=persisted_messages)

letta/agents/temporal/activities/create_step.py

@@ -0,0 +1,57 @@
+from temporalio import activity
+
+from letta.agents.temporal.types import CreateStepParams, CreateStepResult
+from letta.helpers.datetime_helpers import get_utc_timestamp_ns
+from letta.schemas.enums import StepStatus
+from letta.schemas.openai.chat_completion_response import UsageStatistics
+from letta.schemas.step_metrics import StepMetrics
+from letta.services.step_manager import StepManager
+
+
+@activity.defn(name="create_step")
+async def create_step(params: CreateStepParams) -> CreateStepResult:
+    """
+    Persist step to the database, update usage statistics, and record metrics.
+
+    This activity saves the step to the database, updates its usage statistics,
+    and records timing metrics.
+    """
+    step_manager = StepManager()
+
+    # Determine status based on stop_reason
+    status = StepStatus.ERROR if params.stop_reason == "error" else StepStatus.SUCCESS
+
+    # Persist step to database
+    persisted_step = await step_manager.log_step_async(
+        actor=params.actor,
+        agent_id=params.agent_state.id,
+        provider_name=params.agent_state.llm_config.model_endpoint_type,
+        provider_category=params.agent_state.llm_config.provider_category or "base",
+        model=params.agent_state.llm_config.model,
+        model_endpoint=params.agent_state.llm_config.model_endpoint,
+        context_window_limit=params.agent_state.llm_config.context_window,
+        usage=params.usage,
+        provider_id=None,
+        run_id=params.run_id,
+        step_id=params.step_id,
+        project_id=params.agent_state.project_id,
+        status=status,
+        allow_partial=True,
+    )
+
+    # Record step metrics
+    await step_manager.record_step_metrics_async(
+        actor=params.actor,
+        step_id=persisted_step.id,
+        llm_request_ns=params.llm_request_ns,
+        tool_execution_ns=params.tool_execution_ns,
+        step_ns=params.step_ns,
+        agent_id=params.agent_state.id,
+        run_id=params.run_id,
+        project_id=params.agent_state.project_id,
+        template_id=params.agent_state.template_id,
+        base_template_id=params.agent_state.base_template_id,
+        allow_partial=True,
+    )
+
+    return CreateStepResult(step=persisted_step)

letta/agents/temporal/activities/example_activity.py

@@ -0,0 +1,9 @@
+from temporalio import activity
+
+from letta.agents.temporal.types import PreparedMessages
+
+
+@activity.defn(name="example_activity")
+async def example_activity(input_: PreparedMessages) -> str:
+    # Process the result from the previous activity
+    pass

letta/agents/temporal/activities/execute_tool.py

@@ -0,0 +1,130 @@
+import json
+from typing import Any
+
+from temporalio import activity
+
+from letta.agents.temporal.activities.llm_request import ApplicationError
+from letta.agents.temporal.types import ExecuteToolParams, ExecuteToolResult
+from letta.helpers.datetime_helpers import get_utc_timestamp_ns
+from letta.schemas.tool_execution_result import ToolExecutionResult
+from letta.services.agent_manager import AgentManager
+from letta.services.block_manager import BlockManager
+from letta.services.message_manager import MessageManager
+from letta.services.passage_manager import PassageManager
+from letta.services.run_manager import RunManager
+from letta.services.tool_executor.tool_execution_manager import ToolExecutionManager
+
+
+@activity.defn(name="execute_tool")
+async def execute_tool(params: ExecuteToolParams) -> ExecuteToolResult:
+    """
+    Execute the tool using ToolExecutionManager.
+    Returns the execution result and timing information.
+    """
+    message_manager = MessageManager()
+    agent_manager = AgentManager()
+    block_manager = BlockManager()
+    run_manager = RunManager()
+    passage_manager = PassageManager()
+
+    target_tool = next((x for x in params.agent_state.tools if x.name == params.tool_name), None)
+
+    if not target_tool:
+        return ExecuteToolResult(
+            tool_execution_result=ToolExecutionResult(
+                func_return=f"Tool {params.tool_name} not found",
+                status="error",
+            ),
+            execution_time_ns=0,
+        )
+
+    start_time = get_utc_timestamp_ns()
+
+    # Decrypt environment variable values
+    sandbox_env_vars = {var.key: var.get_value_secret().get_plaintext() for var in params.agent_state.secrets}
+    tool_execution_manager = ToolExecutionManager(
+        agent_state=params.agent_state,
+        message_manager=message_manager,
+        agent_manager=agent_manager,
+        block_manager=block_manager,
+        run_manager=run_manager,
+        passage_manager=passage_manager,
+        sandbox_env_vars=sandbox_env_vars,
+        actor=params.actor,
+    )
+
+    tool_execution_result = await tool_execution_manager.execute_tool_async(
+        function_name=params.tool_name,
+        function_args=params.tool_args,
+        tool=target_tool,
+        step_id=params.step_id,
+    )
+
+    end_time = get_utc_timestamp_ns()
+
+    # Exceptions are not JSON serializable, make sure to deserialize post activity execution
+    if isinstance(tool_execution_result.func_return, Exception):
+        tool_execution_result.func_return = _serialize_func_return(tool_execution_result.func_return)
+
+    return ExecuteToolResult(
+        tool_execution_result=tool_execution_result,
+        execution_time_ns=end_time - start_time,  # TODO: actually record this or use native Temporal metrics?
+    )
+
+
+def _serialize_func_return(e: Exception) -> str:
+    """Serialize exception to be JSON serializable string"""
+    result = {
+        "type": type(e).__name__,
+        "module": type(e).__module__,
+        "args": list(e.args) if e.args else [],
+        "message": str(e),
+    }
+
+    # Preserve custom attributes if present
+    if hasattr(e, "__dict__"):
+        custom_attrs = {k: v for k, v in e.__dict__.items() if isinstance(v, (str, int, float, bool, list, dict, type(None)))}
+        if custom_attrs:
+            result["custom_attrs"] = custom_attrs
+
+    return result
+
+
+def deserialize_func_return(data: dict) -> Exception:
+    """Deserialize back to Exception class"""
+    exception_map = {
+        "ValueError": ValueError,
+        "KeyError": KeyError,
+        "TypeError": TypeError,
+        "RuntimeError": RuntimeError,
+        "ApplicationError": ApplicationError,
+    }
+
+    exc_class = exception_map.get(data["type"], Exception)
+
+    # Create exception with original args
+    if data.get("args"):
+        exc = exc_class(*data["args"])
+    else:
+        exc = exc_class(data.get("message", ""))
+
+    # Restore custom attributes if any
+    if data.get("custom_attrs"):
+        for key, value in data["custom_attrs"].items():
+            setattr(exc, key, value)
+
+    return exc
+
+
+def is_serialized_exception(data: Any) -> bool:
+    """Check if data is a serialized exception"""
+    # Should have been serialized to a string
+    if not isinstance(data, str):
+        return False
+
+    try:
+        # Soft check if data has exception structure
+        parsed = json.loads(data)
+        return isinstance(parsed, dict) and "type" in parsed and "message" in parsed
+    except Exception:
+        return False