devops-bot-sdk 1.6.19__tar.gz → 1.6.24__tar.gz

{devops_bot_sdk-1.6.19 → devops_bot_sdk-1.6.24}/PKG-INFO

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

{devops_bot_sdk-1.6.19 → devops_bot_sdk-1.6.24}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.6.19 → devops_bot_sdk-1.6.24}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -17,13 +17,18 @@ sdk/exceptions.py
 sdk/formats.py
 sdk/git_ops.py
 sdk/github_ingest.py
+sdk/graph_recon.py
 sdk/graphify.py
+sdk/intake.py
 sdk/local_exec.py
+sdk/phase_timer.py
+sdk/plan_run.py
 sdk/platform_compat.py
 sdk/py.typed
 sdk/run_auto.py
 sdk/scheduler.py
 sdk/sse.py
+sdk/task_file.py
 sdk/test.py
 sdk/test_pipeline.py
 sdk/ticket_fields.py
@@ -88,6 +93,7 @@ sdk/ui/session.py
 sdk/ui/setup_manager.py
 sdk/ui/static/agents.html
 sdk/ui/static/app.js
+sdk/ui/static/chat.html
 sdk/ui/static/custom-agents.html
 sdk/ui/static/default-agents.html
 sdk/ui/static/index.html
@@ -98,6 +104,7 @@ sdk/ui/static/setup.html
 sdk/ui/static/styles.css
 sdk/ui/static/tickets.html
 tests/test_agent_activity.py
+tests/test_agent_activity_tracking.py
 tests/test_agent_chat_features.py
 tests/test_agent_listing.py
 tests/test_agent_prompt_async.py
@@ -113,19 +120,28 @@ tests/test_config_token_diagnostics.py
 tests/test_configure_token_owner.py
 tests/test_console_encoding.py
 tests/test_departments.py
+tests/test_epic_decompose_run.py
 tests/test_epic_inherited_agent_id.py
+tests/test_epic_session_isolation.py
 tests/test_formats.py
 tests/test_git_action.py
 tests/test_github_ingest.py
+tests/test_graph_recon.py
+tests/test_graphify_build.py
+tests/test_graphify_hook_install.py
 tests/test_health.py
 tests/test_otp_login.py
+tests/test_phase_timer.py
+tests/test_recon_session_isolation.py
 tests/test_run_auto_agent_only.py
 tests/test_run_outputs.py
 tests/test_schedule_api.py
 tests/test_scheduler.py
 tests/test_service_token_warning.py
+tests/test_task_file_and_plan_run.py
 tests/test_ticket_fields.py
 tests/test_ticket_run_resolve_by_id.py
+tests/test_ticket_speed_fixes.py
 tests/test_update_timer.py
 tests/test_updater_extras.py
 tests/test_vps_health.py

{devops_bot_sdk-1.6.19 → devops_bot_sdk-1.6.24}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.6.19
+Version: 1.6.24
 
 Public surface:
   BackendClient.from_config()        — create client from ~/.agentos/config.toml
@@ -34,7 +34,7 @@ Rules:
   - All data egress through submit_webhook only
 """
 
-__version__ = "1.6.19"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
+__version__ = "1.6.24"   # 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.19 → devops_bot_sdk-1.6.24}/sdk/agentd.py

@@ -114,6 +114,22 @@ def _stop_requested() -> bool:
     return _STOP_FILE.exists()
 
 
+def _auto_loop_owns_queue() -> bool:
+    """True when an `agentos-auto` loop is live and processing the ticket queue.
+
+    Reuses run_auto's own liveness check, which already distinguishes a running
+    daemon from a stale PID file left by a crash. Best-effort: if we cannot tell,
+    say False — refusing to dispatch on an unreadable PID file would silently
+    disable ticket-label agents, which is worse than the overlap we are avoiding.
+    """
+    try:
+        from sdk import run_auto
+
+        return run_auto._daemon_running() is not None
+    except Exception:  # noqa: BLE001
+        return False
+
+
 def _set_stop() -> None:
     _AGENTOS_DIR.mkdir(parents=True, exist_ok=True)
     _STOP_FILE.write_text("stop")
@@ -585,11 +601,30 @@ class AgentDaemon:
         `_TICKET_POLL_INTERVAL_S` between iterations. Keeps an in-memory set
         of already-dispatched task ids so a task is never re-fired on a later
         poll within this daemon's lifetime.
+
+        DEFERS while an `agentos-auto` loop owns the queue. That loop processes
+        tickets strictly sequentially, oldest `createdAt` first; dispatching from
+        here concurrently (`asyncio.create_task` below) would run a ticket
+        alongside it and out of order — two agents editing the same working
+        directory at once, and a queue that no longer honours creation time.
+        Deferring costs at most one poll interval: the ticket stays To Do and is
+        picked up on a later tick, or by the auto-loop itself.
         """
         dispatched_task_ids: set[str] = set()
         ticket_agents = [m for m in self._manifests if m.trigger.type == "ticket_label"]
