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

letta/services/tool_executor/core_tool_executor.py

@@ -11,6 +11,7 @@ from letta.constants import (
 from letta.helpers.json_helpers import json_dumps
 from letta.log import get_logger
 from letta.schemas.agent import AgentState
+from letta.schemas.block import BlockUpdate
 from letta.schemas.enums import MessageRole, TagMatchMode
 from letta.schemas.sandbox_config import SandboxConfig
 from letta.schemas.tool import Tool
@@ -46,8 +47,11 @@ class LettaCoreToolExecutor(ToolExecutor):
             "core_memory_replace": self.core_memory_replace,
             "memory_replace": self.memory_replace,
             "memory_insert": self.memory_insert,
+            "memory_str_replace": self.memory_str_replace,
+            "memory_str_insert": self.memory_str_insert,
             "memory_rethink": self.memory_rethink,
             "memory_finish_edits": self.memory_finish_edits,
+            "memory": self.memory,
         }
 
         if function_name not in function_map:
@@ -479,8 +483,14 @@ class LettaCoreToolExecutor(ToolExecutor):
                 "are for display purposes only)."
             )
 
-        if agent_state.memory.get_block(label) is None:
-            agent_state.memory.create_block(label=label, value=new_memory)
+        try:
+            agent_state.memory.get_block(label)
+        except KeyError:
+            # Block doesn't exist, create it
+            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)
 
@@ -502,3 +512,388 @@ class LettaCoreToolExecutor(ToolExecutor):
 
     async def memory_finish_edits(self, agent_state: AgentState, actor: User) -> None:
         return None
