letta-nightly 0.11.7.dev20251008104128__py3-none-any.whl → 0.12.0.dev20251009203644__py3-none-any.whl

letta/__init__.py

@@ -5,7 +5,7 @@ try:
     __version__ = version("letta")
 except PackageNotFoundError:
     # Fallback for development installations
-    __version__ = "0.11.7"
+    __version__ = "0.12.0"
 
 if os.environ.get("LETTA_VERSION"):
     __version__ = os.environ["LETTA_VERSION"]

letta/agents/letta_agent_v3.py

@@ -595,9 +595,30 @@ class LettaAgentV3(LettaAgentV2):
         # -1. no tool call, no content
         if tool_call is None and (content is None or len(content) == 0):
             # Edge case is when there's also no content - basically, the LLM "no-op'd"
-            # In this case, we actually do not want to persist the no-op message
-            continue_stepping, heartbeat_reason, stop_reason = False, None, LettaStopReason(stop_reason=StopReasonType.end_turn.value)
-            messages_to_persist = initial_messages or []
+            # If RequiredBeforeExitToolRule exists and not all required tools have been called,
+            # inject a rule-violation heartbeat to keep looping and inform the model.
+            uncalled = tool_rules_solver.get_uncalled_required_tools(available_tools=set([t.name for t in agent_state.tools]))
+            if uncalled:
+                # TODO: we may need to change this to not have a "heartbeat" prefix for v3?
+                heartbeat_reason = (
+                    f"{NON_USER_MSG_PREFIX}ToolRuleViolated: You must call {', '.join(uncalled)} at least once to exit the loop."
+                )
+                from letta.server.rest_api.utils import create_heartbeat_system_message
+
+                heartbeat_msg = create_heartbeat_system_message(
+                    agent_id=agent_state.id,
+                    model=agent_state.llm_config.model,
+                    function_call_success=True,
+                    timezone=agent_state.timezone,
+                    heartbeat_reason=heartbeat_reason,
+                    run_id=run_id,
+                )
+                messages_to_persist = (initial_messages or []) + [heartbeat_msg]
+                continue_stepping, stop_reason = True, None
+            else:
+                # In this case, we actually do not want to persist the no-op message
+                continue_stepping, heartbeat_reason, stop_reason = False, None, LettaStopReason(stop_reason=StopReasonType.end_turn.value)
+                messages_to_persist = initial_messages or []
 
         # 0. If there's no tool call, we can early exit
         elif tool_call is None:
@@ -627,7 +648,8 @@ class LettaAgentV3(LettaAgentV2):
                 run_id=run_id,
                 is_approval_response=is_approval or is_denial,
                 force_set_request_heartbeat=False,
-                add_heartbeat_on_continue=False,
+                # If we're continuing due to a required-before-exit rule, include a heartbeat to guide the model
+                add_heartbeat_on_continue=bool(heartbeat_reason),
             )
             messages_to_persist = (initial_messages or []) + assistant_message
 
@@ -843,7 +865,13 @@ class LettaAgentV3(LettaAgentV2):
         stop_reason: LettaStopReason | None = None
 
         if tool_call_name is None:
-            # No tool call? End loop
+            # No tool call – if there are required-before-exit tools uncalled, keep stepping
+            # and provide explicit feedback to the model; otherwise end the loop.
+            uncalled = tool_rules_solver.get_uncalled_required_tools(available_tools=set([t.name for t in agent_state.tools]))
+            if uncalled and not is_final_step:
+                reason = f"{NON_USER_MSG_PREFIX}ToolRuleViolated: You must call {', '.join(uncalled)} at least once to exit the loop."
+                return True, reason, None
+            # No required tools remaining → end turn
             return False, None, LettaStopReason(stop_reason=StopReasonType.end_turn.value)
         else:
             if tool_rule_violated:

letta/database_utils.py

