letta-nightly 0.11.7.dev20251007104119__py3-none-any.whl → 0.12.0.dev20251009104148__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/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/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")