fast-agent-mcp 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

mcp_agent/agents/workflow/orchestrator_agent.py

@@ -5,7 +5,7 @@ This workflow provides an implementation that manages complex tasks by
 dynamically planning, delegating to specialized agents, and synthesizing results.
 """
 
-from typing import Any, Dict, List, Literal, Optional, Type
+from typing import Any, Dict, List, Literal, Optional, Tuple, Type
 
 from mcp.types import TextContent
 
@@ -29,6 +29,7 @@ from mcp_agent.agents.workflow.orchestrator_prompts import (
 )
 from mcp_agent.core.agent_types import AgentConfig
 from mcp_agent.core.exceptions import AgentConfigError
+from mcp_agent.core.prompt import Prompt
 from mcp_agent.core.request_params import RequestParams
 from mcp_agent.logging.logger import get_logger
 from mcp_agent.mcp.interfaces import ModelT
@@ -117,7 +118,7 @@ class OrchestratorAgent(BaseAgent):
         prompt: List[PromptMessageMultipart],
         model: Type[ModelT],
         request_params: Optional[RequestParams] = None,
-    ) -> Optional[ModelT]:
+    ) -> Tuple[ModelT | None, PromptMessageMultipart]:
         """
         Execute an orchestration plan and parse the result into a structured format.
 
@@ -138,12 +139,11 @@ class OrchestratorAgent(BaseAgent):
             prompt_message = PromptMessageMultipart(
                 role="user", content=[TextContent(type="text", text=result_text)]
             )
-
-            # Use the LLM's structured parsing capability
+            assert self._llm
             return await self._llm.structured([prompt_message], model, request_params)
         except Exception as e:
             self.logger.warning(f"Failed to parse orchestration result: {str(e)}")
-            return None
+            return None, Prompt.assistant(f"Failed to parse orchestration result: {str(e)}")
 
     async def initialize(self) -> None:
         """Initialize the orchestrator agent and worker agents."""
@@ -429,7 +429,8 @@ class OrchestratorAgent(BaseAgent):
             plan_msg = PromptMessageMultipart(
                 role="user", content=[TextContent(type="text", text=prompt)]
             )
-            return await self._llm.structured([plan_msg], Plan, request_params)
+            plan, _ = await self._llm.structured([plan_msg], Plan, request_params)
+            return plan
         except Exception as e:
             self.logger.error(f"Failed to parse plan: {str(e)}")
             return None
@@ -483,7 +484,8 @@ class OrchestratorAgent(BaseAgent):
             plan_msg = PromptMessageMultipart(
                 role="user", content=[TextContent(type="text", text=prompt)]
             )
-            return await self._llm.structured([plan_msg], NextStep, request_params)
+            next_step, _ = await self._llm.structured([plan_msg], NextStep, request_params)
+            return next_step
         except Exception as e:
             self.logger.error(f"Failed to parse next step: {str(e)}")
             return None

mcp_agent/agents/workflow/parallel_agent.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import Any, List, Optional
+from typing import Any, List, Optional, Tuple
 
 from mcp.types import TextContent
 
@@ -113,7 +113,7 @@ class ParallelAgent(BaseAgent):
         prompt: List[PromptMessageMultipart],
         model: type[ModelT],
         request_params: Optional[RequestParams] = None,
-    ) -> Optional[ModelT]:
+    ) -> Tuple[ModelT | None, PromptMessageMultipart]:
         """
         Apply the prompt and return the result as a Pydantic model.
 

mcp_agent/agents/workflow/router_agent.py

@@ -5,7 +5,7 @@ This provides a simplified implementation that routes messages to agents
 by determining the best agent for a request and dispatching to it.
 """
 
-from typing import TYPE_CHECKING, List, Optional, Type
+from typing import TYPE_CHECKING, List, Optional, Tuple, Type
 
 from mcp.types import TextContent
 from pydantic import BaseModel
@@ -14,6 +14,7 @@ from mcp_agent.agents.agent import Agent
 from mcp_agent.agents.base_agent import BaseAgent
 from mcp_agent.core.agent_types import AgentConfig
 from mcp_agent.core.exceptions import AgentConfigError
+from mcp_agent.core.prompt import Prompt
 from mcp_agent.core.request_params import RequestParams
 from mcp_agent.logging.logger import get_logger
 from mcp_agent.mcp.interfaces import ModelT
