letta-nightly 0.8.3.dev20250611104259__py3-none-any.whl → 0.8.4.dev20250613104250__py3-none-any.whl

letta/client/client.py

@@ -1,6 +1,6 @@
 import sys
 import time
-from typing import Callable, Dict, Generator, List, Optional, Union
+from typing import Callable, Dict, List, Optional, Union
 
 import requests
 
@@ -18,7 +18,7 @@ from letta.schemas.file import FileMetadata
 from letta.schemas.job import Job
 from letta.schemas.letta_message import LettaMessage, LettaMessageUnion
 from letta.schemas.letta_request import LettaRequest, LettaStreamingRequest
-from letta.schemas.letta_response import LettaResponse, LettaStreamingResponse
+from letta.schemas.letta_response import LettaResponse
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import ArchivalMemorySummary, ChatMemory, CreateArchivalMemory, Memory, RecallMemorySummary
 from letta.schemas.message import Message, MessageCreate
@@ -136,6 +136,7 @@ class AbstractClient(object):
         stream: Optional[bool] = False,
         stream_steps: bool = False,
         stream_tokens: bool = False,
+        max_steps: Optional[int] = None,
     ) -> LettaResponse:
         raise NotImplementedError
 
@@ -977,7 +978,8 @@ class RESTClient(AbstractClient):
         stream: Optional[bool] = False,
         stream_steps: bool = False,
         stream_tokens: bool = False,
-    ) -> Union[LettaResponse, Generator[LettaStreamingResponse, None, None]]:
+        max_steps: Optional[int] = 10,
+    ) -> LettaResponse:
         """
         Send a message to an agent
 
@@ -988,6 +990,7 @@ class RESTClient(AbstractClient):
             name(str): Name of the sender
             stream (bool): Stream the response (default: `False`)
             stream_tokens (bool): Stream tokens (default: `False`)
+            max_steps (int): Maximum number of steps the agent should take (default: 10)
 
         Returns:
             response (LettaResponse): Response from the agent

letta/constants.py

@@ -31,6 +31,9 @@ LETTA_TOOL_MODULE_NAMES = [
     LETTA_FILES_TOOL_MODULE_NAME,
 ]
 
+DEFAULT_ORG_ID = "org-00000000-0000-4000-8000-000000000000"
+DEFAULT_ORG_NAME = "default_org"
+
 
 # String in the error message for when the context window is too large
 # Example full message:
@@ -43,6 +46,9 @@ IN_CONTEXT_MEMORY_KEYWORD = "CORE_MEMORY"
 # OpenAI error message: Invalid 'messages[1].tool_calls[0].id': string too long. Expected a string with maximum length 29, but got a string with length 36 instead.
 TOOL_CALL_ID_MAX_LEN = 29
 
+# Max steps for agent loop
+DEFAULT_MAX_STEPS = 50
+
 # minimum context window size
 MIN_CONTEXT_WINDOW = 4096
 

letta/data_sources/connectors.py

@@ -8,8 +8,8 @@ from letta.embeddings import embedding_model
 from letta.schemas.file import FileMetadata
 from letta.schemas.passage import Passage
 from letta.schemas.source import Source
+from letta.services.file_manager import FileManager
 from letta.services.passage_manager import PassageManager
-from letta.services.source_manager import SourceManager
 
 
 class DataConnector:
@@ -38,9 +38,7 @@ class DataConnector:
         """
 
 
-async def load_data(
-    connector: DataConnector, source: Source, passage_manager: PassageManager, source_manager: SourceManager, actor: "User"
-):
+async def load_data(connector: DataConnector, source: Source, passage_manager: PassageManager, file_manager: FileManager, actor: "User"):
     from letta.llm_api.llm_client import LLMClient
     from letta.schemas.embedding_config import EmbeddingConfig
 
