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

letta/services/source_manager.py

@@ -1,7 +1,7 @@
 import asyncio
 from typing import List, Optional
 
-from sqlalchemy import select
+from sqlalchemy import and_, exists, select
 
 from letta.orm import Agent as AgentModel
 from letta.orm.errors import NoResultFound
@@ -19,6 +19,30 @@ from letta.utils import enforce_types, printd
 class SourceManager:
     """Manager class to handle business logic related to Sources."""
 
+    @trace_method
+    async def _validate_source_exists_async(self, session, source_id: str, actor: PydanticUser) -> None:
+        """
+        Validate that a source exists and user has access to it using raw SQL for efficiency.
+
+        Args:
+            session: Database session
+            source_id: ID of the source to validate
+            actor: User performing the action
+
+        Raises:
+            NoResultFound: If source doesn't exist or user doesn't have access
+        """
+        source_exists_query = select(
+            exists().where(
+                and_(SourceModel.id == source_id, SourceModel.organization_id == actor.organization_id, SourceModel.is_deleted == False)
+            )
+        )
+
+        result = await session.execute(source_exists_query)
+
+        if not result.scalar():
+            raise NoResultFound(f"Source with ID {source_id} not found")
+
     @enforce_types
     @trace_method
     async def create_source(self, source: PydanticSource, actor: PydanticUser) -> PydanticSource:
@@ -93,20 +117,20 @@ class SourceManager:
 
     @enforce_types
     @trace_method
-    async def list_attached_agents(self, source_id: str, actor: Optional[PydanticUser] = None) -> List[PydanticAgentState]:
+    async def list_attached_agents(self, source_id: str, actor: PydanticUser) -> List[PydanticAgentState]:
         """
         Lists all agents that have the specified source attached.
 
         Args:
             source_id: ID of the source to find attached agents for
-            actor: User performing the action (optional for now, following existing pattern)
+            actor: User performing the action
 
         Returns:
             List[PydanticAgentState]: List of agents that have this source attached
         """
         async with db_registry.async_session() as session:
             # Verify source exists and user has permission to access it
-            source = await SourceModel.read_async(db_session=session, identifier=source_id, actor=actor)
+            await self._validate_source_exists_async(session, source_id, actor)
 
             # Use junction table query instead of relationship to avoid performance issues
             query = (
@@ -114,7 +138,7 @@ class SourceManager:
                 .join(SourcesAgents, AgentModel.id == SourcesAgents.agent_id)
                 .where(
                     SourcesAgents.source_id == source_id,
-                    AgentModel.organization_id == actor.organization_id if actor else True,
+                    AgentModel.organization_id == actor.organization_id,
                     AgentModel.is_deleted == False,
                 )
                 .order_by(AgentModel.created_at.desc(), AgentModel.id)
@@ -125,6 +149,31 @@ class SourceManager:
 
             return await asyncio.gather(*[agent.to_pydantic_async() for agent in agents_orm])
 
+    @enforce_types
+    @trace_method
+    async def get_agents_for_source_id(self, source_id: str, actor: PydanticUser) -> List[str]:
+        """
+        Get all agent IDs associated with a given source ID.
+
+        Args:
+            source_id: ID of the source to find agents for
+            actor: User performing the action
+
+        Returns:
+            List[str]: List of agent IDs that have this source attached
+        """
+        async with db_registry.async_session() as session:
+            # Verify source exists and user has permission to access it
+            await self._validate_source_exists_async(session, source_id, actor)
+
+            # Query the junction table directly for performance
+            query = select(SourcesAgents.agent_id).where(SourcesAgents.source_id == source_id)
+
+            result = await session.execute(query)
+            agent_ids = result.scalars().all()
+
+            return list(agent_ids)
+
     # TODO: We make actor optional for now, but should most likely be enforced due to security reasons
     @enforce_types
     @trace_method
@@ -152,3 +201,63 @@ class SourceManager:
                 return None
             else:
                 return sources[0].to_pydantic()
+
+    @enforce_types
+    @trace_method
+    async def get_sources_by_ids_async(self, source_ids: List[str], actor: PydanticUser) -> List[PydanticSource]:
+        """
+        Get multiple sources by their IDs in a single query.
+
+        Args:
+            source_ids: List of source IDs to retrieve
+            actor: User performing the action
+
+        Returns:
+            List[PydanticSource]: List of sources (may be fewer than requested if some don't exist)
+        """
+        if not source_ids:
+            return []
+
+        async with db_registry.async_session() as session:
+            query = select(SourceModel).where(
+                SourceModel.id.in_(source_ids), SourceModel.organization_id == actor.organization_id, SourceModel.is_deleted == False
+            )
+
+            result = await session.execute(query)
+            sources_orm = result.scalars().all()
+
+            return [source.to_pydantic() for source in sources_orm]
+
+    @enforce_types
+    @trace_method
+    async def get_sources_for_agents_async(self, agent_ids: List[str], actor: PydanticUser) -> List[PydanticSource]:
+        """
+        Get all sources associated with the given agents via sources-agents relationships.
+
+        Args:
+            agent_ids: List of agent IDs to find sources for
+            actor: User performing the action
+
+        Returns:
+            List[PydanticSource]: List of unique sources associated with these agents
+        """
+        if not agent_ids:
+            return []
+
+        async with db_registry.async_session() as session:
+            # Join through sources-agents junction table
+            query = (
+                select(SourceModel)
+                .join(SourcesAgents, SourceModel.id == SourcesAgents.source_id)
+                .where(
+                    SourcesAgents.agent_id.in_(agent_ids),
+                    SourceModel.organization_id == actor.organization_id,
+                    SourceModel.is_deleted == False,
+                )
+                .distinct()  # Ensure we don't get duplicate sources
+            )
+
+            result = await session.execute(query)
+            sources_orm = result.scalars().all()
+
+            return [source.to_pydantic() for source in sources_orm]

letta/services/step_manager.py

@@ -12,6 +12,7 @@ from letta.orm.job import Job as JobModel
 from letta.orm.sqlalchemy_base import AccessType
 from letta.orm.step import Step as StepModel
 from letta.otel.tracing import get_trace_id, trace_method
+from letta.schemas.letta_stop_reason import LettaStopReason, StopReasonType
 from letta.schemas.openai.chat_completion_response import UsageStatistics
 from letta.schemas.step import Step as PydanticStep
 from letta.schemas.user import User as PydanticUser
@@ -131,6 +132,7 @@ class StepManager:
         job_id: Optional[str] = None,
         step_id: Optional[str] = None,
         project_id: Optional[str] = None,
+        stop_reason: Optional[LettaStopReason] = None,
     ) -> PydanticStep:
         step_data = {
             "origin": None,
@@ -153,12 +155,14 @@ class StepManager:
         }
         if step_id:
             step_data["id"] = step_id
+        if stop_reason:
+            step_data["stop_reason"] = stop_reason.stop_reason
         async with db_registry.async_session() as session:
-            if job_id:
-                await self._verify_job_access_async(session, job_id, actor, access=["write"])
             new_step = StepModel(**step_data)
-            await new_step.create_async(session)
-            return new_step.to_pydantic()
+            await new_step.create_async(session, no_commit=True, no_refresh=True)
+            pydantic_step = new_step.to_pydantic()
+            await session.commit()
+            return pydantic_step
 
     @enforce_types
     @trace_method
@@ -205,6 +209,33 @@ class StepManager:
             await session.commit()
             return step.to_pydantic()
 
+    @enforce_types
+    @trace_method
+    async def update_step_stop_reason(self, actor: PydanticUser, step_id: str, stop_reason: StopReasonType) -> PydanticStep:
+        """Update the stop reason for a step.
+
+        Args:
+            actor: The user making the request
+            step_id: The ID of the step to update
+            stop_reason: The stop reason to set
+
+        Returns:
+            The updated step
+
+        Raises:
+            NoResultFound: If the step does not exist
+        """
+        async with db_registry.async_session() as session:
+            step = await session.get(StepModel, step_id)
+            if not step:
+                raise NoResultFound(f"Step with id {step_id} does not exist")
+            if step.organization_id != actor.organization_id:
+                raise Exception("Unauthorized")
+
+            step.stop_reason = stop_reason
+            await session.commit()
+            return step
+
     def _verify_job_access(
         self,
         session: Session,
@@ -307,5 +338,6 @@ class NoopStepManager(StepManager):
         job_id: Optional[str] = None,
         step_id: Optional[str] = None,
         project_id: Optional[str] = None,
+        stop_reason: Optional[LettaStopReason] = None,
     ) -> PydanticStep:
         return

letta/services/telemetry_manager.py

@@ -1,6 +1,7 @@
 from letta.helpers.json_helpers import json_dumps, json_loads
 from letta.helpers.singleton import singleton
 from letta.orm.provider_trace import ProviderTrace as ProviderTraceModel
