letta-nightly 0.11.7.dev20251007104119__py3-none-any.whl → 0.11.7.dev20251008104128__py3-none-any.whl

letta/agents/voice_agent.py

@@ -214,7 +214,6 @@ class VoiceAgent(BaseAgent):
                 response_text=content,
                 agent_id=agent_state.id,
                 model=agent_state.llm_config.model,
-                actor=self.actor,
                 timezone=agent_state.timezone,
             )
             letta_message_db_queue.extend(assistant_msgs)
@@ -273,11 +272,9 @@ class VoiceAgent(BaseAgent):
                 function_name=tool_call_name,
                 function_arguments=tool_args,
                 tool_call_id=tool_call_id,
-                function_call_success=success_flag,
                 function_response=tool_result,
                 tool_execution_result=tool_execution_result,
                 timezone=agent_state.timezone,
-                actor=self.actor,
                 continue_stepping=True,
             )
             letta_message_db_queue.extend(tool_call_messages)
@@ -343,8 +340,7 @@ class VoiceAgent(BaseAgent):
             tools = [
                 t
                 for t in agent_state.tools
-                if t.tool_type
-                in {ToolType.EXTERNAL_COMPOSIO, ToolType.CUSTOM, ToolType.LETTA_FILES_CORE, ToolType.LETTA_BUILTIN, ToolType.EXTERNAL_MCP}
+                if t.tool_type in {ToolType.CUSTOM, ToolType.LETTA_FILES_CORE, ToolType.LETTA_BUILTIN, ToolType.EXTERNAL_MCP}
             ]
         else:
             tools = agent_state.tools
@@ -504,7 +500,7 @@ class VoiceAgent(BaseAgent):
         keyword_results = {}
         if convo_keyword_queries:
             for keyword in convo_keyword_queries:
