letta-nightly 0.6.54.dev20250420104127__py3-none-any.whl → 0.7.0.dev20250421104249__py3-none-any.whl

letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.6.54"
+__version__ = "0.7.0"
 
 # import clients
 from letta.client.client import LocalClient, RESTClient, create_client

letta/constants.py

@@ -60,9 +60,9 @@ BASE_SLEEPTIME_TOOLS = [
     "memory_insert",
     "memory_rethink",
     "memory_finish_edits",
-    "archival_memory_insert",
-    "archival_memory_search",
-    "conversation_search",
+    # "archival_memory_insert",
+    # "archival_memory_search",
+    # "conversation_search",
 ]
 # Multi agent tools
 MULTI_AGENT_TOOLS = ["send_message_to_agent_and_wait_for_reply", "send_message_to_agents_matching_tags", "send_message_to_agent_async"]

letta/data_sources/connectors.py

@@ -159,7 +159,13 @@ class DirectoryConnector(DataConnector):
         from llama_index.core.node_parser import TokenTextSplitter
 
         parser = TokenTextSplitter(chunk_size=chunk_size)
-        documents = SimpleDirectoryReader(input_files=[file.file_path]).load_data()
+        if file.file_type == "application/pdf":
+            from llama_index.readers.file import PDFReader
+
+            reader = PDFReader()
+            documents = reader.load_data(file=file.file_path)
+        else:
+            documents = SimpleDirectoryReader(input_files=[file.file_path]).load_data()
         nodes = parser.get_nodes_from_documents(documents)
         for node in nodes:
             yield node.text, None

letta/errors.py

@@ -204,3 +204,13 @@ class InvalidInnerMonologueError(LettaMessageError):
     """Error raised when a message has a malformed inner monologue."""
 
     default_error_message = "The message has a malformed inner monologue."
+
+
+class HandleNotFoundError(LettaError):
+    """Error raised when a handle is not found."""
+
+    def __init__(self, handle: str, available_handles: List[str]):
+        super().__init__(
+            message=f"Handle {handle} not found, must be one of {available_handles}",
+            code=ErrorCode.NOT_FOUND,
+        )

letta/llm_api/google_ai_client.py

@@ -56,6 +56,9 @@ class GoogleAIClient(LLMClientBase):
             tool_names = [t.function.name for t in tool_objs]
             # Convert to the exact payload style Google expects
             tools = self.convert_tools_to_google_ai_format(tool_objs)
+        else:
+            tool_names = []
+
         contents = self.add_dummy_model_messages(
             [m.to_google_ai_dict() for m in messages],
         )

letta/orm/message.py

@@ -1,7 +1,7 @@
 from typing import List, Optional
 
 from openai.types.chat.chat_completion_message_tool_call import ChatCompletionMessageToolCall as OpenAIToolCall
-from sqlalchemy import BigInteger, FetchedValue, ForeignKey, Index, Sequence, event, text
+from sqlalchemy import BigInteger, FetchedValue, ForeignKey, Index, event, text
 from sqlalchemy.orm import Mapped, Session, mapped_column, relationship
 
 from letta.orm.custom_columns import MessageContentColumn, ToolCallColumn, ToolReturnColumn
