@team-agent/installer 0.2.11 → 0.3.1

package/src/team_agent/mcp_server/tools.py

@@ -1,352 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-from pathlib import Path
-from typing import Any
-
-from team_agent import runtime
-from team_agent.events import EventLog
-from team_agent.message_store import MessageStore
-from team_agent.state import load_runtime_state, save_runtime_state, write_team_state
-
-from team_agent.mcp_server.normalize import _compact_tool_result, _normalize_report_envelope, _text
-
-
-def _requires_ack_for_target(to: str | list[str]) -> bool:
-    if isinstance(to, list):
-        return any(target not in {"leader", "Leader"} for target in to)
-    return to not in {"leader", "Leader"}
-
-
-def _is_worker_recipient(to: str | list[str]) -> bool:
-    if not isinstance(to, str):
-        return False
-    if to in {"", "*", "leader", "Leader"}:
-        return False
-    return True
-
-
-def _merge_tasks_by_id(prefer: list[Any], fallback: list[Any]) -> list[dict[str, Any]]:
-    """Build a deduped task list keyed by ``id``.
-
-    ``prefer`` is searched first so its entries win on duplicate ids — the
-    top-level ``state["tasks"]`` view receives in-place updates from
-    ``collect`` (Family B view-vs-source asymmetry) while
-    ``teams[team_key].tasks`` may have stayed pre-collect. Walking the
-    preferred list first ensures an earlier ``done`` status is not
-    regressed when ``assign_task`` re-publishes the merged list as the
-    new source on ``teams[team_key].tasks``.
-    """
-    out: dict[str, dict[str, Any]] = {}
-    for entry in list(prefer) + list(fallback):
-        if not isinstance(entry, dict):
-            continue
-        task_id = entry.get("id")
-        if not task_id:
-            continue
-        out.setdefault(str(task_id), entry)
-    return list(out.values())
-
-
-def _latest_task_for_assignee(state: dict[str, Any], agent_id: str | None) -> str | None:
-    """Return the most recently registered, non-terminal task id assigned
-    to ``agent_id``. Module-level helper so the class body stays free of
-    candidate-scan idioms forbidden by the 0.2.6 Family C contract."""
-    if not agent_id:
-        return None
-    tasks = state.get("tasks", [])
-    if not isinstance(tasks, list):
-        return None
-    for entry in tasks[::-1]:
-        if not isinstance(entry, dict):
-            continue
-        if entry.get("assignee") != agent_id:
-            continue
-        if entry.get("status") in {"done", "failed"}:
-            continue
-        return str(entry.get("id") or "")
-    return None
-
-
-class TeamOrchestratorTools:
-    """0.2.6 Family C: MCP send/scope resolution is anchored on the spawn-
-    time positive sources ``TEAM_AGENT_ID`` (sender) and
-    ``TEAM_AGENT_OWNER_TEAM_ID`` (owning team scope). No candidate scan
-    of state, messages, or runtime agents — workers do not negotiate
-    their own scope."""
-
-    def __init__(self, workspace: Path):
-        self.workspace = workspace.resolve()
-        self.agent_id = _text(os.environ.get("TEAM_AGENT_ID"))
-        self.owner_team_id = _text(os.environ.get("TEAM_AGENT_OWNER_TEAM_ID"))
-
-    def assign_task(self, task: dict[str, Any], message: str | None = None) -> dict[str, Any]:
-        # 0.2.6 Family B (C8): the source of truth for tasks lives in
-        # ``state.teams[team_key].tasks``; the top-level ``tasks`` field is
-        # a derived view. Workflow:
-        #   * resolve the team key from the spawn-time
-        #     ``TEAM_AGENT_OWNER_TEAM_ID`` env (Family C C13), or
-        #     ``state.active_team_key`` for legacy single-team callers.
-        #   * reconcile teams[team_key].tasks with the top-level view by id
-        #     before appending — readers that still write to top-level
-        #     (legacy ``collect`` updates ``state["tasks"]`` in place)
-        #     leave the team entry stale; using top-level entries first
-        #     keeps an earlier ``done`` from regressing to ``pending``.
-        #   * append / update the new task into the merged list and bind
-        #     the same list object as both source and view so the next
-        #     save round-trips one truth in two locations.
-        state = load_runtime_state(self.workspace)
-        team_key = (
-            self.owner_team_id
-            or _text(state.get("active_team_key"))
-            or ""
-        )
-        teams = state.setdefault("teams", {})
-        team_entry: dict[str, Any] | None
-        if team_key and isinstance(teams.get(team_key), dict):
-            team_entry = teams[team_key]
-        elif team_key:
-            team_entry = {"tasks": [], "status": "alive"}
-            teams[team_key] = team_entry
-        else:
-            team_entry = None
-        if team_entry is None:
-            # Legacy single-team workspaces — no team scope to write through.
-            target_tasks = state.setdefault("tasks", [])
-        else:
-            top_view = state.get("tasks")
-            team_tasks = team_entry.get("tasks")
-            target_tasks = _merge_tasks_by_id(
-                top_view if isinstance(top_view, list) else [],
-                team_tasks if isinstance(team_tasks, list) else [],
-            )
-            team_entry["tasks"] = target_tasks
-            state["tasks"] = target_tasks
-        existing = next((item for item in target_tasks if item.get("id") == task.get("id")), None)
-        if existing:
-            existing.update(task)
-        else:
-            target_tasks.append(task)
-        save_runtime_state(self.workspace, state)
-        content = message or task.get("description") or task.get("title") or json.dumps(task)
-        return _compact_tool_result(runtime.send_message(self.workspace, task.get("assignee"), content, task_id=task["id"]))
-
-    def send_message(
-        self,
-        to: str | list[str],
-        content: str,
-        task_id: str | None = None,
-        sender: str | None = None,
-        requires_ack: bool | None = None,
-        scope: str | None = None,
-    ) -> dict[str, Any]:
-        # 0.2.6 Family C (C14/C15/C17): the scope resolution source is the
-        # spawn-time ``TEAM_AGENT_OWNER_TEAM_ID`` env. ``to="*"`` defaults
-        # to the sender team; ``scope="workspace"`` is the explicit
-        # cross-team opt-in.
-        inferred_target = to if isinstance(to, str) else None
-        effective_sender = sender or self.agent_id or self._sender_from_env(target=inferred_target) or "unknown"
-        effective_requires_ack = requires_ack if requires_ack is not None else _requires_ack_for_target(to)
-        # 0.2.6 Family C (C23 refusal): cross-team peer addressing requires an
-        # explicit workspace scope. Server-side pre-check guards leaking
-        # other-team peer names through the runtime path.
-        refusal = self._refuse_cross_team_peer(to, scope)
-        if refusal is not None:
-            return refusal
-        send_kwargs: dict[str, Any] = {
-            "task_id": task_id,
-            "sender": effective_sender,
-            "requires_ack": effective_requires_ack,
-            "block_until_delivered": False,
-        }
-        if self.owner_team_id:
-            send_kwargs["team"] = self.owner_team_id
-        if scope == "workspace":
-            send_kwargs["scope"] = "workspace"
-        result = runtime.send_message(self.workspace, to, content, **send_kwargs)
-        EventLog(self.workspace).write(
-            "mcp.scope_resolved",
-            sender_team_id=self.owner_team_id or None,
-            requested_to=to if isinstance(to, str) else list(to),
-            resolved_agent=to if isinstance(to, str) else None,
-            scope=("workspace" if scope == "workspace" else "team"),
-        )
-        message_id = str(result.get("message_id") or "")
-        if _is_worker_recipient(to) and message_id:
-            return {
-                "status": "accepted",
-                "delivery_pending": True,
-                "poll_via": f"team-agent inbox {message_id}",
-                "message_id": message_id,
-            }
-        return _compact_tool_result(result)
-
-    def _refuse_cross_team_peer(
-        self, to: str | list[str], scope: str | None
-    ) -> dict[str, Any] | None:
-        if scope == "workspace":
-            return None
-        if not isinstance(to, str) or to in {"*", "leader", "Leader", ""}:
-            return None
-        if not self.owner_team_id:
-            return None
-        visible = set(self.get_visible_peers().get("peers") or [])
-        if to in visible or to == self.agent_id:
-            return None
-        hint = (
-            "the requested peer is not part of your team. "
-            "pass scope='workspace' to address peers in other teams."
-        )
-        EventLog(self.workspace).write(
-            "mcp.send_message_refused",
-            reason="peer_not_in_scope",
-            sender_team_id=self.owner_team_id,
-            scope="team",
-            hint=hint,
-        )
-        return {
-            "ok": False,
-            "status": "refused",
-            "reason": "peer_not_in_scope",
-            "hint": hint,
-        }
-
-    def _sender_from_env(self, *, target: str | None) -> str | None:
-        if self.agent_id:
-            return self.agent_id
-        EventLog(self.workspace).write(
-            "mcp.identity_inference_failed",
-            target=target,
-            sender_team_id=self.owner_team_id or None,
-            fallback="unknown",
-        )
-        return None
-
-    def get_visible_peers(self) -> dict[str, Any]:
-        """0.2.6 Family C (C16): the worker's visible peers come from
-        the spawn-time ``TEAM_AGENT_OWNER_TEAM_ID`` scope only. Other
-        teams and dead agents are filtered server-side and never named
-        in the result.
-        """
-        state = load_runtime_state(self.workspace)
-        scope_team = self.owner_team_id or ""
-        teams = state.get("teams") if isinstance(state.get("teams"), dict) else {}
-        team_entry = teams.get(scope_team) if scope_team else {}
-        agents = team_entry.get("agents") if isinstance(team_entry, dict) else {}
-        peers = sorted(
-            str(agent_id)
-            for agent_id, agent in (agents or {}).items()
-            if isinstance(agent, dict) and str(agent.get("status") or "alive").lower() not in {"dead", "stopped"}
-            or not isinstance(agent, dict)
-        )
-        return {
-            "peers": peers,
-            "sender_team_id": scope_team or None,
-            "scope": "team",
-        }
-
-    def report_result(
-        self,
-        envelope: dict[str, Any] | None = None,
-        summary: str | None = None,
-        status: str = "success",
-        changes: list[dict[str, Any]] | None = None,
-        tests: list[dict[str, Any]] | None = None,
-        risks: list[dict[str, Any]] | None = None,
-        artifacts: list[dict[str, Any]] | None = None,
-        next_actions: list[dict[str, Any]] | None = None,
-        task_id: str | None = None,
-        agent_id: str | None = None,
-    ) -> dict[str, Any]:
-        env = dict(envelope or {})
-        effective_task = self._infer_task_id(
-            agent_id or _text(env.get("agent_id")) or self.agent_id,
-            task_id or _text(env.get("task_id")),
-        )
-        effective_agent = agent_id or _text(env.get("agent_id")) or self._infer_agent_id(task_id=effective_task) or "unknown"
-        env.setdefault("schema_version", "result_envelope_v1")
-        env.setdefault("agent_id", effective_agent)
-        env.setdefault("task_id", effective_task)
-        env.setdefault("status", status)
-        env.setdefault("summary", summary or env.get("summary") or "completed")
-        env.setdefault("changes", changes if changes is not None else [])
-        env.setdefault("tests", tests if tests is not None else [])
-        env.setdefault("risks", risks if risks is not None else [])
-        env.setdefault("artifacts", artifacts if artifacts is not None else [])
-        env.setdefault("next_actions", next_actions if next_actions is not None else [])
-        env = _normalize_report_envelope(env)
-        return _compact_tool_result(runtime.report_result(self.workspace, env))
-
-    def _infer_agent_id(self, provided: str | None = None, task_id: str | None = None, target: str | None = None) -> str | None:
-        # 0.2.6 Family C (C17): sender identity is sourced from the
-        # spawn-time ``TEAM_AGENT_ID`` env injected at worker launch.
-        # Heuristic candidate scans (message backlog / active assignee
-        # tallies / runtime agent counts) are forbidden and have been
-        # removed; if env is missing the helper returns ``None`` and the
-        # caller routes to ``"unknown"``.
-        if _text(provided):
-            return _text(provided)
-        if self.agent_id:
-            return self.agent_id
-        EventLog(self.workspace).write(
-            "mcp.identity_inference_failed",
-            target=target,
-            task_id=task_id,
-            sender_team_id=self.owner_team_id or None,
-            fallback="unknown",
-        )
-        return None
-
-    def _infer_task_id(self, agent_id: str | None, provided: str | None = None) -> str:
-        if provided:
-            return provided
-        state = load_runtime_state(self.workspace)
-        latest = _latest_task_for_assignee(state, agent_id)
-        if latest:
-            return latest
-        EventLog(self.workspace).write("mcp.task_inference_failed", agent_id=agent_id, fallback="manual")
-        return "manual"
-
-    def _task_for_id(self, state: dict[str, Any], task_id: str | None) -> dict[str, Any] | None:
-        if not task_id:
-            return None
-        return next((task for task in state.get("tasks", []) if task.get("id") == task_id), None)
-
-    def update_state(self, note: str) -> dict[str, Any]:
-        state = load_runtime_state(self.workspace)
-        spec_path = Path(state.get("spec_path", self.workspace / "team.spec.yaml"))
-        from team_agent.spec import load_spec
-
-        spec = load_spec(spec_path)
-        state.setdefault("notes", []).append(note)
-        save_runtime_state(self.workspace, state)
-        path = write_team_state(self.workspace, spec, state)
-        return {"ok": True, "state_file": str(path)}
-
-    def get_team_status(self) -> dict[str, Any]:
-        return runtime.status(self.workspace, as_json=True, compact=True)
-
-    def stop_agent(self, agent_id: str) -> dict[str, Any]:
-        return _compact_tool_result(runtime.stop_agent(self.workspace, agent_id))
-
-    def reset_agent(self, agent_id: str, discard_session: bool = False) -> dict[str, Any]:
-        return _compact_tool_result(runtime.reset_agent(self.workspace, agent_id, discard_session=discard_session))
-
-    def add_agent(self, new_agent_id: str, role_file_path: str) -> dict[str, Any]:
-        return _compact_tool_result(runtime.add_agent(self.workspace, new_agent_id, role_file_path=role_file_path))
-
-    def fork_agent(self, source_agent_id: str, as_agent_id: str, label: str | None = None) -> dict[str, Any]:
-        return _compact_tool_result(runtime.fork_agent(self.workspace, source_agent_id, as_agent_id=as_agent_id, label=label))
-
-    def request_human(self, question: str, task_id: str | None = None, agent_id: str | None = None) -> dict[str, Any]:
-        store = MessageStore(self.workspace)
-        sender = agent_id or self._infer_agent_id(task_id=task_id, target="leader") or "unknown"
-        message_id = store.create_message(task_id, sender, "leader", question, requires_ack=True)
-        return {"ok": True, "message_id": message_id, "status": "needs_human"}
-
-    def stuck_list(self) -> dict[str, Any]:
-        return runtime.stuck_list(self.workspace)
-
-    def stuck_cancel(self, agent_id: str, alert_type: str = "stuck") -> dict[str, Any]:
-        return runtime.stuck_cancel(self.workspace, agent_id, alert_type=alert_type, suppressed_by=self.agent_id or "leader")

