@team-agent/installer 0.2.10 → 0.3.0

package/src/team_agent/profiles/helpers.py

@@ -1,69 +0,0 @@
-from __future__ import annotations
-
-import re
-import urllib.parse
-from typing import Any
-
-from team_agent.rust_core import redact_text
-from team_agent.profiles.constants import SECRET_KEYS
-
-
-def _format_profile_check_failure(check: dict[str, Any]) -> str:
-    agent_id = check.get("agent_id") or "unknown"
-    profile = check.get("profile") or "-"
-    reason = check.get("reason") or "profile_invalid"
-    suggestion = check.get("suggestion") or f"Inspect safely with `team-agent profile show {profile} --workspace . --json`."
-    return f"profile validation failed for {agent_id} profile {profile}: {reason}. {suggestion}"
-
-def _alternate_value(values: dict[str, str], key: str) -> str | None:
-    alternates = {
-        "BASE_URL": ["ANTHROPIC_BASE_URL", "OPENAI_BASE_URL"],
-        "API_KEY": ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "AUTH_TOKEN", "OPENAI_API_KEY", "GEMINI_API_KEY"],
-    }
-    for candidate in alternates.get(key, []):
-        if values.get(candidate):
-            return values[candidate]
-    return None
-
-def _strip_env_value(value: str) -> str:
-    if len(value) >= 2 and value[0] == value[-1] and value[0] in {"'", '"'}:
-        return value[1:-1]
-    return value
-
-def _safe_codex_provider_id(value: str) -> bool:
-    return re.fullmatch(r"[A-Za-z0-9_-]+", value) is not None
-
-def _is_secret_key(key: str) -> bool:
-    upper = key.upper()
-    return upper in SECRET_KEYS or "KEY" in upper or "TOKEN" in upper or "SECRET" in upper
-
-def _safe_profile_value(key: str, value: str) -> dict[str, Any]:
-    if _is_secret_key(key):
-        return {"present": bool(value), "redacted": True}
-    return {"present": bool(value), "redacted": False, "value": _safe_plain_profile_value(value)}
-
-def _common_missing_values(auth_mode: str | None, values: dict[str, str]) -> list[str]:
-    if auth_mode == "compatible_api":
-        required = ["BASE_URL", "API_KEY", "MODEL"]
-    elif auth_mode == "official_api":
-        required = ["API_KEY"]
-    else:
-        required = []
-    missing = []
-    for key in required:
-        if key == "MODEL":
-            if not (values.get("MODEL") or values.get("ANTHROPIC_MODEL")):
-                missing.append(key)
-            continue
-        if not values.get(key) and not _alternate_value(values, key):
-            missing.append(key)
-    return missing
-
-def _safe_plain_profile_value(value: str) -> str:
-    parsed = urllib.parse.urlparse(value)
-    if parsed.scheme and parsed.netloc:
-        host = parsed.hostname or ""
-        port = f":{parsed.port}" if parsed.port else ""
-        auth = "[redacted]@" if parsed.username or parsed.password else ""
-        value = urllib.parse.urlunparse((parsed.scheme, f"{auth}{host}{port}", parsed.path, "", "", ""))
-    return str(redact_text(value).get("text") or "")

package/src/team_agent/profiles/provider_env.py