+        deferring = False
 
         while not _stop_requested():
+            if ticket_agents and _auto_loop_owns_queue():
+                if not deferring:
+                    logger.info("agentd.watch_tickets_deferred reason=auto_loop_running")
+                    deferring = True
+                await asyncio.sleep(_TICKET_POLL_INTERVAL_S)
+                continue
+            if deferring:
+                logger.info("agentd.watch_tickets_resumed")
+                deferring = False
+
             if ticket_agents:
                 try:
                     tasks = await self.client.list_todo_tasks_raw()
@@ -611,7 +646,7 @@ class AgentDaemon:
 
             await asyncio.sleep(_TICKET_POLL_INTERVAL_S)
 
-    async def run_forever(self) -> None:
+    async def run_forever(self) -> None:  # noqa: D401 — see class docstring
         """Load + schedule agents, start the cron scheduler, then watch tickets
         until stopped. Shuts the scheduler down cleanly on the way out."""
         await self.load_and_schedule()

devops_bot_sdk-1.6.24/sdk/agents/activity.py

@@ -0,0 +1,250 @@
+"""Agent-activity reporting — the ONE place a custom / department agent run is
+recorded, for both sinks:
+
+  * the LOCAL usage ledger (``sdk.agents.usage`` → ``~/.agentos/usage.jsonl``),
+    which backs ``GET /api/ui/agents/usage`` and, through it, the AI backend
+    report's "VPS Agent Logs" section, and
+  * the PLATFORM activity feed — ``POST {ML_GATEWAY}/ml-api/agent-activity``
+    with ``{activity, agentId}``, which the ML backend writes into the Postgres
+    ``agent_activities`` table (docs/DATABASE_SCHEMA.md #3: ``user_id``,
+    ``activity``, ``agent_id``) and the AI backend reads back RBAC-scoped for
+    reporting + chat.
+
+Every VPS-side agent run goes through here no matter how it was triggered — the
+control panel (chat / run / run-on-ticket), an ``agentd`` cron schedule, an
+``agentd`` ticket-label trigger, the CLI, or the desktop IPC bridge. Before this
+module only the control-panel paths emitted, so scheduled and ticket-triggered
+runs never reached ``agent_activities``.
+
+``agent_activities.agent_id`` is an FK onto ``agents.id``, so only agents that
+exist in the BACKEND emit — ``BackendClient.resolve_agent_id`` returns None for
+a local-only manifest and the emit is skipped (the local ledger still records
+it). Both custom and department-default agents resolve, so both are tracked.
+
+Best-effort throughout: nothing in here raises into a run.
+"""
+from __future__ import annotations
+
+import logging
+import os
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:  # pragma: no cover — typing only
+    from sdk.client import BackendClient
+
+logger = logging.getLogger("sdk.agents.activity")
+
+# How a run reached us → the verb that opens the activity line. Keep these short:
+# the feed is rendered as one line per row in reports and in chat answers.
+_VERB = {
+    "chat": "Chatted with",
+    "run": "Ran",
+    "run-ticket": "Ran",
+    "scheduled": "Ran (schedule)",
+    "ticket_label": "Ran (ticket trigger)",
+    "cli": "Ran (cli)",
+}
+
+
+def describe(name: str, kind: str, result: dict | None, duration_s: float = 0.0,
+             detail: str = "") -> str:
+    """The human-readable ``activity`` string stored in ``agent_activities``."""
+    res = result or {}
+    verb = _VERB.get(kind, "Ran")
+    status = "ok" if res.get("ok") else "error"
+    line = f"{verb} agent '{name}' — {status}"
+    if duration_s:
+        line += f" ({round(float(duration_s), 1)}s)"
+    err = str(res.get("error") or "").strip()
+    if status == "error" and err:
+        line += f": {err[:200]}"
+    if detail:
+        line += f" — {detail}"
+    return line
+
+
+# ── Run-log lines → the activity event ────────────────────────────────────
+# Every line `run_log.log_line` writes to a run's Markdown file is also noted
+# here, so the activity event a run produces carries what the run actually DID
+# rather than only that it finished. The buffer exists because the alternative —
+# a webhook POST per line — is exactly the pattern that saturated the shared
+# Postgres pool and led to `client.ActivityFlusher` (see sdk/client.py:100).
+#
+# Two sinks, matching that design:
+#   * a ticket-scoped `ActivityFlusher`, when one is active (the ticket loop sets
+#     it) — `record()` does no I/O and the flusher coalesces into one POST every
+#     3-5 minutes;
+#   * otherwise this per-run buffer, drained by `record_run` into the ONE
+#     per-run event. So an agent run costs one POST no matter how chatty it is.
+_LINE_BUF: dict[str, list[str]] = {}
+_LINE_BUF_MAX_LINES = 40          # keep the tail — recent lines are the useful ones
+_LINE_BUF_MAX_CHARS = 4000        # bounded like _ACTIVITY_FLUSH_MAX_CHARS
+
+
+def note(bucket: str, text: str) -> None:
+    """Record one run-log line against ``bucket`` (a run's output folder name).
+
+    Never raises and never does I/O: this is called from `run_log.log_line`, on
+    the hot path of a streaming engine run.
+    """
+    line = str(text or "").strip()
+    if not line:
+        return
+    try:
+        from sdk.client import _ACTIVE_ACTIVITY_FLUSHER
+        flusher = _ACTIVE_ACTIVITY_FLUSHER.get()
+    except Exception:  # noqa: BLE001
+        flusher = None
+    if flusher is not None:
+        flusher.record(line)
+        return
+    buf = _LINE_BUF.setdefault(str(bucket), [])
+    buf.append(line)
+    if len(buf) > _LINE_BUF_MAX_LINES:
+        del buf[: len(buf) - _LINE_BUF_MAX_LINES]
+
+
+def drain(bucket: str) -> list[str]:
+    """Take and clear the lines noted for ``bucket``."""
+    return _LINE_BUF.pop(str(bucket), [])
+
+
+def _lines_block(lines: list[str]) -> str:
+    """The recorded lines as one bounded block, newest-biased."""
+    if not lines:
+        return ""
+    out: list[str] = []
+    total = 0
+    for line in reversed(lines):                  # newest first, then re-reverse
+        if total + len(line) + 1 > _LINE_BUF_MAX_CHARS:
+            break
+        out.append(line)
+        total += len(line) + 1
+    return "\n".join(reversed(out))
+
+
+def mirror_to_auto_log(name: str, kind: str, result: dict | None,
+                       duration_s: float = 0.0, *, detail: str = "",
+                       task_id: str = "") -> bool:
+    """Append a one-line summary of an agent run to ``~/.agentos/auto.log``.
+
+    `agentos-auto logs [-f]` tails that file and nothing else, so before this an
+    agent run — including a ticket-triggered one — was invisible there: it landed
+    in `agent_outputs/<agent>/*.md` and `usage.jsonl`, and an operator watching
+    the log saw the ticket loop go quiet with no explanation. Mirroring here
+    rather than at each trigger site is deliberate: every VPS-side run already
+    funnels through `record_run`, so one append covers the panel, the CLI, an
+    agentd cron schedule, an agentd ticket-label trigger and the IPC bridge.
+
+    A summary, not a transcript — the transcript stays in `agent_outputs/`, and
+    the pointer below is how you get from one to the other. Best-effort and
+    silent on failure: a log line must never break a run. Set
+    ``AGENTOS_NO_AGENT_LOG_MIRROR=1`` to turn it off.
+    """
+    if os.getenv("AGENTOS_NO_AGENT_LOG_MIRROR"):
+        return False
+    try:
+        from sdk.agents.run_log import agent_dir
+        from sdk.run_auto import _LOG_FILE
+    except Exception:  # noqa: BLE001 — never break a run over a log line
+        return False
+
+    res = result or {}
+    stamp = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%SZ")
+    line = f"  • [{stamp}] {describe(name, kind, res, duration_s, detail)}"
+    # agentd passes the ticket BOTH as `detail` ("task T1") and as `task_id`, so an
+    # unconditional suffix renders "… — task T1 · task T1".
+    if task_id and f"task {task_id}" not in line:
+        line += f" · task {task_id}"
+    try:
+        where = agent_dir(name)
+    except Exception:  # noqa: BLE001
+        where = None
+    if where:
+        line += f"\n    ↳ transcript: {where}"
+
+    try:
+        _LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
+        with _LOG_FILE.open("a", encoding="utf-8") as fh:
+            fh.write(line + "\n")
+        return True
+    except Exception as exc:  # noqa: BLE001
+        logger.debug("auto.log mirror failed agent=%s err=%s", name, exc)
+        return False
+
+
+async def emit(name: str, kind: str, result: dict | None, duration_s: float = 0.0,
+               *, client: "BackendClient | None" = None, detail: str = "",
+               task_id: str = "", lines: list[str] | None = None) -> bool:
+    """Emit ONE ``{activity, agentId[, taskId]}`` event for a finished agent run.
+
+    Returns True when the webhook accepted it, False otherwise (unknown agent,
+    no token, backend down) — never raises.
+
+    ``task_id`` attributes a ticket-triggered run to its ticket. A scheduled or
+    CLI run has no ticket and omits it.
+    """
+    try:
+        if client is None:
+            from sdk.client import BackendClient
+            client = BackendClient.from_config()
+        agent_id = await client.resolve_agent_id(name)
+        if not agent_id:
+            # Local-only agent → not tracked. This used to return in silence,
+            # which is why "the webhook never fires" had no diagnosable cause:
+            # the run succeeded, the ledger recorded it, and the only missing
+            # thing was a Postgres row nobody could tie back to a decision.
+            # `resolve_agent_id` logs WHY (unreachable listing vs genuinely
+            # absent); this says what it cost.
+            logger.warning(
+                "agent %r has no backend agentId — skipping the agent-activity "
+                "webhook, so this run will not appear in agent_activities. It is "
+                "still in the local ledger and in agent_outputs/.", name)
+            return False
+        activity_text = describe(name, kind, result, duration_s, detail)
+        block = _lines_block(lines or [])
+        if block:
+            activity_text += "\n" + block
+        return await client.log_agent_activity(activity_text, agent_id, task_id=task_id)
+    except Exception as exc:  # noqa: BLE001 — activity emit must never break a run
+        logger.warning("activity emit failed agent=%s err=%s", name, exc)
+        return False
+
+
+async def record_run(name: str, kind: str, result: dict | None, duration_s: float = 0.0,
+                     *, client: "BackendClient | None" = None, detail: str = "",
+                     task_id: str = "") -> None:
+    """Record a finished run to BOTH sinks: local ledger, then platform feed.
+
+    The ledger write happens first and independently of the webhook, so a
+    backend outage still leaves per-agent utilisation on the VPS (which is what
+    ``/api/ui/agents/usage`` and the report's "VPS Agent Logs" read).
+    """
+    res: dict[str, Any] = result or {}
+    try:
+        from sdk.agents import usage as usage_mod
+        usage_mod.record(
+            name,
+            kind=kind,
+            duration_s=duration_s,
+            input_tokens=res.get("input_tokens", 0) or 0,
+            output_tokens=res.get("output_tokens", 0) or 0,
+            cost_usd=res.get("cost_usd", 0.0) or 0.0,
+            ok=bool(res.get("ok")),
+        )
+    except Exception as exc:  # noqa: BLE001 — ledger write must never break a run
+        logger.debug("activity ledger write failed agent=%s err=%s", name, exc)
+
+    mirror_to_auto_log(name, kind, res, duration_s, detail=detail, task_id=task_id)
+
+    # Whatever this run's log lines recorded travels with the ONE event, so the
+    # activity feed shows what the agent did, not just that it finished.
+    try:
+        from sdk.agents.run_log import _folder_name
+        lines = drain(_folder_name(name))
+    except Exception:  # noqa: BLE001
+        lines = []
+
+    await emit(name, kind, res, duration_s, client=client, detail=detail,
+               task_id=task_id, lines=lines)

