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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.6.2
+Version: 1.6.6
 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.6}/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.6
 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.6}/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.6}/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.6
 
 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.6"   # 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.6}/sdk/agentd.py

@@ -543,7 +543,7 @@ class AgentDaemon:
         validate) is logged and skipped — it must never prevent PERSONAL
         agents from loading.
         """
-        from sdk.agents.manifest import AgentManifest
+        from sdk.agents.manifest import manifest_from_backend_row
 
         try:
             rows = await self.client.list_department_agents()
@@ -555,13 +555,15 @@ class AgentDaemon:
         for row in rows:
             if row.get("status") != "active":
                 continue
-            try:
-                manifests.append(AgentManifest(**row["manifest"]))
-            except Exception as exc:  # noqa: BLE001
+            # Prompt-based rows: the `manifest` column this used to read was
+            # dropped from the table, so every row raised KeyError here.
+            manifest = manifest_from_backend_row(row)
+            if manifest is None:
                 logger.warning(
-                    "agentd.department_agent_manifest_invalid name=%s err=%s",
-                    row.get("name"), exc,
+                    "agentd.department_agent_not_runnable name=%s", row.get("name"),
                 )
+                continue
+            manifests.append(manifest)
         return manifests
 
     async def watch_tickets(self) -> None:

{devops_bot_sdk-1.6.2 → devops_bot_sdk-1.6.6}/sdk/agents/chat.py

@@ -41,14 +41,60 @@ def _tee_events(log_path, on_event: "EventHandler | None") -> "EventHandler":
 EventHandler = Callable[[dict], Awaitable[None]]
 
 
-def _find_agent(name: str) -> AgentManifest:
-    match = next((m for m in load_agents() if m.name == name), None)
-    if match is None:
-        raise LookupError(
-            f"no local agent named '{name}' — install it first "
-            f"(agentos agent add / default-agents activate)"
-        )
-    return match
+def _find_agent(name: str) -> AgentManifest | None:
+    """A LOCAL manifest by name (``~/.agentos/agents``), or None."""
+    return next((m for m in load_agents() if m.name == name), None)
+
+
+async def resolve_agent(name: str, client=None) -> AgentManifest:
+    """Find the agent to run: local manifest → your backend agents → department.
+
+    The BACKEND is where agents live now — they are authored in the web app, and
+    nothing writes ``~/.agentos/agents`` anymore. Resolving only locally meant
+    every agent the UI could list was unrunnable ("no local agent named …"), for
+    department defaults as much as personal ones. A local manifest still wins when
+    present, so a hand-written one keeps overriding its backend namesake.
+
+    ``client`` lets a caller that already has one pass it in rather than having a
+    second one built here behind its back.
+
+    Raises ``LookupError`` naming every place that was checked and why.
+    """
+    local = _find_agent(name)
+    if local is not None:
+        return local
+
+    from sdk.agents.manifest import manifest_from_backend_row
+
+    if client is None:
+        from sdk.client import BackendClient
+        client = BackendClient.from_config()
+
+    reasons: list[str] = []
+    for label, attr in (("your agents", "list_custom_agents"),
+                        ("department defaults", "list_department_agents")):
+        fetch = getattr(client, attr, None)
+        if fetch is None:
+            continue
+        try:
+            rows = await fetch() or []
+        except Exception as exc:  # noqa: BLE001 — a fetch failure is not "not found"
+            reasons.append(f"{label} could not be fetched ({str(exc) or type(exc).__name__})")
+            continue
+        for row in rows:
+            if row.get("name") == name:
+                manifest = manifest_from_backend_row(row)
+                if manifest is not None:
+                    return manifest
+                reasons.append(
+                    f"'{name}' is in your {label} but its prompt is empty, so there "
+                    f"is no instruction to run — add one in the web app"
+                )
+
+    detail = "; ".join(reasons) if reasons else (
+        "not in ~/.agentos/agents/, your backend agents, or your department defaults"
+    )
+    raise LookupError(f"no agent named '{name}' — {detail}")
 
 
 def _render_conversation(history: list[dict] | None, message: str) -> str:
@@ -87,7 +133,7 @@ async def chat_with_agent(
     ``files_changed``, ``error``). ``claude_code``/``model`` engines run through
     the local Claude executor; ``shell`` runs the composed prompt as a command.
     """
-    manifest = _find_agent(name)
+    manifest = await resolve_agent(name)
 
     skills = load_skills()
     skill_text = resolve_skill_text(manifest, skills)
