letta-nightly 0.11.7.dev20250916104104__py3-none-any.whl → 0.11.7.dev20250918104055__py3-none-any.whl

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

@@ -0,0 +1,113 @@
+from typing import List, Literal, Optional
+
+from fastapi import APIRouter, Body, Depends, HTTPException, Query
+from pydantic import BaseModel
+
+from letta.orm.errors import NoResultFound
+from letta.schemas.archive import Archive as PydanticArchive
+from letta.server.rest_api.dependencies import HeaderParams, get_headers, get_letta_server
+from letta.server.server import SyncServer
+
+router = APIRouter(prefix="/archives", tags=["archives"])
+
+
+class ArchiveCreateRequest(BaseModel):
+    """Request model for creating an archive.
+
+    Intentionally excludes vector_db_provider. These are derived internally (vector DB provider from env).
+    """
+
+    name: str
+    description: Optional[str] = None
+
+
+class ArchiveUpdateRequest(BaseModel):
+    """Request model for updating an archive (partial).
+
+    Supports updating only name and description.
+    """
+
+    name: Optional[str] = None
+    description: Optional[str] = None
+
+
+@router.post("/", response_model=PydanticArchive, operation_id="create_archive")
+async def create_archive(
+    archive: ArchiveCreateRequest = Body(...),
+    server: "SyncServer" = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
+    """
+    Create a new archive.
+    """
+    try:
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+        return await server.archive_manager.create_archive_async(
+            name=archive.name,
+            description=archive.description,
+            actor=actor,
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/", response_model=List[PydanticArchive], operation_id="list_archives")
+async def list_archives(
+    before: Optional[str] = Query(
+        None,
+        description="Archive ID cursor for pagination. Returns archives that come before this archive ID in the specified sort order",
+    ),
+    after: Optional[str] = Query(
+        None,
+        description="Archive ID cursor for pagination. Returns archives that come after this archive ID in the specified sort order",
+    ),
+    limit: Optional[int] = Query(50, description="Maximum number of archives to return"),
+    order: Literal["asc", "desc"] = Query(
+        "desc", description="Sort order for archives by creation time. 'asc' for oldest first, 'desc' for newest first"
+    ),
+    name: Optional[str] = Query(None, description="Filter by archive name (exact match)"),
+    agent_id: Optional[str] = Query(None, description="Only archives attached to this agent ID"),
+    server: "SyncServer" = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
+    """
+    Get a list of all archives for the current organization with optional filters and pagination.
+    """
+    try:
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+        archives = await server.archive_manager.list_archives_async(
+            actor=actor,
+            before=before,
+            after=after,
+            limit=limit,
+            ascending=(order == "asc"),
+            name=name,
+            agent_id=agent_id,
+        )
+        return archives
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.patch("/{archive_id}", response_model=PydanticArchive, operation_id="modify_archive")
+async def modify_archive(
+    archive_id: str,
+    archive: ArchiveUpdateRequest = Body(...),
+    server: "SyncServer" = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
+    """
+    Update an existing archive's name and/or description.
+    """
+    try:
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+        return await server.archive_manager.update_archive_async(
+            archive_id=archive_id,
+            name=archive.name,
+            description=archive.description,
+            actor=actor,
+        )
+    except NoResultFound as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

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

@@ -19,18 +19,23 @@ async def list_jobs(
     before: Optional[str] = Query(None, description="Cursor for pagination"),
     after: Optional[str] = Query(None, description="Cursor for pagination"),
     limit: Optional[int] = Query(50, description="Limit for pagination"),
+    active: bool = Query(False, description="Filter for active jobs."),
     ascending: bool = Query(True, description="Whether to sort jobs oldest to newest (True, default) or newest to oldest (False)"),
     headers: HeaderParams = Depends(get_headers),
 ):
     """
     List all jobs.
-    TODO (cliandy): implementation for pagination
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
 
+    statuses = None
+    if active:
+        statuses = [JobStatus.created, JobStatus.running]
+
     # TODO: add filtering by status
     return await server.job_manager.list_jobs_async(
         actor=actor,
+        statuses=statuses,
         source_id=source_id,
         before=before,
         after=after,
@@ -39,7 +44,7 @@ async def list_jobs(
     )
 
 
-@router.get("/active", response_model=List[Job], operation_id="list_active_jobs")
+@router.get("/active", response_model=List[Job], operation_id="list_active_jobs", deprecated=True)
 async def list_active_jobs(
     server: "SyncServer" = Depends(get_letta_server),
     headers: HeaderParams = Depends(get_headers),

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

@@ -10,6 +10,7 @@ from letta.orm.errors import NoResultFound
 from letta.schemas.enums import JobStatus, JobType
 from letta.schemas.letta_message import LettaMessageUnion
 from letta.schemas.letta_request import RetrieveStreamRequest
+from letta.schemas.letta_stop_reason import StopReasonType
 from letta.schemas.openai.chat_completion_response import UsageStatistics
 from letta.schemas.run import Run
 from letta.schemas.step import Step
@@ -31,9 +32,11 @@ def list_runs(
     server: "SyncServer" = Depends(get_letta_server),
     agent_ids: Optional[List[str]] = Query(None, description="The unique identifier of the agent associated with the run."),
     background: Optional[bool] = Query(None, description="If True, filters for runs that were created in background mode."),
+    stop_reason: Optional[StopReasonType] = Query(None, description="Filter runs by stop reason."),
     after: Optional[str] = Query(None, description="Cursor for pagination"),
     before: Optional[str] = Query(None, description="Cursor for pagination"),
     limit: Optional[int] = Query(50, description="Maximum number of runs to return"),
+    active: bool = Query(False, description="Filter for active runs."),
     ascending: bool = Query(
         False,
         description="Whether to sort agents oldest to newest (True) or newest to oldest (False, default)",
@@ -44,16 +47,21 @@ def list_runs(
     List all runs.
     """
     actor = server.user_manager.get_user_or_default(user_id=headers.actor_id)
+    statuses = None
+    if active:
+        statuses = [JobStatus.created, JobStatus.running]
 
     runs = [
         Run.from_job(job)
         for job in server.job_manager.list_jobs(
             actor=actor,
+            statuses=statuses,
             job_type=JobType.RUN,
             limit=limit,
             before=before,
             after=after,
             ascending=False,
+            stop_reason=stop_reason,
         )
     ]
     if agent_ids:
@@ -63,7 +71,7 @@ def list_runs(
     return runs
 
 
-@router.get("/active", response_model=List[Run], operation_id="list_active_runs")
+@router.get("/active", response_model=List[Run], operation_id="list_active_runs", deprecated=True)
 def list_active_runs(
     server: "SyncServer" = Depends(get_letta_server),
     agent_ids: Optional[List[str]] = Query(None, description="The unique identifier of the agent associated with the run."),

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

@@ -5,6 +5,8 @@ from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query
 from pydantic import BaseModel, Field
 
 from letta.orm.errors import NoResultFound
+from letta.schemas.letta_message import LettaMessageUnion
+from letta.schemas.message import Message
 from letta.schemas.provider_trace import ProviderTrace
 from letta.schemas.step import Step
 from letta.schemas.step_metrics import StepMetrics
@@ -138,6 +140,33 @@ async def modify_feedback_for_step(
         raise HTTPException(status_code=404, detail="Step not found")
 
 
+@router.get("/{step_id}/messages", response_model=List[LettaMessageUnion], operation_id="list_messages_for_step")
+async def list_messages_for_step(
+    step_id: str,
+    headers: HeaderParams = Depends(get_headers),
+    server: SyncServer = Depends(get_letta_server),
+    before: Optional[str] = Query(
+        None, description="Message ID cursor for pagination. Returns messages that come before this message ID in the specified sort order"
+    ),
+    after: Optional[str] = Query(
+        None, description="Message ID cursor for pagination. Returns messages that come after this message ID in the specified sort order"
+    ),
+    limit: Optional[int] = Query(100, description="Maximum number of messages to return"),
+    order: Literal["asc", "desc"] = Query(
+        "asc", description="Sort order for messages by creation time. 'asc' for oldest first, 'desc' for newest first"
+    ),
+    order_by: Literal["created_at"] = Query("created_at", description="Sort by field"),
+):
+    """
+    List messages for a given step.
+    """
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    messages = await server.step_manager.list_step_messages_async(
+        step_id=step_id, actor=actor, before=before, after=after, limit=limit, ascending=(order == "asc")
+    )
+    return Message.to_letta_messages_from_list(messages)
+
+
 @router.patch("/{step_id}/transaction/{transaction_id}", response_model=Step, operation_id="update_step_transaction_id")
 async def update_step_transaction_id(
     step_id: str,

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

@@ -728,35 +728,16 @@ async def add_mcp_server_to_config(
             return await server.add_mcp_server_to_config(server_config=request, allow_upsert=True)
         else:
             # log to DB
-            from letta.schemas.mcp import MCPServer
-
-            if isinstance(request, StdioServerConfig):
-                mapped_request = MCPServer(server_name=request.server_name, server_type=request.type, stdio_config=request)
-                # don't allow stdio servers
-                if tool_settings.mcp_disable_stdio:  # protected server
-                    raise HTTPException(
-                        status_code=400,
-                        detail="stdio is not supported in the current environment, please use a self-hosted Letta server in order to add a stdio MCP server",
-                    )
-            elif isinstance(request, SSEServerConfig):
-                mapped_request = MCPServer(
-                    server_name=request.server_name,
-                    server_type=request.type,
-                    server_url=request.server_url,
-                    token=request.resolve_token(),
-                    custom_headers=request.custom_headers,
-                )
-            elif isinstance(request, StreamableHTTPServerConfig):
-                mapped_request = MCPServer(
-                    server_name=request.server_name,
-                    server_type=request.type,
-                    server_url=request.server_url,
-                    token=request.resolve_token(),
-                    custom_headers=request.custom_headers,
+            # Check if stdio servers are disabled
+            if isinstance(request, StdioServerConfig) and tool_settings.mcp_disable_stdio:
+                raise HTTPException(
+                    status_code=400,
+                    detail="stdio is not supported in the current environment, please use a self-hosted Letta server in order to add a stdio MCP server",
                 )
 
             # Create MCP server and optimistically sync tools
-            await server.mcp_manager.create_mcp_server_with_tools(mapped_request, actor=actor)
+            # The mcp_manager will handle encryption of sensitive fields
+            await server.mcp_manager.create_mcp_server_from_config_with_tools(request, actor=actor)
 
             # TODO: don't do this in the future (just return MCPServer)
             all_servers = await server.mcp_manager.list_mcp_servers(actor=actor)

letta/server/server.py

@@ -38,12 +38,12 @@ from letta.log import get_logger
 from letta.orm.errors import NoResultFound
 from letta.otel.tracing import log_event, trace_method
 from letta.prompts.gpt_system import get_system_text
-from letta.schemas.agent import AgentState, AgentType, CreateAgent, UpdateAgent
+from letta.schemas.agent import AgentState, CreateAgent, UpdateAgent
 from letta.schemas.block import Block, BlockUpdate, CreateBlock
 from letta.schemas.embedding_config import EmbeddingConfig
 
 # openai schemas
-from letta.schemas.enums import JobStatus, MessageStreamStatus, ProviderCategory, ProviderType, SandboxType, ToolSourceType
+from letta.schemas.enums import AgentType, JobStatus, MessageStreamStatus, ProviderCategory, ProviderType, SandboxType, ToolSourceType
 from letta.schemas.environment_variables import SandboxEnvironmentVariableCreate
 from letta.schemas.group import GroupCreate, ManagerType, SleeptimeManager, VoiceSleeptimeManager
 from letta.schemas.job import Job, JobUpdate

letta/services/agent_manager.py

@@ -50,15 +50,13 @@ from letta.otel.tracing import trace_method
 from letta.prompts.prompt_generator import PromptGenerator
 from letta.schemas.agent import (
     AgentState as PydanticAgentState,
-    AgentType,
     CreateAgent,
     InternalTemplateAgentCreate,
     UpdateAgent,
-    get_prompt_template_for_agent_type,
 )
 from letta.schemas.block import DEFAULT_BLOCKS, Block as PydanticBlock, BlockUpdate
 from letta.schemas.embedding_config import EmbeddingConfig
-from letta.schemas.enums import ProviderType, TagMatchMode, ToolType, VectorDBProvider
+from letta.schemas.enums import AgentType, ProviderType, TagMatchMode, ToolType, VectorDBProvider
 from letta.schemas.file import FileMetadata as PydanticFileMetadata
 from letta.schemas.group import Group as PydanticGroup, ManagerType
 from letta.schemas.llm_config import LLMConfig
@@ -455,7 +453,8 @@ class AgentManager:
                     [{"agent_id": aid, "identity_id": iid} for iid in identity_ids],
                 )
 
-                if agent_create.tool_exec_environment_variables:
+                agent_secrets = agent_create.secrets or agent_create.tool_exec_environment_variables
+                if agent_secrets:
                     env_rows = [
                         {
                             "agent_id": aid,
@@ -463,7 +462,7 @@ class AgentManager:
                             "value": val,
                             "organization_id": actor.organization_id,
                         }
-                        for key, val in agent_create.tool_exec_environment_variables.items()
+                        for key, val in agent_secrets.items()
                     ]
                     session.execute(insert(AgentEnvironmentVariable).values(env_rows))
 
@@ -674,7 +673,8 @@ class AgentManager:
                 )
 
                 env_rows = []
-                if agent_create.tool_exec_environment_variables:
+                agent_secrets = agent_create.secrets or agent_create.tool_exec_environment_variables
+                if agent_secrets:
                     env_rows = [
                         {
                             "agent_id": aid,
@@ -682,7 +682,7 @@ class AgentManager:
                             "value": val,
                             "organization_id": actor.organization_id,
                         }
-                        for key, val in agent_create.tool_exec_environment_variables.items()
+                        for key, val in agent_secrets.items()
                     ]
                     result = await session.execute(insert(AgentEnvironmentVariable).values(env_rows).returning(AgentEnvironmentVariable.id))
                     env_rows = [{**row, "id": env_var_id} for row, env_var_id in zip(env_rows, result.scalars().all())]
@@ -701,8 +701,9 @@ class AgentManager:
 
                 result = await new_agent.to_pydantic_async(include_relationships=include_relationships)
 
-                if agent_create.tool_exec_environment_variables and env_rows:
+                if agent_secrets and env_rows:
                     result.tool_exec_environment_variables = [AgentEnvironmentVariable(**row) for row in env_rows]
+                    result.secrets = [AgentEnvironmentVariable(**row) for row in env_rows]
 
                 # initial message sequence (skip if _init_with_no_messages is True)
                 if not _init_with_no_messages:
@@ -894,7 +895,8 @@ class AgentManager:
                 )
                 session.expire(agent, ["tags"])
 
-            if agent_update.tool_exec_environment_variables is not None:
+            agent_secrets = agent_update.secrets or agent_update.tool_exec_environment_variables
+            if agent_secrets is not None:
                 session.execute(delete(AgentEnvironmentVariable).where(AgentEnvironmentVariable.agent_id == aid))
                 env_rows = [
                     {
@@ -903,7 +905,7 @@ class AgentManager:
                         "value": v,
                         "organization_id": agent.organization_id,
                     }
-                    for k, v in agent_update.tool_exec_environment_variables.items()
+                    for k, v in agent_secrets.items()
                 ]
                 if env_rows:
                     self._bulk_insert_pivot(session, AgentEnvironmentVariable.__table__, env_rows)
@@ -1019,7 +1021,8 @@ class AgentManager:
                 )
                 session.expire(agent, ["tags"])
 
-            if agent_update.tool_exec_environment_variables is not None:
+            agent_secrets = agent_update.secrets or agent_update.tool_exec_environment_variables
+            if agent_secrets is not None:
                 await session.execute(delete(AgentEnvironmentVariable).where(AgentEnvironmentVariable.agent_id == aid))
                 env_rows = [
                     {
@@ -1028,7 +1031,7 @@ class AgentManager:
                         "value": v,
                         "organization_id": agent.organization_id,
                     }
-                    for k, v in agent_update.tool_exec_environment_variables.items()
+                    for k, v in agent_secrets.items()
                 ]
                 if env_rows:
                     await self._bulk_insert_pivot_async(session, AgentEnvironmentVariable.__table__, env_rows)
@@ -1544,6 +1547,8 @@ class AgentManager:
             if env_vars:
                 for var in agent.tool_exec_environment_variables:
                     var.value = env_vars.get(var.key, "")
+                for var in agent.secrets:
+                    var.value = env_vars.get(var.key, "")
 
             agent = agent.create(session, actor=actor)
 
@@ -1627,6 +1632,7 @@ class AgentManager:
             # Remove stale variables
             stale_keys = set(existing_vars) - set(env_vars)
             agent.tool_exec_environment_variables = [var for var in updated_vars if var.key not in stale_keys]
+            agent.secrets = [var for var in updated_vars if var.key not in stale_keys]
 
             # Update the agent in the database
             agent.update(session, actor=actor)
@@ -1786,7 +1792,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_in_thread_async(
+        curr_memory_str = agent_state.memory.compile(
             sources=agent_state.sources,
             tool_usage_rules=tool_rules_solver.compile_tool_rule_prompts(),
             max_files_open=agent_state.max_files_open,
@@ -1976,7 +1982,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_in_thread_async(
+        new_memory_str = new_memory.compile(
             sources=agent_state.sources,
             tool_usage_rules=temp_tool_rules_solver.compile_tool_rule_prompts(),
             max_files_open=agent_state.max_files_open,
@@ -2000,7 +2006,7 @@ class AgentManager:
             agent_state.memory = Memory(
                 blocks=blocks,
                 file_blocks=agent_state.memory.file_blocks,
-                prompt_template=get_prompt_template_for_agent_type(agent_state.agent_type),
+                agent_type=agent_state.agent_type,
             )
 
             # NOTE: don't do this since re-buildin the memory is handled at the start of the step

letta/services/agent_serialization_manager.py

@@ -209,8 +209,10 @@ class AgentSerializationManager:
         agent_schema.id = agent_file_id
 
         # wipe the values of tool_exec_environment_variables (they contain secrets)
-        if agent_schema.tool_exec_environment_variables:
-            agent_schema.tool_exec_environment_variables = {key: "" for key in agent_schema.tool_exec_environment_variables}
+        agent_secrets = agent_schema.secrets or agent_schema.tool_exec_environment_variables
+        if agent_secrets:
+            agent_schema.tool_exec_environment_variables = {key: "" for key in agent_secrets}
+            agent_schema.secrets = {key: "" for key in agent_secrets}
 
         if agent_schema.messages:
             for message in agent_schema.messages:
@@ -655,10 +657,16 @@ class AgentSerializationManager:
                 if agent_data.get("source_ids"):
                     agent_data["source_ids"] = [file_to_db_ids[file_id] for file_id in agent_data["source_ids"]]
 
-                if env_vars and agent_data.get("tool_exec_environment_variables"):
+                if env_vars and agent_data.get("secrets"):
                     # update environment variable values from the provided env_vars dict
+                    for key in agent_data["secrets"]:
+                        agent_data["secrets"][key] = env_vars.get(key, "")
+                        agent_data["tool_exec_environment_variables"][key] = env_vars.get(key, "")
+                elif env_vars and agent_data.get("tool_exec_environment_variables"):
+                    # also handle tool_exec_environment_variables for backwards compatibility
                     for key in agent_data["tool_exec_environment_variables"]:
                         agent_data["tool_exec_environment_variables"][key] = env_vars.get(key, "")
+                        agent_data["secrets"][key] = env_vars.get(key, "")
 
                 # Override project_id if provided
                 if project_id:

letta/services/archive_manager.py

@@ -87,6 +87,79 @@ class ArchiveManager:
             )
             return archive.to_pydantic()
 
+    @enforce_types
+    @trace_method
+    async def update_archive_async(
+        self,
+        archive_id: str,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        actor: PydanticUser = None,
+    ) -> PydanticArchive:
+        """Update archive name and/or description."""
+        async with db_registry.async_session() as session:
+            archive = await ArchiveModel.read_async(
+                db_session=session,
+                identifier=archive_id,
+                actor=actor,
+                check_is_deleted=True,
+            )
+
+            if name is not None:
+                archive.name = name
+            if description is not None:
+                archive.description = description
+
+            await archive.update_async(session, actor=actor)
+            return archive.to_pydantic()
+
+    @enforce_types
+    @trace_method
+    async def list_archives_async(
+        self,
+        *,
+        actor: PydanticUser,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: Optional[int] = 50,
+        ascending: bool = False,
+        name: Optional[str] = None,
+        agent_id: Optional[str] = None,
+    ) -> List[PydanticArchive]:
+        """List archives with pagination and optional filters.
+
+        Filters:
+        - name: exact match on name
+        - agent_id: only archives attached to given agent
+        """
+        filter_kwargs = {}
+        if name is not None:
+            filter_kwargs["name"] = name
+
+        join_model = None
+        join_conditions = None
+        if agent_id is not None:
+            join_model = ArchivesAgents
+            join_conditions = [
+                ArchivesAgents.archive_id == ArchiveModel.id,
+                ArchivesAgents.agent_id == agent_id,
+            ]
+
+        async with db_registry.async_session() as session:
+            archives = await ArchiveModel.list_async(
+                db_session=session,
+                before=before,
+                after=after,
+                limit=limit,
+                ascending=ascending,
+                actor=actor,
+                check_is_deleted=True,
+                join_model=join_model,
+                join_conditions=join_conditions,
+                **filter_kwargs,
+            )
+            return [a.to_pydantic() for a in archives]
+
     @enforce_types
     @trace_method
     def attach_agent_to_archive(

letta/services/helpers/agent_manager_helper.py

@@ -29,13 +29,12 @@ from letta.orm.errors import NoResultFound
 from letta.orm.identity import Identity
 from letta.orm.passage import ArchivalPassage, SourcePassage
 from letta.orm.sources_agents import SourcesAgents
-from letta.orm.sqlite_functions import adapt_array
 from letta.otel.tracing import trace_method
 from letta.prompts import gpt_system
 from letta.prompts.prompt_generator import PromptGenerator
-from letta.schemas.agent import AgentState, AgentType
+from letta.schemas.agent import AgentState
 from letta.schemas.embedding_config import EmbeddingConfig
-from letta.schemas.enums import MessageRole
+from letta.schemas.enums import AgentType, MessageRole
 from letta.schemas.letta_message_content import TextContent
 from letta.schemas.memory import Memory
 from letta.schemas.message import Message, MessageCreate
@@ -246,7 +245,7 @@ def compile_system_message(
     timezone: str,
     user_defined_variables: Optional[dict] = None,
     append_icm_if_missing: bool = True,
-    template_format: Literal["f-string", "mustache", "jinja2"] = "f-string",
+    template_format: Literal["f-string", "mustache"] = "f-string",
     previous_message_count: int = 0,
     archival_memory_size: int | None = 0,
     tool_rules_solver: Optional[ToolRulesSolver] = None,
@@ -312,7 +311,7 @@ def compile_system_message(
             raise ValueError(f"Failed to format system prompt - {str(e)}. System prompt value:\n{system_prompt}")
 
     else:
-        # TODO support for mustache and jinja2
+        # TODO support for mustache
         raise NotImplementedError(template_format)
 
     return formatted_prompt
@@ -921,6 +920,8 @@ async def build_passage_query(
             main_query = main_query.order_by(combined_query.c.embedding.cosine_distance(embedded_text).asc())
         else:
             # SQLite with custom vector type
+            from letta.orm.sqlite_functions import adapt_array
+
             query_embedding_binary = adapt_array(embedded_text)
             main_query = main_query.order_by(
                 func.cosine_distance(combined_query.c.embedding, query_embedding_binary).asc(),
@@ -1054,6 +1055,8 @@ async def build_source_passage_query(
             query = query.order_by(SourcePassage.embedding.cosine_distance(embedded_text).asc())
         else:
             # SQLite with custom vector type
+            from letta.orm.sqlite_functions import adapt_array
+
             query_embedding_binary = adapt_array(embedded_text)
             query = query.order_by(
                 func.cosine_distance(SourcePassage.embedding, query_embedding_binary).asc(),
@@ -1151,6 +1154,8 @@ async def build_agent_passage_query(
             query = query.order_by(ArchivalPassage.embedding.cosine_distance(embedded_text).asc())
         else:
             # SQLite with custom vector type
+            from letta.orm.sqlite_functions import adapt_array
+
             query_embedding_binary = adapt_array(embedded_text)
             query = query.order_by(
                 func.cosine_distance(ArchivalPassage.embedding, query_embedding_binary).asc(),