@@ -0,0 +1,161 @@
+"""
+Database URI utilities for consistent database connection handling across the application.
+
+This module provides utilities for parsing and converting database URIs to ensure
+consistent behavior between the main application, alembic migrations, and other
+database-related components.
+"""
+
+from typing import Optional
+from urllib.parse import urlparse, urlunparse
+
+
+def parse_database_uri(uri: str) -> dict[str, Optional[str]]:
+    """
+    Parse a database URI into its components.
+
+    Args:
+        uri: Database URI (e.g., postgresql://user:pass@host:port/db)
+
+    Returns:
+        Dictionary with parsed components: scheme, driver, user, password, host, port, database
+    """
+    parsed = urlparse(uri)
+
+    # Extract driver from scheme (e.g., postgresql+asyncpg -> asyncpg)
+    scheme_parts = parsed.scheme.split("+")
+    base_scheme = scheme_parts[0] if scheme_parts else ""
+    driver = scheme_parts[1] if len(scheme_parts) > 1 else None
+
+    return {
+        "scheme": base_scheme,
+        "driver": driver,
+        "user": parsed.username,
+        "password": parsed.password,
+        "host": parsed.hostname,
+        "port": str(parsed.port) if parsed.port else None,
+        "database": parsed.path.lstrip("/") if parsed.path else None,
+        "query": parsed.query,
+        "fragment": parsed.fragment,
+    }
+
+
+def build_database_uri(
+    scheme: str = "postgresql",
+    driver: Optional[str] = None,
+    user: Optional[str] = None,
+    password: Optional[str] = None,
+    host: Optional[str] = None,
+    port: Optional[str] = None,
+    database: Optional[str] = None,
+    query: Optional[str] = None,
+    fragment: Optional[str] = None,
+) -> str:
+    """
+    Build a database URI from components.
+
+    Args:
+        scheme: Base scheme (e.g., "postgresql")
+        driver: Driver name (e.g., "asyncpg", "pg8000")
+        user: Username
+        password: Password
+        host: Hostname
+        port: Port number
+        database: Database name
+        query: Query string
+        fragment: Fragment
+
+    Returns:
+        Complete database URI
+    """
+    # Combine scheme and driver
+    full_scheme = f"{scheme}+{driver}" if driver else scheme
+
+    # Build netloc (user:password@host:port)
+    netloc_parts = []
+    if user:
+        if password:
+            netloc_parts.append(f"{user}:{password}")
+        else:
+            netloc_parts.append(user)
+
+    if host:
+        if port:
+            netloc_parts.append(f"{host}:{port}")
+        else:
+            netloc_parts.append(host)
+
+    netloc = "@".join(netloc_parts) if netloc_parts else ""
+
+    # Build path
+    path = f"/{database}" if database else ""
+
+    # Build the URI
+    return urlunparse((full_scheme, netloc, path, "", query or "", fragment or ""))
+
+
+def convert_to_async_uri(uri: str) -> str:
+    """
+    Convert a database URI to use the asyncpg driver for async operations.
+
+    Args:
+        uri: Original database URI
+
+    Returns:
+        URI with asyncpg driver and ssl parameter adjustments
+    """
+    components = parse_database_uri(uri)
+
+    # Convert to asyncpg driver
+    components["driver"] = "asyncpg"
+
+    # Build the new URI
+    new_uri = build_database_uri(**components)
+
+    # Replace sslmode= with ssl= for asyncpg compatibility
+    new_uri = new_uri.replace("sslmode=", "ssl=")
+
+    return new_uri
+
+
+def convert_to_sync_uri(uri: str) -> str:
+    """
+    Convert a database URI to use the pg8000 driver for sync operations (alembic).
+
+    Args:
+        uri: Original database URI
+
+    Returns:
+        URI with pg8000 driver and sslmode parameter adjustments
+    """
+    components = parse_database_uri(uri)
+
+    # Convert to pg8000 driver
+    components["driver"] = "pg8000"
+
+    # Build the new URI
+    new_uri = build_database_uri(**components)
+
+    # Replace ssl= with sslmode= for pg8000 compatibility
+    new_uri = new_uri.replace("ssl=", "sslmode=")
+
+    return new_uri
+
+
+def get_database_uri_for_context(uri: str, context: str = "async") -> str:
+    """
+    Get the appropriate database URI for a specific context.
+
+    Args:
+        uri: Original database URI
+        context: Context type ("async" for asyncpg, "sync" for pg8000, "alembic" for pg8000)
+
+    Returns:
+        URI formatted for the specified context
+    """
+    if context in ["async"]:
+        return convert_to_async_uri(uri)
+    elif context in ["sync", "alembic"]:
+        return convert_to_sync_uri(uri)
+    else:
+        raise ValueError(f"Unknown context: {context}. Must be 'async', 'sync', or 'alembic'")

letta/interfaces/anthropic_streaming_interface.py

@@ -279,9 +279,11 @@ class AnthropicStreamingInterface:
                     if prev_message_type and prev_message_type != "tool_call_message":
                         message_index += 1
                     if self.tool_call_name not in self.requires_approval_tools:
