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

letta/adapters/letta_llm_adapter.py

@@ -28,6 +28,7 @@ class LettaLLMAdapter(ABC):
         self.response_data: dict | None = None
         self.chat_completions_response: ChatCompletionResponse | None = None
         self.reasoning_content: list[TextContent | ReasoningContent | RedactedReasoningContent] | None = None
+        self.content: list[TextContent | ReasoningContent | RedactedReasoningContent] | None = None
         self.tool_call: ToolCall | None = None
         self.usage: LettaUsageStatistics = LettaUsageStatistics()
         self.telemetry_manager: TelemetryManager = TelemetryManager()

letta/adapters/letta_llm_request_adapter.py

@@ -1,4 +1,3 @@
-import asyncio
 from typing import AsyncGenerator
 
 from letta.adapters.letta_llm_adapter import LettaLLMAdapter

letta/adapters/letta_llm_stream_adapter.py

@@ -1,4 +1,3 @@
-import asyncio
 from typing import AsyncGenerator
 
 from letta.adapters.letta_llm_adapter import LettaLLMAdapter
@@ -26,8 +25,9 @@ class LettaLLMStreamAdapter(LettaLLMAdapter):
     specific streaming formats.
     """
 
-    def __init__(self, llm_client: LLMClientBase, llm_config: LLMConfig) -> None:
+    def __init__(self, llm_client: LLMClientBase, llm_config: LLMConfig, run_id: str | None = None) -> None:
         super().__init__(llm_client, llm_config)
+        self.run_id = run_id
         self.interface: OpenAIStreamingInterface | AnthropicStreamingInterface | None = None
 
     async def invoke_llm(
@@ -58,8 +58,11 @@ class LettaLLMStreamAdapter(LettaLLMAdapter):
                 use_assistant_message=use_assistant_message,
                 put_inner_thoughts_in_kwarg=self.llm_config.put_inner_thoughts_in_kwargs,
                 requires_approval_tools=requires_approval_tools,
+                run_id=self.run_id,
+                step_id=step_id,
             )
         elif self.llm_config.model_endpoint_type == ProviderType.openai:
+            # For non-v1 agents, always use Chat Completions streaming interface
             self.interface = OpenAIStreamingInterface(
                 use_assistant_message=use_assistant_message,
                 is_openai_proxy=self.llm_config.provider_name == "lmstudio_openai",
@@ -67,6 +70,8 @@ class LettaLLMStreamAdapter(LettaLLMAdapter):
                 messages=messages,
                 tools=tools,
                 requires_approval_tools=requires_approval_tools,
+                run_id=self.run_id,
+                step_id=step_id,
             )
         else:
             raise ValueError(f"Streaming not supported for provider {self.llm_config.model_endpoint_type}")

letta/adapters/simple_llm_request_adapter.py

@@ -0,0 +1,88 @@
+from typing import AsyncGenerator
+
+from letta.adapters.letta_llm_request_adapter import LettaLLMRequestAdapter
+from letta.helpers.datetime_helpers import get_utc_timestamp_ns
+from letta.schemas.letta_message import LettaMessage
+from letta.schemas.letta_message_content import OmittedReasoningContent, ReasoningContent, TextContent
+
+
+class SimpleLLMRequestAdapter(LettaLLMRequestAdapter):
+    """Simplifying assumptions:
+
+    - No inner thoughts in kwargs
+    - No forced tool calls
+    - Content native as assistant message
+    """
+
+    async def invoke_llm(
+        self,
+        request_data: dict,
+        messages: list,
+        tools: list,
+        use_assistant_message: bool,
+        requires_approval_tools: list[str] = [],
+        step_id: str | None = None,
+        actor: str | None = None,
+    ) -> AsyncGenerator[LettaMessage | None, None]:
+        """
+        Execute a blocking LLM request and yield the response.
+
+        This adapter:
+        1. Makes a blocking request to the LLM
+        2. Converts the response to chat completion format
+        3. Extracts reasoning and tool call information
+        4. Updates all instance variables
+        5. Yields nothing (blocking mode doesn't stream)
+        """
+        # Store request data
+        self.request_data = request_data
+
+        # Make the blocking LLM request
+        self.response_data = await self.llm_client.request_async(request_data, self.llm_config)
+        self.llm_request_finish_timestamp_ns = get_utc_timestamp_ns()
+
+        # Convert response to chat completion format
+        self.chat_completions_response = self.llm_client.convert_response_to_chat_completion(self.response_data, messages, self.llm_config)
+
+        # Extract reasoning content from the response
+        if self.chat_completions_response.choices[0].message.reasoning_content:
+            self.reasoning_content = [
+                ReasoningContent(
+                    reasoning=self.chat_completions_response.choices[0].message.reasoning_content,
+                    is_native=True,
+                    signature=self.chat_completions_response.choices[0].message.reasoning_content_signature,
+                )
+            ]
+        elif self.chat_completions_response.choices[0].message.omitted_reasoning_content:
+            self.reasoning_content = [OmittedReasoningContent()]
+        else:
+            # logger.info("No reasoning content found.")
+            self.reasoning_content = None
+
+        if self.chat_completions_response.choices[0].message.content:
+            # NOTE: big difference - 'content' goes into 'content'
+            # Reasoning placed into content for legacy reasons
+            self.content = [TextContent(text=self.chat_completions_response.choices[0].message.content)]
+        else:
+            self.content = None
+
+        if self.reasoning_content and len(self.reasoning_content) > 0:
+            # Temp workaround to consolidate parts to persist reasoning content, this should be integrated better
+            self.content = self.reasoning_content + (self.content or [])
+
+        # Extract tool call
+        if self.chat_completions_response.choices[0].message.tool_calls:
+            self.tool_call = self.chat_completions_response.choices[0].message.tool_calls[0]
+        else:
+            self.tool_call = None
+
+        # Extract usage statistics
+        self.usage.step_count = 1
+        self.usage.completion_tokens = self.chat_completions_response.usage.completion_tokens
+        self.usage.prompt_tokens = self.chat_completions_response.usage.prompt_tokens
+        self.usage.total_tokens = self.chat_completions_response.usage.total_tokens
+
+        self.log_provider_trace(step_id=step_id, actor=actor)
+
+        yield None
+        return

letta/adapters/simple_llm_stream_adapter.py

@@ -0,0 +1,192 @@
+from typing import AsyncGenerator, List
+
+from letta.adapters.letta_llm_stream_adapter import LettaLLMStreamAdapter
+from letta.helpers.datetime_helpers import get_utc_timestamp_ns
+from letta.interfaces.anthropic_streaming_interface import SimpleAnthropicStreamingInterface
+from letta.interfaces.gemini_streaming_interface import SimpleGeminiStreamingInterface
+from letta.interfaces.openai_streaming_interface import SimpleOpenAIResponsesStreamingInterface, SimpleOpenAIStreamingInterface
+from letta.schemas.enums import ProviderType
+from letta.schemas.letta_message import LettaMessage
+from letta.schemas.letta_message_content import LettaMessageContentUnion
+from letta.schemas.provider_trace import ProviderTraceCreate
+from letta.schemas.usage import LettaUsageStatistics
+from letta.schemas.user import User
+from letta.settings import settings
+from letta.utils import safe_create_task
+
+
+class SimpleLLMStreamAdapter(LettaLLMStreamAdapter):
+    """
+    Adapter for handling streaming LLM requests with immediate token yielding.
+
+    This adapter supports real-time streaming of tokens from the LLM, providing
+    minimal time-to-first-token (TTFT) latency. It uses specialized streaming
+    interfaces for different providers (OpenAI, Anthropic) to handle their
+    specific streaming formats.
+    """
+
+    async def invoke_llm(
+        self,
+        request_data: dict,
+        messages: list,
+        tools: list,
+        use_assistant_message: bool,  # NOTE: not used
+        requires_approval_tools: list[str] = [],
+        step_id: str | None = None,
+        actor: User | None = None,
+    ) -> AsyncGenerator[LettaMessage, None]:
+        """
+        Execute a streaming LLM request and yield tokens/chunks as they arrive.
+
+        This adapter:
+        1. Makes a streaming request to the LLM
+        2. Yields chunks immediately for minimal TTFT
+        3. Accumulates response data through the streaming interface
+        4. Updates all instance variables after streaming completes
+        """
+        # Store request data
+        self.request_data = request_data
+
+        # Instantiate streaming interface
+        if self.llm_config.model_endpoint_type in [ProviderType.anthropic, ProviderType.bedrock]:
+            # NOTE: different
+            self.interface = SimpleAnthropicStreamingInterface(
+                requires_approval_tools=requires_approval_tools,
+                run_id=self.run_id,
+                step_id=step_id,
+            )
+        elif self.llm_config.model_endpoint_type == ProviderType.openai:
+            # Decide interface based on payload shape
+            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,
+                    messages=messages,
+                    tools=tools,
+                    requires_approval_tools=requires_approval_tools,
+                    run_id=self.run_id,
+                    step_id=step_id,
+                )
+            else:
+                self.interface = SimpleOpenAIStreamingInterface(
+                    is_openai_proxy=self.llm_config.provider_name == "lmstudio_openai",
+                    messages=messages,
+                    tools=tools,
+                    requires_approval_tools=requires_approval_tools,
+                    model=self.llm_config.model,
+                    run_id=self.run_id,
+                    step_id=step_id,
+                )
+        elif self.llm_config.model_endpoint_type in [ProviderType.google_ai, ProviderType.google_vertex]:
+            self.interface = SimpleGeminiStreamingInterface(
+                requires_approval_tools=requires_approval_tools,
+                run_id=self.run_id,
+                step_id=step_id,
+            )
+        else:
+            raise ValueError(f"Streaming not supported for provider {self.llm_config.model_endpoint_type}")
+
+        # Extract optional parameters
+        # ttft_span = kwargs.get('ttft_span', None)
+
+        # Start the streaming request
+        stream = await self.llm_client.stream_async(request_data, self.llm_config)
+
+        # Process the stream and yield chunks immediately for TTFT
+        async for chunk in self.interface.process(stream):  # TODO: add ttft span
+            # Yield each chunk immediately as it arrives
+            yield chunk
+
+        # After streaming completes, extract the accumulated data
+        self.llm_request_finish_timestamp_ns = get_utc_timestamp_ns()
+
+        # Extract tool call from the interface
+        try:
+            self.tool_call = self.interface.get_tool_call_object()
+        except ValueError as e:
+            # No tool call, handle upstream
+            self.tool_call = None
+
+        # Extract reasoning content from the interface
+        # TODO this should probably just be called "content"?
+        # self.reasoning_content = self.interface.get_reasoning_content()
+
+        # Extract all content parts
+        self.content: List[LettaMessageContentUnion] = self.interface.get_content()
+
+        # Extract usage statistics
+        # Some providers don't provide usage in streaming, use fallback if needed
+        if hasattr(self.interface, "input_tokens") and hasattr(self.interface, "output_tokens"):
+            # Handle cases where tokens might not be set (e.g., LMStudio)
+            input_tokens = self.interface.input_tokens
+            output_tokens = self.interface.output_tokens
+
+            # Fallback to estimated values if not provided
+            if not input_tokens and hasattr(self.interface, "fallback_input_tokens"):
+                input_tokens = self.interface.fallback_input_tokens
+            if not output_tokens and hasattr(self.interface, "fallback_output_tokens"):
+                output_tokens = self.interface.fallback_output_tokens
+
+            self.usage = LettaUsageStatistics(
+                step_count=1,
+                completion_tokens=output_tokens or 0,
+                prompt_tokens=input_tokens or 0,
+                total_tokens=(input_tokens or 0) + (output_tokens or 0),
+            )
+        else:
+            # Default usage statistics if not available
+            self.usage = LettaUsageStatistics(step_count=1, completion_tokens=0, prompt_tokens=0, total_tokens=0)
+
+        # Store any additional data from the interface
+        self.message_id = self.interface.letta_message_id
+
+        # Log request and response data
+        self.log_provider_trace(step_id=step_id, actor=actor)
+
+    def log_provider_trace(self, step_id: str | None, actor: User | None) -> None:
+        """
+        Log provider trace data for telemetry purposes in a fire-and-forget manner.
+
+        Creates an async task to log the request/response data without blocking
+        the main execution flow. For streaming adapters, this includes the final
+        tool call and reasoning content collected during streaming.
+
+        Args:
+            step_id: The step ID associated with this request for logging purposes
+            actor: The user associated with this request for logging purposes
+        """
+        if step_id is None or actor is None or not settings.track_provider_trace:
+            return
+
+        safe_create_task(
+            self.telemetry_manager.create_provider_trace_async(
+                actor=actor,
+                provider_trace_create=ProviderTraceCreate(
+                    request_json=self.request_data,
+                    response_json={
+                        "content": {
+                            "tool_call": self.tool_call.model_dump_json() if self.tool_call else None,
+                            # "reasoning": [content.model_dump_json() for content in self.reasoning_content],
+                            # NOTE: different
+                            # TODO potentially split this into both content and reasoning?
+                            "content": [content.model_dump_json() for content in self.content],
+                        },
+                        "id": self.interface.message_id,
+                        "model": self.interface.model,
+                        "role": "assistant",
+                        # "stop_reason": "",
+                        # "stop_sequence": None,
+                        "type": "message",
+                        "usage": {
+                            "input_tokens": self.usage.prompt_tokens,
+                            "output_tokens": self.usage.completion_tokens,
+                        },
+                    },
+                    step_id=step_id,  # Use original step_id for telemetry
+                    organization_id=actor.organization_id,
+                ),
+            ),
+            label="create_provider_trace",
+        )

letta/agents/agent_loop.py

@@ -2,6 +2,7 @@ from typing import TYPE_CHECKING
 
 from letta.agents.base_agent_v2 import BaseAgentV2
 from letta.agents.letta_agent_v2 import LettaAgentV2
+from letta.agents.letta_agent_v3 import LettaAgentV3
 from letta.groups.sleeptime_multi_agent_v3 import SleeptimeMultiAgentV3
 from letta.schemas.agent import AgentState
 from letta.schemas.enums import AgentType
@@ -17,6 +18,11 @@ class AgentLoop:
     def load(agent_state: AgentState, actor: "User") -> BaseAgentV2:
         if agent_state.enable_sleeptime and agent_state.agent_type != AgentType.voice_convo_agent:
             return SleeptimeMultiAgentV3(agent_state=agent_state, actor=actor, group=agent_state.multi_agent_group)
+        elif agent_state.agent_type == AgentType.letta_v1_agent:
+            return LettaAgentV3(
+                agent_state=agent_state,
+                actor=actor,
+            )
         else:
             return LettaAgentV2(
                 agent_state=agent_state,

letta/agents/ephemeral_summary_agent.py

@@ -82,9 +82,10 @@ class EphemeralSummaryAgent(BaseAgent):
             message_creates=[system_message_create] + input_messages,
             agent_id=self.agent_id,
             timezone=agent_state.timezone,
+            run_id=None,  # TODO: add this
         )
 
-        request_data = llm_client.build_request_data(messages, agent_state.llm_config, tools=[])
+        request_data = llm_client.build_request_data(agent_state.agent_type, messages, agent_state.llm_config, tools=[])
         response_data = await llm_client.request_async(request_data, agent_state.llm_config)
         response = llm_client.convert_response_to_chat_completion(response_data, messages, agent_state.llm_config)
         summary = response.choices[0].message.content.strip()

letta/agents/helpers.py

@@ -1,13 +1,16 @@
 import json
 import uuid
 import xml.etree.ElementTree as ET
-from typing import List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple
+from uuid import UUID, uuid4
 
 from letta.errors import PendingApprovalError
 from letta.helpers import ToolRulesSolver
 from letta.log import get_logger
 from letta.schemas.agent import AgentState
+from letta.schemas.enums import MessageRole
 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.letta_stop_reason import LettaStopReason, StopReasonType
 from letta.schemas.message import Message, MessageCreate, MessageCreateBase
@@ -53,6 +56,7 @@ def _prepare_in_context_messages(
     agent_state: AgentState,
     message_manager: MessageManager,
     actor: User,
+    run_id: str,
 ) -> Tuple[List[Message], List[Message]]:
     """
     Prepares in-context messages for an agent, based on the current state and a new user input.
@@ -62,6 +66,7 @@ def _prepare_in_context_messages(
         agent_state (AgentState): The current state of the agent, including message buffer config.
         message_manager (MessageManager): The manager used to retrieve and create messages.
         actor (User): The user performing the action, used for access control and attribution.
+        run_id (str): The run ID associated with this message processing.
 
     Returns:
         Tuple[List[Message], List[Message]]: A tuple containing:
@@ -78,7 +83,9 @@ def _prepare_in_context_messages(
 
     # Create a new user message from the input and store it
     new_in_context_messages = message_manager.create_many_messages(
-        create_input_messages(input_messages=input_messages, agent_id=agent_state.id, timezone=agent_state.timezone, actor=actor),
+        create_input_messages(
+            input_messages=input_messages, agent_id=agent_state.id, timezone=agent_state.timezone, run_id=run_id, actor=actor
+        ),
         actor=actor,
     )
 
@@ -90,6 +97,7 @@ async def _prepare_in_context_messages_async(
     agent_state: AgentState,
     message_manager: MessageManager,
     actor: User,
+    run_id: str,
 ) -> Tuple[List[Message], List[Message]]:
     """
     Prepares in-context messages for an agent, based on the current state and a new user input.
@@ -100,6 +108,7 @@ async def _prepare_in_context_messages_async(
         agent_state (AgentState): The current state of the agent, including message buffer config.
         message_manager (MessageManager): The manager used to retrieve and create messages.
         actor (User): The user performing the action, used for access control and attribution.
+        run_id (str): The run ID associated with this message processing.
 
     Returns:
         Tuple[List[Message], List[Message]]: A tuple containing:
@@ -116,7 +125,9 @@ async def _prepare_in_context_messages_async(
 
     # Create a new user message from the input and store it
     new_in_context_messages = await message_manager.create_many_messages_async(
-        create_input_messages(input_messages=input_messages, agent_id=agent_state.id, timezone=agent_state.timezone, actor=actor),
+        create_input_messages(
+            input_messages=input_messages, agent_id=agent_state.id, timezone=agent_state.timezone, run_id=run_id, actor=actor
+        ),
         actor=actor,
         project_id=agent_state.project_id,
     )
@@ -129,6 +140,7 @@ async def _prepare_in_context_messages_no_persist_async(
     agent_state: AgentState,
     message_manager: MessageManager,
     actor: User,
+    run_id: Optional[str] = None,
 ) -> Tuple[List[Message], List[Message]]:
     """
     Prepares in-context messages for an agent, based on the current state and a new user input.
@@ -138,6 +150,7 @@ async def _prepare_in_context_messages_no_persist_async(
         agent_state (AgentState): The current state of the agent, including message buffer config.
         message_manager (MessageManager): The manager used to retrieve and create messages.
         actor (User): The user performing the action, used for access control and attribution.
+        run_id (str): The run ID associated with this message processing.
 
     Returns:
         Tuple[List[Message], List[Message]]: A tuple containing:
@@ -173,7 +186,7 @@ async def _prepare_in_context_messages_no_persist_async(
 
         # Create a new user message from the input but dont store it yet
         new_in_context_messages = create_input_messages(
-            input_messages=input_messages, agent_id=agent_state.id, timezone=agent_state.timezone, actor=actor
+            input_messages=input_messages, agent_id=agent_state.id, timezone=agent_state.timezone, run_id=run_id, actor=actor
         )
 
     return current_in_context_messages, new_in_context_messages
@@ -232,8 +245,9 @@ def deserialize_message_history(xml_str: str) -> Tuple[List[str], str]:
     return messages, context
 
 
-def generate_step_id():
-    return f"step-{uuid.uuid4()}"
+def generate_step_id(uid: Optional[UUID] = None) -> str:
+    uid = uid or uuid4()
+    return f"step-{uid}"
 
 
 def _safe_load_tool_call_str(tool_call_args_str: str) -> dict:
@@ -254,6 +268,106 @@ def _safe_load_tool_call_str(tool_call_args_str: str) -> dict:
     return tool_args
 
 
+def _json_type_matches(value: Any, expected_type: Any) -> bool:
+    """Basic JSON Schema type checking for common types.
+
+    expected_type can be a string (e.g., "string") or a list (union).
+    This is intentionally lightweight; deeper validation can be added as needed.
+    """
+
+    def match_one(v: Any, t: str) -> bool:
+        if t == "string":
+            return isinstance(v, str)
+        if t == "integer":
+            # bool is subclass of int in Python; exclude
+            return isinstance(v, int) and not isinstance(v, bool)
+        if t == "number":
+            return (isinstance(v, int) and not isinstance(v, bool)) or isinstance(v, float)
+        if t == "boolean":
+            return isinstance(v, bool)
+        if t == "object":
+            return isinstance(v, dict)
+        if t == "array":
+            return isinstance(v, list)
+        if t == "null":
+            return v is None
+        # Fallback: don't over-reject on unknown types
+        return True
+
+    if isinstance(expected_type, list):
+        return any(match_one(value, t) for t in expected_type)
+    if isinstance(expected_type, str):
+        return match_one(value, expected_type)
+    return True
+
+
+def _schema_accepts_value(prop_schema: Dict[str, Any], value: Any) -> bool:
+    """Check if a value is acceptable for a property schema.
+
+    Handles: type, enum, const, anyOf, oneOf (by shallow traversal).
+    """
+    if prop_schema is None:
+        return True
+
+    # const has highest precedence
+    if "const" in prop_schema:
+        return value == prop_schema["const"]
+
+    # enums
+    if "enum" in prop_schema:
+        try:
+            return value in prop_schema["enum"]
+        except Exception:
+            return False
+
+    # unions
+    for union_key in ("anyOf", "oneOf"):
+        if union_key in prop_schema and isinstance(prop_schema[union_key], list):
+            for sub in prop_schema[union_key]:
+                if _schema_accepts_value(sub, value):
+                    return True
+            return False
+
+    # type-based
+    if "type" in prop_schema:
+        if not _json_type_matches(value, prop_schema["type"]):
+            return False
+
+    # No strict constraints specified: accept
+    return True
+
+
+def merge_and_validate_prefilled_args(tool: "Tool", llm_args: Dict[str, Any], prefilled_args: Dict[str, Any]) -> Dict[str, Any]:
+    """Merge LLM-provided args with prefilled args from tool rules.
+
+    - Overlapping keys are replaced by prefilled values (prefilled wins).
+    - Validates that prefilled keys exist on the tool schema and that values satisfy
+      basic JSON Schema constraints (type/enum/const/anyOf/oneOf).
+    - Returns merged args, or raises ValueError on invalid prefilled inputs.
+    """
+    from letta.schemas.tool import Tool  # local import to avoid circulars in type hints
+
+    assert isinstance(tool, Tool)
+    schema = (tool.json_schema or {}).get("parameters", {})
+    props: Dict[str, Any] = schema.get("properties", {}) if isinstance(schema, dict) else {}
+
+    errors: list[str] = []
+    for k, v in prefilled_args.items():
+        if k not in props:
+            errors.append(f"Unknown argument '{k}' for tool '{tool.name}'.")
+            continue
+        if not _schema_accepts_value(props.get(k), v):
+            expected = props.get(k, {}).get("type")
+            errors.append(f"Invalid value for '{k}': {v!r} does not match expected schema type {expected!r}.")
+
+    if errors:
+        raise ValueError("; ".join(errors))
+
+    merged = dict(llm_args or {})
+    merged.update(prefilled_args)
+    return merged
+
+
 def _pop_heartbeat(tool_args: dict) -> bool:
     hb = tool_args.pop("request_heartbeat", False)
     return str(hb).lower() == "true" if isinstance(hb, str) else bool(hb)
@@ -264,3 +378,25 @@ def _build_rule_violation_result(tool_name: str, valid: list[str], solver: ToolR
     hint_txt = ("\n** Hint: Possible rules that were violated:\n" + "\n".join(f"\t- {h}" for h in hint_lines)) if hint_lines else ""
     msg = f"[ToolConstraintError] Cannot call {tool_name}, valid tools include: {valid}.{hint_txt}"
     return ToolExecutionResult(status="error", func_return=msg)
+
+
+def _load_last_function_response(in_context_messages: list[Message]):
+    """Load the last function response from message history"""
+    for msg in reversed(in_context_messages):
+        if msg.role == MessageRole.tool and msg.content and len(msg.content) == 1 and isinstance(msg.content[0], TextContent):
+            text_content = msg.content[0].text
+            try:
+                response_json = json.loads(text_content)
+                if response_json.get("message"):
+                    return response_json["message"]
+            except (json.JSONDecodeError, KeyError):
+                raise ValueError(f"Invalid JSON format in message: {text_content}")
+    return None
+
+
+def _maybe_get_approval_messages(messages: list[Message]) -> Tuple[Message | None, Message | None]:
+    if len(messages) >= 2:
+        maybe_approval_request, maybe_approval_response = messages[-2], messages[-1]
+        if maybe_approval_request.role == "approval" and maybe_approval_response.role == "approval":
+            return maybe_approval_request, maybe_approval_response
+    return None, None