fast-agent-mcp 0.0.15__py3-none-any.whl → 0.1.0__py3-none-any.whl

mcp_agent/workflows/orchestrator/orchestrator_prompts.py

@@ -10,29 +10,34 @@ PLAN_RESULT_TEMPLATE = """Plan Objective: {plan_objective}
 Progress So Far (steps completed):
 {steps_str}
 
-Plan Current Status: {plan_status}
-Plan Current Result: {plan_result}"""
+Result: {plan_result}"""
 
 FULL_PLAN_PROMPT_TEMPLATE = """You are tasked with orchestrating a plan to complete an objective.
 You can analyze results from the previous steps already executed to decide if the objective is complete.
-Your plan must be structured in sequential steps, with each step containing independent parallel subtasks.
 
-Objective: {objective}
+<fastagent:data>
+<fastagent:objective>
+{objective}
+</fastagent:objective>
+
+<fastagent:available-agents>
+{agents}
+</fastagent:available-agents>
 
+<fastagent:progress>
 {plan_result}
+</fastagent:progress>
+
+<fastagent:status>
+{plan_status}
+</fastagent:status>
+</fastagent:data>
 
+Your plan must be structured in sequential steps, with each step containing independent parallel subtasks.
 If the previous results achieve the objective, return is_complete=True.
 Otherwise, generate remaining steps needed.
 
-You have access to the following MCP Servers (which are collections of tools/functions),
-and Agents (which are collections of servers):
-
-Agents:
-{agents}
-
-IMPORTANT: You can ONLY use the agents listed above. Do not invent or reference agents that are not in the list.
-The plan will fail if you reference agents that are not available.
-
+<fastagent:instruction>
 Generate a plan with all remaining steps needed.
 Steps are sequential, but each Step can have parallel subtasks.
 For each Step, specify a description of the step and independent subtasks that can run in parallel.
@@ -40,6 +45,9 @@ For each subtask specify:
     1. Clear description of the task that an LLM can execute  
     2. Name of 1 Agent from the available agents list above
     
+CRITICAL: You MUST ONLY use agent names that are EXACTLY as they appear in <fastagent:available-agents> above.
+Do NOT invent new agents. Do NOT modify agent names. The plan will FAIL if you use an agent that doesn't exist.
+
 Return your response in the following JSON structure:
     {{
         "steps": [
@@ -48,11 +56,11 @@ Return your response in the following JSON structure:
                 "tasks": [
                     {{
                         "description": "Description of task 1",
-                        "agent": "agent_name"  # For AgentTask - MUST be one of the available agents
+                        "agent": "agent_name"  // agent MUST be exactly one of the agent names listed above
                     }},
                     {{
                         "description": "Description of task 2", 
-                        "agent": "agent_name2"  # MUST be one of the available agents
+                        "agent": "agent_name2"  // agent MUST be exactly one of the agent names listed above
                     }}
                 ]
             }}
@@ -61,58 +69,120 @@ Return your response in the following JSON structure:
     }}
 
 You must respond with valid JSON only, with no triple backticks. No markdown formatting.
-No extra text. Do not wrap in ```json code fences."""
+No extra text. Do not wrap in ```json code fences.
+</fastagent:instruction>
+"""
 
 ITERATIVE_PLAN_PROMPT_TEMPLATE = """You are tasked with determining only the next step in a plan
 needed to complete an objective. You must analyze the current state and progress from previous steps 
 to decide what to do next.
 
-A Step must be sequential in the plan, but can have independent parallel subtasks. Only return a single Step.
+<fastagent:data>
+<fastagent:objective>
+{objective}
+</fastagent:objective>
 
-Objective: {objective}
+<fastagent:available-agents>
+{agents}
+</fastagent:available-agents>
 
+<fastagent:progress>
 {plan_result}
-    
-If the previous results achieve the objective, return is_complete=True.
-Otherwise, generate the next Step.
+</fastagent:progress>
 
-You have access to the following MCP Servers (which are collections of tools/functions),
-and Agents (which are collections of servers):
-
-Agents:
-{agents}
+<fastagent:status>
+{plan_status}
+</fastagent:status>
+</fastagent:data>
 
