@team-agent/installer 0.2.10 → 0.3.0

package/src/team_agent/provider_cli/codex.py

@@ -1,336 +0,0 @@
-from __future__ import annotations
-
-import json
-import re
-import subprocess
-import time
-from datetime import datetime, timedelta, timezone
-from pathlib import Path
-from typing import Any
-
-from team_agent.permissions import resolve_permissions
-from team_agent.provider_cli.adapter import (
-    ProviderAdapter,
-    ResumeUnavailable,
-    agent_model,
-    parse_time,
-)
-from team_agent.provider_cli.prompt import compile_system_prompt
-
-
-class CodexAdapter(ProviderAdapter):
-    provider = "codex"
-    command_name = "codex"
-    _model_catalog_cache: dict[str, Any] | None = None
-
-    def build_command(self, agent: dict[str, Any], workspace: Path, mcp_config: dict[str, Any]) -> list[str]:
-        cmd = self._base_command(agent, mcp_config, resume=False)
-        return cmd
-
-    def build_resume_command(
-        self,
-        agent_state: dict[str, Any],
-        workspace: Path,
-        mcp_config: dict[str, Any] | None = None,
-    ) -> list[str]:
-        _ = workspace
-        session_id = agent_state.get("session_id")
-        if not session_id:
-            raise ResumeUnavailable("codex resume requires session_id")
-        agent = dict(agent_state.get("_agent_spec") or agent_state)
-        cmd = self._base_command(agent, mcp_config or {}, resume=True)
-        cmd.append(str(session_id))
-        return cmd
-
-    def supports_session_fork(self, agent: dict[str, Any] | None = None) -> bool:
-        return not agent or agent.get("auth_mode") != "compatible_api"
-
-    def build_fork_command(
-        self,
-        agent: dict[str, Any],
-        source_session_id: str,
-        workspace: Path,
-        mcp_config: dict[str, Any],
-    ) -> list[str]:
-        _ = workspace
-        if not source_session_id:
-            raise ResumeUnavailable("codex fork requires source session_id")
-        cmd = self._base_command(agent, mcp_config, resume=False, fork=True)
-        cmd.append(str(source_session_id))
-        return cmd
-
-    def capture_session_id(
-        self,
-        agent_id: str,
-        spawn_context: dict[str, Any],
-        timeout_s: float = 3.0,
-    ) -> dict[str, Any] | None:
-        _ = agent_id
-        cwd = spawn_context.get("cwd")
-        if not cwd:
-            return None
-        start = parse_time(spawn_context.get("spawn_time")) or datetime.now(timezone.utc)
-        root = Path(spawn_context.get("sessions_root") or Path.home() / ".codex" / "sessions")
-        deadline = time.monotonic() + max(timeout_s, 0.0)
-        exclude = {str(item) for item in spawn_context.get("exclude_session_ids", []) if item}
-        while True:
-            match = find_codex_rollout(root, Path(str(cwd)), start, exclude_session_ids=exclude)
-            if match:
-                return {
-                    "session_id": match["session_id"],
-                    "rollout_path": match["rollout_path"],
-                    "captured_at": datetime.now(timezone.utc).isoformat(),
-                    "captured_via": "fs_watch",
-                    "attribution_confidence": match["confidence"],
-                    "spawn_cwd": str(cwd),
-                }
-            if time.monotonic() >= deadline:
-                return None
-            time.sleep(0.2)
-
-    def _base_command(
-        self,
-        agent: dict[str, Any],
-        mcp_config: dict[str, Any],
-        resume: bool,
-        fork: bool = False,
-    ) -> list[str]:
-        prompt = compile_system_prompt(agent)
-        cmd = ["codex"]
-        if resume:
-            cmd.append("resume")
-        elif fork:
-            cmd.append("fork")
-        cmd.extend(["--no-alt-screen", "--disable", "shell_snapshot", "--disable", "apps"])
-        profile_overrides = agent.get("_provider_profile", {}).get("command_overrides", {})
-        if profile_overrides.get("codex_profile"):
-            cmd.extend(["--profile", str(profile_overrides["codex_profile"])])
-        if agent.get("_runtime", {}).get("dangerous_auto_approve"):
-            cmd.append("--dangerously-bypass-approvals-and-sandbox")
-        else:
-            tools = set(resolve_permissions(agent)["tools"])
-            sandbox = "workspace-write" if {"fs_write", "execute_bash"} & tools else "read-only"
-            cmd.extend(["--sandbox", sandbox, "--ask-for-approval", "on-request"])
-        model = agent_model(agent)
-        if model:
-            cmd.extend(["--model", model])
-        for config in profile_overrides.get("codex_config", []):
-            cmd.extend(["-c", str(config)])
-        if prompt:
-            escaped = prompt.replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n")
-            cmd.extend(["-c", f'developer_instructions="{escaped}"'])
-        for server_name, cfg in mcp_config.items():
-            prefix = f"mcp_servers.{server_name}"
-            cmd.extend(["-c", f'{prefix}.command="{cfg["command"]}"'])
-            args = "[" + ", ".join(json.dumps(str(arg)) for arg in cfg.get("args", [])) + "]"
-            cmd.extend(["-c", f"{prefix}.args={args}"])
-            for env_key, env_val in cfg.get("env", {}).items():
-                cmd.extend(["-c", f'{prefix}.env.{env_key}="{env_val}"'])
-            cmd.extend(["-c", f"{prefix}.tool_timeout_sec=600.0"])
-        return cmd
-
-    def auth_hint(self) -> dict[str, Any]:
-        if "OPENAI_API_KEY" in __import__("os").environ:
-            return {"status": "present", "detail": "OPENAI_API_KEY is set"}
-        if Path.home().joinpath(".codex").exists():
-            return {"status": "present", "detail": "~/.codex exists; run codex login if startup fails"}
-        return {"status": "missing_or_unknown", "detail": "run codex login or set OPENAI_API_KEY"}
-
-    def status_patterns(self) -> dict[str, str]:
-        return {"idle": r"(›|❯|codex>)", "processing": r"•.*esc to interrupt", "error": "Error|Traceback|panic"}
-
-    def handle_startup_prompts(
-        self,
-        session_name: str,
-        window_name: str,
-        checks: int = 30,
-        sleep_s: float = 0.5,
-    ) -> list[dict[str, Any]]:
-        handled: list[dict[str, Any]] = []
-        target = f"{session_name}:{window_name}"
-        for _ in range(max(checks, 0)):
-            proc = subprocess.run(
-                ["tmux", "capture-pane", "-p", "-S", "-", "-t", target],
-                text=True,
-                capture_output=True,
-                timeout=5,
-                check=False,
-            )
-            output = proc.stdout if proc.returncode == 0 else ""
-            update = maybe_skip_update_prompt(target, output)
-            if update:
-                handled.append(update)
-                if sleep_s > 0:
-                    time.sleep(sleep_s)
-                continue
-            trust_pos = max(
-                output.rfind("Do you trust the contents of this directory?"),
-                output.rfind("Do you trust the files in this folder?"),
-                output.rfind("Do you trust this folder?"),
-            )
-            ready_pos = max(output.rfind("OpenAI Codex"), output.rfind("›"), output.rfind("codex>"))
-            if trust_pos >= 0 and trust_pos > ready_pos:
-                subprocess.run(["tmux", "send-keys", "-t", target, "Enter"], check=False)
-                handled.append({"prompt": "codex_workspace_trust", "action": "sent_enter"})
-                if sleep_s > 0:
-                    time.sleep(sleep_s)
-                continue
-            if ready_pos >= 0:
-                break
-            if sleep_s > 0:
-                time.sleep(sleep_s)
-        return handled
-
-    def handle_runtime_prompts(self, session_name: str, window_name: str) -> list[dict[str, Any]]:
-        target = f"{session_name}:{window_name}"
-        proc = subprocess.run(
-            ["tmux", "capture-pane", "-p", "-S", "-", "-t", target],
-            text=True,
-            capture_output=True,
-            timeout=5,
-            check=False,
-        )
-        output = proc.stdout if proc.returncode == 0 else ""
-        handled = maybe_skip_update_prompt(target, output)
-        return [handled] if handled else []
-
-    def validate_model(self, model: str | None) -> dict[str, Any]:
-        if not model:
-            return {"ok": True, "status": "model_not_set", "provider": self.provider, "model": model}
-        catalog = self._model_catalog()
-        if not catalog.get("ok"):
-            details = {key: value for key, value in catalog.items() if key != "ok"}
-            return {"ok": False, "status": "model_catalog_unavailable", "provider": self.provider, "model": model, **details}
-        models = catalog.get("models", [])
-        slugs = {str(item.get("slug") or "") for item in models if item.get("slug")}
-        if model in slugs:
-            return {"ok": True, "status": "model_supported", "provider": self.provider, "model": model}
-        slug_by_lower = {slug.lower(): slug for slug in slugs}
-        display_to_slug = {
-            str(item.get("display_name") or "").lower(): str(item.get("slug"))
-            for item in models
-            if item.get("display_name") and item.get("slug")
-        }
-        normalized = model.lower()
-        suggested = slug_by_lower.get(normalized) or display_to_slug.get(normalized)
-        result = {
-            "ok": False,
-            "status": "unsupported_model",
-            "reason": "model_id_not_found",
-            "provider": self.provider,
-            "model": model,
-            "available_models": sorted(slugs),
-        }
-        if suggested:
-            result["reason"] = "model_id_not_exact"
-            result["suggested_model"] = suggested
-        return result
-
-    def _model_catalog(self) -> dict[str, Any]:
-        if self._model_catalog_cache is not None:
-            return self._model_catalog_cache
-        if not self.is_installed():
-            return {"ok": False, "reason": "codex_command_missing", "command": self.command_name}
-        try:
-            proc = subprocess.run(
-                [self.command_name, "debug", "models"],
-                text=True,
-                capture_output=True,
-                timeout=12,
-                check=False,
-            )
-        except (OSError, subprocess.TimeoutExpired) as exc:
-            return {"ok": False, "reason": "model_catalog_command_failed", "command": "codex debug models", "error": str(exc)}
-        if proc.returncode != 0:
-            return {
-                "ok": False,
-                "reason": "model_catalog_command_failed",
-                "command": "codex debug models",
-                "stderr": proc.stderr.strip(),
-            }
-        try:
-            data = json.loads(proc.stdout or "{}")
-        except json.JSONDecodeError as exc:
-            return {"ok": False, "reason": "model_catalog_parse_failed", "command": "codex debug models", "error": str(exc)}
-        models = data.get("models")
-        if not isinstance(models, list):
-            return {"ok": False, "reason": "model_catalog_shape_invalid", "command": "codex debug models"}
-        self._model_catalog_cache = {"ok": True, "command": "codex debug models", "models": models}
-        return self._model_catalog_cache
-
-
-def maybe_skip_update_prompt(target: str, output: str) -> dict[str, Any] | None:
-    update_pos = max(output.rfind("Update available!"), output.rfind("Update now"))
-    ready_pos = max(output.rfind("OpenAI Codex"), output.rfind("›"), output.rfind("codex>"))
-    if update_pos >= 0 and update_pos > ready_pos:
-        subprocess.run(["tmux", "send-keys", "-t", target, "Down", "Enter"], check=False)
-        return {"prompt": "codex_update_available", "action": "sent_skip"}
-    return None
-
-
-def find_codex_rollout(
-    root: Path,
-    cwd: Path,
-    spawn_time: datetime,
-    exclude_session_ids: set[str] | None = None,
-) -> dict[str, Any] | None:
-    if not root.exists():
-        return None
-    exclude_session_ids = exclude_session_ids or set()
-    lower_bound = spawn_time - timedelta(seconds=2)
-    upper_bound = datetime.now(timezone.utc) + timedelta(seconds=5)
-    candidates: list[dict[str, Any]] = []
-    for path in sorted(root.glob("**/rollout-*.jsonl"), key=lambda p: p.stat().st_mtime, reverse=True)[:1500]:
-        meta = read_codex_session_meta(path)
-        if not meta:
-            continue
-        meta_cwd = meta.get("cwd")
-        if not meta_cwd:
-            continue
-        try:
-            same_cwd = Path(str(meta_cwd)).resolve() == cwd.resolve()
-        except OSError:
-            same_cwd = str(meta_cwd) == str(cwd)
-        if not same_cwd:
-            continue
-        ts = parse_time(meta.get("timestamp"))
-        if ts and (ts < lower_bound or ts > upper_bound):
-            continue
-        originator = meta.get("originator")
-        origin_ok = originator in {"codex-tui", "codex_exec"}
-        session_id = meta.get("id") or rollout_id_from_name(path)
-        if not session_id:
-            continue
-        if str(session_id) in exclude_session_ids:
-            continue
-        candidates.append(
-            {
-                "session_id": str(session_id),
-                "rollout_path": str(path),
-                "timestamp": ts or datetime.fromtimestamp(path.stat().st_mtime, timezone.utc),
-                "confidence": "high" if origin_ok and ts else "medium",
-            }
-        )
-    if not candidates:
-        return None
-    candidates.sort(key=lambda item: item["timestamp"])
-    return candidates[0]
-
-
-def read_codex_session_meta(path: Path) -> dict[str, Any] | None:
-    try:
-        with path.open(encoding="utf-8") as handle:
-            first = handle.readline()
-        data = json.loads(first)
-    except (OSError, json.JSONDecodeError):
-        return None
-    if "session_meta" in data:
-        payload = data.get("session_meta", {}).get("payload")
-    else:
-        payload = data.get("payload")
-    return payload if isinstance(payload, dict) else None
-
-
-def rollout_id_from_name(path: Path) -> str | None:
-    match = re.search(r"([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})\.jsonl$", path.name)
-    return match.group(1) if match else None