+from letta.otel.tracing import trace_method
 from letta.schemas.provider_trace import ProviderTrace as PydanticProviderTrace
 from letta.schemas.provider_trace import ProviderTraceCreate
 from letta.schemas.step import Step as PydanticStep
@@ -10,7 +11,9 @@ from letta.utils import enforce_types
 
 
 class TelemetryManager:
+
     @enforce_types
+    @trace_method
     async def get_provider_trace_by_step_id_async(
         self,
         step_id: str,
@@ -21,6 +24,7 @@ class TelemetryManager:
             return provider_trace.to_pydantic()
 
     @enforce_types
+    @trace_method
     async def create_provider_trace_async(self, actor: PydanticUser, provider_trace_create: ProviderTraceCreate) -> PydanticProviderTrace:
         async with db_registry.async_session() as session:
             provider_trace = ProviderTraceModel(**provider_trace_create.model_dump())
@@ -31,10 +35,13 @@ class TelemetryManager:
             if provider_trace_create.response_json:
                 response_json_str = json_dumps(provider_trace_create.response_json)
                 provider_trace.response_json = json_loads(response_json_str)
-            await provider_trace.create_async(session, actor=actor)
-            return provider_trace.to_pydantic()
+            await provider_trace.create_async(session, actor=actor, no_commit=True, no_refresh=True)
+            pydantic_provider_trace = provider_trace.to_pydantic()
+            await session.commit()
+            return pydantic_provider_trace
 
     @enforce_types
+    @trace_method
     def create_provider_trace(self, actor: PydanticUser, provider_trace_create: ProviderTraceCreate) -> PydanticProviderTrace:
         with db_registry.session() as session:
             provider_trace = ProviderTraceModel(**provider_trace_create.model_dump())

letta/services/tool_executor/builtin_tool_executor.py

@@ -1,10 +1,12 @@
 import asyncio
 import json
+import os
 import time
 from typing import Any, Dict, List, Literal, Optional
 
 from pydantic import BaseModel
 
+from letta.constants import WEB_SEARCH_MODEL_ENV_VAR_DEFAULT_VALUE, WEB_SEARCH_MODEL_ENV_VAR_NAME
 from letta.functions.prompts import FIRECRAWL_SEARCH_SYSTEM_PROMPT, get_firecrawl_search_user_prompt
 from letta.functions.types import SearchTask
 from letta.log import get_logger
@@ -322,8 +324,10 @@ class LettaBuiltinToolExecutor(ToolExecutor):
         # Time the OpenAI request
         start_time = time.time()
 
+        model = os.getenv(WEB_SEARCH_MODEL_ENV_VAR_NAME, WEB_SEARCH_MODEL_ENV_VAR_DEFAULT_VALUE)
+        logger.info(f"Using model {model} for web search result parsing")
         response = await client.beta.chat.completions.parse(
-            model="gpt-4.1-mini-2025-04-14",
+            model=model,
             messages=[{"role": "system", "content": FIRECRAWL_SEARCH_SYSTEM_PROMPT}, {"role": "user", "content": user_prompt}],
             response_format=DocumentAnalysis,
             temperature=0.1,

letta/services/tool_executor/core_tool_executor.py

@@ -96,7 +96,7 @@ class LettaCoreToolExecutor(ToolExecutor):
         try:
             page = int(page)
         except:
-            raise ValueError(f"'page' argument must be an integer")
+            raise ValueError("'page' argument must be an integer")
 
         count = RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
         messages = await MessageManager().list_user_messages_for_agent_async(
@@ -110,7 +110,7 @@ class LettaCoreToolExecutor(ToolExecutor):
         num_pages = math.ceil(total / count) - 1  # 0 index
 
         if len(messages) == 0:
-            results_str = f"No results found."
+            results_str = "No results found."
         else:
             results_pref = f"Showing {len(messages)} of {total} results (page {page}/{num_pages}):"
             results_formatted = [message.content[0].text for message in messages]
@@ -137,7 +137,7 @@ class LettaCoreToolExecutor(ToolExecutor):
         try:
             page = int(page)
         except:
-            raise ValueError(f"'page' argument must be an integer")
+            raise ValueError("'page' argument must be an integer")
 
         count = RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE
 

letta/services/tool_manager.py

@@ -1,5 +1,5 @@
-import asyncio
 import importlib
+import os
 import warnings
 from typing import List, Optional, Set, Union
 
@@ -14,6 +14,7 @@ from letta.constants import (
     FILES_TOOLS,
     LETTA_TOOL_MODULE_NAMES,
     LETTA_TOOL_SET,
+    LOCAL_ONLY_MULTI_AGENT_TOOLS,
     MCP_TOOL_TAG_NAME_PREFIX,
 )
 from letta.functions.functions import derive_openai_json_schema, load_function_set
@@ -30,6 +31,7 @@ from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry
 from letta.services.helpers.agent_manager_helper import calculate_multi_agent_tools
 from letta.services.mcp.types import SSEServerConfig, StdioServerConfig
+from letta.settings import settings
 from letta.utils import enforce_types, printd
 
 logger = get_logger(__name__)
@@ -74,6 +76,7 @@ class ToolManager:
         if tool_id:
             # Put to dict and remove fields that should not be reset
             update_data = pydantic_tool.model_dump(exclude_unset=True, exclude_none=True)
+            update_data["organization_id"] = actor.organization_id
 
             # If there's anything to update
             if update_data:
@@ -146,12 +149,12 @@ class ToolManager:
     def create_tool(self, pydantic_tool: PydanticTool, actor: PydanticUser) -> PydanticTool:
         """Create a new tool based on the ToolCreate schema."""
         with db_registry.session() as session:
-            # Set the organization id at the ORM layer
-            pydantic_tool.organization_id = actor.organization_id
             # Auto-generate description if not provided
             if pydantic_tool.description is None:
                 pydantic_tool.description = pydantic_tool.json_schema.get("description", None)
             tool_data = pydantic_tool.model_dump(to_orm=True)
+            # Set the organization id at the ORM layer
+            tool_data["organization_id"] = actor.organization_id
 
             tool = ToolModel(**tool_data)
             tool.create(session, actor=actor)  # Re-raise other database-related errors
@@ -162,12 +165,12 @@ class ToolManager:
     async def create_tool_async(self, pydantic_tool: PydanticTool, actor: PydanticUser) -> PydanticTool:
         """Create a new tool based on the ToolCreate schema."""
         async with db_registry.async_session() as session:
-            # Set the organization id at the ORM layer
-            pydantic_tool.organization_id = actor.organization_id
             # Auto-generate description if not provided
             if pydantic_tool.description is None:
                 pydantic_tool.description = pydantic_tool.json_schema.get("description", None)
             tool_data = pydantic_tool.model_dump(to_orm=True)
+            # Set the organization id at the ORM layer
+            tool_data["organization_id"] = actor.organization_id
 
             tool = ToolModel(**tool_data)
             await tool.create_async(session, actor=actor)  # Re-raise other database-related errors
@@ -250,7 +253,10 @@ class ToolManager:
         # TODO: This requires a deeper rethink about how we keep all our internal tools up-to-date
         if not after and upsert_base_tools:
             existing_tool_names = {tool.name for tool in tools}
-            missing_base_tools = LETTA_TOOL_SET - existing_tool_names
+            base_tool_names = (
+                LETTA_TOOL_SET - set(LOCAL_ONLY_MULTI_AGENT_TOOLS) if os.getenv("LETTA_ENVIRONMENT") == "PRODUCTION" else LETTA_TOOL_SET
+            )
+            missing_base_tools = base_tool_names - existing_tool_names
 
             # If any base tools are missing, upsert all base tools
             if missing_base_tools:
@@ -462,7 +468,10 @@ class ToolManager:
         actor: PydanticUser,
         allowed_types: Optional[Set[ToolType]] = None,
     ) -> List[PydanticTool]:
-        """Add default tools defined in the various function_sets modules, optionally filtered by ToolType."""
+        """Add default tools defined in the various function_sets modules, optionally filtered by ToolType.
+
+        Optimized bulk implementation using single database session and batch operations.
+        """
 
         functions_to_schema = {}
         for module_name in LETTA_TOOL_MODULE_NAMES:
@@ -474,7 +483,8 @@ class ToolManager:
             except Exception as e:
                 raise e
 
-        tools = []
+        # prepare tool data for bulk operations
+        tool_data_list = []
         for name, schema in functions_to_schema.items():
             if name not in LETTA_TOOL_SET:
                 continue
@@ -500,17 +510,82 @@ class ToolManager:
             if allowed_types is not None and tool_type not in allowed_types:
                 continue
 
-            tools.append(
-                self.create_or_update_tool_async(
-                    PydanticTool(
-                        name=name,
-                        tags=[tool_type.value],
-                        source_type="python",
-                        tool_type=tool_type,
-                        return_char_limit=BASE_FUNCTION_RETURN_CHAR_LIMIT,
-                    ),
-                    actor=actor,
-                )
+            # create pydantic tool for validation and conversion
+            pydantic_tool = PydanticTool(
+                name=name,
+                tags=[tool_type.value],
+                source_type="python",
+                tool_type=tool_type,
+                return_char_limit=BASE_FUNCTION_RETURN_CHAR_LIMIT,
             )
 
-        return await asyncio.gather(*tools)
+            # auto-generate description if not provided
+            if pydantic_tool.description is None:
+                pydantic_tool.description = pydantic_tool.json_schema.get("description", None)
+
+            tool_data_list.append(pydantic_tool)
+
+        if not tool_data_list:
+            return []
+
+        if settings.letta_pg_uri_no_default:
+            async with db_registry.async_session() as session:
+                return await self._bulk_upsert_postgresql(session, tool_data_list, actor)
+        else:
+            return await self._upsert_tools_individually(tool_data_list, actor)
+
+    @trace_method
+    async def _bulk_upsert_postgresql(self, session, tool_data_list: List[PydanticTool], actor: PydanticUser) -> List[PydanticTool]:
+        """hyper-optimized postgresql bulk upsert using on_conflict_do_update."""
+        from sqlalchemy import func, select
+        from sqlalchemy.dialects.postgresql import insert
+
+        # prepare data for bulk insert
+        table = ToolModel.__table__
+        valid_columns = {col.name for col in table.columns}
+
+        insert_data = []
+        for tool in tool_data_list:
+            tool_dict = tool.model_dump(to_orm=True)
+            # set created/updated by fields
+            if actor:
+                tool_dict["_created_by_id"] = actor.id
+                tool_dict["_last_updated_by_id"] = actor.id
+                tool_dict["organization_id"] = actor.organization_id
+
+            # filter to only include columns that exist in the table
+            filtered_dict = {k: v for k, v in tool_dict.items() if k in valid_columns}
+            insert_data.append(filtered_dict)
+
+        # use postgresql's native bulk upsert
+        stmt = insert(table).values(insert_data)
+
+        # on conflict, update all columns except id, created_at, and _created_by_id
+        excluded = stmt.excluded
+        update_dict = {}
+        for col in table.columns:
+            if col.name not in ("id", "created_at", "_created_by_id"):
+                if col.name == "updated_at":
+                    update_dict[col.name] = func.now()
+                else:
+                    update_dict[col.name] = excluded[col.name]
+
+        upsert_stmt = stmt.on_conflict_do_update(index_elements=["name", "organization_id"], set_=update_dict)
+
+        await session.execute(upsert_stmt)
+        await session.commit()
+
+        # fetch results
+        tool_names = [tool.name for tool in tool_data_list]
+        result_query = select(ToolModel).where(ToolModel.name.in_(tool_names), ToolModel.organization_id == actor.organization_id)
+        result = await session.execute(result_query)
+        return [tool.to_pydantic() for tool in result.scalars()]
+
+    @trace_method
+    async def _upsert_tools_individually(self, tool_data_list: List[PydanticTool], actor: PydanticUser) -> List[PydanticTool]:
+        """fallback to individual upserts for sqlite (original approach)."""
+        tools = []
+        for tool in tool_data_list:
+            upserted_tool = await self.create_or_update_tool_async(tool, actor)
+            tools.append(upserted_tool)
+        return tools

letta/services/user_manager.py

@@ -1,6 +1,6 @@
 from typing import List, Optional
 
-from sqlalchemy import select, text
+from sqlalchemy import select
 
 from letta.constants import DEFAULT_ORG_ID
 from letta.data_sources.redis_client import get_redis_client
@@ -8,7 +8,6 @@ from letta.helpers.decorators import async_redis_cache
 from letta.log import get_logger
 from letta.orm.errors import NoResultFound
 from letta.orm.organization import Organization as OrganizationModel
-from letta.orm.sqlalchemy_base import is_postgresql_session
 from letta.orm.user import User as UserModel
 from letta.otel.tracing import trace_method
 from letta.schemas.user import User as PydanticUser
@@ -157,16 +156,9 @@ class UserManager:
     async def get_actor_by_id_async(self, actor_id: str) -> PydanticUser:
         """Fetch a user by ID asynchronously."""
         async with db_registry.async_session() as session:
-            # Turn off seqscan to force use pk index
-            if is_postgresql_session(session):
-                await session.execute(text("SET LOCAL enable_seqscan = OFF"))
-            try:
-                stmt = select(UserModel).where(UserModel.id == actor_id)
-                result = await session.execute(stmt)
-                user = result.scalar_one_or_none()
-            finally:
-                if is_postgresql_session(session):
-                    await session.execute(text("SET LOCAL enable_seqscan = ON"))
+            stmt = select(UserModel).where(UserModel.id == actor_id)
+            result = await session.execute(stmt)
+            user = result.scalar_one_or_none()
 
             if not user:
                 raise NoResultFound(f"User not found with id={actor_id}")

letta/settings.py

@@ -1,4 +1,5 @@
 import os
+from enum import Enum
 from pathlib import Path
 from typing import Optional
 
@@ -182,6 +183,11 @@ if "--use-file-pg-uri" in sys.argv:
         pass
 
 
+class DatabaseChoice(str, Enum):
+    POSTGRES = "postgres"
+    SQLITE = "sqlite"
+
+
 class Settings(BaseSettings):
     model_config = SettingsConfigDict(env_prefix="letta_", extra="ignore")
 
@@ -220,21 +226,24 @@ class Settings(BaseSettings):
     multi_agent_concurrent_sends: int = 50
 
     # telemetry logging
-    otel_exporter_otlp_endpoint: Optional[str] = None  # otel default: "http://localhost:4317"
-    otel_preferred_temporality: Optional[int] = Field(
+    otel_exporter_otlp_endpoint: str | None = None  # otel default: "http://localhost:4317"
+    otel_preferred_temporality: int | None = Field(
         default=1, ge=0, le=2, description="Exported metric temporality. {0: UNSPECIFIED, 1: DELTA, 2: CUMULATIVE}"
     )
     disable_tracing: bool = Field(default=False, description="Disable OTEL Tracing")
     llm_api_logging: bool = Field(default=True, description="Enable LLM API logging at each step")
     track_last_agent_run: bool = Field(default=False, description="Update last agent run metrics")
+    track_errored_messages: bool = Field(default=True, description="Enable tracking for errored messages")
+    track_stop_reason: bool = Field(default=True, description="Enable tracking stop reason on steps.")
+    track_agent_run: bool = Field(default=True, description="Enable tracking agent run with cancellation support")
 
-    # uvicorn settings
+    # FastAPI Application Settings
     uvicorn_workers: int = 1
     uvicorn_reload: bool = False
     uvicorn_timeout_keep_alive: int = 5
 
-    use_uvloop: bool = False
-    use_granian: bool = False
+    use_uvloop: bool = Field(default=True, description="Enable uvloop as asyncio event loop.")
+    use_granian: bool = Field(default=False, description="Use Granian for workers")
     sqlalchemy_tracing: bool = False
 
     # event loop parallelism
@@ -244,6 +253,10 @@ class Settings(BaseSettings):
     use_experimental: bool = False
     use_vertex_structured_outputs_experimental: bool = False
 
+    # Database pool monitoring
+    enable_db_pool_monitoring: bool = True  # Enable connection pool monitoring
+    db_pool_monitoring_interval: int = 30  # Seconds between pool stats collection
+
     # cron job parameters
     enable_batch_job_polling: bool = False
     poll_running_llm_batches_interval_seconds: int = 5 * 60
@@ -272,7 +285,7 @@ class Settings(BaseSettings):
         elif self.pg_db and self.pg_user and self.pg_password and self.pg_host and self.pg_port:
             return f"postgresql+pg8000://{self.pg_user}:{self.pg_password}@{self.pg_host}:{self.pg_port}/{self.pg_db}"
         else:
-            return f"postgresql+pg8000://letta:letta@localhost:5432/letta"
+            return "postgresql+pg8000://letta:letta@localhost:5432/letta"
 
     # add this property to avoid being returned the default
     # reference: https://github.com/letta-ai/letta/issues/1362
@@ -285,6 +298,10 @@ class Settings(BaseSettings):
         else:
             return None
 
+    @property
+    def database_engine(self) -> DatabaseChoice:
+        return DatabaseChoice.POSTGRES if self.letta_pg_uri_no_default else DatabaseChoice.SQLITE
+
     @property
     def plugin_register_dict(self) -> dict:
         plugins = {}

letta/system.py

@@ -66,7 +66,7 @@ def get_initial_boot_messages(version, timezone):
                         "type": "function",
                         "function": {
                             "name": "send_message",
-                            "arguments": '{\n  "message": "' + f"Hi, is anyone there?" + '"\n}',
+                            "arguments": '{\n  "message": "' + "Hi, is anyone there?" + '"\n}',
                         },
                     }
                 ],