letta-nightly 0.8.15.dev20250720104313__py3-none-any.whl → 0.8.16.dev20250721104533__py3-none-any.whl

letta/agents/letta_agent_batch.py

@@ -100,7 +100,6 @@ async def execute_tool_wrapper(params: ToolExecutionParams) -> tuple[str, ToolEx
 # TODO: Limitations ->
 # TODO: Only works with anthropic for now
 class LettaAgentBatch(BaseAgent):
-
     def __init__(
         self,
         message_manager: MessageManager,
@@ -516,7 +515,7 @@ class LettaAgentBatch(BaseAgent):
         for agent_id, new_msgs in msg_map.items():
             ast = ctx.agent_state_map[agent_id]
             if not ast.message_buffer_autoclear:
-                await self.agent_manager.set_in_context_messages_async(
+                await self.agent_manager.update_message_ids_async(
                     agent_id=agent_id,
                     message_ids=ast.message_ids + [m.id for m in new_msgs],
                     actor=self.actor,

letta/agents/voice_agent.py

@@ -1,4 +1,3 @@
-import asyncio
 import json
 import uuid
 from datetime import datetime, timedelta, timezone
@@ -299,7 +298,7 @@ class VoiceAgent(BaseAgent):
             in_context_messages=in_context_messages, new_letta_messages=new_letta_messages
         )
 
-        await self.agent_manager.set_in_context_messages_async(
+        await self.agent_manager.update_message_ids_async(
             agent_id=self.agent_id, message_ids=[m.id for m in new_in_context_messages], actor=self.actor
         )
 
@@ -308,18 +307,17 @@ class VoiceAgent(BaseAgent):
         in_context_messages: List[Message],
         agent_state: AgentState,
     ) -> List[Message]:
-        self.num_messages, self.num_archival_memories = await asyncio.gather(
-            (
-                self.message_manager.size_async(actor=self.actor, agent_id=agent_state.id)
-                if self.num_messages is None
-                else asyncio.sleep(0, result=self.num_messages)
-            ),
-            (
-                self.passage_manager.agent_passage_size_async(actor=self.actor, agent_id=agent_state.id)
-                if self.num_archival_memories is None
-                else asyncio.sleep(0, result=self.num_archival_memories)
-            ),
-        )
+        if not self.num_messages:
+            self.num_messages = await self.message_manager.size_async(
+                agent_id=agent_state.id,
+                actor=self.actor,
+            )
+        if not self.num_archival_memories:
+            self.num_archival_memories = await self.passage_manager.agent_passage_size_async(
+                agent_id=agent_state.id,
+                actor=self.actor,
+            )
+
         return await super()._rebuild_memory_async(
             in_context_messages, agent_state, num_messages=self.num_messages, num_archival_memories=self.num_archival_memories
         )
@@ -379,19 +377,19 @@ class VoiceAgent(BaseAgent):
                                     "type": ["array", "null"],
                                     "items": {"type": "string"},
                                     "description": (
-                                        "Extra keywords (e.g., order ID, place name). " "Use *null* when the utterance is already specific."
+                                        "Extra keywords (e.g., order ID, place name). Use *null* when the utterance is already specific."
                                     ),
                                 },
                                 "start_minutes_ago": {
                                     "type": ["integer", "null"],
                                     "description": (
-                                        "Newer bound of the time window, in minutes ago. " "Use *null* if no lower bound is needed."
+                                        "Newer bound of the time window, in minutes ago. Use *null* if no lower bound is needed."
                                     ),
                                 },
                                 "end_minutes_ago": {
                                     "type": ["integer", "null"],
                                     "description": (
-                                        "Older bound of the time window, in minutes ago. " "Use *null* if no upper bound is needed."
+                                        "Older bound of the time window, in minutes ago. Use *null* if no upper bound is needed."
                                     ),
                                 },
                             },

letta/client/client.py

@@ -568,8 +568,8 @@ class RESTClient(AbstractClient):
             tool_names += BASE_MEMORY_TOOLS
         tool_ids += [self.get_tool_id(tool_name=name) for name in tool_names]
 
-        assert embedding_config or self._default_embedding_config, f"Embedding config must be provided"
-        assert llm_config or self._default_llm_config, f"LLM config must be provided"
+        assert embedding_config or self._default_embedding_config, "Embedding config must be provided"
+        assert llm_config or self._default_llm_config, "LLM config must be provided"
 
         # TODO: This should not happen here, we need to have clear separation between create/add blocks
         # TODO: This is insanely hacky and a result of allowing free-floating blocks
@@ -1392,7 +1392,7 @@ class RESTClient(AbstractClient):
         Returns:
             source (Source): Created source
         """
-        assert embedding_config or self._default_embedding_config, f"Must specify embedding_config for source"
+        assert embedding_config or self._default_embedding_config, "Must specify embedding_config for source"
         source_create = SourceCreate(name=name, embedding_config=embedding_config or self._default_embedding_config)
         payload = source_create.model_dump()
         response = requests.post(f"{self.base_url}/{self.api_prefix}/sources", json=payload, headers=self.headers)

letta/constants.py

@@ -378,3 +378,8 @@ PINECONE_MAX_RETRY_ATTEMPTS = 3
 PINECONE_RETRY_BASE_DELAY = 1.0  # seconds
 PINECONE_RETRY_MAX_DELAY = 60.0  # seconds
 PINECONE_RETRY_BACKOFF_FACTOR = 2.0
+PINECONE_THROTTLE_DELAY = 0.75  # seconds base delay between batches
+
+# builtin web search
+WEB_SEARCH_MODEL_ENV_VAR_NAME = "LETTA_BUILTIN_WEBSEARCH_OPENAI_MODEL_NAME"
+WEB_SEARCH_MODEL_ENV_VAR_DEFAULT_VALUE = "gpt-4.1-mini-2025-04-14"

letta/embeddings.py

@@ -190,7 +190,6 @@ class GoogleEmbeddings:
 
 
 class GoogleVertexEmbeddings:
-
     def __init__(self, model: str, project_id: str, region: str):
         from google import genai
 
@@ -203,7 +202,6 @@ class GoogleVertexEmbeddings:
 
 
 class OpenAIEmbeddings:
-
     def __init__(self, api_key: str, model: str, base_url: str):
         if base_url:
             self.client = OpenAI(api_key=api_key, base_url=base_url)

letta/errors.py

@@ -219,3 +219,11 @@ class HandleNotFoundError(LettaError):
             message=f"Handle {handle} not found, must be one of {available_handles}",
             code=ErrorCode.NOT_FOUND,
         )
+
+
+class AgentFileExportError(Exception):
+    """Exception raised during agent file export operations"""
+
+
+class AgentFileImportError(Exception):
+    """Exception raised during agent file import operations"""

letta/functions/function_sets/base.py

@@ -42,7 +42,7 @@ def conversation_search(self: "Agent", query: str, page: Optional[int] = 0) -> O
     try:
         page = int(page)
     except:
-        raise ValueError(f"'page' argument must be an integer")
+        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
@@ -55,7 +55,7 @@ def conversation_search(self: "Agent", query: str, page: Optional[int] = 0) -> O
     total = len(messages)
     num_pages = math.ceil(total / count) - 1  # 0 index
     if len(messages) == 0:
-        results_str = f"No results found."
+        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]
@@ -103,7 +103,7 @@ def archival_memory_search(self: "Agent", query: str, page: Optional[int] = 0, s
     try:
         page = int(page)
     except:
-        raise ValueError(f"'page' argument must be an integer")
+        raise ValueError("'page' argument must be an integer")
     count = RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
 
     try:

letta/functions/helpers.py

@@ -23,7 +23,6 @@ from letta.settings import settings
 
 # TODO needed?
 def generate_mcp_tool_wrapper(mcp_tool_name: str) -> tuple[str, str]:
-
     wrapper_function_str = f"""\
 def {mcp_tool_name}(**kwargs):
     raise RuntimeError("Something went wrong - we should never be using the persisted source code for MCP. Please reach out to Letta team")
@@ -46,7 +45,7 @@ def generate_langchain_tool_wrapper(
     _assert_all_classes_are_imported(tool, additional_imports_module_attr_map)
 
     tool_instantiation = f"tool = {generate_imported_tool_instantiation_call_str(tool)}"
-    run_call = f"return tool._run(**kwargs)"
+    run_call = "return tool._run(**kwargs)"
     func_name = humps.decamelize(tool_name)
 
     # Combine all parts into the wrapper function
@@ -240,7 +239,7 @@ async def async_execute_send_message_to_agent(
     try:
         server.agent_manager.get_agent_by_id(agent_id=other_agent_id, actor=sender_agent.user)
     except NoResultFound:
-        raise ValueError(f"Target agent {other_agent_id} either does not exist or is not in org " f"({sender_agent.user.organization_id}).")
+        raise ValueError(f"Target agent {other_agent_id} either does not exist or is not in org ({sender_agent.user.organization_id}).")
 
     # 2. Use your async retry logic
     return await _async_send_message_with_retries(

letta/groups/sleeptime_multi_agent.py

@@ -20,7 +20,6 @@ from letta.services.message_manager import MessageManager
 
 
 class SleeptimeMultiAgent(Agent):
-
     def __init__(
         self,
         interface: AgentInterface,

letta/helpers/composio_helpers.py

@@ -10,7 +10,7 @@ def get_composio_api_key(actor: User, logger: Optional[Logger] = None) -> Option
     api_keys = SandboxConfigManager().list_sandbox_env_vars_by_key(key="COMPOSIO_API_KEY", actor=actor)
     if not api_keys:
         if logger:
-            logger.debug(f"No API keys found for Composio. Defaulting to the environment variable...")
+            logger.debug("No API keys found for Composio. Defaulting to the environment variable...")
         if tool_settings.composio_api_key:
             return tool_settings.composio_api_key
         else:
@@ -26,7 +26,7 @@ async def get_composio_api_key_async(actor: User, logger: Optional[Logger] = Non
     api_keys = await SandboxConfigManager().list_sandbox_env_vars_by_key_async(key="COMPOSIO_API_KEY", actor=actor)
     if not api_keys:
         if logger:
-            logger.debug(f"No API keys found for Composio. Defaulting to the environment variable...")
+            logger.debug("No API keys found for Composio. Defaulting to the environment variable...")
         if tool_settings.composio_api_key:
             return tool_settings.composio_api_key
         else:

letta/helpers/converters.py

@@ -245,7 +245,7 @@ def deserialize_message_content(data: Optional[List[Dict]]) -> List[MessageConte
         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"]}'
+            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)

letta/helpers/pinecone_utils.py

@@ -31,6 +31,7 @@ from letta.constants import (
     PINECONE_RETRY_BASE_DELAY,
     PINECONE_RETRY_MAX_DELAY,
     PINECONE_TEXT_FIELD_NAME,
+    PINECONE_THROTTLE_DELAY,
 )
 from letta.log import get_logger
 from letta.schemas.user import User
@@ -256,6 +257,13 @@ async def upsert_records_to_pinecone_index(records: List[dict], actor: User):
                 logger.debug(f"[Pinecone] Upserting batch {batch_num}/{total_batches} with {len(batch)} records")
                 await dense_index.upsert_records(actor.organization_id, batch)
 
+                # throttle between batches (except the last one)
+                if batch_num < total_batches:
+                    jitter = random.uniform(0, PINECONE_THROTTLE_DELAY * 0.2)  # ±20% jitter
+                    throttle_delay = PINECONE_THROTTLE_DELAY + jitter
+                    logger.debug(f"[Pinecone] Throttling for {throttle_delay:.3f}s before next batch")
+                    await asyncio.sleep(throttle_delay)
+
             logger.info(f"[Pinecone] Successfully upserted all {len(records)} records in {total_batches} batches")
 
 

letta/helpers/tool_rule_solver.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, Set, Union
+from typing import List, Optional, Union
 
 from pydantic import BaseModel, Field
 
@@ -107,25 +107,20 @@ class ToolRulesSolver(BaseModel):
         self.tool_call_history.clear()
 
     def get_allowed_tool_names(
-        self, available_tools: Set[str], error_on_empty: bool = False, last_function_response: Optional[str] = None
+        self, available_tools: set[str], error_on_empty: bool = True, last_function_response: str | None = None
     ) -> List[str]:
-        """Get a list of tool names allowed based on the last tool called."""
+        """Get a list of tool names allowed based on the last tool called.
+
+        The logic is as follows:
+            1. if there are no previous tool calls and we have InitToolRules, those are the only options for the first tool call
+            2. else we take the intersection of the Parent/Child/Conditional/MaxSteps as the options
+            3. Continue/Terminal/RequiredBeforeExit rules are applied in the agent loop flow, not to restrict tools
+        """
         # TODO: This piece of code here is quite ugly and deserves a refactor
-        # TODO: There's some weird logic encoded here:
-        # TODO: -> This only takes into consideration Init, and a set of Child/Conditional/MaxSteps tool rules
-        # TODO: -> Init tool rules outputs are treated additively, Child/Conditional/MaxSteps are intersection based
         # TODO: -> Tool rules should probably be refactored to take in a set of tool names?
-        # If no tool has been called yet, return InitToolRules additively
-        if not self.tool_call_history:
-            if self.init_tool_rules:
-                # If there are init tool rules, only return those defined in the init tool rules
-                return [rule.tool_name for rule in self.init_tool_rules]
-            else:
-                # Otherwise, return all tools besides those constrained by parent tool rules
-                available_tools = available_tools - set.union(set(), *(set(rule.children) for rule in self.parent_tool_rules))
-                return list(available_tools)
+        if not self.tool_call_history and self.init_tool_rules:
+            return [rule.tool_name for rule in self.init_tool_rules]
         else:
-            # Collect valid tools from all child-based 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)
@@ -151,11 +146,11 @@ 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 has_required_tools_been_called(self, available_tools: Set[str]) -> bool:
+    def has_required_tools_been_called(self, available_tools: set[str]) -> bool:
         """Check if all required-before-exit tools have been called."""
         return len(self.get_uncalled_required_tools(available_tools=available_tools)) == 0
 
-    def get_uncalled_required_tools(self, available_tools: Set[str]) -> List[str]:
+    def get_uncalled_required_tools(self, available_tools: set[str]) -> List[str]:
         """Get the list of required-before-exit tools that have not been called yet."""
         if not self.required_before_exit_tool_rules:
             return []  # No required tools means no uncalled tools

letta/llm_api/aws_bedrock.py

@@ -41,22 +41,36 @@ def get_bedrock_client(
     return bedrock
 
 
-def bedrock_get_model_list(region_name: str) -> List[dict]:
+def bedrock_get_model_list(
+    region_name: str,
+    access_key_id: Optional[str] = None,
+    secret_access_key: Optional[str] = None,
+) -> List[dict]:
     """
     Get list of available models from Bedrock.
 
     Args:
         region_name: AWS region name
+        access_key_id: Optional AWS access key ID
+        secret_access_key: Optional AWS secret access key
+
+        TODO: Implement model_provider and output_modality filtering
         model_provider: Optional provider name to filter models. If None, returns all models.
         output_modality: Output modality to filter models. Defaults to "text".
 
     Returns:
         List of model summaries
+
     """
     import boto3
 
     try:
-        bedrock = boto3.client("bedrock", region_name=region_name)
+        bedrock = boto3.client(
+            "bedrock",
+            region_name=region_name,
+            aws_access_key_id=access_key_id,
+            aws_secret_access_key=secret_access_key,
+        )
         response = bedrock.list_inference_profiles()
         return response["inferenceProfileSummaries"]
     except Exception as e:

letta/llm_api/cohere.py

@@ -307,7 +307,7 @@ def cohere_chat_completions_request(
     data = chat_completion_request.model_dump(exclude_none=True)
 
     if "functions" in data:
-        raise ValueError(f"'functions' unexpected in Anthropic API payload")
+        raise ValueError("'functions' unexpected in Anthropic API payload")
 
     # If tools == None, strip from the payload
     if "tools" in data and data["tools"] is None:

letta/llm_api/openai_client.py

@@ -54,7 +54,7 @@ def accepts_developer_role(model: str) -> bool:
 
     See: https://community.openai.com/t/developer-role-not-accepted-for-o1-o1-mini-o3-mini/1110750/7
     """
-    if is_openai_reasoning_model(model) and not "o1-mini" in model or "o1-preview" in model:
+    if is_openai_reasoning_model(model) and "o1-mini" not in model or "o1-preview" in model:
         return True
     else:
         return False

letta/local_llm/grammars/gbnf_grammar_generator.py

@@ -697,7 +697,7 @@ def generate_markdown_documentation(
             # Indenting the fields section
             documentation += f"  {fields_prefix}:\n"
         else:
-            documentation += f"  attributes:\n"
+            documentation += "  attributes:\n"
         if isclass(model) and issubclass(model, BaseModel):
             for name, field_type in model.__annotations__.items():
                 # if name == "markdown_code_block":

letta/local_llm/llm_chat_completion_wrappers/zephyr.py

@@ -43,7 +43,7 @@ class ZephyrMistralWrapper(LLMChatCompletionWrapper):
 
         # System instructions go first
         assert messages[0]["role"] == "system"
-        prompt += f"<|system|>"
+        prompt += "<|system|>"
         prompt += f"\n{messages[0]['content']}"
 
         # Next is the functions preamble
@@ -52,7 +52,7 @@ class ZephyrMistralWrapper(LLMChatCompletionWrapper):
             func_str = ""
             func_str += f"{schema['name']}:"
             func_str += f"\n  description: {schema['description']}"
-            func_str += f"\n  params:"
+            func_str += "\n  params:"
             for param_k, param_v in schema["parameters"]["properties"].items():
                 # TODO we're ignoring type
                 func_str += f"\n    {param_k}: {param_v['description']}"
@@ -60,8 +60,8 @@ class ZephyrMistralWrapper(LLMChatCompletionWrapper):
             return func_str
 
         # prompt += f"\nPlease select the most suitable function and parameters from the list of available functions below, based on the user's input. Provide your response in JSON format."
-        prompt += f"\nPlease select the most suitable function and parameters from the list of available functions below, based on the ongoing conversation. Provide your response in JSON format."
-        prompt += f"\nAvailable functions:"
+        prompt += "\nPlease select the most suitable function and parameters from the list of available functions below, based on the ongoing conversation. Provide your response in JSON format."
+        prompt += "\nAvailable functions:"
         if function_documentation is not None:
             prompt += f"\n{function_documentation}"
         else:
@@ -92,7 +92,7 @@ class ZephyrMistralWrapper(LLMChatCompletionWrapper):
                         prompt += f"\n<|user|>\n{message['content']}{IM_END_TOKEN}"
                         # prompt += f"\nUSER: {message['content']}"
             elif message["role"] == "assistant":
-                prompt += f"\n<|assistant|>"
+                prompt += "\n<|assistant|>"
                 if message["content"] is not None:
                     prompt += f"\n{message['content']}"
                 # prompt += f"\nASSISTANT: {message['content']}"
@@ -103,7 +103,7 @@ class ZephyrMistralWrapper(LLMChatCompletionWrapper):
             elif message["role"] in ["function", "tool"]:
                 # TODO find a good way to add this
                 # prompt += f"\nASSISTANT: (function return) {message['content']}"
-                prompt += f"\n<|assistant|>"
+                prompt += "\n<|assistant|>"
                 prompt += f"\nFUNCTION RETURN: {message['content']}"
                 # prompt += f"\nFUNCTION RETURN: {message['content']}"
                 continue
@@ -116,7 +116,7 @@ class ZephyrMistralWrapper(LLMChatCompletionWrapper):
 
         if self.include_assistant_prefix:
             # prompt += f"\nASSISTANT:"
-            prompt += f"\n<|assistant|>"
+            prompt += "\n<|assistant|>"
             if self.include_opening_brance_in_prefix:
                 prompt += "\n{"
 
@@ -214,9 +214,9 @@ class ZephyrMistralInnerMonologueWrapper(ZephyrMistralWrapper):
             func_str = ""
             func_str += f"{schema['name']}:"
             func_str += f"\n  description: {schema['description']}"
-            func_str += f"\n  params:"
+            func_str += "\n  params:"
             if add_inner_thoughts:
-                func_str += f"\n    inner_thoughts: Deep inner monologue private to you only."
+                func_str += "\n    inner_thoughts: Deep inner monologue private to you only."
             for param_k, param_v in schema["parameters"]["properties"].items():
                 # TODO we're ignoring type
                 func_str += f"\n    {param_k}: {param_v['description']}"
@@ -224,8 +224,8 @@ class ZephyrMistralInnerMonologueWrapper(ZephyrMistralWrapper):
             return func_str
 
         # prompt += f"\nPlease select the most suitable function and parameters from the list of available functions below, based on the user's input. Provide your response in JSON format."
-        prompt += f"\nPlease select the most suitable function and parameters from the list of available functions below, based on the ongoing conversation. Provide your response in JSON format."
-        prompt += f"\nAvailable functions:"
+        prompt += "\nPlease select the most suitable function and parameters from the list of available functions below, based on the ongoing conversation. Provide your response in JSON format."
+        prompt += "\nAvailable functions:"
         if function_documentation is not None:
             prompt += f"\n{function_documentation}"
         else:
@@ -259,10 +259,10 @@ class ZephyrMistralInnerMonologueWrapper(ZephyrMistralWrapper):
                     except:
                         prompt += f"\n<|user|>\n{message['content']}{IM_END_TOKEN}"
             elif message["role"] == "assistant":
-                prompt += f"\n<|assistant|>"
+                prompt += "\n<|assistant|>"
                 # need to add the function call if there was one
                 inner_thoughts = message["content"]
-                if "function_call" in message and message["function_call"]:
+                if message.get("function_call"):
                     prompt += f"\n{create_function_call(message['function_call'], inner_thoughts=inner_thoughts)}"
             elif message["role"] in ["function", "tool"]:
                 # TODO find a good way to add this
@@ -277,7 +277,7 @@ class ZephyrMistralInnerMonologueWrapper(ZephyrMistralWrapper):
         #    prompt += "\n### RESPONSE"
 
         if self.include_assistant_prefix:
-            prompt += f"\n<|assistant|>"
+            prompt += "\n<|assistant|>"
             if self.include_opening_brance_in_prefix:
                 prompt += "\n{"
 

letta/local_llm/utils.py

@@ -76,7 +76,7 @@ def num_tokens_from_functions(functions: List[dict], model: str = "gpt-4"):
     except KeyError:
         from letta.utils import printd
 
-        printd(f"Warning: model not found. Using cl100k_base encoding.")
+        printd("Warning: model not found. Using cl100k_base encoding.")
         encoding = tiktoken.get_encoding("cl100k_base")
 
     num_tokens = 0
@@ -238,7 +238,6 @@ def num_tokens_from_messages(messages: List[dict], model: str = "gpt-4") -> int:
         num_tokens += tokens_per_message
         for key, value in message.items():
             try:
-
                 if isinstance(value, list) and key == "tool_calls":
                     num_tokens += num_tokens_from_tool_calls(tool_calls=value, model=model)
                     # special case for tool calling (list)

letta/orm/agent.py

@@ -93,7 +93,7 @@ class Agent(SqlalchemyBase, OrganizationMixin, AsyncAttrs):
     timezone: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="The timezone of the agent (for the context window).")
 
     # relationships
-    organization: Mapped["Organization"] = relationship("Organization", back_populates="agents")
+    organization: Mapped["Organization"] = relationship("Organization", back_populates="agents", lazy="raise")
     tool_exec_environment_variables: Mapped[List["AgentEnvironmentVariable"]] = relationship(
         "AgentEnvironmentVariable",
         back_populates="agent",
@@ -128,7 +128,7 @@ class Agent(SqlalchemyBase, OrganizationMixin, AsyncAttrs):
     groups: Mapped[List["Group"]] = relationship(
         "Group",
         secondary="groups_agents",
-        lazy="selectin",
+        lazy="raise",
         back_populates="agents",
         passive_deletes=True,
     )
@@ -138,7 +138,7 @@ class Agent(SqlalchemyBase, OrganizationMixin, AsyncAttrs):
         viewonly=True,
         back_populates="manager_agent",
     )
-    batch_items: Mapped[List["LLMBatchItem"]] = relationship("LLMBatchItem", back_populates="agent", lazy="selectin")
+    batch_items: Mapped[List["LLMBatchItem"]] = relationship("LLMBatchItem", back_populates="agent", lazy="raise")
     file_agents: Mapped[List["FileAgent"]] = relationship(
         "FileAgent",
         back_populates="agent",

letta/orm/block.py

@@ -55,11 +55,11 @@ class Block(OrganizationMixin, SqlalchemyBase):
     __mapper_args__ = {"version_id_col": version}
 
     # relationships
-    organization: Mapped[Optional["Organization"]] = relationship("Organization")
+    organization: Mapped[Optional["Organization"]] = relationship("Organization", lazy="raise")
     agents: Mapped[List["Agent"]] = relationship(
         "Agent",
         secondary="blocks_agents",
-        lazy="selectin",
+        lazy="raise",
         passive_deletes=True,  # Ensures SQLAlchemy doesn't fetch blocks_agents rows before deleting
         back_populates="core_memory",
         doc="Agents associated with this block.",
@@ -67,14 +67,14 @@ class Block(OrganizationMixin, SqlalchemyBase):
     identities: Mapped[List["Identity"]] = relationship(
         "Identity",
         secondary="identities_blocks",
-        lazy="selectin",
+        lazy="raise",
         back_populates="blocks",
         passive_deletes=True,
     )
     groups: Mapped[List["Group"]] = relationship(
         "Group",
         secondary="groups_blocks",
-        lazy="selectin",
+        lazy="raise",
         back_populates="shared_blocks",
         passive_deletes=True,
     )

letta/orm/files_agents.py

@@ -96,7 +96,6 @@ class FileAgent(SqlalchemyBase, OrganizationMixin):
             visible_content += truncated_warning
 
         return PydanticBlock(
-            organization_id=self.organization_id,
             value=visible_content,
             label=self.file_name,  # use denormalized file_name instead of self.file.file_name
             read_only=True,

letta/orm/identity.py

@@ -23,6 +23,8 @@ class Identity(SqlalchemyBase, OrganizationMixin):
             "organization_id",
             name="unique_identifier_key_project_id_organization_id",
             postgresql_nulls_not_distinct=True,
+            # For SQLite compatibility, we'll need to handle the NULL case differently
+            # in the service layer since SQLite doesn't support postgresql_nulls_not_distinct
         ),
     )
 

letta/orm/mcp_server.py

@@ -50,5 +50,3 @@ class MCPServer(SqlalchemyBase, OrganizationMixin):
     metadata_: Mapped[Optional[dict]] = mapped_column(
         JSON, default=lambda: {}, doc="A dictionary of additional metadata for the MCP server."
     )
-    # relationships
-    # organization: Mapped["Organization"] = relationship("Organization", back_populates="mcp_server", lazy="selectin")