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

letta/agents/temporal/activities/llm_request.py

@@ -0,0 +1,114 @@
+from temporalio import activity
+from temporalio.exceptions import ApplicationError
+
+from letta.adapters.letta_llm_request_adapter import LettaLLMRequestAdapter
+from letta.agents.temporal.types import LLMCallResult, LLMRequestParams
+from letta.errors import (
+    ContextWindowExceededError,
+    LLMAuthenticationError,
+    LLMBadRequestError,
+    LLMConnectionError,
+    LLMError,
+    LLMJSONParsingError,
+    LLMNotFoundError,
+    LLMPermissionDeniedError,
+    LLMRateLimitError,
+    LLMServerError,
+    LLMTimeoutError,
+    LLMUnprocessableEntityError,
+)
+from letta.helpers.datetime_helpers import get_utc_timestamp_ns
+from letta.llm_api.llm_client import LLMClient
+from letta.schemas.openai.chat_completion_response import UsageStatistics
+
+
+@activity.defn(name="llm_request")
+async def llm_request(params: LLMRequestParams) -> LLMCallResult:
+    """
+    Build and execute a non-streaming LLM request and return parsed tool call. Errors from the provider are intentionally propagated so the workflow can handle retries (e.g., summarization on ContextWindowExceededError).
+    """
+    agent_state = params.agent_state
+    llm_config = agent_state.llm_config
+
+    llm_client = LLMClient.create(
+        provider_type=llm_config.model_endpoint_type,
+        put_inner_thoughts_first=True,
+        actor=params.actor,
+    )
+    llm_adapter = LettaLLMRequestAdapter(llm_client=llm_client, llm_config=llm_config)
+
+    request_data = llm_client.build_request_data(
+        agent_type=agent_state.agent_type,
+        messages=params.messages,
+        llm_config=llm_config,
+        tools=params.allowed_tools,
+        force_tool_call=params.force_tool_call,
+    )
+
+    try:
+        # Track LLM request timing
+        llm_request_start_ns = get_utc_timestamp_ns()
+
+        # execute the llm request
+        invocation = llm_adapter.invoke_llm(
+            request_data=request_data,
+            messages=params.messages,
+            tools=params.allowed_tools,
+            use_assistant_message=params.use_assistant_message,
+            requires_approval_tools=params.requires_approval_tools or [],
+            step_id=params.step_id,
+            actor=params.actor,
+        )
+
+        # iterate through the async generator (non-streaming mode yields once with None)
+        async for _ in invocation:
+            pass
+
+        # Calculate LLM request duration
+        llm_request_end_ns = get_utc_timestamp_ns()
+        llm_request_ns = llm_request_end_ns - llm_request_start_ns
+
+        # extract results from the adapter after invocation completes
+        usage = llm_adapter.chat_completions_response.usage if llm_adapter.chat_completions_response else UsageStatistics()
+        return LLMCallResult(
+            tool_call=llm_adapter.tool_call,
+            reasoning_content=llm_adapter.reasoning_content,
+            assistant_message_id=llm_adapter.message_id,
+            usage=usage,
+            request_finish_ns=llm_adapter.llm_request_finish_timestamp_ns,
+            llm_request_start_ns=llm_request_start_ns,
+            llm_request_ns=llm_request_ns,
+        )
+    except (ValueError, LLMJSONParsingError) as e:
+        # Invalid or unparseable LLM response — non-retryable at activity layer
+        raise ApplicationError(str(e), type=type(e).__name__, non_retryable=True)
+    except ContextWindowExceededError as e:
+        # Context window overflow — non-retryable at activity layer; handled by workflow summarization
+        raise ApplicationError(str(e), type="ContextWindowExceededError", non_retryable=True)
+    except LLMError as e:
+        retryable_subtypes = (
+            LLMConnectionError,
+            LLMRateLimitError,
+            LLMServerError,
+            LLMTimeoutError,
+        )
+        non_retryable_subtypes = (
+            LLMBadRequestError,
+            LLMAuthenticationError,
+            LLMPermissionDeniedError,
+            LLMNotFoundError,
+            LLMUnprocessableEntityError,
+        )
+        if isinstance(e, retryable_subtypes):
+            non_retryable = False
+        elif isinstance(e, non_retryable_subtypes):
+            non_retryable = True
+        else:
+            # Default conservatively: do not retry unknown LLMError types
+            non_retryable = True
+        raise ApplicationError(str(e), type=type(e).__name__, non_retryable=non_retryable)
+    except TimeoutError as e:
+        raise ApplicationError(str(e), type=type(e).__name__, non_retryable=False)
+    except Exception as e:
+        # Any unexpected error — do not retry at activity layer
+        raise ApplicationError(str(e), type=type(e).__name__, non_retryable=True)