+
+    async def memory_delete(self, agent_state: AgentState, actor: User, path: str) -> str:
+        """Delete a memory block by detaching it from the agent."""
+        # Extract memory block label from path
+        label = path.removeprefix("/memories/").replace("/", "_")
+
+        try:
+            # Check if memory block exists
+            memory_block = agent_state.memory.get_block(label)
+            if memory_block is None:
+                raise ValueError(f"Error: Memory block '{label}' does not exist")
+
+            # Detach the block from the agent
+            updated_agent_state = await self.agent_manager.detach_block_async(
+                agent_id=agent_state.id, block_id=memory_block.id, actor=actor
+            )
+
+            # Update the agent state with the updated memory from the database
+            agent_state.memory = updated_agent_state.memory
+
+            return f"Successfully deleted memory block '{label}'"
+
+        except Exception as e:
+            return f"Error performing delete: {str(e)}"
+
+    async def memory_update_description(self, agent_state: AgentState, actor: User, path: str, description: str) -> str:
+        """Update the description of a memory block."""
+        label = path.removeprefix("/memories/").replace("/", "_")
+
+        try:
+            # Check if old memory block exists
+            memory_block = agent_state.memory.get_block(label)
+            if memory_block is None:
+                raise ValueError(f"Error: Memory block '{label}' does not exist")
+
+            await self.block_manager.update_block_async(
+                block_id=memory_block.id, block_update=BlockUpdate(description=description), actor=actor
+            )
+            await self.agent_manager.rebuild_system_prompt_async(agent_id=agent_state.id, actor=actor, force=True)
+
+            return f"Successfully updated description of memory block '{label}'"
+
+        except Exception as e:
+            raise Exception(f"Error performing update_description: {str(e)}")
+
+    async def memory_rename(self, agent_state: AgentState, actor: User, old_path: str, new_path: str) -> str:
+        """Rename a memory block by copying content to new label and detaching old one."""
+        # Extract memory block labels from paths
+        old_label = old_path.removeprefix("/memories/").replace("/", "_")
+        new_label = new_path.removeprefix("/memories/").replace("/", "_")
+
+        try:
+            # Check if old memory block exists
+            memory_block = agent_state.memory.get_block(old_label)
+            if memory_block is None:
+                raise ValueError(f"Error: Memory block '{old_label}' does not exist")
+
+            await self.block_manager.update_block_async(block_id=memory_block.id, block_update=BlockUpdate(label=new_label), actor=actor)
+            await self.agent_manager.rebuild_system_prompt_async(agent_id=agent_state.id, actor=actor, force=True)
+
+            return f"Successfully renamed memory block '{old_label}' to '{new_label}'"
+
+        except Exception as e:
+            raise Exception(f"Error performing rename: {str(e)}")
+
+    async def memory_view(self, agent_state: AgentState, actor: User, path: str, view_range: Optional[int] = None) -> str:
+        """View the content of a memory block with optional line range."""
+        try:
+            # Special case: if path is "/memories", list all blocks
+            if path == "/memories":
+                blocks = agent_state.memory.get_blocks()
+
+                if not blocks:
+                    raise ValueError("No memory blocks found.")
+
+                result_lines = [f"Found {len(blocks)} memory block(s):\n"]
+
+                for i, block in enumerate(blocks, 1):
+                    content = str(block.value)
+                    content_length = len(content)
+                    line_count = len(content.split("\n")) if content else 0
+
+                    # Basic info
+                    block_info = [f"{i}. {block.label}"]
+
+                    # Add description if available
+                    if block.description:
+                        block_info.append(f"   Description: {block.description}")
+
+                    # Add read-only status
+                    if block.read_only:
+                        block_info.append("   Read-only: true")
+
+                    # Add content stats
+                    block_info.append(f"   Character limit: {block.limit}")
+                    block_info.append(f"   Current length: {content_length} characters")
+                    block_info.append(f"   Lines: {line_count}")
+
+                    # Add content preview (first 100 characters)
+                    if content:
+                        preview = content[:100].replace("\n", "\\n")
+                        if len(content) > 100:
+                            preview += "..."
+                        block_info.append(f"   Preview: {preview}")
+                    else:
+                        block_info.append("   Preview: (empty)")
+
+                    result_lines.append("\n".join(block_info))
+                    if i < len(blocks):  # Add separator between blocks
+                        result_lines.append("")
+
+                return "\n".join(result_lines)
+
+            # Extract memory block label from path (e.g., "/memories/preferences.txt" -> "preferences.txt")
+            if path.startswith("/memories/"):
+                label = path[10:]  # Remove "/memories/" prefix
+            else:
+                label = path
+
+            # Get the memory block
+            memory_block = agent_state.memory.get_block(label)
+            if memory_block is None:
+                raise ValueError(f"Error: Memory block '{label}' does not exist")
+
+            # Get the content
+            content = str(memory_block.value)
+            if not content:
+                raise ValueError(f"Memory block '{label}' is empty")
+
+            # Split content into lines
+            lines = content.split("\n")
+            total_lines = len(lines)
+
+            # Handle view_range parameter
+            if view_range is not None:
+                if view_range <= 0:
+                    raise ValueError(f"Error: view_range must be positive, got {view_range}")
+
+                # Show only the first view_range lines
+                lines_to_show = lines[:view_range]
+                range_info = f" (showing first {view_range} of {total_lines} lines)"
+            else:
+                lines_to_show = lines
+                range_info = f" ({total_lines} lines total)"
+
+            # Format output with line numbers
+            numbered_lines = []
+            for i, line in enumerate(lines_to_show, start=1):
+                numbered_lines.append(f"Line {i}: {line}")
+
+            numbered_content = "\n".join(numbered_lines)
+
+            # Add metadata information
+            metadata_info = []
+            if memory_block.description:
+                metadata_info.append(f"Description: {memory_block.description}")
+            if memory_block.read_only:
+                metadata_info.append("Read-only: true")
+            metadata_info.append(f"Character limit: {memory_block.limit}")
+            metadata_info.append(f"Current length: {len(content)} characters")
+
+            metadata_str = "\n".join(metadata_info)
+
+            result = f"Memory block: {label}{range_info}\n"
+            result += f"Metadata:\n{metadata_str}\n\n"
+            result += f"Content:\n{numbered_content}"
+
+            return result
+
+        except KeyError:
+            raise ValueError(f"Error: Memory block '{label}' does not exist")
+        except Exception as e:
+            raise Exception(f"Error viewing memory block: {str(e)}")
+
+    async def memory_create(
+        self, agent_state: AgentState, actor: User, path: str, description: str, file_text: Optional[str] = None
+    ) -> str:
+        """Create a memory block by setting its value to an empty string."""
+        from letta.schemas.block import Block
+
+        label = path.removeprefix("/memories/").replace("/", "_")
+
+        # Create a new block and persist it to the database
+        new_block = Block(label=label, value=file_text if file_text else "", description=description)
+        persisted_block = await self.block_manager.create_or_update_block_async(new_block, actor)
+
+        # Attach the block to the agent
+        await self.agent_manager.attach_block_async(agent_id=agent_state.id, block_id=persisted_block.id, actor=actor)
+
+        # Add the persisted block to memory
+        agent_state.memory.set_block(persisted_block)
+
+        await self.agent_manager.update_memory_if_changed_async(agent_id=agent_state.id, new_memory=agent_state.memory, actor=actor)
+        return f"Successfully created memory block '{label}'"
+
+    async def memory_str_replace(self, agent_state: AgentState, actor: User, path: str, old_str: str, new_str: str) -> str:
+        """Replace text in a memory block."""
+        label = path.removeprefix("/memories/").replace("/", "_")
+
+        memory_block = agent_state.memory.get_block(label)
+        if memory_block is None:
+            raise ValueError(f"Error: Memory block '{label}' does not exist")
+
+        if memory_block.read_only:
+            raise ValueError(f"{READ_ONLY_BLOCK_EDIT_ERROR}")
+
+        if bool(MEMORY_TOOLS_LINE_NUMBER_PREFIX_REGEX.search(old_str)):
+            raise ValueError(
+                "old_str contains a line number prefix, which is not allowed. "
+                "Do not include line numbers when calling memory tools (line "
+                "numbers are for display purposes only)."
+            )
+        if CORE_MEMORY_LINE_NUMBER_WARNING in old_str:
+            raise ValueError(
+                "old_str contains a line number warning, which is not allowed. "
+                "Do not include line number information when calling memory tools "
+                "(line numbers are for display purposes only)."
+            )
+        if bool(MEMORY_TOOLS_LINE_NUMBER_PREFIX_REGEX.search(new_str)):
+            raise ValueError(
+                "new_str contains a line number prefix, which is not allowed. "
+                "Do not include line numbers when calling memory tools (line "
+                "numbers are for display purposes only)."
+            )
+
+        old_str = str(old_str).expandtabs()
+        new_str = str(new_str).expandtabs()
+        current_value = str(memory_block.value).expandtabs()
+
+        # Check if old_str is unique in the block
+        occurences = current_value.count(old_str)
+        if occurences == 0:
+            raise ValueError(
+                f"No replacement was performed, old_str `{old_str}` did not appear verbatim in memory block with label `{label}`."
+            )
+        elif occurences > 1:
+            content_value_lines = current_value.split("\n")
+            lines = [idx + 1 for idx, line in enumerate(content_value_lines) if old_str in line]
+            raise ValueError(
+                f"No replacement was performed. Multiple occurrences of old_str `{old_str}` in lines {lines}. Please ensure it is unique."
+            )
+
+        # Replace old_str with new_str
+        new_value = current_value.replace(str(old_str), str(new_str))
+
+        # Write the new content to the block
+        await self.block_manager.update_block_async(block_id=memory_block.id, block_update=BlockUpdate(value=new_value), actor=actor)
+        await self.agent_manager.rebuild_system_prompt_async(agent_id=agent_state.id, actor=actor, force=True)
+
+        # Prepare the success message
+        success_msg = f"The core memory block with label `{label}` has been edited. "
+        success_msg += (
+            "Review the changes and make sure they are as expected (correct indentation, "
+            "no duplicate lines, etc). Edit the memory block again if necessary."
+        )
+
+        return success_msg
+
+    async def memory_str_insert(self, agent_state: AgentState, actor: User, path: str, insert_text: str, insert_line: int = -1) -> str:
+        """Insert text into a memory block at a specific line."""
+        label = path.removeprefix("/memories/").replace("/", "_")
+
+        memory_block = agent_state.memory.get_block(label)
+        if memory_block is None:
+            raise ValueError(f"Error: Memory block '{label}' does not exist")
+
+        if memory_block.read_only:
+            raise ValueError(f"{READ_ONLY_BLOCK_EDIT_ERROR}")
+
+        if bool(MEMORY_TOOLS_LINE_NUMBER_PREFIX_REGEX.search(insert_text)):
+            raise ValueError(
+                "insert_text contains a line number prefix, which is not allowed. "
+                "Do not include line numbers when calling memory tools (line "
+                "numbers are for display purposes only)."
+            )
+        if CORE_MEMORY_LINE_NUMBER_WARNING in insert_text:
+            raise ValueError(
+                "insert_text contains a line number warning, which is not allowed. "
+                "Do not include line number information when calling memory tools "
+                "(line numbers are for display purposes only)."
+            )
+
+        current_value = str(memory_block.value).expandtabs()
+        insert_text = str(insert_text).expandtabs()
+        current_value_lines = current_value.split("\n")
+        n_lines = len(current_value_lines)
+
+        # Check if we're in range, from 0 (pre-line), to 1 (first line), to n_lines (last line)
+        if insert_line == -1:
+            insert_line = n_lines
+        elif insert_line < 0 or insert_line > n_lines:
+            raise ValueError(
+                f"Invalid `insert_line` parameter: {insert_line}. It should be within "
+                f"the range of lines of the memory block: {[0, n_lines]}, or -1 to "
+                f"append to the end of the memory block."
+            )
+
+        # Insert the new text as a line
+        SNIPPET_LINES = 3
+        insert_text_lines = insert_text.split("\n")
+        new_value_lines = current_value_lines[:insert_line] + insert_text_lines + current_value_lines[insert_line:]
+        snippet_lines = (
+            current_value_lines[max(0, insert_line - SNIPPET_LINES) : insert_line]
+            + insert_text_lines
+            + current_value_lines[insert_line : insert_line + SNIPPET_LINES]
+        )
+
+        # Collate into the new value to update
+        new_value = "\n".join(new_value_lines)
+        snippet = "\n".join(snippet_lines)
+
+        # Write into the block
+        await self.block_manager.update_block_async(block_id=memory_block.id, block_update=BlockUpdate(value=new_value), actor=actor)
+        await self.agent_manager.rebuild_system_prompt_async(agent_id=agent_state.id, actor=actor, force=True)
+
+        # Prepare the success message
+        success_msg = f"The core memory block with label `{label}` has been edited. "
+        success_msg += (
+            "Review the changes and make sure they are as expected (correct indentation, "
+            "no duplicate lines, etc). Edit the memory block again if necessary."
+        )
+
+        return success_msg
+
+    async def memory(
+        self,
+        agent_state: AgentState,
+        actor: User,
+        command: str,
+        file_text: Optional[str] = None,
+        description: Optional[str] = None,
+        path: 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,
+        view_range: Optional[int] = None,
+    ) -> Optional[str]:
+        if command == "view":
+            if path is None:
+                raise ValueError("Error: path is required for view command")
+            return await self.memory_view(agent_state, actor, path, view_range)
+
+        elif command == "create":
+            if path is None:
+                raise ValueError("Error: path is required for create command")
+            if description is None:
+                raise ValueError("Error: description is required for create command")
+            return await self.memory_create(agent_state, actor, path, description, file_text)
+
+        elif command == "str_replace":
+            if path is None:
+                raise ValueError("Error: path is required for str_replace command")
+            if old_str is None:
+                raise ValueError("Error: old_str is required for str_replace command")
+            if new_str is None:
+                raise ValueError("Error: new_str is required for str_replace command")
+            return await self.memory_str_replace(agent_state, actor, path, old_str, new_str)
+
+        elif command == "insert":
+            if path is None:
+                raise ValueError("Error: path is required for insert command")
+            if insert_text is None:
+                raise ValueError("Error: insert_text is required for insert command")
+            return await self.memory_str_insert(agent_state, actor, path, insert_text, insert_line)
+
+        elif command == "delete":
+            if path is None:
+                raise ValueError("Error: path is required for delete command")
+            return await self.memory_delete(agent_state, actor, path)
+
+        elif command == "rename":
+            if path and description:
+                return await self.memory_update_description(agent_state, actor, path, description)
+            elif old_path and new_path:
+                return await self.memory_rename(agent_state, actor, old_path, new_path)
+            else:
+                raise ValueError(
+                    "Error: path and description are required for update_description command, or old_path and new_path are required for rename command"
+                )
+
+        else:
+            raise ValueError(f"Error: Unknown command '{command}'. Supported commands: str_replace, str_insert, insert, delete, rename")