@@ -94,7 +92,7 @@ async def load_data(
 
     for file_metadata in connector.find_files(source):
         file_count += 1
-        await source_manager.create_file(file_metadata, actor)
+        await file_manager.create_file(file_metadata, actor)
 
         # generate passages
         for passage_text, passage_metadata in connector.generate_passages(file_metadata, chunk_size=embedding_config.embedding_chunk_size):

letta/functions/async_composio_toolset.py

@@ -84,7 +84,10 @@ class AsyncComposioToolSet(BaseComposioToolSet, runtime="letta", description_cha
                             # Handle specific error codes from Composio API
                             if error_code == 10401 or "API_KEY_NOT_FOUND" in error_message:
                                 raise ApiKeyNotProvidedError()
-                            if "connected account not found" in error_message.lower():
+                            if (
+                                "connected account not found" in error_message.lower()
+                                or "no connected account found" in error_message.lower()
+                            ):
                                 raise ConnectedAccountNotFoundError(f"Connected account not found: {error_message}")
                             if "enum metadata not found" in error_message.lower():
                                 raise EnumMetadataNotFound(f"Enum metadata not found: {error_message}")

letta/functions/function_sets/files.py

@@ -32,12 +32,13 @@ async def close_file(agent_state: "AgentState", file_name: str) -> str:
     raise NotImplementedError("Tool not implemented. Please contact the Letta team.")
 
 
-async def grep(agent_state: "AgentState", pattern: str) -> str:
+async def grep(agent_state: "AgentState", pattern: str, include: Optional[str] = None) -> str:
     """
-    Grep tool to search files across data sources with keywords.
+    Grep tool to search files across data sources with a keyword or regex pattern.
 
     Args:
-        pattern (str): Keyword or regex pattern to search.
+        pattern (str): Keyword or regex pattern to search within file contents.
+        include (Optional[str]): Optional keyword or regex pattern to filter filenames to include in the search.
 
     Returns:
         str: Matching lines or summary output.

letta/functions/schema_generator.py

@@ -547,8 +547,11 @@ def generate_tool_schema_for_composio(
             property_schema["enum"] = field_props["enum"]
 
         # Handle array item types
-        if field_props["type"] == "array" and "items" in field_props:
-            property_schema["items"] = field_props["items"]
+        if field_props["type"] == "array":
+            if "items" in field_props:
+                property_schema["items"] = field_props["items"]
+            elif "anyOf" in field_props:
+                property_schema["items"] = [t for t in field_props["anyOf"] if "items" in t][0]["items"]
 
         # Add the property to the schema
         properties_json[field_name] = property_schema

letta/groups/sleeptime_multi_agent_v2.py

@@ -4,6 +4,7 @@ from typing import AsyncGenerator, List, Optional
 
 from letta.agents.base_agent import BaseAgent
 from letta.agents.letta_agent import LettaAgent
+from letta.constants import DEFAULT_MAX_STEPS
 from letta.groups.helpers import stringify_message
 from letta.otel.tracing import trace_method
 from letta.schemas.enums import JobStatus
@@ -61,7 +62,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
     async def step(
         self,
         input_messages: List[MessageCreate],
-        max_steps: int = 10,
+        max_steps: int = DEFAULT_MAX_STEPS,
         use_assistant_message: bool = True,
         request_start_timestamp_ns: Optional[int] = None,
         include_return_message_types: Optional[List[MessageType]] = None,
@@ -131,7 +132,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
     async def step_stream_no_tokens(
         self,
         input_messages: List[MessageCreate],
-        max_steps: int = 10,
+        max_steps: int = DEFAULT_MAX_STEPS,
         use_assistant_message: bool = True,
         request_start_timestamp_ns: Optional[int] = None,
         include_return_message_types: Optional[List[MessageType]] = None,
@@ -149,7 +150,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
     async def step_stream(
         self,
         input_messages: List[MessageCreate],
-        max_steps: int = 10,
+        max_steps: int = DEFAULT_MAX_STEPS,
         use_assistant_message: bool = True,
         request_start_timestamp_ns: Optional[int] = None,
         include_return_message_types: Optional[List[MessageType]] = None,

letta/helpers/converters.py

@@ -12,6 +12,8 @@ from letta.schemas.agent import AgentStepState
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import ProviderType, ToolRuleType
 from letta.schemas.letta_message_content import (
+    ImageContent,
+    ImageSourceType,
     MessageContent,
     MessageContentType,
     OmittedReasoningContent,
@@ -216,12 +218,13 @@ def serialize_message_content(message_content: Optional[List[Union[MessageConten
     serialized_message_content = []
     for content in message_content:
         if isinstance(content, MessageContent):
+            if content.type == MessageContentType.image:
+                assert content.source.type == ImageSourceType.letta, f"Invalid image source type: {content.source.type}"
             serialized_message_content.append(content.model_dump(mode="json"))
         elif isinstance(content, dict):
             serialized_message_content.append(content)  # Already a dictionary, leave it as-is
         else:
             raise TypeError(f"Unexpected message content type: {type(content)}")
-
     return serialized_message_content
 
 
@@ -238,6 +241,9 @@ def deserialize_message_content(data: Optional[List[Dict]]) -> List[MessageConte
         content_type = item.get("type")
         if content_type == MessageContentType.text:
             content = TextContent(**item)
+        elif content_type == MessageContentType.image:
+            assert item["source"]["type"] == ImageSourceType.letta, f'Invalid image source type: {item["source"]["type"]}'
+            content = ImageContent(**item)
         elif content_type == MessageContentType.tool_call:
             content = ToolCallContent(**item)
         elif content_type == MessageContentType.tool_return:

letta/helpers/message_helper.py

@@ -1,6 +1,11 @@
+import base64
+import mimetypes
+
+import httpx
+
 from letta import system
 from letta.schemas.enums import MessageRole
-from letta.schemas.letta_message_content import TextContent
+from letta.schemas.letta_message_content import Base64Image, ImageContent, ImageSourceType, TextContent
 from letta.schemas.message import Message, MessageCreate
 
 
@@ -33,24 +38,39 @@ def _convert_message_create_to_message(
 
     # Extract message content
     if isinstance(message_create.content, str):
+        assert message_create.content != "", "Message content must not be empty"
+        message_content = [TextContent(text=message_create.content)]
+    elif isinstance(message_create.content, list) and len(message_create.content) > 0:
         message_content = message_create.content
-    elif message_create.content and len(message_create.content) > 0 and isinstance(message_create.content[0], TextContent):
-        message_content = message_create.content[0].text
     else:
         raise ValueError("Message content is empty or invalid")
 
-    # Apply wrapping if needed
-    if message_create.role not in {MessageRole.user, MessageRole.system}:
-        raise ValueError(f"Invalid message role: {message_create.role}")
-    elif message_create.role == MessageRole.user and wrap_user_message:
-        message_content = system.package_user_message(user_message=message_content)
-    elif message_create.role == MessageRole.system and wrap_system_message:
-        message_content = system.package_system_message(system_message=message_content)
+    assert message_create.role in {MessageRole.user, MessageRole.system}, f"Invalid message role: {message_create.role}"
+    for content in message_content:
+        if isinstance(content, TextContent):
+            # Apply wrapping if needed
+            if message_create.role == MessageRole.user and wrap_user_message:
+                content.text = system.package_user_message(user_message=content.text)
+            elif message_create.role == MessageRole.system and wrap_system_message:
+                content.text = system.package_system_message(system_message=content.text)
+        elif isinstance(content, ImageContent):
+            if content.source.type == ImageSourceType.url:
+                # Convert URL image to Base64Image if needed
+                image_response = httpx.get(content.source.url)
+                image_response.raise_for_status()
+                image_media_type = image_response.headers.get("content-type")
+                if not image_media_type:
+                    image_media_type, _ = mimetypes.guess_type(content.source.url)
+                image_data = base64.standard_b64encode(image_response.content).decode("utf-8")
+                content.source = Base64Image(media_type=image_media_type, data=image_data)
+            if content.source.type == ImageSourceType.letta and not content.source.data:
+                # TODO: hydrate letta image with data from db
+                pass
 
     return Message(
         agent_id=agent_id,
         role=message_create.role,
-        content=[TextContent(text=message_content)] if message_content else [],
+        content=message_content,
         name=message_create.name,
         model=None,  # assigned later?
         tool_calls=None,  # irrelevant

letta/helpers/tool_rule_solver.py

@@ -2,6 +2,7 @@ from typing import List, Optional, Set, Union
 
 from pydantic import BaseModel, Field
 
+from letta.schemas.block import Block
 from letta.schemas.enums import ToolRuleType
 from letta.schemas.tool_rule import (
     BaseToolRule,
@@ -116,10 +117,10 @@ class ToolRulesSolver(BaseModel):
                 return list(available_tools)
         else:
             # Collect valid tools from all child-based rules
-            valid_tool_sets = [
-                rule.get_valid_tools(self.tool_call_history, available_tools, last_function_response)
-                for rule in self.child_based_tool_rules + self.parent_tool_rules
-            ]
+            valid_tool_sets = []
+            for rule in self.child_based_tool_rules + self.parent_tool_rules:
+                tools = rule.get_valid_tools(self.tool_call_history, available_tools, last_function_response)
+                valid_tool_sets.append(tools)
 
             # Compute intersection of all valid tool sets
             final_allowed_tools = set.intersection(*valid_tool_sets) if valid_tool_sets else available_tools
@@ -141,6 +142,70 @@ 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 compile_tool_rule_prompts(self) -> Optional[Block]:
+        """
+        Compile prompt templates from all tool rules into an ephemeral Block.
+
+        Returns:
+            Optional[str]: Compiled prompt string with tool rule constraints, or None if no templates exist.
+        """
+        compiled_prompts = []
+
+        all_rules = (
+            self.init_tool_rules
+            + self.continue_tool_rules
+            + self.child_based_tool_rules
+            + self.parent_tool_rules
+            + self.terminal_tool_rules
+        )
+
+        for rule in all_rules:
+            rendered = rule.render_prompt()
+            if rendered:
+                compiled_prompts.append(rendered)
+
+        if compiled_prompts:
+            return Block(
+                label="tool_usage_rules",
+                value="\n".join(compiled_prompts),
+                description="The following constraints define rules for tool usage and guide desired behavior. These rules must be followed to ensure proper tool execution and workflow.",
+            )
+        return None
+
+    def guess_rule_violation(self, tool_name: str) -> List[str]:
+        """
+        Check if the given tool name or the previous tool in history matches any tool rule,
+        and return rendered prompt templates for matching rules.
+
+        Args:
+            tool_name: The name of the tool to check for rule violations
+
+        Returns:
+            List of rendered prompt templates from matching tool rules
+        """
+        violated_rules = []
+
+        # Get the previous tool from history if it exists
+        previous_tool = self.tool_call_history[-1] if self.tool_call_history else None
+
+        # Check all tool rules for matches
+        all_rules = (
+            self.init_tool_rules
+            + self.continue_tool_rules
+            + self.child_based_tool_rules
+            + self.parent_tool_rules
+            + self.terminal_tool_rules
+        )
+
+        for rule in all_rules:
+            # Check if the current tool name or previous tool matches this rule's tool_name
+            if rule.tool_name == tool_name or (previous_tool and rule.tool_name == previous_tool):
+                rendered_prompt = rule.render_prompt()
+                if rendered_prompt:
+                    violated_rules.append(rendered_prompt)
+
+        return violated_rules
+
     @staticmethod
     def validate_conditional_tool(rule: ConditionalToolRule):
         """

letta/interfaces/anthropic_streaming_interface.py

@@ -91,7 +91,14 @@ class AnthropicStreamingInterface:
     def get_tool_call_object(self) -> ToolCall:
         """Useful for agent loop"""
         # hack for tool rules
-        tool_input = json.loads(self.accumulated_tool_call_args)
+        try:
+            tool_input = json.loads(self.accumulated_tool_call_args)
+        except json.JSONDecodeError as e:
+            logger.warning(
+                f"Failed to decode tool call arguments for tool_call_id={self.tool_call_id}, "
+                f"name={self.tool_call_name}. Raw input: {self.accumulated_tool_call_args!r}. Error: {e}"
+            )
+            raise
         if "id" in tool_input and tool_input["id"].startswith("toolu_") and "function" in tool_input:
             arguments = str(json.dumps(tool_input["function"]["arguments"], indent=2))
         else:

letta/interfaces/openai_streaming_interface.py

@@ -60,8 +60,11 @@ class OpenAIStreamingInterface:
     def get_tool_call_object(self) -> ToolCall:
         """Useful for agent loop"""
         function_name = self.last_flushed_function_name if self.last_flushed_function_name else self.function_name_buffer
+        tool_call_id = self.last_flushed_function_id if self.last_flushed_function_id else self.function_id_buffer
+        if not tool_call_id:
+            raise ValueError("No tool call ID available")
         return ToolCall(
-            id=self.last_flushed_function_id,
+            id=tool_call_id,
             function=FunctionCall(arguments=self.current_function_arguments, name=function_name),
         )
 

letta/llm_api/anthropic_client.py

@@ -1,4 +1,5 @@
 import json
+import logging
 import re
 from typing import Dict, List, Optional, Union
 
@@ -201,7 +202,7 @@ class AnthropicClient(LLMClientBase):
             tool_choice = {"type": "auto", "disable_parallel_tool_use": True}
             tools_for_request = [OpenAITool(function=f) for f in tools]
         elif force_tool_call is not None:
-            tool_choice = {"type": "tool", "name": force_tool_call}
+            tool_choice = {"type": "tool", "name": force_tool_call, "disable_parallel_tool_use": True}
             tools_for_request = [OpenAITool(function=f) for f in tools if f["name"] == force_tool_call]
 
             # need to have this setting to be able to put inner thoughts in kwargs
@@ -271,6 +272,8 @@ class AnthropicClient(LLMClientBase):
         return data
 
     async def count_tokens(self, messages: List[dict] = None, model: str = None, tools: List[OpenAITool] = None) -> int:
+        logging.getLogger("httpx").setLevel(logging.WARNING)
+
         client = anthropic.AsyncAnthropic()
         if messages and len(messages) == 0:
             messages = None
@@ -286,9 +289,6 @@ class AnthropicClient(LLMClientBase):
                 tools=anthropic_tools or [],
             )
         except:
-            import ipdb
-
-            ipdb.set_trace()
             raise
 
         token_count = result.input_tokens

letta/llm_api/openai_client.py

@@ -26,6 +26,7 @@ from letta.log import get_logger
 from letta.otel.tracing import trace_method
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import ProviderCategory, ProviderType
+from letta.schemas.letta_message_content import MessageContentType
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import Message as PydanticMessage
 from letta.schemas.openai.chat_completion_request import ChatCompletionRequest
@@ -93,20 +94,13 @@ def supports_structured_output(llm_config: LLMConfig) -> bool:
 # TODO move into LLMConfig as a field?
 def requires_auto_tool_choice(llm_config: LLMConfig) -> bool:
     """Certain providers require the tool choice to be set to 'auto'."""
-
     if "nebius.com" in llm_config.model_endpoint:
         return True
     if "together.ai" in llm_config.model_endpoint or "together.xyz" in llm_config.model_endpoint:
         return True
-    # proxy also has this issue (FIXME check)
-    elif llm_config.model_endpoint == LETTA_MODEL_ENDPOINT:
-        return True
-    # same with vLLM (FIXME check)
-    elif llm_config.handle and "vllm" in llm_config.handle:
+    if llm_config.handle and "vllm" in llm_config.handle:
         return True
-    else:
-        # will use "required" instead of "auto"
-        return False
+    return False
 
 
 class OpenAIClient(LLMClientBase):
@@ -203,7 +197,7 @@ class OpenAIClient(LLMClientBase):
         # TODO: This vllm checking is very brittle and is a patch at most
         tool_choice = None
         if requires_auto_tool_choice(llm_config):
-            tool_choice = "auto"  # TODO change to "required" once proxy supports it
+            tool_choice = "auto"
         elif tools:
             # only set if tools is non-Null
             tool_choice = "required"
@@ -213,7 +207,7 @@ class OpenAIClient(LLMClientBase):
 
         data = ChatCompletionRequest(
             model=model,
-            messages=openai_message_list,
+            messages=fill_image_content_in_messages(openai_message_list, messages),
             tools=[OpenAITool(type="function", function=f) for f in tools] if tools else None,
             tool_choice=tool_choice,
             user=str(),
@@ -221,6 +215,9 @@ class OpenAIClient(LLMClientBase):
             # NOTE: the reasoners that don't support temperature require 1.0, not None
             temperature=llm_config.temperature if supports_temperature_param(model) else 1.0,
         )
+        if tools and supports_parallel_tool_calling(model):
+            data.parallel_tool_calls = False
+
         # always set user id for openai requests
         if self.actor:
             data.user = self.actor.id
@@ -402,3 +399,51 @@ class OpenAIClient(LLMClientBase):
 
         # Fallback for unexpected errors
         return super().handle_llm_error(e)
+
+
+def fill_image_content_in_messages(openai_message_list: List[dict], pydantic_message_list: List[PydanticMessage]) -> List[dict]:
+    """
+    Converts image content to openai format.
+    """
+
+    if len(openai_message_list) != len(pydantic_message_list):
+        return openai_message_list
+
+    new_message_list = []
+    for idx in range(len(openai_message_list)):
+        openai_message, pydantic_message = openai_message_list[idx], pydantic_message_list[idx]
+        if pydantic_message.role != "user":
+            new_message_list.append(openai_message)
+            continue
+
+        if not isinstance(pydantic_message.content, list) or (
+            len(pydantic_message.content) == 1 and pydantic_message.content[0].type == MessageContentType.text
+        ):
+            new_message_list.append(openai_message)
+            continue
+
+        message_content = []
+        for content in pydantic_message.content:
+            if content.type == MessageContentType.text:
+                message_content.append(
+                    {
+                        "type": "text",
+                        "text": content.text,
+                    }
+                )
+            elif content.type == MessageContentType.image:
+                message_content.append(
+                    {
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:{content.source.media_type};base64,{content.source.data}",
+                            "detail": content.source.detail or "auto",
+                        },
+                    }
+                )
+            else:
+                raise ValueError(f"Unsupported content type {content.type}")
+
+        new_message_list.append({"role": "user", "content": message_content})
+
+    return new_message_list

