swarmkit-runtime 1.0.0__tar.gz

swarmkit_runtime-1.0.0/.gitignore

@@ -0,0 +1,66 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+.venv/
+venv/
+env/
+.eggs/
+*.egg-info/
+*.egg
+build/
+dist/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.pyre/
+.pytype/
+.coverage
+.coverage.*
+htmlcov/
+coverage.xml
+*.cover
+.hypothesis/
+.tox/
+.nox/
+
+# Node / TypeScript
+node_modules/
+.next/
+out/
+.turbo/
+.nx/
+dist/
+*.tsbuildinfo
+.pnpm-store/
+.yarn/
+
+# Editors / OS
+.vscode/
+.idea/
+*.swp
+*.swo
+.DS_Store
+Thumbs.db
+*~
+
+# Env / secrets
+.env
+.env.local
+.env.*.local
+*.pem
+
+# SwarmKit runtime artifacts (per design §9.3)
+.swarmkit/
+*.sqlite
+*.sqlite-journal
+
+# Claude Code
+.claude/settings.local.json
+
+# Build / logs
+*.log
+.cache/
+_site/

swarmkit_runtime-1.0.0/CLAUDE.md

@@ -0,0 +1,55 @@
+# CLAUDE.md — packages/runtime
+
+## Package identity
+
+`swarmkit-runtime` — the Python component of the three-package system. Loads topology files, compiles them into LangGraph graphs, enforces governance through the `GovernanceProvider` abstraction, and exposes the `swarmkit` CLI + FastAPI server.
+
+The design doc is the authoritative source for architectural decisions — see `design/SwarmKit-Design-v0.6.md`. §9, §14, §16, §18 are the most relevant sections to this package.
+
+## Module map
+
+| Module | Responsibility | Design ref |
+| --- | --- | --- |
+| `cli/` | Typer-based CLI, authoring entry points | §14.2 |
+| `topology/` | Load, validate, resolve topology YAML/JSON | §10 |
+| `skills/` | Skill registry + category semantics (capability, decision, coordination, persistence) | §6 |
+| `archetypes/` | Archetype registry and instantiation | §13 |
+| `governance/` | `GovernanceProvider` interface + `AGTGovernanceProvider` | §8.5, §16.5 |
+| `langgraph_compiler/` | Topology → `StateGraph` dynamic construction | §14.3 |
+| `mcp/` | MCP client + sandboxed server lifecycle | §18 |
+| `audit/` | Append-only audit log, skill gap log surfacing | §14.5, §16.4 |
+
+## Non-negotiable invariants
+
+These come from the design's architectural principles and separation-of-powers model. Do not relax without explicit approval.
+
+1. **Topology is data.** Never generate or inline topology as Python code inside this package. The runtime reads YAML/JSON and interprets.
+2. **All governance goes through `GovernanceProvider`.** No direct AGT imports outside `governance/`. If code needs policy evaluation, identity, or audit, it goes through the interface.
+3. **Audit is append-only from agent perspective.** No code path should expose `update` or `delete` on audit entries to executive-layer callers.
+4. **Pillar boundaries are enforced at the module level** (design §8.4). Executive code invokes skills via middleware that routes through the policy engine — there is no bypass.
+5. **Skills are the only extension primitive.** When adding a capability, add a skill category or skill definition — do not introduce parallel extension mechanisms.
+6. **Eject must stay intact.** Every feature you add to the runtime needs an ejection story; if it cannot be expressed in generated LangGraph code, reconsider the design.
+
+## Style
+
+- Python 3.11+, strict typing (`mypy --strict`).
+- Prefer `pydantic` models for all schema-shaped data; use `dataclass` only for internal value objects.
+- Async-first where I/O is involved (`anyio` / `httpx` / `fastapi`).
+- Error taxonomy: custom exceptions live in each module's `_errors.py`; no bare `raise Exception`.
+
+## Testing
+
+- `pytest` + `pytest-asyncio`. Tests live under `tests/`.
+- Integration tests that touch real MCP servers or AGT gate on env vars; unit tests mock at the `GovernanceProvider` seam.
+- Every reference topology ships a smoke test that loads + compiles it without executing.
+
+## Commands
+
+```bash
+uv run pytest packages/runtime/tests             # tests
+uv run ruff check packages/runtime               # lint
+uv run mypy packages/runtime                     # typecheck
+uv run swarmkit --help                           # CLI entry
+```
+
+Or via the root justfile: `just test-py`, `just lint-py`, `just typecheck-py`.

