Dev/0.7.3 (#790)

* commit

* mcp from plugin

* remove unneedded plugin tests

Author: evalstate

pyproject.toml

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

src/fast_agent/acp/slash_commands.py

@@ -48,6 +48,7 @@
 from fast_agent.command_actions import (
     PluginCommandActionContext,
     PluginCommandActionRegistry,
+    PluginRuntimeFacade,
 )
 from fast_agent.command_actions.accessors import (
     plugin_command_base_path_for_provider,
@@ -69,6 +70,7 @@
 if TYPE_CHECKING:
     from fast_agent.acp.acp_context import ACPContext
     from fast_agent.command_actions.models import PluginCommandAgentProtocol
+    from fast_agent.command_actions.runtime import AttachMcpServerCallback, DetachMcpServerCallback
     from fast_agent.commands.context import AgentProvider
     from fast_agent.config import MCPServerSettings
     from fast_agent.core.fastagent import AgentInstance
@@ -770,6 +772,24 @@ async def _execute_plugin_command_action(
                     agent=cast("PluginCommandAgentProtocol", agent),
                     settings=command_context.settings,
                     session_cwd=command_context.session_cwd,
+                    runtime=PluginRuntimeFacade(
+                        current_agent_name=agent.name,
+                        attach_mcp_server_callback=cast(
+                            "AttachMcpServerCallback | None",
+                            self._attach_mcp_server_callback,
+                        ),
+                        detach_mcp_server_callback=cast(
+                            "DetachMcpServerCallback | None",
+                            self._detach_mcp_server_callback,
+                        ),
+                        list_attached_mcp_servers_callback=(
+                            self._list_attached_mcp_servers_callback
+                        ),
+                        list_configured_detached_mcp_servers_callback=(
+                            self._list_configured_detached_mcp_servers_callback
+                        ),
+                    ),
+                    is_acp=True,
                 ),
             )
         except AgentConfigError as exc:

src/fast_agent/agents/tool_runner.py

@@ -19,6 +19,7 @@
     DEFAULT_MAX_ITERATIONS,
     FAST_AGENT_ERROR_CHANNEL,
     FAST_AGENT_SYNTHETIC_FINAL_CHANNEL,
+    FAST_AGENT_TIMING,
     FAST_AGENT_USAGE,
 )
 from fast_agent.core.logging.logger import get_logger
@@ -698,9 +699,10 @@ def _synthesize_passthrough_assistant(
             FAST_AGENT_SYNTHETIC_FINAL_CHANNEL: [text_content("tool_result_passthrough")]
         }
         if self._last_message is not None and self._last_message.channels:
-            usage_blocks = self._last_message.channels.get(FAST_AGENT_USAGE)
-            if usage_blocks:
-                channels[FAST_AGENT_USAGE] = list(usage_blocks)
+            for channel_name in (FAST_AGENT_TIMING, FAST_AGENT_USAGE):
+                blocks = self._last_message.channels.get(channel_name)
+                if blocks:
+                    channels[channel_name] = list(blocks)
 
         return PromptMessageExtended(
             role="assistant",

src/fast_agent/batch/structured.py

@@ -22,8 +22,8 @@
 from fast_agent.batch.template import DEFAULT_ROW_TEMPLATE, render_row_template
 from fast_agent.batch.traces import BatchTraceOptions, BatchTraceRecorder
 from fast_agent.cli.runtime.request_builders import resolve_default_instruction
-from fast_agent.constants import FAST_AGENT_TIMING
-from fast_agent.llm.request_params import RequestParams
+from fast_agent.constants import FAST_AGENT_TIMING, FAST_AGENT_USAGE
+from fast_agent.llm.request_params import BatchRequestContext, RequestParams
 from fast_agent.llm.structured_schema import (
     StructuredSchemaSource,
     load_json_schema_file,
@@ -120,21 +120,38 @@ def _identity_for_candidate(candidate: RowCandidate, id_field: str | None) -> tu
     return str(row[id_field]), None
 
 
-def _extract_timing(response: Any) -> dict[str, Any] | None:
+def _extract_json_channel(response: Any, channel_name: str) -> dict[str, Any] | None:
     channels = response.channels
     if not isinstance(channels, Mapping):
         return None
-    timing_blocks = channels.get(FAST_AGENT_TIMING)
-    if not timing_blocks:
+    blocks = channels.get(channel_name)
+    if not blocks:
         return None
-    timing_text = get_text(timing_blocks[0])
-    if not timing_text:
+    text = get_text(blocks[0])
+    if not text:
         return None
     try:
-        timing = json.loads(timing_text)
+        payload = json.loads(text)
     except json.JSONDecodeError:
         return None
-    return timing if isinstance(timing, dict) else None
+    return payload if isinstance(payload, dict) else None
+
+
+def _extract_timing(response: Any) -> dict[str, Any] | None:
+    return _extract_json_channel(response, FAST_AGENT_TIMING)
+
+
+def _extract_usage(response: Any) -> dict[str, Any] | None:
+    usage = _extract_json_channel(response, FAST_AGENT_USAGE)
+    if usage is None:
+        return None
+    if "turn" not in usage and "raw_usage" not in usage:
+        return usage
+    return {
+        key: value
+        for key in ("turn", "raw_usage")
+        if (value := usage.get(key)) is not None
+    }
 
 
 def _write_optional_failure(
@@ -152,6 +169,7 @@ def _write_optional_telemetry(
     row_number: int,
     ok: bool,
     timing: dict[str, Any] | None,
+    usage: dict[str, Any] | None = None,
 ) -> None:
     if telemetry_handle is None:
         return
@@ -162,7 +180,7 @@ def _write_optional_telemetry(
             "row_number": row_number,
             "ok": ok,
             "timing": timing or {},
-            "usage": {},
+            "usage": usage or {},
         },
     )
 
@@ -350,8 +368,13 @@ async def run_structured_batch(options: StructuredBatchOptions) -> dict[str, Any
                                 worker,
                                 rendered=rendered,
                                 schema_source=schema_source,
+                                batch_context=BatchRequestContext(
+                                    row_number=candidate.row_number,
+                                    identity=identity,
+                                ),
                             )
                             timing = _extract_timing(response)
+                            usage = _extract_usage(response)
                             summary.add_timing(timing)
                             if parsed is None:
                                 record = error_envelope(
@@ -372,6 +395,7 @@ async def run_structured_batch(options: StructuredBatchOptions) -> dict[str, Any
                                     row_number=candidate.row_number,
                                     ok=False,
                                     timing=timing,
+                                    usage=usage,
                                 )
                                 summary.processed_rows += 1
                                 summary.failed_rows += 1
@@ -399,6 +423,7 @@ async def run_structured_batch(options: StructuredBatchOptions) -> dict[str, Any
                                 row_number=candidate.row_number,
                                 ok=True,
                                 timing=timing,
+                                usage=usage,
                             )
                             summary.processed_rows += 1
                             if trace_recorder is not None:
@@ -516,8 +541,9 @@ async def _row_call(
     *,
     rendered: str,
     schema_source: SchemaSource | None,
+    batch_context: BatchRequestContext,
 ) -> tuple[Any | None, Any]:
-    request_params = RequestParams(use_history=False)
+    request_params = RequestParams(use_history=False, batch_context=batch_context)
     if schema_source is None:
         response = await worker.generate(rendered, request_params)
         return response.last_text() or "", response

src/fast_agent/cli/commands/check_config.py

@@ -92,7 +92,7 @@ class ProviderCatalogScope:
         providers=(Provider.HUGGINGFACE,),
     ),
     "xai": ProviderCatalogScope(
-        display_name="XAI",
+        display_name="xAI",
         providers=(Provider.XAI,),
     ),
     "openrouter": ProviderCatalogScope(

src/fast_agent/command_actions/__init__.py

@@ -13,6 +13,7 @@
     PluginCommandActionRegistry,
     normalize_plugin_command_action_result,
 )
+from fast_agent.command_actions.runtime import PluginRuntime, PluginRuntimeFacade
 
 __all__ = [
     "FAST_AGENT_AUDIT_CHANNEL",
@@ -22,6 +23,8 @@
     "PluginCommandActionRegistry",
     "PluginCommandActionResult",
     "PluginCommandActionSpec",
+    "PluginRuntime",
+    "PluginRuntimeFacade",
     "parse_plugin_command_action_specs",
     "normalize_plugin_command_action_result",
 ]

src/fast_agent/command_actions/loader.py

@@ -4,6 +4,7 @@
 
 import importlib.util
 import inspect
+import sys
 from pathlib import Path
 from typing import TYPE_CHECKING, cast
 
@@ -43,9 +44,11 @@ def load_plugin_command_action_function(
         )
 
     module = importlib.util.module_from_spec(import_spec)
+    sys.modules[module_name] = module
     try:
         import_spec.loader.exec_module(module)
     except Exception as exc:  # noqa: BLE001
+        sys.modules.pop(module_name, None)
         raise AgentConfigError(
             f"Failed to import command action module for '{spec}'",
             str(exc),

src/fast_agent/command_actions/models.py

@@ -13,6 +13,7 @@
     from pathlib import Path
 
     from fast_agent.agents.agent_types import AgentConfig
+    from fast_agent.command_actions.runtime import PluginRuntime
     from fast_agent.config import Settings
     from fast_agent.context import Context
     from fast_agent.interfaces import AgentProtocol
@@ -97,6 +98,9 @@ class PluginCommandActionContext:
     agent: PluginCommandAgentProtocol
     settings: "Settings | None" = None
     session_cwd: Path | None = None
+    runtime: "PluginRuntime | None" = None
+    is_tui: bool = False
+    is_acp: bool = False
 
     @property
     def agent_name(self) -> str:

src/fast_agent/command_actions/runtime.py

@@ -0,0 +1,120 @@
+"""Runtime capabilities exposed to plugin command actions."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Awaitable, Callable, Protocol
+
+if TYPE_CHECKING:
+    from fast_agent.config import MCPServerSettings
+    from fast_agent.mcp.mcp_aggregator import MCPAttachOptions, MCPAttachResult, MCPDetachResult
+
+
+AttachMcpServerCallback = Callable[
+    [str, str, "MCPServerSettings | None", "MCPAttachOptions | None"],
+    Awaitable["MCPAttachResult"],
+]
+DetachMcpServerCallback = Callable[[str, str], Awaitable["MCPDetachResult"]]
+ListMcpServersCallback = Callable[[str], Awaitable[list[str]]]
+
+
+class PluginRuntime(Protocol):
+    """Stable live-runtime capabilities exposed to plugin command actions."""
+
+    async def attach_mcp_server(
+        self,
+        *,
+        server_name: str,
+        agent_name: str | None = None,
+        server_config: "MCPServerSettings | None" = None,
+        options: "MCPAttachOptions | None" = None,
+    ) -> "MCPAttachResult":
+        """Attach an MCP server to a running MCP-capable agent and refresh instructions."""
+
+    async def detach_mcp_server(
+        self,
+        *,
+        server_name: str,
+        agent_name: str | None = None,
+    ) -> "MCPDetachResult":
+        """Detach an MCP server from a running MCP-capable agent and refresh instructions."""
+
+    async def list_attached_mcp_servers(
+        self,
+        *,
+        agent_name: str | None = None,
+    ) -> tuple[str, ...]:
+        """List MCP servers attached to a running MCP-capable agent."""
+
+    async def list_configured_detached_mcp_servers(
+        self,
+        *,
+        agent_name: str | None = None,
+    ) -> tuple[str, ...]:
+        """List configured MCP servers that are not currently attached."""
+
+
+@dataclass(frozen=True, slots=True)
+class PluginRuntimeFacade:
+    """Callback-backed implementation of plugin runtime capabilities."""
+
+    current_agent_name: str
+    attach_mcp_server_callback: AttachMcpServerCallback | None = None
+    detach_mcp_server_callback: DetachMcpServerCallback | None = None
+    list_attached_mcp_servers_callback: ListMcpServersCallback | None = None
+    list_configured_detached_mcp_servers_callback: ListMcpServersCallback | None = None
+
+    def _target_agent_name(self, agent_name: str | None) -> str:
+        return agent_name or self.current_agent_name
+
+    async def attach_mcp_server(
+        self,
+        *,
+        server_name: str,
+        agent_name: str | None = None,
+        server_config: "MCPServerSettings | None" = None,
+        options: "MCPAttachOptions | None" = None,
+    ) -> "MCPAttachResult":
+        if self.attach_mcp_server_callback is None:
+            raise RuntimeError("Runtime MCP server attachment is not available.")
+        return await self.attach_mcp_server_callback(
+            self._target_agent_name(agent_name),
+            server_name,
+            server_config,
+            options,
+        )
+
+    async def detach_mcp_server(
+        self,
+        *,
+        server_name: str,
+        agent_name: str | None = None,
+    ) -> "MCPDetachResult":
+        if self.detach_mcp_server_callback is None:
+            raise RuntimeError("Runtime MCP server detachment is not available.")
+        return await self.detach_mcp_server_callback(
+            self._target_agent_name(agent_name),
+            server_name,
+        )
+
+    async def list_attached_mcp_servers(
+        self,
+        *,
+        agent_name: str | None = None,
+    ) -> tuple[str, ...]:
+        if self.list_attached_mcp_servers_callback is None:
+            raise RuntimeError("Runtime MCP server listing is not available.")
+        servers = await self.list_attached_mcp_servers_callback(self._target_agent_name(agent_name))
+        return tuple(servers)
+
+    async def list_configured_detached_mcp_servers(
+        self,
+        *,
+        agent_name: str | None = None,
+    ) -> tuple[str, ...]:
+        if self.list_configured_detached_mcp_servers_callback is None:
+            raise RuntimeError("Configured MCP server listing is not available.")
+        servers = await self.list_configured_detached_mcp_servers_callback(
+            self._target_agent_name(agent_name)
+        )
+        return tuple(servers)

src/fast_agent/core/agent_card_loader.py

@@ -1179,7 +1179,7 @@ def _dump_request_params(params: RequestParams | None) -> dict[str, Any] | None:
         return None
     dump = params.model_dump(
         exclude_defaults=True,
-        exclude={"messages", "systemPrompt", "use_history", "model"},
+        exclude={"messages", "systemPrompt", "use_history", "model", "batch_context"},
     )
     return dump or None