package/src/team_agent/provider_cli/copilot.py

@@ -1,8 +0,0 @@
-from __future__ import annotations
-
-from team_agent.provider_cli.unsupported import UnsupportedCliPlug
-
-
-class CopilotCliPlug(UnsupportedCliPlug):
-    provider = "copilot"
-    command_name = "copilot"

package/src/team_agent/provider_cli/fake.py

@@ -1,39 +0,0 @@
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-from typing import Any
-
-from team_agent.provider_cli.adapter import ProviderAdapter
-
-
-class FakeAdapter(ProviderAdapter):
-    provider = "fake"
-    command_name = sys.executable
-
-    def build_command(self, agent: dict[str, Any], workspace: Path, mcp_config: dict[str, Any]) -> list[str]:
-        return [
-            sys.executable,
-            "-m",
-            "team_agent.fake_worker",
-            "--workspace",
-            str(workspace),
-            "--agent-id",
-            agent["id"],
-        ]
-
-    def build_resume_command(
-        self,
-        agent_state: dict[str, Any],
-        workspace: Path,
-        mcp_config: dict[str, Any] | None = None,
-    ) -> list[str]:
-        agent = dict(agent_state.get("_agent_spec") or agent_state)
-        agent.setdefault("id", agent_state.get("agent_id") or agent_state.get("id"))
-        return self.build_command(agent, workspace, mcp_config or {})
-
-    def auth_hint(self) -> dict[str, Any]:
-        return {"status": "present", "detail": "fake provider is local test worker"}
-
-    def status_patterns(self) -> dict[str, str]:
-        return {"idle": "TEAM_AGENT_FAKE_READY", "processing": "TEAM_AGENT_FAKE_WORKING", "error": "Traceback"}