-IMPORTANT: You can ONLY use the agents listed above. Do not invent or reference agents that are not in the list.
-The plan will fail if you reference agents that are not available.
+A Step must be sequential in the plan, but can have independent parallel subtasks. Only return a single Step.
+If the previous results achieve the objective, return is_complete=True.
+Otherwise, generate the next Step.
 
+<fastagent:instruction>
 Generate the next step, by specifying a description of the step and independent subtasks that can run in parallel:
 For each subtask specify:
     1. Clear description of the task that an LLM can execute  
     2. Name of 1 Agent from the available agents list above
 
+CRITICAL: You MUST ONLY use agent names that are EXACTLY as they appear in <fastagent:available-agents> above.
+Do NOT invent new agents. Do NOT modify agent names. The plan will FAIL if you use an agent that doesn't exist.
+
 Return your response in the following JSON structure:
     {{
         "description": "Description of step 1",
         "tasks": [
             {{
                 "description": "Description of task 1",
-                "agent": "agent_name"  # For AgentTask - MUST be one of the available agents
+                "agent": "agent_name"  // agent MUST be exactly one of the agent names listed above
             }}
         ],
         "is_complete": false
     }}
 
 You must respond with valid JSON only, with no triple backticks. No markdown formatting.
-No extra text. Do not wrap in ```json code fences."""
-
-TASK_PROMPT_TEMPLATE = """You are part of a larger workflow to achieve the objective: {objective}.
-Your job is to accomplish only the following task: {task}.
-
-Results so far that may provide helpful context:
-{context}"""
-
-SYNTHESIZE_STEP_PROMPT_TEMPLATE = """Synthesize the results of these parallel tasks into a cohesive result:
-{step_result}"""
-
-SYNTHESIZE_PLAN_PROMPT_TEMPLATE = """Synthesize the results of executing all steps in the plan into a cohesive result:
-{plan_result}"""
+No extra text. Do not wrap in ```json code fences.
+</fastagent:instruction>
+"""
+
+TASK_PROMPT_TEMPLATE = """You are part of a larger workflow to achieve an objective.
+
+<fastagent:data>
+<fastagent:objective>
+{objective}
+</fastagent:objective>
+
+<fastagent:task>
+{task}
+</fastagent:task>
+
+<fastagent:context>
+{context}
+</fastagent:context>
+</fastagent:data>
+
+<fastagent:instruction>
+Your job is to accomplish only the task specified above.
+Use the context from previous steps to inform your approach.
+The context contains structured XML with the results from previous steps - pay close attention to:
+- The objective in <fastagent:objective>
+- Previous step results in <fastagent:steps>
+- Task results and their attribution in <fastagent:task-result>
+
+Provide a direct, focused response that addresses the task.
+</fastagent:instruction>
+"""
+
+SYNTHESIZE_STEP_PROMPT_TEMPLATE = """You need to synthesize the results of parallel tasks into a cohesive result.
+
+<fastagent:data>
+<fastagent:step-results>
+{step_result}
+</fastagent:step-results>
+</fastagent:data>
+
+<fastagent:instruction>
+Analyze the results from all tasks in this step.
+Each task was executed by a specific agent (finder, writer, etc.)
+Consider the expertise of each agent when weighing their results.
+Combine the information into a coherent, unified response.
+Focus on key insights and important outcomes.
+Resolve any conflicting information if present.
+</fastagent:instruction>
+"""
+
+SYNTHESIZE_PLAN_PROMPT_TEMPLATE = """You need to synthesize the results of all completed plan steps into a final response.
+
+<fastagent:data>
+<fastagent:plan-results>
+{plan_result}
+</fastagent:plan-results>
+</fastagent:data>
+
+<fastagent:instruction>
+Create a comprehensive final response that addresses the original objective.
+Integrate all the information gathered across all plan steps.
+Provide a clear, complete answer that achieves the objective.
+Focus on delivering value through your synthesis, not just summarizing.
+</fastagent:instruction>
+"""

mcp_agent/workflows/router/router_base.py

@@ -200,6 +200,7 @@ class Router(ABC, ContextDependent):
             category=server_name,
             name=server_config.name if server_config else server_name,
             description=server_config.description,
+            tools=[],  # Empty list to avoid validation errors
         )
 
     def get_agent_category(self, agent: Agent) -> AgentRouterCategory:
@@ -207,14 +208,17 @@ class Router(ABC, ContextDependent):
             agent.instruction({}) if callable(agent.instruction) else agent.instruction
         )
 
+        # Just get server categories without attempting to access tools
+        # This is a simpler approach that avoids potential issues with uninitialized agents
+        server_categories = [
+            self.get_server_category(server_name) for server_name in agent.server_names
+        ]
+
         return AgentRouterCategory(
             category=agent,
             name=agent.name,
             description=agent_description,
-            servers=[
-                self.get_server_category(server_name)
-                for server_name in agent.server_names
-            ],
+            servers=server_categories,
         )
 
     def get_function_category(self, function: Callable) -> RouterCategory:
@@ -231,9 +235,6 @@ class Router(ABC, ContextDependent):
     ) -> str:
         """Format a category into a readable string."""
 
-        index_str = f"{index}. " if index is not None else " "
-        category_str = ""
-
         if isinstance(category, ServerRouterCategory):
             category_str = self._format_server_category(category)
         elif isinstance(category, AgentRouterCategory):
@@ -241,36 +242,127 @@ class Router(ABC, ContextDependent):
         else:
             category_str = self._format_function_category(category)
 
-        return f"{index_str}{category_str}"
+        return category_str
 
     def _format_tools(self, tools: List[FastTool]) -> str:
         """Format a list of tools into a readable string."""
         if not tools:
-            return "No tool information provided."
+            # Return a note about tools within XML tags to maintain structure
+            return '<fastagent:tool name="info">No tool information available</fastagent:tool>'
 
         tool_descriptions = []
         for tool in tools:
-            desc = f"- {tool.name}: {tool.description}"
+            # Access tool name and description safely
+            tool_name = getattr(tool, "name", "unnamed-tool")
+            tool_description = getattr(tool, "description", "No description available")
+            desc = f'<fastagent:tool name="{tool_name}">{tool_description}</fastagent:tool>'
             tool_descriptions.append(desc)
 
         return "\n".join(tool_descriptions)
 
     def _format_server_category(self, category: ServerRouterCategory) -> str:
         """Format a server category into a readable string."""
-        description = category.description or "No description provided"
-        tools = self._format_tools(category.tools)
-        return f"Server Category: {category.name}\nDescription: {description}\nTools in server:\n{tools}"
+        # Check if we have any content (description or tools)
+        has_description = bool(category.description)
+        has_tools = bool(category.tools)
+        
+        # If no content at all, use self-closing tag
+        if not has_description and not has_tools:
+            return f'<fastagent:server-category name="{category.name}" />'
+            
+        # Otherwise, build the content
+        description_section = ""
+        if has_description:
+            description_section = f"\n<fastagent:description>{category.description}</fastagent:description>"
+            
+        # Add tools section if we have tool information
+        if has_tools:
+            tools = self._format_tools(category.tools)
+            return f"""<fastagent:server-category name="{category.name}">{description_section}
+<fastagent:tools>
+{tools}
+</fastagent:tools>
+</fastagent:server-category>"""
+        else:
+            # Just description, no tools
+            return f"""<fastagent:server-category name="{category.name}">{description_section}
+</fastagent:server-category>"""
 
     def _format_agent_category(self, category: AgentRouterCategory) -> str:
         """Format an agent category into a readable string."""
-        description = category.description or "No description provided"
-        servers = "\n".join(
-            [f"- {server.name} ({server.description})" for server in category.servers]
-        )
-
-        return f"Agent Category: {category.name}\nDescription: {description}\nServers in agent:\n{servers}"
+        # Check if we have any content (description or servers)
+        has_description = bool(category.description)
+        has_servers = bool(category.servers)
+        
+        # If no content at all, use self-closing tag
+        if not has_description and not has_servers:
+            return f'<fastagent:agent-category name="{category.name}" />'
+            
+        # Build description section if needed
+        description_section = ""
+        if has_description:
+            description_section = f"\n<fastagent:description>{category.description}</fastagent:description>"
+
+        # Handle the case with no servers
+        if not has_servers:
+            return f"""<fastagent:agent-category name="{category.name}">{description_section}
+</fastagent:agent-category>"""
+
+        # Format servers with proper XML tags and include their tools
+        server_sections = []
+        for server in category.servers:
+            # Check if this server has any content
+            has_server_description = bool(server.description)
+            has_server_tools = bool(server.tools)
+            
+            # Use self-closing tag if server has no content
+            if not has_server_description and not has_server_tools:
+                server_section = f'<fastagent:server name="{server.name}" />'
+                server_sections.append(server_section)
+                continue
+                
+            # Build server description if needed
+            server_desc_section = ""
+            if has_server_description:
+                server_desc_section = f"\n<fastagent:description>{server.description}</fastagent:description>"
+
+            # Format server tools if available
+            if has_server_tools:
+                tool_items = []
+                for tool in server.tools:
+                    tool_desc = tool.description if tool.description else ""
+                    tool_items.append(
+                        f'<fastagent:tool name="{tool.name}">{tool_desc}</fastagent:tool>'
+                    )
+
+                tools_section = f"\n<fastagent:tools>\n{chr(10).join(tool_items)}\n</fastagent:tools>"
+                server_section = f"""<fastagent:server name="{server.name}">{server_desc_section}{tools_section}
+</fastagent:server>"""
+            else:
+                # Just description, no tools
+                server_section = f"""<fastagent:server name="{server.name}">{server_desc_section}
+</fastagent:server>"""
+            
+            server_sections.append(server_section)
+
+        servers = "\n".join(server_sections)
+
+        return f"""<fastagent:agent-category name="{category.name}">{description_section}
+<fastagent:servers>
+{servers}
+</fastagent:servers>
+</fastagent:agent-category>"""
 
     def _format_function_category(self, category: RouterCategory) -> str:
         """Format a function category into a readable string."""
-        description = category.description or "No description provided"
-        return f"Function Category: {category.name}\nDescription: {description}"
+        # Check if we have a description
+        has_description = bool(category.description)
+        
+        # If no description, use self-closing tag
+        if not has_description:
+            return f'<fastagent:function-category name="{category.name}" />'
+            
+        # Include description
+        return f"""<fastagent:function-category name="{category.name}">
+<fastagent:description>{category.description}</fastagent:description>
+</fastagent:function-category>"""

mcp_agent/workflows/router/router_llm.py

@@ -17,17 +17,23 @@ logger = get_logger(__name__)
 DEFAULT_ROUTING_INSTRUCTION = """
 You are a highly accurate request router that directs incoming requests to the most appropriate category.
 A category is a specialized destination, such as a Function, an MCP Server (a collection of tools/functions), or an Agent (a collection of servers).