{devops_bot_sdk-1.6.19 → devops_bot_sdk-1.6.24}/sdk/agents/run_log.py

@@ -175,7 +175,13 @@ def start_run(agent_name: str, *, scope: str = "custom", engine: str = "",
 
 
 def log_line(path: Path | None, text: str) -> None:
-    """Append a raw line to the activity block (best-effort, no-op if path is None)."""
+    """Append a raw line to the activity block (best-effort, no-op if path is None).
+
+    The line is also noted for the run's activity event (``activity.note``), so
+    what the run did reaches the platform feed and not merely the fact that it
+    finished. That is a buffer append with no I/O — a POST per line is what
+    saturated the shared Postgres pool and is why the coalescing exists.
+    """
     if not path:
         return
     try:
@@ -183,6 +189,11 @@ def log_line(path: Path | None, text: str) -> None:
             fh.write(f"[{_now()}] {text}\n")
     except Exception as exc:  # noqa: BLE001
         logger.debug("run_log.line failed: %s", exc)
+    try:
+        from sdk.agents import activity
+        activity.note(path.parent.name, str(text))
+    except Exception as exc:  # noqa: BLE001 — a feed note must never break a run
+        logger.debug("run_log.note failed: %s", exc)
 
 
 def log_event(path: Path | None, event: dict) -> None:

{devops_bot_sdk-1.6.19 → devops_bot_sdk-1.6.24}/sdk/cli.py

@@ -12,6 +12,14 @@ Command surface:
         Store (or replace) the co_<uuid>_<hex> backend token. See
         sdk.config.configure_cli.
 
+    agentos chat [--product-id ID] [--pv-id ID] [--no-autorun]
+        Describe work in plain language; the backend asks the follow-up
+        questions until it has a goal, scope, acceptance criteria,
+        constraints, owning department and priority, then builds the plan,
+        creates the ticket(s) and wakes the auto-loop. The new ticket still
+        runs in createdAt order behind anything already queued.
+        See sdk.intake.chat_cli.
+
     agentos agent new
         Interactive wizard (input() prompts) — name, description, engine
         (default "claude_code"), trigger type (schedule/ticket_label/manual/
@@ -86,6 +94,15 @@ def main() -> None:
         configure_cli(rotate="--rotate" in sys.argv)
         return
 
+    if noun == "chat":
+        from sdk.intake import IntakeError, chat_cli
+        try:
+            chat_cli(rest)
+        except IntakeError as exc:
+            print(f"error: {exc}")
+            sys.exit(1)
+        return
+
     if noun == "agent":
         _agent_command(rest)
         return
@@ -111,9 +128,10 @@ def main() -> None:
 
 
 def _print_usage() -> None:
-    print("usage: agentos <configure|agent|integration|default-agents|agentd|github> ...")
+    print("usage: agentos <configure|chat|agent|integration|default-agents|agentd|github> ...")
     print()
     print("  agentos configure [--rotate]")
+    print("  agentos chat [--product-id ID] [--pv-id ID] [--no-autorun]   # requirements → ticket")
     print("  agentos agent <list|run NAME|chat NAME MSG|logs NAME|enable NAME|disable NAME|rm NAME>")
     print("  agentos agent <set-key NAME KEY[=VALUE]…|keys NAME|rm-key NAME KEY…>   # persistent API keys (custom agents)")
     print("  agentos integration <add PATH|test NAME|list|rm NAME>")

{devops_bot_sdk-1.6.19 → devops_bot_sdk-1.6.24}/sdk/client.py

@@ -45,6 +45,11 @@ logger = logging.getLogger(__name__)
 # agents without a lookup on every run.
 _AGENT_ID_CACHE: dict[str, str] = {}
 
+# GitHub access token, keyed by the co_ token that fetched it → (token, expires_at
+# monotonic). Keyed per credential so two clients on one box never share a token.
+_GITHUB_TOKEN_CACHE: dict[str, tuple[str, float]] = {}
+_GITHUB_TOKEN_TTL_S = float(os.getenv("AGENTOS_GITHUB_TOKEN_TTL_S", "") or 1800.0)
+
 # ── Ticket status-change observers ────────────────────────────────────────
 # Best-effort, synchronous hooks fired when the client changes a ticket's backend
 # status (In Progress / Backlog / To Do). The CLI loop registers one to track
@@ -928,9 +933,25 @@ class BackendClient:
         endpoint lives on the ML backend (devopsbot-be), authorised by the same
         co_ token. Best-effort: returns None on any failure so a run without a
         connected GitHub account still proceeds (clone/PR steps just won't auth).
+
+        Memoized for _GITHUB_TOKEN_TTL_S. The auto-loop asks for this once per
+        ticket and again inside epic/story handling, so a long queue made the same
+        round-trip dozens of times for a value that does not change between
+        tickets. A TTL rather than a permanent cache so a token refreshed on the
+        backend is picked up without restarting the daemon; a failed fetch is not
+        cached, so a transient outage cannot pin None for the whole window.
         """
+        import time as _time
+
+        now = _time.monotonic()
+        cached = _GITHUB_TOKEN_CACHE.get(self._token)
+        if cached and now < cached[1]:
+            return cached[0]
         record = await self.github_token_record()
-        return (record or {}).get("accessToken") or None
+        token = (record or {}).get("accessToken") or None
+        if token:
+            _GITHUB_TOKEN_CACHE[self._token] = (token, now + _GITHUB_TOKEN_TTL_S)
+        return token
 
     async def ingest_github_prs(
         self,
@@ -1435,23 +1456,79 @@ class BackendClient:
         Returns None when the name isn't a backend agent (e.g. a local-only manifest)
         — the caller then skips activity emit, so only backend agents are tracked.
         Cached per process (the id↔name mapping is stable within a session).
+
+        Two things this deliberately does NOT do:
+
+        * **Negative-cache a lookup that failed.** Both listings are best-effort, so
+          a transient 5xx or timeout used to leave `rows` empty, be recorded as
+          "not a backend agent", and disable activity reporting for that agent for
+          the rest of the process — a daemon restart was the only cure, and nothing
+          said why. A failed lookup now returns None WITHOUT caching, so the next
+          run retries.
+        * **Insist on byte-identical names.** The name comes from a local manifest
+          or a caller argument while the row is authored in the web app, so casing
+          and stray whitespace drift. Exact match wins; a casefolded match is
+          accepted as a fallback and logged, because a silent near-miss here
+          presents as "the webhook never fires" with no other symptom.
         """
         nm = (name or "").strip()
         if not nm:
             return None
         if nm in _AGENT_ID_CACHE:
             return _AGENT_ID_CACHE[nm] or None
+
+        # The ML gateway first: it owns the `agents` table that
+        # `agent_activities.agent_id` points at, and answers both scopes in one
+        # call. The AI backend's two per-scope endpoints are the fallback.
         rows: list[dict] = []
-        for fetch in (self.list_custom_agents, self.list_department_agents):
-            try:
-                rows += await fetch()
-            except Exception:  # noqa: BLE001 — best-effort across both sources
-                pass
+        failures = 0
+        try:
+            rows = await self.list_gateway_agents()
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("client.resolve_agent_id gateway listing failed err=%s", exc)
+        if not rows:
+            for fetch in (self.list_custom_agents, self.list_department_agents):
+                try:
+                    rows += await fetch()
+                except Exception as exc:  # noqa: BLE001 — best-effort across sources
+                    failures += 1
+                    logger.warning("client.resolve_agent_id listing failed source=%s err=%s",
+                                   getattr(fetch, "__name__", "?"), exc)
+            if not rows and not failures:
+                # Both fallbacks answered, both empty: nothing is visible to this
+                # token at all, which is not the same as "this name is absent".
+                failures = 1
+
         for r in rows:
             if r.get("name") == nm and r.get("id"):
                 _AGENT_ID_CACHE[nm] = str(r["id"])
                 return _AGENT_ID_CACHE[nm]
-        _AGENT_ID_CACHE[nm] = ""     # negative-cache: not a backend agent
+
+        folded = nm.casefold()
+        for r in rows:
+            if str(r.get("name") or "").strip().casefold() == folded and r.get("id"):
+                logger.warning(
+                    "client.resolve_agent_id matched %r to backend agent %r by "
+                    "casefolded name — align the names to make this exact",
+                    nm, r.get("name"),
+                )
+                _AGENT_ID_CACHE[nm] = str(r["id"])
+                return _AGENT_ID_CACHE[nm]
+
+        if failures and not rows:
+            # Could not see the catalogue at all — "absent" is not established.
+            logger.warning(
+                "client.resolve_agent_id could not reach any agent listing; not "
+                "caching a negative for %r (activity will retry next run)", nm)
+            return None
+
+        logger.warning(
+            "client.resolve_agent_id: %r is not a backend agent for this token "
+            "(%d visible: %s) — activity will NOT be recorded in agent_activities",
+            nm, len(rows),
+            ", ".join(sorted(str(r.get("name")) for r in rows if r.get("name")))[:300],
+        )
+        _AGENT_ID_CACHE[nm] = ""     # negative-cache: genuinely not a backend agent
         return None
 
     async def report_vps_allocation(self, payload: dict) -> bool:
@@ -1687,6 +1764,44 @@ class BackendClient:
         _check_status(resp.status_code, self._base_url)
         return resp.json().get("agents", [])
 
+    async def list_gateway_agents(self) -> list[dict]:
+        """GET ``{ML_GATEWAY_URL}/ml-api/agents`` — every agent this token can see.
+
+        One call returns BOTH scopes: ``data.personal`` (the caller's own custom
+        agents) and ``data.department`` (their department's defaults). Rows carry
+        the same ``id``/``name`` shape as the AI backend's two per-scope endpoints.
+
+        This is the authoritative list for activity reporting, and the reason it is
+        preferred over ``list_custom_agents`` + ``list_department_agents``:
+        ``agent_activities.agent_id`` is a foreign key onto ``agents.id`` in THIS
+        service's Postgres, and this endpoint reads that same table. The AI
+        backend's listings are a re-projection of it — equivalent today (verified:
+        identical ids for all six agents) but able to drift, and they cost two
+        round-trips plus a dependency on a second service being up.
+
+        Best-effort: returns [] rather than raising, so a caller can fall back.
+        """
+        from sdk.config import ML_GATEWAY_URL
+
+        url = f"{ML_GATEWAY_URL.rstrip('/')}/ml-api/agents"
+        headers = {**self._headers, "accept": "*/*",
+                   "developer-name": "null", "product": ""}
+        async with httpx.AsyncClient(timeout=15.0) as client:
+            resp = await client.get(url, headers=headers)
+        if resp.status_code >= 400:
+            logger.warning("client.list_gateway_agents failed status=%s body=%s",
+                           resp.status_code, resp.text[:200])
+            return []
+        data = (resp.json() or {}).get("data") or {}
+        if not isinstance(data, dict):
+            return []
+        rows: list[dict] = []
+        for scope in ("personal", "department"):
+            got = data.get(scope)
+            if isinstance(got, list):
+                rows += [r for r in got if isinstance(r, dict)]
+        return rows
+
     async def list_product_agents(self, product_id: str) -> dict:
         """GET /api/v1/product/agents?product_id=… — a product's custom agents.
 

{devops_bot_sdk-1.6.19 → devops_bot_sdk-1.6.24}/sdk/config.py

@@ -151,6 +151,17 @@ def save(base_url: str, token: str) -> None:
 
 
 def get_base_url() -> str:
+    """The AI backend this machine talks to.
+
+    ``AGENTOS_AI_URL`` overrides the stored value, so a local backend can be
+    pointed at for a test run without rewriting config.toml — which is the state
+    you do not want to leave a real box in. Same precedence as the other
+    overrides here: env, then ``~/.agentos/.env``, then stored, then the default.
+    """
+    override = (os.environ.get("AGENTOS_AI_URL", "")
+                or _dotenv_value("AGENTOS_AI_URL")).strip()
+    if override:
+        return override.rstrip("/")
     return load().get("base_url", AI_DEFAULT_URL)