package/src/team_agent/provider_cli/gemini.py

@@ -1,95 +0,0 @@
-from __future__ import annotations
-
-import json
-from pathlib import Path
-from typing import Any
-
-from team_agent.provider_cli.adapter import (
-    ProviderAdapter,
-    agent_model,
-    read_json_object,
-)
-from team_agent.provider_cli.prompt import compile_system_prompt
-
-
-class GeminiCliAdapter(ProviderAdapter):
-    provider = "gemini_cli"
-    command_name = "gemini"
-
-    def build_command(self, agent: dict[str, Any], workspace: Path, mcp_config: dict[str, Any]) -> list[str]:
-        prompt = compile_system_prompt(agent)
-        cmd = ["gemini"]
-        if agent.get("_runtime", {}).get("dangerous_auto_approve"):
-            cmd.extend(["--yolo", "--sandbox", "false"])
-        model = agent_model(agent)
-        if model:
-            cmd.extend(["--model", model])
-        if prompt:
-            cmd.extend(["-i", prompt])
-        return cmd
-
-    def install_mcp(self, workspace: Path, agent_id: str, config: dict[str, Any]) -> Path:
-        path = super().install_mcp(workspace, agent_id, config)
-        self._register_mcp_servers(path, config)
-        return path
-
-    def cleanup_mcp(self, workspace: Path, agent_id: str, mcp_path: Path | None = None) -> None:
-        path = mcp_path or workspace / ".team" / "runtime" / "mcp" / f"{agent_id}.json"
-        self._restore_mcp_servers(path)
-
-    def _register_mcp_servers(self, mcp_path: Path, config: dict[str, Any]) -> None:
-        settings_path = Path.home() / ".gemini" / "settings.json"
-        settings_path.parent.mkdir(parents=True, exist_ok=True)
-        settings = read_json_object(settings_path)
-        mcp_servers = settings.setdefault("mcpServers", {})
-        if not isinstance(mcp_servers, dict):
-            raise ValueError(f"{settings_path}: mcpServers must be an object")
-
-        backup = {
-            "settings_path": str(settings_path),
-            "servers": {name: mcp_servers.get(name) for name in config},
-        }
-        gemini_backup_path(mcp_path).write_text(json.dumps(backup, indent=2), encoding="utf-8")
-
-        for name, server in config.items():
-            mcp_servers[name] = {
-                "command": server["command"],
-                "args": server.get("args", []),
-                "env": server.get("env", {}),
-            }
-        settings_path.write_text(json.dumps(settings, indent=2), encoding="utf-8")
-
-    def _restore_mcp_servers(self, mcp_path: Path) -> None:
-        backup_path = gemini_backup_path(mcp_path)
-        if not backup_path.exists():
-            return
-        backup = json.loads(backup_path.read_text(encoding="utf-8"))
-        settings_path = Path(backup["settings_path"])
-        settings = read_json_object(settings_path)
-        mcp_servers = settings.setdefault("mcpServers", {})
-        if not isinstance(mcp_servers, dict):
-            raise ValueError(f"{settings_path}: mcpServers must be an object")
-        for name, previous in backup.get("servers", {}).items():
-            if previous is None:
-                mcp_servers.pop(name, None)
-            else:
-                mcp_servers[name] = previous
-        settings_path.write_text(json.dumps(settings, indent=2), encoding="utf-8")
-        backup_path.unlink(missing_ok=True)
-
-    def auth_hint(self) -> dict[str, Any]:
-        if "GEMINI_API_KEY" in __import__("os").environ:
-            return {"status": "present", "detail": "GEMINI_API_KEY is set"}
-        if Path.home().joinpath(".gemini").exists():
-            return {"status": "present", "detail": "~/.gemini exists; run gemini to verify OAuth"}
-        return {"status": "missing_or_unknown", "detail": "run gemini OAuth setup or set GEMINI_API_KEY"}
-
-    def status_patterns(self) -> dict[str, str]:
-        return {"idle": r"\*\s+Type your message", "processing": r"\(esc to cancel", "error": "Error|APIError|Traceback"}
-
-    def exit_text(self) -> str:
-        return "\x04"
-
-
-def gemini_backup_path(mcp_path: Path) -> Path:
-    return mcp_path.with_suffix(".gemini-backup.json")

