fast-agent-mcp 0.3.5__tar.gz → 0.3.6__tar.gz

{fast_agent_mcp-0.3.5 → fast_agent_mcp-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.3.5
+Version: 0.3.6
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>
 License:                                  Apache License

{fast_agent_mcp-0.3.5/src/fast_agent/resources → fast_agent_mcp-0.3.6/examples}/setup/.gitignore

@@ -22,3 +22,9 @@ fastagent.jsonl
 # Editors (optional)
 .idea/
 .vscode/
+
+# Packaging metadata
+*.dist-info/
+*.egg-info/
+dist/
+build/

{fast_agent_mcp-0.3.5 → fast_agent_mcp-0.3.6}/examples/setup/agent.py

@@ -6,8 +6,15 @@ from fast_agent import FastAgent
 fast = FastAgent("fast-agent example")
 
 
+default_instruction = """You are a helpful AI Agent.
+
+{{serverInstructions}}
+
+The current date is {{currentDate}}."""
+
+
 # Define the agent
-@fast.agent(instruction="You are a helpful AI Agent")
+@fast.agent(instruction=default_instruction)
 async def main():
     # use the --model command line switch or agent arguments to change model
     async with fast.run() as agent:

{fast_agent_mcp-0.3.5 → fast_agent_mcp-0.3.6}/examples/setup/pyproject.toml.tmpl

@@ -15,3 +15,9 @@ package = true
 [project.scripts]
 fast-agent-app = "agent:main"
 
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+py-modules = ["agent"]

{fast_agent_mcp-0.3.5 → fast_agent_mcp-0.3.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.3.5"
+version = "0.3.6"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }

{fast_agent_mcp-0.3.5 → fast_agent_mcp-0.3.6}/src/fast_agent/agents/llm_agent.py

@@ -137,10 +137,24 @@ class LlmAgent(LlmDecorator):
         display_name = name if name is not None else self.name
         display_model = model if model is not None else (self.llm.model_name if self._llm else None)
 
+        # Convert highlight_items to highlight_index
+        highlight_index = None
+        if highlight_items and bottom_items:
+            if isinstance(highlight_items, str):
+                try:
+                    highlight_index = bottom_items.index(highlight_items)
+                except ValueError:
+                    pass
+            elif isinstance(highlight_items, list) and len(highlight_items) > 0:
+                try:
+                    highlight_index = bottom_items.index(highlight_items[0])
+                except ValueError:
+                    pass
+
         await self.display.show_assistant_message(
             message_text,
             bottom_items=bottom_items,
-            highlight_items=highlight_items,
+            highlight_index=highlight_index,
             max_item_length=max_item_length,
             name=display_name,
             model=display_model,

{fast_agent_mcp-0.3.5 → fast_agent_mcp-0.3.6}/src/fast_agent/agents/mcp_agent.py

@@ -156,6 +156,9 @@ class McpAgent(ABC, ToolAgent):
         """
         await self.__aenter__()
 
+        # Apply template substitution to the instruction with server instructions
+        await self._apply_instruction_templates()
+
     async def shutdown(self) -> None:
         """
         Shutdown the agent and close all MCP server connections.
@@ -174,6 +177,67 @@ class McpAgent(ABC, ToolAgent):
         self._initialized = value
         self._aggregator.initialized = value
 
+    async def _apply_instruction_templates(self) -> None:
+        """
+        Apply template substitution to the instruction, including server instructions.
+        This is called during initialization after servers are connected.
+        """
+        if not self.instruction:
+            return
+
+        # Gather server instructions if the template includes {{serverInstructions}}
+        if "{{serverInstructions}}" in self.instruction:
+            try:
+                instructions_data = await self._aggregator.get_server_instructions()
+                server_instructions = self._format_server_instructions(instructions_data)
+            except Exception as e:
+                self.logger.warning(f"Failed to get server instructions: {e}")
+                server_instructions = ""
+
+            # Replace the template variable
+            self.instruction = self.instruction.replace("{{serverInstructions}}", server_instructions)
+
+
+        # Update default request params to match
+        if self._default_request_params:
+            self._default_request_params.systemPrompt = self.instruction
+
+        self.logger.debug(f"Applied instruction templates for agent {self._name}")
+
+    def _format_server_instructions(self, instructions_data: Dict[str, tuple[str | None, List[str]]]) -> str:
+        """
+        Format server instructions with XML tags and tool lists.
+
+        Args:
+            instructions_data: Dict mapping server name to (instructions, tool_names)
+
+        Returns:
+            Formatted string with server instructions
+        """
+        if not instructions_data:
+            return ""
+
+        formatted_parts = []
+        for server_name, (instructions, tool_names) in instructions_data.items():
+            # Skip servers with no instructions
+            if instructions is None:
+                continue
+
+            # Format tool names with server prefix
+            prefixed_tools = [f"{server_name}-{tool}" for tool in tool_names]
+            tools_list = ", ".join(prefixed_tools) if prefixed_tools else "No tools available"
+
+            formatted_parts.append(
+                f"<mcp-server name=\"{server_name}\">\n"
+                f"<tools>{tools_list}</tools>\n"
+                f"<instructions>\n{instructions}\n</instructions>\n"
+                f"</mcp-server>"
+            )
+
+        if formatted_parts:
+            return "\n\n".join(formatted_parts)
+        return ""
+
     async def __call__(
         self,
         message: Union[
@@ -549,12 +613,20 @@ class McpAgent(ABC, ToolAgent):
             namespaced_tool = self._aggregator._namespaced_tool_map.get(tool_name)
             display_tool_name = namespaced_tool.tool.name if namespaced_tool else tool_name
 
+            # Find the index of the current tool in available_tools for highlighting
+            highlight_index = None
+            try:
+                highlight_index = available_tools.index(display_tool_name)
+            except ValueError:
+                # Tool not found in list, no highlighting
+                pass
+
             self.display.show_tool_call(
                 name=self._name,
                 tool_args=tool_args,
                 bottom_items=available_tools,
                 tool_name=display_tool_name,
-                highlight_items=tool_name,
+                highlight_index=highlight_index,
                 max_item_length=12,
             )
 

{fast_agent_mcp-0.3.5 → fast_agent_mcp-0.3.6}/src/fast_agent/agents/tool_agent.py

@@ -128,11 +128,21 @@ class ToolAgent(LlmAgent):
         for correlation_id, tool_request in request.tool_calls.items():
             tool_name = tool_request.params.name
             tool_args = tool_request.params.arguments or {}
+
+            # Find the index of the current tool in available_tools for highlighting
+            highlight_index = None
+            try:
+                highlight_index = available_tools.index(tool_name)
+            except ValueError:
+                # Tool not found in list, no highlighting
+                pass
+
             self.display.show_tool_call(
                 name=self.name,
                 tool_args=tool_args,
                 bottom_items=available_tools,
                 tool_name=tool_name,
+                highlight_index=highlight_index,
                 max_item_length=12,
             )
 

{fast_agent_mcp-0.3.5 → fast_agent_mcp-0.3.6}/src/fast_agent/agents/workflow/router_agent.py

@@ -300,10 +300,18 @@ class RouterAgent(LlmAgent):
             if response.reasoning:
                 routing_message += f" ({response.reasoning})"
 
+            # Convert highlight_items to highlight_index
+            agent_keys = list(self.agent_map.keys())
+            highlight_index = None
+            try:
+                highlight_index = agent_keys.index(response.agent)
+            except ValueError:
+                pass
+
             await self.display.show_assistant_message(
                 routing_message,
-                bottom_items=list(self.agent_map.keys()),
-                highlight_items=[response.agent],
+                bottom_items=agent_keys,
+                highlight_index=highlight_index,
                 name=self.name,
             )
 

{fast_agent_mcp-0.3.5 → fast_agent_mcp-0.3.6}/src/fast_agent/cli/commands/auth.py

@@ -22,14 +22,28 @@ from fast_agent.ui.console import console
 app = typer.Typer(help="Manage OAuth authentication state for MCP servers")
 
 
-def _get_keyring_backend_name() -> str:
+def _get_keyring_status() -> tuple[str, bool]:
+    """Return (backend_name, usable) where usable=False for the fail backend or missing keyring."""
     try:
         import keyring
 
         kr = keyring.get_keyring()
-        return getattr(kr, "name", kr.__class__.__name__)
+        name = getattr(kr, "name", kr.__class__.__name__)
+        try:
+            from keyring.backends.fail import Keyring as FailKeyring  # type: ignore
+
+            return name, not isinstance(kr, FailKeyring)
+        except Exception:
+            # If fail backend marker cannot be imported, assume usable
+            return name, True
     except Exception:
-        return "unavailable"
+        return "unavailable", False
+
+
+def _get_keyring_backend_name() -> str:
+    # Backwards-compat helper; prefer _get_keyring_status in new code
+    name, _ = _get_keyring_status()
+    return name
 
 
 def _keyring_get_password(service: str, username: str) -> str | None:
@@ -106,7 +120,7 @@ def status(
 ) -> None:
     """Show keyring backend and token status for configured MCP servers."""
     settings = get_settings(config_path)
-    backend = _get_keyring_backend_name()
+    backend, backend_usable = _get_keyring_status()
 
     # Single-target view if target provided
     if target:
@@ -123,12 +137,15 @@ def status(
 
         # Direct presence check
         present = False
-        try:
-            import keyring
+        if backend_usable:
+            try:
+                import keyring
 
-            present = keyring.get_password("fast-agent-mcp", f"oauth:tokens:{identity}") is not None
-        except Exception:
-            present = False
+                present = (
+                    keyring.get_password("fast-agent-mcp", f"oauth:tokens:{identity}") is not None
+                )
+            except Exception:
+                present = False
 
         table = Table(show_header=True, box=None)
         table.add_column("Identity", header_style="bold")
@@ -139,7 +156,10 @@ def status(
         token_disp = "[bold green]✓[/bold green]" if present else "[dim]✗[/dim]"
         table.add_row(identity, token_disp, servers_for_id)
 
-        console.print(f"Keyring backend: [green]{backend}[/green]")
+        if backend_usable and backend != "unavailable":
+            console.print(f"Keyring backend: [green]{backend}[/green]")
+        else:
+            console.print("Keyring backend: [red]not available[/red]")
         console.print(table)
         console.print(
             "\n[dim]Run 'fast-agent auth clear --identity "
@@ -148,7 +168,10 @@ def status(
         return
 
     # Full status view
-    console.print(f"Keyring backend: [green]{backend}[/green]")
+    if backend_usable and backend != "unavailable":
+        console.print(f"Keyring backend: [green]{backend}[/green]")
+    else:
+        console.print("Keyring backend: [red]not available[/red]")
 
     tokens = list_keyring_tokens()
     token_table = Table(show_header=True, box=None)
@@ -181,25 +204,25 @@ def status(
             )
             # Direct presence check for each identity so status works even without index
             has_token = False
+            token_disp = "[dim]✗[/dim]"
             if persist == "keyring" and row["oauth"]:
-                try:
-                    import keyring
-
-                    has_token = (
-                        keyring.get_password("fast-agent-mcp", f"oauth:tokens:{row['identity']}")
-                        is not None
-                    )
-                except Exception:
-                    has_token = False
-            token_disp = (
-                "[bold green]✓[/bold green]"
-                if has_token
-                else (
-                    "[yellow]memory[/yellow]"
-                    if persist == "memory" and row["oauth"]
-                    else "[dim]✗[/dim]"
-                )
-            )
+                if backend_usable:
+                    try:
+                        import keyring
+
+                        has_token = (
+                            keyring.get_password(
+                                "fast-agent-mcp", f"oauth:tokens:{row['identity']}"
+                            )
+                            is not None
+                        )
+                    except Exception:
+                        has_token = False
+                    token_disp = "[bold green]✓[/bold green]" if has_token else "[dim]✗[/dim]"
+                else:
+                    token_disp = "[red]not available[/red]"
+            elif persist == "memory" and row["oauth"]:
+                token_disp = "[yellow]memory[/yellow]"
             map_table.add_row(
                 row["name"],
                 row["transport"].upper(),

{fast_agent_mcp-0.3.5 → fast_agent_mcp-0.3.6}/src/fast_agent/cli/commands/check_config.py

@@ -305,14 +305,25 @@ def show_check_summary() -> None:
     env_table.add_column("Value")
 
     # Determine keyring backend early so it can appear in the top section
+    # Also detect whether the backend is actually usable (not the fail backend)
+    keyring_usable = False
     try:
         import keyring  # type: ignore
 
         keyring_backend = keyring.get_keyring()
         keyring_name = getattr(keyring_backend, "name", keyring_backend.__class__.__name__)
+        try:
+            # Detect the "fail" backend explicitly; it's present but unusable
+            from keyring.backends.fail import Keyring as FailKeyring  # type: ignore
+
+            keyring_usable = not isinstance(keyring_backend, FailKeyring)
+        except Exception:
+            # If we can't import the fail backend marker, assume usable
+            keyring_usable = True
     except Exception:
         keyring = None  # type: ignore
         keyring_name = "unavailable"
+        keyring_usable = False
 
     # Python info (highlight version and path in green)
     env_table.add_row(
@@ -345,11 +356,14 @@ def show_check_summary() -> None:
         )
     else:  # parsed successfully
         env_table.add_row("Config File", f"[green]Found[/green] ({config_path})")
-        default_model_value = config_summary.get("default_model", "haiku (system default)")
+        default_model_value = config_summary.get("default_model", "gpt-5-mini.low (system default)")
         env_table.add_row("Default Model", f"[green]{default_model_value}[/green]")
 
     # Keyring backend (always shown in application-level settings)
-    env_table.add_row("Keyring Backend", f"[green]{keyring_name}[/green]")
+    if keyring_usable and keyring_name != "unavailable":
+        env_table.add_row("Keyring Backend", f"[green]{keyring_name}[/green]")
+    else:
+        env_table.add_row("Keyring Backend", "[red]not available[/red]")
 
     console.print(env_table)
 
@@ -514,7 +528,9 @@ def show_check_summary() -> None:
                 try:
                     cfg = MCPServerSettings(
                         name=name,
-                        transport="sse" if transport == "SSE" else ("stdio" if transport == "STDIO" else "http"),
+                        transport="sse"
+                        if transport == "SSE"
+                        else ("stdio" if transport == "STDIO" else "http"),
                         url=(server.get("url") or None),
                         auth=server.get("auth") if isinstance(server.get("auth"), dict) else None,
                     )
@@ -532,11 +548,16 @@ def show_check_summary() -> None:
                     persist = "keyring"
                     if cfg.auth is not None and hasattr(cfg.auth, "persist"):
                         persist = getattr(cfg.auth, "persist") or "keyring"
-                    if keyring and persist == "keyring" and oauth_enabled:
+                    if keyring and keyring_usable and persist == "keyring" and oauth_enabled:
                         identity = compute_server_identity(cfg)
                         tkey = f"oauth:tokens:{identity}"
-                        has = keyring.get_password("fast-agent-mcp", tkey) is not None
+                        try:
+                            has = keyring.get_password("fast-agent-mcp", tkey) is not None
+                        except Exception:
+                            has = False
                         token_status = "[bold green]✓[/bold green]" if has else "[dim]✗[/dim]"
+                    elif persist == "keyring" and not keyring_usable and oauth_enabled:
+                        token_status = "[red]not available[/red]"
                     elif persist == "memory" and oauth_enabled:
                         token_status = "[yellow]memory[/yellow]"
 

{fast_agent_mcp-0.3.5 → fast_agent_mcp-0.3.6}/src/fast_agent/cli/commands/go.py

@@ -18,10 +18,16 @@ app = typer.Typer(
     context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
 )
 
+default_instruction = """You are a helpful AI Agent.
+
+{{serverInstructions}}
+
+The current date is {{currentDate}}."""
+
 
 async def _run_agent(
     name: str = "fast-agent cli",
-    instruction: str = "You are a helpful AI Agent.",
+    instruction: str = default_instruction,
     config_path: Optional[str] = None,
     server_list: Optional[List[str]] = None,
     model: Optional[str] = None,
@@ -352,7 +358,7 @@ def go(
         stdio_commands.append(stdio)
 
     # Resolve instruction from file/URL or use default
-    resolved_instruction = "You are a helpful AI Agent."  # Default
+    resolved_instruction = default_instruction  # Default
     agent_name = "agent"
 
     if instruction:

{fast_agent_mcp-0.3.5 → fast_agent_mcp-0.3.6}/src/fast_agent/cli/commands/setup.py

@@ -26,9 +26,7 @@ def load_template_text(filename: str) -> str:
         res_name = "pyproject.toml.tmpl"
     else:
         res_name = filename
-    resource_path = (
-        files("fast_agent").joinpath("resources").joinpath("setup").joinpath(res_name)
-    )
+    resource_path = files("fast_agent").joinpath("resources").joinpath("setup").joinpath(res_name)
     if resource_path.is_file():
         return resource_path.read_text()
 
@@ -137,9 +135,8 @@ def init(
         # Always use latest fast-agent-mcp (no version pin)
         fast_agent_dep = '"fast-agent-mcp"'
 
-        return (
-            template_text.replace("{{python_requires}}", py_req)
-            .replace("{{fast_agent_dep}}", fast_agent_dep)
+        return template_text.replace("{{python_requires}}", py_req).replace(
+            "{{fast_agent_dep}}", fast_agent_dep
         )
 
     pyproject_template = load_template_text("pyproject.toml")
@@ -169,7 +166,7 @@ def init(
                 "2. Keep fastagent.secrets.yaml secure and never commit it to version control"
             )
             console.print(
-                "3. Update fastagent.config.yaml to set a default model (currently system default is 'haiku')"
+                "3. Update fastagent.config.yaml to set a default model (currently system default is 'gpt-5-mini.low')"
             )
         console.print("\nTo get started, run:")
         console.print("  uv run agent.py")

{fast_agent_mcp-0.3.5 → fast_agent_mcp-0.3.6}/src/fast_agent/config.py

@@ -37,7 +37,7 @@ class MCPServerAuthSettings(BaseModel):
 
 
 class MCPSamplingSettings(BaseModel):
-    model: str = "haiku"
+    model: str = "gpt-5-mini.low"
 
     model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
 
@@ -122,6 +122,9 @@ class MCPServerSettings(BaseModel):
     cwd: str | None = None
     """Working directory for the executed server command."""
 
+    include_instructions: bool = True
+    """Whether to include this server's instructions in the system prompt (default: True)."""
+
     implementation: Implementation | None = None
 
     @model_validator(mode="before")

{fast_agent_mcp-0.3.5 → fast_agent_mcp-0.3.6}/src/fast_agent/mcp/mcp_aggregator.py

@@ -461,6 +461,36 @@ class MCPAggregator(ContextDependent):
         for server_name in self.server_names:
             await self._refresh_server_tools(server_name)
 
+    async def get_server_instructions(self) -> Dict[str, tuple[str, List[str]]]:
+        """
+        Get instructions from all connected servers along with their tool names.
+
+        Returns:
+            Dict mapping server name to tuple of (instructions, list of tool names)
+        """
+        instructions = {}
+
+        if self.connection_persistence and hasattr(self, '_persistent_connection_manager'):
+            # Get instructions from persistent connections
+            for server_name in self.server_names:
+                try:
+                    server_conn = await self._persistent_connection_manager.get_server(
+                        server_name, client_session_factory=self._create_session_factory(server_name)
+                    )
+                    # Always include server, even if no instructions
+                    # Get tool names for this server
+                    tool_names = [
+                        namespaced_tool.tool.name
+                        for namespaced_tool_name, namespaced_tool in self._namespaced_tool_map.items()
+                        if namespaced_tool.server_name == server_name
+                    ]
+                    # Include server even if instructions is None
+                    instructions[server_name] = (server_conn.server_instructions, tool_names)
+                except Exception as e:
+                    logger.debug(f"Failed to get instructions from server {server_name}: {e}")
+
+        return instructions
+
     async def _execute_on_server(
         self,
         server_name: str,

{fast_agent_mcp-0.3.5 → fast_agent_mcp-0.3.6}/src/fast_agent/mcp/mcp_connection_manager.py

@@ -105,6 +105,9 @@ class ServerConnection:
         self._error_occurred = False
         self._error_message = None
 
+        # Server instructions from initialization
+        self.server_instructions: str | None = None
+
     def is_healthy(self) -> bool:
         """Check if the server connection is healthy and ready to use."""
         return self.session is not None and not self._error_occurred
@@ -131,10 +134,20 @@ class ServerConnection:
         Initializes the server connection and session.
         Must be called within an async context.
         """
-
+        assert self.session, "Session must be created before initialization"
         result = await self.session.initialize()
 
         self.server_capabilities = result.capabilities
+
+        # Store instructions if provided by the server and enabled in config
+        if self.server_config.include_instructions:
+            self.server_instructions = getattr(result, 'instructions', None)
+            if self.server_instructions:
+                logger.debug(f"{self.server_name}: Received server instructions", data={"instructions": self.server_instructions})
+        else:
+            self.server_instructions = None
+            logger.debug(f"{self.server_name}: Server instructions disabled by configuration")
+
         # If there's an init hook, run it
 
         # Now the session is ready for use
@@ -343,7 +356,9 @@ class MCPConnectionManager(ContextDependent):
         def transport_context_factory():
             if config.transport == "stdio":
                 if not config.command:
-                    raise ValueError(f"Server '{server_name}' uses stdio transport but no command is specified")
+                    raise ValueError(
+                        f"Server '{server_name}' uses stdio transport but no command is specified"
+                    )
                 server_params = StdioServerParameters(
                     command=config.command,
                     args=config.args if config.args is not None else [],
@@ -357,7 +372,9 @@ class MCPConnectionManager(ContextDependent):
                 return _add_none_to_context(stdio_client(server_params, errlog=error_handler))
             elif config.transport == "sse":
                 if not config.url:
-                    raise ValueError(f"Server '{server_name}' uses sse transport but no url is specified")
+                    raise ValueError(
+                        f"Server '{server_name}' uses sse transport but no url is specified"
+                    )
                 # Suppress MCP library error spam
                 self._suppress_mcp_sse_errors()
                 oauth_auth = build_oauth_provider(config)
@@ -376,7 +393,9 @@ class MCPConnectionManager(ContextDependent):
                 )
             elif config.transport == "http":
                 if not config.url:
-                    raise ValueError(f"Server '{server_name}' uses http transport but no url is specified")
+                    raise ValueError(
+                        f"Server '{server_name}' uses http transport but no url is specified"
+                    )
                 oauth_auth = build_oauth_provider(config)
                 headers = dict(config.headers or {})
                 if oauth_auth is not None: