devops-bot-sdk 1.6.2__tar.gz → 1.6.4__tar.gz

{devops_bot_sdk-1.6.2 → devops_bot_sdk-1.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.6.2
+Version: 1.6.4
 Summary: DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app
 Author: noumanaziz2128
 License-Expression: LicenseRef-Proprietary

{devops_bot_sdk-1.6.2 → devops_bot_sdk-1.6.4}/devops_bot_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.6.2
+Version: 1.6.4
 Summary: DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app
 Author: noumanaziz2128
 License-Expression: LicenseRef-Proprietary

{devops_bot_sdk-1.6.2 → devops_bot_sdk-1.6.4}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -93,6 +93,7 @@ sdk/ui/static/styles.css
 sdk/ui/static/tickets.html
 tests/test_agent_activity.py
 tests/test_agent_chat_features.py
+tests/test_agent_listing.py
 tests/test_agent_prompt_async.py
 tests/test_agent_prompt_models.py
 tests/test_agent_run_ticket.py

{devops_bot_sdk-1.6.2 → devops_bot_sdk-1.6.4}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.6.2
+Version: 1.6.4
 
 Public surface:
   BackendClient.from_config()        — create client from ~/.agentos/config.toml
@@ -30,7 +30,7 @@ Rules:
   - All data egress through submit_webhook only
 """
 
-__version__ = "1.6.2"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
+__version__ = "1.6.4"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
 __author__  = "AgentOS"   # sdk.client.SDK_VERSION and the UI server version all read this.
 
 from sdk.client import BackendClient

{devops_bot_sdk-1.6.2 → devops_bot_sdk-1.6.4}/sdk/agents/inventory.py

@@ -37,17 +37,19 @@ def _map_backend_agent(row: dict, source: str) -> dict:
 
 
 async def _custom_agents() -> list[dict]:
-    """The caller's custom agents (``relation_type=person``) from the backend.
+    """The caller's own custom agents (``relation_type='User'``) from the backend.
 
-    Backend is the source of truth — agents are authored in the web app and read
-    via GET /api/v1/agents. Best-effort: degrades to empty on any error.
+    Backend is the source of truth — agents are authored in the web app, owned by
+    the caller's ``users.id``, and read via GET /api/v1/agents. Best-effort:
+    degrades to empty on any error, but logs at WARNING because "this user owns no
+    agents" and "the fetch failed" look identical downstream once both are ``[]``.
     """
     try:
         from sdk.client import BackendClient
         rows = await BackendClient.from_config().list_custom_agents()
         return [_map_backend_agent(r, "custom") for r in rows]
     except Exception as exc:  # noqa: BLE001
-        logger.debug("custom-agent inventory failed: %s", exc)
+        logger.warning("custom-agent inventory failed (listing as empty): %s", exc)
         return []
 
 

{devops_bot_sdk-1.6.2 → devops_bot_sdk-1.6.4}/sdk/cli.py

@@ -201,43 +201,80 @@ def _agent_chat(name: str, message: str) -> None:
         sys.exit(1)
 
 
+def _agent_row_summary(row: dict) -> tuple[str, str]:
+    """``(variables, skills)`` display columns for a backend prompt-based row.
+
+    The live ``agents`` table is prompt-based — ``prompt`` is
+    ``{system_prompt, variables:[{name,…}]}`` and skills arrive hydrated from the
+    ``_AgentSkills`` join. The old ``engine``/``trigger_type`` columns this listing
+    used to print no longer exist on the row, so they are gone from the table.
+    """
+    prompt = row.get("prompt") or {}
+    pvars = prompt.get("variables", []) if isinstance(prompt, dict) else []
+    names = [v.get("name") for v in pvars if isinstance(v, dict) and v.get("name")]
+    skills = [s.get("name") for s in (row.get("skills") or []) if isinstance(s, dict)]
+    return ",".join(n for n in names if n), ",".join(s for s in skills if s)
+
+
 def _agent_list() -> None:
+    """`agentos agent list` — every agent this user can reach.
+
+    The BACKEND is the source of truth for personal agents: they are authored in the
+    web app and stored as ``agents`` rows owned by the caller
+    (``relation_type='User'``, ``relation_id=<the caller's users.id>``), read via
+    GET /api/v1/agents. Local ``~/.agentos/agents/*.yaml`` manifests are still
+    listed — legacy/hand-written ones keep working — but they are no longer the
+    only source: since agent creation moved to the web app nothing writes that
+    directory, so listing it alone showed every user an empty table even when they
+    owned agents server-side.
+    """
     from sdk.agents.manifest import load_agents
     from sdk.client import BackendClient
 
     manifests = load_agents()
 
-    statuses: dict[str, str] = {}
+    custom_rows: list[dict] = []
     dept_rows: list[dict] = []
-    try:
-        client = BackendClient.from_config()
-        remote = asyncio.run(client.list_custom_agents())
-        for item in remote or []:
-            if isinstance(item, dict):
-                nm, st = item.get("name"), item.get("status", "")
-            else:
-                nm, st = getattr(item, "name", None), getattr(item, "status", "")
-            if nm:
-                statuses[nm] = st or ""
-        dept_rows = asyncio.run(client.list_department_agents())
-    except Exception as exc:  # noqa: BLE001 — backend status is best-effort for `list`
-        print(f"warning: could not fetch backend status ({exc})", file=sys.stderr)
-
-    if not manifests and not dept_rows:
-        print("no local agents found in ~/.agentos/agents/, and no department "
-              "default agents returned by the backend")
-        return
-
-    print(f"{'NAME':<24}{'ENGINE':<16}{'TRIGGER':<16}{'SOURCE':<12}{'STATUS'}")
-    for m in manifests:
+    errors: list[str] = []
+    client = BackendClient.from_config()
+    for label, fetch in (("custom", client.list_custom_agents),
+                         ("department", client.list_department_agents)):
+        try:
+            rows = asyncio.run(fetch()) or []
+        except Exception as exc:  # noqa: BLE001 — one source failing must not hide the other
+            # str() is EMPTY on some httpx errors (ReadTimeout, ConnectTimeout), which
+            # would print a warning with no reason at all — name the class then.
+            errors.append(f"{label}: {str(exc) or type(exc).__name__}")
+            continue
+        if label == "custom":
+            custom_rows = [r for r in rows if isinstance(r, dict)]
+        else:
+            dept_rows = [r for r in rows if isinstance(r, dict)]
+
+    for err in errors:
+        print(f"warning: could not fetch {err}", file=sys.stderr)
+
+    # Local manifests that also exist server-side are the same agent — show once.
+    remote_names = {r.get("name") for r in custom_rows}
+    local_only = [m for m in manifests if m.name not in remote_names]
+
+    if not custom_rows and not dept_rows and not local_only:
+        print("no agents found: none owned by you on the backend, no department "
+              "defaults, and no local manifests in ~/.agentos/agents/")
+        if not errors:
+            print("(personal agents are created in the web app — they appear here "
+                  "once saved)")
+        return
+
+    print(f"{'NAME':<32}{'SOURCE':<12}{'STATUS':<10}{'VARIABLES':<24}SKILLS")
+    for source, rows in (("personal", custom_rows), ("department", dept_rows)):
+        for row in rows:
+            variables, skills = _agent_row_summary(row)
+            print(f"{str(row.get('name', ''))[:31]:<32}{source:<12}"
+                  f"{str(row.get('status', ''))[:9]:<10}{variables[:23]:<24}{skills}")
+    for m in local_only:
         trigger_type = m.trigger.type if m.trigger else ""
-        status = statuses.get(m.name, "-")
-        print(f"{m.name:<24}{m.engine:<16}{trigger_type:<16}{'personal':<12}{status}")
-    for row in dept_rows:
-        print(
-            f"{row.get('name', ''):<24}{row.get('engine', ''):<16}"
-            f"{row.get('trigger_type', ''):<16}{'department':<12}{row.get('status', '')}"
-        )
+        print(f"{m.name[:31]:<32}{'local':<12}{'-':<10}{trigger_type[:23]:<24}")
 
 
 def _agent_run_ticket(name: str, flags: list[str]) -> None:

{devops_bot_sdk-1.6.2 → devops_bot_sdk-1.6.4}/sdk/client.py

@@ -1372,12 +1372,25 @@ class BackendClient:
     # This client only lists/reads them and manages per-agent status/delete.
 
     async def list_custom_agents(self) -> list[dict]:
-        """GET /api/v1/agents — list registered custom agents."""
+        """GET /api/v1/agents — the caller's OWN custom agents.
+
+        The backend scopes these to ``agents`` rows whose owner is this caller
+        (``relation_type='User'``, ``relation_id`` = the ``users.id`` it resolves
+        from ``GET /ml-api/users/profile`` for the presented token), so the list is
+        per-user with nothing to pass in. Rows are prompt-based: ``prompt`` =
+        ``{system_prompt, variables:[…]}``, plus a hydrated ``skills`` list.
+
+        An empty list means "this user owns no agents" and nothing else — the
+        backend answers 401 when it cannot verify the identity behind the token and
+        404 when the endpoint is absent (``BackendFeatureMissing``), so a silent
+        empty is never a masked failure. Agents are authored in the web app; the SDK
+        is consume-only.
+        """
+        url = self._url("/api/v1/agents")
         async with httpx.AsyncClient(timeout=15.0) as client:
-            resp = await client.get(
-                self._url("/api/v1/agents"),
-                headers=self._headers,
-            )
+            resp = await client.get(url, headers=self._headers)
+        if resp.status_code == 404:
+            raise BackendFeatureMissing("Custom agents", url)
         _check_status(resp.status_code, self._base_url)
         return resp.json().get("agents", [])
 

{devops_bot_sdk-1.6.2 → devops_bot_sdk-1.6.4}/sdk/ui/api.py

@@ -499,12 +499,14 @@ async def product_agents(product_id: str = Query(...)) -> dict:
 
 @router.get("/agents", dependencies=[_auth])
 async def agents() -> dict:
-    """The caller's custom agents (``relation_type=person``) from the backend.
-
-    Backend is the source of truth — agents are authored in the web app and read
-    here via GET /api/v1/agents (prompt-based shape: prompt = {system_prompt,
-    variables:[…]}; skills = [{name,…}]). Best-effort: on backend error the list
-    is empty with an ``error`` string the UI can surface.
+    """The caller's own custom agents (``relation_type='User'``) from the backend.
+
+    Backend is the source of truth — agents are authored in the web app, owned by
+    the caller's ``users.id`` (which the backend resolves from the profile for the
+    presented token), and read here via GET /api/v1/agents (prompt-based shape:
+    prompt = {system_prompt, variables:[…]}; skills = [{name,…}]). Best-effort: on
+    backend error the list is empty with an ``error`` string the UI can surface, so
+    "you own none" stays distinguishable from "the call failed".
     """
     from sdk.client import BackendClient
     from sdk.exceptions import BackendFeatureMissing
@@ -544,11 +546,16 @@ async def agents_all(department_id: str = Query("")) -> dict:
     """Every agent a person can pick to chat: their custom agents + department
     defaults, both read from the backend (source of truth).
 