letta/agents/temporal/activities/prepare_messages.py

@@ -0,0 +1,27 @@
+from temporalio import activity
+
+from letta.agents.helpers import _prepare_in_context_messages_no_persist_async
+from letta.agents.temporal.types import PreparedMessages, WorkflowInputParams
+from letta.services.message_manager import MessageManager
+
+
+@activity.defn(name="prepare_messages")
+async def prepare_messages(input_: WorkflowInputParams) -> PreparedMessages:
+    """Prepare in-context and new input messages without persisting.
+
+    Mirrors `_prepare_in_context_messages_no_persist_async` from the v2 agent, but
+    runs as a Temporal activity so the workflow stays deterministic.
+    """
+    message_manager = MessageManager()
+    in_context_messages, input_messages_to_persist = await _prepare_in_context_messages_no_persist_async(
+        input_messages=input_.messages,
+        agent_state=input_.agent_state,
+        message_manager=message_manager,
+        actor=input_.actor,
+        run_id=input_.run_id,
+    )
+
+    return PreparedMessages(
+        in_context_messages=in_context_messages,
+        input_messages_to_persist=input_messages_to_persist,
+    )

letta/agents/temporal/activities/refresh_context.py

@@ -0,0 +1,160 @@
+from typing import List
+
+from temporalio import activity
+
+from letta.agents.temporal.types import RefreshContextParams, RefreshContextResult
+from letta.helpers import ToolRulesSolver
+from letta.helpers.datetime_helpers import get_utc_time
+from letta.helpers.reasoning_helper import scrub_inner_thoughts_from_messages
+from letta.prompts.prompt_generator import PromptGenerator
+from letta.schemas.agent import AgentState
+from letta.schemas.message import Message, MessageUpdate
+from letta.schemas.user import User
+from letta.services.agent_manager import AgentManager
+from letta.services.archive_manager import ArchiveManager
+from letta.services.message_manager import MessageManager
+from letta.services.passage_manager import PassageManager
+from letta.utils import united_diff
+
+
+def _extract_dynamic_section(text: str) -> str:
+    start_marker = "</base_instructions>"
+    end_marker = "<memory_metadata>"
+    start_idx = text.find(start_marker)
+    end_idx = text.find(end_marker)
+    if start_idx != -1 and end_idx != -1:
+        return text[start_marker.__len__() + start_idx : end_idx]
+    return text
+
+
+async def _rebuild_memory(
+    agent_state: AgentState,
+    in_context_messages: list[Message],
+    num_messages: int,
+    num_archival_memories: int,
+    actor: User,
+    message_manager: MessageManager,
+    passage_manager: PassageManager,
+    agent_manager: AgentManager,
+    archive_manager: ArchiveManager,
+    tool_rules_solver: ToolRulesSolver,
+) -> tuple[list[Message], AgentState]:
+    agent_state = await agent_manager.refresh_memory_async(agent_state=agent_state, actor=actor)
+
+    tool_constraint_block = None
+    if tool_rules_solver is not None:
+        tool_constraint_block = tool_rules_solver.compile_tool_rule_prompts()
+
+    archive = await archive_manager.get_default_archive_for_agent_async(
+        agent_id=agent_state.id,
+        actor=actor,
+    )
+
+    if archive:
+        archive_tags = await passage_manager.get_unique_tags_for_archive_async(
+            archive_id=archive.id,
+            actor=actor,
+        )
+    else:
+        archive_tags = None
+
+    # TODO: This is a pretty brittle pattern established all over our code, need to get rid of this
+    curr_system_message = in_context_messages[0]
+    curr_system_message_text = curr_system_message.content[0].text
+
+    # extract the dynamic section that includes memory blocks, tool rules, and directories
+    # this avoids timestamp comparison issues
+    def extract_dynamic_section(text):
+        start_marker = "</base_instructions>"
+        end_marker = "<memory_metadata>"
+
+        start_idx = text.find(start_marker)
+        end_idx = text.find(end_marker)
+
+        if start_idx != -1 and end_idx != -1:
+            return text[start_idx:end_idx]
+        return text  # fallback to full text if markers not found
+
+    curr_dynamic_section = extract_dynamic_section(curr_system_message_text)
+
+    # generate just the memory string with current state for comparison
+    curr_memory_str = agent_state.memory.compile(
+        tool_usage_rules=tool_constraint_block,
+        sources=agent_state.sources,
+        max_files_open=agent_state.max_files_open,
+        llm_config=agent_state.llm_config,
+    )
+    new_dynamic_section = extract_dynamic_section(curr_memory_str)
+
+    # compare just the dynamic sections (memory blocks, tool rules, directories)
+    if curr_dynamic_section == new_dynamic_section:
+        return in_context_messages, agent_state
+
+    memory_edit_timestamp = get_utc_time()
+
+    # size of messages and archival memories
+    if num_messages is None:
+        num_messages = await message_manager.size_async(actor=actor, agent_id=agent_state.id)
+    if num_archival_memories is None:
+        num_archival_memories = await passage_manager.agent_passage_size_async(actor=actor, agent_id=agent_state.id)
+
+    new_system_message_str = PromptGenerator.get_system_message_from_compiled_memory(
+        system_prompt=agent_state.system,
+        memory_with_sources=curr_memory_str,
+        in_context_memory_last_edit=memory_edit_timestamp,
+        timezone=agent_state.timezone,
+        previous_message_count=num_messages - len(in_context_messages),
+        archival_memory_size=num_archival_memories,
+        archive_tags=archive_tags,
+    )
+
+    diff = united_diff(curr_system_message_text, new_system_message_str)
+    if len(diff) > 0:
+        # [DB Call] Update Messages
+        # NOTE: So this is the only write in the activity
+        # I think this fine, since it's okay to rewrite the system message, it's idempotent afaik
+        new_system_message = await message_manager.update_message_by_id_async(
+            curr_system_message.id, message_update=MessageUpdate(content=new_system_message_str), actor=actor
+        )
+        return [new_system_message] + in_context_messages[1:], agent_state
+
+    else:
+        return in_context_messages, agent_state
+
+
+@activity.defn(name="refresh_context_and_system_message")
+async def refresh_context_and_system_message(params: RefreshContextParams) -> RefreshContextResult:
+    agent_state = params.agent_state
+    in_context_messages = list(params.in_context_messages)
+    tool_rules_solver = params.tool_rules_solver
+    actor = params.actor
+
+    message_manager = MessageManager()
+    passage_manager = PassageManager()
+    agent_manager = AgentManager()
+    archive_manager = ArchiveManager()
+
+    """Mirror LettaAgentV2._refresh_messages + _rebuild_memory as an activity."""
+    num_messages = await message_manager.size_async(
+        agent_id=agent_state.id,
+        actor=actor,
+    )
+    num_archival_memories = await passage_manager.agent_passage_size_async(
+        agent_id=agent_state.id,
+        actor=actor,
+    )
+    in_context_messages, agent_state = await _rebuild_memory(
+        agent_state=agent_state,
+        in_context_messages=in_context_messages,
+        num_messages=num_messages,
+        num_archival_memories=num_archival_memories,
+        actor=actor,
+        message_manager=message_manager,
+        passage_manager=passage_manager,
+        agent_manager=agent_manager,
+        archive_manager=archive_manager,
+        tool_rules_solver=tool_rules_solver,
+    )
+
+    in_context_messages = scrub_inner_thoughts_from_messages(in_context_messages, agent_state.llm_config)
+    return RefreshContextResult(messages=in_context_messages, agent_state=agent_state)

letta/agents/temporal/activities/summarize_conversation_history.py

@@ -0,0 +1,77 @@
+from typing import List
+
+from temporalio import activity
+
+from letta.agents.temporal.types import SummarizeParams
+from letta.schemas.agent import AgentType
+from letta.schemas.message import Message
+from letta.services.agent_manager import AgentManager
+from letta.services.message_manager import MessageManager
+from letta.services.summarizer.enums import SummarizationMode
+from letta.services.summarizer.summarizer import Summarizer
+from letta.settings import summarizer_settings
+
+
+@activity.defn(name="summarize_conversation_history")
+async def summarize_conversation_history(params: SummarizeParams) -> List[Message]:
+    """Summarize/evict history to fit context window and update agent message ids.
+
+    This activity mirrors LettaAgentV2.summarize_conversation_history:
+      - If force or tokens exceed window, call Summarizer.summarize(..., force=True, clear=True)
+      - Else call Summarizer.summarize(...) without force to perform partial evictions as needed
+      - Update AgentManager.update_message_ids_async with new in-context message IDs
+      - Return the updated in_context_messages
+
+    Notes:
+      - This activity performs DB updates and should remain an activity for determinism.
+      - Summarizer instance is created/configured inside the activity using agent_state and managers.
+    """
+    # instantiate managers
+    agent_manager = AgentManager()
+    message_manager = MessageManager()
+
+    # determine summarization mode based on agent type
+    mode = (
+        SummarizationMode.STATIC_MESSAGE_BUFFER
+        if params.agent_state.agent_type == AgentType.voice_convo_agent
+        else summarizer_settings.mode
+    )
+
+    # create summarizer instance with configuration from settings
+    summarizer = Summarizer(
+        mode=mode,
+        summarizer_agent=None,  # temporal doesn't use summarization agents yet
+        message_buffer_limit=summarizer_settings.message_buffer_limit,
+        message_buffer_min=summarizer_settings.message_buffer_min,
+        partial_evict_summarizer_percentage=summarizer_settings.partial_evict_summarizer_percentage,
+        agent_manager=agent_manager,
+        message_manager=message_manager,
+        actor=params.actor,
+        agent_id=params.agent_state.id,
+    )
+
+    # perform summarization
+    if params.force:
+        # force summarization with clear flag when context window exceeded
+        new_in_context_messages, updated = await summarizer.summarize(
+            in_context_messages=params.in_context_messages,
+            new_letta_messages=params.new_letta_messages,
+            force=True,
+            clear=True,
+        )
+    else:
+        # regular summarization without force
+        new_in_context_messages, updated = await summarizer.summarize(
+            in_context_messages=params.in_context_messages,
+            new_letta_messages=params.new_letta_messages,
+        )
+
+    # update agent message ids in database
+    message_ids = [m.id for m in new_in_context_messages]
+    await agent_manager.update_message_ids_async(
+        agent_id=params.agent_state.id,
+        message_ids=message_ids,
+        actor=params.actor,
+    )
+
+    return new_in_context_messages

