letta-nightly 0.11.7.dev20250917104122__py3-none-any.whl → 0.11.7.dev20250918104055__py3-none-any.whl

letta/agent.py

@@ -42,7 +42,7 @@ from letta.memory import summarize_messages
 from letta.orm import User
 from letta.otel.tracing import log_event, trace_method
 from letta.prompts.prompt_generator import PromptGenerator
-from letta.schemas.agent import AgentState, AgentStepResponse, UpdateAgent, get_prompt_template_for_agent_type
+from letta.schemas.agent import AgentState, AgentStepResponse, UpdateAgent
 from letta.schemas.block import BlockUpdate
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import MessageRole, ProviderType, StepStatus, ToolType
@@ -221,7 +221,7 @@ class Agent(BaseAgent):
             self.agent_state.memory = Memory(
                 blocks=[self.block_manager.get_block_by_id(block.id, actor=self.user) for block in self.agent_state.memory.get_blocks()],
                 file_blocks=self.agent_state.memory.file_blocks,
-                prompt_template=get_prompt_template_for_agent_type(self.agent_state.agent_type),
+                agent_type=self.agent_state.agent_type,
             )
 
             # NOTE: don't do this since re-buildin the memory is handled at the start of the step
@@ -880,7 +880,7 @@ class Agent(BaseAgent):
             current_persisted_memory = Memory(
                 blocks=[self.block_manager.get_block_by_id(block.id, actor=self.user) for block in self.agent_state.memory.get_blocks()],
                 file_blocks=self.agent_state.memory.file_blocks,
-                prompt_template=get_prompt_template_for_agent_type(self.agent_state.agent_type),
+                agent_type=self.agent_state.agent_type,
             )  # read blocks from DB
             self.update_memory_if_changed(current_persisted_memory)
 

letta/agents/agent_loop.py

@@ -3,7 +3,8 @@ from typing import TYPE_CHECKING
 from letta.agents.base_agent_v2 import BaseAgentV2
 from letta.agents.letta_agent_v2 import LettaAgentV2
 from letta.groups.sleeptime_multi_agent_v3 import SleeptimeMultiAgentV3
-from letta.schemas.agent import AgentState, AgentType
+from letta.schemas.agent import AgentState
+from letta.schemas.enums import AgentType
 
 if TYPE_CHECKING:
     from letta.orm import User

letta/agents/base_agent.py

@@ -139,7 +139,7 @@ class BaseAgent(ABC):
             curr_dynamic_section = extract_dynamic_section(curr_system_message_text)
 
             # generate just the memory string with current state for comparison
-            curr_memory_str = await agent_state.memory.compile_in_thread_async(
+            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
             )
             new_dynamic_section = extract_dynamic_section(curr_memory_str)

letta/agents/letta_agent_v2.py

@@ -29,8 +29,8 @@ from letta.local_llm.constants import INNER_THOUGHTS_KWARG
 from letta.log import get_logger
 from letta.otel.tracing import log_event, trace_method, tracer
 from letta.prompts.prompt_generator import PromptGenerator
-from letta.schemas.agent import AgentState, AgentType, UpdateAgent
-from letta.schemas.enums import JobStatus, MessageRole, MessageStreamStatus, StepStatus
+from letta.schemas.agent import AgentState, UpdateAgent
+from letta.schemas.enums import AgentType, JobStatus, MessageRole, MessageStreamStatus, StepStatus
 from letta.schemas.letta_message import LettaMessage, MessageType
 from letta.schemas.letta_message_content import OmittedReasoningContent, ReasoningContent, RedactedReasoningContent, TextContent
 from letta.schemas.letta_response import LettaResponse
@@ -679,7 +679,7 @@ class LettaAgentV2(BaseAgentV2):
         curr_dynamic_section = extract_dynamic_section(curr_system_message_text)
 
         # generate just the memory string with current state for comparison
-        curr_memory_str = await agent_state.memory.compile_in_thread_async(
+        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
         )
         new_dynamic_section = extract_dynamic_section(curr_memory_str)

letta/agents/temporal/activities/__init__.py

@@ -0,0 +1,4 @@
+from .core_activities import your_activity
+from .processing_activities import process_activity_result
+
+__all__ = ["prepare_messages", "example_activity"]

