letta-nightly 0.10.0.dev20250806104523__py3-none-any.whl → 0.11.0.dev20250807000848__py3-none-any.whl

letta/schemas/providers/vllm.py

@@ -27,12 +27,12 @@ class VLLMProvider(Provider):
     async def list_llm_models_async(self) -> list[LLMConfig]:
         from letta.llm_api.openai import openai_get_model_list_async
 
-        # TODO (cliandy): previously unsupported with vLLM; confirm if this is still the case or not
-        response = await openai_get_model_list_async(self.base_url, api_key=self.api_key)
-
+        base_url = self.base_url.rstrip("/") + "/v1" if not self.base_url.endswith("/v1") else self.base_url
+        response = await openai_get_model_list_async(base_url, api_key=self.api_key)
         data = response.get("data", response)
 
         configs = []
+
         for model in data:
             model_name = model["id"]
 
@@ -40,7 +40,7 @@ class VLLMProvider(Provider):
                 LLMConfig(
                     model=model_name,
                     model_endpoint_type="openai",  # TODO (cliandy): this was previous vllm for the completions provider, why?
-                    model_endpoint=self.base_url,
+                    model_endpoint=base_url,
                     model_wrapper=self.default_prompt_formatter,
                     context_window=model["max_model_len"],
                     handle=self.get_handle(model_name),

letta/schemas/sandbox_config.py

@@ -81,7 +81,9 @@ class E2BSandboxConfig(BaseModel):
 
 class ModalSandboxConfig(BaseModel):
     timeout: int = Field(5 * 60, description="Time limit for the sandbox (in seconds).")
-    pip_requirements: Optional[List[str]] = Field(None, description="A list of pip packages to install in the Modal sandbox")
+    pip_requirements: list[str] | None = Field(None, description="A list of pip packages to install in the Modal sandbox")
+    npm_requirements: list[str] | None = Field(None, description="A list of npm packages to install in the Modal sandbox")
+    language: Literal["python", "typescript"] = "python"
 
     @property
     def type(self) -> "SandboxType":

letta/schemas/tool.py

@@ -22,8 +22,9 @@ from letta.functions.schema_generator import (
     generate_tool_schema_for_mcp,
 )
 from letta.log import get_logger
-from letta.orm.enums import ToolType
+from letta.schemas.enums import ToolType
 from letta.schemas.letta_base import LettaBase
+from letta.schemas.npm_requirement import NpmRequirement
 from letta.schemas.pip_requirement import PipRequirement
 
 logger = get_logger(__name__)
@@ -60,7 +61,8 @@ class Tool(BaseTool):
 
     # tool configuration
     return_char_limit: int = Field(FUNCTION_RETURN_CHAR_LIMIT, description="The maximum number of characters in the response.")
-    pip_requirements: Optional[List[PipRequirement]] = Field(None, description="Optional list of pip packages required by this tool.")
+    pip_requirements: list[PipRequirement] | None = Field(None, description="Optional list of pip packages required by this tool.")
+    npm_requirements: list[NpmRequirement] | None = Field(None, description="Optional list of npm packages required by this tool.")
 
     # metadata fields
     created_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
@@ -144,7 +146,8 @@ class ToolCreate(LettaBase):
     )
     args_json_schema: Optional[Dict] = Field(None, description="The args JSON schema of the function.")
     return_char_limit: int = Field(FUNCTION_RETURN_CHAR_LIMIT, description="The maximum number of characters in the response.")
-    pip_requirements: Optional[List[PipRequirement]] = Field(None, description="Optional list of pip packages required by this tool.")
+    pip_requirements: list[PipRequirement] | None = Field(None, description="Optional list of pip packages required by this tool.")
+    npm_requirements: list[NpmRequirement] | None = Field(None, description="Optional list of npm packages required by this tool.")
 
     @classmethod
     def from_mcp(cls, mcp_server_name: str, mcp_tool: MCPTool) -> "ToolCreate":
@@ -206,39 +209,6 @@ class ToolCreate(LettaBase):
             json_schema=json_schema,
         )
 
