letta-nightly 0.8.5.dev20250625104328__py3-none-any.whl → 0.8.6.dev20250626104326__py3-none-any.whl

letta/schemas/agent.py

@@ -4,8 +4,12 @@ from typing import Dict, List, Optional
 
 from pydantic import BaseModel, Field, field_validator, model_validator
 
-from letta.constants import CORE_MEMORY_LINE_NUMBER_WARNING, DEFAULT_EMBEDDING_CHUNK_SIZE
-from letta.helpers import ToolRulesSolver
+from letta.constants import (
+    CORE_MEMORY_LINE_NUMBER_WARNING,
+    DEFAULT_EMBEDDING_CHUNK_SIZE,
+    FILE_MEMORY_EMPTY_MESSAGE,
+    FILE_MEMORY_EXISTS_MESSAGE,
+)
 from letta.schemas.block import CreateBlock
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.environment_variables import AgentEnvironmentVariable
@@ -110,6 +114,9 @@ class AgentState(OrmMetadataBase, validate_assignment=True):
     last_run_completion: Optional[datetime] = Field(None, description="The timestamp when the agent last completed a run.")
     last_run_duration_ms: Optional[int] = Field(None, description="The duration in milliseconds of the agent's last run.")
 
+    # timezone
+    timezone: Optional[str] = Field(None, description="The timezone of the agent (IANA format).")
+
     def get_agent_env_vars_as_dict(self) -> Dict[str, str]:
         # Get environment variables for this agent specifically
         per_agent_env_vars = {}
@@ -193,6 +200,7 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
     )
     enable_sleeptime: Optional[bool] = Field(None, description="If set to True, memory management will move to a background agent thread.")
     response_format: Optional[ResponseFormatUnion] = Field(None, description="The response format for the agent.")
+    timezone: Optional[str] = Field(None, description="The timezone of the agent (IANA format).")
 
     @field_validator("name")
     @classmethod
@@ -286,6 +294,7 @@ class UpdateAgent(BaseModel):
     response_format: Optional[ResponseFormatUnion] = Field(None, description="The response format for the agent.")
     last_run_completion: Optional[datetime] = Field(None, description="The timestamp when the agent last completed a run.")
     last_run_duration_ms: Optional[int] = Field(None, description="The duration in milliseconds of the agent's last run.")
+    timezone: Optional[str] = Field(None, description="The timezone of the agent (IANA format).")
 
     class Config:
         extra = "ignore"  # Ignores extra fields
@@ -301,11 +310,6 @@ class AgentStepResponse(BaseModel):
     usage: UsageStatistics = Field(..., description="Usage statistics of the LLM call during the agent's step.")
 
 
-class AgentStepState(BaseModel):
-    step_number: int = Field(..., description="The current step number in the agent loop")
-    tool_rules_solver: ToolRulesSolver = Field(..., description="The current state of the ToolRulesSolver")
-
-
 def get_prompt_template_for_agent_type(agent_type: Optional[AgentType] = None):
 
     # Sleeptime agents use the MemGPT v2 memory tools (line numbers)
@@ -333,24 +337,34 @@ def get_prompt_template_for_agent_type(agent_type: Optional[AgentType] = None):
             "{% if not loop.last %}\n{% endif %}"
             "{% endfor %}"
             "\n</memory_blocks>"
-            "<files>\nThe following memory files are currently accessible:\n\n"
+            "\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 %}"
+            f"\n\n<files>\n{{% if file_blocks %}}{FILE_MEMORY_EXISTS_MESSAGE}\n{{% else %}}{FILE_MEMORY_EMPTY_MESSAGE}{{% endif %}}"
             "{% for block in file_blocks %}"
             f"<file status=\"{{{{ '{FileStatus.open.value}' if block.value else '{FileStatus.closed.value}' }}}}\">\n"
             "<{{ 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"
             f"{CORE_MEMORY_LINE_NUMBER_WARNING}\n"
             "{% for line in block.value.split('\\n') %}"
-            "Line {{ loop.index }}: {{ line }}\n"
+            "{{ loop.index }}: {{ line }}\n"
             "{% endfor %}"
             "</value>\n"
+            "{% endif %}"
             "</{{ block.label }}>\n"
             "</file>\n"
             "{% if not loop.last %}\n{% endif %}"
@@ -379,21 +393,31 @@ def get_prompt_template_for_agent_type(agent_type: Optional[AgentType] = None):
             "{% if not loop.last %}\n{% endif %}"
             "{% endfor %}"
             "\n</memory_blocks>"
