letta-nightly 0.11.7.dev20251008104128__py3-none-any.whl → 0.12.0.dev20251009104148__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/llm_api/anthropic_client.py

@@ -325,6 +325,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

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)

letta/schemas/message.py

@@ -965,7 +965,13 @@ class Message(BaseMessage):
             }
 
         elif self.role == "assistant" or self.role == "approval":
-            assert self.tool_calls is not None or text_content is not None, vars(self)
+            try:
+                assert self.tool_calls is not None or text_content is not None, vars(self)
+            except AssertionError as e:
+                # relax check if this message only contains reasoning content
+                if self.content is not None and len(self.content) > 0 and isinstance(self.content[0], ReasoningContent):
+                    return None
+                raise e
 
             # if native content, then put it directly inside the content
             if native_content:
@@ -1040,6 +1046,7 @@ class Message(BaseMessage):
         put_inner_thoughts_in_kwargs: bool = False,
         use_developer_message: bool = False,
     ) -> List[dict]:
+        messages = Message.filter_messages_for_llm_api(messages)
         result = [
             m.to_openai_dict(
                 max_tool_id_length=max_tool_id_length,
@@ -1149,6 +1156,7 @@ class Message(BaseMessage):
         messages: List[Message],
         max_tool_id_length: int = TOOL_CALL_ID_MAX_LEN,
     ) -> List[dict]:
+        messages = Message.filter_messages_for_llm_api(messages)
         result = []
         for message in messages:
             result.extend(message.to_openai_responses_dicts(max_tool_id_length=max_tool_id_length))
@@ -1156,6 +1164,7 @@ class Message(BaseMessage):
 
     def to_anthropic_dict(
         self,
+        current_model: str,
         inner_thoughts_xml_tag="thinking",
         put_inner_thoughts_in_kwargs: bool = False,
         # if true, then treat the content field as AssistantMessage
@@ -1242,20 +1251,22 @@ class Message(BaseMessage):
                     for content_part in self.content:
                         # TextContent, ImageContent, ToolCallContent, ToolReturnContent, ReasoningContent, RedactedReasoningContent, OmittedReasoningContent
                         if isinstance(content_part, ReasoningContent):
-                            content.append(
-                                {
-                                    "type": "thinking",
-                                    "thinking": content_part.reasoning,
-                                    "signature": content_part.signature,
-                                }
-                            )
+                            if current_model == self.model:
+                                content.append(
+                                    {
+                                        "type": "thinking",
+                                        "thinking": content_part.reasoning,
+                                        "signature": content_part.signature,
+                                    }
+                                )
                         elif isinstance(content_part, RedactedReasoningContent):
-                            content.append(
-                                {
-                                    "type": "redacted_thinking",
-                                    "data": content_part.data,
-                                }
-                            )
+                            if current_model == self.model:
+                                content.append(
+                                    {
+                                        "type": "redacted_thinking",
+                                        "data": content_part.data,
+                                    }
+                                )
                         elif isinstance(content_part, TextContent):
                             content.append(
                                 {
@@ -1272,20 +1283,22 @@ class Message(BaseMessage):
                 if self.content is not None and len(self.content) >= 1:
                     for content_part in self.content:
                         if isinstance(content_part, ReasoningContent):
-                            content.append(
-                                {
-                                    "type": "thinking",
-                                    "thinking": content_part.reasoning,
-                                    "signature": content_part.signature,
-                                }
-                            )
+                            if current_model == self.model:
+                                content.append(
+                                    {
+                                        "type": "thinking",
+                                        "thinking": content_part.reasoning,
+                                        "signature": content_part.signature,
+                                    }
+                                )
                         if isinstance(content_part, RedactedReasoningContent):
-                            content.append(
-                                {
-                                    "type": "redacted_thinking",
-                                    "data": content_part.data,
-                                }
-                            )
+                            if current_model == self.model:
+                                content.append(
+                                    {
+                                        "type": "redacted_thinking",
+                                        "data": content_part.data,
+                                    }
+                                )
                         if isinstance(content_part, TextContent):
                             content.append(
                                 {
@@ -1349,14 +1362,17 @@ class Message(BaseMessage):
     @staticmethod
     def to_anthropic_dicts_from_list(
         messages: List[Message],
+        current_model: str,
         inner_thoughts_xml_tag: str = "thinking",
         put_inner_thoughts_in_kwargs: bool = False,
         # if true, then treat the content field as AssistantMessage
         native_content: bool = False,
         strip_request_heartbeat: bool = False,
     ) -> List[dict]:
+        messages = Message.filter_messages_for_llm_api(messages)
         result = [
             m.to_anthropic_dict(
+                current_model=current_model,
                 inner_thoughts_xml_tag=inner_thoughts_xml_tag,
                 put_inner_thoughts_in_kwargs=put_inner_thoughts_in_kwargs,
                 native_content=native_content,
@@ -1369,6 +1385,7 @@ class Message(BaseMessage):
 
     def to_google_dict(
         self,
+        current_model: str,
         put_inner_thoughts_in_kwargs: bool = True,
         # if true, then treat the content field as AssistantMessage
         native_content: bool = False,
@@ -1484,11 +1501,12 @@ class Message(BaseMessage):
                 for content in self.content:
                     if isinstance(content, TextContent):
                         native_part = {"text": content.text}
-                        if content.signature:
+                        if content.signature and current_model == self.model:
                             native_part["thought_signature"] = content.signature
                         native_google_content_parts.append(native_part)
                     elif isinstance(content, ReasoningContent):
-                        native_google_content_parts.append({"text": content.reasoning, "thought": True})
+                        if current_model == self.model:
+                            native_google_content_parts.append({"text": content.reasoning, "thought": True})
                     elif isinstance(content, ToolCallContent):
                         native_part = {
                             "function_call": {
@@ -1496,7 +1514,7 @@ class Message(BaseMessage):
                                 "args": content.input,
                             },
                         }
-                        if content.signature:
+                        if content.signature and current_model == self.model:
                             native_part["thought_signature"] = content.signature
                         native_google_content_parts.append(native_part)
                     else:
@@ -1554,11 +1572,14 @@ class Message(BaseMessage):
     @staticmethod
     def to_google_dicts_from_list(
         messages: List[Message],
+        current_model: str,
         put_inner_thoughts_in_kwargs: bool = True,
         native_content: bool = False,
     ):
+        messages = Message.filter_messages_for_llm_api(messages)
         result = [
             m.to_google_dict(
+                current_model=current_model,
                 put_inner_thoughts_in_kwargs=put_inner_thoughts_in_kwargs,
                 native_content=native_content,
             )
@@ -1567,6 +1588,45 @@ class Message(BaseMessage):
         result = [m for m in result if m is not None]
         return result
 
+    def is_approval_request(self) -> bool:
+        return self.role == "approval" and self.tool_calls is not None and len(self.tool_calls) > 0
+
+    def is_approval_response(self) -> bool:
+        return self.role == "approval" and self.tool_calls is None and self.approve is not None
+
+    def is_summarization_message(self) -> bool:
+        return (
+            self.role == "user"
+            and self.content is not None
+            and len(self.content) == 1
+            and isinstance(self.content[0], TextContent)
+            and "system_alert" in self.content[0].text
+        )
+
+    @staticmethod
+    def filter_messages_for_llm_api(
+        messages: List[Message],
+    ) -> List[Message]:
+        messages = [m for m in messages if m is not None]
+        if len(messages) == 0:
+            return []
+        # Add special handling for legacy bug where summarization triggers in the middle of hitl
+        messages_to_filter = []
+        for i in range(len(messages) - 1):
+            first_message_is_approval = messages[i].is_approval_request()
+            second_message_is_summary = messages[i + 1].is_summarization_message()
+            third_message_is_optional_approval = i + 2 >= len(messages) or messages[i + 2].is_approval_response()
+            if first_message_is_approval and second_message_is_summary and third_message_is_optional_approval:
+                messages_to_filter.append(messages[i])
+        for idx in reversed(messages_to_filter):  # reverse to avoid index shift
+            messages.remove(idx)
+
+        # Filter last message if it is a lone approval request without a response - this only occurs for token counting
+        if messages[-1].role == "approval" and messages[-1].tool_calls is not None and len(messages[-1].tool_calls) > 0:
+            messages.remove(messages[-1])
+
+        return messages
+
     @staticmethod
     def generate_otid_from_id(message_id: str, index: int) -> str:
         """

letta/schemas/run_metrics.py

@@ -0,0 +1,21 @@
+from typing import Optional
+
+from pydantic import Field
+
+from letta.schemas.letta_base import LettaBase
+
+
+class RunMetricsBase(LettaBase):
+    __id_prefix__ = "run"
+
+
+class RunMetrics(RunMetricsBase):
+    id: str = Field(..., description="The id of the run this metric belongs to (matches runs.id).")
+    organization_id: Optional[str] = Field(None, description="The unique identifier of the organization.")
+    agent_id: Optional[str] = Field(None, description="The unique identifier of the agent.")
+    project_id: Optional[str] = Field(None, description="The project that the run belongs to (cloud only).")
+    run_start_ns: Optional[int] = Field(None, description="The timestamp of the start of the run in nanoseconds.")
+    run_ns: Optional[int] = Field(None, description="Total time for the run in nanoseconds.")
+    num_steps: Optional[int] = Field(None, description="The number of steps in the run.")
+    template_id: Optional[str] = Field(None, description="The template ID that the run belongs to (cloud only).")
+    base_template_id: Optional[str] = Field(None, description="The base template ID that the run belongs to (cloud only).")

letta/server/db.py

@@ -10,18 +10,11 @@ from sqlalchemy.ext.asyncio import (
     create_async_engine,
 )
 
+from letta.database_utils import get_database_uri_for_context
 from letta.settings import settings
 
-# Convert PostgreSQL URI to async format
-pg_uri = settings.letta_pg_uri
-if pg_uri.startswith("postgresql://"):
-    async_pg_uri = pg_uri.replace("postgresql://", "postgresql+asyncpg://")
-else:
-    # Handle other URI formats (e.g., postgresql+pg8000://)
-    async_pg_uri = f"postgresql+asyncpg://{pg_uri.split('://', 1)[1]}" if "://" in pg_uri else pg_uri
-
-# Replace sslmode with ssl for asyncpg
-async_pg_uri = async_pg_uri.replace("sslmode=", "ssl=")
+# Convert PostgreSQL URI to async format using common utility
+async_pg_uri = get_database_uri_for_context(settings.letta_pg_uri, "async")
 
 # Build engine configuration based on settings
 engine_args = {

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

@@ -13,6 +13,7 @@ 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.run_metrics import RunMetrics
 from letta.schemas.step import Step
 from letta.server.rest_api.dependencies import HeaderParams, get_headers, get_letta_server
 from letta.server.rest_api.redis_stream_manager import redis_sse_stream_generator
@@ -224,6 +225,23 @@ async def retrieve_run_usage(
         raise HTTPException(status_code=404, detail=f"Run '{run_id}' not found")
 
 
+@router.get("/{run_id}/metrics", response_model=RunMetrics, operation_id="retrieve_metrics_for_run")
+async def retrieve_metrics_for_run(
+    run_id: str,
+    headers: HeaderParams = Depends(get_headers),
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Get run metrics by run ID.
+    """
+    try:
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+        runs_manager = RunManager()
+        return await runs_manager.get_run_metrics_async(run_id=run_id, actor=actor)
+    except NoResultFound:
+        raise HTTPException(status_code=404, detail="Run metrics not found")
+
+
 @router.get(
     "/{run_id}/steps",
     response_model=List[Step],
@@ -247,18 +265,14 @@ async def list_run_steps(
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
     runs_manager = RunManager()
 
-    try:
-        steps = await runs_manager.get_run_steps(
-            run_id=run_id,
-            actor=actor,
-            limit=limit,
-            before=before,
-            after=after,
-            ascending=(order == "asc"),
-        )
-        return steps
-    except NoResultFound as e:
-        raise HTTPException(status_code=404, detail=str(e))
+    return await runs_manager.get_run_steps(
+        run_id=run_id,
+        actor=actor,
+        limit=limit,
+        before=before,
+        after=after,
+        ascending=(order == "asc"),
+    )
 
 
 @router.delete("/{run_id}", response_model=Run, operation_id="delete_run")
@@ -272,12 +286,7 @@ async def delete_run(
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
     runs_manager = RunManager()
-
-    try:
-        run = await runs_manager.delete_run_by_id(run_id=run_id, actor=actor)
-        return run
-    except NoResultFound:
-        raise HTTPException(status_code=404, detail="Run not found")
+    return await runs_manager.delete_run_by_id(run_id=run_id, actor=actor)
 
 
 @router.post(

letta/services/context_window_calculator/token_counter.py

@@ -74,7 +74,7 @@ class AnthropicTokenCounter(TokenCounter):
         return await self.client.count_tokens(model=self.model, tools=tools)
 
     def convert_messages(self, messages: List[Any]) -> List[Dict[str, Any]]:
-        return Message.to_anthropic_dicts_from_list(messages)
+        return Message.to_anthropic_dicts_from_list(messages, current_model=self.model)
 
 
 class TiktokenCounter(TokenCounter):

letta/services/helpers/run_manager_helper.py

@@ -2,14 +2,10 @@ from datetime import datetime
 from typing import Optional
 
 from sqlalchemy import asc, desc, nulls_last, select
-from letta.settings import DatabaseChoice, settings
 
 from letta.orm.run import Run as RunModel
-from letta.settings import DatabaseChoice, settings
-from sqlalchemy import asc, desc
-from typing import Optional
-
 from letta.services.helpers.agent_manager_helper import _cursor_filter
+from letta.settings import DatabaseChoice, settings
 
 
 async def _apply_pagination_async(
@@ -29,17 +25,11 @@ async def _apply_pagination_async(
         sort_nulls_last = False
 
     if after:
-        result = (
-            await session.execute(
-                select(sort_column, RunModel.id).where(RunModel.id == after)
-            )
-        ).first()
+        result = (await session.execute(select(sort_column, RunModel.id).where(RunModel.id == after))).first()
         if result:
             after_sort_value, after_id = result
             # SQLite does not support as granular timestamping, so we need to round the timestamp
-            if settings.database_engine is DatabaseChoice.SQLITE and isinstance(
-                after_sort_value, datetime
-            ):
+            if settings.database_engine is DatabaseChoice.SQLITE and isinstance(after_sort_value, datetime):
                 after_sort_value = after_sort_value.strftime("%Y-%m-%d %H:%M:%S")
             query = query.where(
                 _cursor_filter(
@@ -53,17 +43,11 @@ async def _apply_pagination_async(
             )
 
     if before:
-        result = (
-            await session.execute(
-                select(sort_column, RunModel.id).where(RunModel.id == before)
-            )
-        ).first()
+        result = (await session.execute(select(sort_column, RunModel.id).where(RunModel.id == before))).first()
         if result:
             before_sort_value, before_id = result
             # SQLite does not support as granular timestamping, so we need to round the timestamp
-            if settings.database_engine is DatabaseChoice.SQLITE and isinstance(
-                before_sort_value, datetime
-            ):
+            if settings.database_engine is DatabaseChoice.SQLITE and isinstance(before_sort_value, datetime):
                 before_sort_value = before_sort_value.strftime("%Y-%m-%d %H:%M:%S")
             query = query.where(
                 _cursor_filter(

letta/services/run_manager.py

@@ -8,9 +8,11 @@ from sqlalchemy.orm import Session
 
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.log import get_logger
+from letta.orm.agent import Agent as AgentModel
 from letta.orm.errors import NoResultFound
 from letta.orm.message import Message as MessageModel
 from letta.orm.run import Run as RunModel
+from letta.orm.run_metrics import RunMetrics as RunMetricsModel
 from letta.orm.sqlalchemy_base import AccessType
 from letta.orm.step import Step as StepModel
 from letta.otel.tracing import log_event, trace_method
@@ -21,6 +23,7 @@ from letta.schemas.letta_response import LettaResponse
 from letta.schemas.letta_stop_reason import LettaStopReason, StopReasonType
 from letta.schemas.message import Message as PydanticMessage
 from letta.schemas.run import Run as PydanticRun, RunUpdate
+from letta.schemas.run_metrics import RunMetrics as PydanticRunMetrics
 from letta.schemas.step import Step as PydanticStep
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User as PydanticUser
@@ -62,6 +65,23 @@ class RunManager:
             run = RunModel(**run_data)
             run.organization_id = organization_id
             run = await run.create_async(session, actor=actor, no_commit=True, no_refresh=True)
+
+            # Create run metrics with start timestamp
+            import time
+
+            # Get the project_id from the agent
+            agent = await session.get(AgentModel, agent_id)
+            project_id = agent.project_id if agent else None
+
+            metrics = RunMetricsModel(
+                id=run.id,
+                organization_id=organization_id,
+                agent_id=agent_id,
+                project_id=project_id,
+                run_start_ns=int(time.time() * 1e9),  # Current time in nanoseconds
+                num_steps=0,  # Initialize to 0
+            )
+            await metrics.create_async(session)
             await session.commit()
 
         return run.to_pydantic()
@@ -178,6 +198,21 @@ class RunManager:
             await run.update_async(db_session=session, actor=actor, no_commit=True, no_refresh=True)
             final_metadata = run.metadata_
             pydantic_run = run.to_pydantic()
+
+            await session.commit()
+
+        # update run metrics table
+        num_steps = len(await self.step_manager.list_steps_async(run_id=run_id, actor=actor))
+        async with db_registry.async_session() as session:
+            metrics = await RunMetricsModel.read_async(db_session=session, identifier=run_id, actor=actor)
+            # Calculate runtime if run is completing
+            if is_terminal_update and metrics.run_start_ns:
+                import time
+
+                current_ns = int(time.time() * 1e9)
+                metrics.run_ns = current_ns - metrics.run_start_ns
+            metrics.num_steps = num_steps
+            await metrics.update_async(db_session=session, actor=actor, no_commit=True, no_refresh=True)
             await session.commit()
 
         # Dispatch callback outside of database session if needed
@@ -299,3 +334,31 @@ class RunManager:
                 raise NoResultFound(f"Run with id {run_id} not found")
             pydantic_run = run.to_pydantic()
             return pydantic_run.request_config
+
+    @enforce_types
+    async def get_run_metrics_async(self, run_id: str, actor: PydanticUser) -> PydanticRunMetrics:
+        """Get metrics for a run."""
+        async with db_registry.async_session() as session:
+            metrics = await RunMetricsModel.read_async(db_session=session, identifier=run_id, actor=actor)
+            return metrics.to_pydantic()
+
+    @enforce_types
+    async def get_run_steps(
+        self,
+        run_id: str,
+        actor: PydanticUser,
+        limit: Optional[int] = 100,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        ascending: bool = False,
+    ) -> List[PydanticStep]:
+        """Get steps for a run."""
+        async with db_registry.async_session() as session:
+            run = await RunModel.read_async(db_session=session, identifier=run_id, actor=actor, access_type=AccessType.ORGANIZATION)
+            if not run:
+                raise NoResultFound(f"Run with id {run_id} not found")
+
+        steps = await self.step_manager.list_steps_async(
+            actor=actor, run_id=run_id, limit=limit, before=before, after=after, order="asc" if ascending else "desc"
+        )
+        return steps

letta/system.py

@@ -248,7 +248,11 @@ def unpack_message(packed_message: str) -> str:
         warnings.warn(f"Was unable to find 'message' field in packed message object: '{packed_message}'")
         return packed_message
     else:
-        message_type = message_json["type"]
+        try:
+            message_type = message_json["type"]
+        except:
+            return packed_message
+
         if message_type != "user_message":
             warnings.warn(f"Expected type to be 'user_message', but was '{message_type}', so not unpacking: '{packed_message}'")
             return packed_message

{letta_nightly-0.11.7.dev20251008104128.dist-info → letta_nightly-0.12.0.dev20251009104148.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: letta-nightly
-Version: 0.11.7.dev20251008104128
+Version: 0.12.0.dev20251009104148
 Summary: Create LLM agents with long-term memory and custom tools
 Author-email: Letta Team <contact@letta.com>
 License: Apache License

{letta_nightly-0.11.7.dev20251008104128.dist-info → letta_nightly-0.12.0.dev20251009104148.dist-info}/RECORD

@@ -1,7 +1,8 @@
-letta/__init__.py,sha256=ZwTfnKwttBN_OlSwb4a3-r8foHZiqx9VfpbsM3BT7xA,1620
+letta/__init__.py,sha256=YF1Hcr7H49Jrjsp2dkyB-FWzee4pnuGLJnLBERmmsi0,1620
 letta/agent.py,sha256=xP13DDysFq-h3Ny7DiTN5ZC2txRripMNvPFt8dfFDbE,89498
 letta/config.py,sha256=JFGY4TWW0Wm5fTbZamOwWqk5G8Nn-TXyhgByGoAqy2c,12375
 letta/constants.py,sha256=Yxp2DGlVnesnevIQbXqfYadxvVuYYk_6-lsF7YmHixs,16255
+letta/database_utils.py,sha256=D0lIbOkUQDBd2cJL1bmepyrsD5Rl29ZZLMkwnB7z8o0,4492
 letta/embeddings.py,sha256=d2o1nOVTaofBk6j-WwsE0_ugvxa1nIOcceqGuJ4w_pc,2045
 letta/errors.py,sha256=cpZQlm1VaGypu1SWj1-5bqfbW2kwKwdfcSculec5J5M,11534
 letta/interface.py,sha256=kYOTv1xhNWcoL9qP7cs8hGp9gKBimcBmqIhCUeoil18,13026
@@ -12,7 +13,7 @@ letta/pytest.ini,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/settings.py,sha256=CbSbYJ21q8MSrWJBie0YxXC2ijmPLNr7mojU4DPZuH4,15810
 letta/streaming_interface.py,sha256=rPMfwUcjqITWk2tVqFQm1hmP99tU2IOHg9gU2dgPSo8,16400
 letta/streaming_utils.py,sha256=ZRFGFpQqn9ujCEbgZdLM7yTjiuNNvqQ47sNhV8ix-yQ,16553
-letta/system.py,sha256=kHF7n3Viq7gV5UIUEXixod2gWa2jroUgztpEzMC1Sew,8925
+letta/system.py,sha256=NClLhwB9Dw20L6IDPpfcnmxXqYQlA5E92xzJ0hGPLo0,8993
 letta/utils.py,sha256=c108IxvNVf0NeuQRrr2NK-asqjpzOI79YKSHYyhEqrQ,43541
 letta/adapters/letta_llm_adapter.py,sha256=Uo9l2lUI-n9mymWlK8lTResdWx0mc-F_ttmmKRJKzxo,3527
 letta/adapters/letta_llm_request_adapter.py,sha256=ApEaMOkvtH5l09NvVgm0r2qaqTnGSqwVqAFA7n5N1HA,4757
@@ -30,7 +31,7 @@ letta/agents/helpers.py,sha256=Hz8dKczPxMmDh-ILiUAEHgT55hMgIHO1yV8Vo0PORcw,16837
 letta/agents/letta_agent.py,sha256=4SSx6aORD28B1IogEoWeCTQr4jBaniX9jJolD4pssaQ,98156
 letta/agents/letta_agent_batch.py,sha256=NizNeIHvFtG4XpZCIplOSF8GohwHvNEkAUvsFBSdtSs,27950
 letta/agents/letta_agent_v2.py,sha256=MBoXVMIPixozb3xts2Bl8BCbExMIv3vtGbKZK1RitT4,60101
-letta/agents/letta_agent_v3.py,sha256=2yWG8cDkxrFJR57GeU3ReLGqim27L0OP0XcRtQVW-VE,46161
+letta/agents/letta_agent_v3.py,sha256=i8idcEKVcZxJk67T_g0zLFBcrlHfygcuN9V_xk4Sj0c,48081
 letta/agents/voice_agent.py,sha256=DP7g7TPFhaIAxmpur9yyJVI8Sb_MnoWfpHm7Q-t7mJI,23177
 letta/agents/voice_sleeptime_agent.py,sha256=_JzCbWBOKrmo1cTaqZFTrQudpJEapwAyrXYtAHUILGo,8675
 letta/cli/cli.py,sha256=tKtghlX36Rp0_HbkMosvlAapL07JXhA0vKLGTNKnxSQ,1615
@@ -98,13 +99,13 @@ letta/jobs/llm_batch_job_polling.py,sha256=HUCTa1lTOiLAB_8m95RUfeNJa4lxlF8paGdCV
 letta/jobs/scheduler.py,sha256=Ub5VTCA8P5C9Y-0mPK2YIPJSEzKbSd2l5Sp0sOWctD8,8697
 letta/jobs/types.py,sha256=K8GKEnqEgAT6Kq4F2hUrBC4ZAFM9OkfOjVMStzxKuXQ,742
 letta/llm_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/llm_api/anthropic_client.py,sha256=YhLfiiRVVr3JoZtz8SnXOPuC62za4En2ThqmrXPM_zo,42160
+letta/llm_api/anthropic_client.py,sha256=xZc2tvqz0_P3oNc0Wd2iWpK8qopQJkOSGnOFyo7v7hU,42204
 letta/llm_api/azure_client.py,sha256=BeChGsH4brrSgZBbCf8UE5RkW-3ZughpKnsBY2VYxwI,3841
 letta/llm_api/bedrock_client.py,sha256=xB01zdk1bzzf0ExkPcWcuxuLb1GXaJglvgRMYP2zai4,3572
 letta/llm_api/deepseek_client.py,sha256=YYja4-LWODE8fAJPSIVGxA7q0hb6-QmWRxWhlboTp64,17144
 letta/llm_api/google_ai_client.py,sha256=JweTUHZXvK6kcZBGXA7XEU53KP4vM7_zdD7AorCtsdI,8166
 letta/llm_api/google_constants.py,sha256=eOjOv-FImyJ4b4QGIaod-mEROMtrBFz0yhuYHqOEkwY,797
-letta/llm_api/google_vertex_client.py,sha256=Ws6qBlYIBdw009epkBiIRWVW47aNHAgAabwPDL6f1L0,39461
+letta/llm_api/google_vertex_client.py,sha256=__j0OQDjzW1auyzvXKJoWLg3oPDLQgLL79A26K6GT84,39509
 letta/llm_api/groq_client.py,sha256=C34aWj2fv5A9AG_BKLdz-pXcvPQ6zf38f28EXkTtCjY,3361
 letta/llm_api/helpers.py,sha256=GXV_SuaU7uSCDj6bxDcCCF7CUjuZQCVWd5qZ3OsHVNk,17587
 letta/llm_api/llm_api_tools.py,sha256=EZLya93AbRblpnzpz5c1jEUI8n-zIbH7wbBH5LnLd6Q,12674
@@ -157,7 +158,7 @@ letta/local_llm/webui/legacy_settings.py,sha256=BLmd3TSx5StnY3ibjwaxYATPt_Lvq-o1
 letta/local_llm/webui/settings.py,sha256=gmLHfiOl1u4JmlAZU2d2O8YKF9lafdakyjwR_ftVPh8,552
 letta/openai_backcompat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/openai_backcompat/openai_object.py,sha256=GSzeCTwLpLD2fH4X8wVqzwdmoTjKK2I4PnriBY453lc,13505
-letta/orm/__init__.py,sha256=-P_frbPnMa19v8Zb8qvKycU3K72iIRrVzrAo2yPn2V0,1662
+letta/orm/__init__.py,sha256=ZlnnsQu3PSzpHyGmXsBnHZCfRiiszUkND3G69Ma6fr0,1707
 letta/orm/agent.py,sha256=HS8hbS3uJoH8uezxKQ1vNr0YoXyTKBKhPsQdz4SrVK4,17747
 letta/orm/agents_tags.py,sha256=-rWR8DoEiHM4yc9vAHgHuvjIwgMXMWzKnTKFlBBu3TQ,1076
 letta/orm/archive.py,sha256=82engq9ZfNrp1yu8QS5df4vsIwQC33CADZA-05doNko,3920
@@ -191,6 +192,7 @@ letta/orm/prompt.py,sha256=NpFPTm3jD8Aewxhlnq8s4eIzANJ3bAEtbq6UmFqyc3U,489
 letta/orm/provider.py,sha256=dBvqXcQ7vMEkbsCQ82NezUB4RTCT3KiyZlkC3Z9ZTPg,1955
 letta/orm/provider_trace.py,sha256=CJMGz-rLqagJ-yXh9SJRbiGr5nAYdxY524hmiTgDFx4,1153
 letta/orm/run.py,sha256=eQgqfq-F9W9hHRbnfSVOhrW936J0xiTb5bvaVviTxvM,3820
+letta/orm/run_metrics.py,sha256=WiWiJgx-eaQxn6ldUkv7aloUUKdB2l8lzTommoDOhCg,3094
 letta/orm/sandbox_config.py,sha256=FxFhKlbfGwE3d0quNbKXLkVcKSWh0HPmQVShdvktCoo,4497
 letta/orm/source.py,sha256=tRxqjWM8n1LBhlDTIiKhJ82-tpWErTeiDXMFz1rwY4g,1715
 letta/orm/sources_agents.py,sha256=Fvo8ujDNeeqleiiqXk-0VUPiQDawLAN-d28RxdvWnbs,554
@@ -270,7 +272,7 @@ letta/schemas/llm_config.py,sha256=dzEiIvm1l5xlYF0Q1It-18l9HKdwMd4Yr09A3gWhhNI,1
 letta/schemas/llm_config_overrides.py,sha256=E6qJuVA8TwAAy3VjGitJ5jSQo5PbN-6VPcZOF5qhP9A,1815
 letta/schemas/mcp.py,sha256=Wiu3FL5qupaHFaMqKFp-w1Ev6ShQ5dPfAtKIMGmRiF8,15527
 letta/schemas/memory.py,sha256=g2cPd0CF_3atzVkQA8ioIm52oZbsr6Ng-w31qGgNJ_g,20206
-letta/schemas/message.py,sha256=Ey2Kq3ipdPUwTIixYoWxpko9nF-22lhigqZ_3kinKFY,71874
+letta/schemas/message.py,sha256=kXTfYnbFm7uzj2TIy-R3ixrSJGnR6xasdt1wgYJJOvw,74961
 letta/schemas/npm_requirement.py,sha256=HkvBF7KjHUH-MG-RAEYJHO2MLRS2rxFUcmbpbZVznLk,457
 letta/schemas/organization.py,sha256=TXrHN4IBQnX-mWvRuCOH57XZSLYCVOY0wWm2_UzDQIA,1279
 letta/schemas/passage.py,sha256=_bO19zOIQtQ3F3VqDSgIJqh15V0IIrJ_KdlbCt6-4D0,3940
@@ -280,6 +282,7 @@ letta/schemas/provider_trace.py,sha256=L-L5gEt9X1wMiI5w1fQ79qvJ1g1Kvo2TobeQC1p9a
 letta/schemas/providers.py,sha256=oHDHP3wUVPe3S2RfefUcsgE2DFCnkMFXx75FE7h0Pzw,69393
 letta/schemas/response_format.py,sha256=b2onyfSDCxnNkSHd4NsfJg_4ni5qBIK_F6zeJoMvjq0,2131
 letta/schemas/run.py,sha256=wjpDNsgme51WVr5EJ12Px6qhtOYbw-PMpJP32lche14,3630
+letta/schemas/run_metrics.py,sha256=xbeObgpP-0guO3RRvEfEK5YNV6G7ol4whx3_ds88mIk,1147
 letta/schemas/sandbox_config.py,sha256=iw3-QS7PNy649tdynTJUxBbaruprykYAuGO6q28w-gU,5974
 letta/schemas/secret.py,sha256=1vq33Z-Oe2zSeVnGuj6j04YoO0Y9LxX1bmkprg6C1NA,15659
 letta/schemas/source.py,sha256=Uxsm8-XA3vuIt5Ihu_l2Aau7quuqmyIDg7qIryklUqY,3565
@@ -328,7 +331,7 @@ letta/serialize_schemas/marshmallow_tool.py,sha256=Cq4JQeLBrHdeoi8YhT84rXMXBCtiA
 letta/serialize_schemas/pydantic_agent_schema.py,sha256=CqGqSFzArYE2CzFsIU8LXVmH1A1jYFQpFy7Sj62n_4A,3171
 letta/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/constants.py,sha256=yAdGbLkzlOU_dLTx0lKDmAnj0ZgRXCEaIcPJWO69eaE,92
-letta/server/db.py,sha256=lRQpacwE0sAjZgYqlui7BvCWYQYs3O58g2J67r92_Ks,3257
+letta/server/db.py,sha256=bh294tLdOQxOrO9jICDrXa_UXTAYFByu_47tPXlKrjs,3006
 letta/server/generate_openapi_schema.sh,sha256=14Q6r0fbNNVVdf4X3Z-H0ZtyrVw5zYLzL5Doom3kM9k,351
 letta/server/server.py,sha256=nEvHxECQJ6I6EC2GQRNzHZpxg5HgFkhCXzqFwB-U9E4,78499
 letta/server/startup.sh,sha256=z-Fea-7LiuS_aG1tJqS8JAsDQaamwC_kuDhv9D3PPPY,2698
@@ -367,7 +370,7 @@ letta/server/rest_api/routers/v1/llms.py,sha256=sv5VWqB0-iSRi6LyzqsM1fLmOFm9UhM9
 letta/server/rest_api/routers/v1/messages.py,sha256=MgfHaTuPGyO1RjtjDuu4fC5dkmXEannUc9XGEK_aFLg,8559
 letta/server/rest_api/routers/v1/organizations.py,sha256=Un7qRo-69m9bC_TYyMnIRNLXf3fHHbNh1aVghnzzips,2932
 letta/server/rest_api/routers/v1/providers.py,sha256=_gKcCbEN2tW7c0BO7_cMFEYdhhsxDlKaopqXlZXMU1s,5996
-letta/server/rest_api/routers/v1/runs.py,sha256=EABftoK5CcA3aD9NmkLIiuuEAp2QLMt5kKo0_xjyzWw,14551
+letta/server/rest_api/routers/v1/runs.py,sha256=qdCnp90Mdycu_itmPk78U_gYVbboBcadsCCAAdl4Oe8,14957
 letta/server/rest_api/routers/v1/sandbox_configs.py,sha256=1x1QOOv-7jB9qf_AiYXH7ITyYMYicAgA4a5Qc8OHwB0,8702
 letta/server/rest_api/routers/v1/sources.py,sha256=8fkCbprC4PZlcf5HnBYj2-8PjWFIkL0TWZBlp95N7nE,22319
 letta/server/rest_api/routers/v1/steps.py,sha256=OIExfKSwilCmtrVHhF80h8g3yqhf5ww533FIw7N8noI,8251
@@ -404,7 +407,7 @@ letta/services/organization_manager.py,sha256=fHDTtZVCLOeH3_NPCRlDH-a3i2iPYAjSs-
 letta/services/passage_manager.py,sha256=TsdO9VN7oh4xV_oPvi9eyFOIrVA1fT7qGB8taYnf0b8,38419
 letta/services/per_agent_lock_manager.py,sha256=cMaW8r-qhucQbiK27jVqz8wzhlr2yuRNXbdkaMO4lnk,627
 letta/services/provider_manager.py,sha256=qSCoN2Qy5SQcsZZOThAE2rAfDjT7zr32omenGSHBYAs,7877
-letta/services/run_manager.py,sha256=tI1_CjN40gmJxUyCs26i0ToIZciaUTZ0Tj_g9Pz0ZLA,13557
+letta/services/run_manager.py,sha256=fWTTEKG0tVEDcKUrR0sEj9ozgZ7ziPFV7LvZO2UdXgk,16292
 letta/services/sandbox_config_manager.py,sha256=dBDb6fuL7K-Ds6eL3TmcyCDQ7UKlF_nbJ2bixpmxm98,14956
 letta/services/source_manager.py,sha256=IteOcn9ydoO7KARoPh-JuuYwO4jWcsBoTsrkGWvDk9c,18864
 letta/services/step_manager.py,sha256=V9LlX5dOMuTVFkoncrFnzcgtn0sokhsOcUNSahiCZS0,22666
@@ -414,7 +417,7 @@ letta/services/tool_schema_generator.py,sha256=PA-hOhLi_w9VNbPpC3kt1YWybc2uQfkX5
 letta/services/user_manager.py,sha256=0LgTED-EPUCmQkXm0LPMBV6ONbOFtsXJnHxjoG5YjRU,6159
 letta/services/context_window_calculator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/context_window_calculator/context_window_calculator.py,sha256=Ux1UU_l0Nk08HGUMUUrjbtnm2thVRC9bHE7poo8gb8o,8241
-letta/services/context_window_calculator/token_counter.py,sha256=Am3ofVdi0_RiJz56b2uqc1Xz_1WglHkiyRwWrXvYrx8,4815
+letta/services/context_window_calculator/token_counter.py,sha256=cdSoF8muJmBezE9gf8kL-LG6QOeP5mlaPAp2xr2Upbg,4841
 letta/services/file_processor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/file_processor/file_processor.py,sha256=VkQDtb79Xlj4bWLbGGG53ZPwaDf55w7t50WhlwNYvfI,15923
 letta/services/file_processor/file_types.py,sha256=kHe_EWK2k8y_5glVkCkkdZy1BLALyBvtlpZ9V-kiqHE,13070
@@ -432,7 +435,7 @@ letta/services/file_processor/parser/base_parser.py,sha256=WfnXP6fL-xQz4eIHEWa6-
 letta/services/file_processor/parser/markitdown_parser.py,sha256=BpCM82ocDKbNTKhb2Zu3ffYUXR5fqudiUiwxmmUePg4,3715
 letta/services/file_processor/parser/mistral_parser.py,sha256=NmCdVdpAB5f-VjILJp85pz2rSjlghKEg7qKTFzZLhP8,2384
 letta/services/helpers/agent_manager_helper.py,sha256=FGOcaFkuOnTadaHFQ2H3wi3w5MVPNMgT32E99mSrKkg,51126
-letta/services/helpers/run_manager_helper.py,sha256=q73DyDodrBmoC6tutfGOwpC6mqvTi46dFA2RcL-xuaA,2877
+letta/services/helpers/run_manager_helper.py,sha256=3hzxJ2gA1QEVSP-IhNf6NyTxoXogI8bqPGgqTTNpyRk,2599
 letta/services/helpers/tool_execution_helper.py,sha256=45L7woJ98jK5MQAnhE_4NZdCeyOOzC4328FTQPM7iTA,9159
 letta/services/helpers/tool_parser_helper.py,sha256=gJ-XwvqIgVPlnPVbseHL0YPfTUtk6svqC43-U4VcM5k,4467
 letta/services/lettuce/__init__.py,sha256=UU0Jb58TV72EW204f8U2rru_Q9HlpaxqhECDF3t5N98,151
@@ -473,8 +476,8 @@ letta/templates/sandbox_code_file.py.j2,sha256=eXga5J_04Z8-pGdwfOCDjcRnMceIqcF5i
 letta/templates/sandbox_code_file_async.py.j2,sha256=lb7nh_P2W9VZHzU_9TxSCEMUod7SDziPXgvT75xVds0,2748
 letta/templates/summary_request_text.j2,sha256=ZttQwXonW2lk4pJLYzLK0pmo4EO4EtUUIXjgXKiizuc,842
 letta/types/__init__.py,sha256=hokKjCVFGEfR7SLMrtZsRsBfsC7yTIbgKPLdGg4K1eY,147
-letta_nightly-0.11.7.dev20251008104128.dist-info/METADATA,sha256=ojYZkA1rT1M3girk9unsdfPOx9uoGUr6ZzNKfGoJkcI,24468
-letta_nightly-0.11.7.dev20251008104128.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-letta_nightly-0.11.7.dev20251008104128.dist-info/entry_points.txt,sha256=m-94Paj-kxiR6Ktu0us0_2qfhn29DzF2oVzqBE6cu8w,41
-letta_nightly-0.11.7.dev20251008104128.dist-info/licenses/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.11.7.dev20251008104128.dist-info/RECORD,,
+letta_nightly-0.12.0.dev20251009104148.dist-info/METADATA,sha256=-xts5F15qFLK5pjWrucujMu7g3rWG_qDh3uG9DQuzjE,24468
+letta_nightly-0.12.0.dev20251009104148.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+letta_nightly-0.12.0.dev20251009104148.dist-info/entry_points.txt,sha256=m-94Paj-kxiR6Ktu0us0_2qfhn29DzF2oVzqBE6cu8w,41
+letta_nightly-0.12.0.dev20251009104148.dist-info/licenses/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.12.0.dev20251009104148.dist-info/RECORD,,