letta/agents/temporal/activities/example_activity.py

@@ -0,0 +1,7 @@
+from temporalio import activity
+from ..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/prepare_messages.py

@@ -0,0 +1,10 @@
+from temporalio import activity
+from ..types import WorkflowInputParams, PreparedMessages
+
+@activity.defn(name="prepare_messages")
+async def prepare_messages(input_: WorkflowInputParams) -> PreparedMessages:
+    # TODO
+    return PreparedMessages(
+        in_context_messages=[],
+        input_messages_to_persist=[],
+    )

letta/agents/temporal/temporal_agent_workflow.py

@@ -0,0 +1,56 @@
+from dataclasses import dataclass
+from datetime import timedelta
+from temporalio import workflow
+
+from ...schemas.letta_stop_reason import StopReasonType
+from ...schemas.usage import LettaUsageStatistics
+
+# Import activity, passing it through the sandbox without reloading the module
+with workflow.unsafe.imports_passed_through():
+    from .activities import prepare_messages, example_activity
+    from .types import WorkflowInputParams, FinalResult
+
+@workflow.defn
+class TemporalAgentWorkflow:
+    @workflow.run
+    async def run(self, params: WorkflowInputParams) -> FinalResult:
+        messages = await workflow.execute_activity(
+            prepare_messages, params, start_to_close_timeout=timedelta(seconds=5)
+        )
+        result = FinalResult(
+            stop_reason=StopReasonType.end_turn,
+            usage=LettaUsageStatistics(),
+        )
+
+        for i in range(params.max_steps):
+            _ = await workflow.execute_activity(
+                example_activity, messages, start_to_close_timeout=timedelta(seconds=5)
+            )
+            # self._maybe_get_approval_messages
+            # if approval
+                # parse tool params from approval message
+            # else
+                # self._check_run_cancellation
+                # self._refresh_messages
+
+                # try:
+                    # self.llm_client.build_request_data
+                    # self.llm_client.request_async
+                    # self.llm_client.convert_response_to_chat_completion
+                # except ContextWindowExceededError:
+                    # self.summarize_conversation_history
+                    # self.llm_client.build_request_data
+                    # self.llm_client.request_async
+                    # self.llm_client.convert_response_to_chat_completion
+
+                # self._update_global_usage_stats
+                # parse tool call args
+                # self._handle_ai_response <-- this needs to be broken up into individual pieces
+                # self.agent_manager.update_message_ids_async
+                # convert message to letta message and return
+            pass
+
+        # self.summarize_conversation_history
+        # put together final result
+
+        return result

letta/agents/temporal/types.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from typing import List
+from letta.schemas.agent import AgentState
+from letta.schemas.letta_stop_reason import StopReasonType
+from letta.schemas.message import Message, MessageCreate
+from letta.schemas.usage import LettaUsageStatistics
+from letta.schemas.user import User
+
+@dataclass
+class WorkflowInputParams:
+    agent_state: AgentState
+    messages: list[MessageCreate]
+    actor: User
+    max_steps: int = 50
+
+@dataclass
+class PreparedMessages:
+    in_context_messages: List[Message]
+    input_messages_to_persist: List[Message]
+
+
+@dataclass
+class FinalResult:
+    stop_reason: StopReasonType
+    usage: LettaUsageStatistics

letta/agents/voice_agent.py

@@ -14,8 +14,8 @@ from letta.helpers.tool_execution_helper import add_pre_execution_message, enabl
 from letta.interfaces.openai_chat_completions_streaming_interface import OpenAIChatCompletionsStreamingInterface
 from letta.log import get_logger
 from letta.prompts.prompt_generator import PromptGenerator