-            "<files>\nThe following memory files are currently accessible:\n\n"
+            "\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 %}"
+            f"\n\n<files>\n{{% if file_blocks %}}{FILE_MEMORY_EXISTS_MESSAGE}\n{{% else %}}{FILE_MEMORY_EMPTY_MESSAGE}{{% endif %}}"
             "{% for block in file_blocks %}"
             f"<file status=\"{{{{ '{FileStatus.open.value}' if block.value else '{FileStatus.closed.value}' }}}}\">\n"
             "<{{ 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 %}"
             "</{{ block.label }}>\n"
             "</file>\n"
             "{% if not loop.last %}\n{% endif %}"

letta/schemas/enums.py

@@ -45,7 +45,7 @@ class JobStatus(str, Enum):
     Status of the job.
     """
 
-    not_started = "not_started"
+    #  TODO (cliandy): removed `not_started`, but what does `pending` or `expired` here mean and where do we use them?
     created = "created"
     running = "running"
     completed = "completed"
@@ -86,6 +86,7 @@ class ToolRuleType(str, Enum):
     constrain_child_tools = "constrain_child_tools"
     max_count_per_step = "max_count_per_step"
     parent_last_tool = "parent_last_tool"
+    required_before_exit = "required_before_exit"  # tool must be called before loop can exit
 
 
 class FileProcessingStatus(str, Enum):
@@ -94,3 +95,43 @@ class FileProcessingStatus(str, Enum):
     EMBEDDING = "embedding"
     COMPLETED = "completed"
     ERROR = "error"
+
+
+class ToolType(str, Enum):
+    CUSTOM = "custom"
+    LETTA_CORE = "letta_core"
+    LETTA_MEMORY_CORE = "letta_memory_core"
+    LETTA_MULTI_AGENT_CORE = "letta_multi_agent_core"
+    LETTA_SLEEPTIME_CORE = "letta_sleeptime_core"
+    LETTA_VOICE_SLEEPTIME_CORE = "letta_voice_sleeptime_core"
+    LETTA_BUILTIN = "letta_builtin"
+    LETTA_FILES_CORE = "letta_files_core"
+    EXTERNAL_COMPOSIO = "external_composio"
+    EXTERNAL_LANGCHAIN = "external_langchain"
+    # TODO is "external" the right name here? Since as of now, MCP is local / doesn't support remote?
+    EXTERNAL_MCP = "external_mcp"
+
+
+class JobType(str, Enum):
+    JOB = "job"
+    RUN = "run"
+    BATCH = "batch"
+
+
+class ToolSourceType(str, Enum):
+    """Defines what a tool was derived from"""
+
+    python = "python"
+    json = "json"
+
+
+class ActorType(str, Enum):
+    LETTA_USER = "letta_user"
+    LETTA_AGENT = "letta_agent"
+    LETTA_SYSTEM = "letta_system"
+
+
+class MCPServerType(str, Enum):
+    SSE = "sse"
+    STDIO = "stdio"
+    STREAMABLE_HTTP = "streamable_http"

letta/schemas/job.py

@@ -1,12 +1,12 @@
 from datetime import datetime
-from typing import Optional
+from typing import List, Optional
 
 from pydantic import BaseModel, Field
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
-from letta.orm.enums import JobType
-from letta.schemas.enums import JobStatus
+from letta.schemas.enums import JobStatus, JobType
 from letta.schemas.letta_base import OrmMetadataBase
+from letta.schemas.letta_message import MessageType
 
 
 class JobBase(OrmMetadataBase):
@@ -94,3 +94,6 @@ class LettaRequestConfig(BaseModel):
         default=DEFAULT_MESSAGE_TOOL_KWARG,
         description="The name of the message argument in the designated message tool.",
     )
+    include_return_message_types: Optional[List[MessageType]] = Field(
+        default=None, description="Only return specified message types in the response. If `None` (default) returns all messages."
+    )

letta/schemas/letta_request.py

@@ -39,6 +39,10 @@ class LettaStreamingRequest(LettaRequest):
     )
 
 
+class LettaAsyncRequest(LettaRequest):
+    callback_url: Optional[str] = Field(None, description="Optional callback URL to POST to when the job completes")
+
+
 class LettaBatchRequest(LettaRequest):
     agent_id: str = Field(..., description="The ID of the agent to send this batch request for")
 

letta/schemas/llm_batch_job.py

@@ -2,14 +2,19 @@ from datetime import datetime
 from typing import Optional, Union
 
 from anthropic.types.beta.messages import BetaMessageBatch, BetaMessageBatchIndividualResponse
-from pydantic import Field
+from pydantic import BaseModel, Field
 
-from letta.schemas.agent import AgentStepState
+from letta.helpers import ToolRulesSolver
 from letta.schemas.enums import AgentStepStatus, JobStatus, ProviderType
 from letta.schemas.letta_base import OrmMetadataBase
 from letta.schemas.llm_config import LLMConfig
 
 
+class AgentStepState(BaseModel):
+    step_number: int = Field(..., description="The current step number in the agent loop")
+    tool_rules_solver: ToolRulesSolver = Field(..., description="The current state of the ToolRulesSolver")
+
+
 class LLMBatchItemBase(OrmMetadataBase, validate_assignment=True):
     __id_prefix__ = "batch_item"
 

letta/schemas/memory.py

@@ -108,10 +108,10 @@ class Memory(BaseModel, validate_assignment=True):
         except Exception as e:
             raise ValueError(f"Prompt template is not compatible with current memory structure: {str(e)}")
 
-    def compile(self) -> str:
+    def compile(self, tool_usage_rules=None) -> str:
         """Generate a string representation of the memory in-context using the Jinja2 template"""
         template = Template(self.prompt_template)
-        return template.render(blocks=self.blocks, file_blocks=self.file_blocks)
+        return template.render(blocks=self.blocks, file_blocks=self.file_blocks, tool_usage_rules=tool_usage_rules)
 
     def list_block_labels(self) -> List[str]:
         """Return a list of the block names held inside the memory object"""

letta/schemas/providers.py

@@ -98,7 +98,7 @@ class Provider(ProviderBase):
             case ProviderType.anthropic:
                 return AnthropicProvider(**self.model_dump(exclude_none=True))
             case ProviderType.bedrock:
-                return AnthropicBedrockProvider(**self.model_dump(exclude_none=True))
+                return BedrockProvider(**self.model_dump(exclude_none=True))
             case ProviderType.ollama:
                 return OllamaProvider(**self.model_dump(exclude_none=True))
             case ProviderType.google_ai:
@@ -1513,15 +1513,15 @@ class CohereProvider(OpenAIProvider):
     pass
 
 
-class AnthropicBedrockProvider(Provider):
+class BedrockProvider(Provider):
     provider_type: Literal[ProviderType.bedrock] = Field(ProviderType.bedrock, description="The type of the provider.")
     provider_category: ProviderCategory = Field(ProviderCategory.base, description="The category of the provider (base or byok)")
-    aws_region: str = Field(..., description="AWS region for Bedrock")
+    region: str = Field(..., description="AWS region for Bedrock")
 
     def list_llm_models(self):
         from letta.llm_api.aws_bedrock import bedrock_get_model_list
 
-        models = bedrock_get_model_list(self.aws_region)
+        models = bedrock_get_model_list(self.region)
 
         configs = []
         for model_summary in models:
@@ -1539,6 +1539,32 @@ class AnthropicBedrockProvider(Provider):
             )
         return configs
 
+    async def list_llm_models_async(self) -> List[LLMConfig]:
+        from letta.llm_api.aws_bedrock import bedrock_get_model_list_async
+
+        models = await bedrock_get_model_list_async(
+            self.access_key,
+            self.api_key,
+            self.region,
+        )
+
+        configs = []
+        for model_summary in models:
+            model_arn = model_summary["inferenceProfileArn"]
+            configs.append(
+                LLMConfig(
+                    model=model_arn,
+                    model_endpoint_type=self.provider_type.value,
+                    model_endpoint=None,
+                    context_window=self.get_model_context_window(model_arn),
+                    handle=self.get_handle(model_arn),
+                    provider_name=self.name,
+                    provider_category=self.provider_category,
+                )
+            )
+
+        return configs
+
     def list_embedding_models(self):
         return []
 
@@ -1548,7 +1574,7 @@ class AnthropicBedrockProvider(Provider):
 
         return bedrock_get_model_context_window(model_name)
 
-    def get_handle(self, model_name: str) -> str:
+    def get_handle(self, model_name: str, is_embedding: bool = False, base_name: Optional[str] = None) -> str:
         print(model_name)
         model = model_name.split(".")[-1]
-        return f"bedrock/{model}"
+        return f"{self.name}/{model}"

letta/schemas/run.py

@@ -2,7 +2,7 @@ from typing import Optional
 
 from pydantic import Field
 
-from letta.orm.enums import JobType
+from letta.schemas.enums import JobType
 from letta.schemas.job import Job, JobBase, LettaRequestConfig
 
 

letta/schemas/tool_rule.py

@@ -52,7 +52,7 @@ class ChildToolRule(BaseToolRule):
     type: Literal[ToolRuleType.constrain_child_tools] = ToolRuleType.constrain_child_tools
     children: List[str] = Field(..., description="The children tools that can be invoked.")
     prompt_template: Optional[str] = Field(
-        default="<tool_constraint>After using {{ tool_name }}, you can only use these tools: {{ children | join(', ') }}</tool_constraint>",
+        default="<tool_rule>\nAfter using {{ tool_name }}, you must use one of these tools: {{ children | join(', ') }}\n</tool_rule>",
         description="Optional Jinja2 template for generating agent prompt about this tool rule.",
     )
 
@@ -61,7 +61,7 @@ class ChildToolRule(BaseToolRule):
         return set(self.children) if last_tool == self.tool_name else available_tools
 
     def _get_default_template(self) -> Optional[str]:
-        return "<tool_constraint>After using {{ tool_name }}, you can only use these tools: {{ children | join(', ') }}</tool_constraint>"
+        return "<tool_rule>\nAfter using {{ tool_name }}, you must use one of these tools: {{ children | join(', ') }}\n</tool_rule>"
 
 
 class ParentToolRule(BaseToolRule):
@@ -72,7 +72,7 @@ class ParentToolRule(BaseToolRule):
     type: Literal[ToolRuleType.parent_last_tool] = ToolRuleType.parent_last_tool
     children: List[str] = Field(..., description="The children tools that can be invoked.")
     prompt_template: Optional[str] = Field(
-        default="<tool_constraint>{{ children | join(', ') }} can only be used after {{ tool_name }}</tool_constraint>",
+        default="<tool_rule>\n{{ children | join(', ') }} can only be used after {{ tool_name }}\n</tool_rule>",
         description="Optional Jinja2 template for generating agent prompt about this tool rule.",
     )
 
@@ -81,7 +81,7 @@ class ParentToolRule(BaseToolRule):
         return set(self.children) if last_tool == self.tool_name else available_tools - set(self.children)
 
     def _get_default_template(self) -> Optional[str]:
-        return "<tool_constraint>{{ children | join(', ') }} can only be used after {{ tool_name }}</tool_constraint>"
+        return "<tool_rule>\n{{ children | join(', ') }} can only be used after {{ tool_name }}\n</tool_rule>"
 
 
 class ConditionalToolRule(BaseToolRule):
@@ -94,7 +94,7 @@ class ConditionalToolRule(BaseToolRule):
     child_output_mapping: Dict[Any, str] = Field(..., description="The output case to check for mapping")
     require_output_mapping: bool = Field(default=False, description="Whether to throw an error when output doesn't match any case")
     prompt_template: Optional[str] = Field(
-        default="<tool_constraint>{{ tool_name }} will determine which tool to use next based on its output</tool_constraint>",
+        default="<tool_rule>\n{{ tool_name }} will determine which tool to use next based on its output\n</tool_rule>",
         description="Optional Jinja2 template for generating agent prompt about this tool rule.",
     )
 
@@ -143,7 +143,7 @@ class ConditionalToolRule(BaseToolRule):
             return str(function_output) == str(key)
 
     def _get_default_template(self) -> Optional[str]:
-        return "<tool_constraint>{{ tool_name }} will determine which tool to use next based on its output</tool_constraint>"
+        return "<tool_rule>\n{{ tool_name }} will determine which tool to use next based on its output\n</tool_rule>"
 
 
 class InitToolRule(BaseToolRule):
@@ -161,12 +161,12 @@ class TerminalToolRule(BaseToolRule):
 
     type: Literal[ToolRuleType.exit_loop] = ToolRuleType.exit_loop
     prompt_template: Optional[str] = Field(
-        default="<tool_constraint>{{ tool_name }} ends the conversation when called</tool_constraint>",
+        default="<tool_rule>\n{{ tool_name }} ends your response (yields control) when called\n</tool_rule>",
         description="Optional Jinja2 template for generating agent prompt about this tool rule.",
     )
 
     def _get_default_template(self) -> Optional[str]:
-        return "<tool_constraint>{{ tool_name }} ends the conversation when called</tool_constraint>"
+        return "<tool_rule>\n{{ tool_name }} ends your response (yields control) when called\n</tool_rule>"
 
 
 class ContinueToolRule(BaseToolRule):
@@ -176,11 +176,30 @@ class ContinueToolRule(BaseToolRule):
 
     type: Literal[ToolRuleType.continue_loop] = ToolRuleType.continue_loop
     prompt_template: Optional[str] = Field(
-        default="<tool_constraint>{{ tool_name }} requires continuing the conversation when called</tool_constraint>",
+        default="<tool_rule>\n{{ tool_name }} requires continuing your response when called\n</tool_rule>",
         description="Optional Jinja2 template for generating agent prompt about this tool rule.",
     )
 
 
+class RequiredBeforeExitToolRule(BaseToolRule):
+    """
+    Represents a tool rule configuration where this tool must be called before the agent loop can exit.
+    """
+
+    type: Literal[ToolRuleType.required_before_exit] = ToolRuleType.required_before_exit
+    prompt_template: Optional[str] = Field(
+        default="<tool_rule>{{ tool_name }} must be called before ending the conversation</tool_rule>",
+        description="Optional Jinja2 template for generating agent prompt about this tool rule.",
+    )
+
+    def get_valid_tools(self, tool_call_history: List[str], available_tools: Set[str], last_function_response: Optional[str]) -> Set[str]:
+        """Returns all available tools - the logic for preventing exit is handled elsewhere."""
+        return available_tools
+
+    def _get_default_template(self) -> Optional[str]:
+        return "<tool_rule>{{ tool_name }} must be called before ending the conversation</tool_rule>"
+
+
 class MaxCountPerStepToolRule(BaseToolRule):
     """
     Represents a tool rule configuration which constrains the total number of times this tool can be invoked in a single step.