-    @classmethod
-    def from_langchain(
-        cls,
-        langchain_tool: "LangChainBaseTool",
-        additional_imports_module_attr_map: dict[str, str] = None,
-    ) -> "ToolCreate":
-        """
-        Class method to create an instance of Tool from a Langchain tool (must be from langchain_community.tools).
-
-        Args:
-            langchain_tool (LangChainBaseTool): An instance of a LangChain BaseTool (BaseTool from LangChain)
-            additional_imports_module_attr_map (dict[str, str]): A mapping of module names to attribute name. This is used internally to import all the required classes for the langchain tool. For example, you would pass in `{"langchain_community.utilities": "WikipediaAPIWrapper"}` for `from langchain_community.tools import WikipediaQueryRun`. NOTE: You do NOT need to specify the tool import here, that is done automatically for you.
-
-        Returns:
-            Tool: A Letta Tool initialized with attributes derived from the provided LangChain BaseTool object.
-        """
-        from letta.functions.helpers import generate_langchain_tool_wrapper
-
-        description = langchain_tool.description
-        source_type = "python"
-        tags = ["langchain"]
-        # NOTE: langchain tools may come from different packages
-        wrapper_func_name, wrapper_function_str = generate_langchain_tool_wrapper(langchain_tool, additional_imports_module_attr_map)
-        json_schema = generate_schema_from_args_schema_v2(langchain_tool.args_schema, name=wrapper_func_name, description=description)
-
-        return cls(
-            description=description,
-            source_type=source_type,
-            tags=tags,
-            source_code=wrapper_function_str,
-            json_schema=json_schema,
-        )
-
 
 class ToolUpdate(LettaBase):
     description: Optional[str] = Field(None, description="The description of the tool.")
@@ -250,7 +220,8 @@ class ToolUpdate(LettaBase):
     )
     args_json_schema: Optional[Dict] = Field(None, description="The args JSON schema of the function.")
     return_char_limit: Optional[int] = Field(None, description="The maximum number of characters in the response.")
-    pip_requirements: Optional[List[PipRequirement]] = Field(None, description="Optional list of pip packages required by this tool.")
+    pip_requirements: list[PipRequirement] | None = Field(None, description="Optional list of pip packages required by this tool.")
+    npm_requirements: list[NpmRequirement] | None = Field(None, description="Optional list of npm packages required by this tool.")
 
     class Config:
         extra = "ignore"  # Allows extra fields without validation errors
@@ -267,4 +238,5 @@ class ToolRunFromSource(LettaBase):
     json_schema: Optional[Dict] = Field(
         None, description="The JSON schema of the function (auto-generated from source_code if not provided)"
     )
-    pip_requirements: Optional[List[PipRequirement]] = Field(None, description="Optional list of pip packages required by this tool.")
+    pip_requirements: list[PipRequirement] | None = Field(None, description="Optional list of pip packages required by this tool.")
+    npm_requirements: list[NpmRequirement] | None = Field(None, description="Optional list of npm packages required by this tool.")

letta/schemas/tool_rule.py

@@ -208,7 +208,7 @@ class MaxCountPerStepToolRule(BaseToolRule):
     type: Literal[ToolRuleType.max_count_per_step] = ToolRuleType.max_count_per_step
     max_count_limit: int = Field(..., description="The max limit for the total number of times this tool can be invoked in a single step.")
     prompt_template: Optional[str] = Field(
-        default="<tool_rule>\n{{ tool_name }}: max {{ max_count_limit }} use(s) per response\n</tool_rule>",
+        default="<tool_rule>\n{{ tool_name }}: at most {{ max_count_limit }} use(s) per response\n</tool_rule>",
         description="Optional Jinja2 template for generating agent prompt about this tool rule.",
     )
 
@@ -223,7 +223,7 @@ class MaxCountPerStepToolRule(BaseToolRule):
         return available_tools
 
     def _get_default_template(self) -> Optional[str]:
-        return "<tool_rule>\n{{ tool_name }}: max {{ max_count_limit }} use(s) per response\n</tool_rule>"
+        return "<tool_rule>\n{{ tool_name }}: at most {{ max_count_limit }} use(s) per response\n</tool_rule>"
 
 
 ToolRule = Annotated[

letta/server/db.py

@@ -226,7 +226,12 @@ class DatabaseRegistry:
 
     def _build_sqlalchemy_engine_args(self, *, is_async: bool) -> dict:
         """Prepare keyword arguments for create_engine / create_async_engine."""
-        use_null_pool = settings.disable_sqlalchemy_pooling
+        # For async SQLite, always use NullPool to avoid cleanup issues during cancellation
+        if is_async and settings.database_engine is DatabaseChoice.SQLITE:
+            use_null_pool = True
+            logger.info("Forcing NullPool for async SQLite to avoid cancellation cleanup issues")
+        else:
+            use_null_pool = settings.disable_sqlalchemy_pooling
 
         if use_null_pool:
             logger.info("Disabling pooling on SqlAlchemy")
@@ -262,7 +267,8 @@ class DatabaseRegistry:
                     }
                 )
 
-        elif is_async:
+        elif is_async and settings.database_engine is DatabaseChoice.POSTGRES:
+            # Invalid for SQLite, results in [0] TypeError: 'prepared_statement_name_func' is an invalid keyword argument for Connection()
             # For asyncpg, statement_cache_size should be in connect_args
             base_args.update(
                 {

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

@@ -4,7 +4,7 @@ import traceback
 from datetime import datetime, timezone
 from typing import Annotated, Any, Dict, List, Optional, Union
 
-from fastapi import APIRouter, Body, Depends, File, Header, HTTPException, Query, Request, UploadFile, status
+from fastapi import APIRouter, Body, Depends, File, Form, Header, HTTPException, Query, Request, UploadFile, status
 from fastapi.responses import JSONResponse
 from marshmallow import ValidationError
 from orjson import orjson
@@ -13,7 +13,7 @@ from sqlalchemy.exc import IntegrityError, OperationalError
 from starlette.responses import Response, StreamingResponse
 
 from letta.agents.letta_agent import LettaAgent
-from letta.constants import DEFAULT_MAX_STEPS, DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG, LETTA_MODEL_ENDPOINT, REDIS_RUN_ID_PREFIX
+from letta.constants import DEFAULT_MAX_STEPS, DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG, REDIS_RUN_ID_PREFIX
 from letta.data_sources.redis_client import get_redis_client
 from letta.groups.sleeptime_multi_agent_v2 import SleeptimeMultiAgentV2
 from letta.helpers.datetime_helpers import get_utc_timestamp_ns
@@ -169,16 +169,17 @@ def import_agent_serialized(
     file: UploadFile = File(...),
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: str | None = Header(None, alias="user_id"),
-    append_copy_suffix: bool = Query(True, description='If set to True, appends "_copy" to the end of the agent name.'),
-    override_existing_tools: bool = Query(
+    append_copy_suffix: bool = Form(True, description='If set to True, appends "_copy" to the end of the agent name.'),
+    override_existing_tools: bool = Form(
         True,
         description="If set to True, existing tools can get their source code overwritten by the uploaded tool definitions. Note that Letta core tools can never be updated externally.",
     ),
-    project_id: str | None = Query(None, description="The project ID to associate the uploaded agent with."),
-    strip_messages: bool = Query(
+    project_id: str | None = Form(None, description="The project ID to associate the uploaded agent with."),
+    strip_messages: bool = Form(
         False,
         description="If set to True, strips all messages from the agent before importing.",
     ),
+    env_vars: Optional[Dict[str, Any]] = Form(None, description="Environment variables to pass to the agent for tool execution."),
 ):
     """
     Import a serialized agent file and recreate the agent in the system.
@@ -199,6 +200,7 @@ def import_agent_serialized(
             override_existing_tools=override_existing_tools,
             project_id=project_id,
             strip_messages=strip_messages,
+            env_vars=env_vars,
         )
         return new_agent
 
@@ -1017,7 +1019,6 @@ async def send_message_streaming(
         "ollama",
     ]
     model_compatible_token_streaming = agent.llm_config.model_endpoint_type in ["anthropic", "openai", "bedrock"]
-    not_letta_endpoint = agent.llm_config.model_endpoint != LETTA_MODEL_ENDPOINT
 
     # Create a new job for execution tracking
     if settings.track_agent_run:
@@ -1085,7 +1086,7 @@ async def send_message_streaming(
                 )
             from letta.server.rest_api.streaming_response import StreamingResponseWithStatusCode, add_keepalive_to_stream
 
-            if request.stream_tokens and model_compatible_token_streaming and not_letta_endpoint:
+            if request.stream_tokens and model_compatible_token_streaming:
                 raw_stream = agent_loop.step_stream(
                     input_messages=request.messages,
                     max_steps=request.max_steps,

letta/server/server.py

@@ -80,6 +80,7 @@ from letta.server.rest_api.interface import StreamingServerInterface
 from letta.server.rest_api.utils import sse_async_generator
 from letta.services.agent_manager import AgentManager
 from letta.services.agent_serialization_manager import AgentSerializationManager
+from letta.services.archive_manager import ArchiveManager
 from letta.services.block_manager import BlockManager
 from letta.services.file_manager import FileManager
 from letta.services.files_agents_manager import FileAgentManager
@@ -215,6 +216,7 @@ class SyncServer(Server):
         self.message_manager = MessageManager()
         self.job_manager = JobManager()
         self.agent_manager = AgentManager()
+        self.archive_manager = ArchiveManager()
         self.provider_manager = ProviderManager()
         self.step_manager = StepManager()
         self.identity_manager = IdentityManager()
@@ -1146,29 +1148,12 @@ class SyncServer(Server):
         )
         return records
 
-    def insert_archival_memory(self, agent_id: str, memory_contents: str, actor: User) -> List[Passage]:
-        # Get the agent object (loaded in memory)
-        agent_state = self.agent_manager.get_agent_by_id(agent_id=agent_id, actor=actor)
-        # Insert into archival memory
-        # TODO: @mindy look at moving this to agent_manager to avoid above extra call
-        passages = self.passage_manager.insert_passage(agent_state=agent_state, agent_id=agent_id, text=memory_contents, actor=actor)
-
-        # rebuild agent system prompt - force since no archival change
-        self.agent_manager.rebuild_system_prompt(agent_id=agent_id, actor=actor, force=True)
-
-        return passages
-
     async def insert_archival_memory_async(self, agent_id: str, memory_contents: str, actor: User) -> List[Passage]:
         # Get the agent object (loaded in memory)
         agent_state = await self.agent_manager.get_agent_by_id_async(agent_id=agent_id, actor=actor)
-        # Insert into archival memory
-        # TODO: @mindy look at moving this to agent_manager to avoid above extra call
-        passages = await self.passage_manager.insert_passage_async(
-            agent_state=agent_state, agent_id=agent_id, text=memory_contents, actor=actor
-        )
 
-        # rebuild agent system prompt - force since no archival change
-        await self.agent_manager.rebuild_system_prompt_async(agent_id=agent_id, actor=actor, force=True)
+        # Insert passages into the archive
+        passages = await self.passage_manager.insert_passage_async(agent_state=agent_state, text=memory_contents, actor=actor)
 
         return passages
 
@@ -1177,17 +1162,6 @@ class SyncServer(Server):
         passages = self.passage_manager.update_passage_by_id(passage_id=memory_id, passage=passage, actor=actor)
         return passages
 
-    def delete_archival_memory(self, memory_id: str, actor: User):
-        # TODO check if it exists first, and throw error if not
-        # TODO: need to also rebuild the prompt here
-        passage = self.passage_manager.get_passage_by_id(passage_id=memory_id, actor=actor)
-
-        # delete the passage
-        self.passage_manager.delete_passage_by_id(passage_id=memory_id, actor=actor)
-
-        # rebuild system prompt and force
-        self.agent_manager.rebuild_system_prompt(agent_id=passage.agent_id, actor=actor, force=True)
-
     async def delete_archival_memory_async(self, memory_id: str, actor: User):
         # TODO check if it exists first, and throw error if not
         # TODO: need to also rebuild the prompt here
@@ -1196,9 +1170,6 @@ class SyncServer(Server):
         # delete the passage
         await self.passage_manager.delete_passage_by_id_async(passage_id=memory_id, actor=actor)
 
-        # rebuild system prompt and force
-        await self.agent_manager.rebuild_system_prompt_async(agent_id=passage.agent_id, actor=actor, force=True)
-
     def get_agent_recall(
         self,
         user_id: str,
@@ -2258,10 +2229,7 @@ class SyncServer(Server):
             llm_config = letta_agent.agent_state.llm_config
             # supports_token_streaming = ["openai", "anthropic", "xai", "deepseek"]
             supports_token_streaming = ["openai", "anthropic", "deepseek"]  # TODO re-enable xAI once streaming is patched
-            if stream_tokens and (
-                llm_config.model_endpoint_type not in supports_token_streaming
-                or llm_config.model_endpoint == constants.LETTA_MODEL_ENDPOINT
-            ):
+            if stream_tokens and (llm_config.model_endpoint_type not in supports_token_streaming):
                 warnings.warn(
                     f"Token streaming is only supported for models with type {' or '.join(supports_token_streaming)} in the model_endpoint: agent has endpoint type {llm_config.model_endpoint_type} and {llm_config.model_endpoint}. Setting stream_tokens to False."
                 )
@@ -2393,9 +2361,7 @@ class SyncServer(Server):
 
         llm_config = letta_multi_agent.agent_state.llm_config
         supports_token_streaming = ["openai", "anthropic", "deepseek"]
-        if stream_tokens and (
-            llm_config.model_endpoint_type not in supports_token_streaming or llm_config.model_endpoint == constants.LETTA_MODEL_ENDPOINT
-        ):
+        if stream_tokens and (llm_config.model_endpoint_type not in supports_token_streaming):
             warnings.warn(
                 f"Token streaming is only supported for models with type {' or '.join(supports_token_streaming)} in the model_endpoint: agent has endpoint type {llm_config.model_endpoint_type} and {llm_config.model_endpoint}. Setting stream_tokens to False."
             )

letta/server/startup.sh

@@ -57,6 +57,9 @@ fi
 if [ -n "$CLICKHOUSE_ENDPOINT" ] && [ -n "$CLICKHOUSE_PASSWORD" ]; then
     echo "Starting OpenTelemetry Collector with Clickhouse export..."
     CONFIG_FILE="/etc/otel/config-clickhouse.yaml"
+elif [ -n "$SIGNOZ_ENDPOINT" ] && [ -n "$SIGNOZ_INGESTION_KEY" ]; then
+    echo "Starting OpenTelemetry Collector with Signoz export..."
+    CONFIG_FILE="/etc/otel/config-signoz.yaml"
 else
     echo "Starting OpenTelemetry Collector with file export only..."
     CONFIG_FILE="/etc/otel/config-file.yaml"

letta/services/agent_manager.py

@@ -1,7 +1,7 @@
 import asyncio
 import os
 from datetime import datetime, timezone
-from typing import Dict, List, Optional, Set, Tuple
+from typing import Any, Dict, List, Optional, Set, Tuple
 
 import sqlalchemy as sa
 from sqlalchemy import delete, func, insert, literal, or_, select, tuple_
@@ -19,6 +19,7 @@ from letta.constants import (
     DEFAULT_MAX_FILES_OPEN,
     DEFAULT_TIMEZONE,
     DEPRECATED_LETTA_TOOLS,
+    EXCLUDED_PROVIDERS_FROM_BASE_TOOL_RULES,
     FILES_TOOLS,
 )
 from letta.helpers import ToolRulesSolver
@@ -26,7 +27,7 @@ from letta.helpers.datetime_helpers import get_utc_time
 from letta.llm_api.llm_client import LLMClient
 from letta.log import get_logger
 from letta.orm import Agent as AgentModel
-from letta.orm import AgentPassage, AgentsTags
+from letta.orm import AgentsTags, ArchivalPassage
 from letta.orm import Block as BlockModel
 from letta.orm import BlocksAgents
 from letta.orm import Group as GroupModel
@@ -35,7 +36,6 @@ 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
@@ -47,10 +47,11 @@ from letta.schemas.block import DEFAULT_BLOCKS
 from letta.schemas.block import Block as PydanticBlock
 from letta.schemas.block import BlockUpdate
 from letta.schemas.embedding_config import EmbeddingConfig
-from letta.schemas.enums import ProviderType
+from letta.schemas.enums import ProviderType, ToolType
 from letta.schemas.file import FileMetadata as PydanticFileMetadata
 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 ContextWindowOverview, Memory
 from letta.schemas.message import Message
 from letta.schemas.message import Message as PydanticMessage
@@ -86,8 +87,8 @@ from letta.services.helpers.agent_manager_helper import (
     calculate_multi_agent_tools,
     check_supports_structured_output,
     compile_system_message,
-    compile_system_message_async,
     derive_system_message,
+    get_system_message_from_compiled_memory,
     initialize_message_sequence,
     initialize_message_sequence_async,
     package_initial_message_sequence,
@@ -332,11 +333,26 @@ class AgentManager:
                 tool_names = set(name_to_id.keys())  # now canonical
 
                 tool_rules = list(agent_create.tool_rules or [])
-                if agent_create.include_base_tool_rules:
+
+                # Override include_base_tool_rules to False if provider is not in excluded set and include_base_tool_rules is not explicitly set to True
+                if (
+                    (
+                        agent_create.llm_config.model_endpoint_type in EXCLUDED_PROVIDERS_FROM_BASE_TOOL_RULES
+                        and agent_create.include_base_tool_rules is None
+                    )
+                    and agent_create.agent_type != AgentType.sleeptime_agent
+                ) or agent_create.include_base_tool_rules is False:
+                    agent_create.include_base_tool_rules = False
+                    logger.info(f"Overriding include_base_tool_rules to False for provider: {agent_create.llm_config.model_endpoint_type}")
+                else:
+                    agent_create.include_base_tool_rules = True
+
+                should_add_base_tool_rules = agent_create.include_base_tool_rules
+                if should_add_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):
+                        elif tn in (BASE_TOOLS + BASE_MEMORY_TOOLS + BASE_MEMORY_TOOLS_V2 + BASE_SLEEPTIME_TOOLS):
                             tool_rules.append(ContinueToolRule(tool_name=tn))
 
                 if tool_rules:
@@ -349,6 +365,7 @@ class AgentManager:
                         enable_sleeptime=agent_create.enable_sleeptime,
                         system=agent_create.system,
                     ),
+                    hidden=agent_create.hidden,
                     agent_type=agent_create.agent_type,
                     llm_config=agent_create.llm_config,
                     embedding_config=agent_create.embedding_config,
@@ -443,6 +460,9 @@ class AgentManager:
         if not agent_create.llm_config or not agent_create.embedding_config:
             raise ValueError("llm_config and embedding_config are required")
 
+        if agent_create.reasoning is not None:
+            agent_create.llm_config = LLMConfig.apply_reasoning_setting_to_config(agent_create.llm_config, agent_create.reasoning)
+
         # blocks
         block_ids = list(agent_create.block_ids or [])
         if agent_create.memory_blocks:
@@ -521,9 +541,23 @@ class AgentManager:
 
                 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:
+
+                # Override include_base_tool_rules to False if provider is not in excluded set and include_base_tool_rules is not explicitly set to True
+                if (
+                    (
+                        agent_create.llm_config.model_endpoint_type in EXCLUDED_PROVIDERS_FROM_BASE_TOOL_RULES
+                        and agent_create.include_base_tool_rules is None
+                    )
+                    and agent_create.agent_type != AgentType.sleeptime_agent
+                ) or agent_create.include_base_tool_rules is False:
+                    agent_create.include_base_tool_rules = False
+                    logger.info(f"Overriding include_base_tool_rules to False for provider: {agent_create.llm_config.model_endpoint_type}")
+                else:
+                    agent_create.include_base_tool_rules = True
+
+                should_add_base_tool_rules = agent_create.include_base_tool_rules
+                if should_add_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))
@@ -547,6 +581,7 @@ class AgentManager:
                     description=agent_create.description,
                     metadata_=agent_create.metadata,
                     tool_rules=tool_rules,
+                    hidden=agent_create.hidden,
                     project_id=agent_create.project_id,
                     template_id=agent_create.template_id,
                     base_template_id=agent_create.base_template_id,
@@ -859,6 +894,10 @@ class AgentManager:
             agent.updated_at = datetime.now(timezone.utc)
             agent.last_updated_by_id = actor.id
 
+            if agent_update.reasoning is not None:
+                llm_config = agent_update.llm_config or agent.llm_config
+                agent_update.llm_config = LLMConfig.apply_reasoning_setting_to_config(llm_config, agent_update.reasoning)
+
             scalar_updates = {
                 "name": agent_update.name,
                 "system": agent_update.system,
@@ -1294,6 +1333,19 @@ class AgentManager:
             agent = AgentModel.read(db_session=session, name=agent_name, actor=actor)
             return agent.to_pydantic()
 
+    @enforce_types
+    @trace_method
+    async def get_agent_archive_ids_async(self, agent_id: str, actor: PydanticUser) -> List[str]:
+        """Get all archive IDs associated with an agent."""
+        from letta.orm import ArchivesAgents
+
+        async with db_registry.async_session() as session:
+            # Direct query to archives_agents table for performance
+            query = select(ArchivesAgents.archive_id).where(ArchivesAgents.agent_id == agent_id)
+            result = await session.execute(query)
+            archive_ids = [row[0] for row in result.fetchall()]
+            return archive_ids
+
     @enforce_types
     @trace_method
     def delete_agent(self, agent_id: str, actor: PydanticUser) -> None:
@@ -1411,6 +1463,7 @@ class AgentManager:
         override_existing_tools: bool = True,
         project_id: Optional[str] = None,
         strip_messages: Optional[bool] = False,
+        env_vars: Optional[dict[str, Any]] = None,
     ) -> PydanticAgentState:
         serialized_agent_dict = serialized_agent.model_dump()
         tool_data_list = serialized_agent_dict.pop("tools", [])
@@ -1441,6 +1494,11 @@ class AgentManager:
             if strip_messages:
                 # we want to strip all but the first (system) message
                 agent.message_ids = [agent.message_ids[0]]
+
+            if env_vars:
+                for var in agent.tool_exec_environment_variables:
+                    var.value = env_vars.get(var.key, "")
+
             agent = agent.create(session, actor=actor)
 
             pydantic_agent = agent.to_pydantic()
@@ -1465,7 +1523,7 @@ class AgentManager:
             ):
                 pydantic_tool = existing_pydantic_tool
             else:
-                pydantic_tool = self.tool_manager.create_or_update_tool(pydantic_tool, actor=actor)
+                pydantic_tool = self.tool_manager.create_or_update_tool(pydantic_tool, actor=actor, bypass_name_check=True)
 
             pydantic_agent = self.attach_tool(agent_id=pydantic_agent.id, tool_id=pydantic_tool.id, actor=actor)
 
@@ -1683,7 +1741,7 @@ class AgentManager:
 
         # note: we only update the system prompt if the core memory is changed
         # this means that the archival/recall memory statistics may be someout out of date
-        curr_memory_str = await agent_state.memory.compile_async(
+        curr_memory_str = await agent_state.memory.compile_in_thread_async(
             sources=agent_state.sources,
             tool_usage_rules=tool_rules_solver.compile_tool_rule_prompts(),
             max_files_open=agent_state.max_files_open,
@@ -1705,16 +1763,13 @@ class AgentManager:
 
         # update memory (TODO: potentially update recall/archival stats separately)
 
-        new_system_message_str = await compile_system_message_async(
+        new_system_message_str = get_system_message_from_compiled_memory(
             system_prompt=agent_state.system,
-            in_context_memory=agent_state.memory,
+            memory_with_sources=curr_memory_str,
             in_context_memory_last_edit=memory_edit_timestamp,
             timezone=agent_state.timezone,
             previous_message_count=num_messages - len(agent_state.message_ids),
             archival_memory_size=num_archival_memories,
-            tool_rules_solver=tool_rules_solver,
-            sources=agent_state.sources,
-            max_files_open=agent_state.max_files_open,
         )
 
         diff = united_diff(curr_system_message_openai["content"], new_system_message_str)
@@ -1873,7 +1928,7 @@ class AgentManager:
         agent_state = await self.get_agent_by_id_async(agent_id=agent_id, actor=actor, include_relationships=["memory", "sources"])
         system_message = await self.message_manager.get_message_by_id_async(message_id=agent_state.message_ids[0], actor=actor)
         temp_tool_rules_solver = ToolRulesSolver(agent_state.tool_rules)
-        new_memory_str = await new_memory.compile_async(
+        new_memory_str = await new_memory.compile_in_thread_async(
             sources=agent_state.sources,
             tool_usage_rules=temp_tool_rules_solver.compile_tool_rule_prompts(),
             max_files_open=agent_state.max_files_open,
@@ -2340,21 +2395,24 @@ class AgentManager:
                 main_query = main_query.limit(limit)
 
             # Execute query
-            results = list(session.execute(main_query))
+            result = session.execute(main_query)
 
             passages = []
-            for row in results:
+            for row in result:
                 data = dict(row._mapping)
-                if data["agent_id"] is not None:
-                    # This is an AgentPassage - remove source fields
+                if data.get("archive_id", None):
+                    # This is an ArchivalPassage - remove source fields
                     data.pop("source_id", None)
                     data.pop("file_id", None)
                     data.pop("file_name", None)
-                    passage = AgentPassage(**data)
-                else:
-                    # This is a SourcePassage - remove agent field
-                    data.pop("agent_id", None)
+                    passage = ArchivalPassage(**data)
+                elif data.get("source_id", None):
+                    # This is a SourcePassage - remove archive field
+                    data.pop("archive_id", None)
+                    data.pop("agent_id", None)  # For backward compatibility
                     passage = SourcePassage(**data)
+                else:
+                    raise ValueError(f"Passage data is malformed, is neither ArchivalPassage nor SourcePassage {data}")
                 passages.append(passage)
 
             return [p.to_pydantic() for p in passages]
@@ -2406,16 +2464,19 @@ class AgentManager:
             passages = []
             for row in result:
                 data = dict(row._mapping)
-                if data["agent_id"] is not None:
-                    # This is an AgentPassage - remove source fields
+                if data.get("archive_id", None):
+                    # This is an ArchivalPassage - remove source fields
                     data.pop("source_id", None)
                     data.pop("file_id", None)
                     data.pop("file_name", None)
-                    passage = AgentPassage(**data)
-                else:
-                    # This is a SourcePassage - remove agent field
-                    data.pop("agent_id", None)
+                    passage = ArchivalPassage(**data)
+                elif data.get("source_id", None):
+                    # This is a SourcePassage - remove archive field
+                    data.pop("archive_id", None)
+                    data.pop("agent_id", None)  # For backward compatibility
                     passage = SourcePassage(**data)
+                else:
+                    raise ValueError(f"Passage data is malformed, is neither ArchivalPassage nor SourcePassage {data}")
                 passages.append(passage)
 
             return [p.to_pydantic() for p in passages]