@@ -164,7 +210,7 @@ async def run_agent(
     ``{{variable}}`` is left unfilled — the UI gates the Run button on this, and
     this is the server-side backstop.
     """
-    manifest = _find_agent(name)
+    manifest = await resolve_agent(name)
 
     skills = load_skills()
     skill_text = resolve_skill_text(manifest, skills)

{devops_bot_sdk-1.6.2 → devops_bot_sdk-1.6.6}/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.6}/sdk/agents/manifest.py

@@ -23,8 +23,14 @@ INTEGRATIONS_DIR = Path.home() / ".agentos" / "integrations"
 # Full-string match: ${ENV_VAR_NAME} — no inline secrets allowed in integration env.
 _ENV_PLACEHOLDER_RE = re.compile(r"^\$\{[A-Za-z_][A-Za-z0-9_]*\}$")
 
-# Agent names: letters, digits, hyphen, underscore only.
-_AGENT_NAME_RE = re.compile(r"^[A-Za-z0-9_-]+$")
+# Agent names. Agents are authored in the WEB APP now, where names are free text
+# — "AI Research Agent", "Jira & Confluence Project Management Agent". A rule of
+# `[A-Za-z0-9_-]+` rejected every one of them, so a backend agent could not be
+# materialized into a manifest and therefore could not be run at all. Spaces and
+# ordinary punctuation are allowed; what stays banned is anything that could
+# escape a path or break a log line, since the name is used to derive filenames
+# (see agents/secrets.py, varstore.py, run_log.py — all of which sanitize too).
+_AGENT_NAME_RE = re.compile(r"^[^\x00-\x1f/\\<>:\"|?*]+$")
 
 # Flags an inline secret like `token: abc123...` in free-text fields while
 # allowing the ${ENV_VAR} placeholder form. Mirrors the backend
@@ -210,6 +216,57 @@ def assert_secret_free(obj: object, _where: str = "payload") -> None:
             )
 
 
+def manifest_from_backend_row(row: dict) -> AgentManifest | None:
+    """Materialize a runnable manifest from a backend prompt-based ``agents`` row.
+
+    Agents are authored in the web app, so the row — not a local YAML file — is
+    what the engine has to run. The row shape (docs/DATABASE_SCHEMA.md §4) is
+    ``{name, status, prompt: {system_prompt, variables:[…]}, skills:[{name,
+    description, …}]}``; there is no ``engine``/``trigger``/``manifest`` column
+    anymore, so those are supplied here:
+
+      * ``engine="claude_code"`` — the only engine a web-app agent targets.
+      * ``trigger=manual`` — the row carries no trigger; scheduled and
+        ticket-label dispatch stay a local-manifest feature.
+
+    Each attached skill's description is folded into the prompt rather than left
+    in ``manifest.skills``: skill names on the row refer to backend ``skills``
+    rows, which ``resolve_skill_text`` (local ``~/.agentos/skills``) would drop as
+    dangling references, silently losing the instruction text.
+
+    Returns ``None`` if the row cannot make a valid manifest (no name, or an empty
+    / too-short prompt), so a malformed row is skipped rather than raising.
+    """
+    name = str((row or {}).get("name") or "").strip()
+    if not name:
+        return None
+
+    prompt_obj = row.get("prompt") or {}
+    if not isinstance(prompt_obj, dict):
+        prompt_obj = {}
+    prompt = str(prompt_obj.get("system_prompt") or "").strip()
+
+    for skill in row.get("skills") or []:
+        if not isinstance(skill, dict):
+            continue
+        s_name = str(skill.get("name") or "").strip()
+        s_body = str(skill.get("description") or "").strip()
+        if s_name and s_body:
+            prompt = f"{prompt}\n\n## Skill: {s_name}\n\n{s_body}"
+
+    try:
+        return AgentManifest(
+            name=name,
+            description=prompt[:200],
+            engine="claude_code",
+            trigger=TriggerSpec(type="manual"),
+            prompt=prompt,
+        )
+    except ValidationError as exc:
+        logger.warning("backend agent '%s' is not runnable: %s", name, exc)
+        return None
+
+
 def load_agents(dir: Path = AGENTS_DIR) -> list[AgentManifest]:
     """Load every agent manifest under `dir`.
 

{devops_bot_sdk-1.6.2 → devops_bot_sdk-1.6.6}/sdk/agents/secrets.py

@@ -34,7 +34,15 @@ SECRETS_DIR = Path.home() / ".agentos" / "agent_secrets"
 
 
 def _path(agent_name: str) -> Path:
-    return SECRETS_DIR / f"{agent_name}.json.enc"
+    """Store file for an agent's keys.
+
+    The name is sanitized because agent names are free text from the web app now
+    ("Jira & Confluence Project Management Agent") — an unsanitized name
+    containing a path separator would resolve outside SECRETS_DIR. Mirrors
+    ``varstore._path`` so the two stores key the same way.
+    """
+    safe = "".join(c for c in (agent_name or "") if c.isalnum() or c in "-_") or "agent"
+    return SECRETS_DIR / f"{safe}.json.enc"
 
 
 def load_secrets(agent_name: str) -> dict[str, str]:

{devops_bot_sdk-1.6.2 → devops_bot_sdk-1.6.6}/sdk/agents/ticket_run.py

@@ -25,15 +25,19 @@ async def resolve_manifest(
 ) -> "AgentManifest | None":
     """Find the agent manifest to run, by ``scope``.
 
-    * ``custom`` (default) — a personal agent from the local manifests
-      (``~/.agentos/agents``).
     * ``department`` — an ACTIVE department default pulled from the backend
-      (``list_department_agents``), materialized read-only (never written back),
-      exactly as ``agentd._load_department_agents`` does.
+      (``list_department_agents``) and materialized read-only (never written back).
+    * ``custom`` (default) — a local manifest, then the caller's own backend
+      agents, then their department defaults, via ``chat.resolve_agent``.
 
-    Returns None when no matching agent is found.
+    Backend rows are prompt-based (``prompt.system_prompt`` + attached skills);
+    the ``manifest`` column this used to read no longer exists on the table, so
+    reading it raised ``KeyError`` and made every department agent unrunnable.
+
+    Returns None when no matching agent is found, so the caller reports it.
     """
-    from sdk.agents.manifest import AgentManifest, load_agents
+    from sdk.agents.chat import resolve_agent
+    from sdk.agents.manifest import manifest_from_backend_row
 
     name = (name or "").strip()
     if scope == "department":
@@ -43,16 +47,13 @@ async def resolve_manifest(
             return None
         for row in rows:
             if row.get("name") == name and row.get("status") == "active":
-                try:
-                    return AgentManifest(**row["manifest"])
-                except Exception:  # noqa: BLE001 — invalid manifest → not runnable
-                    return None
+                return manifest_from_backend_row(row)
         return None
 
-    for m in load_agents():
-        if m.name == name:
-            return m
-    return None
+    try:
+        return await resolve_agent(name, client)
+    except LookupError:
+        return None
 
 
 async def run_on_ticket(

{devops_bot_sdk-1.6.2 → devops_bot_sdk-1.6.6}/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:
@@ -296,35 +333,27 @@ def _agent_run_ticket(name: str, flags: list[str]) -> None:
 
 
 def _agent_run(name: str) -> None:
-    from sdk.agents.manifest import AgentManifest, load_agents
+    """`agentos agent run NAME` — dispatch one run locally.
+
+    Resolution order is shared with the UI and `agent chat` (see
+    ``sdk.agents.chat.resolve_agent``): a local manifest wins, then the caller's
+    own backend agents, then their department defaults. It used to check local
+    manifests and department rows only — and read a `manifest` column the
+    prompt-based `agents` table no longer has — so nothing authored in the web app
+    could be run.
+    """
+    from sdk.agents.chat import resolve_agent
     from sdk.client import BackendClient
     from sdk import agentd
 
     client = BackendClient.from_config()
-
-    matched = next((m for m in load_agents() if m.name == name), None)
-    if matched is not None:
-        asyncio.run(agentd._dispatch_agent_run(matched, client))
-        return
-
-    # Not a local personal agent -- check this user's department defaults
-    # (read-only, pulled from the backend; see AgentDaemon._load_department_agents).
     try:
-        dept_row = next(
-            (r for r in asyncio.run(client.list_department_agents()) if r.get("name") == name),
-            None,
-        )
-    except Exception as exc:  # noqa: BLE001
-        print(f"error: could not fetch department agents ({exc})")
-        sys.exit(1)
-
-    if dept_row is None:
-        print(f"error: no agent named '{name}' (checked ~/.agentos/agents/ and "
-              f"this user's department default agents)")
+        manifest = asyncio.run(resolve_agent(name, client))
+    except LookupError as exc:
+        print(f"error: {exc}")
         sys.exit(1)
 
-    dept_manifest = AgentManifest(**dept_row["manifest"])
-    asyncio.run(agentd._dispatch_agent_run(dept_manifest, client))
+    asyncio.run(agentd._dispatch_agent_run(manifest, client))
 
 
 def _agent_logs(name: str) -> None:

{devops_bot_sdk-1.6.2 → devops_bot_sdk-1.6.6}/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.6}/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])