swarmkit_runtime-1.0.0/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: swarmkit-runtime
+Version: 1.0.0
+Summary: SwarmKit runtime: topology interpreter, LangGraph compiler, AGT-backed governance, CLI and HTTP server.
+Author: Srijith Kartha
+License: MIT
+Keywords: agents,agt,langgraph,mcp,multi-agent,swarm
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Requires-Dist: agent-os-kernel<4.0,>=3.2.0
+Requires-Dist: agent-sre<4.0,>=3.2.0
+Requires-Dist: agentmesh-platform<4.0,>=3.2.0
+Requires-Dist: anthropic>=0.39
+Requires-Dist: anyio>=4.4
+Requires-Dist: fastapi>=0.115
+Requires-Dist: google-genai>=1.0
+Requires-Dist: httpx>=0.27
+Requires-Dist: langchain-core>=0.3
+Requires-Dist: langgraph>=0.2
+Requires-Dist: mcp>=1.0
+Requires-Dist: openai>=1.50
+Requires-Dist: pydantic>=2.8
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.7
+Requires-Dist: sqlalchemy>=2.0
+Requires-Dist: swarmkit-schema
+Requires-Dist: typer>=0.12
+Requires-Dist: uvicorn[standard]>=0.30
+Provides-Extra: dev
+Requires-Dist: mypy>=1.11; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Requires-Dist: types-pyyaml; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# swarmkit-runtime
+
+Python runtime for SwarmKit. Interprets topology files, compiles them into LangGraph `StateGraph`s, enforces governance via the `GovernanceProvider` abstraction (AGT-backed in v1.0), and exposes the `swarmkit` CLI plus a persistent HTTP server.
+
+## Layout
+
+```
+src/swarmkit_runtime/
+├── cli/                 # Typer-based CLI: init, author, run, serve, eject
+├── topology/            # Topology loader, validator, resolver (archetype + skill refs)
+├── skills/              # Skill registry, category-specific semantics, composition
+├── archetypes/          # Archetype registry and instantiation
+├── governance/          # GovernanceProvider interface + AGTGovernanceProvider impl
+├── langgraph_compiler/  # Topology → StateGraph compilation (design §14.3)
+├── mcp/                 # MCP client, server lifecycle, sandbox supervision
+└── audit/               # Append-only audit log adapters, skill gap log surfacing
+```
+
+## Design references
+
+- §7 Architectural Principles — `topology as data`, `eject, never lock-in`
+- §8 Separation of Powers — `governance/` module is the SwarmKit side; AGT is the implementation
+- §9 System Architecture — this package is component #1 of 3
+- §14 Runtime Architecture — three execution modes (one-shot, persistent, scheduled)
+
+## Entry points (design §14.2)
+
+| Command | What it does |
+| --- | --- |
+| `swarmkit init` | Launch Workspace Authoring Swarm in terminal chat mode |
+| `swarmkit author topology [name]` | Launch Topology Authoring variant |
+| `swarmkit author skill [name]` | Launch Skill Authoring Swarm |
+| `swarmkit author archetype [name]` | Launch Archetype Authoring variant |
+| `swarmkit run topology.yaml` | One-shot execution |
+| `swarmkit serve workspace/` | Persistent / scheduled mode |
+| `swarmkit eject topology.yaml` | Export LangGraph code |
+
+## Development
+
+```bash
+uv sync --package swarmkit-runtime
+uv run pytest packages/runtime/tests
+uv run swarmkit --help
+```

swarmkit_runtime-1.0.0/README.md