+                        tool_call_delta = ToolCallDelta(name=self.tool_call_name, tool_call_id=self.tool_call_id)
                         tool_call_msg = ToolCallMessage(
                             id=self.letta_message_id,
-                            tool_call=ToolCallDelta(name=self.tool_call_name, tool_call_id=self.tool_call_id),
+                            tool_call=tool_call_delta,
+                            tool_calls=tool_call_delta,
                             date=datetime.now(timezone.utc).isoformat(),
                             otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                             run_id=self.run_id,
@@ -423,15 +425,17 @@ class AnthropicStreamingInterface:
                             tool_call_args += buffered_msg.tool_call.arguments if buffered_msg.tool_call.arguments else ""
                         tool_call_args = tool_call_args.replace(f'"{INNER_THOUGHTS_KWARG}": "{current_inner_thoughts}"', "")
 
+                        tool_call_delta = ToolCallDelta(
+                            name=self.tool_call_name,
+                            tool_call_id=self.tool_call_id,
+                            arguments=tool_call_args,
+                        )
                         tool_call_msg = ToolCallMessage(
                             id=self.tool_call_buffer[0].id,
                             otid=Message.generate_otid_from_id(self.tool_call_buffer[0].id, message_index),
                             date=self.tool_call_buffer[0].date,
-                            tool_call=ToolCallDelta(
-                                name=self.tool_call_name,
-                                tool_call_id=self.tool_call_id,
-                                arguments=tool_call_args,
-                            ),
+                            tool_call=tool_call_delta,
+                            tool_calls=tool_call_delta,
                             run_id=self.run_id,
                         )
                         prev_message_type = tool_call_msg.message_type
@@ -467,9 +471,13 @@ class AnthropicStreamingInterface:
                             run_id=self.run_id,
                         )
                     else:
+                        tool_call_delta = ToolCallDelta(
+                            name=self.tool_call_name, tool_call_id=self.tool_call_id, arguments=delta.partial_json
+                        )
                         tool_call_msg = ToolCallMessage(
                             id=self.letta_message_id,
-                            tool_call=ToolCallDelta(name=self.tool_call_name, tool_call_id=self.tool_call_id, arguments=delta.partial_json),
+                            tool_call=tool_call_delta,
+                            tool_calls=tool_call_delta,
                             date=datetime.now(timezone.utc).isoformat(),
                             run_id=self.run_id,
                         )
@@ -778,9 +786,11 @@ class SimpleAnthropicStreamingInterface:
                 else:
                     if prev_message_type and prev_message_type != "tool_call_message":
                         message_index += 1