@@ -189,7 +208,7 @@ class MaxCountPerStepToolRule(BaseToolRule):
     type: Literal[ToolRuleType.max_count_per_step] = ToolRuleType.max_count_per_step
     max_count_limit: int = Field(..., description="The max limit for the total number of times this tool can be invoked in a single step.")
     prompt_template: Optional[str] = Field(
-        default="<tool_constraint>{{ tool_name }}: max {{ max_count_limit }} use(s) per turn</tool_constraint>",
+        default="<tool_rule>\n{{ tool_name }}: max {{ max_count_limit }} use(s) per response\n</tool_rule>",
         description="Optional Jinja2 template for generating agent prompt about this tool rule.",
     )
 
@@ -204,10 +223,19 @@ class MaxCountPerStepToolRule(BaseToolRule):
         return available_tools
 
     def _get_default_template(self) -> Optional[str]:
-        return "<tool_constraint>{{ tool_name }}: max {{ max_count_limit }} use(s) per turn</tool_constraint>"
+        return "<tool_rule>\n{{ tool_name }}: max {{ max_count_limit }} use(s) per response\n</tool_rule>"
 
 
 ToolRule = Annotated[
-    Union[ChildToolRule, InitToolRule, TerminalToolRule, ConditionalToolRule, ContinueToolRule, MaxCountPerStepToolRule, ParentToolRule],
+    Union[
+        ChildToolRule,
+        InitToolRule,
+        TerminalToolRule,
+        ConditionalToolRule,
+        ContinueToolRule,
+        RequiredBeforeExitToolRule,
+        MaxCountPerStepToolRule,
+        ParentToolRule,
+    ],
     Field(discriminator="type"),
 ]