-from letta.schemas.agent import AgentState, AgentType
-from letta.schemas.enums import MessageRole, ToolType
+from letta.schemas.agent import AgentState
+from letta.schemas.enums import AgentType, MessageRole, ToolType
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.message import Message, MessageCreate
 from letta.schemas.openai.chat_completion_request import (

letta/orm/agent.py

@@ -13,8 +13,9 @@ from letta.orm.identity import Identity
 from letta.orm.mixins import OrganizationMixin, ProjectMixin, TemplateEntityMixin, TemplateMixin
 from letta.orm.organization import Organization
 from letta.orm.sqlalchemy_base import SqlalchemyBase
-from letta.schemas.agent import AgentState as PydanticAgentState, AgentType, get_prompt_template_for_agent_type
+from letta.schemas.agent import AgentState as PydanticAgentState
 from letta.schemas.embedding_config import EmbeddingConfig
+from letta.schemas.enums import AgentType
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import Memory
 from letta.schemas.response_format import ResponseFormatUnion
@@ -249,7 +250,7 @@ class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, TemplateEntityMixin
                     if (block := b.to_pydantic_block(per_file_view_window_char_limit=self._get_per_file_view_window_char_limit()))
                     is not None
                 ],
-                prompt_template=get_prompt_template_for_agent_type(self.agent_type),
+                agent_type=self.agent_type,
             ),
             "identity_ids": lambda: [i.id for i in self.identities],
             "multi_agent_group": lambda: self.multi_agent_group,
@@ -366,7 +367,7 @@ class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, TemplateEntityMixin
                 for b in file_agents
                 if (block := b.to_pydantic_block(per_file_view_window_char_limit=self._get_per_file_view_window_char_limit())) is not None
             ],
-            prompt_template=get_prompt_template_for_agent_type(self.agent_type),
+            agent_type=self.agent_type,
         )
         state["identity_ids"] = [i.id for i in identities]
         state["multi_agent_group"] = multi_agent_group

letta/prompts/prompt_generator.py

@@ -94,7 +94,7 @@ class PromptGenerator:
         timezone: str,
         user_defined_variables: Optional[dict] = None,
         append_icm_if_missing: bool = True,
-        template_format: Literal["f-string", "mustache", "jinja2"] = "f-string",
+        template_format: Literal["f-string", "mustache"] = "f-string",
         previous_message_count: int = 0,
         archival_memory_size: int = 0,
         archive_tags: Optional[List[str]] = None,
@@ -150,7 +150,7 @@ class PromptGenerator:
                 raise ValueError(f"Failed to format system prompt - {str(e)}. System prompt value:\n{system_prompt}")
 
         else:
-            # TODO support for mustache and jinja2
+            # TODO support for mustache
             raise NotImplementedError(template_format)
 
         return formatted_prompt
@@ -164,7 +164,7 @@ class PromptGenerator:
         timezone: str,
         user_defined_variables: Optional[dict] = None,
         append_icm_if_missing: bool = True,
-        template_format: Literal["f-string", "mustache", "jinja2"] = "f-string",
+        template_format: Literal["f-string", "mustache"] = "f-string",
         previous_message_count: int = 0,
         archival_memory_size: int = 0,
         tool_rules_solver: Optional[ToolRulesSolver] = None,
@@ -181,7 +181,7 @@ class PromptGenerator:
         else:
             pass
 