letta/agents/temporal/activities/update_message_ids.py

@@ -0,0 +1,25 @@
+from temporalio import activity
+
+from letta.agents.temporal.types import UpdateMessageIdsParams, UpdateMessageIdsResult
+from letta.services.agent_manager import AgentManager
+
+
+@activity.defn(name="update_message_ids")
+async def update_message_ids(params: UpdateMessageIdsParams) -> UpdateMessageIdsResult:
+    """Update agent's message IDs in the database."""
+    agent_manager = AgentManager()
+
+    # update message ids in database
+    await agent_manager.update_message_ids_async(
+        agent_id=params.agent_id,
+        message_ids=params.message_ids,
+        actor=params.actor,
+    )
+
+    # get the updated agent state
+    updated_agent_state = await agent_manager.get_agent_async(
+        agent_id=params.agent_id,
+        actor=params.actor,
+    )
+
+    return UpdateMessageIdsResult(success=True, agent_state=updated_agent_state, persisted_messages=[])

letta/agents/temporal/activities/update_run.py

@@ -0,0 +1,43 @@
+from temporalio import activity
+
+from letta.agents.temporal.types import UpdateRunParams
+from letta.schemas.letta_response import LettaResponse
+from letta.schemas.letta_stop_reason import LettaStopReason, StopReasonType
+from letta.schemas.message import Message
+from letta.schemas.run import RunUpdate
+from letta.services.run_manager import RunManager
+
+
+@activity.defn(name="update_run")
+async def update_run(params: UpdateRunParams) -> None:
+    """
+    Update run status and add messages to run.
+    """
+    run_manager = RunManager()
+
+    if params.stop_reason is None:
+        params.stop_reason = LettaStopReason(stop_reason=StopReasonType.end_turn.value)
+    messages = Message.to_letta_messages_from_list(params.persisted_messages, use_assistant_message=True, reverse=False)
+    result = LettaResponse(messages=messages, stop_reason=params.stop_reason, usage=params.usage)
+
+    # Update run status
+    update = RunUpdate(
+        status=params.run_status,
+        stop_reason=params.stop_reason.stop_reason if params.stop_reason else None,
+        metadata_={"result": result.model_dump(mode="json")},
+        total_duration_ns=params.total_duration_ns,
+    )
+
+    await run_manager.update_run_by_id_async(
+        run_id=params.run_id,
+        update=update,
+        actor=params.actor,
+        refresh_result_messages=False,  # TODO: Temporary field while there's discrepancies between Temporal / rest of message invocation endpoints
+    )
+
+    # TODO: we shouldn't have a try / catch here and fix idempotency thoroughly, fixing to enable re-running jobs
+    # Note: RunManager doesn't have an add_messages method
+    # Messages are typically associated with the run through steps
+    # This functionality may need to be handled differently
+
+    return

