letta-nightly 0.11.7.dev20251007104119__py3-none-any.whl → 0.11.7.dev20251008104128__py3-none-any.whl

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

@@ -52,7 +52,7 @@ async def create_voice_chat_completions(
         message_manager=server.message_manager,
         agent_manager=server.agent_manager,
         block_manager=server.block_manager,
-        job_manager=server.job_manager,
+        run_manager=server.run_manager,
         passage_manager=server.passage_manager,
         actor=actor,
     )

letta/server/rest_api/streaming_response.py

@@ -13,23 +13,23 @@ from starlette.types import Send
 
 from letta.errors import LettaUnexpectedStreamCancellationError, PendingApprovalError
 from letta.log import get_logger
-from letta.schemas.enums import JobStatus
+from letta.schemas.enums import RunStatus
 from letta.schemas.letta_ping import LettaPing
 from letta.schemas.user import User
 from letta.server.rest_api.utils import capture_sentry_exception
-from letta.services.job_manager import JobManager
+from letta.services.run_manager import RunManager
 from letta.settings import settings
 from letta.utils import safe_create_task
 
 logger = get_logger(__name__)
 
 
-class JobCancelledException(Exception):
-    """Exception raised when a job is explicitly cancelled (not due to client timeout)"""
+class RunCancelledException(Exception):
+    """Exception raised when a run is explicitly cancelled (not due to client timeout)"""
 