-    Custom agents (``relation_type=person``) come from GET /api/v1/agents; defaults
-    (``relation_type=department`` + org-wide common) from GET /api/v1/department-agents.
-    Custom wins on a name collision. Each entry carries its detected variables so
-    the UI can render input fields. Both are best-effort — an unreachable backend
-    yields an empty list plus an error string rather than a hard failure.
+    The caller's own custom agents (``relation_type='User'``, owned by their
+    ``users.id``) come from GET /api/v1/agents; defaults (``relation_type='Department'``
+    + org-wide common) from GET /api/v1/department-agents. Custom wins on a name
+    collision. Each entry carries its detected variables so the UI can render input
+    fields.
+
+    Both sources are independent and best-effort: one failing never empties the
+    other, and each reports its own reason (``custom_error`` / ``defaults_error``)
+    so the picker can say WHY it is empty instead of just "(no agents installed)".
+    An empty ``agents`` with no error means the user genuinely owns none yet.
     """
     from sdk.client import BackendClient
     from sdk.exceptions import BackendFeatureMissing
@@ -556,41 +563,52 @@ async def agents_all(department_id: str = Query("")) -> dict:
     out: list[dict] = []
     seen: set[str] = set()
     dept = department_id
+    custom_error = ""
     defaults_error = ""
 
     try:
         client = BackendClient.from_config()
-        if not dept:
+    except Exception as exc:  # noqa: BLE001 — not configured / no token
+        return {"agents": [], "department_id": dept,
+                "custom_error": str(exc), "defaults_error": str(exc)}
+
+    if not dept:
+        try:
             profile = await client.bootstrap()
             dept = getattr(profile, "department_id", None) or ""
+        except Exception:  # noqa: BLE001 — the department label is cosmetic here
+            dept = ""
 
-        # Custom agents first so they win any name collision with a default.
-        try:
-            for r in await client.list_custom_agents():
-                nm = r.get("name")
-                if not nm or nm in seen:
-                    continue
-                seen.add(nm)
-                out.append(_flat_agent(r, "custom", chattable=True))
-        except BackendFeatureMissing:
-            defaults_error = ("Custom agents aren't available on this backend — "
-                              "it may be running an older version.")
-
-        # Department defaults (a default must be activated/cloned before it runs).
-        try:
-            for r in await client.list_department_agents():
-                nm = r.get("name")
-                if not nm or nm in seen:
-                    continue
-                seen.add(nm)
-                out.append(_flat_agent(r, "default", chattable=False, department_id=dept))
-        except BackendFeatureMissing:
-            defaults_error = ("Department default agents aren't available on this "
-                              "backend — it may be running an older version.")
-    except Exception:  # noqa: BLE001 — best-effort; return whatever we gathered
-        pass
+    # Custom agents first so they win any name collision with a default.
+    try:
+        for r in await client.list_custom_agents():
+            nm = r.get("name")
+            if not nm or nm in seen:
+                continue
+            seen.add(nm)
+            out.append(_flat_agent(r, "custom", chattable=True))
+    except BackendFeatureMissing:
+        custom_error = ("Custom agents aren't available on this backend — "
+                        "it may be running an older version.")
+    except Exception as exc:  # noqa: BLE001 — surface it; don't hide it as "none"
+        custom_error = f"Couldn't load your agents: {exc}"
+
+    # Department defaults (a default must be activated/cloned before it runs).
+    try:
+        for r in await client.list_department_agents():
+            nm = r.get("name")
+            if not nm or nm in seen:
+                continue
+            seen.add(nm)
+            out.append(_flat_agent(r, "default", chattable=False, department_id=dept))
+    except BackendFeatureMissing:
+        defaults_error = ("Department default agents aren't available on this "
+                          "backend — it may be running an older version.")
+    except Exception as exc:  # noqa: BLE001
+        defaults_error = f"Couldn't load department defaults: {exc}"
 
-    return {"agents": out, "department_id": dept, "defaults_error": defaults_error}
+    return {"agents": out, "department_id": dept,
+            "custom_error": custom_error, "defaults_error": defaults_error}
 
 
 @router.get("/profile", dependencies=[_auth])

{devops_bot_sdk-1.6.2 → devops_bot_sdk-1.6.4}/sdk/ui/static/app.js

@@ -605,10 +605,17 @@
         const custom = [], deflt = [];
         (d.agents || []).forEach(a => { agents[a.name] = a; (a.source === "default" ? deflt : custom).push(a); });
         const opt = a => `<option value="${esc(a.name)}">${esc(a.name)}${a.variables && a.variables.length ? " · " + a.variables.length + " input(s)" : ""}${a.source === "default" ? " (department)" : ""}</option>`;
+        // An empty picker has two very different causes — say which. A load error
+        // must never read as "you have no agents"; agents live in the web app, so
+        // the genuinely-empty case points the user there.
+        const emptyLabel = d.custom_error
+          ? "(couldn't load your agents — see the message below)"
+          : "(no agents yet — create one in the web app)";
         $("agent-pick").innerHTML =
           (custom.length ? `<optgroup label="Your agents">${custom.map(opt).join("")}</optgroup>` : "") +
           (deflt.length ? `<optgroup label="Department defaults">${deflt.map(opt).join("")}</optgroup>` : "") ||
-          `<option value="">(no agents installed)</option>`;
+          `<option value="">${esc(emptyLabel)}</option>`;
+        if (d.custom_error) toast(d.custom_error, "err");
         // Deep-link support: /agents.html?agent=NAME preselects that agent.
         const want = new URLSearchParams(location.search).get("agent");
         if (want && agents[want]) $("agent-pick").value = want;

devops_bot_sdk-1.6.4/tests/test_agent_listing.py

@@ -0,0 +1,170 @@
+"""Listing the agents a person actually has — CLI and control panel.
+
+The bug this covers: `agentos agent list` listed only local
+``~/.agentos/agents/*.yaml`` manifests as "personal", but nothing writes that
+directory since agent creation moved to the web app — so every user saw an empty
+table while owning agents server-side. The BACKEND is the source of truth
+(``GET /api/v1/agents``, scoped to the caller's own ``users.id``), and a fetch
+FAILURE must never be rendered as "you have no agents".
+
+Covers:
+  * ``sdk.cli._agent_list`` — backend rows are the personal source; local-only
+    manifests still show; one source failing does not hide the other.
+  * ``sdk.client.BackendClient.list_custom_agents`` — 404 → BackendFeatureMissing.
+  * ``GET /api/ui/agents/all`` — per-source error strings (custom vs defaults).
+"""
+from __future__ import annotations
+
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from sdk import cli
+
+
+def _row(name, *, variables=(), skills=(), status="active"):
+    """A backend prompt-based ``agents`` row (docs/DATABASE_SCHEMA.md §4)."""
+    return {
+        "id": f"id-{name}", "name": name, "status": status,
+        "relation_type": "User", "relation_id": "0c2fa9fe-5707-420c-89c6-a36a11a4bcc3",
+        "prompt": {"system_prompt": "do things", "variables": [{"name": v} for v in variables]},
+        "skills": [{"name": s} for s in skills],
+    }
+
+
+class TestAgentListCli:
+    def _run(self, capsys, *, custom, dept, manifests=()):
+        client = SimpleNamespace(
+            list_custom_agents=AsyncMock(**custom),
+            list_department_agents=AsyncMock(**dept),
+        )
+        with patch("sdk.agents.manifest.load_agents", return_value=list(manifests)), \
+             patch("sdk.client.BackendClient.from_config", return_value=client):
+            cli._agent_list()
+        return capsys.readouterr()
+
+    def test_backend_agents_are_listed_as_personal(self, capsys):
+        """The whole point: web-app-authored agents appear with no local files."""
+        out = self._run(
+            capsys,
+            custom={"return_value": [_row("My Research Agent", variables=["topic"],
+                                          skills=["web-search"])]},
+            dept={"return_value": [_row("AI Engineer")]},
+        )
+        assert "My Research Agent" in out.out
+        assert "personal" in out.out
+        assert "topic" in out.out and "web-search" in out.out
+        assert "AI Engineer" in out.out and "department" in out.out
+
+    def test_local_manifest_also_on_the_backend_is_listed_once(self, capsys):
+        manifest = SimpleNamespace(name="My Research Agent", engine="claude_code",
+                                   trigger=SimpleNamespace(type="schedule"))
+        out = self._run(capsys, custom={"return_value": [_row("My Research Agent")]},
+                        dept={"return_value": []}, manifests=[manifest])
+        assert out.out.count("My Research Agent") == 1
+        assert "local" not in out.out
+
+    def test_local_only_manifest_still_shows(self, capsys):
+        manifest = SimpleNamespace(name="legacy-agent", engine="claude_code",
+                                   trigger=SimpleNamespace(type="schedule"))
+        out = self._run(capsys, custom={"return_value": []}, dept={"return_value": []},
+                        manifests=[manifest])
+        assert "legacy-agent" in out.out and "local" in out.out
+
+    def test_owning_none_says_so_without_an_error(self, capsys):
+        out = self._run(capsys, custom={"return_value": []}, dept={"return_value": []})
+        assert "no agents found" in out.out
+        assert "web app" in out.out          # points the user where agents are made
+        assert "warning" not in out.err
+
+    def test_custom_failure_is_a_warning_and_does_not_hide_defaults(self, capsys):
+        out = self._run(capsys, custom={"side_effect": RuntimeError("boom")},
+                        dept={"return_value": [_row("AI Engineer")]})
+        assert "could not fetch custom: boom" in out.err
+        assert "AI Engineer" in out.out, "one source failing must not empty the other"
+
+    def test_blank_exception_message_still_names_the_failure(self, capsys):
+        """httpx.ReadTimeout stringifies to "" — a reasonless warning is useless."""
+        class ReadTimeout(Exception):
+            def __str__(self):
+                return ""
+        out = self._run(capsys, custom={"side_effect": ReadTimeout()},
+                        dept={"return_value": []})
+        assert "could not fetch custom: ReadTimeout" in out.err
+
+
+class TestListCustomAgentsClient:
+    @pytest.mark.asyncio
+    async def test_404_raises_backend_feature_missing(self):
+        """Parity with list_department_agents — an absent endpoint is not "no agents"."""
+        from sdk.client import BackendClient
+        from sdk.exceptions import BackendFeatureMissing
+
+        client = BackendClient(base_url="http://be", token="co_x_y")
+        resp = SimpleNamespace(status_code=404, json=lambda: {})
+        http = AsyncMock()
+        http.get = AsyncMock(return_value=resp)
+        http.__aenter__ = AsyncMock(return_value=http)
+        http.__aexit__ = AsyncMock(return_value=False)
+        with patch("sdk.client.httpx.AsyncClient", return_value=http):
+            with pytest.raises(BackendFeatureMissing):
+                await client.list_custom_agents()
+
+    @pytest.mark.asyncio
+    async def test_200_returns_rows(self):
+        from sdk.client import BackendClient
+
+        client = BackendClient(base_url="http://be", token="co_x_y")
+        rows = [_row("a")]
+        resp = SimpleNamespace(status_code=200, json=lambda: {"agents": rows})
+        http = AsyncMock()
+        http.get = AsyncMock(return_value=resp)
+        http.__aenter__ = AsyncMock(return_value=http)
+        http.__aexit__ = AsyncMock(return_value=False)
+        with patch("sdk.client.httpx.AsyncClient", return_value=http):
+            assert await client.list_custom_agents() == rows
+
+
+class TestUiAgentsAll:
+    @pytest.mark.asyncio
+    async def test_reports_custom_and_default_errors_separately(self):
+        from sdk.ui import api
+
+        client = SimpleNamespace(
+            list_custom_agents=AsyncMock(side_effect=RuntimeError("custom down")),
+            list_department_agents=AsyncMock(return_value=[_row("AI Engineer")]),
+            bootstrap=AsyncMock(return_value=SimpleNamespace(department_id="d-1")),
+        )
+        with patch("sdk.client.BackendClient.from_config", return_value=client):
+            out = await api.agents_all(department_id="d-1")
+        assert "custom down" in out["custom_error"]
+        assert out["defaults_error"] == ""
+        assert [a["name"] for a in out["agents"]] == ["AI Engineer"]
+
+    @pytest.mark.asyncio
+    async def test_no_errors_when_the_user_simply_owns_none(self):
+        from sdk.ui import api
+
+        client = SimpleNamespace(
+            list_custom_agents=AsyncMock(return_value=[]),
+            list_department_agents=AsyncMock(return_value=[]),
+            bootstrap=AsyncMock(return_value=SimpleNamespace(department_id="d-1")),
+        )
+        with patch("sdk.client.BackendClient.from_config", return_value=client):
+            out = await api.agents_all(department_id="d-1")
+        assert out == {"agents": [], "department_id": "d-1",
+                       "custom_error": "", "defaults_error": ""}
+
+    @pytest.mark.asyncio
+    async def test_custom_wins_a_name_collision_with_a_default(self):
+        from sdk.ui import api
+
+        client = SimpleNamespace(
+            list_custom_agents=AsyncMock(return_value=[_row("Shared")]),
+            list_department_agents=AsyncMock(return_value=[_row("Shared")]),
+            bootstrap=AsyncMock(return_value=SimpleNamespace(department_id="d-1")),
+        )
+        with patch("sdk.client.BackendClient.from_config", return_value=client):
+            out = await api.agents_all(department_id="d-1")
+        assert [(a["name"], a["source"]) for a in out["agents"]] == [("Shared", "custom")]