letta/services/tool_executor/files_tool_executor.py

@@ -20,9 +20,9 @@ from letta.services.block_manager import BlockManager
 from letta.services.file_manager import FileManager
 from letta.services.file_processor.chunker.line_chunker import LineChunker
 from letta.services.files_agents_manager import FileAgentManager
-from letta.services.job_manager import JobManager
 from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
+from letta.services.run_manager import RunManager
 from letta.services.source_manager import SourceManager
 from letta.services.tool_executor.tool_executor_base import ToolExecutor
 from letta.utils import get_friendly_error_msg
@@ -47,7 +47,7 @@ class LettaFileToolExecutor(ToolExecutor):
         message_manager: MessageManager,
         agent_manager: AgentManager,
         block_manager: BlockManager,
-        job_manager: JobManager,
+        run_manager: RunManager,
         passage_manager: PassageManager,
         actor: User,
     ):
@@ -55,7 +55,7 @@ class LettaFileToolExecutor(ToolExecutor):
             message_manager=message_manager,
             agent_manager=agent_manager,
             block_manager=block_manager,
-            job_manager=job_manager,
+            run_manager=run_manager,
             passage_manager=passage_manager,
             actor=actor,
         )

letta/services/tool_executor/multi_agent_tool_executor.py

@@ -7,10 +7,12 @@ from letta.schemas.enums import MessageRole
 from letta.schemas.letta_message import AssistantMessage
 from letta.schemas.letta_message_content import TextContent
 from letta.schemas.message import MessageCreate