@@ -0,0 +1,44 @@
+# swarmkit-runtime
+
+Python runtime for SwarmKit. Interprets topology files, compiles them into LangGraph `StateGraph`s, enforces governance via the `GovernanceProvider` abstraction (AGT-backed in v1.0), and exposes the `swarmkit` CLI plus a persistent HTTP server.
+
+## Layout
+
+```
+src/swarmkit_runtime/
+├── cli/                 # Typer-based CLI: init, author, run, serve, eject
+├── topology/            # Topology loader, validator, resolver (archetype + skill refs)
+├── skills/              # Skill registry, category-specific semantics, composition
+├── archetypes/          # Archetype registry and instantiation
+├── governance/          # GovernanceProvider interface + AGTGovernanceProvider impl
+├── langgraph_compiler/  # Topology → StateGraph compilation (design §14.3)
+├── mcp/                 # MCP client, server lifecycle, sandbox supervision
+└── audit/               # Append-only audit log adapters, skill gap log surfacing
+```
+
+## Design references
+
+- §7 Architectural Principles — `topology as data`, `eject, never lock-in`
+- §8 Separation of Powers — `governance/` module is the SwarmKit side; AGT is the implementation
+- §9 System Architecture — this package is component #1 of 3
+- §14 Runtime Architecture — three execution modes (one-shot, persistent, scheduled)
+
+## Entry points (design §14.2)
+
+| Command | What it does |
+| --- | --- |
+| `swarmkit init` | Launch Workspace Authoring Swarm in terminal chat mode |
+| `swarmkit author topology [name]` | Launch Topology Authoring variant |
+| `swarmkit author skill [name]` | Launch Skill Authoring Swarm |
+| `swarmkit author archetype [name]` | Launch Archetype Authoring variant |
+| `swarmkit run topology.yaml` | One-shot execution |
+| `swarmkit serve workspace/` | Persistent / scheduled mode |
+| `swarmkit eject topology.yaml` | Export LangGraph code |
+
+## Development
+
+```bash
+uv sync --package swarmkit-runtime
+uv run pytest packages/runtime/tests
+uv run swarmkit --help
+```

swarmkit_runtime-1.0.0/pyproject.toml

@@ -0,0 +1,82 @@
+[project]
+name = "swarmkit-runtime"
+version = "1.0.0"
+description = "SwarmKit runtime: topology interpreter, LangGraph compiler, AGT-backed governance, CLI and HTTP server."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "Srijith Kartha" }]
+keywords = ["agents", "multi-agent", "swarm", "langgraph", "mcp", "agt"]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+# Dependencies below are intentionally un-pinned placeholders. Lock concrete
+# versions once Phase 1 implementation begins — see design §20.1.
+dependencies = [
+    # Core
+    "pydantic>=2.8",
+    "pyyaml>=6.0",
+    "typer>=0.12",           # CLI — `swarmkit` entrypoint
+    "rich>=13.7",            # terminal rendering for authoring chat
+    "httpx>=0.27",
+    "anyio>=4.4",
+
+    # Execution engine (design §7, §14)
+    "langgraph>=0.2",
+    "langchain-core>=0.3",
+
+    # Governance — Microsoft AGT (design §8, §16).
+    # Pinned to 3.x; AGT is iterating fast (public preview, v1→v3 in 7 weeks).
+    # The GovernanceProvider ABC (§8.5) isolates the runtime from AGT API churn.
+    "agent-os-kernel>=3.2.0,<4.0",
+    "agentmesh-platform>=3.2.0,<4.0",
+    "agent-sre>=3.2.0,<4.0",
+
+    # MCP (design §18)
+    "mcp>=1.0",
+
+    # LLM SDKs — one per ModelProvider built-in (design/details/model-provider-abstraction.md).
+    # Only model_providers/ imports these; everything else goes through ModelProvider ABC.
+    "anthropic>=0.39",
+    "google-genai>=1.0",
+    "openai>=1.50",
+    # Ollama uses httpx only (already in core deps) — no dedicated SDK.
+
+    # HTTP server for persistent mode (design §14.1)
+    "fastapi>=0.115",
+    "uvicorn[standard]>=0.30",
+
+    # Storage / checkpointing (design §14.5)
+    "sqlalchemy>=2.0",
+    # "psycopg[binary]>=3.2",  # optional Postgres backend
+
+    # Schema package (workspace sibling)
+    "swarmkit-schema",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.23",
+    "pytest-cov>=5.0",
+    "mypy>=1.11",
+    "ruff>=0.6",
+    "types-pyyaml",
+]
+
+[project.scripts]
+swarmkit = "swarmkit_runtime.cli:app"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/swarmkit_runtime"]