+                    tool_call_delta = ToolCallDelta(name=self.tool_call_name, tool_call_id=self.tool_call_id)
                     tool_call_msg = ToolCallMessage(
                         id=self.letta_message_id,
-                        tool_call=ToolCallDelta(name=self.tool_call_name, tool_call_id=self.tool_call_id),
+                        tool_call=tool_call_delta,
+                        tool_calls=tool_call_delta,
                         date=datetime.now(timezone.utc).isoformat(),
                         otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                         run_id=self.run_id,
@@ -860,9 +870,11 @@ class SimpleAnthropicStreamingInterface:
                 else:
                     if prev_message_type and prev_message_type != "tool_call_message":
                         message_index += 1
+                    tool_call_delta = ToolCallDelta(name=self.tool_call_name, tool_call_id=self.tool_call_id, arguments=delta.partial_json)
                     tool_call_msg = ToolCallMessage(
                         id=self.letta_message_id,
-                        tool_call=ToolCallDelta(name=self.tool_call_name, tool_call_id=self.tool_call_id, arguments=delta.partial_json),
+                        tool_call=tool_call_delta,
+                        tool_calls=tool_call_delta,
                         date=datetime.now(timezone.utc).isoformat(),
                         otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                         run_id=self.run_id,

letta/interfaces/gemini_streaming_interface.py

@@ -273,15 +273,17 @@ class SimpleGeminiStreamingInterface:
                 else:
                     if prev_message_type and prev_message_type != "tool_call_message":
                         message_index += 1
+                    tool_call_delta = ToolCallDelta(
+                        name=name,
+                        arguments=arguments_str,
+                        tool_call_id=call_id,
+                    )
                     yield ToolCallMessage(
                         id=self.letta_message_id,
                         otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                         date=datetime.now(timezone.utc),
-                        tool_call=ToolCallDelta(
-                            name=name,
-                            arguments=arguments_str,
-                            tool_call_id=call_id,
-                        ),
+                        tool_call=tool_call_delta,
+                        tool_calls=tool_call_delta,
                         run_id=self.run_id,
                         step_id=self.step_id,
                     )

letta/interfaces/openai_streaming_interface.py

@@ -336,14 +336,16 @@ class OpenAIStreamingInterface:
                                         step_id=self.step_id,
                                     )
                                 else:
+                                    tool_call_delta = ToolCallDelta(
+                                        name=self.function_name_buffer,
+                                        arguments=None,
+                                        tool_call_id=self.function_id_buffer,
+                                    )
                                     tool_call_msg = ToolCallMessage(
                                         id=self.letta_message_id,
                                         date=datetime.now(timezone.utc),
-                                        tool_call=ToolCallDelta(
-                                            name=self.function_name_buffer,
-                                            arguments=None,
-                                            tool_call_id=self.function_id_buffer,
-                                        ),
+                                        tool_call=tool_call_delta,
+                                        tool_calls=tool_call_delta,
                                         otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                                         run_id=self.run_id,
                                         step_id=self.step_id,
@@ -423,14 +425,16 @@ class OpenAIStreamingInterface:
                                             step_id=self.step_id,
                                         )
                                     else:
+                                        tool_call_delta = ToolCallDelta(
+                                            name=self.function_name_buffer,
+                                            arguments=combined_chunk,
+                                            tool_call_id=self.function_id_buffer,
+                                        )
                                         tool_call_msg = ToolCallMessage(
                                             id=self.letta_message_id,
                                             date=datetime.now(timezone.utc),
-                                            tool_call=ToolCallDelta(
-                                                name=self.function_name_buffer,
-                                                arguments=combined_chunk,
-                                                tool_call_id=self.function_id_buffer,
-                                            ),
+                                            tool_call=tool_call_delta,
+                                            tool_calls=tool_call_delta,
                                             # name=name,
                                             otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                                             run_id=self.run_id,
@@ -460,14 +464,16 @@ class OpenAIStreamingInterface:
                                             step_id=self.step_id,
                                         )
                                     else:
+                                        tool_call_delta = ToolCallDelta(
+                                            name=None,
+                                            arguments=updates_main_json,
+                                            tool_call_id=self.function_id_buffer,
+                                        )
                                         tool_call_msg = ToolCallMessage(
                                             id=self.letta_message_id,
                                             date=datetime.now(timezone.utc),
-                                            tool_call=ToolCallDelta(
-                                                name=None,
-                                                arguments=updates_main_json,
-                                                tool_call_id=self.function_id_buffer,
-                                            ),
+                                            tool_call=tool_call_delta,
+                                            tool_calls=tool_call_delta,
                                             # name=name,
                                             otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                                             run_id=self.run_id,
@@ -717,14 +723,16 @@ class SimpleOpenAIStreamingInterface:
                         step_id=self.step_id,
                     )
                 else:
+                    tool_call_delta = ToolCallDelta(
+                        name=tool_call.function.name,
+                        arguments=tool_call.function.arguments,
+                        tool_call_id=tool_call.id,
+                    )
                     tool_call_msg = ToolCallMessage(
                         id=self.letta_message_id,
                         date=datetime.now(timezone.utc),
-                        tool_call=ToolCallDelta(
-                            name=tool_call.function.name,
-                            arguments=tool_call.function.arguments,
-                            tool_call_id=tool_call.id,
-                        ),
+                        tool_call=tool_call_delta,
+                        tool_calls=tool_call_delta,
                         # name=name,
                         otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                         run_id=self.run_id,
@@ -945,15 +953,17 @@ class SimpleOpenAIResponsesStreamingInterface:
                 else:
                     if prev_message_type and prev_message_type != "tool_call_message":
                         message_index += 1
+                    tool_call_delta = ToolCallDelta(
+                        name=name,
+                        arguments=arguments if arguments != "" else None,
+                        tool_call_id=call_id,
+                    )
                     yield ToolCallMessage(
                         id=self.letta_message_id,
                         otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                         date=datetime.now(timezone.utc),
-                        tool_call=ToolCallDelta(
-                            name=name,
-                            arguments=arguments if arguments != "" else None,
-                            tool_call_id=call_id,
-                        ),
+                        tool_call=tool_call_delta,
+                        tool_calls=tool_call_delta,
                         run_id=self.run_id,
                         step_id=self.step_id,
                     )
@@ -1113,15 +1123,17 @@ class SimpleOpenAIResponsesStreamingInterface:
             else:
                 if prev_message_type and prev_message_type != "tool_call_message":
                     message_index += 1
+                tool_call_delta = ToolCallDelta(
+                    name=None,
+                    arguments=delta,
+                    tool_call_id=None,
+                )
                 yield ToolCallMessage(
                     id=self.letta_message_id,
                     otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
                     date=datetime.now(timezone.utc),
-                    tool_call=ToolCallDelta(
-                        name=None,
-                        arguments=delta,
-                        tool_call_id=None,
-                    ),
+                    tool_call=tool_call_delta,
+                    tool_calls=tool_call_delta,
                     run_id=self.run_id,
                     step_id=self.step_id,
                 )

letta/llm_api/anthropic_client.py

@@ -56,6 +56,9 @@ class AnthropicClient(LLMClientBase):
     def request(self, request_data: dict, llm_config: LLMConfig) -> dict:
         client = self._get_anthropic_client(llm_config, async_client=False)
         betas: list[str] = []
+        # Interleaved thinking for reasoner (sync path parity)
+        if llm_config.enable_reasoner:
+            betas.append("interleaved-thinking-2025-05-14")
         # 1M context beta for Sonnet 4/4.5 when enabled
         try:
             from letta.settings import model_settings
@@ -325,6 +328,7 @@ class AnthropicClient(LLMClientBase):
         data["system"] = self._add_cache_control_to_system_message(system_content)
         data["messages"] = PydanticMessage.to_anthropic_dicts_from_list(
             messages=messages[1:],
+            current_model=llm_config.model,
             inner_thoughts_xml_tag=inner_thoughts_xml_tag,
             put_inner_thoughts_in_kwargs=put_kwargs,
             # if react, use native content + strip heartbeats
@@ -370,6 +374,7 @@ class AnthropicClient(LLMClientBase):
     async def count_tokens(self, messages: List[dict] = None, model: str = None, tools: List[OpenAITool] = None) -> int:
         logging.getLogger("httpx").setLevel(logging.WARNING)
 
+        # Use the default client; token counting is lightweight and does not require BYOK overrides
         client = anthropic.AsyncAnthropic()
         if messages and len(messages) == 0:
             messages = None
@@ -378,23 +383,20 @@ class AnthropicClient(LLMClientBase):
         else:
             anthropic_tools = None
 
+        # Detect presence of reasoning blocks anywhere in the final assistant message.
+        # Interleaved thinking is not guaranteed to be the first content part.
         thinking_enabled = False
         if messages and len(messages) > 0:
-            # Check if the last assistant message starts with a thinking block
-            # Find the last assistant message
-            last_assistant_message = None
-            for message in reversed(messages):
-                if message.get("role") == "assistant":
-                    last_assistant_message = message
-                    break
-
-            if (
-                last_assistant_message
-                and isinstance(last_assistant_message.get("content"), list)
-                and len(last_assistant_message["content"]) > 0
-                and last_assistant_message["content"][0].get("type") == "thinking"
-            ):
-                thinking_enabled = True
+            last_assistant_message = next((m for m in reversed(messages) if m.get("role") == "assistant"), None)
+            if last_assistant_message:
+                content = last_assistant_message.get("content")
+                if isinstance(content, list):
+                    for part in content:
+                        if isinstance(part, dict) and part.get("type") in {"thinking", "redacted_thinking"}:
+                            thinking_enabled = True
+                            break
+                elif isinstance(content, str) and "<thinking>" in content:
+                    thinking_enabled = True
 
         try:
             count_params = {
@@ -403,9 +405,27 @@ class AnthropicClient(LLMClientBase):
                 "tools": anthropic_tools or [],
             }
 
+            betas: list[str] = []
             if thinking_enabled:
+                # Match interleaved thinking behavior so token accounting is consistent
                 count_params["thinking"] = {"type": "enabled", "budget_tokens": 16000}
-            result = await client.beta.messages.count_tokens(**count_params)
+                betas.append("interleaved-thinking-2025-05-14")
+
+            # Opt-in to 1M context if enabled for this model in settings
+            try:
+                if (
+                    model
+                    and model_settings.anthropic_sonnet_1m
+                    and (model.startswith("claude-sonnet-4") or model.startswith("claude-sonnet-4-5"))
+                ):
+                    betas.append("context-1m-2025-08-07")
+            except Exception:
+                pass
+
+            if betas:
+                result = await client.beta.messages.count_tokens(**count_params, betas=betas)
+            else:
+                result = await client.beta.messages.count_tokens(**count_params)
         except:
             raise
 

letta/llm_api/google_vertex_client.py

@@ -311,6 +311,7 @@ class GoogleVertexClient(LLMClientBase):
         contents = self.add_dummy_model_messages(
             PydanticMessage.to_google_dicts_from_list(
                 messages,
+                current_model=llm_config.model,
                 put_inner_thoughts_in_kwargs=False if agent_type == AgentType.letta_v1_agent else True,
                 native_content=True if agent_type == AgentType.letta_v1_agent else False,
             ),

letta/orm/__init__.py

@@ -27,6 +27,7 @@ from letta.orm.prompt import Prompt
 from letta.orm.provider import Provider
 from letta.orm.provider_trace import ProviderTrace
 from letta.orm.run import Run
+from letta.orm.run_metrics import RunMetrics
 from letta.orm.sandbox_config import AgentEnvironmentVariable, SandboxConfig, SandboxEnvironmentVariable
 from letta.orm.source import Source
 from letta.orm.sources_agents import SourcesAgents

letta/orm/run_metrics.py

@@ -0,0 +1,82 @@
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, Optional
+
+from sqlalchemy import BigInteger, ForeignKey, Integer, String
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Mapped, Session, mapped_column, relationship
+
+from letta.orm.mixins import AgentMixin, OrganizationMixin, ProjectMixin, TemplateMixin
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.run_metrics import RunMetrics as PydanticRunMetrics
+from letta.schemas.user import User
+from letta.settings import DatabaseChoice, settings
+
+if TYPE_CHECKING:
+    from letta.orm.agent import Agent
+    from letta.orm.run import Run
+    from letta.orm.step import Step
+
+
+class RunMetrics(SqlalchemyBase, ProjectMixin, AgentMixin, OrganizationMixin, TemplateMixin):
+    """Tracks performance metrics for agent steps."""
+
+    __tablename__ = "run_metrics"
+    __pydantic_model__ = PydanticRunMetrics
+
+    id: Mapped[str] = mapped_column(
+        ForeignKey("runs.id", ondelete="CASCADE"),
+        primary_key=True,
+        doc="The unique identifier of the run this metric belongs to (also serves as PK)",
+    )
+    run_start_ns: Mapped[Optional[int]] = mapped_column(
+        BigInteger,
+        nullable=True,
+        doc="The timestamp of the start of the run in nanoseconds",
+    )
+    run_ns: Mapped[Optional[int]] = mapped_column(
+        BigInteger,
+        nullable=True,
+        doc="Total time for the run in nanoseconds",
+    )
+    num_steps: Mapped[Optional[int]] = mapped_column(
+        Integer,
+        nullable=True,
+        doc="The number of steps in the run",
+    )
+    run: Mapped[Optional["Run"]] = relationship("Run", foreign_keys=[id])
+    agent: Mapped[Optional["Agent"]] = relationship("Agent")
+
+    def create(
+        self,
+        db_session: Session,
+        actor: Optional[User] = None,
+        no_commit: bool = False,
+    ) -> "RunMetrics":
+        """Override create to handle SQLite timestamp issues"""
+        # For SQLite, explicitly set timestamps as server_default may not work
+        if settings.database_engine == DatabaseChoice.SQLITE:
+            now = datetime.now(timezone.utc)
+            if not self.created_at:
+                self.created_at = now
+            if not self.updated_at:
+                self.updated_at = now
+
+        return super().create(db_session, actor=actor, no_commit=no_commit)
+
+    async def create_async(
+        self,
+        db_session: AsyncSession,
+        actor: Optional[User] = None,
+        no_commit: bool = False,
+        no_refresh: bool = False,
+    ) -> "RunMetrics":
+        """Override create_async to handle SQLite timestamp issues"""
+        # For SQLite, explicitly set timestamps as server_default may not work
+        if settings.database_engine == DatabaseChoice.SQLITE:
+            now = datetime.now(timezone.utc)
+            if not self.created_at:
+                self.created_at = now
+            if not self.updated_at:
+                self.updated_at = now
+
+        return await super().create_async(db_session, actor=actor, no_commit=no_commit, no_refresh=no_refresh)