package/src/team_agent/provider_cli/opencode.py

@@ -1,8 +0,0 @@
-from __future__ import annotations
-
-from team_agent.provider_cli.unsupported import UnsupportedCliPlug
-
-
-class OpenCodeCliPlug(UnsupportedCliPlug):
-    provider = "opencode"
-    command_name = "opencode"

package/src/team_agent/provider_cli/prompt.py

@@ -1,62 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any
-
-from team_agent.permissions import resolve_permissions
-
-
-TEAMMATE_SYSTEM_PROMPT = """# Team Agent Teammate Runtime Contract
-
-You are a teammate in a Team Agent runtime, not the user's primary assistant.
-The user normally talks to the team lead. Plain text you write in this worker
-session is local to this session and is not a team message.
-
-Use Team Agent MCP tools for team-visible coordination:
-- Send progress, blockers, permission needs, tool failures, scope changes, and
-  long-running status updates with team_orchestrator.send_message(to='leader',
-  content='<short message>').
-- Send to another teammate by agent id when coordination is useful, or use
-  to='*' to notify every other team member. The runtime resolves only this team
-  and excludes your own worker.
-- When the task is complete, call team_orchestrator.report_result exactly once.
-- Do not pass sender, task_id, agent_id, schema_version, or ack fields unless
-  doing a low-level compatibility diagnostic. The MCP runtime fills protocol
-  fields from the current worker and task state.
-
-If you are blocked or cannot continue, message the leader promptly instead of
-waiting silently. If work takes several minutes, send a short progress update.
-"""
-
-
-def compile_system_prompt(agent: dict[str, Any]) -> str:
-    prompt_cfg = agent.get("system_prompt", {})
-    identity = (
-        f"You are Team Agent worker `{agent.get('id')}` with role `{agent.get('role')}`. "
-        "When asked about your role or identity, answer with this Team Agent worker identity first, "
-        "not only the generic provider product identity."
-    )
-    chunks: list[str] = [identity, TEAMMATE_SYSTEM_PROMPT]
-    if prompt_cfg.get("inline"):
-        chunks.append(str(prompt_cfg["inline"]))
-    if prompt_cfg.get("file"):
-        chunks.append(Path(prompt_cfg["file"]).read_text(encoding="utf-8"))
-    contract = agent.get("output_contract", {})
-    if contract.get("format") == "result_envelope_v1":
-        chunks.append(
-            "For progress or blockers, call team_orchestrator.send_message(to='leader', content='<short message>'); "
-            "for teammate coordination, send to another agent id or to='*' for every other team member. "
-            "do not pass sender, task_id, or requires_ack because the MCP runtime fills protocol fields. "
-            "the runtime injects it into the attached Codex leader pane when the leader has run attach-leader. "
-            "If no leader is attached, the tool returns a fallback/failed result instead of completion. "
-            "Final completion must call team_orchestrator.report_result exactly once with a short summary "
-            "and optional status/changes/tests; MCP fills schema_version, task_id, and agent_id."
-        )
-    perms = resolve_permissions(agent)
-    if perms["has_prompt_only"]:
-        prompt_only = [e["tool"] for e in perms["resolved_tools"] if e["enforcement"] == "prompt_only"]
-        chunks.append(
-            "Permission note: these tools are prompt-only for this provider and not hard-enforced: "
-            + ", ".join(prompt_only)
-        )
-    return "\n\n".join(chunk for chunk in chunks if chunk)