-        memory_with_sources = await in_context_memory.compile_in_thread_async(
+        memory_with_sources = in_context_memory.compile(
             tool_usage_rules=tool_constraint_block, sources=sources, max_files_open=max_files_open
         )
 

letta/schemas/agent.py

@@ -22,6 +22,8 @@ from letta.schemas.tool_rule import ToolRule
 from letta.utils import calculate_file_defaults_based_on_context_window, create_random_username
 
 
+# TODO: Remove this upon next OSS release, there's a duplicate AgentType in enums
+# TODO: This is done in the interest of time to avoid needing to update the sandbox template IDs on cloud/rebuild
 class AgentType(str, Enum):
     """
     Enum to represent the type of agent.
@@ -383,196 +385,5 @@ class AgentStepResponse(BaseModel):
 
 
 def get_prompt_template_for_agent_type(agent_type: Optional[AgentType] = None):
-    # Workflow agents and ReAct agents don't use memory blocks
-    # However, they still allow files to be injected into the context
-    if agent_type == AgentType.react_agent or agent_type == AgentType.workflow_agent:
-        return (
-            "{% if sources %}"
-            "<directories>\n"
-            "{% if max_files_open %}"
-            "<file_limits>\n"
-            "- current_files_open={{ file_blocks|selectattr('value')|list|length }}\n"
-            "- max_files_open={{ max_files_open }}\n"
-            "</file_limits>\n"
-            "{% endif %}"
-            "{% for source in sources %}"
-            f'<directory name="{{{{ source.name }}}}">\n'
-            "{% if source.description %}"
-            "<description>{{ source.description }}</description>\n"
-            "{% endif %}"
-            "{% if source.instructions %}"
-            "<instructions>{{ source.instructions }}</instructions>\n"
-            "{% endif %}"
-            "{% if file_blocks %}"
-            "{% for block in file_blocks %}"
-            "{% if block.source_id and block.source_id == source.id %}"
-            f"<file status=\"{{{{ '{FileStatus.open.value}' if block.value else '{FileStatus.closed.value}' }}}}\">\n"
-            "<{{ block.label }}>\n"
-            "<description>\n"
-            "{{ block.description }}\n"
-            "</description>\n"
-            "<metadata>"
-            "{% if block.read_only %}\n- read_only=true{% endif %}\n"
-            "- chars_current={{ block.value|length }}\n"
-            "- chars_limit={{ block.limit }}\n"
-            "</metadata>\n"
-            "<value>\n"
-            "{{ block.value }}\n"
-            "</value>\n"
-            "</file>\n"
-            "{% endif %}"
-            "{% endfor %}"
-            "{% endif %}"
-            "</directory>\n"
-            "{% endfor %}"
-            "</directories>"
-            "{% endif %}"
-        )
-
-    # Sleeptime agents use the MemGPT v2 memory tools (line numbers)
-    # MemGPT v2 tools use line-number, so core memory blocks should have line numbers
-    elif agent_type == AgentType.sleeptime_agent or agent_type == AgentType.memgpt_v2_agent:
-        return (
-            "<memory_blocks>\nThe following memory blocks are currently engaged in your core memory unit:\n\n"
-            "{% for block in blocks %}"
-            "<{{ block.label }}>\n"
-            "<description>\n"
-            "{{ block.description }}\n"
-            "</description>\n"
-            "<metadata>"
-            "{% if block.read_only %}\n- read_only=true{% endif %}\n"
-            "- chars_current={{ block.value|length }}\n"
-            "- chars_limit={{ block.limit }}\n"
-            "</metadata>\n"
-            "<value>\n"
-            f"{CORE_MEMORY_LINE_NUMBER_WARNING}\n"
-            "{% for line in block.value.split('\\n') %}"
-            "Line {{ loop.index }}: {{ line }}\n"
-            "{% endfor %}"
-            "</value>\n"
-            "</{{ block.label }}>\n"
-            "{% if not loop.last %}\n{% endif %}"
-            "{% endfor %}"
-            "\n</memory_blocks>"
-            "\n\n{% if tool_usage_rules %}"
-            "<tool_usage_rules>\n"
-            "{{ tool_usage_rules.description }}\n\n"
-            "{{ tool_usage_rules.value }}\n"
-            "</tool_usage_rules>"
-            "{% endif %}"
-            "\n\n{% if sources %}"
-            "<directories>\n"
-            "{% if max_files_open %}"
-            "<file_limits>\n"
-            "- current_files_open={{ file_blocks|selectattr('value')|list|length }}\n"
-            "- max_files_open={{ max_files_open }}\n"
-            "</file_limits>\n"
-            "{% endif %}"
-            "{% for source in sources %}"
-            f'<directory name="{{{{ source.name }}}}">\n'
-            "{% if source.description %}"
-            "<description>{{ source.description }}</description>\n"
-            "{% endif %}"
-            "{% if source.instructions %}"
-            "<instructions>{{ source.instructions }}</instructions>\n"
-            "{% endif %}"
-            "{% if file_blocks %}"
-            "{% for block in file_blocks %}"
-            "{% if block.source_id and block.source_id == source.id %}"
-            f"<file status=\"{{{{ '{FileStatus.open.value}' if block.value else '{FileStatus.closed.value}' }}}}\" name=\"{{{{ block.label }}}}\">\n"
-            "{% if block.description %}"
-            "<description>\n"
-            "{{ block.description }}\n"
-            "</description>\n"
-            "{% endif %}"
-            "<metadata>"
-            "{% if block.read_only %}\n- read_only=true{% endif %}\n"
-            "- chars_current={{ block.value|length }}\n"
-            "- chars_limit={{ block.limit }}\n"
-            "</metadata>\n"
-            "{% if block.value %}"
-            "<value>\n"
-            "{{ block.value }}\n"
-            "</value>\n"
-            "{% endif %}"
-            "</file>\n"
-            "{% endif %}"
-            "{% endfor %}"
-            "{% endif %}"
-            "</directory>\n"
-            "{% endfor %}"
-            "</directories>"
-            "{% endif %}"
-        )
-
-    # All other agent types use memory blocks
-    else:
-        return (
-            "<memory_blocks>\nThe following memory blocks are currently engaged in your core memory unit:\n\n"
-            "{% for block in blocks %}"
-            "<{{ block.label }}>\n"
-            "<description>\n"
-            "{{ block.description }}\n"
-            "</description>\n"
-            "<metadata>"
-            "{% if block.read_only %}\n- read_only=true{% endif %}\n"
-            "- chars_current={{ block.value|length }}\n"
-            "- chars_limit={{ block.limit }}\n"
-            "</metadata>\n"
-            "<value>\n"
-            "{{ block.value }}\n"
-            "</value>\n"
-            "</{{ block.label }}>\n"
-            "{% if not loop.last %}\n{% endif %}"
-            "{% endfor %}"
-            "\n</memory_blocks>"
-            "\n\n{% if tool_usage_rules %}"
-            "<tool_usage_rules>\n"
-            "{{ tool_usage_rules.description }}\n\n"
-            "{{ tool_usage_rules.value }}\n"
-            "</tool_usage_rules>"
-            "{% endif %}"
-            "\n\n{% if sources %}"
-            "<directories>\n"
-            "{% if max_files_open %}"
-            "<file_limits>\n"
-            "- current_files_open={{ file_blocks|selectattr('value')|list|length }}\n"
-            "- max_files_open={{ max_files_open }}\n"
-            "</file_limits>\n"
-            "{% endif %}"
-            "{% for source in sources %}"
-            f'<directory name="{{{{ source.name }}}}">\n'
-            "{% if source.description %}"
-            "<description>{{ source.description }}</description>\n"
-            "{% endif %}"
-            "{% if source.instructions %}"
-            "<instructions>{{ source.instructions }}</instructions>\n"
-            "{% endif %}"
-            "{% if file_blocks %}"
-            "{% for block in file_blocks %}"
-            "{% if block.source_id and block.source_id == source.id %}"
-            f"<file status=\"{{{{ '{FileStatus.open.value}' if block.value else '{FileStatus.closed.value}' }}}}\" name=\"{{{{ block.label }}}}\">\n"
-            "{% if block.description %}"
-            "<description>\n"
-            "{{ block.description }}\n"
-            "</description>\n"
-            "{% endif %}"
-            "<metadata>"
-            "{% if block.read_only %}\n- read_only=true{% endif %}\n"
-            "- chars_current={{ block.value|length }}\n"
-            "- chars_limit={{ block.limit }}\n"
-            "</metadata>\n"
-            "{% if block.value %}"
-            "<value>\n"
-            "{{ block.value }}\n"
-            "</value>\n"
-            "{% endif %}"
-            "</file>\n"
-            "{% endif %}"
-            "{% endfor %}"
-            "{% endif %}"
-            "</directory>\n"
-            "{% endfor %}"
-            "</directories>"
-            "{% endif %}"
-        )
+    """Deprecated. Templates are not used anymore; fast renderer handles formatting."""
+    return ""

letta/schemas/enums.py

@@ -21,6 +21,21 @@ class ProviderType(str, Enum):
     xai = "xai"
 
 
+class AgentType(str, Enum):
+    """
+    Enum to represent the type of agent.
+    """
+
+    memgpt_agent = "memgpt_agent"  # the OG set of memgpt tools
+    memgpt_v2_agent = "memgpt_v2_agent"  # memgpt style tools, but refreshed
+    react_agent = "react_agent"  # basic react agent, no memory tools
+    workflow_agent = "workflow_agent"  # workflow with auto-clearing message buffer
+    split_thread_agent = "split_thread_agent"
+    sleeptime_agent = "sleeptime_agent"
+    voice_convo_agent = "voice_convo_agent"
+    voice_sleeptime_agent = "voice_sleeptime_agent"
+
+
 class ProviderCategory(str, Enum):
     base = "base"
     byok = "byok"