@@ -73,7 +74,7 @@ class RoutingResponse(BaseModel):
 class RouterResult(BaseModel):
     """Router result with agent reference and confidence rating."""
 
-    result: Agent
+    result: BaseAgent
     confidence: str
     reasoning: Optional[str] = None
 
@@ -221,7 +222,7 @@ class RouterAgent(BaseAgent):
         prompt: List[PromptMessageMultipart],
         model: Type[ModelT],
         request_params: Optional[RequestParams] = None,
-    ) -> Optional[ModelT]:
+    ) -> Tuple[ModelT | None, PromptMessageMultipart]:
         """
         Route the request to the most appropriate agent and parse its response.
 
@@ -236,7 +237,7 @@ class RouterAgent(BaseAgent):
         routing_result = await self._get_routing_result(prompt)
 
         if not routing_result:
-            return None
+            return None, Prompt.assistant("No routing result")
 
         # Get the selected agent
         selected_agent = routing_result.result
@@ -287,7 +288,8 @@ class RouterAgent(BaseAgent):
         )
 
         # Get structured response from LLM
-        response = await self._llm.structured(
+        assert self._llm
+        response, _ = await self._llm.structured(
             [prompt], RoutingResponse, self._default_request_params
         )
 

mcp_agent/core/{direct_agent_app.py → agent_app.py}

@@ -2,14 +2,17 @@
 Direct AgentApp implementation for interacting with agents without proxies.
 """
 
-from typing import Dict, Optional, Union
+from typing import Dict, List, Optional, Union
+
+from deprecated import deprecated
+from mcp.types import PromptMessage
 
 from mcp_agent.agents.agent import Agent
 from mcp_agent.core.interactive_prompt import InteractivePrompt
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
 
-class DirectAgentApp:
+class AgentApp:
     """
     Container for active agents that provides a simple API for interacting with them.
     This implementation works directly with Agent instances without proxies.
@@ -44,7 +47,7 @@ class DirectAgentApp:
 
     async def __call__(
         self,
-        message: Union[str, PromptMessageMultipart] | None = None,
+        message: Union[str, PromptMessage, PromptMessageMultipart] | None = None,
         agent_name: str | None = None,
         default_prompt: str = "",
     ) -> str:
@@ -53,9 +56,12 @@ class DirectAgentApp:
         This mirrors the FastAgent implementation that allowed agent("message").
 
         Args:
-            message: The message to send
+            message: Message content in various formats:
+                - String: Converted to a user PromptMessageMultipart
+                - PromptMessage: Converted to PromptMessageMultipart
+                - PromptMessageMultipart: Used directly
             agent_name: Optional name of the agent to send to (defaults to first agent)
-            default: Default message to use in interactive prompt mode
+            default_prompt: Default message to use in interactive prompt mode
 
         Returns:
             The agent's response as a string or the result of the interactive session
@@ -63,14 +69,21 @@ class DirectAgentApp:
         if message:
             return await self._agent(agent_name).send(message)
 
-        return await self._agent(agent_name).prompt(default_prompt=default_prompt)
+        return await self.interactive(agent_name=agent_name, default_prompt=default_prompt)
 
-    async def send(self, message: str, agent_name: Optional[str] = None) -> str:
+    async def send(
+        self,
+        message: Union[str, PromptMessage, PromptMessageMultipart],
+        agent_name: Optional[str] = None,
+    ) -> str:
         """
         Send a message to the specified agent (or to all agents).
 
         Args:
-            message: The message to send
+            message: Message content in various formats:
+                - String: Converted to a user PromptMessageMultipart
+                - PromptMessage: Converted to PromptMessageMultipart
+                - PromptMessageMultipart: Used directly
             agent_name: Optional name of the agent to send to
 
         Returns:
@@ -97,32 +110,119 @@ class DirectAgentApp:
 
         Args:
             prompt_name: Name of the prompt template to apply
-            agent_name: Name of the agent to send to
             arguments: Optional arguments for the prompt template
+            agent_name: Name of the agent to send to
 
         Returns:
             The agent's response as a string
         """
         return await self._agent(agent_name).apply_prompt(prompt_name, arguments)
 
-    async def list_prompts(self, agent_name: str | None = None):
+    async def list_prompts(self, server_name: str | None = None, agent_name: str | None = None):
         """
         List available prompts for an agent.
 
         Args:
+            server_name: Optional name of the server to list prompts from
             agent_name: Name of the agent to list prompts for
 
         Returns:
             Dictionary mapping server names to lists of available prompts
         """
-        return await self._agent(agent_name).list_prompts()
+        return await self._agent(agent_name).list_prompts(server_name=server_name)
+
+    async def get_prompt(
+        self,
+        prompt_name: str,
+        arguments: Dict[str, str] | None = None,
+        server_name: str | None = None,
+        agent_name: str | None = None,
+    ):
+        """
+        Get a prompt from a server.
+
+        Args:
+            prompt_name: Name of the prompt, optionally namespaced
+            arguments: Optional dictionary of arguments to pass to the prompt template
+            server_name: Optional name of the server to get the prompt from
+            agent_name: Name of the agent to use
 
-    async def with_resource(self, user_prompt: str, server_name: str, resource_name: str) -> str:
-        return await self._agent(None).with_resource(
-            prompt_content=user_prompt, server_name=server_name, resource_name=resource_name
+        Returns:
+            GetPromptResult containing the prompt information
+        """
+        return await self._agent(agent_name).get_prompt(
+            prompt_name=prompt_name, arguments=arguments, server_name=server_name
         )
 
-    async def prompt(self, agent_name: Optional[str] = None, default_prompt: str = "") -> str:
+    async def with_resource(
+        self,
+        prompt_content: Union[str, PromptMessage, PromptMessageMultipart],
+        resource_uri: str,
+        server_name: str | None = None,
+        agent_name: str | None = None,
+    ) -> str:
+        """
+        Send a message with an attached MCP resource.
+
+        Args:
+            prompt_content: Content in various formats (String, PromptMessage, or PromptMessageMultipart)
+            resource_uri: URI of the resource to retrieve
+            server_name: Optional name of the MCP server to retrieve the resource from
+            agent_name: Name of the agent to use
+
+        Returns:
+            The agent's response as a string
+        """
+        return await self._agent(agent_name).with_resource(
+            prompt_content=prompt_content, resource_uri=resource_uri, server_name=server_name
+        )
+
+    async def list_resources(
+        self,
+        server_name: str | None = None,
+        agent_name: str | None = None,
+    ) -> Dict[str, List[str]]:
+        """
+        List available resources from one or all servers.
+
+        Args:
+            server_name: Optional server name to list resources from
+            agent_name: Name of the agent to use
+
+        Returns:
+            Dictionary mapping server names to lists of resource URIs
+        """
+        return await self._agent(agent_name).list_resources(server_name=server_name)
+
+    async def get_resource(
+        self,
+        resource_uri: str,
+        server_name: str | None = None,
+        agent_name: str | None = None,
+    ):
+        """
+        Get a resource from an MCP server.
+
+        Args:
+            resource_uri: URI of the resource to retrieve
+            server_name: Optional name of the MCP server to retrieve the resource from
+            agent_name: Name of the agent to use
+
+        Returns:
+            ReadResourceResult object containing the resource content
+        """
+        return await self._agent(agent_name).get_resource(
+            resource_uri=resource_uri, server_name=server_name
+        )
+
+    @deprecated
+    async def prompt(self, agent_name: str | None = None, default_prompt: str = "") -> str:
+        """
+        Deprecated - use interactive() instead.
+        """
+        return await self.interactive(agent_name=agent_name, default_prompt=default_prompt)
+
+    async def interactive(self, agent_name: str | None = None, default_prompt: str = "") -> str:
         """
         Interactive prompt for sending messages with advanced features.
 

mcp_agent/core/direct_factory.py

@@ -147,11 +147,11 @@ async def create_agents_by_type(
                 await agent.initialize()
 
                 # Attach LLM to the agent
-                llm_factory = model_factory_func(
-                    model=config.model,
-                    request_params=config.default_request_params,
+                llm_factory = model_factory_func(model=config.model)
+                await agent.attach_llm(
+                    llm_factory,
+                    request_params=config.default_request_params
                 )
-                await agent.attach_llm(llm_factory)
                 result_agents[name] = agent
 
             elif agent_type == AgentType.ORCHESTRATOR:
@@ -183,11 +183,11 @@ async def create_agents_by_type(
                 await orchestrator.initialize()
 
                 # Attach LLM to the orchestrator
-                llm_factory = model_factory_func(
-                    model=config.model,
-                    request_params=config.default_request_params,
+                llm_factory = model_factory_func(model=config.model)
+                await orchestrator.attach_llm(
+                    llm_factory,
+                    request_params=config.default_request_params
                 )
-                await orchestrator.attach_llm(llm_factory)
 
                 result_agents[name] = orchestrator
 
@@ -247,11 +247,11 @@ async def create_agents_by_type(
                 await router.initialize()
 
                 # Attach LLM to the router
-                llm_factory = model_factory_func(
-                    model=config.model,
-                    request_params=config.default_request_params,
+                llm_factory = model_factory_func(model=config.model)
+                await router.attach_llm(
+                    llm_factory,
+                    request_params=config.default_request_params
                 )
-                await router.attach_llm(llm_factory)
                 result_agents[name] = router
 
             elif agent_type == AgentType.CHAIN:

mcp_agent/core/fastagent.py

@@ -15,7 +15,7 @@ import yaml
 from mcp_agent.app import MCPApp
 from mcp_agent.config import Settings
 from mcp_agent.context import Context
-from mcp_agent.core.direct_agent_app import DirectAgentApp
+from mcp_agent.core.agent_app import AgentApp
 from mcp_agent.core.direct_decorators import (
     agent as agent_decorator,
 )
@@ -110,8 +110,15 @@ class FastAgent:
 
         self.name = name
         self.config_path = config_path
-        self._load_config()
-
+        try:
+            self._load_config()
+        except yaml.parser.ParserError as e:
+            handle_error(
+                e,
+                "YAML Parsing Error",
+                "There was an error parsing the config or secrets YAML configuration file.",
+            )
+            raise SystemExit(1)
         # Create the MCPApp with the config
         self.app = MCPApp(
             name=name,
@@ -196,7 +203,7 @@ class FastAgent:
                 )
 
                 # Create a wrapper with all agents for simplified access
-                wrapper = DirectAgentApp(active_agents)
+                wrapper = AgentApp(active_agents)
 
                 # Handle direct message sending if --agent and --message are provided
                 if hasattr(self, "args") and self.args.agent and self.args.message:
@@ -297,6 +304,12 @@ class FastAgent:
                 e,
                 "User requested exit",
             )
+        elif isinstance(e, asyncio.CancelledError):
+            handle_error(
+                e,
+                "Cancelled",
+                "The operation was cancelled.",
+            )
         else:
             handle_error(e, error_type or "Error", "An unexpected error occurred.")
 

mcp_agent/core/mcp_content.py

@@ -14,6 +14,8 @@ from mcp.types import (
     BlobResourceContents,
     EmbeddedResource,
     ImageContent,
+    ReadResourceResult,
+    ResourceContents,
     TextContent,
     TextResourceContents,
 )
@@ -25,6 +27,9 @@ from mcp_agent.mcp.mime_utils import (
     is_image_mime_type,
 )
 
+# Type for all MCP content types
+MCPContentType = Union[TextContent, ImageContent, EmbeddedResource, ResourceContents]
+
 
 def MCPText(
     text: str,
@@ -147,7 +152,8 @@ def MCPFile(
 
 
 def MCPPrompt(
-    *content_items: Union[dict, str, Path, bytes], role: Literal["user", "assistant"] = "user"
+    *content_items: Union[dict, str, Path, bytes, MCPContentType, 'EmbeddedResource', 'ReadResourceResult'], 
+    role: Literal["user", "assistant"] = "user"
 ) -> List[dict]:
     """
     Create one or more prompt messages with various content types.
@@ -158,6 +164,11 @@ def MCPPrompt(
     - File paths with text mime types or other mime types become EmbeddedResource
     - Dicts with role and content are passed through unchanged
     - Raw bytes become ImageContent
+    - TextContent objects are used directly
+    - ImageContent objects are used directly
+    - EmbeddedResource objects are used directly
+    - ResourceContent objects are wrapped in EmbeddedResource
+    - ReadResourceResult objects are expanded into multiple messages
 
     Args:
         *content_items: Content items of various types
@@ -173,9 +184,9 @@ def MCPPrompt(
             # Already a fully formed message
             result.append(item)
         elif isinstance(item, str):
-            # Simple text content (that's not a file path)
+            # Simple text content
             result.append(MCPText(item, role=role))
-        elif isinstance(item, Path) or isinstance(item, str):
+        elif isinstance(item, Path):
             # File path - determine the content type based on mime type
             path_str = str(item)
             mime_type = guess_mime_type(path_str)
@@ -189,6 +200,28 @@ def MCPPrompt(
         elif isinstance(item, bytes):
             # Raw binary data, assume image
             result.append(MCPImage(data=item, role=role))
+        elif isinstance(item, TextContent):
+            # Already a TextContent, wrap in a message
+            result.append({"role": role, "content": item})
+        elif isinstance(item, ImageContent):
+            # Already an ImageContent, wrap in a message
+            result.append({"role": role, "content": item})
+        elif isinstance(item, EmbeddedResource):
+            # Already an EmbeddedResource, wrap in a message
+            result.append({"role": role, "content": item})
+        elif hasattr(item, 'type') and item.type == 'resource' and hasattr(item, 'resource'):
+            # Looks like an EmbeddedResource but may not be the exact class
+            result.append({"role": role, "content": EmbeddedResource(type="resource", resource=item.resource)})
+        elif isinstance(item, ResourceContents):
+            # It's a ResourceContents, wrap it in an EmbeddedResource
+            result.append({"role": role, "content": EmbeddedResource(type="resource", resource=item)})
+        elif isinstance(item, ReadResourceResult):
+            # It's a ReadResourceResult, convert each resource content
+            for resource_content in item.contents:
+                result.append({
+                    "role": role, 
+                    "content": EmbeddedResource(type="resource", resource=resource_content)
+                })
         else:
             # Try to convert to string
             result.append(MCPText(str(item), role=role))
@@ -196,12 +229,12 @@ def MCPPrompt(
     return result
 
 
-def User(*content_items) -> List[dict]:
+def User(*content_items: Union[dict, str, Path, bytes, MCPContentType, 'EmbeddedResource', 'ReadResourceResult']) -> List[dict]:
     """Create user message(s) with various content types."""
     return MCPPrompt(*content_items, role="user")
 
 
-def Assistant(*content_items) -> List[dict]:
+def Assistant(*content_items: Union[dict, str, Path, bytes, MCPContentType, 'EmbeddedResource', 'ReadResourceResult']) -> List[dict]:
     """Create assistant message(s) with various content types."""
     return MCPPrompt(*content_items, role="assistant")
 

mcp_agent/core/prompt.py

@@ -2,14 +2,15 @@
 Prompt class for easily creating and working with MCP prompt content.
 """
 
-from typing import List, Literal
+from pathlib import Path
+from typing import List, Literal, Union
 
 from mcp.types import PromptMessage
 
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
 # Import our content helper functions
-from .mcp_content import Assistant, MCPPrompt, User
+from .mcp_content import Assistant, MCPContentType, MCPPrompt, User
 
 
 class Prompt:
@@ -25,34 +26,75 @@ class Prompt:
     - Strings become TextContent
     - Image file paths become ImageContent
     - Other file paths become EmbeddedResource
+    - TextContent objects are used directly
+    - ImageContent objects are used directly
+    - EmbeddedResource objects are used directly 
     - Pre-formatted messages pass through unchanged
     """
 
     @classmethod
-    def user(cls, *content_items) -> PromptMessageMultipart:
+    def user(cls, *content_items: Union[str, Path, bytes, dict, MCPContentType, PromptMessage, PromptMessageMultipart]) -> PromptMessageMultipart:
         """
         Create a user PromptMessageMultipart with various content items.
 
         Args:
-            *content_items: Content items (strings, file paths, etc.)
+            *content_items: Content items in various formats:
+                - Strings: Converted to TextContent
+                - Path objects: Converted based on file type (image/text/binary)
+                - Bytes: Treated as image data
+                - Dicts with role/content: Content extracted
+                - TextContent: Used directly
+                - ImageContent: Used directly
+                - EmbeddedResource: Used directly
+                - PromptMessage: Content extracted
+                - PromptMessageMultipart: Content extracted with role changed to user
 
         Returns:
             A PromptMessageMultipart with user role and the specified content
         """
+        # Handle PromptMessage and PromptMessageMultipart directly
+        if len(content_items) == 1:
+            item = content_items[0]
+            if isinstance(item, PromptMessage):
+                return PromptMessageMultipart(role="user", content=[item.content])
+            elif isinstance(item, PromptMessageMultipart):
+                # Keep the content but change role to user
+                return PromptMessageMultipart(role="user", content=item.content)
+                
+        # Use the original implementation for other types
         messages = User(*content_items)
         return PromptMessageMultipart(role="user", content=[msg["content"] for msg in messages])
 
     @classmethod
-    def assistant(cls, *content_items) -> PromptMessageMultipart:
+    def assistant(cls, *content_items: Union[str, Path, bytes, dict, MCPContentType, PromptMessage, PromptMessageMultipart]) -> PromptMessageMultipart:
         """
         Create an assistant PromptMessageMultipart with various content items.
 
         Args:
-            *content_items: Content items (strings, file paths, etc.)
+            *content_items: Content items in various formats:
+                - Strings: Converted to TextContent
+                - Path objects: Converted based on file type (image/text/binary)
+                - Bytes: Treated as image data
+                - Dicts with role/content: Content extracted
+                - TextContent: Used directly
+                - ImageContent: Used directly
+                - EmbeddedResource: Used directly
+                - PromptMessage: Content extracted
+                - PromptMessageMultipart: Content extracted with role changed to assistant
 
         Returns:
             A PromptMessageMultipart with assistant role and the specified content
         """
+        # Handle PromptMessage and PromptMessageMultipart directly
+        if len(content_items) == 1:
+            item = content_items[0]
+            if isinstance(item, PromptMessage):
+                return PromptMessageMultipart(role="assistant", content=[item.content])
+            elif isinstance(item, PromptMessageMultipart):
+                # Keep the content but change role to assistant
+                return PromptMessageMultipart(role="assistant", content=item.content)
+                
+        # Use the original implementation for other types
         messages = Assistant(*content_items)
         return PromptMessageMultipart(
             role="assistant", content=[msg["content"] for msg in messages]
@@ -60,18 +102,38 @@ class Prompt:
 
     @classmethod
     def message(
-        cls, *content_items, role: Literal["user", "assistant"] = "user"
+        cls, *content_items: Union[str, Path, bytes, dict, MCPContentType, PromptMessage, PromptMessageMultipart], 
+        role: Literal["user", "assistant"] = "user"
     ) -> PromptMessageMultipart:
         """
         Create a PromptMessageMultipart with the specified role and content items.
 
         Args:
-            *content_items: Content items (strings, file paths, etc.)
+            *content_items: Content items in various formats:
+                - Strings: Converted to TextContent
+                - Path objects: Converted based on file type (image/text/binary)
+                - Bytes: Treated as image data
+                - Dicts with role/content: Content extracted
+                - TextContent: Used directly
+                - ImageContent: Used directly
+                - EmbeddedResource: Used directly
+                - PromptMessage: Content extracted
+                - PromptMessageMultipart: Content extracted with role changed as specified
             role: Role for the message (user or assistant)
 
         Returns:
             A PromptMessageMultipart with the specified role and content
         """
+        # Handle PromptMessage and PromptMessageMultipart directly
+        if len(content_items) == 1:
+            item = content_items[0]
+            if isinstance(item, PromptMessage):
+                return PromptMessageMultipart(role=role, content=[item.content])
+            elif isinstance(item, PromptMessageMultipart):
+                # Keep the content but change role as specified
+                return PromptMessageMultipart(role=role, content=item.content)
+                
+        # Use the original implementation for other types
         messages = MCPPrompt(*content_items, role=role)
         return PromptMessageMultipart(
             role=messages[0]["role"] if messages else role,

mcp_agent/core/validation.py

@@ -231,7 +231,7 @@ def get_dependencies_groups(
             dependencies[name].update(agent_data.get("parallel_agents", []))
         elif agent_type == AgentType.CHAIN.value:
             # Chain agents depend on the agents in their sequence
-            dependencies[name].update(agent_data.get("chain_agents", []))
+            dependencies[name].update(agent_data.get("sequence", []))
         elif agent_type == AgentType.ROUTER.value:
             # Router agents depend on the agents they route to
             dependencies[name].update(agent_data.get("router_agents", []))