letta/local_llm/utils.py

@@ -44,24 +44,6 @@ def post_json_auth_request(uri, json_payload, auth_type, auth_key):
     return response
 
 
-# deprecated for Box
-class DotDict(dict):
-    """Allow dot access on properties similar to OpenAI response object"""
-
-    def __getattr__(self, attr):
-        return self.get(attr)
-
-    def __setattr__(self, key, value):
-        self[key] = value
-
-    # following methods necessary for pickling
-    def __getstate__(self):
-        return vars(self)
-
-    def __setstate__(self, state):
-        vars(self).update(state)
-
-
 def load_grammar_file(grammar):
     # Set grammar
     grammar_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), "grammars", f"{grammar}.gbnf")
@@ -79,8 +61,9 @@ def load_grammar_file(grammar):
 
 # TODO: support tokenizers/tokenizer apis available in local models
 def count_tokens(s: str, model: str = "gpt-4") -> int:
-    encoding = tiktoken.encoding_for_model(model)
-    return len(encoding.encode(s))
+    from letta.utils import count_tokens
+
+    return count_tokens(s, model)
 
 
 def num_tokens_from_functions(functions: List[dict], model: str = "gpt-4"):

letta/orm/sqlalchemy_base.py

@@ -494,6 +494,8 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
 
         identifiers = [] if identifier is None else [identifier]
         query, query_conditions = cls._read_multiple_preprocess(identifiers, actor, access, access_type, check_is_deleted, **kwargs)