-                messages = await self.message_manager.list_messages_for_agent_async(
+                messages = await self.message_manager.list_messages(
                     agent_id=self.agent_id,
                     actor=self.actor,
                     query_text=keyword,

letta/constants.py

@@ -13,9 +13,6 @@ API_PREFIX = "/v1"
 OLLAMA_API_PREFIX = "/v1"
 OPENAI_API_PREFIX = "/openai"
 
-COMPOSIO_ENTITY_ENV_VAR_KEY = "COMPOSIO_ENTITY"
-COMPOSIO_TOOL_TAG_NAME = "composio"
-
 MCP_CONFIG_NAME = "mcp_config.json"
 MCP_TOOL_TAG_NAME_PREFIX = "mcp"  # full format, mcp:server_name
 
@@ -89,7 +86,7 @@ SEND_MESSAGE_TOOL_NAME = "send_message"
 BASE_TOOLS = [SEND_MESSAGE_TOOL_NAME, "conversation_search", "archival_memory_insert", "archival_memory_search"]
 DEPRECATED_LETTA_TOOLS = ["archival_memory_insert", "archival_memory_search"]
 # Base memory tools CAN be edited, and are added by default by the server
-BASE_MEMORY_TOOLS = ["core_memory_append", "core_memory_replace"]
+BASE_MEMORY_TOOLS = ["core_memory_append", "core_memory_replace", "memory"]
 # New v2 collection of the base memory tools (effecitvely same as sleeptime set), to pair with memgpt_v2 prompt
 BASE_MEMORY_TOOLS_V2 = [
     "memory_replace",
@@ -98,6 +95,11 @@ BASE_MEMORY_TOOLS_V2 = [
     # "memory_rethink",
     # "memory_finish_edits",
 ]
+
+# v3 collection, currently just a omni memory tool for anthropic
+BASE_MEMORY_TOOLS_V3 = [
+    "memory",
+]
 # Base tools if the memgpt agent has enable_sleeptime on
 BASE_SLEEPTIME_CHAT_TOOLS = [SEND_MESSAGE_TOOL_NAME, "conversation_search", "archival_memory_search"]
 # Base memory tools for sleeptime agent
@@ -118,6 +120,7 @@ BASE_VOICE_SLEEPTIME_TOOLS = [
     "rethink_user_memory",
     "finish_rethinking_memory",
 ]
+
 # Multi agent tools
 MULTI_AGENT_TOOLS = ["send_message_to_agent_and_wait_for_reply", "send_message_to_agents_matching_tags", "send_message_to_agent_async"]
 LOCAL_ONLY_MULTI_AGENT_TOOLS = ["send_message_to_agent_async"]
@@ -219,6 +222,7 @@ LLM_MAX_TOKENS = {
     "gpt-5-mini-2025-08-07": 272000,
     "gpt-5-nano": 272000,
     "gpt-5-nano-2025-08-07": 272000,
+    "gpt-5-codex": 272000,
     # reasoners
     "o1": 200000,
     # "o1-pro": 200000,  # responses API only

letta/errors.py

@@ -97,6 +97,46 @@ class LettaUserNotFoundError(LettaError):
     """Error raised when a user is not found."""
 
 
+class LettaInvalidArgumentError(LettaError):
+    """Error raised when an invalid argument is provided."""
+
+    def __init__(self, message: str, argument_name: Optional[str] = None):
+        details = {"argument_name": argument_name} if argument_name else {}
+        super().__init__(message=message, code=ErrorCode.INVALID_ARGUMENT, details=details)
+
+
+class LettaMCPError(LettaError):
+    """Base error for MCP-related issues."""
+
+
+class LettaInvalidMCPSchemaError(LettaMCPError):
+    """Error raised when an invalid MCP schema is provided."""
+
+    def __init__(self, server_name: str, mcp_tool_name: str, reasons: List[str]):
+        details = {"server_name": server_name, "mcp_tool_name": mcp_tool_name, "reasons": reasons}
+        super().__init__(
+            message=f"MCP tool {mcp_tool_name} has an invalid schema and cannot be attached - reasons: {reasons}",
+            code=ErrorCode.INVALID_ARGUMENT,
+            details=details,
+        )
+
+
+class LettaMCPConnectionError(LettaMCPError):
+    """Error raised when unable to connect to MCP server."""
+
+    def __init__(self, message: str, server_name: Optional[str] = None):
+        details = {"server_name": server_name} if server_name else {}
+        super().__init__(message=message, code=ErrorCode.INTERNAL_SERVER_ERROR, details=details)
+
+
+class LettaMCPTimeoutError(LettaMCPError):
+    """Error raised when MCP server operation times out."""
+
+    def __init__(self, message: str, server_name: Optional[str] = None):
+        details = {"server_name": server_name} if server_name else {}
+        super().__init__(message=message, code=ErrorCode.TIMEOUT, details=details)
+
+
 class LettaUnexpectedStreamCancellationError(LettaError):
     """Error raised when a streaming request is terminated unexpectedly."""
 

letta/functions/function_sets/base.py

@@ -1,8 +1,82 @@
-from typing import List, Literal, Optional
+from typing import TYPE_CHECKING, Any, List, Literal, Optional
 
-from letta.agent import Agent
 from letta.constants import CORE_MEMORY_LINE_NUMBER_WARNING
 
+if TYPE_CHECKING:
+    from letta.schemas.agent import AgentState
+
+
+def memory(
+    agent_state: "AgentState",
+    command: str,
+    path: Optional[str] = None,
+    file_text: Optional[str] = None,
+    description: Optional[str] = None,
+    old_str: Optional[str] = None,
+    new_str: Optional[str] = None,
+    insert_line: Optional[int] = None,
+    insert_text: Optional[str] = None,
+    old_path: Optional[str] = None,
+    new_path: Optional[str] = None,
+) -> Optional[str]:
+    """
+    Memory management tool with various sub-commands for memory block operations.
+
+    Args:
+        command (str): The sub-command to execute. Supported commands:
+            - "view": List memory blocks or view specific block content
+            - "create": Create a new memory block
+            - "str_replace": Replace text in a memory block
+            - "insert": Insert text at a specific line in a memory block
+            - "delete": Delete a memory block
+            - "rename": Rename a memory block
+        path (Optional[str]): Path to the memory block (for str_replace, insert, delete)
+        file_text (Optional[str]): The value to set in the memory block (for create)
+        description (Optional[str]): The description to set in the memory block (for create, rename)
+        old_str (Optional[str]): Old text to replace (for str_replace)
+        new_str (Optional[str]): New text to replace with (for str_replace)
+        insert_line (Optional[int]): Line number to insert at (for insert)
+        insert_text (Optional[str]): Text to insert (for insert)
+        old_path (Optional[str]): Old path for rename operation
+        new_path (Optional[str]): New path for rename operation
+        view_range (Optional[int]): Range of lines to view (for view)
+
+    Returns:
+        Optional[str]: Success message or error description
+
+    Examples:
+        # List all memory blocks
+        memory(agent_state, "view", path="/memories")
+
+        # View specific memory block content
+        memory(agent_state, "view", path="/memories/user_preferences")
+
+        # View first 10 lines of a memory block
+        memory(agent_state, "view", path="/memories/user_preferences", view_range=10)
+
+        # Replace text in a memory block
+        memory(agent_state, "str_replace", path="/memories/user_preferences", old_str="theme: dark", new_str="theme: light")
+
+        # Insert text at line 5
+        memory(agent_state, "insert", path="/memories/notes", insert_line=5, insert_text="New note here")
+
+        # Delete a memory block
+        memory(agent_state, "delete", path="/memories/old_notes")
+
+        # Rename a memory block
+        memory(agent_state, "rename", old_path="/memories/temp", new_path="/memories/permanent")
+
+        # Update the description of a memory block
+        memory(agent_state, "rename", path="/memories/temp", description="The user's temporary notes.")
+
+        # Create a memory block with starting text
+        memory(agent_state, "create", path="/memories/coding_preferences", "description": "The user's coding preferences.", "file_text": "The user seems to add type hints to all of their Python code.")
+
+        # Create an empty memory block
+        memory(agent_state, "create", path="/memories/coding_preferences", "description": "The user's coding preferences.")
+    """
+    raise NotImplementedError("This should never be invoked directly. Contact Letta if you see this error message.")
+
 
 def send_message(self: "Agent", message: str) -> Optional[str]:
     """
@@ -202,7 +276,10 @@ def rethink_memory(agent_state: "AgentState", new_memory: str, target_block_labe
     """
 
     if agent_state.memory.get_block(target_block_label) is None:
-        agent_state.memory.create_block(label=target_block_label, value=new_memory)
+        from letta.schemas.block import Block
+
+        new_block = Block(label=target_block_label, value=new_memory)
+        agent_state.memory.set_block(new_block)
 
     agent_state.memory.update_block_value(label=target_block_label, value=new_memory)
     return None
@@ -395,7 +472,10 @@ def memory_rethink(agent_state: "AgentState", label: str, new_memory: str) -> No
         )
 
     if agent_state.memory.get_block(label) is None:
-        agent_state.memory.create_block(label=label, value=new_memory)
+        from letta.schemas.block import Block
+
+        new_block = Block(label=label, value=new_memory)
+        agent_state.memory.set_block(new_block)
 
     agent_state.memory.update_block_value(label=label, value=new_memory)
 

letta/functions/function_sets/multi_agent.py

@@ -14,9 +14,6 @@ from letta.schemas.message import MessageCreate
 from letta.server.rest_api.dependencies import get_letta_server
 from letta.settings import settings
 
-if TYPE_CHECKING:
-    from letta.agent import Agent
-
 
 def send_message_to_agent_and_wait_for_reply(self: "Agent", message: str, other_agent_id: str) -> str:
     """

letta/functions/schema_generator.py

@@ -2,7 +2,6 @@ import inspect
 import warnings
 from typing import Any, Dict, List, Optional, Tuple, Type, Union, get_args, get_origin
 
-from composio.client.collections import ActionParametersModel
 from docstring_parser import parse
 from pydantic import BaseModel
 from typing_extensions import Literal
@@ -588,11 +587,111 @@ def generate_schema_from_args_schema_v2(
     return function_call_json
 
 
+def normalize_mcp_schema(schema: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Normalize an MCP JSON schema to fix common issues:
+    1. Add explicit 'additionalProperties': false to all object types
+    2. Add explicit 'type' field to properties using $ref
+    3. Process $defs recursively
+
+    Args:
+        schema: The JSON schema to normalize (will be modified in-place)
+
+    Returns:
+        The normalized schema (same object, modified in-place)
+    """
+    import copy
+
+    # Work on a deep copy to avoid modifying the original
+    schema = copy.deepcopy(schema)
+
+    def normalize_object_schema(obj_schema: Dict[str, Any], defs: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Recursively normalize an object schema."""
+
+        # If this is an object type, add additionalProperties if missing
+        if obj_schema.get("type") == "object":
+            if "additionalProperties" not in obj_schema:
+                obj_schema["additionalProperties"] = False
+
+        # Handle properties
+        if "properties" in obj_schema:
+            for prop_name, prop_schema in obj_schema["properties"].items():
+                # Handle $ref references
+                if "$ref" in prop_schema:
+                    # Add explicit type based on the reference
+                    if "type" not in prop_schema:
+                        # Try to resolve the type from $defs if available
+                        if defs and prop_schema["$ref"].startswith("#/$defs/"):
+                            def_name = prop_schema["$ref"].split("/")[-1]
+                            if def_name in defs:
+                                ref_schema = defs[def_name]
+                                if "type" in ref_schema:
+                                    prop_schema["type"] = ref_schema["type"]
+
+                        # If still no type, assume object (common case for model references)
+                        if "type" not in prop_schema:
+                            prop_schema["type"] = "object"
+
+                    # Don't add additionalProperties to properties with $ref
+                    # The $ref schema itself will have additionalProperties
+                    # Adding it here makes the validator think it allows empty objects
+                    continue
+
+                # Recursively normalize nested objects
+                if isinstance(prop_schema, dict):
+                    if prop_schema.get("type") == "object":
+                        normalize_object_schema(prop_schema, defs)
+
+                    # Handle arrays with object items
+                    if prop_schema.get("type") == "array" and "items" in prop_schema:
+                        items = prop_schema["items"]
+                        if isinstance(items, dict):
+                            # Handle $ref in items
+                            if "$ref" in items and "type" not in items:
+                                if defs and items["$ref"].startswith("#/$defs/"):
+                                    def_name = items["$ref"].split("/")[-1]
+                                    if def_name in defs and "type" in defs[def_name]:
+                                        items["type"] = defs[def_name]["type"]
+                                if "type" not in items:
+                                    items["type"] = "object"
+
+                            # Recursively normalize items
+                            if items.get("type") == "object":
+                                normalize_object_schema(items, defs)
+
+                    # Handle anyOf (complex union types)
+                    if "anyOf" in prop_schema:
+                        for option in prop_schema["anyOf"]:
+                            if isinstance(option, dict) and option.get("type") == "object":
+                                normalize_object_schema(option, defs)
+
+        # Handle array items at the top level
+        if "items" in obj_schema and isinstance(obj_schema["items"], dict):
+            if obj_schema["items"].get("type") == "object":
+                normalize_object_schema(obj_schema["items"], defs)
+
+        return obj_schema
+
+    # Process $defs first if they exist
+    defs = schema.get("$defs", {})
+    if defs:
+        for def_name, def_schema in defs.items():
+            if isinstance(def_schema, dict):
+                normalize_object_schema(def_schema, defs)
+
+    # Process the main schema
+    normalize_object_schema(schema, defs)
+
+    return schema
+
+
 def generate_tool_schema_for_mcp(
     mcp_tool: MCPTool,
     append_heartbeat: bool = True,
     strict: bool = False,
 ) -> Dict[str, Any]:
+    from letta.functions.schema_validator import validate_complete_json_schema
+
     # MCP tool.inputSchema is a JSON schema
     # https://github.com/modelcontextprotocol/python-sdk/blob/775f87981300660ee957b63c2a14b448ab9c3675/src/mcp/types.py#L678
     parameters_schema = mcp_tool.inputSchema
@@ -603,11 +702,16 @@ def generate_tool_schema_for_mcp(
     assert "properties" in parameters_schema, parameters_schema
     # assert "required" in parameters_schema, parameters_schema
 
+    # Normalize the schema to fix common issues with MCP schemas
+    # This adds additionalProperties: false and explicit types for $ref properties
+    parameters_schema = normalize_mcp_schema(parameters_schema)
+
     # Zero-arg tools often omit "required" because nothing is required.
     # Normalise so downstream code can treat it consistently.
     parameters_schema.setdefault("required", [])
 
     # Process properties to handle anyOf types and make optional fields strict-compatible
+    # TODO: de-duplicate with handling in normalize_mcp_schema
     if "properties" in parameters_schema:
         for field_name, field_props in parameters_schema["properties"].items():
             # Handle anyOf types by flattening to type array
@@ -660,6 +764,14 @@ def generate_tool_schema_for_mcp(
         if REQUEST_HEARTBEAT_PARAM not in parameters_schema["required"]:
             parameters_schema["required"].append(REQUEST_HEARTBEAT_PARAM)
 
+    # Re-validate the schema after normalization and update the health status
+    # This allows previously INVALID schemas to pass if normalization fixed them
+    if mcp_tool.health:
+        health_status, health_reasons = validate_complete_json_schema(parameters_schema)
+        mcp_tool.health.status = health_status.value
+        mcp_tool.health.reasons = health_reasons
+        logger.debug(f"MCP tool {name} schema health after normalization: {health_status.value}, reasons: {health_reasons}")
+
     # Return the final schema
     if strict:
         # https://platform.openai.com/docs/guides/function-calling#strict-mode
@@ -679,73 +791,3 @@ def generate_tool_schema_for_mcp(
             "description": description,
             "parameters": parameters_schema,
         }
-
-
-def generate_tool_schema_for_composio(
-    parameters_model: ActionParametersModel,
-    name: str,
-    description: str,
-    append_heartbeat: bool = True,
-    strict: bool = False,
-) -> Dict[str, Any]:
-    properties_json = {}
-    required_fields = parameters_model.required or []
-
-    # Extract properties from the ActionParametersModel
-    for field_name, field_props in parameters_model.properties.items():
-        # Initialize the property structure
-        property_schema = {
-            "type": field_props["type"],
-            "description": field_props.get("description", ""),
-        }
-
-        # Handle optional default values
-        if "default" in field_props:
-            property_schema["default"] = field_props["default"]
-
-        # Handle enumerations
-        if "enum" in field_props:
-            property_schema["enum"] = field_props["enum"]
-
-        # Handle array item types
-        if field_props["type"] == "array":
-            if "items" in field_props:
-                property_schema["items"] = field_props["items"]
-            elif "anyOf" in field_props:
-                property_schema["items"] = [t for t in field_props["anyOf"] if "items" in t][0]["items"]
-
-        # Add the property to the schema
-        properties_json[field_name] = property_schema
-
-    # Add the optional heartbeat parameter
-    if append_heartbeat:
-        properties_json[REQUEST_HEARTBEAT_PARAM] = {
-            "type": "boolean",
-            "description": REQUEST_HEARTBEAT_DESCRIPTION,
-        }
-        required_fields.append(REQUEST_HEARTBEAT_PARAM)
-
-    # Return the final schema
-    if strict:
-        # https://platform.openai.com/docs/guides/function-calling#strict-mode
-        return {
-            "name": name,
-            "description": description,
-            "strict": True,  # NOTE
-            "parameters": {
-                "type": "object",
-                "properties": properties_json,
-                "additionalProperties": False,  # NOTE
-                "required": required_fields,
-            },
-        }
-    else:
-        return {
-            "name": name,
-            "description": description,
-            "parameters": {
-                "type": "object",
-                "properties": properties_json,
-                "required": required_fields,
-            },
-        }

letta/groups/dynamic_multi_agent.py

@@ -1,8 +1,9 @@
 from typing import List, Optional
 
-from letta.agent import Agent, AgentState
+from letta.agents.base_agent import BaseAgent
 from letta.interface import AgentInterface
 from letta.orm import User
+from letta.schemas.agent import AgentState
 from letta.schemas.block import Block
 from letta.schemas.letta_message_content import TextContent
 from letta.schemas.message import Message, MessageCreate
@@ -11,7 +12,7 @@ from letta.schemas.usage import LettaUsageStatistics
 from letta.services.tool_manager import ToolManager
 
 
-class DynamicMultiAgent(Agent):
+class DynamicMultiAgent(BaseAgent):
     def __init__(
         self,
         interface: AgentInterface,

letta/groups/helpers.py

@@ -1,7 +1,6 @@
 import json
 from typing import Dict, Optional, Union
 
-from letta.agent import Agent
 from letta.interface import AgentInterface
 from letta.orm.group import Group
 from letta.orm.user import User
@@ -18,7 +17,7 @@ def load_multi_agent(
     actor: User,
     interface: Union[AgentInterface, None] = None,
     mcp_clients: Optional[Dict[str, AsyncBaseMCPClient]] = None,
-) -> Agent:
+) -> "Agent":
     if len(group.agent_ids) == 0:
         raise ValueError("Empty group: group must have at least one agent")
 

letta/groups/round_robin_multi_agent.py

@@ -1,15 +1,16 @@
 from typing import List, Optional
 
-from letta.agent import Agent, AgentState
+from letta.agents.base_agent import BaseAgent
 from letta.interface import AgentInterface
 from letta.orm import User
+from letta.schemas.agent import AgentState
 from letta.schemas.letta_message_content import TextContent
 from letta.schemas.message import Message, MessageCreate
 from letta.schemas.openai.chat_completion_response import UsageStatistics
 from letta.schemas.usage import LettaUsageStatistics
 
 
-class RoundRobinMultiAgent(Agent):
+class RoundRobinMultiAgent(BaseAgent):
     def __init__(
         self,
         interface: AgentInterface,

letta/groups/sleeptime_multi_agent.py

@@ -3,10 +3,11 @@ import threading
 from datetime import datetime, timezone
 from typing import List, Optional
 
-from letta.agent import Agent, AgentState
+from letta.agents.base_agent import BaseAgent
 from letta.groups.helpers import stringify_message
 from letta.interface import AgentInterface
 from letta.orm import User
+from letta.schemas.agent import AgentState
 from letta.schemas.enums import JobStatus
 from letta.schemas.job import JobUpdate
 from letta.schemas.letta_message_content import TextContent
@@ -19,7 +20,7 @@ from letta.services.job_manager import JobManager
 from letta.services.message_manager import MessageManager
 
 
-class SleeptimeMultiAgent(Agent):
+class SleeptimeMultiAgent(BaseAgent):
     def __init__(
         self,
         interface: AgentInterface,

letta/groups/sleeptime_multi_agent_v2.py

@@ -268,7 +268,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
             prior_messages = []
             if self.group.sleeptime_agent_frequency:
                 try:
-                    prior_messages = await self.message_manager.list_messages_for_agent_async(
+                    prior_messages = await self.message_manager.list_messages(
                         agent_id=foreground_agent_id,
                         actor=self.actor,
                         after=last_processed_message_id,

letta/groups/sleeptime_multi_agent_v3.py

@@ -7,14 +7,14 @@ from letta.constants import DEFAULT_MAX_STEPS
 from letta.groups.helpers import stringify_message
 from letta.otel.tracing import trace_method
 from letta.schemas.agent import AgentState
-from letta.schemas.enums import JobStatus
+from letta.schemas.enums import JobStatus, RunStatus
 from letta.schemas.group import Group, ManagerType
 from letta.schemas.job import JobUpdate
 from letta.schemas.letta_message import MessageType
 from letta.schemas.letta_message_content import TextContent
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.message import Message, MessageCreate
-from letta.schemas.run import Run
+from letta.schemas.run import Run, RunUpdate
 from letta.schemas.user import User
 from letta.services.group_manager import GroupManager
 from letta.utils import safe_create_task
@@ -134,14 +134,14 @@ class SleeptimeMultiAgentV3(LettaAgentV2):
         use_assistant_message: bool = True,
     ) -> str:
         run = Run(
-            user_id=self.actor.id,
-            status=JobStatus.created,
+            agent_id=sleeptime_agent_id,
+            status=RunStatus.created,
             metadata={
-                "job_type": "sleeptime_agent_send_message_async",  # is this right?
+                "run_type": "sleeptime_agent_send_message_async",  # is this right?
                 "agent_id": sleeptime_agent_id,
             },
         )
-        run = await self.job_manager.create_job_async(pydantic_job=run, actor=self.actor)
+        run = await self.run_manager.create_run(pydantic_run=run, actor=self.actor)
 
         safe_create_task(
             self._participant_agent_step(
@@ -167,15 +167,15 @@ class SleeptimeMultiAgentV3(LettaAgentV2):
         use_assistant_message: bool = True,
     ) -> LettaResponse:
         try:
-            # Update job status
-            job_update = JobUpdate(status=JobStatus.running)
-            await self.job_manager.update_job_by_id_async(job_id=run_id, job_update=job_update, actor=self.actor)
+            # Update run status
+            run_update = RunUpdate(status=RunStatus.running)
+            await self.run_manager.update_run_by_id_async(run_id=run_id, update=run_update, actor=self.actor)
 
             # Create conversation transcript
             prior_messages = []
             if self.group.sleeptime_agent_frequency:
                 try:
-                    prior_messages = await self.message_manager.list_messages_for_agent_async(
+                    prior_messages = await self.message_manager.list_messages(
                         agent_id=foreground_agent_id,
                         actor=self.actor,
                         after=last_processed_message_id,
@@ -212,22 +212,22 @@ class SleeptimeMultiAgentV3(LettaAgentV2):
                 use_assistant_message=use_assistant_message,
             )
 
-            # Update job status
-            job_update = JobUpdate(
-                status=JobStatus.completed,
+            # Update run status
+            run_update = RunUpdate(
+                status=RunStatus.completed,
                 completed_at=datetime.now(timezone.utc).replace(tzinfo=None),
                 metadata={
                     "result": result.model_dump(mode="json"),
                     "agent_id": sleeptime_agent_state.id,
                 },
             )
-            await self.job_manager.update_job_by_id_async(job_id=run_id, job_update=job_update, actor=self.actor)
+            await self.run_manager.update_run_by_id_async(run_id=run_id, update=run_update, actor=self.actor)
             return result
         except Exception as e:
-            job_update = JobUpdate(
-                status=JobStatus.failed,
+            run_update = RunUpdate(
+                status=RunStatus.failed,
                 completed_at=datetime.now(timezone.utc).replace(tzinfo=None),
                 metadata={"error": str(e)},
             )
-            await self.job_manager.update_job_by_id_async(job_id=run_id, job_update=job_update, actor=self.actor)
+            await self.run_manager.update_run_by_id_async(run_id=run_id, update=run_update, actor=self.actor)
             raise