letta/agents/temporal/constants.py

@@ -0,0 +1,59 @@
+from datetime import timedelta
+
+from temporalio.common import RetryPolicy
+
+# prepare_messages (reads context, builds input messages)
+PREPARE_MESSAGES_ACTIVITY_START_TO_CLOSE_TIMEOUT = timedelta(seconds=30)
+PREPARE_MESSAGES_ACTIVITY_SCHEDULE_TO_CLOSE_TIMEOUT = timedelta(minutes=2)
+
+# refresh_context_and_system_message (rebuilds memory/system prompt, scrubs)
+REFRESH_CONTEXT_ACTIVITY_START_TO_CLOSE_TIMEOUT = timedelta(seconds=180)
+REFRESH_CONTEXT_ACTIVITY_SCHEDULE_TO_CLOSE_TIMEOUT = timedelta(minutes=5)
+
+# llm_request (provider call; can be retried with summarization)
+LLM_ACTIVITY_START_TO_CLOSE_TIMEOUT = timedelta(seconds=300)
+LLM_ACTIVITY_SCHEDULE_TO_CLOSE_TIMEOUT = timedelta(minutes=30)
+
+# Temporal-native retry policy for LLM activity calls.
+# - Retries transient LLM* errors with exponential backoff
+# - Avoids auto-retry on context window issues (handled in workflow via summarization)
+# - Avoids auto-retry on invalid/unsuccessful response parsing
+LLM_ACTIVITY_RETRY_POLICY = RetryPolicy(
+    initial_interval=timedelta(seconds=1),
+    backoff_coefficient=2.0,
+    maximum_interval=timedelta(seconds=30),
+    maximum_attempts=5,
+    non_retryable_error_types=[
+        # Handled explicitly in workflow to alter inputs then re-call
+        "ContextWindowExceededError",
+        # Treat parsing/invalid response as non-retryable at activity layer
+        "ValueError",
+        "LLMJSONParsingError",
+        # Non-retryable LLM API errors
+        "LLMBadRequestError",
+        "LLMAuthenticationError",
+        "LLMPermissionDeniedError",
+        "LLMNotFoundError",
+        "LLMUnprocessableEntityError",
+    ],
+)
+
+# summarize_conversation_history (evicts history, updates message IDs)
+SUMMARIZE_ACTIVITY_START_TO_CLOSE_TIMEOUT = timedelta(seconds=300)
+SUMMARIZE_ACTIVITY_SCHEDULE_TO_CLOSE_TIMEOUT = timedelta(minutes=10)
+
+# tool execution (used later during _handle_ai_response)
+TOOL_EXECUTION_ACTIVITY_START_TO_CLOSE_TIMEOUT = timedelta(seconds=600)
+TOOL_EXECUTION_ACTIVITY_SCHEDULE_TO_CLOSE_TIMEOUT = timedelta(minutes=30)
+
+# create_step (saves step to agent state)
+CREATE_STEP_ACTIVITY_START_TO_CLOSE_TIMEOUT = timedelta(seconds=60)
+CREATE_STEP_ACTIVITY_SCHEDULE_TO_CLOSE_TIMEOUT = timedelta(minutes=30)
+
+# create_messages (saves messages to agent state)
+CREATE_MESSAGES_ACTIVITY_START_TO_CLOSE_TIMEOUT = timedelta(seconds=60)
+CREATE_MESSAGES_ACTIVITY_SCHEDULE_TO_CLOSE_TIMEOUT = timedelta(minutes=30)
+
+# update run metadata (saves status to run)
+UPDATE_RUN_ACTIVITY_START_TO_CLOSE_TIMEOUT = timedelta(seconds=60)
+UPDATE_RUN_ACTIVITY_SCHEDULE_TO_CLOSE_TIMEOUT = timedelta(minutes=30)