letta/serialize_schemas/pydantic_agent_schema.py

@@ -3,7 +3,7 @@ from typing import Any, Dict, List, Optional, Union
 from pydantic import BaseModel, Field
 
 from letta.schemas.embedding_config import EmbeddingConfig
-from letta.schemas.letta_message_content import TextContent
+from letta.schemas.letta_message_content import LettaMessageContentUnion
 from letta.schemas.llm_config import LLMConfig
 
 
@@ -25,7 +25,14 @@ class MessageSchema(BaseModel):
     model: Optional[str]
     name: Optional[str]
     role: str
-    content: List[TextContent]  # TODO: Expand to more in the future
+    content: List[LettaMessageContentUnion] = Field(
+        ...,
+        json_schema_extra={
+            "items": {
+                "$ref": "#/components/schemas/LettaMessageContentUnion",
+            }
+        },
+    )
     tool_call_id: Optional[str]
     tool_calls: List[Any]
     tool_returns: List[Any]

letta/server/rest_api/app.py

@@ -385,9 +385,10 @@ def start_server(
                 address=host or "127.0.0.1",  # Note granian address must be an ip address
                 port=port or REST_DEFAULT_PORT,
                 workers=settings.uvicorn_workers,
-                # threads=
+                # runtime_blocking_threads=
+                # runtime_threads=
                 reload=reload or settings.uvicorn_reload,
-                reload_ignore_patterns=["openapi_letta.json"],
+                reload_paths=["../letta/"],
                 reload_ignore_worker_failure=True,
                 reload_tick=4000,  # set to 4s to prevent crashing on weird state
                 # log_level="info"