letta-nightly 0.11.6.dev20250903104037__py3-none-any.whl → 0.11.7.dev20250904045700__py3-none-any.whl

letta/agents/voice_agent.py

@@ -484,7 +484,7 @@ class VoiceAgent(BaseAgent):
         if start_date and end_date and start_date > end_date:
             start_date, end_date = end_date, start_date
 
-        archival_results = await self.agent_manager.list_passages_async(
+        archival_results = await self.agent_manager.query_agent_passages_async(
             actor=self.actor,
             agent_id=self.agent_id,
             query_text=archival_query,

letta/client/streaming.py

@@ -23,7 +23,6 @@ def _sse_post(url: str, data: dict, headers: dict) -> Generator[Union[LettaStrea
     # TODO: Please note his is a very generous timeout for e2b reasons
     with httpx.Client(timeout=httpx.Timeout(5 * 60.0, read=5 * 60.0)) as client:
         with connect_sse(client, method="POST", url=url, json=data, headers=headers) as event_source:
-
             # Check for immediate HTTP errors before processing the SSE stream
             if not event_source.response.is_success:
                 response_bytes = event_source.response.read()

letta/constants.py

@@ -132,7 +132,7 @@ MEMORY_TOOLS_LINE_NUMBER_PREFIX_REGEX = re.compile(
 )
 
 # Built in tools
-BUILTIN_TOOLS = ["run_code", "web_search"]
+BUILTIN_TOOLS = ["run_code", "web_search", "fetch_webpage"]
 
 # Built in tools
 FILES_TOOLS = ["open_files", "grep_files", "semantic_search_files"]
@@ -167,6 +167,9 @@ def FUNCTION_RETURN_VALUE_TRUNCATED(return_str, return_char: int, return_char_li
 DEFAULT_MESSAGE_TOOL = SEND_MESSAGE_TOOL_NAME
 DEFAULT_MESSAGE_TOOL_KWARG = "message"
 
+# The name of the conversation search tool - messages with this tool should not be indexed
+CONVERSATION_SEARCH_TOOL_NAME = "conversation_search"
+
 PRE_EXECUTION_MESSAGE_ARG = "pre_exec_msg"
 
 REQUEST_HEARTBEAT_PARAM = "request_heartbeat"
@@ -210,12 +213,12 @@ LLM_MAX_TOKENS = {
     "deepseek-reasoner": 64000,
     ## OpenAI models: https://platform.openai.com/docs/models/overview
     # gpt-5
-    "gpt-5": 400000,
-    "gpt-5-2025-08-07": 400000,
-    "gpt-5-mini": 400000,
-    "gpt-5-mini-2025-08-07": 400000,
-    "gpt-5-nano": 400000,
-    "gpt-5-nano-2025-08-07": 400000,
+    "gpt-5": 272000,
+    "gpt-5-2025-08-07": 272000,
+    "gpt-5-mini": 272000,
+    "gpt-5-mini-2025-08-07": 272000,
+    "gpt-5-nano": 272000,
+    "gpt-5-nano-2025-08-07": 272000,
     # reasoners
     "o1": 200000,
     # "o1-pro": 200000,  # responses API only
@@ -340,7 +343,7 @@ CORE_MEMORY_BLOCK_CHAR_LIMIT: int = 20000
 
 # Function return limits
 FUNCTION_RETURN_CHAR_LIMIT = 50000  # ~300 words
-BASE_FUNCTION_RETURN_CHAR_LIMIT = 1000000  # very high (we rely on implementation)
+BASE_FUNCTION_RETURN_CHAR_LIMIT = 50000  # same as regular function limit
 FILE_IS_TRUNCATED_WARNING = "# NOTE: This block is truncated, use functions to view the full content."
 
 MAX_PAUSE_HEARTBEATS = 360  # in min

letta/errors.py

@@ -60,6 +60,15 @@ class LettaToolNameConflictError(LettaError):
         )
 
 
+class LettaToolNameSchemaMismatchError(LettaToolCreateError):
+    """Error raised when a tool name our source codedoes not match the name in the JSON schema."""
+
+    def __init__(self, tool_name: str, json_schema_name: str, source_code: str):
+        super().__init__(
+            message=f"Tool name '{tool_name}' does not match the name in the JSON schema '{json_schema_name}' or in the source code `{source_code}`",
+        )
+
+
 class LettaConfigurationError(LettaError):
     """Error raised when there are configuration-related issues."""
 

letta/functions/function_sets/base.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import List, Literal, Optional
 
 from letta.agent import Agent
 from letta.constants import CORE_MEMORY_LINE_NUMBER_WARNING
@@ -20,113 +20,121 @@ def send_message(self: "Agent", message: str) -> Optional[str]:
     return None
 
 
-def conversation_search(self: "Agent", query: str, page: Optional[int] = 0) -> Optional[str]:
+def conversation_search(
+    self: "Agent",
+    query: str,
+    roles: Optional[List[Literal["assistant", "user", "tool"]]] = None,
+    limit: Optional[int] = None,
+    start_date: Optional[str] = None,
+    end_date: Optional[str] = None,
+) -> Optional[str]:
     """
-    Search prior conversation history using case-insensitive string matching.
+    Search prior conversation history using hybrid search (text + semantic similarity).
 
     Args:
-        query (str): String to search for.
-        page (int): Allows you to page through results. Only use on a follow-up query. Defaults to 0 (first page).
+        query (str): String to search for using both text matching and semantic similarity.
+        roles (Optional[List[Literal["assistant", "user", "tool"]]]): Optional list of message roles to filter by.
+        limit (Optional[int]): Maximum number of results to return. Uses system default if not specified.
+        start_date (Optional[str]): Filter results to messages created after this date. ISO 8601 format: "YYYY-MM-DD" or "YYYY-MM-DDTHH:MM". Examples: "2024-01-15", "2024-01-15T14:30".
+        end_date (Optional[str]): Filter results to messages created before this date. ISO 8601 format: "YYYY-MM-DD" or "YYYY-MM-DDTHH:MM". Examples: "2024-01-20", "2024-01-20T17:00".
+
+    Examples:
+        # Search all messages
+        conversation_search(query="project updates")
+
+        # Search only assistant messages
+        conversation_search(query="error handling", roles=["assistant"])
+
+        # Search with date range
+        conversation_search(query="meetings", start_date="2024-01-15", end_date="2024-01-20")
+
+        # Search with limit
+        conversation_search(query="debugging", limit=10)
 
     Returns:
-        str: Query result string
+        str: Query result string containing matching messages with timestamps and content.
     """
 
-    import math
-
     from letta.constants import RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
     from letta.helpers.json_helpers import json_dumps
 
-    if page is None or (isinstance(page, str) and page.lower().strip() == "none"):
-        page = 0
-    try:
-        page = int(page)
-    except:
-        raise ValueError("'page' argument must be an integer")
-    count = RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
-    # TODO: add paging by page number. currently cursor only works with strings.
-    # original: start=page * count
+    # Use provided limit or default
+    if limit is None:
+        limit = RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
+
     messages = self.message_manager.list_messages_for_agent(
         agent_id=self.agent_state.id,
         actor=self.user,
         query_text=query,
-        limit=count,
+        roles=roles,
+        limit=limit,
     )
-    total = len(messages)
-    num_pages = math.ceil(total / count) - 1  # 0 index
+
     if len(messages) == 0:
         results_str = "No results found."
     else:
-        results_pref = f"Showing {len(messages)} of {total} results (page {page}/{num_pages}):"
-        results_formatted = [message.content[0].text for message in messages]
+        results_pref = f"Found {len(messages)} results:"
+        results_formatted = []
+        for message in messages:
+            # Extract text content from message
+            text_content = message.content[0].text if message.content else ""
+            result_entry = {"role": message.role, "content": text_content}
+            results_formatted.append(result_entry)
         results_str = f"{results_pref} {json_dumps(results_formatted)}"
     return results_str
 
 
-async def archival_memory_insert(self: "Agent", content: str) -> Optional[str]:
+async def archival_memory_insert(self: "Agent", content: str, tags: Optional[list[str]] = None) -> Optional[str]:
     """
     Add to archival memory. Make sure to phrase the memory contents such that it can be easily queried later.
 
     Args:
         content (str): Content to write to the memory. All unicode (including emojis) are supported.
+        tags (Optional[list[str]]): Optional list of tags to associate with this memory for better organization and filtering.
 
     Returns:
         Optional[str]: None is always returned as this function does not produce a response.
     """
-    await self.passage_manager.insert_passage(
-        agent_state=self.agent_state,
-        text=content,
-        actor=self.user,
-    )
-    self.agent_manager.rebuild_system_prompt(agent_id=self.agent_state.id, actor=self.user, force=True)
-    return None
-
-
-async def archival_memory_search(self: "Agent", query: str, page: Optional[int] = 0, start: Optional[int] = 0) -> Optional[str]:
+    raise NotImplementedError("This should never be invoked directly. Contact Letta if you see this error message.")
+
+
+async def archival_memory_search(
+    self: "Agent",
+    query: str,
+    tags: Optional[list[str]] = None,
+    tag_match_mode: Literal["any", "all"] = "any",
+    top_k: Optional[int] = None,
+    start_datetime: Optional[str] = None,
+    end_datetime: Optional[str] = None,
+) -> Optional[str]:
     """
-    Search archival memory using semantic (embedding-based) search.
+    Search archival memory using semantic (embedding-based) search with optional temporal filtering.
 
     Args:
-        query (str): String to search for.
-        page (Optional[int]): Allows you to page through results. Only use on a follow-up query. Defaults to 0 (first page).
-        start (Optional[int]): Starting index for the search results. Defaults to 0.
-
-    Returns:
-        str: Query result string
-    """
+        query (str): String to search for using semantic similarity.
+        tags (Optional[list[str]]): Optional list of tags to filter search results. Only passages with these tags will be returned.
+        tag_match_mode (Literal["any", "all"]): How to match tags - "any" to match passages with any of the tags, "all" to match only passages with all tags. Defaults to "any".
+        top_k (Optional[int]): Maximum number of results to return. Uses system default if not specified.
+        start_datetime (Optional[str]): Filter results to passages created after this datetime. ISO 8601 format: "YYYY-MM-DD" or "YYYY-MM-DDTHH:MM". Examples: "2024-01-15", "2024-01-15T14:30".
+        end_datetime (Optional[str]): Filter results to passages created before this datetime. ISO 8601 format: "YYYY-MM-DD" or "YYYY-MM-DDTHH:MM". Examples: "2024-01-20", "2024-01-20T17:00".
 
-    from letta.constants import RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
-
-    if page is None or (isinstance(page, str) and page.lower().strip() == "none"):
-        page = 0
-    try:
-        page = int(page)
-    except:
-        raise ValueError("'page' argument must be an integer")
-    count = RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
-
-    try:
-        # Get results using passage manager
-        all_results = await self.agent_manager.list_passages_async(
-            actor=self.user,
-            agent_id=self.agent_state.id,
-            query_text=query,
-            limit=count + start,  # Request enough results to handle offset
-            embedding_config=self.agent_state.embedding_config,
-            embed_query=True,
-        )
+    Examples:
+        # Search all passages
+        archival_memory_search(query="project updates")
 
-        # Apply pagination
-        end = min(count + start, len(all_results))
-        paged_results = all_results[start:end]
+        # Search with date range (full days)
+        archival_memory_search(query="meetings", start_datetime="2024-01-15", end_datetime="2024-01-20")
 
-        # Format results to match previous implementation
-        formatted_results = [{"timestamp": str(result.created_at), "content": result.text} for result in paged_results]
+        # Search with specific time range
+        archival_memory_search(query="error logs", start_datetime="2024-01-15T09:30", end_datetime="2024-01-15T17:30")
 
-        return formatted_results, len(formatted_results)
+        # Search from a specific point in time onwards
+        archival_memory_search(query="customer feedback", start_datetime="2024-01-15T14:00")
 
-    except Exception as e:
-        raise e
+    Returns:
+        str: Query result string containing matching passages with timestamps and content.
+    """
+    raise NotImplementedError("This should never be invoked directly. Contact Letta if you see this error message.")
 
 
 def core_memory_append(agent_state: "AgentState", label: str, content: str) -> Optional[str]:  # type: ignore

letta/functions/function_sets/builtin.py

@@ -1,6 +1,4 @@
-from typing import List, Literal
-
-from letta.functions.types import SearchTask
+from typing import List, Literal, Optional
 
 
 def run_code(code: str, language: Literal["python", "js", "ts", "r", "java"]) -> str:
@@ -17,31 +15,52 @@ def run_code(code: str, language: Literal["python", "js", "ts", "r", "java"]) ->
     raise NotImplementedError("This is only available on the latest agent architecture. Please contact the Letta team.")
 
 
-async def web_search(tasks: List[SearchTask], limit: int = 1, return_raw: bool = True) -> str:
+async def web_search(
+    query: str,
+    num_results: int = 10,
+    category: Optional[
+        Literal["company", "research paper", "news", "pdf", "github", "tweet", "personal site", "linkedin profile", "financial report"]
+    ] = None,
+    include_text: bool = False,
+    include_domains: Optional[List[str]] = None,
+    exclude_domains: Optional[List[str]] = None,
+    start_published_date: Optional[str] = None,
+    end_published_date: Optional[str] = None,
+    user_location: Optional[str] = None,
+) -> str:
     """
-    Search the web with a list of query/question pairs and extract passages that answer the corresponding questions.
+    Search the web using Exa's AI-powered search engine and retrieve relevant content.
 
     Examples:
-    tasks -> [
-        SearchTask(
-            query="Tesla Q1 2025 earnings report PDF",
-            question="What was Tesla's net profit in Q1 2025?"
-        ),
-        SearchTask(
-            query="Letta API prebuilt tools core_memory_append",
-            question="What does the core_memory_append tool do in Letta?"
-        )
-    ]
+    web_search("Tesla Q1 2025 earnings report", num_results=5, category="financial report")
+    web_search("Latest research in large language models", category="research paper", include_domains=["arxiv.org", "paperswithcode.com"])
+    web_search("Letta API documentation core_memory_append", num_results=3)
+
+    Args:
+        query (str): The search query to find relevant web content.
+        num_results (int, optional): Number of results to return (1-100). Defaults to 10.
+        category (Optional[Literal], optional): Focus search on specific content types. Defaults to None.
+        include_text (bool, optional): Whether to retrieve full page content. Defaults to False (only returns summary and highlights, since the full text usually will overflow the context window).
+        include_domains (Optional[List[str]], optional): List of domains to include in search results. Defaults to None.
+        exclude_domains (Optional[List[str]], optional): List of domains to exclude from search results. Defaults to None.
+        start_published_date (Optional[str], optional): Only return content published after this date (ISO format). Defaults to None.
+        end_published_date (Optional[str], optional): Only return content published before this date (ISO format). Defaults to None.
+        user_location (Optional[str], optional): Two-letter country code for localized results (e.g., "US"). Defaults to None.
+
+    Returns:
+        str: A JSON-encoded string containing search results with title, URL, content, highlights, and summary.
+    """
+    raise NotImplementedError("This is only available on the latest agent architecture. Please contact the Letta team.")
+
+
+async def fetch_webpage(url: str) -> str:
+    """
+    Fetch a webpage and convert it to markdown/text format using Jina AI reader.
 
     Args:
-        tasks (List[SearchTask]): A list of search tasks, each containing a `query` and a corresponding `question`.
-        limit (int, optional): Maximum number of URLs to fetch and analyse per task (must be > 0). Defaults to 1.
-        return_raw (bool, optional): If set to True, returns the raw content of the web pages.
-                                     This should be True unless otherwise specified by the user. Defaults to True.
+        url: The URL of the webpage to fetch and convert
 
     Returns:
-        str: A JSON-encoded string containing a list of search results.
-             Each result includes ranked snippets with their source URLs and relevance scores,
-             corresponding to each search task.
+        String containing the webpage content in markdown/text format
     """
     raise NotImplementedError("This is only available on the latest agent architecture. Please contact the Letta team.")

letta/functions/function_sets/multi_agent.py

@@ -1,6 +1,5 @@
 import asyncio
 import json
-import os
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from typing import TYPE_CHECKING, List
 
@@ -138,7 +137,7 @@ def send_message_to_agent_async(self: "Agent", message: str, other_agent_id: str
     Returns:
         str: A confirmation message indicating the message was successfully sent.
     """
-    if os.getenv("LETTA_ENVIRONMENT") == "PRODUCTION":
+    if settings.environment == "PRODUCTION":
         raise RuntimeError("This tool is not allowed to be run on Letta Cloud.")
 
     message = (

letta/functions/schema_generator.py

@@ -593,7 +593,6 @@ def generate_tool_schema_for_mcp(
     append_heartbeat: bool = True,
     strict: bool = False,
 ) -> Dict[str, Any]:
-
     # MCP tool.inputSchema is a JSON schema
     # https://github.com/modelcontextprotocol/python-sdk/blob/775f87981300660ee957b63c2a14b448ab9c3675/src/mcp/types.py#L678
     parameters_schema = mcp_tool.inputSchema

letta/helpers/converters.py

@@ -2,8 +2,7 @@ from typing import Any, Dict, List, Optional, Union
 
 import numpy as np
 from anthropic.types.beta.messages import BetaMessageBatch, BetaMessageBatchIndividualResponse
-from openai.types.chat.chat_completion_message_tool_call import ChatCompletionMessageToolCall as OpenAIToolCall
-from openai.types.chat.chat_completion_message_tool_call import Function as OpenAIFunction
+from openai.types.chat.chat_completion_message_tool_call import ChatCompletionMessageToolCall as OpenAIToolCall, Function as OpenAIFunction
 from sqlalchemy import Dialect
 
 from letta.functions.mcp_client.types import StdioServerConfig
@@ -39,6 +38,7 @@ from letta.schemas.tool_rule import (
     MaxCountPerStepToolRule,
     ParentToolRule,
     RequiredBeforeExitToolRule,
+    RequiresApprovalToolRule,
     TerminalToolRule,
     ToolRule,
 )
@@ -91,8 +91,11 @@ def serialize_tool_rules(tool_rules: Optional[List[ToolRule]]) -> List[Dict[str,
     if not tool_rules:
         return []
 
+    # de-duplicate tool rules using dict.fromkeys (preserves order in Python 3.7+)
+    deduplicated_rules = list(dict.fromkeys(tool_rules))
+
     data = [
-        {**rule.model_dump(mode="json"), "type": rule.type.value} for rule in tool_rules
+        {**rule.model_dump(mode="json"), "type": rule.type.value} for rule in deduplicated_rules
     ]  # Convert Enum to string for JSON compatibility
 
     # Validate ToolRule structure
@@ -136,6 +139,8 @@ def deserialize_tool_rule(
         return ParentToolRule(**data)
     elif rule_type == ToolRuleType.required_before_exit:
         return RequiredBeforeExitToolRule(**data)
+    elif rule_type == ToolRuleType.requires_approval:
+        return RequiresApprovalToolRule(**data)
     raise ValueError(f"Unknown ToolRule type: {rule_type}")
 
 

letta/helpers/datetime_helpers.py

@@ -1,7 +1,6 @@
 import re
 import time
-from datetime import datetime, timedelta
-from datetime import timezone as dt_timezone
+from datetime import datetime, timedelta, timezone as dt_timezone
 from typing import Callable
 
 import pytz
@@ -21,11 +20,13 @@ def datetime_to_timestamp(dt):
 
 def get_local_time_fast(timezone):
     # Get current UTC time and convert to the specified timezone
+    # Only return the date to avoid cache busting on every request
     if not timezone:
-        return datetime.now().strftime("%Y-%m-%d %I:%M:%S %p %Z%z")
+        return datetime.now().strftime("%B %d, %Y")
     current_time_utc = datetime.now(pytz.utc)
     local_time = current_time_utc.astimezone(pytz.timezone(timezone))
-    formatted_time = local_time.strftime("%Y-%m-%d %I:%M:%S %p %Z%z")
+    # Return only the date in a human-readable format (e.g., "June 1, 2021")
+    formatted_time = local_time.strftime("%B %d, %Y")
 
     return formatted_time
 

letta/helpers/message_helper.py

@@ -40,8 +40,7 @@ def _convert_message_create_to_message(
     assert isinstance(message_create, MessageCreate)
 
     # Extract message content
-    if isinstance(message_create.content, str):
-        assert message_create.content != "", "Message content must not be empty"
+    if isinstance(message_create.content, str) and message_create.content != "":
         message_content = [TextContent(text=message_create.content)]
     elif isinstance(message_create.content, list) and len(message_create.content) > 0:
         message_content = message_create.content

letta/helpers/pinecone_utils.py

@@ -317,7 +317,6 @@ async def list_pinecone_index_for_files(file_id: str, actor: User, limit: int =
         async with PineconeAsyncio(api_key=settings.pinecone_api_key) as pc:
             description = await pc.describe_index(name=settings.pinecone_source_index)
             async with pc.IndexAsyncio(host=description.index.host) as dense_index:
-
                 kwargs = {"namespace": namespace, "prefix": file_id}
                 if limit is not None:
                     kwargs["limit"] = limit

letta/helpers/tool_rule_solver.py

@@ -11,6 +11,7 @@ from letta.schemas.tool_rule import (
     MaxCountPerStepToolRule,
     ParentToolRule,
     RequiredBeforeExitToolRule,
+    RequiresApprovalToolRule,
     TerminalToolRule,
     ToolRule,
 )
@@ -44,6 +45,9 @@ class ToolRulesSolver(BaseModel):
     required_before_exit_tool_rules: list[RequiredBeforeExitToolRule] = Field(
         default_factory=list, description="Tool rules that must be called before the agent can exit.", exclude=True
     )
+    requires_approval_tool_rules: list[RequiresApprovalToolRule] = Field(
+        default_factory=list, description="Tool rules that trigger an approval request for human-in-the-loop.", exclude=True
+    )
     tool_call_history: list[str] = Field(default_factory=list, description="History of tool calls, updated with each tool call.")
 
     def __init__(self, tool_rules: list[ToolRule] | None = None, **kwargs):
@@ -68,6 +72,8 @@ class ToolRulesSolver(BaseModel):
                     self.parent_tool_rules.append(rule)
                 elif isinstance(rule, RequiredBeforeExitToolRule):
                     self.required_before_exit_tool_rules.append(rule)
+                elif isinstance(rule, RequiresApprovalToolRule):
+                    self.requires_approval_tool_rules.append(rule)
 
     def register_tool_call(self, tool_name: str):
         """Update the internal state to track tool call history."""
@@ -117,6 +123,10 @@ class ToolRulesSolver(BaseModel):
         """Check if the tool is defined as a continue tool in the tool rules."""
         return any(rule.tool_name == tool_name for rule in self.continue_tool_rules)
 
+    def is_requires_approval_tool(self, tool_name: ToolName):
+        """Check if the tool is defined as a requires-approval tool in the tool rules."""
+        return any(rule.tool_name == tool_name for rule in self.requires_approval_tool_rules)
+
     def has_required_tools_been_called(self, available_tools: set[ToolName]) -> bool:
         """Check if all required-before-exit tools have been called."""
         return len(self.get_uncalled_required_tools(available_tools=available_tools)) == 0