@@ -48,7 +48,6 @@ class Message(SqlalchemyBase, OrganizationMixin, AgentMixin):
     # Monotonically increasing sequence for efficient/correct listing
     sequence_id: Mapped[int] = mapped_column(
         BigInteger,
-        Sequence("message_seq_id"),
         server_default=FetchedValue(),
         unique=True,
         nullable=False,

letta/schemas/openai/chat_completion_request.py

@@ -46,7 +46,7 @@ ChatMessage = Union[SystemMessage, UserMessage, AssistantMessage, ToolMessage]
 def cast_message_to_subtype(m_dict: dict) -> ChatMessage:
     """Cast a dictionary to one of the individual message types"""
     role = m_dict.get("role")
-    if role == "system":
+    if role == "system" or role == "developer":
         return SystemMessage(**m_dict)
     elif role == "user":
         return UserMessage(**m_dict)
@@ -55,7 +55,7 @@ def cast_message_to_subtype(m_dict: dict) -> ChatMessage:
     elif role == "tool":
         return ToolMessage(**m_dict)
     else:
-        raise ValueError("Unknown message role")
+        raise ValueError(f"Unknown message role: {role}")
 
 
 class ResponseFormat(BaseModel):

letta/schemas/providers.py

@@ -66,7 +66,6 @@ class ProviderCreate(ProviderBase):
 
 
 class ProviderUpdate(ProviderBase):
-    id: str = Field(..., description="The id of the provider to update.")
     api_key: str = Field(..., description="API key used for requests to the provider.")
 
 

letta/server/rest_api/routers/v1/providers.py

@@ -11,7 +11,7 @@ if TYPE_CHECKING:
 router = APIRouter(prefix="/providers", tags=["providers"])
 
 
-@router.get("/", tags=["providers"], response_model=List[Provider], operation_id="list_providers")
+@router.get("/", response_model=List[Provider], operation_id="list_providers")
 def list_providers(
     after: Optional[str] = Query(None),
     limit: Optional[int] = Query(50),
@@ -31,7 +31,7 @@ def list_providers(
     return providers
 
 
-@router.post("/", tags=["providers"], response_model=Provider, operation_id="create_provider")
+@router.post("/", response_model=Provider, operation_id="create_provider")
 def create_provider(
     request: ProviderCreate = Body(...),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
@@ -47,8 +47,9 @@ def create_provider(
     return provider
 
 
-@router.patch("/", tags=["providers"], response_model=Provider, operation_id="modify_provider")
+@router.patch("/{provider_id}", response_model=Provider, operation_id="modify_provider")
 def modify_provider(
+    provider_id: str,
     request: ProviderUpdate = Body(...),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
     server: "SyncServer" = Depends(get_letta_server),
@@ -57,13 +58,12 @@ def modify_provider(
     Update an existing custom provider
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    provider = server.provider_manager.update_provider(request, actor=actor)
-    return provider
+    return server.provider_manager.update_provider(provider_id=provider_id, request=request, actor=actor)
 
 
-@router.delete("/", tags=["providers"], response_model=None, operation_id="delete_provider")
+@router.delete("/{provider_id}", response_model=None, operation_id="delete_provider")
 def delete_provider(
-    provider_id: str = Query(..., description="The provider_id key to be deleted."),
+    provider_id: str,
     actor_id: Optional[str] = Header(None, alias="user_id"),
     server: "SyncServer" = Depends(get_letta_server),
 ):
@@ -73,6 +73,9 @@ def delete_provider(
     try:
         actor = server.user_manager.get_user_or_default(user_id=actor_id)
         server.provider_manager.delete_provider_by_id(provider_id=provider_id, actor=actor)
+        return JSONResponse(status_code=status.HTTP_200_OK, content={"message": f"Provider id={provider_id} successfully deleted"})
+    except NoResultFound:
+        raise HTTPException(status_code=404, detail=f"Provider provider_id={provider_id} not found for user_id={actor.id}.")
     except HTTPException:
         raise
     except Exception as e:

letta/server/server.py

@@ -20,6 +20,7 @@ import letta.system as system
 from letta.agent import Agent, save_agent
 from letta.config import LettaConfig
 from letta.data_sources.connectors import DataConnector, load_data
+from letta.errors import HandleNotFoundError
 from letta.functions.mcp_client.base_client import BaseMCPClient
 from letta.functions.mcp_client.sse_client import MCP_CONFIG_TOPLEVEL_KEY, SSEMCPClient
 from letta.functions.mcp_client.stdio_client import StdioMCPClient
@@ -702,6 +703,8 @@ class SyncServer(Server):
     @trace_method
     def get_cached_llm_config(self, **kwargs):
         key = make_key(**kwargs)
+        print(self._llm_config_cache)
+        print("KEY", key)
         if key not in self._llm_config_cache:
             self._llm_config_cache[key] = self.get_llm_config_from_handle(**kwargs)
         return self._llm_config_cache[key]
@@ -1179,10 +1182,12 @@ class SyncServer(Server):
             provider = self.get_provider_from_name(provider_name)
 
             llm_configs = [config for config in provider.list_llm_models() if config.handle == handle]
+            print("LLM CONFIGS", llm_configs)
             if not llm_configs:
                 llm_configs = [config for config in provider.list_llm_models() if config.model == model_name]
             if not llm_configs:
-                raise ValueError(f"LLM model {model_name} is not supported by {provider_name}")
+                available_handles = [config.handle for config in provider.list_llm_models()]
+                raise HandleNotFoundError(handle, available_handles)
         except ValueError as e:
             llm_configs = [config for config in self.get_local_llm_configs() if config.handle == handle]
             if not llm_configs:
@@ -1190,6 +1195,8 @@ class SyncServer(Server):
             if not llm_configs:
                 raise e
 
+        print("CONFIGS", llm_configs)
+
         if len(llm_configs) == 1:
             llm_config = llm_configs[0]
         elif len(llm_configs) > 1:

letta/services/agent_manager.py

@@ -1,8 +1,10 @@
-from datetime import datetime
-from typing import Dict, List, Optional
+from datetime import datetime, timezone
+from typing import Dict, List, Optional, Set, Tuple
 
 import numpy as np
-from sqlalchemy import Select, and_, func, literal, or_, select, union_all
+import sqlalchemy as sa
+from sqlalchemy import Select, and_, delete, func, insert, literal, or_, select, union_all
+from sqlalchemy.dialects.postgresql import insert as pg_insert
 
 from letta.constants import (
     BASE_MEMORY_TOOLS,
@@ -19,13 +21,16 @@ from letta.log import get_logger
 from letta.orm import Agent as AgentModel
 from letta.orm import AgentPassage, AgentsTags
 from letta.orm import Block as BlockModel
+from letta.orm import BlocksAgents
 from letta.orm import Group as GroupModel
-from letta.orm import Identity as IdentityModel
+from letta.orm import IdentitiesAgents
 from letta.orm import Source as SourceModel
 from letta.orm import SourcePassage, SourcesAgents
 from letta.orm import Tool as ToolModel
+from letta.orm import ToolsAgents
 from letta.orm.enums import ToolType
 from letta.orm.errors import NoResultFound
+from letta.orm.sandbox_config import AgentEnvironmentVariable
 from letta.orm.sandbox_config import AgentEnvironmentVariable as AgentEnvironmentVariableModel
 from letta.orm.sqlalchemy_base import AccessType
 from letta.orm.sqlite_functions import adapt_array
@@ -36,16 +41,14 @@ from letta.schemas.block import BlockUpdate
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.group import Group as PydanticGroup
 from letta.schemas.group import ManagerType
-from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import Memory
+from letta.schemas.message import Message
 from letta.schemas.message import Message as PydanticMessage
 from letta.schemas.message import MessageCreate, MessageUpdate
 from letta.schemas.passage import Passage as PydanticPassage
 from letta.schemas.source import Source as PydanticSource
 from letta.schemas.tool import Tool as PydanticTool
-from letta.schemas.tool_rule import ContinueToolRule as PydanticContinueToolRule
-from letta.schemas.tool_rule import TerminalToolRule as PydanticTerminalToolRule
-from letta.schemas.tool_rule import ToolRule as PydanticToolRule
+from letta.schemas.tool_rule import ContinueToolRule, TerminalToolRule
 from letta.schemas.user import User as PydanticUser
 from letta.serialize_schemas import MarshmallowAgentSchema
 from letta.serialize_schemas.marshmallow_message import SerializedMessageSchema
@@ -58,7 +61,6 @@ from letta.services.helpers.agent_manager_helper import (
     _apply_pagination,
     _apply_tag_filter,
     _process_relationship,
-    _process_tags,
     check_supports_structured_output,
     compile_system_message,
     derive_system_message,
@@ -77,7 +79,6 @@ from letta.utils import enforce_types, united_diff
 logger = get_logger(__name__)
 
 
-# Agent Manager Class
 class AgentManager:
     """Manager class to handle business logic related to Agents."""
 
@@ -92,124 +93,218 @@ class AgentManager:
         self.passage_manager = PassageManager()
         self.identity_manager = IdentityManager()
 
+    @staticmethod
+    def _resolve_tools(session, names: Set[str], ids: Set[str], org_id: str) -> Tuple[Dict[str, str], Dict[str, str]]:
+        """
+        Bulk‑fetch all ToolModel rows matching either name ∈ names or id ∈ ids
+        (and scoped to this organization), and return two maps:
+          name_to_id, id_to_name.
+        Raises if any requested name or id was not found.
+        """
+        stmt = select(ToolModel.id, ToolModel.name).where(
+            ToolModel.organization_id == org_id,
+            or_(
+                ToolModel.name.in_(names),
+                ToolModel.id.in_(ids),
+            ),
+        )
+        rows = session.execute(stmt).all()
+        name_to_id = {name: tid for tid, name in rows}
+        id_to_name = {tid: name for tid, name in rows}
+
+        missing_names = names - set(name_to_id.keys())
+        missing_ids = ids - set(id_to_name.keys())
+        if missing_names:
+            raise ValueError(f"Tools not found by name: {missing_names}")
+        if missing_ids:
+            raise ValueError(f"Tools not found by id:   {missing_ids}")
+
+        return name_to_id, id_to_name
+
+    @staticmethod
+    @trace_method
+    def _bulk_insert_pivot(session, table, rows: list[dict]):
+        if not rows:
+            return
+
+        dialect = session.bind.dialect.name
+        if dialect == "postgresql":
+            stmt = pg_insert(table).values(rows).on_conflict_do_nothing()
+        elif dialect == "sqlite":
+            stmt = sa.insert(table).values(rows).prefix_with("OR IGNORE")
+        else:
+            # fallback: filter out exact-duplicate dicts in Python
+            seen = set()
+            filtered = []
+            for row in rows:
+                key = tuple(sorted(row.items()))
+                if key not in seen:
+                    seen.add(key)
+                    filtered.append(row)
+            stmt = sa.insert(table).values(filtered)
+
+        session.execute(stmt)
+
+    @staticmethod
+    @trace_method
+    def _replace_pivot_rows(session, table, agent_id: str, rows: list[dict]):
+        """
+        Replace all pivot rows for an agent with *exactly* the provided list.
+        Uses two bulk statements (DELETE + INSERT ... ON CONFLICT DO NOTHING).
+        """
+        # delete all existing rows for this agent
+        session.execute(delete(table).where(table.c.agent_id == agent_id))
+        if rows:
+            AgentManager._bulk_insert_pivot(session, table, rows)
+
     # ======================================================================================================================
     # Basic CRUD operations
     # ======================================================================================================================
     @trace_method
-    @enforce_types
-    def create_agent(
-        self,
-        agent_create: CreateAgent,
-        actor: PydanticUser,
-    ) -> PydanticAgentState:
-        system = derive_system_message(
-            agent_type=agent_create.agent_type,
-            enable_sleeptime=agent_create.enable_sleeptime,
-            system=agent_create.system,
-        )
-
+    def create_agent(self, agent_create: CreateAgent, actor: PydanticUser) -> PydanticAgentState:
+        # validate required configs
         if not agent_create.llm_config or not agent_create.embedding_config:
             raise ValueError("llm_config and embedding_config are required")
 
-        # create blocks (note: cannot be linked into the agent_id is created)
-        block_ids = list(agent_create.block_ids or [])  # Create a local copy to avoid modifying the original
+        # blocks
+        block_ids = list(agent_create.block_ids or [])
         if agent_create.memory_blocks:
-            for create_block in agent_create.memory_blocks:
-                block = self.block_manager.create_or_update_block(PydanticBlock(**create_block.model_dump(to_orm=True)), actor=actor)
-                block_ids.append(block.id)
-
-        # add passed in `tools`
-        tool_names = agent_create.tools or []
+            pydantic_blocks = [PydanticBlock(**b.model_dump(to_orm=True)) for b in agent_create.memory_blocks]
+            created_blocks = self.block_manager.batch_create_blocks(
+                pydantic_blocks,
+                actor=actor,
+            )
+            block_ids.extend([blk.id for blk in created_blocks])
 
-        # add base tools
+        # tools
+        tool_names = set(agent_create.tools or [])
         if agent_create.include_base_tools:
             if agent_create.agent_type == AgentType.sleeptime_agent:
-                tool_names.extend(BASE_SLEEPTIME_TOOLS)
+                tool_names |= set(BASE_SLEEPTIME_TOOLS)
+            elif agent_create.enable_sleeptime:
+                tool_names |= set(BASE_SLEEPTIME_CHAT_TOOLS)
             else:
-                if agent_create.enable_sleeptime:
-                    tool_names.extend(BASE_SLEEPTIME_CHAT_TOOLS)
-                else:
-                    tool_names.extend(BASE_TOOLS + BASE_MEMORY_TOOLS)
+                tool_names |= set(BASE_TOOLS + BASE_MEMORY_TOOLS)
         if agent_create.include_multi_agent_tools:
-            tool_names.extend(MULTI_AGENT_TOOLS)
-
-        # remove duplicates
-        tool_names = list(set(tool_names))
-
-        # convert tool names to ids
-        tool_ids = []
-        for tool_name in tool_names:
-            tool = self.tool_manager.get_tool_by_name(tool_name=tool_name, actor=actor)
-            if not tool:
-                raise ValueError(f"Tool {tool_name} not found")
-            tool_ids.append(tool.id)
-
-        # add passed in `tool_ids`
-        for tool_id in agent_create.tool_ids or []:
-            if tool_id not in tool_ids:
-                tool = self.tool_manager.get_tool_by_id(tool_id=tool_id, actor=actor)
-                if tool:
-                    tool_ids.append(tool.id)
-                    tool_names.append(tool.name)
-                else:
-                    raise ValueError(f"Tool {tool_id} not found")
-
-        # add default tool rules
-        tool_rules = agent_create.tool_rules or []
-        if agent_create.include_base_tool_rules:
-            # apply default tool rules
-            for tool_name in tool_names:
-                if tool_name == "send_message" or tool_name == "send_message_to_agent_async" or tool_name == "memory_finish_edits":
-                    tool_rules.append(PydanticTerminalToolRule(tool_name=tool_name))
-                elif tool_name in BASE_TOOLS + BASE_MEMORY_TOOLS + BASE_SLEEPTIME_TOOLS:
-                    tool_rules.append(PydanticContinueToolRule(tool_name=tool_name))
-
-        # if custom rules, check tool rules are valid
-        if agent_create.tool_rules:
-            check_supports_structured_output(model=agent_create.llm_config.model, tool_rules=agent_create.tool_rules)
-
-        # Create the agent
-        agent_state = self._create_agent(
-            name=agent_create.name,
-            system=system,
-            agent_type=agent_create.agent_type,
-            llm_config=agent_create.llm_config,
-            embedding_config=agent_create.embedding_config,
-            block_ids=block_ids,
-            tool_ids=tool_ids,
-            source_ids=agent_create.source_ids or [],
-            tags=agent_create.tags or [],
-            identity_ids=agent_create.identity_ids or [],
-            description=agent_create.description,
-            metadata=agent_create.metadata,
-            tool_rules=tool_rules,
-            actor=actor,
-            project_id=agent_create.project_id,
-            template_id=agent_create.template_id,
-            base_template_id=agent_create.base_template_id,
-            message_buffer_autoclear=agent_create.message_buffer_autoclear,
-            enable_sleeptime=agent_create.enable_sleeptime,
-        )
+            tool_names |= set(MULTI_AGENT_TOOLS)
 
-        # If there are provided environment variables, add them in
-        if agent_create.tool_exec_environment_variables:
-            agent_state = self._set_environment_variables(
-                agent_id=agent_state.id,
-                env_vars=agent_create.tool_exec_environment_variables,
-                actor=actor,
-            )
+        supplied_ids = set(agent_create.tool_ids or [])
+
+        source_ids = agent_create.source_ids or []
+        identity_ids = agent_create.identity_ids or []
+        tag_values = agent_create.tags or []
 
-        return self.append_initial_message_sequence_to_in_context_messages(actor, agent_state, agent_create.initial_message_sequence)
+        with self.session_maker() as session:
+            with session.begin():
+                name_to_id, id_to_name = self._resolve_tools(
+                    session,
+                    tool_names,
+                    supplied_ids,
+                    actor.organization_id,
+                )
+
+                tool_ids = set(name_to_id.values()) | set(id_to_name.keys())
+                tool_names = set(name_to_id.keys())  # now canonical
+
+                tool_rules = list(agent_create.tool_rules or [])
+                if agent_create.include_base_tool_rules:
+                    for tn in tool_names:
+                        if tn in {"send_message", "send_message_to_agent_async", "memory_finish_edits"}:
+                            tool_rules.append(TerminalToolRule(tool_name=tn))
+                        elif tn in (BASE_TOOLS + BASE_MEMORY_TOOLS + BASE_SLEEPTIME_TOOLS):
+                            tool_rules.append(ContinueToolRule(tool_name=tn))
+
+                if tool_rules:
+                    check_supports_structured_output(model=agent_create.llm_config.model, tool_rules=tool_rules)
+
+                new_agent = AgentModel(
+                    name=agent_create.name,
+                    system=derive_system_message(
+                        agent_type=agent_create.agent_type,
+                        enable_sleeptime=agent_create.enable_sleeptime,
+                        system=agent_create.system,
+                    ),
+                    agent_type=agent_create.agent_type,
+                    llm_config=agent_create.llm_config,
+                    embedding_config=agent_create.embedding_config,
+                    organization_id=actor.organization_id,
+                    description=agent_create.description,
+                    metadata_=agent_create.metadata,
+                    tool_rules=tool_rules,
+                    project_id=agent_create.project_id,
+                    template_id=agent_create.template_id,
+                    base_template_id=agent_create.base_template_id,
+                    message_buffer_autoclear=agent_create.message_buffer_autoclear,
+                    enable_sleeptime=agent_create.enable_sleeptime,
+                    created_by_id=actor.id,
+                    last_updated_by_id=actor.id,
+                )
+                session.add(new_agent)
+                session.flush()
+                aid = new_agent.id
+
+                self._bulk_insert_pivot(
+                    session,
+                    ToolsAgents.__table__,
+                    [{"agent_id": aid, "tool_id": tid} for tid in tool_ids],
+                )
+
+                if block_ids:
+                    rows = [
+                        {"agent_id": aid, "block_id": bid, "block_label": lbl}
+                        for bid, lbl in session.execute(select(BlockModel.id, BlockModel.label).where(BlockModel.id.in_(block_ids))).all()
+                    ]
+                    self._bulk_insert_pivot(session, BlocksAgents.__table__, rows)
+
+                self._bulk_insert_pivot(
+                    session,
+                    SourcesAgents.__table__,
+                    [{"agent_id": aid, "source_id": sid} for sid in source_ids],
+                )
+                self._bulk_insert_pivot(
+                    session,
+                    AgentsTags.__table__,
+                    [{"agent_id": aid, "tag": tag} for tag in tag_values],
+                )
+                self._bulk_insert_pivot(
+                    session,
+                    IdentitiesAgents.__table__,
+                    [{"agent_id": aid, "identity_id": iid} for iid in identity_ids],
+                )
+
+                if agent_create.tool_exec_environment_variables:
+                    env_rows = [
+                        {
+                            "agent_id": aid,
+                            "key": key,
+                            "value": val,
+                            "organization_id": actor.organization_id,
+                        }
+                        for key, val in agent_create.tool_exec_environment_variables.items()
+                    ]
+                    session.execute(insert(AgentEnvironmentVariable).values(env_rows))
+
+                # initial message sequence
+                init_messages = self._generate_initial_message_sequence(
+                    actor,
+                    agent_state=new_agent.to_pydantic(include_relationships={"memory"}),
+                    supplied_initial_message_sequence=agent_create.initial_message_sequence,
+                )
+                new_agent.message_ids = [msg.id for msg in init_messages]
+
+            session.refresh(new_agent)
+
+        self.message_manager.create_many_messages(pydantic_msgs=init_messages, actor=actor)
+        return new_agent.to_pydantic()
 
     @enforce_types
-    def append_initial_message_sequence_to_in_context_messages(
-        self, actor: PydanticUser, agent_state: PydanticAgentState, initial_message_sequence: Optional[List[MessageCreate]] = None
-    ) -> PydanticAgentState:
+    def _generate_initial_message_sequence(
+        self, actor: PydanticUser, agent_state: PydanticAgentState, supplied_initial_message_sequence: Optional[List[MessageCreate]] = None
+    ) -> List[Message]:
         init_messages = initialize_message_sequence(
             agent_state=agent_state, memory_edit_timestamp=get_utc_time(), include_initial_boot_message=True
         )
-
-        if initial_message_sequence is not None:
+        if supplied_initial_message_sequence is not None:
             # We always need the system prompt up front
             system_message_obj = PydanticMessage.dict_to_message(
                 agent_id=agent_state.id,
@@ -219,7 +314,7 @@ class AgentManager:
             # Don't use anything else in the pregen sequence, instead use the provided sequence
             init_messages = [system_message_obj]
             init_messages.extend(
-                package_initial_message_sequence(agent_state.id, initial_message_sequence, agent_state.llm_config.model, actor)
+                package_initial_message_sequence(agent_state.id, supplied_initial_message_sequence, agent_state.llm_config.model, actor)
             )
         else:
             init_messages = [
@@ -227,145 +322,131 @@ class AgentManager:
                 for msg in init_messages
             ]
 
+        return init_messages
+
+    @enforce_types
+    def append_initial_message_sequence_to_in_context_messages(
+        self, actor: PydanticUser, agent_state: PydanticAgentState, initial_message_sequence: Optional[List[MessageCreate]] = None
+    ) -> PydanticAgentState:
+        init_messages = self._generate_initial_message_sequence(actor, agent_state, initial_message_sequence)
         return self.append_to_in_context_messages(init_messages, agent_id=agent_state.id, actor=actor)
 
     @enforce_types
-    def _create_agent(
+    def update_agent(
         self,
+        agent_id: str,
+        agent_update: UpdateAgent,
         actor: PydanticUser,
-        name: str,
-        system: str,
-        agent_type: AgentType,
-        llm_config: LLMConfig,
-        embedding_config: EmbeddingConfig,
-        block_ids: List[str],
-        tool_ids: List[str],
-        source_ids: List[str],
-        tags: List[str],
-        identity_ids: List[str],
-        description: Optional[str] = None,
-        metadata: Optional[Dict] = None,
-        tool_rules: Optional[List[PydanticToolRule]] = None,
-        project_id: Optional[str] = None,
-        template_id: Optional[str] = None,
-        base_template_id: Optional[str] = None,
-        message_buffer_autoclear: bool = False,
-        enable_sleeptime: Optional[bool] = None,
     ) -> PydanticAgentState:
-        """Create a new agent."""
-        with self.session_maker() as session:
-            # Prepare the agent data
-            data = {
-                "name": name,
-                "system": system,
-                "agent_type": agent_type,
-                "llm_config": llm_config,
-                "embedding_config": embedding_config,
-                "organization_id": actor.organization_id,
-                "description": description,
-                "metadata_": metadata,
-                "tool_rules": tool_rules,
-                "project_id": project_id,
-                "template_id": template_id,
-                "base_template_id": base_template_id,
-                "message_buffer_autoclear": message_buffer_autoclear,
-                "enable_sleeptime": enable_sleeptime,
-            }
-
-            # Create the new agent using SqlalchemyBase.create
-            new_agent = AgentModel(**data)
-            _process_relationship(session, new_agent, "tools", ToolModel, tool_ids, replace=True)
-            _process_relationship(session, new_agent, "sources", SourceModel, source_ids, replace=True)
-            _process_relationship(session, new_agent, "core_memory", BlockModel, block_ids, replace=True)
-            _process_tags(new_agent, tags, replace=True)
-            _process_relationship(session, new_agent, "identities", IdentityModel, identity_ids, replace=True)
 
-            new_agent.create(session, actor=actor)
-
-            # Convert to PydanticAgentState and return
-            return new_agent.to_pydantic()
+        new_tools = set(agent_update.tool_ids or [])
+        new_sources = set(agent_update.source_ids or [])
+        new_blocks = set(agent_update.block_ids or [])
+        new_idents = set(agent_update.identity_ids or [])
+        new_tags = set(agent_update.tags or [])
+
+        with self.session_maker() as session, session.begin():
+
+            agent: AgentModel = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
+            agent.updated_at = datetime.now(timezone.utc)
+            agent.last_updated_by_id = actor.id
+
+            scalar_updates = {
+                "name": agent_update.name,
+                "system": agent_update.system,
+                "llm_config": agent_update.llm_config,
+                "embedding_config": agent_update.embedding_config,
+                "message_ids": agent_update.message_ids,
+                "tool_rules": agent_update.tool_rules,
+                "description": agent_update.description,
+                "project_id": agent_update.project_id,
+                "template_id": agent_update.template_id,
+                "base_template_id": agent_update.base_template_id,
+                "message_buffer_autoclear": agent_update.message_buffer_autoclear,
+                "enable_sleeptime": agent_update.enable_sleeptime,
+            }
+            for col, val in scalar_updates.items():
+                if val is not None:
+                    setattr(agent, col, val)
 
-    @enforce_types
-    def update_agent(self, agent_id: str, agent_update: UpdateAgent, actor: PydanticUser) -> PydanticAgentState:
-        agent_state = self._update_agent(agent_id=agent_id, agent_update=agent_update, actor=actor)
+            if agent_update.metadata is not None:
+                agent.metadata_ = agent_update.metadata
 
-        # If there are provided environment variables, add them in
-        if agent_update.tool_exec_environment_variables:
-            agent_state = self._set_environment_variables(
-                agent_id=agent_state.id,
-                env_vars=agent_update.tool_exec_environment_variables,
-                actor=actor,
-            )
+            aid = agent.id
 
-        # Rebuild the system prompt if it's different
-        if agent_update.enable_sleeptime and agent_update.system is None:
-            agent_update.system = derive_system_message(
-                agent_type=agent_state.agent_type,
-                enable_sleeptime=agent_update.enable_sleeptime,
-                system=agent_update.system or agent_state.system,
-            )
-        if agent_update.system and agent_update.system != agent_state.system:
-            agent_state = self.rebuild_system_prompt(agent_id=agent_state.id, actor=actor, force=True, update_timestamp=False)
+            if agent_update.tool_ids is not None:
+                self._replace_pivot_rows(
+                    session,
+                    ToolsAgents.__table__,
+                    aid,
+                    [{"agent_id": aid, "tool_id": tid} for tid in new_tools],
+                )
+                session.expire(agent, ["tools"])
 
-        return agent_state
+            if agent_update.source_ids is not None:
+                self._replace_pivot_rows(
+                    session,
+                    SourcesAgents.__table__,
+                    aid,
+                    [{"agent_id": aid, "source_id": sid} for sid in new_sources],
+                )
+                session.expire(agent, ["sources"])
 
-    @enforce_types
-    def _update_agent(self, agent_id: str, agent_update: UpdateAgent, actor: PydanticUser) -> PydanticAgentState:
-        """
-        Update an existing agent.
+            if agent_update.block_ids is not None:
+                rows = []
+                if new_blocks:
+                    label_map = {
+                        bid: lbl
+                        for bid, lbl in session.execute(select(BlockModel.id, BlockModel.label).where(BlockModel.id.in_(new_blocks)))
+                    }
+                    rows = [{"agent_id": aid, "block_id": bid, "block_label": label_map[bid]} for bid in new_blocks]
 
-        Args:
-            agent_id: The ID of the agent to update.
-            agent_update: UpdateAgent object containing the updated fields.
-            actor: User performing the action.
+                self._replace_pivot_rows(session, BlocksAgents.__table__, aid, rows)
+                session.expire(agent, ["core_memory"])
 
-        Returns:
-            PydanticAgentState: The updated agent as a Pydantic model.
-        """
-        with self.session_maker() as session:
-            # Retrieve the existing agent
-            agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
+            if agent_update.identity_ids is not None:
+                self._replace_pivot_rows(
+                    session,
+                    IdentitiesAgents.__table__,
+                    aid,
+                    [{"agent_id": aid, "identity_id": iid} for iid in new_idents],
+                )
+                session.expire(agent, ["identities"])
 
-            # Update scalar fields directly
-            scalar_fields = {
-                "name",
-                "system",
-                "llm_config",
-                "embedding_config",
-                "message_ids",
-                "tool_rules",
-                "description",
-                "metadata",
-                "project_id",
-                "template_id",
-                "base_template_id",
-                "message_buffer_autoclear",
-                "enable_sleeptime",
-            }
-            for field in scalar_fields:
-                value = getattr(agent_update, field, None)
-                if value is not None:
-                    if field == "metadata":
-                        setattr(agent, "metadata_", value)
-                    else:
-                        setattr(agent, field, value)
-
-            # Update relationships using _process_relationship and _process_tags
-            if agent_update.tool_ids is not None:
-                _process_relationship(session, agent, "tools", ToolModel, agent_update.tool_ids, replace=True)
-            if agent_update.source_ids is not None:
-                _process_relationship(session, agent, "sources", SourceModel, agent_update.source_ids, replace=True)
-            if agent_update.block_ids is not None:
-                _process_relationship(session, agent, "core_memory", BlockModel, agent_update.block_ids, replace=True)
             if agent_update.tags is not None:
-                _process_tags(agent, agent_update.tags, replace=True)
-            if agent_update.identity_ids is not None:
-                _process_relationship(session, agent, "identities", IdentityModel, agent_update.identity_ids, replace=True)
+                self._replace_pivot_rows(
+                    session,
+                    AgentsTags.__table__,
+                    aid,
+                    [{"agent_id": aid, "tag": tag} for tag in new_tags],
+                )
+                session.expire(agent, ["tags"])
+
+            if agent_update.tool_exec_environment_variables is not None:
+                session.execute(delete(AgentEnvironmentVariable).where(AgentEnvironmentVariable.agent_id == aid))
+                env_rows = [
+                    {
+                        "agent_id": aid,
+                        "key": k,
+                        "value": v,
+                        "organization_id": agent.organization_id,
+                    }
+                    for k, v in agent_update.tool_exec_environment_variables.items()
+                ]
+                if env_rows:
+                    self._bulk_insert_pivot(session, AgentEnvironmentVariable.__table__, env_rows)
+                session.expire(agent, ["tool_exec_environment_variables"])
+
+            if agent_update.enable_sleeptime and agent_update.system is None:
+                agent.system = derive_system_message(
+                    agent_type=agent.agent_type,
+                    enable_sleeptime=agent_update.enable_sleeptime,
+                    system=agent.system,
+                )
 
-            # Commit and refresh the agent
-            agent.update(session, actor=actor)
+            session.flush()
+            session.refresh(agent)
 
-            # Convert to PydanticAgentState and return
             return agent.to_pydantic()
 
     # TODO: Make this general and think about how to roll this into sqlalchemybase

letta/services/block_manager.py

@@ -37,6 +37,29 @@ class BlockManager:
                 block.create(session, actor=actor)
             return block.to_pydantic()
 
+    @enforce_types
+    def batch_create_blocks(self, blocks: List[PydanticBlock], actor: PydanticUser) -> List[PydanticBlock]:
+        """
+        Batch-create multiple Blocks in one transaction for better performance.
+        Args:
+            blocks: List of PydanticBlock schemas to create
+            actor:    The user performing the operation
+        Returns:
+            List of created PydanticBlock instances (with IDs, timestamps, etc.)
+        """
+        if not blocks:
+            return []
+
+        with self.session_maker() as session:
+            block_models = [
+                BlockModel(**block.model_dump(to_orm=True, exclude_none=True), organization_id=actor.organization_id) for block in blocks
+            ]
+
+            created_models = BlockModel.batch_create(items=block_models, db_session=session, actor=actor)
+
+            # Convert back to Pydantic
+            return [m.to_pydantic() for m in created_models]
+
     @enforce_types
     def update_block(self, block_id: str, block_update: BlockUpdate, actor: PydanticUser) -> PydanticBlock:
         """Update a block by its ID with the given BlockUpdate object."""

letta/services/helpers/agent_manager_helper.py

@@ -21,9 +21,11 @@ from letta.schemas.passage import Passage as PydanticPassage
 from letta.schemas.tool_rule import ToolRule
 from letta.schemas.user import User
 from letta.system import get_initial_boot_messages, get_login_event
+from letta.tracing import trace_method
 
 
 # Static methods
+@trace_method
 def _process_relationship(
     session, agent: AgentModel, relationship_name: str, model_class, item_ids: List[str], allow_partial=False, replace=True
 ):

letta/services/provider_manager.py

@@ -29,11 +29,11 @@ class ProviderManager:
             return new_provider.to_pydantic()
 
     @enforce_types
-    def update_provider(self, provider_update: ProviderUpdate, actor: PydanticUser) -> PydanticProvider:
+    def update_provider(self, provider_id: str, provider_update: ProviderUpdate, actor: PydanticUser) -> PydanticProvider:
         """Update provider details."""
         with self.session_maker() as session:
             # Retrieve the existing provider by ID
-            existing_provider = ProviderModel.read(db_session=session, identifier=provider_update.id, actor=actor)
+            existing_provider = ProviderModel.read(db_session=session, identifier=provider_id, actor=actor)
 
             # Update only the fields that are provided in ProviderUpdate
             update_data = provider_update.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)

{letta_nightly-0.6.54.dev20250420104127.dist-info → letta_nightly-0.7.0.dev20250421104249.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.54.dev20250420104127
+Version: 0.7.0.dev20250421104249
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -51,11 +51,12 @@ Requires-Dist: isort (>=5.13.2,<6.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: jinja2 (>=3.1.5,<4.0.0)
 Requires-Dist: langchain (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
 Requires-Dist: langchain-community (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
-Requires-Dist: letta_client (>=0.1.104,<0.2.0)
+Requires-Dist: letta_client (>=0.1.124,<0.2.0)
 Requires-Dist: llama-index (>=0.12.2,<0.13.0)
 Requires-Dist: llama-index-embeddings-openai (>=0.3.1,<0.4.0)
 Requires-Dist: locust (>=2.31.5,<3.0.0) ; extra == "dev" or extra == "desktop" or extra == "all"
 Requires-Dist: marshmallow-sqlalchemy (>=1.4.1,<2.0.0)
+Requires-Dist: matplotlib (>=3.10.1,<4.0.0)
 Requires-Dist: mcp (>=1.3.0,<2.0.0)
 Requires-Dist: nltk (>=3.8.1,<4.0.0)
 Requires-Dist: numpy (>=1.26.2,<2.0.0)
@@ -107,26 +108,13 @@ Description-Content-Type: text/markdown
 
 <div align="center">
 <h1>Letta (previously MemGPT)</h1>
-
-**☄️ New release: Letta Agent Development Environment (_read more [here](#-access-the-ade-agent-development-environment)_) ☄️**
-
-<p align="center">
-  <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/letta-ai/letta/refs/heads/main/assets/example_ade_screenshot.png">
-    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/letta-ai/letta/refs/heads/main/assets/example_ade_screenshot_light.png">
-    <img alt="Letta logo" src="https://raw.githubusercontent.com/letta-ai/letta/refs/heads/main/assets/example_ade_screenshot.png" width="800">
-  </picture>
-</p>
-
----
-
 <h3>
 
 [Homepage](https://letta.com) // [Documentation](https://docs.letta.com) // [ADE](https://docs.letta.com/agent-development-environment) // [Letta Cloud](https://forms.letta.com/early-access)
 
 </h3>
 
-**👾 Letta** is an open source framework for building stateful LLM applications. You can use Letta to build **stateful agents** with advanced reasoning capabilities and transparent long-term memory. The Letta framework is white box and model-agnostic.
+**👾 Letta** is an open source framework for building **stateful agents** with advanced reasoning capabilities and transparent long-term memory. The Letta framework is white box and model-agnostic.
 
 [![Discord](https://img.shields.io/discord/1161736243340640419?label=Discord&logo=discord&logoColor=5865F2&style=flat-square&color=5865F2)](https://discord.gg/letta)
 [![Twitter Follow](https://img.shields.io/badge/Follow-%40Letta__AI-1DA1F2?style=flat-square&logo=x&logoColor=white)](https://twitter.com/Letta_AI)

{letta_nightly-0.6.54.dev20250420104127.dist-info → letta_nightly-0.7.0.dev20250421104249.dist-info}/RECORD

@@ -1,4 +1,4 @@
-letta/__init__.py,sha256=ETKsidgnIBpWqFIzN5tWlkw9uL8R3EtF7_Vu7Ldht7Y,918
+letta/__init__.py,sha256=EQrpCriqdG699Hu-3af2VUn66tanxOkvy4kEeGRrOT8,917
 letta/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
 letta/agent.py,sha256=V7Hn2xU1wfp16bfuRsaGMntln49OTc05yiemM5A8XI0,70279
 letta/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -19,11 +19,11 @@ letta/client/client.py,sha256=3uNsMqQyebbjFeWHHyqcManPUH7JzkBzmA9OgOLQrQs,137582
 letta/client/streaming.py,sha256=UsDS_tDTsA3HgYryIDvGGmx_dWfnfQwtmEwLi4Z89Ik,4701
 letta/client/utils.py,sha256=VCGV-op5ZSmurd4yw7Vhf93XDQ0BkyBT8qsuV7EqfiU,2859
 letta/config.py,sha256=JFGY4TWW0Wm5fTbZamOwWqk5G8Nn-TXyhgByGoAqy2c,12375
-letta/constants.py,sha256=R4kq9c4FPfnmJXlii0JEBljqBNeouufVPEdF2FwqFMY,8565
-letta/data_sources/connectors.py,sha256=R2AssXpqS7wN6VI8AfxvqaZs5S1ZACc4E_FewmR9iZI,7022
+letta/constants.py,sha256=munrDJiDg06_9natYWv9mMu8OOS_tr0CdosA0YF5xQw,8571
+letta/data_sources/connectors.py,sha256=m4ALtjlaZpSlJnlq2VMNzx0onowNpjvoa4ZjAB5SMQw,7243
 letta/data_sources/connectors_helper.py,sha256=oQpVlc-BjSz9sTZ7sp4PsJSXJbBKpZPi3Dam03CURTQ,3376
 letta/embeddings.py,sha256=KvC2bl5tARpVY9xcFmw4Cwu1vN0DoH266v2mSUZqwkY,10528
-letta/errors.py,sha256=TezN7uPt7TtOof4Iu9_tq3UxrFE0zjn2o-3_ewKCfiw,6641
+letta/errors.py,sha256=GCgFBvluPxebfz1_wB0y-82N8rlVPhGIn-x7UfV3wVU,6961
 letta/functions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/functions/ast_parsers.py,sha256=CQI0rUoIXcLKAev_GYrXcldRIGN5ZQtk5u4FLoHe5sE,5728
 letta/functions/function_sets/base.py,sha256=Z-trOG7dKbOWpJlsEBNSGlwcQnPuRXqnQ9NMed98nbY,16392
@@ -73,7 +73,7 @@ letta/llm_api/azure_openai.py,sha256=YAkXwKyfnJFNhB45pkJVFsoxUNB_M74rQYchtw_CN6I
 letta/llm_api/azure_openai_constants.py,sha256=ZaR2IasJThijG0uhLKJThrixdAxLPD2IojfeaJ-KQMQ,294
 letta/llm_api/cohere.py,sha256=7Be_t5jt5EtWX8UUScJkX-IF9SpiZw9cDEcRC6PaxUM,14841
 letta/llm_api/deepseek.py,sha256=b1mSW8gnBrpAI8d2GcBpDyLYDnuC-P1UP6xJPalfQS4,12456
-letta/llm_api/google_ai_client.py,sha256=mzp06rYcfP1UHPLvFbHuwvcs7NgPncZFMY6VIcrkA1U,22643
+letta/llm_api/google_ai_client.py,sha256=_uXwB5GcDO4kBTs2qtwy3Yz82rkgn8j4ytqYJDmhSW8,22686
 letta/llm_api/google_constants.py,sha256=1dqwt-YwdYGnAHV5rIPfGHfE3ybPzSn_48vlNYfd-bk,588
 letta/llm_api/google_vertex_client.py,sha256=hDj0pthZrht-dsdzyE6vZYBuSzyiLazSdcgpI76lEqg,11144
 letta/llm_api/helpers.py,sha256=sLYv30UnKBRVPuhU_KDXfKFdbkUONiDAyVEwGr86l3A,16780
@@ -147,7 +147,7 @@ letta/orm/job.py,sha256=PuSaDJlUNYRISgtmzjJFX1744q1cx5gixlSAtiIs19o,2597
 letta/orm/job_messages.py,sha256=SgwaYPYwwAC3dBtl9Xye_TWUl9H_-m95S95TTcfPyOg,1245
 letta/orm/llm_batch_items.py,sha256=eoB4Vi90GC4FIGQIpv4RYoJtuLFy_14VEGWdW2Wy95U,2756
 letta/orm/llm_batch_job.py,sha256=LaeOrnNf6FMm6ff2kOCEAjtbSuz4C5KYU5OmM90F1PY,2368
-letta/orm/message.py,sha256=3067u36PeDFCS7j3Sx4Y4G_HZiHNW3eQ2tkgXgNC9V0,4731
+letta/orm/message.py,sha256=1IMlyvpfw1HqJel_V_tA5GxkNnJiE9mwO0mNgAIFam8,4685
 letta/orm/mixins.py,sha256=9c79Kfr-Z1hL-SDYKeoptx_yMTbBwJJBo9nrKEzSDAc,1622
 letta/orm/organization.py,sha256=STQ5x5zXoPhfagiRQX6j2lWgOqwznPp-K019MPjbY0s,3599
 letta/orm/passage.py,sha256=luoQMBAm2DwWpcGtQziMDjDP5JZZNv1pnEmx-InNHFo,3090
@@ -214,14 +214,14 @@ letta/schemas/llm_config.py,sha256=UA3_a4qv5Kb_jMQSCEZLZ0PLwVyOC332SxIcvZBM5bA,7
 letta/schemas/llm_config_overrides.py,sha256=-oRglCTcajF6UAK3RAa0FLWVuKODPI1v403fDIWMAtA,1815
 letta/schemas/memory.py,sha256=GOYDfPKzbWftUWO9Hv4KW7xAi1EIQmC8zpP7qvEkVHw,10245
 letta/schemas/message.py,sha256=cXcQjwzNE7tbwZGuFu-x8T_yUb3EyVrbHYZKSJ4GpbA,48520
-letta/schemas/openai/chat_completion_request.py,sha256=B07JpvTAuu_mFtKwXmP9_8w7co1a24lha5cMd8JHocE,4139
+letta/schemas/openai/chat_completion_request.py,sha256=PZHzx--ooqJLsHTo1NpHwfywm5L8Id-CUXaKR6eXuko,4171
 letta/schemas/openai/chat_completion_response.py,sha256=yoepGZkg5PIobGqvATJruPdV4odpIUDHWniodSQo3PY,4433
 letta/schemas/openai/chat_completions.py,sha256=l0e9sT9boTD5VBU5YtJ0s7qUtCfFGB2K-gQLeEZ2LHU,3599
 letta/schemas/openai/embedding_response.py,sha256=WKIZpXab1Av7v6sxKG8feW3ZtpQUNosmLVSuhXYa_xU,357
 letta/schemas/openai/openai.py,sha256=Hilo5BiLAGabzxCwnwfzK5QrWqwYD8epaEKFa4Pwndk,7970
 letta/schemas/organization.py,sha256=TXrHN4IBQnX-mWvRuCOH57XZSLYCVOY0wWm2_UzDQIA,1279
 letta/schemas/passage.py,sha256=RG0vkaewEu4a_NAZM-FVyMammHjqpPP0RDYAdu27g6A,3723
-letta/schemas/providers.py,sha256=GE1iagHZQowosLaqIiuou1HPN61QwlJGz8QycxW2i0E,51717
+letta/schemas/providers.py,sha256=lUz9QvMm_-wUUJZ5OGRsefsora0Y_55s3xQwnzL8gOw,51643
 letta/schemas/run.py,sha256=SRqPRziINIiPunjOhE_NlbnQYgxTvqmbauni_yfBQRA,2085
 letta/schemas/sandbox_config.py,sha256=SZCo3FSMz-DIBMKGu0atT4tsVFXGsqMFPaJnjrxpkX4,5993
 letta/schemas/source.py,sha256=IuenIFs7B8uOuYJIHXqR1E28wVSa-pUX6NkLZH7cukg,3141
@@ -265,7 +265,7 @@ letta/server/rest_api/routers/v1/jobs.py,sha256=4oeJfI2odNGubU_g7WSORJhn_usFsbRa
 letta/server/rest_api/routers/v1/llms.py,sha256=lYp5URXtZk1yu_Pe-p1Wq1uQ0qeb6aWtx78rXSB7N_E,881
 letta/server/rest_api/routers/v1/messages.py,sha256=bHB51Qu1q3IngwaYXLPdn7gmi3K66rf-9iLkdTWcpBI,4530
 letta/server/rest_api/routers/v1/organizations.py,sha256=r7rj-cA3shgAgM0b2JCMqjYsDIFv3ruZjU7SYbPGGqg,2831
-letta/server/rest_api/routers/v1/providers.py,sha256=qyZsNTXgLVsoLZoCVY4qaqiG34zCEVmRUP2Cn6maK_4,2949
+letta/server/rest_api/routers/v1/providers.py,sha256=MVfAUvXj_2jx8XFwSigM-8CuCfEATW60h8J5UEmAhp0,3146
 letta/server/rest_api/routers/v1/runs.py,sha256=9nuJRjBtRgZPq3CiCEUA_3S2xPHFP5DsJxIenH5OO34,8847
 letta/server/rest_api/routers/v1/sandbox_configs.py,sha256=9hqnnMwJ3wCwO-Bezu3Xl8i3TDSIuInw3gSeHaKUXfE,8526
 letta/server/rest_api/routers/v1/sources.py,sha256=igrT2w2fkwMDhw8LZMjRug00YG5mYg08C6ZLpRHeYq4,10270
@@ -276,7 +276,7 @@ letta/server/rest_api/routers/v1/users.py,sha256=G5DBHSkPfBgVHN2Wkm-rVYiLQAudwQc
 letta/server/rest_api/routers/v1/voice.py,sha256=0lerWjrKLkt4gXLhZl1cIcgstOz9Q2HZwc67L58BCXE,2451
 letta/server/rest_api/static_files.py,sha256=NG8sN4Z5EJ8JVQdj19tkFa9iQ1kBPTab9f_CUxd_u4Q,3143
 letta/server/rest_api/utils.py,sha256=OKUWg7u4vmROVweqRrs83bQvS958bZAoR_bUFDwwqsc,14861
-letta/server/server.py,sha256=KgSnxcim23Bd0s5JAiN6OK8_57P-Nzuz8QjTsgcag_0,81224
+letta/server/server.py,sha256=M_x7zMlLu1jCBA2ocMND2ZFT50l50KZ7AqVRcoxu834,81484
 letta/server/startup.sh,sha256=MRXh1RKbS5lyA7XAsk7O6Q4LEKOqnv5B-dwe0SnTHeQ,2514
 letta/server/static_files/assets/index-048c9598.js,sha256=mR16XppvselwKCcNgONs4L7kZEVa4OEERm4lNZYtLSk,146819
 letta/server/static_files/assets/index-0e31b727.css,sha256=SBbja96uiQVLDhDOroHgM6NSl7tS4lpJRCREgSS_hA8,7672
@@ -290,10 +290,10 @@ letta/server/ws_api/interface.py,sha256=TWl9vkcMCnLsUtgsuENZ-ku2oMDA-OUTzLh_yNRo
 letta/server/ws_api/protocol.py,sha256=5mDgpfNZn_kNwHnpt5Dsuw8gdNH298sgxTGed3etzYg,1836
 letta/server/ws_api/server.py,sha256=cBSzf-V4zT1bL_0i54OTI3cMXhTIIxqjSRF8pYjk7fg,5835
 letta/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/services/agent_manager.py,sha256=pcc31ldrMbkVJm_YqEPTPYp55kf8KS3jDYtTPSTPoBo,67566
-letta/services/block_manager.py,sha256=5dQT1PBxwoZF4daRSKdAwXzrFQjDzw_GCycYY9Wh3gk,14284
+letta/services/agent_manager.py,sha256=kng5jZenzuA-a2LLB1mDSA-nbDmR3kQdCRltAnIBtwY,70852
+letta/services/block_manager.py,sha256=rphbpGBIEDFvCJ5GJt6A1OfbURGFQZ3WardljELQyAc,15225
 letta/services/group_manager.py,sha256=z1woWRRnjkWrGG_auSicXr2bJaJ653JV6PYl2N_AUfw,12224
-letta/services/helpers/agent_manager_helper.py,sha256=ZVvNYKTc3g9u9Lx-3nwOKTwvpNmJ6picSaxqIQP4wh4,17772
+letta/services/helpers/agent_manager_helper.py,sha256=57ARg5TcmE_JdrWmhz5uaNHAt1NGlJ3wQH1tP2XOiAs,17825
 letta/services/helpers/tool_execution_helper.py,sha256=lLoebs1kZKjw62y1PxHbIDkHq_heJN2ZT0gKje-R8oo,6941
 letta/services/identity_manager.py,sha256=PqnUnM3OGCRnd5NPjGonwYBnYAQK8rpiissdNYUouGU,9389
 letta/services/job_manager.py,sha256=Z9cSD-IqpiOIWE_UOTBUEIxGITrJ10JT1G3ske-0yIY,17166
@@ -302,7 +302,7 @@ letta/services/message_manager.py,sha256=_n7mij6bXyHqn4lppszjiXVQ7gHaiyPKEM_t6k8
 letta/services/organization_manager.py,sha256=Ax0KmPSc_YYsYaxeld9gc7ST-J6DemHQ542DD7l7AWA,3989
 letta/services/passage_manager.py,sha256=KY18gHTbx8ROBsOeR7ZAefTMGZwzbxYqOjbadqVFiyQ,9121
 letta/services/per_agent_lock_manager.py,sha256=porM0cKKANQ1FvcGXOO_qM7ARk5Fgi1HVEAhXsAg9-4,546
-letta/services/provider_manager.py,sha256=QOKMSZOM6eAWa2-nANWQc1frKBh8N3gqDq0V87fnSuc,3748
+letta/services/provider_manager.py,sha256=_gEBW0tYIf2vJEGGYxk-nvogrFI9sjFl_97MSL5WC2s,3759
 letta/services/sandbox_config_manager.py,sha256=ATgZNWNpkdIQDUPy4ABsguHQba2PZf51-c4Ji60MzLE,13361
 letta/services/source_manager.py,sha256=SE24AiPPhpvZMGDD047H3_ZDD7OM4zHbTW1JXjPEv7U,7672
 letta/services/step_manager.py,sha256=B64iYn6Dt9yRKsSJ5vLxWQR2t-apvPLfUZyzrUsJTpI,5335
@@ -325,8 +325,8 @@ letta/streaming_utils.py,sha256=jLqFTVhUL76FeOuYk8TaRQHmPTf3HSRc2EoJwxJNK6U,1194
 letta/system.py,sha256=dnOrS2FlRMwijQnOvfrky0Lg8wEw-FUq2zzfAJOUSKA,8477
 letta/tracing.py,sha256=RstWXpfWVF77nmb_ISORVWd9IQw2Ky3de40k_S70yKI,8258
 letta/utils.py,sha256=IZFvtj9WYcrxUbkoUUYGDxMYQYdn5SgfqsvnARGsAzc,32245
-letta_nightly-0.6.54.dev20250420104127.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.6.54.dev20250420104127.dist-info/METADATA,sha256=ZqpL_KrBv82XOi7w4JSHiWYRxRcAv_2NrUgDGvQJJU8,22953
-letta_nightly-0.6.54.dev20250420104127.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.6.54.dev20250420104127.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.6.54.dev20250420104127.dist-info/RECORD,,
+letta_nightly-0.7.0.dev20250421104249.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.7.0.dev20250421104249.dist-info/METADATA,sha256=QWbK2qhFH3whOhriePYciTizbTeu3j8mL8l7xDolra8,22282
+letta_nightly-0.7.0.dev20250421104249.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.7.0.dev20250421104249.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.7.0.dev20250421104249.dist-info/RECORD,,