-Below are the available routing categories, each with their capabilities and descriptions:
 
+<fastagent:data>
+<fastagent:categories>
 {context}
+</fastagent:categories>
 
-Your task is to analyze the following request and determine the most appropriate categories from the options above. Consider:
+<fastagent:request>
+{request}
+</fastagent:request>
+</fastagent:data>
+
+Your task is to analyze the request and determine the most appropriate categories from the options above. Consider:
 - The specific capabilities and tools each destination offers
 - How well the request matches the category's description
 - Whether the request might benefit from multiple categories (up to {top_k})
 
-Request: {request}
-
+<fastagent:instruction>
 Respond in JSON format:
 {{
     "categories": [
@@ -41,13 +47,21 @@ Respond in JSON format:
 
 Only include categories that are truly relevant. You may return fewer than {top_k} if appropriate.
 If none of the categories are relevant, return an empty list.
+</fastagent:instruction>
 """
 
 ROUTING_SYSTEM_INSTRUCTION = """
 You are a highly accurate request router that directs incoming requests to the most appropriate category.
 A category is a specialized destination, such as a Function, an MCP Server (a collection of tools/functions), or an Agent (a collection of servers).
-You will be provided with a request and a list of categories to choose from.
+
+You will analyze requests and choose the most appropriate categories based on their capabilities and descriptions.
 You can choose one or more categories, or choose none if no category is appropriate.
+
+Follow these guidelines:
+- Carefully match the request's needs with category capabilities
+- Consider which tools or servers would best address the request
+- If multiple categories could help, select all relevant ones
+- Only include truly relevant categories, not tangentially related ones
 """