package/src/team_agent/message_store/__init__.py

@@ -1,23 +0,0 @@
-from __future__ import annotations
-
-from team_agent.message_store.agent_health import delete_agent_health, gc_agent_health, upsert_agent_health
-from team_agent.message_store.core import MessageStore
-from team_agent.message_store.result_watchers import create_result_watcher, mark_result_watcher
-from team_agent.message_store.schema import SCHEMA_VERSION, initialize_schema, utcnow
-
-_REQUIRED_EXPORTS = (
-    "MessageStore",
-    "SCHEMA_VERSION",
-    "initialize_schema",
-    "utcnow",
-    "upsert_agent_health",
-    "delete_agent_health",
-    "gc_agent_health",
-    "create_result_watcher",
-    "mark_result_watcher",
-)
-for _name in _REQUIRED_EXPORTS:
-    if _name not in globals():
-        raise ImportError(f"team_agent.message_store missing export: {_name}")
-
-__all__ = list(_REQUIRED_EXPORTS)

package/src/team_agent/message_store/agent_health.py

@@ -1,113 +0,0 @@
-from __future__ import annotations
-
-from contextlib import closing
-from typing import Any
-
-from team_agent.message_store.schema_migration import MANAGED_TABLE_LAYOUTS
-from team_agent.message_store.schema import utcnow
-
-
-AGENT_HEALTH_SELECT = ", ".join(MANAGED_TABLE_LAYOUTS["agent_health"])
-
-
-def upsert_agent_health(
-    self,
-    agent_id: str,
-    status: str,
-    last_output_at: str | None = None,
-    context_usage_pct: int | None = None,
-    current_task_id: str | None = None,
-    owner_team_id: str | None = None,
-) -> None:
-    now = utcnow()
-    with closing(self.connect()) as conn:
-        with conn:
-            if owner_team_id is None:
-                updated = conn.execute(
-                    """
-                    update agent_health
-                    set status = ?,
-                        last_output_at = coalesce(?, last_output_at),
-                        context_usage_pct = ?,
-                        current_task_id = ?,
-                        updated_at = ?
-                    where owner_team_id is null and agent_id = ?
-                    """,
-                    (status, last_output_at, context_usage_pct, current_task_id, now, agent_id),
-                )
-                if updated.rowcount:
-                    return
-            conn.execute(
-                """
-                insert into agent_health(owner_team_id, agent_id, status, last_output_at, context_usage_pct, current_task_id, updated_at)
-                values (?, ?, ?, ?, ?, ?, ?)
-                on conflict(owner_team_id, agent_id) do update set
-                  status = excluded.status,
-                  last_output_at = coalesce(excluded.last_output_at, agent_health.last_output_at),
-                  context_usage_pct = excluded.context_usage_pct,
-                  current_task_id = excluded.current_task_id,
-                  updated_at = excluded.updated_at
-                """,
-                (owner_team_id, agent_id, status, last_output_at, context_usage_pct, current_task_id, now),
-            )
-
-def agent_health(self, owner_team_id: str | None = None) -> dict[str, dict[str, Any]]:
-    with closing(self.connect()) as conn:
-        if owner_team_id is None:
-            rows = conn.execute(f"select {AGENT_HEALTH_SELECT} from agent_health order by agent_id").fetchall()
-        else:
-            rows = conn.execute(
-                f"select {AGENT_HEALTH_SELECT} from agent_health where owner_team_id = ? or owner_team_id is null order by agent_id",
-                (owner_team_id,),
-            ).fetchall()
-    return {row["agent_id"]: dict(row) for row in rows}
-
-def delete_agent_health(self, agent_id: str, owner_team_id: str | None = None) -> bool:
-    with closing(self.connect()) as conn:
-        with conn:
-            if owner_team_id is None:
-                cur = conn.execute("delete from agent_health where agent_id = ?", (agent_id,))
-            else:
-                cur = conn.execute(
-                    "delete from agent_health where agent_id = ? and (owner_team_id = ? or owner_team_id is null)",
-                    (agent_id, owner_team_id),
-                )
-    return cur.rowcount > 0
-
-def gc_agent_health(self, valid_agent_ids: Any, owner_team_id: str | None = None) -> list[str]:
-    # Caller must pass the workspace-wide set of live agent_ids across every
-    # team sharing this team.db. Rows whose agent_id is not in the set are
-    # deleted. If two teams share a workspace, the caller is responsible for
-    # computing the union before invoking this helper; otherwise live agents
-    # from a sibling team will be swept. Input is validated before any DB
-    # mutation so a derivation bug that silently produces None or non-str
-    # entries cannot delete sibling-team rows by accident.
-    valid: set[str] = set()
-    for entry in valid_agent_ids:
-        if not isinstance(entry, str):
-            raise TypeError(
-                f"gc_agent_health requires str agent_ids; got {type(entry).__name__}"
-            )
-        if not entry:
-            raise ValueError("gc_agent_health does not accept empty agent_ids")
-        valid.add(entry)
-    with closing(self.connect()) as conn:
-        with conn:
-            if owner_team_id is None:
-                rows = conn.execute("select agent_id from agent_health").fetchall()
-            else:
-                rows = conn.execute(
-                    "select agent_id from agent_health where owner_team_id = ? or owner_team_id is null",
-                    (owner_team_id,),
-                ).fetchall()
-            stale = [row["agent_id"] for row in rows if row["agent_id"] not in valid]
-            if stale:
-                placeholders = ",".join("?" for _ in stale)
-                if owner_team_id is None:
-                    conn.execute(f"delete from agent_health where agent_id in ({placeholders})", stale)
-                else:
-                    conn.execute(
-                        f"delete from agent_health where agent_id in ({placeholders}) and (owner_team_id = ? or owner_team_id is null)",
-                        [*stale, owner_team_id],
-                    )
-    return stale