swarmkit_runtime-1.0.0/src/swarmkit_runtime/__init__.py

@@ -0,0 +1,6 @@
+"""SwarmKit runtime — topology interpreter, LangGraph compiler, governance wiring.
+
+See `design/SwarmKit-Design-v0.6.md` §9 and §14 for architectural context.
+"""
+
+__version__ = "0.0.1"

swarmkit_runtime-1.0.0/src/swarmkit_runtime/_workspace_runtime.py

@@ -0,0 +1,308 @@
+"""WorkspaceRuntime — the backend that CLI, HTTP server, and web UI call into.
+
+Owns the full execution lifecycle: resolve workspace → build providers →
+build governance → wire MCP → compile topology → invoke graph → close.
+The CLI is a thin interface over this; ``swarmkit serve`` (M9) and the
+v1.1 web UI will be additional interfaces over the same class.
+
+See ``design/details/workspace-runtime.md`` (to be written) and the
+architectural decision in ``memory/feedback_cli_architecture.md``.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from langgraph.graph.state import CompiledStateGraph
+
+from swarmkit_runtime.governance import GovernanceProvider
+from swarmkit_runtime.governance._mock import MockGovernanceProvider
+from swarmkit_runtime.langgraph_compiler import compile_topology
+from swarmkit_runtime.mcp import MCPClientManager, MCPServerConfig, parse_mcp_servers
+from swarmkit_runtime.model_providers import (
+    AnthropicModelProvider,
+    GoogleModelProvider,
+    GroqModelProvider,
+    MockModelProvider,
+    OllamaModelProvider,
+    OpenAIModelProvider,
+    OpenRouterModelProvider,
+    ProviderRegistry,
+    TogetherModelProvider,
+)
+from swarmkit_runtime.model_providers._registry import ModelProviderProtocol
+from swarmkit_runtime.resolver import ResolvedWorkspace, resolve_workspace
+
+
+@dataclass(frozen=True)
+class RunResult:
+    """Output of a topology execution."""
+
+    output: str
+    agent_results: dict[str, str] = field(default_factory=dict)
+
+
+class MissingMCPServerError(Exception):
+    """A skill targets an MCP server that the workspace doesn't declare."""
+
+    def __init__(self, missing: list[tuple[str, str]]) -> None:
+        self.missing = missing
+        lines = [
+            f"skill '{sid}' targets MCP server '{srv}' but the workspace declares no such server"
+            for sid, srv in missing
+        ]
+        super().__init__("\n".join(lines))
+
+
+class WorkspaceRuntime:
+    """The backend that both CLI and HTTP server call into.
+
+    Holds a resolved workspace plus all the wired runtime components
+    (model providers, governance, MCP manager). Constructed via the
+    ``from_workspace_path`` classmethod.
+    """
+
+    def __init__(
+        self,
+        *,
+        workspace: ResolvedWorkspace,
+        workspace_root: Path,
+        provider_registry: ProviderRegistry,
+        governance: GovernanceProvider,
+        mcp_manager: MCPClientManager | None,
+    ) -> None:
+        self._workspace = workspace
+        self._workspace_root = workspace_root
+        self._provider_registry = provider_registry
+        self._governance = governance
+        self._mcp_manager = mcp_manager
+
+    @classmethod
+    def from_workspace_path(cls, path: Path) -> WorkspaceRuntime:
+        """Build a fully-wired runtime from a workspace directory.
+
+        Resolves the workspace, registers model providers, selects the
+        governance provider, parses MCP server config, and validates
+        that every mcp_tool skill targets a configured server.
+
+        Raises ``ResolutionErrors`` if the workspace is invalid, or
+        ``MissingMCPServerError`` if skills reference unconfigured
+        MCP servers.
+        """
+        ws_root = path.resolve()
+        workspace = resolve_workspace(ws_root)
+
+        registry = ProviderRegistry()
+        register_available_providers(registry)
+
+        governance = build_governance(workspace, ws_root)
+
+        mcp_configs = parse_mcp_servers(getattr(workspace.raw, "mcp_servers", None))
+        mcp_manager = MCPClientManager(mcp_configs, workspace_root=ws_root) if mcp_configs else None
+
+        missing = find_missing_mcp_servers(workspace, mcp_configs)
+        if missing:
+            raise MissingMCPServerError(missing)
+
+        return cls(
+            workspace=workspace,
+            workspace_root=ws_root,
+            provider_registry=registry,
+            governance=governance,
+            mcp_manager=mcp_manager,
+        )
+
+    def compile(self, topology_name: str) -> CompiledStateGraph[Any]:
+        """Compile a named topology into a LangGraph graph.
+
+        Raises ``KeyError`` if the topology doesn't exist.
+        """
+        if topology_name not in self._workspace.topologies:
+            available = sorted(self._workspace.topologies.keys())
+            raise KeyError(
+                f"Topology '{topology_name}' not found. "
+                f"Available: {', '.join(available) or '(none)'}."
+            )
+
+        topology = self._workspace.topologies[topology_name]
+        return compile_topology(
+            topology,
+            provider_registry=self._provider_registry,
+            governance=self._governance,
+            mcp_manager=self._mcp_manager,
+        )
+
+    async def run(
+        self,
+        topology_name: str,
+        user_input: str,
+        *,
+        max_steps: int = 10,
+    ) -> RunResult:
+        """Execute a topology end-to-end and return the result.
+
+        Handles MCP session lifecycle (start_all / close_all) within
+        the same async task so the SDK's anyio task groups unwind cleanly.
+        """
+        graph = self.compile(topology_name)
+
+        if self._mcp_manager is not None:
+            await self._mcp_manager.start_all()
+        try:
+            result = await graph.ainvoke(
+                {
+                    "input": user_input,
+                    "messages": [],
+                    "agent_results": {},
+                    "current_agent": "",
+                    "output": "",
+                },
+                config={"recursion_limit": max_steps},
+            )
+        finally:
+            if self._mcp_manager is not None:
+                await self._mcp_manager.close_all()
+
+        return RunResult(
+            output=result.get("output", ""),
+            agent_results={
+                k: str(v) for k, v in result.get("agent_results", {}).items() if isinstance(v, str)
+            },
+        )
+
+    async def close(self) -> None:
+        """Release all held resources."""
+        if self._mcp_manager is not None:
+            await self._mcp_manager.close_all()
+
+    @property
+    def workspace(self) -> ResolvedWorkspace:
+        return self._workspace
+
+    @property
+    def workspace_root(self) -> Path:
+        return self._workspace_root
+
+    @property
+    def governance(self) -> GovernanceProvider:
+        return self._governance
+
+    @property
+    def mcp_manager(self) -> MCPClientManager | None:
+        return self._mcp_manager
+
+    @property
+    def provider_registry(self) -> ProviderRegistry:
+        return self._provider_registry
+
+
+# ---- helpers (public — used by CLI and tests) ----------------------------
+
+
+def register_available_providers(registry: ProviderRegistry) -> None:
+    """Register all model providers whose credentials are in the environment."""
+    registry.register(MockModelProvider())
+
+    if os.environ.get("ANTHROPIC_API_KEY"):
+        registry.register(AnthropicModelProvider())
+    if os.environ.get("GOOGLE_API_KEY"):
+        registry.register(GoogleModelProvider())
+    if os.environ.get("OPENAI_API_KEY"):
+        registry.register(OpenAIModelProvider())
+    if os.environ.get("OPENROUTER_API_KEY"):
+        registry.register(OpenRouterModelProvider())
+    if os.environ.get("GROQ_API_KEY"):
+        registry.register(GroqModelProvider())
+    if os.environ.get("TOGETHER_API_KEY"):
+        registry.register(TogetherModelProvider())
+
+    registry.register(OllamaModelProvider())
+
+
+def build_governance(workspace: ResolvedWorkspace, ws_root: Path) -> GovernanceProvider:
+    """Select the GovernanceProvider based on workspace.yaml's governance block."""
+    gov = getattr(workspace.raw, "governance", None)
+    if gov is None:
+        return MockGovernanceProvider(allow_all=True)
+
+    provider_value = gov.provider.value if hasattr(gov.provider, "value") else str(gov.provider)
+
+    if provider_value == "agt":
+        from swarmkit_runtime.governance.agt_provider import AGTGovernanceProvider  # noqa: PLC0415
+
+        config = gov.config or {}
+        policies_dir = ws_root / config.get("policies_dir", "policies")
+        audit_db = ws_root / ".swarmkit" / "audit.db"
+        audit_db.parent.mkdir(parents=True, exist_ok=True)
+        return AGTGovernanceProvider.from_config(
+            policy_dir=policies_dir,
+            audit_db=audit_db,
+        )
+
+    if provider_value == "custom":
+        print(
+            "warning: governance.provider=custom is not yet supported; "
+            "falling back to mock. See design §8.5 for the plugin path.",
+            file=sys.stderr,
+        )
+
+    return MockGovernanceProvider(allow_all=True)
+
+
+def resolve_authoring_provider(
+    registry: ProviderRegistry | None = None,
+) -> tuple[ModelProviderProtocol, str]:
+    """Resolve which model provider + model name to use for authoring.
+
+    Checks SWARMKIT_AUTHOR_MODEL (format: provider/model), then falls
+    back to SWARMKIT_PROVIDER + SWARMKIT_MODEL, then first available
+    real provider.
+    """
+    author_model = os.environ.get("SWARMKIT_AUTHOR_MODEL", "")
+    if "/" in author_model:
+        provider_id, model_name = author_model.split("/", 1)
+    else:
+        provider_id = os.environ.get("SWARMKIT_PROVIDER", "")
+        model_name = os.environ.get("SWARMKIT_MODEL", "")
+
+    if registry is None:
+        registry = ProviderRegistry()
+        register_available_providers(registry)
+
+    if provider_id:
+        provider = registry.get(provider_id)
+        if provider is not None:
+            return provider, model_name or "claude-sonnet-4-6"
+
+    for pid in registry.provider_ids:
+        if pid == "mock":
+            continue
+        provider = registry.get(pid)
+        if provider is not None:
+            return provider, model_name or "claude-sonnet-4-6"
+
+    raise RuntimeError(
+        "No model provider available. Set SWARMKIT_PROVIDER "
+        "and the corresponding API key (e.g. GROQ_API_KEY)."
+    )
+
+
+def find_missing_mcp_servers(
+    workspace: ResolvedWorkspace,
+    mcp_configs: dict[str, MCPServerConfig],
+) -> list[tuple[str, str]]:
+    """Return ``(skill_id, server_id)`` pairs whose mcp_tool target is unconfigured."""
+    missing: list[tuple[str, str]] = []
+    for skill_id, skill in workspace.skills.items():
+        impl = skill.raw.implementation
+        impl_type = impl.get("type") if isinstance(impl, dict) else getattr(impl, "type", None)
+        if impl_type != "mcp_tool":
+            continue
+        server_id = impl.get("server") if isinstance(impl, dict) else getattr(impl, "server", "")
+        if server_id and server_id not in mcp_configs:
+            missing.append((skill_id, server_id))
+    return missing