@@ -1,188 +0,0 @@
-from __future__ import annotations
-
-import json
-import shlex
-from pathlib import Path
-from typing import Any
-
-from team_agent.profiles.constants import COMPATIBLE_API_NETWORK_ENV_KEYS
-from team_agent.profiles.helpers import _safe_codex_provider_id
-
-
-def _provider_env_exports(provider: str, auth_mode: str, values: dict[str, str]) -> dict[str, str]:
-    if auth_mode == "subscription":
-        return {}
-    if provider in {"claude", "claude_code"}:
-        exports: dict[str, str] = {}
-        base_url = values.get("ANTHROPIC_BASE_URL") or values.get("BASE_URL")
-        api_key = values.get("ANTHROPIC_API_KEY") or values.get("API_KEY")
-        auth_token = values.get("ANTHROPIC_AUTH_TOKEN") or values.get("AUTH_TOKEN")
-        model = values.get("ANTHROPIC_MODEL") or values.get("MODEL")
-        if base_url:
-            exports["ANTHROPIC_BASE_URL"] = base_url
-        if auth_mode == "official_api" and api_key:
-            exports["ANTHROPIC_API_KEY"] = api_key
-        if auth_token or (auth_mode == "compatible_api" and api_key):
-            exports["ANTHROPIC_AUTH_TOKEN"] = auth_token or api_key
-        if model:
-            exports["ANTHROPIC_MODEL"] = model
-        return exports
-    if provider == "codex":
-        exports = {}
-        api_key = values.get("OPENAI_API_KEY") or values.get("API_KEY")
-        if api_key:
-            exports["TEAM_AGENT_PROVIDER_API_KEY"] = api_key
-            exports.setdefault("OPENAI_API_KEY", api_key)
-        if values.get("BASE_URL"):
-            exports["OPENAI_BASE_URL"] = values["BASE_URL"]
-        return exports
-    if provider == "gemini_cli":
-        api_key = values.get("GEMINI_API_KEY") or values.get("API_KEY")
-        return {"GEMINI_API_KEY": api_key} if api_key else {}
-    return {}
-
-def _provider_env_unsets(provider: str, auth_mode: str) -> list[str]:
-    unsets: list[str] = []
-    if provider in {"claude", "claude_code"}:
-        if auth_mode == "compatible_api":
-            unsets.append("ANTHROPIC_API_KEY")
-        if auth_mode == "official_api":
-            unsets.append("ANTHROPIC_AUTH_TOKEN")
-    if provider == "codex" and auth_mode == "compatible_api":
-        unsets.extend(["OPENAI_API_KEY", "OPENAI_BASE_URL"])
-    if provider == "gemini_cli" and auth_mode == "compatible_api":
-        unsets.append("GEMINI_API_KEY")
-    return sorted(set(unsets))
-
-def _provider_command_overrides(provider: str, auth_mode: str, values: dict[str, str], agent: dict[str, Any]) -> dict[str, Any]:
-    overrides: dict[str, Any] = {}
-    model = agent.get("model") or values.get("MODEL") or values.get("ANTHROPIC_MODEL")
-    if model:
-        overrides["model"] = str(model)
-    if provider == "codex":
-        codex_profile = values.get("CODEX_PROFILE") or values.get("NATIVE_PROFILE")
-        if codex_profile:
-            overrides["codex_profile"] = codex_profile
-        configs: list[str] = []
-        model_provider = values.get("MODEL_PROVIDER")
-        base_url = values.get("BASE_URL")
-        if auth_mode == "compatible_api" and model_provider and base_url and _safe_codex_provider_id(model_provider):
-            configs.append(f'model_provider="{model_provider}"')
-            prefix = f"model_providers.{model_provider}"
-            configs.append(f'{prefix}.base_url="{base_url}"')
-            configs.append(f'{prefix}.env_key="TEAM_AGENT_PROVIDER_API_KEY"')
-            if values.get("WIRE_API"):
-                configs.append(f'{prefix}.wire_api="{values["WIRE_API"]}"')
-            if values.get("PROVIDER_NAME"):
-                configs.append(f'{prefix}.name="{values["PROVIDER_NAME"]}"')
-        if configs:
-            overrides["codex_config"] = configs
-    return overrides
-
-def _write_runtime_env_file(workspace: Path, agent_id: str, exports: dict[str, str], unsets: list[str]) -> Path:
-    directory = workspace / ".team" / "runtime" / "provider-env"
-    directory.mkdir(parents=True, exist_ok=True)
-    path = directory / f"{agent_id}.env"
-    lines = [f"unset {key}" for key in sorted(unsets)]
-    lines.extend(f"export {key}={shlex.quote(value)}" for key, value in sorted(exports.items()))
-    path.write_text("\n".join(lines) + "\n", encoding="utf-8")
-    try:
-        path.chmod(0o600)
-    except OSError:
-        pass
-    return path
-
-def _compatible_claude_config_dir(workspace: Path, agent_id: str) -> Path:
-    directory = workspace / ".team" / "runtime" / "provider-config" / agent_id / "claude"
-    directory.mkdir(parents=True, exist_ok=True)
-    _ensure_compatible_claude_config(directory, workspace)
-    return directory
-
-def ensure_compatible_claude_mcp_config(workspace: Path, agent_id: str, mcp_config: dict[str, Any]) -> None:
-    if not mcp_config:
-        return
-    directory = _compatible_claude_config_dir(workspace, agent_id)
-    state_path = directory / ".claude.json"
-    state = _read_json_object(state_path)
-    projects = state.setdefault("projects", {})
-    if not isinstance(projects, dict):
-        projects = {}
-        state["projects"] = projects
-    for project_key in _claude_project_keys(workspace):
-        project = projects.setdefault(project_key, {})
-        if not isinstance(project, dict):
-            project = {}
-            projects[project_key] = project
-        project["hasTrustDialogAccepted"] = True
-        project.setdefault("projectOnboardingSeenCount", 1)
-        project.setdefault("allowedTools", [])
-        project.setdefault("mcpContextUris", [])
-        project.setdefault("enabledMcpjsonServers", [])
-        project.setdefault("disabledMcpjsonServers", [])
-        project.setdefault("hasClaudeMdExternalIncludesApproved", False)
-        project.setdefault("hasClaudeMdExternalIncludesWarningShown", False)
-        servers = project.setdefault("mcpServers", {})
-        if not isinstance(servers, dict):
-            servers = {}
-            project["mcpServers"] = servers
-        servers.update(mcp_config)
-    _write_json(state_path, state)
-
-def _ensure_compatible_claude_config(directory: Path, workspace: Path) -> None:
-    settings_path = directory / "settings.json"
-    settings = _read_json_object(settings_path)
-    settings.setdefault("theme", "auto")
-    settings.setdefault("skipDangerousModePermissionPrompt", True)
-    _write_json(settings_path, settings)
-
-    state_path = directory / ".claude.json"
-    state = _read_json_object(state_path)
-    state["hasCompletedOnboarding"] = True
-    state.setdefault("lastOnboardingVersion", "2.1.0")
-    state.setdefault("firstStartTime", "1970-01-01T00:00:00.000Z")
-    state.setdefault("numStartups", 0)
-    projects = state.get("projects")
-    if not isinstance(projects, dict):
-        projects = {}
-        state["projects"] = projects
-    for project_key in _claude_project_keys(workspace):
-        project = projects.get(project_key)
-        if not isinstance(project, dict):
-            project = {}
-            projects[project_key] = project
-        project["hasTrustDialogAccepted"] = True
-        project.setdefault("projectOnboardingSeenCount", 1)
-    _write_json(state_path, state)
-
-def _claude_project_keys(workspace: Path) -> list[str]:
-    keys = [str(workspace)]
-    try:
-        resolved = str(workspace.resolve())
-    except OSError:
-        resolved = None
-    if resolved and resolved not in keys:
-        keys.append(resolved)
-    return keys
-
-def _read_json_object(path: Path) -> dict[str, Any]:
-    try:
-        data = json.loads(path.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
-        return {}
-    return data if isinstance(data, dict) else {}
-
-def _write_json(path: Path, data: dict[str, Any]) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
-    try:
-        path.chmod(0o600)
-    except OSError:
-        pass
-
-def _compatible_api_network_exports(auth_mode: str, values: dict[str, str]) -> dict[str, str]:
-    if auth_mode != "compatible_api" or _profile_proxy_mode(values) == "direct":
-        return {}
-    return {key: values[key] for key in COMPATIBLE_API_NETWORK_ENV_KEYS if values.get(key)}
-
-def _profile_proxy_mode(values: dict[str, str]) -> str:
-    return str(values.get("PROXY_MODE") or values.get("NETWORK_MODE") or "inherit").strip().lower()

package/src/team_agent/profiles/smoke.py

@@ -1,201 +0,0 @@
-from __future__ import annotations
-
-from contextlib import contextmanager
-import json
-import os
-import urllib.error
-import urllib.parse
-import urllib.request
-from typing import Any
-
-from team_agent.profiles.constants import COMPATIBLE_API_NETWORK_ENV_KEYS
-from team_agent.profiles.provider_env import _compatible_api_network_exports, _profile_proxy_mode
-from team_agent.rust_core import redact_text
-
-
-def _anthropic_compatible_smoke(
-    values: dict[str, str],
-    model: str | None,
-    base_result: dict[str, Any],
-    timeout: float,
-) -> dict[str, Any]:
-    base_url = values.get("ANTHROPIC_BASE_URL") or values.get("BASE_URL")
-    api_key = values.get("ANTHROPIC_API_KEY") or values.get("API_KEY")
-    auth_token = values.get("ANTHROPIC_AUTH_TOKEN") or values.get("AUTH_TOKEN")
-    if not base_url or not (api_key or auth_token) or not model:
-        return {**base_result, "ok": False, "status": "smoke_failed", "reason": "missing_base_url_api_key_or_model"}
-    endpoint = _anthropic_messages_url(base_url)
-    payload = {
-        "model": model,
-        "max_tokens": 1,
-        "messages": [{"role": "user", "content": "ping"}],
-    }
-    headers = {
-        "content-type": "application/json",
-        "anthropic-version": values.get("ANTHROPIC_VERSION") or "2023-06-01",
-    }
-    headers["authorization"] = f"Bearer {auth_token or api_key}"
-    return _http_json_smoke(endpoint, payload, headers, values, base_result, timeout)
-
-def _openai_compatible_smoke(
-    values: dict[str, str],
-    model: str | None,
-    base_result: dict[str, Any],
-    timeout: float,
-) -> dict[str, Any]:
-    base_url = values.get("OPENAI_BASE_URL") or values.get("BASE_URL")
-    api_key = values.get("OPENAI_API_KEY") or values.get("API_KEY")
-    if not base_url or not api_key or not model:
-        return {**base_result, "ok": False, "status": "smoke_failed", "reason": "missing_base_url_api_key_or_model"}
-    endpoint = _openai_chat_url(base_url)
-    payload = {
-        "model": model,
-        "max_tokens": 1,
-        "messages": [{"role": "user", "content": "ping"}],
-    }
-    headers = {"content-type": "application/json", "authorization": f"Bearer {api_key}"}
-    return _http_json_smoke(endpoint, payload, headers, values, base_result, timeout)
-
-def _http_json_smoke(
-    endpoint: str,
-    payload: dict[str, Any],
-    headers: dict[str, str],
-    values: dict[str, str],
-    base_result: dict[str, Any],
-    timeout: float,
-) -> dict[str, Any]:
-    proxy_info = _proxy_info_for_endpoint(endpoint, values)
-    request = urllib.request.Request(
-        endpoint,
-        data=json.dumps(payload).encode("utf-8"),
-        headers=headers,
-        method="POST",
-    )
-    try:
-        with _temporary_profile_network_env(values):
-            response_ctx = urllib.request.urlopen(request, timeout=timeout)
-        with response_ctx as response:
-            status = int(getattr(response, "status", 200))
-            body = response.read(1024).decode("utf-8", errors="replace")
-    except urllib.error.HTTPError as exc:
-        body = exc.read(4096).decode("utf-8", errors="replace")
-        return {
-            **base_result,
-            **proxy_info,
-            "ok": False,
-            "status": "smoke_failed",
-            "reason": "http_error",
-            "http_status": exc.code,
-            "endpoint": _redacted_endpoint(endpoint),
-            "error": redact_text(body or str(exc)).get("text"),
-        }
-    except Exception as exc:
-        reason = "proxy_connectivity_failed" if proxy_info.get("proxy_configured") else "request_failed"
-        return {
-            **base_result,
-            **proxy_info,
-            "ok": False,
-            "status": "smoke_failed",
-            "reason": reason,
-            "endpoint": _redacted_endpoint(endpoint),
-            "error": redact_text(str(exc)).get("text"),
-            "suggestion": (
-                "Proxy is configured for this request; allow the profile BASE_URL through the proxy or disable the proxy for Team Agent startup."
-                if proxy_info.get("proxy_configured")
-                else "Check BASE_URL network connectivity from this machine."
-            ),
-        }
-    if 200 <= status < 300:
-        return {
-            **base_result,
-            **proxy_info,
-            "ok": True,
-            "status": "smoke_passed",
-            "http_status": status,
-            "endpoint": _redacted_endpoint(endpoint),
-        }
-    return {
-        **base_result,
-        **proxy_info,
-        "ok": False,
-        "status": "smoke_failed",
-        "reason": "unexpected_status",
-        "http_status": status,
-        "endpoint": _redacted_endpoint(endpoint),
-        "error": redact_text(body).get("text"),
-    }
-
-def _anthropic_messages_url(base_url: str) -> str:
-    base = base_url.rstrip("/")
-    if base.endswith("/messages"):
-        return base
-    if base.endswith("/v1"):
-        return f"{base}/messages"
-    return f"{base}/v1/messages"
-
-def _openai_chat_url(base_url: str) -> str:
-    base = base_url.rstrip("/")
-    if base.endswith("/chat/completions"):
-        return base
-    if base.endswith("/v1"):
-        return f"{base}/chat/completions"
-    return f"{base}/v1/chat/completions"
-
-def _redacted_endpoint(endpoint: str) -> str:
-    return endpoint.split("?", 1)[0]
-
-def _proxy_info_for_endpoint(endpoint: str, values: dict[str, str]) -> dict[str, Any]:
-    parsed = urllib.parse.urlparse(endpoint)
-    if _profile_proxy_mode(values) == "direct":
-        return {"proxy_configured": False, "proxy_mode": "direct"}
-    profile_env = _compatible_api_network_exports("compatible_api", values)
-    proxy_url = _proxy_url_from_env(parsed.scheme, profile_env)
-    if proxy_url:
-        return {
-            "proxy_configured": True,
-            "proxy_scheme": parsed.scheme,
-            "proxy_url": _redact_proxy_url(proxy_url),
-            "proxy_source": "profile",
-        }
-    ambient_proxy_url = _proxy_url_from_env(parsed.scheme, os.environ)
-    if ambient_proxy_url:
-        return {
-            "proxy_configured": True,
-            "proxy_scheme": parsed.scheme,
-            "proxy_url": _redact_proxy_url(ambient_proxy_url),
-            "proxy_source": "ambient",
-        }
-    return {"proxy_configured": False}
-
-def _proxy_url_from_env(scheme: str, env: Any) -> str | None:
-    upper = f"{scheme.upper()}_PROXY"
-    lower = f"{scheme.lower()}_proxy"
-    return env.get(upper) or env.get(lower) or env.get("ALL_PROXY") or env.get("all_proxy")
-
-@contextmanager
-def _temporary_profile_network_env(values: dict[str, str]) -> Any:
-    profile_env = _compatible_api_network_exports("compatible_api", values)
-    direct = _profile_proxy_mode(values) == "direct"
-    touched_keys = COMPATIBLE_API_NETWORK_ENV_KEYS if direct else tuple(profile_env)
-    saved = {key: os.environ.get(key) for key in touched_keys}
-    try:
-        if direct:
-            for key in COMPATIBLE_API_NETWORK_ENV_KEYS:
-                os.environ.pop(key, None)
-        os.environ.update(profile_env)
-        yield
-    finally:
-        for key, value in saved.items():
-            if value is None:
-                os.environ.pop(key, None)
-            else:
-                os.environ[key] = value
-
-def _redact_proxy_url(proxy_url: str) -> str:
-    parsed = urllib.parse.urlparse(proxy_url)
-    if not parsed.netloc:
-        return proxy_url
-    host = parsed.hostname or ""
-    port = f":{parsed.port}" if parsed.port else ""
-    auth = "[redacted]@" if parsed.username or parsed.password else ""
-    return urllib.parse.urlunparse((parsed.scheme, f"{auth}{host}{port}", parsed.path, "", "", ""))

package/src/team_agent/provider_cli/__init__.py

@@ -1,43 +0,0 @@
-from __future__ import annotations
-
-from team_agent.provider_cli.adapter import (
-    ProviderAdapter,
-    ResumeUnavailable,
-    agent_model,
-    parse_time,
-    read_json_object,
-)
-from team_agent.provider_cli.base import (
-    ProviderCapabilityError,
-    ProviderCliSocket,
-    ProviderStartupInput,
-)
-from team_agent.provider_cli.claude import ClaudeCodeAdapter
-from team_agent.provider_cli.codex import CodexAdapter
-from team_agent.provider_cli.copilot import CopilotCliPlug
-from team_agent.provider_cli.fake import FakeAdapter
-from team_agent.provider_cli.gemini import GeminiCliAdapter
-from team_agent.provider_cli.opencode import OpenCodeCliPlug
-from team_agent.provider_cli.prompt import TEAMMATE_SYSTEM_PROMPT, compile_system_prompt
-from team_agent.provider_cli.registry import PLUG_TYPES, build_plug
-
-__all__ = [
-    "ClaudeCodeAdapter",
-    "CodexAdapter",
-    "CopilotCliPlug",
-    "FakeAdapter",
-    "GeminiCliAdapter",
-    "OpenCodeCliPlug",
-    "PLUG_TYPES",
-    "ProviderAdapter",
-    "ProviderCapabilityError",
-    "ProviderCliSocket",
-    "ProviderStartupInput",
-    "ResumeUnavailable",
-    "TEAMMATE_SYSTEM_PROMPT",
-    "agent_model",
-    "build_plug",
-    "compile_system_prompt",
-    "parse_time",
-    "read_json_object",
-]

package/src/team_agent/provider_cli/adapter.py

@@ -1,172 +0,0 @@
-from __future__ import annotations
-
-import json
-import shutil
-import subprocess
-import sys
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any
-
-from team_agent.paths import repo_root
-
-
-class ResumeUnavailable(RuntimeError):
-    pass
-
-
-class ProviderAdapter:
-    provider = ""
-    command_name = ""
-
-    def is_installed(self) -> bool:
-        return shutil.which(self.command_name) is not None
-
-    def version(self) -> str | None:
-        if not self.is_installed():
-            return None
-        for args in ([self.command_name, "--version"], [self.command_name, "version"]):
-            try:
-                proc = subprocess.run(args, text=True, capture_output=True, timeout=8, check=False)
-            except (OSError, subprocess.TimeoutExpired):
-                continue
-            text = (proc.stdout or proc.stderr).strip()
-            if text:
-                return text.splitlines()[0]
-        return "installed"
-
-    def auth_hint(self) -> dict[str, Any]:
-        return {"status": "unknown", "detail": "adapter cannot verify auth without starting CLI"}
-
-    def build_command(self, agent: dict[str, Any], workspace: Path, mcp_config: dict[str, Any]) -> list[str]:
-        raise NotImplementedError
-
-    def capture_session_id(
-        self,
-        agent_id: str,
-        spawn_context: dict[str, Any],
-        timeout_s: float = 3.0,
-    ) -> dict[str, Any] | None:
-        _ = agent_id, spawn_context, timeout_s
-        return None
-
-    def build_resume_command(
-        self,
-        agent_state: dict[str, Any],
-        workspace: Path,
-        mcp_config: dict[str, Any] | None = None,
-    ) -> list[str]:
-        _ = workspace, mcp_config
-        session_id = agent_state.get("session_id")
-        if not session_id:
-            raise ResumeUnavailable("session_id is required to resume")
-        raise ResumeUnavailable(f"{self.provider} does not support resume")
-
-    def supports_session_fork(self, agent: dict[str, Any] | None = None) -> bool:
-        _ = agent
-        return False
-
-    def build_fork_command(
-        self,
-        agent: dict[str, Any],
-        source_session_id: str,
-        workspace: Path,
-        mcp_config: dict[str, Any],
-    ) -> list[str]:
-        _ = agent, source_session_id, workspace, mcp_config
-        raise ResumeUnavailable(f"{self.provider} does not support native session fork")
-
-    def session_is_resumable(self, agent_state: dict[str, Any], workspace: Path) -> bool:
-        _ = workspace
-        return bool(agent_state.get("session_id"))
-
-    def recover_session_id(
-        self,
-        agent_id: str,
-        agent_state: dict[str, Any],
-        workspace: Path,
-        exclude_session_ids: set[str] | None = None,
-    ) -> dict[str, Any] | None:
-        _ = agent_id, agent_state, workspace, exclude_session_ids
-        return None
-
-    def mcp_config(self, workspace: Path, agent_id: str, team_id: str | None = None) -> dict[str, Any]:
-        # 0.2.6 Family C (C13): worker spawn env always carries the owning
-        # team id so the MCP server can scope sender requests without
-        # asking the worker which team it belongs to.
-        env = {
-            "TEAM_AGENT_ID": agent_id,
-            "TEAM_AGENT_OWNER_TEAM_ID": str(team_id or ""),
-            "PYTHONPATH": str(repo_root() / "src"),
-        }
-        return {
-            "team_orchestrator": {
-                "type": "stdio",
-                "command": sys.executable,
-                "args": ["-m", "team_agent.mcp_server", "--workspace", str(workspace)],
-                "env": env,
-            }
-        }
-
-    def install_mcp(self, workspace: Path, agent_id: str, config: dict[str, Any]) -> Path:
-        path = workspace / ".team" / "runtime" / "mcp" / f"{agent_id}.json"
-        path.parent.mkdir(parents=True, exist_ok=True)
-        path.write_text(json.dumps({"mcpServers": config}, indent=2), encoding="utf-8")
-        return path
-
-    def cleanup_mcp(self, workspace: Path, agent_id: str, mcp_path: Path | None = None) -> None:
-        return None
-
-    def status_patterns(self) -> dict[str, str]:
-        return {"idle": "", "processing": "", "error": "Error|Traceback|panic"}
-
-    def exit_text(self) -> str:
-        return "/exit"
-
-    def handle_startup_prompts(
-        self,
-        session_name: str,
-        window_name: str,
-        checks: int = 30,
-        sleep_s: float = 0.5,
-    ) -> list[dict[str, Any]]:
-        return []
-
-    def handle_runtime_prompts(self, session_name: str, window_name: str) -> list[dict[str, Any]]:
-        return []
-
-    def validate_model(self, model: str | None) -> dict[str, Any]:
-        return {"ok": True, "status": "not_checked", "provider": self.provider, "model": model}
-
-
-def agent_model(agent: dict[str, Any]) -> str | None:
-    if agent.get("model"):
-        return str(agent["model"])
-    profile_overrides = agent.get("_provider_profile", {}).get("command_overrides", {})
-    if profile_overrides.get("model"):
-        return str(profile_overrides["model"])
-    return None
-
-
-def read_json_object(path: Path) -> dict[str, Any]:
-    if not path.exists():
-        return {}
-    data = json.loads(path.read_text(encoding="utf-8"))
-    if not isinstance(data, dict):
-        raise ValueError(f"{path}: expected a JSON object")
-    return data
-
-
-def parse_time(value: Any) -> datetime | None:
-    if isinstance(value, datetime):
-        return value if value.tzinfo else value.replace(tzinfo=timezone.utc)
-    if not value:
-        return None
-    text = str(value)
-    if text.endswith("Z"):
-        text = text[:-1] + "+00:00"
-    try:
-        dt = datetime.fromisoformat(text)
-    except ValueError:
-        return None
-    return dt if dt.tzinfo else dt.replace(tzinfo=timezone.utc)