package/src/team_agent/provider_cli/registry.py

@@ -1,18 +0,0 @@
-from __future__ import annotations
-
-from team_agent.provider_cli.base import ProviderCliSocket
-from team_agent.provider_cli.copilot import CopilotCliPlug
-from team_agent.provider_cli.opencode import OpenCodeCliPlug
-
-
-PLUG_TYPES = {
-    "opencode": OpenCodeCliPlug,
-    "copilot": CopilotCliPlug,
-}
-
-
-def build_plug(provider: str) -> ProviderCliSocket:
-    try:
-        return PLUG_TYPES[provider]()
-    except KeyError as exc:
-        raise KeyError(f"Unsupported provider plug: {provider}") from exc

package/src/team_agent/provider_cli/unsupported.py

@@ -1,32 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from team_agent.provider_cli.base import ProviderCapabilityError, ProviderStartupInput
-
-
-class UnsupportedCliPlug:
-    provider = ""
-    command_name = ""
-
-    def build_command(self, startup: ProviderStartupInput) -> list[str]:
-        _ = startup
-        self._unsupported("start")
-
-    def build_resume_command(self, startup: ProviderStartupInput) -> list[str]:
-        _ = startup
-        self._unsupported("resume")
-
-    def build_fork_command(self, startup: ProviderStartupInput, source_session_id: str) -> list[str]:
-        _ = startup, source_session_id
-        self._unsupported("fork_or_branch")
-
-    def capture_session_id(self, startup: ProviderStartupInput, timeout_s: float = 3.0) -> dict[str, Any] | None:
-        _ = startup, timeout_s
-        return None
-
-    def cleanup(self, startup: ProviderStartupInput) -> None:
-        _ = startup
-
-    def _unsupported(self, capability: str) -> Any:
-        raise ProviderCapabilityError(self.provider, capability, "provider plug exists but is not implemented yet")