fix: load MCP tools only for main agent

Move MCP loading from load_agent() to KimiCLI.create() to ensure
MCP servers are initialized only once, regardless of subagent count.

Closes #518

Author: xiaoju111a

examples/kimi-psql/main.py

@@ -280,7 +280,7 @@ async def create_psql_soul(llm: LLM, conninfo: str) -> KimiSoul:
 
     # Load agent from configuration
     agent_file = Path(__file__).parent / "agent.yaml"
-    agent = await load_agent(agent_file, runtime, mcp_configs=[])
+    agent = await load_agent(agent_file, runtime)
 
     # Add custom ExecuteSql tool to the loaded agent
     cast(KimiToolset, agent.toolset).add(ExecuteSql(conninfo))

src/kimi_cli/app.py

@@ -118,7 +118,26 @@ async def create(
 
         if agent_file is None:
             agent_file = DEFAULT_AGENT_FILE
-        agent = await load_agent(agent_file, runtime, mcp_configs=mcp_configs or [])
+        agent = await load_agent(agent_file, runtime)
+
+        # Load MCP tools only for main agent (not subagents)
+        if mcp_configs:
+            import pydantic
+            from fastmcp.mcp_config import MCPConfig
+
+            from kimi_cli.exception import MCPConfigError
+
+            validated: list[MCPConfig] = []
+            for mcp_config in mcp_configs:
+                try:
+                    validated.append(
+                        mcp_config
+                        if isinstance(mcp_config, MCPConfig)
+                        else MCPConfig.model_validate(mcp_config)
+                    )
+                except pydantic.ValidationError as e:
+                    raise MCPConfigError(f"Invalid MCP config: {e}") from e
+            await agent.toolset.load_mcp_tools(validated, runtime)
 
         context = Context(session.context_file)
         await context.restore()

src/kimi_cli/soul/agent.py

@@ -6,15 +6,12 @@
 from dataclasses import asdict, dataclass
 from datetime import datetime
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
 
-import pydantic
 from kaos.path import KaosPath
 from kosong.tooling import Toolset
 
 from kimi_cli.agentspec import load_agent_spec
 from kimi_cli.config import Config
-from kimi_cli.exception import MCPConfigError
 from kimi_cli.llm import LLM
 from kimi_cli.session import Session
 from kimi_cli.skill import discover_skills, get_claude_skills_dir, get_skills_dir
@@ -25,9 +22,6 @@
 from kimi_cli.utils.logging import logger
 from kimi_cli.utils.path import list_directory
 
-if TYPE_CHECKING:
-    from fastmcp.mcp_config import MCPConfig
-
 
 @dataclass(frozen=True, slots=True, kw_only=True)
 class BuiltinSystemPromptArgs:
@@ -177,21 +171,14 @@ def add_dynamic_subagent(self, name: str, agent: Agent):
         self.dynamic_subagents[name] = agent
 
 
-async def load_agent(
-    agent_file: Path,
-    runtime: Runtime,
-    *,
-    mcp_configs: list[MCPConfig] | list[dict[str, Any]],
-) -> Agent:
+async def load_agent(agent_file: Path, runtime: Runtime) -> Agent:
     """
     Load agent from specification file.
 
     Raises:
         FileNotFoundError: When the agent file is not found.
         AgentSpecError(KimiCLIException, ValueError): When the agent specification is invalid.
         InvalidToolError(KimiCLIException, ValueError): When any tool cannot be loaded.
-        MCPConfigError(KimiCLIException, ValueError): When any MCP configuration is invalid.
-        MCPRuntimeError(KimiCLIException, RuntimeError): When any MCP server cannot be connected.
     """
     logger.info("Loading agent: {agent_file}", agent_file=agent_file)
     agent_spec = load_agent_spec(agent_file)
@@ -205,11 +192,7 @@ async def load_agent(
     # load subagents before loading tools because Task tool depends on LaborMarket on initialization
     for subagent_name, subagent_spec in agent_spec.subagents.items():
         logger.debug("Loading subagent: {subagent_name}", subagent_name=subagent_name)
-        subagent = await load_agent(
-            subagent_spec.path,
-            runtime.copy_for_fixed_subagent(),
-            mcp_configs=[],  # Subagents don't need MCP tools, only main agent loads them
-        )
+        subagent = await load_agent(subagent_spec.path, runtime.copy_for_fixed_subagent())
         runtime.labor_market.add_fixed_subagent(subagent_name, subagent, subagent_spec.description)
 
     toolset = KimiToolset()
@@ -230,22 +213,6 @@ async def load_agent(
         tools = [tool for tool in tools if tool not in agent_spec.exclude_tools]
     toolset.load_tools(tools, tool_deps)
 
-    if mcp_configs:
-        validated_mcp_configs: list[MCPConfig] = []
-        if mcp_configs:
-            from fastmcp.mcp_config import MCPConfig
-
-            for mcp_config in mcp_configs:
-                try:
-                    validated_mcp_configs.append(
-                        mcp_config
-                        if isinstance(mcp_config, MCPConfig)
-                        else MCPConfig.model_validate(mcp_config)
-                    )
-                except pydantic.ValidationError as e:
-                    raise MCPConfigError(f"Invalid MCP config: {e}") from e
-        await toolset.load_mcp_tools(validated_mcp_configs, runtime)
-
     return Agent(
         name=agent_spec.name,
         system_prompt=system_prompt,

tests/test_default_agent.py

@@ -14,7 +14,7 @@
 
 @pytest.mark.skipif(platform.system() == "Windows", reason="Skipping test on Windows")
 async def test_default_agent(runtime: Runtime):
-    agent = await load_agent(DEFAULT_AGENT_FILE, runtime, mcp_configs=[])
+    agent = await load_agent(DEFAULT_AGENT_FILE, runtime)
     assert agent.system_prompt.replace(
         f"{runtime.builtin_args.KIMI_WORK_DIR}", "/path/to/work/dir"
     ) == snapshot(

tests/test_load_agent.py

@@ -73,7 +73,7 @@ def test_load_tools_invalid(runtime: Runtime):
 async def test_load_agent_invalid_tools(agent_file_invalid_tools: Path, runtime: Runtime):
     """Test loading agent with invalid tools raises ValueError."""
     with pytest.raises(ValueError, match="Invalid tools"):
-        await load_agent(agent_file_invalid_tools, runtime, mcp_configs=[])
+        await load_agent(agent_file_invalid_tools, runtime)
 
 
 @pytest.fixture