+from letta.schemas.run import Run
 from letta.schemas.sandbox_config import SandboxConfig
 from letta.schemas.tool import Tool
 from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.schemas.user import User
+from letta.services.run_manager import RunManager
 from letta.services.tool_executor.tool_executor_base import ToolExecutor
 from letta.settings import settings
 from letta.utils import safe_create_task
@@ -43,13 +45,15 @@ class LettaMultiAgentToolExecutor(ToolExecutor):
 
         # Execute the appropriate function
         function_args_copy = function_args.copy()  # Make a copy to avoid modifying the original
-        function_response = await function_map[function_name](agent_state, **function_args_copy)
+        function_response = await function_map[function_name](agent_state, actor, **function_args_copy)
         return ToolExecutionResult(
             status="success",
             func_return=function_response,
         )
 
-    async def send_message_to_agent_and_wait_for_reply(self, agent_state: AgentState, message: str, other_agent_id: str) -> str:
+    async def send_message_to_agent_and_wait_for_reply(
+        self, agent_state: AgentState, actor: User, message: str, other_agent_id: str
+    ) -> str:
         augmented_message = (
             f"[Incoming message from agent with ID '{agent_state.id}' - to reply to this message, "
             f"make sure to use the 'send_message' at the end, and the system will notify the sender of your response] "
@@ -57,10 +61,10 @@ class LettaMultiAgentToolExecutor(ToolExecutor):
         )
 
         other_agent_state = await self.agent_manager.get_agent_by_id_async(agent_id=other_agent_id, actor=self.actor)
-        return str(await self._process_agent(agent_state=other_agent_state, message=augmented_message))
+        return str(await self._process_agent(agent_state=other_agent_state, message=augmented_message, actor=actor))
 
     async def send_message_to_agents_matching_tags_async(
-        self, agent_state: AgentState, message: str, match_all: List[str], match_some: List[str]
+        self, agent_state: AgentState, actor: User, message: str, match_all: List[str], match_some: List[str]
     ) -> str:
         # Find matching agents
         matching_agents = await self.agent_manager.list_agents_matching_tags_async(
@@ -76,25 +80,36 @@ class LettaMultiAgentToolExecutor(ToolExecutor):
             f"{message}"
         )
 
-        tasks = [
-            safe_create_task(
-                self._process_agent(agent_state=agent_state, message=augmented_message), label=f"process_agent_{agent_state.id}"
-            )
-            for agent_state in matching_agents
-        ]
-        results = await asyncio.gather(*tasks)
+        # Run concurrent requests and collect their return values.
+        # Note: Do not wrap with safe_create_task here — it swallows return values (returns None).
+        coros = [self._process_agent(agent_state=a_state, message=augmented_message, actor=actor) for a_state in matching_agents]
+        results = await asyncio.gather(*coros)
         return str(results)
 
-    async def _process_agent(self, agent_state: AgentState, message: str) -> Dict[str, Any]:
+    async def _process_agent(self, agent_state: AgentState, message: str, actor: User) -> Dict[str, Any]:
         from letta.agents.letta_agent_v2 import LettaAgentV2
 
         try:
+            runs_manager = RunManager()
+            run = await runs_manager.create_run(
+                pydantic_run=Run(
+                    agent_id=agent_state.id,
+                    background=False,
+                    metadata={
+                        "run_type": "agent_send_message_to_agent",  # TODO: Make this a constant
+                    },
+                ),
+                actor=actor,
+            )
+
             letta_agent = LettaAgentV2(
                 agent_state=agent_state,
                 actor=self.actor,
             )
 
-            letta_response = await letta_agent.step([MessageCreate(role=MessageRole.system, content=[TextContent(text=message)])])
+            letta_response = await letta_agent.step(
+                [MessageCreate(role=MessageRole.system, content=[TextContent(text=message)])], run_id=run.id
+            )
             messages = letta_response.messages
 
             send_message_content = [message.content for message in messages if isinstance(message, AssistantMessage)]
@@ -111,7 +126,7 @@ class LettaMultiAgentToolExecutor(ToolExecutor):
                 "type": type(e).__name__,
             }
 
-    async def send_message_to_agent_async(self, agent_state: AgentState, message: str, other_agent_id: str) -> str:
+    async def send_message_to_agent_async(self, agent_state: AgentState, actor: User, message: str, other_agent_id: str) -> str:
         if settings.environment == "PRODUCTION":
             raise RuntimeError("This tool is not allowed to be run on Letta Cloud.")
 
@@ -125,7 +140,7 @@ class LettaMultiAgentToolExecutor(ToolExecutor):
 
         other_agent_state = await self.agent_manager.get_agent_by_id_async(agent_id=other_agent_id, actor=self.actor)
         task = safe_create_task(
-            self._process_agent(agent_state=other_agent_state, message=prefixed), label=f"send_message_to_{other_agent_id}"
+            self._process_agent(agent_state=other_agent_state, message=prefixed, actor=actor), label=f"send_message_to_{other_agent_id}"
         )
 
         task.add_done_callback(lambda t: (logger.error(f"Async send_message task failed: {t.exception()}") if t.exception() else None))