-    def __init__(self, job_id: str, message: str = None):
-        self.job_id = job_id
-        super().__init__(message or f"Job {job_id} was explicitly cancelled")
+    def __init__(self, run_id: str, message: str = None):
+        self.run_id = run_id
+        super().__init__(message or f"Run {run_id} was explicitly cancelled")
 
 
 async def add_keepalive_to_stream(
@@ -109,21 +109,21 @@ async def add_keepalive_to_stream(
 # TODO (cliandy) wrap this and handle types
 async def cancellation_aware_stream_wrapper(
     stream_generator: AsyncIterator[str | bytes],
-    job_manager: JobManager,
-    job_id: str,
+    run_manager: RunManager,
+    run_id: str,
     actor: User,
     cancellation_check_interval: float = 0.5,
 ) -> AsyncIterator[str | bytes]:
     """
-    Wraps a stream generator to provide real-time job cancellation checking.
+    Wraps a stream generator to provide real-time run cancellation checking.
 
-    This wrapper periodically checks for job cancellation while streaming and
+    This wrapper periodically checks for run cancellation while streaming and
     can interrupt the stream at any point, not just at step boundaries.
 
     Args:
         stream_generator: The original stream generator to wrap
-        job_manager: Job manager instance for checking job status
-        job_id: ID of the job to monitor for cancellation
+        run_manager: Run manager instance for checking run status
+        run_id: ID of the run to monitor for cancellation
         actor: User/actor making the request
         cancellation_check_interval: How often to check for cancellation (seconds)
 
@@ -131,7 +131,7 @@ async def cancellation_aware_stream_wrapper(
         Stream chunks from the original generator until cancelled
 
     Raises:
-        asyncio.CancelledError: If the job is cancelled during streaming
+        asyncio.CancelledError: If the run is cancelled during streaming
     """
     last_cancellation_check = asyncio.get_event_loop().time()
 
@@ -141,32 +141,32 @@ async def cancellation_aware_stream_wrapper(
             current_time = asyncio.get_event_loop().time()
             if current_time - last_cancellation_check >= cancellation_check_interval:
                 try:
-                    job = await job_manager.get_job_by_id_async(job_id=job_id, actor=actor)
-                    if job.status == JobStatus.cancelled:
-                        logger.info(f"Stream cancelled for job {job_id}, interrupting stream")
+                    run = await run_manager.get_run_by_id_async(run_id=run_id, actor=actor)
+                    if run.status == RunStatus.cancelled:
+                        logger.info(f"Stream cancelled for run {run_id}, interrupting stream")
                         # Send cancellation event to client
                         cancellation_event = {"message_type": "stop_reason", "stop_reason": "cancelled"}
                         yield f"data: {json.dumps(cancellation_event)}\n\n"
-                        # Raise custom exception for explicit job cancellation
-                        raise JobCancelledException(job_id, f"Job {job_id} was cancelled")
+                        # Raise custom exception for explicit run cancellation
+                        raise RunCancelledException(run_id, f"Run {run_id} was cancelled")
                 except Exception as e:
                     # Log warning but don't fail the stream if cancellation check fails
-                    logger.warning(f"Failed to check job cancellation for job {job_id}: {e}")
+                    logger.warning(f"Failed to check run cancellation for run {run_id}: {e}")
 
                 last_cancellation_check = current_time
 
             yield chunk
 
-    except JobCancelledException:
-        # Re-raise JobCancelledException to distinguish from client timeout
-        logger.info(f"Stream for job {job_id} was explicitly cancelled and cleaned up")
+    except RunCancelledException:
+        # Re-raise RunCancelledException to distinguish from client timeout
+        logger.info(f"Stream for run {run_id} was explicitly cancelled and cleaned up")
         raise
     except asyncio.CancelledError:
         # Re-raise CancelledError (likely client timeout) to ensure proper cleanup
-        logger.info(f"Stream for job {job_id} was cancelled (likely client timeout) and cleaned up")
+        logger.info(f"Stream for run {run_id} was cancelled (likely client timeout) and cleaned up")
         raise
     except Exception as e:
-        logger.error(f"Error in cancellation-aware stream wrapper for job {job_id}: {e}")
+        logger.error(f"Error in cancellation-aware stream wrapper for run {run_id}: {e}")
         raise
 
 
@@ -267,12 +267,12 @@ class StreamingResponseWithStatusCode(StreamingResponse):
                         self._client_connected = False
                         # Continue processing but don't try to send more data
 
-        # Handle explicit job cancellations (should not throw error)
-        except JobCancelledException as exc:
-            logger.info(f"Stream was explicitly cancelled for job {exc.job_id}")
+        # Handle explicit run cancellations (should not throw error)
+        except RunCancelledException as exc:
+            logger.info(f"Stream was explicitly cancelled for run {exc.run_id}")
             # Handle explicit cancellation gracefully without error
             more_body = False
-            cancellation_resp = {"message": "Job was cancelled"}
+            cancellation_resp = {"message": "Run was cancelled"}
             cancellation_event = f"event: cancelled\ndata: {json.dumps(cancellation_resp)}\n\n".encode(self.charset)
             if not self.response_started:
                 await send(

letta/server/rest_api/utils.py

@@ -27,7 +27,13 @@ from letta.otel.metric_registry import MetricRegistry
 from letta.otel.tracing import tracer
 from letta.schemas.agent import AgentState
 from letta.schemas.enums import MessageRole
-from letta.schemas.letta_message_content import OmittedReasoningContent, ReasoningContent, RedactedReasoningContent, TextContent
+from letta.schemas.letta_message_content import (
+    OmittedReasoningContent,
+    ReasoningContent,
+    RedactedReasoningContent,
+    SummarizedReasoningContent,
+    TextContent,
+)
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import ApprovalCreate, Message, MessageCreate, ToolReturn
 from letta.schemas.tool_execution_result import ToolExecutionResult
@@ -148,7 +154,7 @@ def capture_sentry_exception(e: BaseException):
         sentry_sdk.capture_exception(e)
 
 
-def create_input_messages(input_messages: List[MessageCreate], agent_id: str, timezone: str, actor: User) -> List[Message]:
+def create_input_messages(input_messages: List[MessageCreate], agent_id: str, timezone: str, run_id: str, actor: User) -> List[Message]:
     """
     Converts a user input message into the internal structured format.
 
@@ -156,7 +162,9 @@ def create_input_messages(input_messages: List[MessageCreate], agent_id: str, ti
     we should unify this when it's clear what message attributes we need.
     """
 
-    messages = convert_message_creates_to_messages(input_messages, agent_id, timezone, wrap_user_message=False, wrap_system_message=False)
+    messages = convert_message_creates_to_messages(
+        input_messages, agent_id, timezone, run_id, wrap_user_message=False, wrap_system_message=False
+    )
     return messages
 
 
@@ -184,10 +192,13 @@ def create_approval_request_message_from_llm_response(
     reasoning_content: Optional[List[Union[TextContent, ReasoningContent, RedactedReasoningContent, OmittedReasoningContent]]] = None,
     pre_computed_assistant_message_id: Optional[str] = None,
     step_id: str | None = None,
+    run_id: str = None,
+    append_request_heartbeat: bool = True,
 ) -> Message:
     # Construct the tool call with the assistant's message
-    # Force set request_heartbeat in tool_args to calculated continue_stepping
-    function_arguments[REQUEST_HEARTBEAT_PARAM] = continue_stepping
+    # Optionally set request_heartbeat in tool args (v2 behavior only)
+    if append_request_heartbeat:
+        function_arguments[REQUEST_HEARTBEAT_PARAM] = continue_stepping
     tool_call = OpenAIToolCall(
         id=tool_call_id,
         function=OpenAIFunction(
@@ -207,6 +218,7 @@ def create_approval_request_message_from_llm_response(
         tool_call_id=tool_call_id,
         created_at=get_utc_time(),
         step_id=step_id,
+        run_id=run_id,
     )
     if pre_computed_assistant_message_id:
         approval_message.id = pre_computed_assistant_message_id
@@ -216,82 +228,130 @@ def create_approval_request_message_from_llm_response(
 def create_letta_messages_from_llm_response(
     agent_id: str,
     model: str,
-    function_name: str,
-    function_arguments: Dict,
-    tool_execution_result: ToolExecutionResult,
-    tool_call_id: str,
-    function_call_success: bool,
+    function_name: Optional[str],
+    function_arguments: Optional[Dict],
+    tool_execution_result: Optional[ToolExecutionResult],
+    tool_call_id: Optional[str],
     function_response: Optional[str],
     timezone: str,
-    actor: User,
+    run_id: str | None = None,
+    step_id: str = None,
     continue_stepping: bool = False,
     heartbeat_reason: Optional[str] = None,
-    reasoning_content: Optional[List[Union[TextContent, ReasoningContent, RedactedReasoningContent, OmittedReasoningContent]]] = None,
+    reasoning_content: Optional[
+        List[Union[TextContent, ReasoningContent, RedactedReasoningContent, OmittedReasoningContent | SummarizedReasoningContent]]
+    ] = None,
     pre_computed_assistant_message_id: Optional[str] = None,
     llm_batch_item_id: Optional[str] = None,
-    step_id: str | None = None,
     is_approval_response: bool | None = None,
+    # force set request_heartbeat, useful for v2 loop to ensure matching tool rules
+    force_set_request_heartbeat: bool = True,
+    add_heartbeat_on_continue: bool = True,
 ) -> List[Message]:
     messages = []
-    if not is_approval_response:
-        # Construct the tool call with the assistant's message
-        # Force set request_heartbeat in tool_args to calculated continue_stepping
-        function_arguments[REQUEST_HEARTBEAT_PARAM] = continue_stepping
-        tool_call = OpenAIToolCall(
-            id=tool_call_id,
-            function=OpenAIFunction(
-                name=function_name,
-                arguments=json.dumps(function_arguments),
-            ),
-            type="function",
-        )
-        # TODO: Use ToolCallContent instead of tool_calls
-        # TODO: This helps preserve ordering
-        assistant_message = Message(
-            role=MessageRole.assistant,
-            content=reasoning_content if reasoning_content else [],
+    if not is_approval_response:  # Skip approval responses (omit them)
+        if function_name is not None:
+            # Construct the tool call with the assistant's message
+            # Force set request_heartbeat in tool_args to calculated continue_stepping
+            if force_set_request_heartbeat:
+                function_arguments[REQUEST_HEARTBEAT_PARAM] = continue_stepping
+            tool_call = OpenAIToolCall(
+                id=tool_call_id,
+                function=OpenAIFunction(
+                    name=function_name,
+                    arguments=json.dumps(function_arguments),
+                ),
+                type="function",
+            )
+            # TODO: Use ToolCallContent instead of tool_calls
+            # TODO: This helps preserve ordering
+
+            # Safeguard against empty text messages
+            content = []
+            if reasoning_content:
+                for content_part in reasoning_content:
+                    if isinstance(content_part, TextContent) and content_part.text == "":
+                        continue
+                    content.append(content_part)
+
+            assistant_message = Message(
+                role=MessageRole.assistant,
+                content=content,
+                agent_id=agent_id,
+                model=model,
+                tool_calls=[tool_call],
+                tool_call_id=tool_call_id,
+                created_at=get_utc_time(),
+                batch_item_id=llm_batch_item_id,
+                run_id=run_id,
+            )
+        else:
+            # Safeguard against empty text messages
+            content = []
+            if reasoning_content:
+                for content_part in reasoning_content:
+                    if isinstance(content_part, TextContent) and content_part.text == "":
+                        continue
+                    content.append(content_part)
+
+            # Should only hit this if using react agents
+            if content and len(content) > 0:
+                assistant_message = Message(
+                    role=MessageRole.assistant,
+                    # NOTE: weird that this is called "reasoning_content" here, since it's not
+                    content=content,
+                    agent_id=agent_id,
+                    model=model,
+                    tool_calls=None,
+                    tool_call_id=None,
+                    created_at=get_utc_time(),
+                    batch_item_id=llm_batch_item_id,
+                    run_id=run_id,
+                )
+            else:
+                assistant_message = None
+
+        if assistant_message:
+            if pre_computed_assistant_message_id:
+                assistant_message.id = pre_computed_assistant_message_id
+            messages.append(assistant_message)
+
+    # TODO: Use ToolReturnContent instead of TextContent
+    # TODO: This helps preserve ordering
+    if tool_execution_result is not None:
+        packaged_function_response = package_function_response(tool_execution_result.success_flag, function_response, timezone)
+        tool_message = Message(
+            role=MessageRole.tool,
+            content=[TextContent(text=packaged_function_response)],
             agent_id=agent_id,
             model=model,
-            tool_calls=[tool_call],
+            tool_calls=[],
             tool_call_id=tool_call_id,
             created_at=get_utc_time(),
+            name=function_name,
             batch_item_id=llm_batch_item_id,
+            tool_returns=[
+                ToolReturn(
+                    tool_call_id=tool_call_id,
+                    status=tool_execution_result.status,
+                    stderr=tool_execution_result.stderr,
+                    stdout=tool_execution_result.stdout,
+                    func_response=packaged_function_response,
+                )
+            ],
+            run_id=run_id,
         )
-        if pre_computed_assistant_message_id:
-            assistant_message.id = pre_computed_assistant_message_id
-        messages.append(assistant_message)
+        messages.append(tool_message)
 
-    # TODO: Use ToolReturnContent instead of TextContent
-    # TODO: This helps preserve ordering
-    tool_message = Message(
-        role=MessageRole.tool,
-        content=[TextContent(text=package_function_response(function_call_success, function_response, timezone))],
-        agent_id=agent_id,
-        model=model,
-        tool_calls=[],
-        tool_call_id=tool_call_id,
-        created_at=get_utc_time(),
-        name=function_name,
-        batch_item_id=llm_batch_item_id,
-        tool_returns=[
-            ToolReturn(
-                status=tool_execution_result.status,
-                stderr=tool_execution_result.stderr,
-                stdout=tool_execution_result.stdout,
-                # func_return=tool_execution_result.func_return,
-            )
-        ],
-    )
-    messages.append(tool_message)
-
-    if continue_stepping:
+    if continue_stepping and add_heartbeat_on_continue:
+        # TODO skip this for react agents, instead we just force looping
         heartbeat_system_message = create_heartbeat_system_message(
             agent_id=agent_id,
             model=model,
-            function_call_success=function_call_success,
-            actor=actor,
+            function_call_success=(tool_execution_result.success_flag if tool_execution_result is not None else True),
             timezone=timezone,
             heartbeat_reason=heartbeat_reason,
+            run_id=run_id,
         )
         messages.append(heartbeat_system_message)
 
@@ -306,9 +366,9 @@ def create_heartbeat_system_message(
     model: str,
     function_call_success: bool,
     timezone: str,
-    actor: User,
     llm_batch_item_id: Optional[str] = None,
     heartbeat_reason: Optional[str] = None,
+    run_id: Optional[str] = None,
 ) -> Message:
     if heartbeat_reason:
         text_content = heartbeat_reason
@@ -324,6 +384,7 @@ def create_heartbeat_system_message(
         tool_call_id=None,
         created_at=get_utc_time(),
         batch_item_id=llm_batch_item_id,
+        run_id=run_id,
     )
     return heartbeat_system_message
 
@@ -332,7 +393,6 @@ def create_assistant_messages_from_openai_response(
     response_text: str,
     agent_id: str,
     model: str,
-    actor: User,
     timezone: str,
 ) -> List[Message]:
     """
@@ -348,10 +408,8 @@ def create_assistant_messages_from_openai_response(
         function_arguments={DEFAULT_MESSAGE_TOOL_KWARG: response_text},  # Avoid raw string manipulation
         tool_execution_result=ToolExecutionResult(status="success"),
         tool_call_id=tool_call_id,
-        function_call_success=True,
         function_response=None,
         timezone=timezone,
-        actor=actor,
         continue_stepping=False,
     )