+        if query is None:
+            raise NoResultFound(f"{cls.__name__} not found with identifier {identifier}")
 
         if settings.letta_pg_uri_no_default:
             await db_session.execute(text("SET LOCAL enable_seqscan = OFF"))
@@ -533,6 +535,8 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             NoResultFound: if the object is not found
         """
         query, query_conditions = cls._read_multiple_preprocess(identifiers, actor, access, access_type, check_is_deleted, **kwargs)
+        if query is None:
+            return []
         results = db_session.execute(query).scalars().all()
         return cls._read_multiple_postprocess(results, identifiers, query_conditions)
 
@@ -553,6 +557,8 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         The primary accessor for ORM record(s)
         """
         query, query_conditions = cls._read_multiple_preprocess(identifiers, actor, access, access_type, check_is_deleted, **kwargs)
+        if query is None:
+            return []
         results = await db_session.execute(query)
         return cls._read_multiple_postprocess(results.scalars().all(), identifiers, query_conditions)
 
@@ -582,7 +588,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
             query_conditions.append(f"id='{identifiers}'")
         elif not kwargs:
             logger.debug(f"No identifiers provided for {cls.__name__}, returning empty list")
-            return []
+            return None, query_conditions
 
         if kwargs:
             query = query.filter_by(**kwargs)

letta/otel/metric_registry.py

@@ -120,3 +120,29 @@ class MetricRegistry:
                 unit="1",
             ),
         )
+
+    # (includes endpoint_path, method, status_code)
+    @property
+    def endpoint_e2e_ms_histogram(self) -> Histogram:
+        return self._get_or_create_metric(
+            "hist_endpoint_e2e_ms",
+            partial(
+                self._meter.create_histogram,
+                name="hist_endpoint_e2e_ms",
+                description="Histogram for endpoint e2e time (ms)",
+                unit="ms",
+            ),
+        )
+
+    # (includes endpoint_path, method, status_code)
+    @property
+    def endpoint_request_counter(self) -> Counter:
+        return self._get_or_create_metric(
+            "count_endpoint_requests",
+            partial(
+                self._meter.create_counter,
+                name="count_endpoint_requests",
+                description="Counts the number of endpoint requests",
+                unit="1",
+            ),
+        )