letta/services/tool_executor/tool_execution_manager.py

@@ -16,11 +16,10 @@ from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.schemas.user import User
 from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
-from letta.services.job_manager import JobManager
 from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
+from letta.services.run_manager import RunManager
 from letta.services.tool_executor.builtin_tool_executor import LettaBuiltinToolExecutor
-from letta.services.tool_executor.composio_tool_executor import ExternalComposioToolExecutor
 from letta.services.tool_executor.core_tool_executor import LettaCoreToolExecutor
 from letta.services.tool_executor.files_tool_executor import LettaFileToolExecutor
 from letta.services.tool_executor.mcp_tool_executor import ExternalMCPToolExecutor
@@ -40,7 +39,6 @@ class ToolExecutorFactory:
         ToolType.LETTA_MULTI_AGENT_CORE: LettaMultiAgentToolExecutor,
         ToolType.LETTA_BUILTIN: LettaBuiltinToolExecutor,
         ToolType.LETTA_FILES_CORE: LettaFileToolExecutor,
-        ToolType.EXTERNAL_COMPOSIO: ExternalComposioToolExecutor,
         ToolType.EXTERNAL_MCP: ExternalMCPToolExecutor,
     }
 
@@ -51,7 +49,7 @@ class ToolExecutorFactory:
         message_manager: MessageManager,
         agent_manager: AgentManager,
         block_manager: BlockManager,
-        job_manager: JobManager,
+        run_manager: RunManager,
         passage_manager: PassageManager,
         actor: User,
     ) -> ToolExecutor:
@@ -61,7 +59,7 @@ class ToolExecutorFactory:
             message_manager=message_manager,
             agent_manager=agent_manager,
             block_manager=block_manager,
-            job_manager=job_manager,
+            run_manager=run_manager,
             passage_manager=passage_manager,
             actor=actor,
         )
@@ -75,7 +73,7 @@ class ToolExecutionManager:
         message_manager: MessageManager,
         agent_manager: AgentManager,
         block_manager: BlockManager,
-        job_manager: JobManager,
+        run_manager: RunManager,
         passage_manager: PassageManager,
         actor: User,
         agent_state: Optional[AgentState] = None,
@@ -85,7 +83,7 @@ class ToolExecutionManager:
         self.message_manager = message_manager
         self.agent_manager = agent_manager
         self.block_manager = block_manager
-        self.job_manager = job_manager
+        self.run_manager = run_manager
         self.passage_manager = passage_manager
         self.agent_state = agent_state
         self.logger = get_logger(__name__)
@@ -107,7 +105,7 @@ class ToolExecutionManager:
                 message_manager=self.message_manager,
                 agent_manager=self.agent_manager,
                 block_manager=self.block_manager,
-                job_manager=self.job_manager,
+                run_manager=self.run_manager,
                 passage_manager=self.passage_manager,
                 actor=self.actor,
             )

letta/services/tool_executor/tool_executor_base.py

@@ -8,9 +8,9 @@ from letta.schemas.tool_execution_result import ToolExecutionResult
 from letta.schemas.user import User
 from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
-from letta.services.job_manager import JobManager
 from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
+from letta.services.run_manager import RunManager
 
 
 class ToolExecutor(ABC):
@@ -21,14 +21,14 @@ class ToolExecutor(ABC):
         message_manager: MessageManager,
         agent_manager: AgentManager,
         block_manager: BlockManager,
-        job_manager: JobManager,
+        run_manager: RunManager,
         passage_manager: PassageManager,
         actor: User,
     ):
         self.message_manager = message_manager
         self.agent_manager = agent_manager
         self.block_manager = block_manager
-        self.job_manager = job_manager
+        self.run_manager = run_manager
         self.passage_manager = passage_manager
         self.actor = actor