snippbot 0.1.0b1__py3-none-any.whl

snippbot/__init__.py

@@ -0,0 +1,18 @@
+"""Snippbot - Autonomous AI agents for your local machine.
+
+This is the main package for running Snippbot locally. It provides:
+- HTTP API server for the UI and external integrations
+- WebSocket server for real-time updates
+- Background daemon for autonomous task execution
+
+Usage:
+    snippbot start          # Start the daemon
+    snippbot status         # Check daemon status
+    snippbot config set ... # Configure settings
+"""
+
+__version__ = "0.1.0b1"
+
+from snippbot.server import create_app, run_server
+
+__all__ = ["__version__", "create_app", "run_server"]

snippbot/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running as: python -m snippbot"""
+
+from snippbot.cli import main
+
+if __name__ == "__main__":
+    main()

snippbot/api/__init__.py

@@ -0,0 +1,16 @@
+"""REST API handlers.
+
+This module provides the HTTP API for Snippbot:
+- /api/projects - Project management
+- /api/tasks - Task management
+- /api/memory - Memory search and episodes
+- /api/insights - Proactive insights
+- /api/goals - Goal tracking
+- /api/snipp - Token economy
+- /api/daemon - Daemon control
+"""
+
+from snippbot.api.routes import api_routes
+from snippbot.api.health import health_routes
+
+__all__ = ["api_routes", "health_routes"]

snippbot/api/agents.py

@@ -0,0 +1,603 @@
+"""Agent profile and conversation roster API endpoints."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import re
+from pathlib import Path
+from typing import Any, Optional
+
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+from starlette.routing import Route
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# PROFILE.md metadata extraction — used to enrich gateway agents (which only
+# expose `role` from their own parser) with archetype + expertise tags.
+# ---------------------------------------------------------------------------
+
+_PROFILE_SEARCH_DIRS: list[Path] = []
+
+
+def _profile_search_dirs() -> list[Path]:
+    """Directories to scan for `<agent_id>/workspace/PROFILE.md`.
+
+    Matches the gateway's discovery paths (see claude_gateway.config.discover_agents):
+    repo-root `vps/agents/` plus the two per-user install locations.
+    `parents[5]` resolves to the monorepo root when this file lives at
+    `packages/local/src/snippbot/api/agents.py`.
+    """
+    global _PROFILE_SEARCH_DIRS
+    if _PROFILE_SEARCH_DIRS:
+        return _PROFILE_SEARCH_DIRS
+    here = Path(__file__).resolve()
+    candidates = [
+        here.parents[5] / "vps" / "agents" if len(here.parents) >= 6 else None,
+        Path.home() / ".snippai" / "agents",
+        Path.home() / ".snippbot" / "agents",
+        Path.home() / "projects" / "snippbot" / "vps" / "agents",
+    ]
+    _PROFILE_SEARCH_DIRS = [p for p in candidates if p is not None and p.exists()]
+    return _PROFILE_SEARCH_DIRS
+
+
+def _read_profile_metadata(agent_id: str) -> dict[str, Any]:
+    """Read `- **Field:** value` lines from an agent's profile.
+
+    Tries IDENTITY.md (post-Phase-5 canonical), then PROFILE.md (v1).
+    Extracts Role, Archetype, Vibe, and an optional Expertise line
+    (comma-separated tags). Returns an empty dict if neither file can be
+    found or read — callers must not rely on any field being present.
+    """
+    for base in _profile_search_dirs():
+        workspace = base / agent_id / "workspace"
+        for filename in ("IDENTITY.md", "PROFILE.md"):
+            profile_path = workspace / filename
+            if not profile_path.is_file():
+                continue
+            try:
+                text = profile_path.read_text(encoding="utf-8", errors="replace")
+            except OSError:
+                continue
+
+            meta: dict[str, Any] = {}
+            for line in text.splitlines():
+                m = re.match(r"^\s*-\s+\*\*([A-Za-z][A-Za-z ]*):\*\*\s*(.*)$", line)
+                if not m:
+                    continue
+                field = m.group(1).strip().lower()
+                value = m.group(2).strip()
+                if not value:
+                    continue
+                if field == "role":
+                    meta["role"] = value
+                elif field == "archetype":
+                    meta["archetype"] = value
+                elif field == "vibe":
+                    meta["vibe"] = value
+                elif field == "expertise":
+                    tags: list[str] = []
+                    seen: set[str] = set()
+                    for raw in value.split(","):
+                        tag = raw.strip()
+                        if tag and tag.lower() not in seen:
+                            seen.add(tag.lower())
+                            tags.append(tag)
+                    if tags:
+                        meta["expertise_tags"] = tags
+            return meta
+    return {}
+
+
+def _compose_short_bio(role: Optional[str], archetype: Optional[str]) -> Optional[str]:
+    """Blend role + archetype into a single short_bio string for the popover."""
+    role = (role or "").strip() or None
+    archetype = (archetype or "").strip() or None
+    if role and archetype:
+        return f"{role} — {archetype}"
+    return role or archetype
+
+# ---------------------------------------------------------------------------
+# Lazy singletons (same pattern as chat.py)
+# ---------------------------------------------------------------------------
+
+_agent_store = None
+_roster_store = None
+
+
+def get_agent_store():
+    global _agent_store
+    if _agent_store is None:
+        from snippbot_core.chat.agent_store import AgentStore
+        _agent_store = AgentStore()
+    return _agent_store
+
+
+def get_roster_store():
+    global _roster_store
+    if _roster_store is None:
+        from snippbot_core.chat.roster import RosterStore
+        _roster_store = RosterStore()
+    return _roster_store
+
+
+# ===========================================================================
+# Agent profile endpoints
+# ===========================================================================
+
+
+async def list_available_tools(request: Request) -> JSONResponse:
+    """GET /api/tools/available — list all tool names + priority + source.
+
+    Powers the Agent Tool Profile picker (PLAN_AGENT_TOOL_PROFILES Phase 4).
+    Shape: ``{"tools": [{"name", "description", "priority", "source"}], "count"}``.
+
+    Includes MCP tools and is not filtered by ``chat_only``, so the UI can
+    expose every tool an agent might possibly invoke.
+    """
+    try:
+        from snippbot_core.tools.registry import get_tool_registry
+
+        defs = await get_tool_registry().async_get_enabled_tool_definitions(
+            include_mcp=True,
+            chat_only=True,
+        )
+        # Pull `_source` off the raw (un-cleaned) tool list — `async_get_enabled_tool_definitions`
+        # strips it. Need to call the inner helper to retain metadata.
+        all_with_meta = await get_tool_registry().async_get_all_tools(
+            include_mcp=True,
+            chat_only=True,
+        )
+        source_by_name: dict[str, str] = {
+            t.get("name", ""): t.get("_source", "unknown") for t in all_with_meta
+        }
+        tools: list[dict[str, Any]] = []
+        for d in defs:
+            name = d.get("name")
+            if not name:
+                continue
+            tools.append({
+                "name": name,
+                "description": (d.get("description") or "")[:300],
+                "priority": d.get("_priority", 5),
+                "source": source_by_name.get(name, "unknown"),
+            })
+        return JSONResponse({"tools": tools, "count": len(tools)})
+    except Exception:
+        logger.exception("Failed to list available tools")
+        return JSONResponse({"error": "tool registry unavailable"}, status_code=500)
+
+
+async def list_all_agents(request: Request) -> JSONResponse:
+    """GET /api/agents/all — unified list of gateway agents + AgentStore profiles.
+
+    Returns normalized shape: ``{id, handle, name, short_bio?, source,
+    avatar_url?, expertise_tags?, preferred_model?}``.
+
+    Source discriminator lets the UI show badges or scope behavior (e.g.
+    only AgentStore profiles are editable). Handles are deduped — if the
+    same handle exists in both sources, the AgentStore profile wins (user
+    config beats gateway convention).
+
+    Fixes B1 by giving the frontend a single source of truth; fixes B2 by
+    exposing AgentStore profiles with their true `handle` rather than
+    their UUID `id`, so `@!handle` round-trips correctly through
+    `parse_mentions` → `handle_to_id` on the backend.
+    """
+    from snippbot.api.chat import get_gateway_client
+
+    store = get_agent_store()
+    gateway_client = get_gateway_client()
+
+    # Fetch both sources in parallel.
+    store_task = asyncio.to_thread(store.list_agents)
+    try:
+        gateway_agents, store_profiles = await asyncio.gather(
+            gateway_client.list_agents(), store_task, return_exceptions=True
+        )
+    except Exception as exc:  # pragma: no cover — gather shouldn't raise
+        logger.warning("Failed to list unified agents: %s", exc)
+        return JSONResponse({"error": str(exc)}, status_code=500)
+
+    if isinstance(gateway_agents, Exception):
+        logger.debug("Gateway agent list failed (using empty): %s", gateway_agents)
+        gateway_agents = []
+    if isinstance(store_profiles, Exception):
+        logger.warning("AgentStore list failed (using empty): %s", store_profiles)
+        store_profiles = []
+
+    # Pre-build gateway display map so a store row with the same handle can
+    # borrow the gateway's richer display fields (name, bio, tags, avatar)
+    # when the store row was auto-seeded with only an id/handle (e.g. to
+    # persist `preferred_model` for a gateway-only agent like Elon).
+    gateway_by_handle: dict[str, dict[str, Any]] = {}
+    for agent in gateway_agents or []:
+        gw_id = agent.get("id", "") if isinstance(agent, dict) else ""
+        if not gw_id:
+            continue
+        profile_meta = await asyncio.to_thread(_read_profile_metadata, gw_id)
+        role = agent.get("role") or profile_meta.get("role") or agent.get("description")
+        archetype = profile_meta.get("archetype")
+        gateway_by_handle[gw_id] = {
+            "id": gw_id,
+            "name": agent.get("display_name") or agent.get("name") or gw_id,
+            "short_bio": _compose_short_bio(role, archetype),
+            "expertise_tags": profile_meta.get("expertise_tags") or [],
+            "avatar_url": f"/gateway/api/agents/{gw_id}/avatar",
+        }
+
+    seen_handles: set[str] = set()
+    merged: list[dict] = []
+
+    # Store profiles first, enriched with gateway fields when the store row
+    # matches a gateway handle and the store field is empty/default.
+    for profile in store_profiles:
+        handle = profile.handle
+        if handle in seen_handles:
+            continue
+        seen_handles.add(handle)
+        gw = gateway_by_handle.get(handle, {})
+        # A store row is considered a "stub" for this field if it's empty OR
+        # equals the id/handle (which is how insert_agent_with_id seeds them).
+        store_name_is_stub = not profile.name or profile.name == profile.id or profile.name == profile.handle
+        merged.append({
+            "id": profile.id,
+            "handle": handle,
+            "name": (gw.get("name") if store_name_is_stub and gw.get("name") else None) or profile.name,
+            "short_bio": profile.short_bio or gw.get("short_bio"),
+            "avatar_url": profile.avatar_url or gw.get("avatar_url"),
+            "expertise_tags": profile.expertise_tags or gw.get("expertise_tags") or [],
+            "preferred_model": profile.preferred_model,
+            "tool_profile": profile.tool_profile,
+            "source": "store",
+        })
+
+    # Gateway agents without a matching store row.
+    for agent_id, gw in gateway_by_handle.items():
+        if agent_id in seen_handles:
+            continue
+        seen_handles.add(agent_id)
+        entry: dict[str, Any] = {
+            "id": agent_id,
+            "handle": agent_id,  # gateway convention: handle == id
+            "name": gw["name"],
+            "short_bio": gw["short_bio"],
+            "avatar_url": gw["avatar_url"],
+            "source": "gateway",
+        }
+        if gw["expertise_tags"]:
+            entry["expertise_tags"] = gw["expertise_tags"]
+        merged.append(entry)
+
+    return JSONResponse(merged)
+
+
+# Caps on tool_profile shape (S2 audit finding). Single-user local app, so
+# these are defence-in-depth against a misbehaving UI or malformed JSON, not
+# adversarial input.
+_TOOL_PROFILE_MAX_TOOLS_LIST_LEN = 1000
+_TOOL_PROFILE_MAX_TOOL_NAME_LEN = 200
+_TOOL_PROFILE_ALLOWED_KEYS = frozenset({"mode", "tools", "include_core", "max_tools"})
+
+
+def _validate_tool_profile(tp: Any) -> Optional[str]:
+    """Return an error message if ``tp`` is not a valid tool_profile, else None.
+
+    Schema:
+      {
+        "mode": "allowlist" | "blocklist",   # required when tp is set
+        "tools": [str, ...],                 # required, can be empty
+        "include_core": bool,                # optional, default true
+        "max_tools": int,                    # optional, positive
+      }
+
+    Unknown keys are rejected (S3) so the persisted row stays canonical.
+    ``tools`` is capped at 1000 names of 200 chars each (S2).
+    """
+    if not isinstance(tp, dict):
+        return "'tool_profile' must be an object or null"
+    unknown = set(tp.keys()) - _TOOL_PROFILE_ALLOWED_KEYS
+    if unknown:
+        return f"tool_profile contains unknown keys: {sorted(unknown)}"
+    mode = tp.get("mode")
+    if mode not in ("allowlist", "blocklist"):
+        return "tool_profile.mode must be 'allowlist' or 'blocklist'"
+    tools = tp.get("tools", [])
+    if not isinstance(tools, list) or not all(isinstance(t, str) for t in tools):
+        return "tool_profile.tools must be a list of strings"
+    if len(tools) > _TOOL_PROFILE_MAX_TOOLS_LIST_LEN:
+        return f"tool_profile.tools must contain at most {_TOOL_PROFILE_MAX_TOOLS_LIST_LEN} entries"
+    if any(len(t) > _TOOL_PROFILE_MAX_TOOL_NAME_LEN for t in tools):
+        return f"tool_profile.tools entries must be ≤ {_TOOL_PROFILE_MAX_TOOL_NAME_LEN} chars"
+    if "include_core" in tp and not isinstance(tp["include_core"], bool):
+        return "tool_profile.include_core must be a boolean"
+    if "max_tools" in tp:
+        mt = tp["max_tools"]
+        if not isinstance(mt, int) or isinstance(mt, bool) or mt <= 0:
+            return "tool_profile.max_tools must be a positive integer"
+    return None
+
+
+async def update_agent(request: Request) -> JSONResponse:
+    """PATCH /api/agents/{agent_id} — edit profile fields.
+
+    If the agent doesn't have a chat-DB row yet (e.g. a gateway-only agent
+    like 'elon' or 'donna'), and the caller is setting `preferred_model`,
+    a minimal row is auto-seeded so the preference can be persisted. This
+    keeps the multi-agent chat path's `agent_store.get_agent(...)` read
+    consistent with what gets written here.
+    """
+    agent_id = request.path_params["agent_id"]
+
+    try:
+        body = await request.json()
+    except Exception:
+        return JSONResponse({"error": "Invalid JSON body"}, status_code=400)
+
+    # Validate field types: each editable field must be the right shape if
+    # present. Rejects accidental int/object writes that would corrupt the row
+    # and 500 subsequent reads at pydantic validation time.
+    _str_fields = ("name", "handle", "short_bio", "preferred_model", "avatar_url", "system_prompt")
+    for _field in _str_fields:
+        if _field in body and body[_field] is not None and not isinstance(body[_field], str):
+            return JSONResponse(
+                {"error": f"'{_field}' must be a string"},
+                status_code=400,
+            )
+    if "expertise_tags" in body and body["expertise_tags"] is not None:
+        if not isinstance(body["expertise_tags"], list) or not all(isinstance(t, str) for t in body["expertise_tags"]):
+            return JSONResponse(
+                {"error": "'expertise_tags' must be a list of strings"},
+                status_code=400,
+            )
+
+    tool_profile_present = "tool_profile" in body
+    tool_profile = body.get("tool_profile") if tool_profile_present else None
+    if tool_profile_present and tool_profile is not None:
+        err = _validate_tool_profile(tool_profile)
+        if err:
+            return JSONResponse({"error": err}, status_code=400)
+
+    store = get_agent_store()
+
+    existing = await asyncio.to_thread(store.get_agent, agent_id)
+    if existing is None:
+        # PLAN_PER_AGENT_THINKING_MODE.md soak audit: don't lazy-seed rows
+        # for unknown agent IDs. Option A's startup sync now eagerly seeds
+        # every gateway-folder agent, so a missing row genuinely means
+        # "no such agent" (or the sync hasn't completed yet). Fall back to
+        # checking the gateway directories: if a matching folder exists,
+        # seed (handles the brief startup-race window or a folder added
+        # mid-session); otherwise 404 to prevent orphan rows that would
+        # be deleted on the next sync (the "recreate-delete loop" the
+        # audit flagged).
+        gateway_folder_exists = any(
+            (root / agent_id).is_dir() for root in _profile_search_dirs()
+        )
+        if not gateway_folder_exists:
+            return JSONResponse(
+                {
+                    "error": (
+                        f"Agent '{agent_id}' not found. Create a gateway "
+                        f"agent folder under vps/agents/<handle>/ first."
+                    )
+                },
+                status_code=404,
+            )
+        await asyncio.to_thread(
+            store.insert_agent_with_id,
+            agent_id=agent_id,
+            name=body.get("name") or agent_id,
+            handle=body.get("handle") or agent_id,
+        )
+
+    # Use store sentinel so "field omitted from body" is distinguishable
+    # from "tool_profile: null" (which clears the profile).
+    from snippbot_core.chat.agent_store import AgentStore as _AS
+    tp_arg: Any = body["tool_profile"] if tool_profile_present else _AS._UNSET
+
+    updated = await asyncio.to_thread(
+        store.update_agent,
+        agent_id=agent_id,
+        name=body.get("name"),
+        handle=body.get("handle"),
+        short_bio=body.get("short_bio"),
+        expertise_tags=body.get("expertise_tags"),
+        preferred_model=body.get("preferred_model"),
+        avatar_url=body.get("avatar_url"),
+        system_prompt=body.get("system_prompt"),
+        tool_profile=tp_arg,
+    )
+
+    if not updated and existing is not None:
+        return JSONResponse({"error": "No fields to update"}, status_code=400)
+
+    agent = await asyncio.to_thread(store.get_agent, agent_id)
+
+    # PLAN_AGENT_TOOL_PROFILES Phase 5.4 — fire telemetry when the tool
+    # profile changed. Best-effort: dashboard observability must never
+    # block a successful PATCH.
+    if tool_profile_present:
+        try:
+            from snippbot_core.event_bus import get_event_bus
+            from snippbot_core.events import AGENT_TOOL_PROFILE_UPDATED
+
+            tp_val = body["tool_profile"]
+            payload: dict[str, Any] = {
+                "agent_id": agent_id,
+                "source": "api",
+            }
+            if tp_val is None:
+                payload.update({"mode": None, "tool_count": 0, "include_core": True})
+            elif isinstance(tp_val, dict):
+                payload.update({
+                    "mode": tp_val.get("mode"),
+                    "tool_count": len(tp_val.get("tools") or []),
+                    "include_core": bool(tp_val.get("include_core", True)),
+                })
+            get_event_bus().publish(AGENT_TOOL_PROFILE_UPDATED, payload)
+        except Exception:
+            logger.debug("Failed to publish AGENT_TOOL_PROFILE_UPDATED", exc_info=True)
+
+    return JSONResponse(agent.model_dump(mode="json"))
+
+
+# ===========================================================================
+# Conversation roster endpoints
+# ===========================================================================
+
+
+async def list_roster(request: Request) -> JSONResponse:
+    """GET /api/chat/conversations/{conversation_id}/agents — list active roster."""
+    conversation_id = request.path_params["conversation_id"]
+    store = get_roster_store()
+    members = await asyncio.to_thread(store.active_members, conversation_id)
+    return JSONResponse([m.to_dict() for m in members])
+
+
+async def add_to_roster(request: Request) -> JSONResponse:
+    """POST /api/chat/conversations/{conversation_id}/agents — add agent to roster."""
+    conversation_id = request.path_params["conversation_id"]
+
+    try:
+        body = await request.json()
+    except Exception:
+        return JSONResponse({"error": "Invalid JSON body"}, status_code=400)
+
+    agent_id = body.get("agent_id")
+    if not agent_id:
+        return JSONResponse({"error": "'agent_id' is required"}, status_code=400)
+
+    # NOTE: We don't verify the agent exists in AgentStore — roster members
+    # can reference either AgentStore profiles OR gateway-managed agents
+    # (Snippbot workspace agents like Donna, Elon, etc.). The roster stores
+    # the agent_id as a free-form reference.
+
+    roster_store = get_roster_store()
+    try:
+        member = await asyncio.to_thread(
+            roster_store.add_member,
+            conversation_id=conversation_id,
+            agent_id=agent_id,
+            role=body.get("role", "member"),
+        )
+    except Exception as exc:
+        logger.warning("Failed to add agent to roster: %s", exc)
+        return JSONResponse({"error": str(exc)}, status_code=400)
+
+    return JSONResponse(member.to_dict(), status_code=201)
+
+
+async def update_roster_member(request: Request) -> JSONResponse:
+    """PATCH /api/chat/conversations/{conversation_id}/agents/{agent_id} — update role/muted."""
+    conversation_id = request.path_params["conversation_id"]
+    agent_id = request.path_params["agent_id"]
+
+    try:
+        body = await request.json()
+    except Exception:
+        return JSONResponse({"error": "Invalid JSON body"}, status_code=400)
+
+    roster_store = get_roster_store()
+
+    # Verify membership exists
+    member = await asyncio.to_thread(roster_store.get_member, conversation_id, agent_id)
+    if member is None:
+        return JSONResponse({"error": "Agent is not in this conversation roster"}, status_code=404)
+
+    role = body.get("role")
+    muted = body.get("muted")
+
+    # Promote to lead — `roster_store.promote_lead` atomically updates
+    # both conversation_agents.role and conversations.lead_agent_id in a
+    # single transaction (fixes B6 / M5 / N7 — they used to be separate
+    # thread-worker calls with a crash-window race).
+    # Pass thinking_store so the slot auto-fills on lead promotion when the
+    # new lead is Jarvis-default (PLAN_PER_AGENT_THINKING_MODE.md).
+    if role == "lead":
+        from snippbot_core.thinking.store import get_thinking_store
+        thinking_store = get_thinking_store()
+        promoted = await asyncio.to_thread(
+            roster_store.promote_lead,
+            conversation_id=conversation_id,
+            new_lead_agent_id=agent_id,
+            thinking_store=thinking_store,
+        )
+        if not promoted:
+            return JSONResponse({"error": "Failed to promote agent to lead"}, status_code=400)
+
+        # Handle muted separately if also provided
+        if muted is not None:
+            await asyncio.to_thread(
+                roster_store.update_member,
+                conversation_id=conversation_id,
+                agent_id=agent_id,
+                muted=muted,
+            )
+    else:
+        updated = await asyncio.to_thread(
+            roster_store.update_member,
+            conversation_id=conversation_id,
+            agent_id=agent_id,
+            role=role,
+            muted=muted,
+        )
+        if not updated:
+            return JSONResponse({"error": "No fields to update"}, status_code=400)
+
+    # Return the updated member
+    updated_member = await asyncio.to_thread(roster_store.get_member, conversation_id, agent_id)
+    return JSONResponse(updated_member.to_dict())
+
+
+async def remove_from_roster(request: Request) -> JSONResponse:
+    """DELETE /api/chat/conversations/{conversation_id}/agents/{agent_id} — remove from roster."""
+    conversation_id = request.path_params["conversation_id"]
+    agent_id = request.path_params["agent_id"]
+
+    roster_store = get_roster_store()
+    removed = await asyncio.to_thread(
+        roster_store.remove_member,
+        conversation_id=conversation_id,
+        agent_id=agent_id,
+    )
+
+    if not removed:
+        return JSONResponse({"error": "Agent is not in this conversation roster"}, status_code=404)
+
+    return JSONResponse({"ok": True, "conversation_id": conversation_id, "agent_id": agent_id})
+
+
+# ===========================================================================
+# Route table
+# ===========================================================================
+
+# NOTE: These routes are spread into api_routes which is mounted under /api
+# in server.py, so paths here must NOT include the /api prefix.
+#
+# GET /agents, GET /agents/all, and POST /agents are intentionally NOT
+# registered here — they're defined directly in `routes.py` (next to the
+# workspace-manager handlers) and registered earlier in api_routes so that
+# Starlette's first-match resolves them deterministically. The unified
+# AgentStore-aware handler `list_all_agents` (imported by routes.py) is
+# the one bound to /agents/all. Adding duplicates here would re-introduce
+# the route shadow this module deleted.
+agent_routes = [
+    Route("/agents/{agent_id}", update_agent, methods=["PATCH"]),
+    Route("/tools/available", list_available_tools, methods=["GET"]),
+]
+
+# Roster routes must be injected into chat_routes (which is Mounted at /chat),
+# because Starlette matches Mount("/chat") before reaching top-level routes.
+# Paths are relative to the /chat mount prefix.
+roster_routes = [
+    Route("/conversations/{conversation_id}/agents", list_roster, methods=["GET"]),
+    Route("/conversations/{conversation_id}/agents", add_to_roster, methods=["POST"]),
+    Route("/conversations/{conversation_id}/agents/{agent_id}", update_roster_member, methods=["PATCH"]),
+    Route("/conversations/{conversation_id}/agents/{agent_id}", remove_from_roster, methods=["DELETE"]),
+]