devops-bot-sdk 1.6.26__tar.gz → 1.6.28__tar.gz

{devops_bot_sdk-1.6.26 → devops_bot_sdk-1.6.28}/PKG-INFO

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

{devops_bot_sdk-1.6.26 → devops_bot_sdk-1.6.28}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.6.26 → devops_bot_sdk-1.6.28}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -24,10 +24,12 @@ sdk/local_exec.py
 sdk/phase_timer.py
 sdk/plan_run.py
 sdk/platform_compat.py
+sdk/proof_readers.py
 sdk/py.typed
 sdk/run_auto.py
 sdk/scheduler.py
 sdk/self_report.py
+sdk/self_report_local.py
 sdk/sse.py
 sdk/task_file.py
 sdk/test.py
@@ -137,6 +139,7 @@ tests/test_otp_login.py
 tests/test_phase_timer.py
 tests/test_plan_new_command.py
 tests/test_plan_run_activity.py
+tests/test_proof_readers.py
 tests/test_recon_session_isolation.py
 tests/test_run_auto_agent_only.py
 tests/test_run_outputs.py

{devops_bot_sdk-1.6.26 → devops_bot_sdk-1.6.28}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.6.26
+Version: 1.6.28
 
 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.26"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
+__version__ = "1.6.28"   # 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.26 → devops_bot_sdk-1.6.28}/sdk/cli.py

@@ -67,6 +67,9 @@ Command surface:
         sdk/self_report.py.
     agentos report list [--limit N]
         Recent submissions, newest first: date, score, verdict, id.
+    agentos report formats
+        Every proof format the SDK can read on this machine, and what happens
+        to the ones it cannot.
     agentos report show <ID>
         One submission in full — its text, its proofs and the evaluator's
         per-criterion reasoning.
@@ -728,6 +731,7 @@ def _report_usage() -> None:
     print("                            [--project NAME] [--proof PATH|URL]… [--no-wait]")
     print("       agentos report list [--limit N]")
     print("       agentos report show <ID>")
+    print("       agentos report formats                              # what a proof can be")
     print()
     print("  Report work that never reached Jira or GitHub, attach proofs, and have the")
     print("  submission scored against them. It then appears in your daily and overall")
@@ -762,7 +766,7 @@ def _report_command(args: list[str]) -> None:
     ``agentos configure`` prints, and exit 1 — never a traceback.
     """
     from sdk.exceptions import TokenNotConfigured
-    from sdk.self_report import SelfReportError
+    from sdk.self_report import _SUBMIT_ERRORS, SelfReportError
 
     verb = args[0] if args else None
     rest = args[1:]
@@ -778,6 +782,9 @@ def _report_command(args: list[str]) -> None:
         if verb == "show" and rest and not rest[0].startswith("-"):
             _report_show(rest[0])
             return
+        if verb == "formats":
+            _report_formats()
+            return
     except TokenNotConfigured as exc:
         # The same failure every other verb gives on an unconfigured machine —
         # `sdk.config` composes a cause-specific message; we only add the prefix.
@@ -786,6 +793,12 @@ def _report_command(args: list[str]) -> None:
     except SelfReportError as exc:
         print(f"error: {exc}")
         sys.exit(1)
+    except _SUBMIT_ERRORS as exc:
+        # The backend answered and the answer was no. Its own words — a 404 says
+        # the deployment has no self-report routes, which is not a token problem
+        # and must not be printed as one.
+        print(f"error: {exc}")
+        sys.exit(1)
 
     _report_usage()
     sys.exit(1)
@@ -842,6 +855,13 @@ def _report_submit(args: list[str]) -> None:
           + (f"   project: {result['project']}" if result.get("project") else ""))
     print(f"proofs     : {len(result.get('proofs') or [])} accepted"
           + (f", {len(result.get('rejected') or [])} skipped" if result.get("rejected") else ""))
+    if result.get("stored") == "gateway":
+        # Say which half holds it. "Recorded" and "recorded in the durable store"
+        # are different promises, and only the person filing it can decide whether
+        # the difference matters to them.
+        print("stored     : locally + the activity feed the daily/overall reports read")
+        print("             (the platform's self-report store is not deployed on this "
+              "backend; scored on this machine)")
     if status == "evaluated":
         print(f"score      : {result.get('score', 0)}/100")
         print(f"verdict    : {result.get('verdict') or 'unknown'}")
@@ -856,6 +876,33 @@ def _report_submit(args: list[str]) -> None:
     # backend-side outcome the person cannot act on, and it is recorded, not lost.
 
 
+def _report_formats() -> None:
+    """What the SDK can read from a proof without the backend.
+
+    Worth its own verb: a person choosing what to attach needs to know that a
+    screen recording is usable and a .7z is not BEFORE they file, not after the
+    score comes back lower than the work deserved.
+    """
+    from sdk import proof_readers
+
+    print("Proof files the SDK reads on this machine:\n")
+    for group, exts in proof_readers.supported().items():
+        joined = " ".join(exts)
+        print(f"  {group}")
+        for i in range(0, len(joined), 68):
+            print(f"      {joined[i:i + 68]}")
+    print()
+    if proof_readers.have_ffmpeg():
+        print("  ffmpeg is installed — video proofs are sampled into still frames the")
+        print("  scorer can look at.")
+    else:
+        print("  ffmpeg is NOT installed — a video proof is recorded and described, but")
+        print("  its content cannot be inspected. Install ffmpeg to change that.")
+    print("  Audio cannot be transcribed locally; it is recorded and described.")
+    print("  URL proofs are fetched here. A GitHub PR or issue is read through the API")
+    print("  with your linked token, so proofs in private repos are readable.")
+
+
 def _report_list(limit: int) -> None:
     """Recent submissions, newest first — date, score, verdict, id."""
     from sdk import self_report
@@ -870,8 +917,11 @@ def _report_list(limit: int) -> None:
         score = f"{ev.get('score')}/100" if r.get("status") == "evaluated" else "—"
         verdict = (ev.get("verdict") or r.get("status") or "")[:25]
         what = " ".join(str(r.get("text") or "").split())[:46]
-        print(f"{str(r.get('date', '')):<12}{score:<8}{verdict:<26}"
-              f"{str(r.get('id', '')):<26}{what}")
+        rid = str(r.get("id", "")) + (" *" if r.get("stored") == "gateway" else "")
+        print(f"{str(r.get('date', '')):<12}{score:<8}{verdict:<26}{rid:<26}{what}")
+    if any(r.get("stored") == "gateway" for r in rows):
+        print("\n* recorded on this machine and in the activity feed — the platform's "
+              "self-report store was not deployed when it was filed.")
 
 
 def _report_show(report_id: str) -> None:

{devops_bot_sdk-1.6.26 → devops_bot_sdk-1.6.28}/sdk/client.py

@@ -23,7 +23,7 @@ from typing import Any, AsyncGenerator
 import httpx
 
 from sdk.exceptions import (
-    BackendAuthFailed, BackendFeatureMissing, BackendPermissionDenied, BackendUnreachable,
+    BackendAuthFailed, BackendFeatureMissing, BackendPermissionDenied, BackendRejected, BackendUnreachable,
     BackendVersionTooOld, TokenNotConfigured,
 )
 from sdk.models.envelope import Envelope
@@ -1551,9 +1551,57 @@ class BackendClient:
     # `self_report`), the blob upload and the evaluator; the SDK only speaks
     # HTTP to it with the co_ token, exactly like every other method here.
     #
-    # Best-effort return shapes (dict / None) rather than raised errors, so the
-    # panel and the CLI can present a partial result instead of a traceback —
-    # the same posture `create_task_ml` and `list_jira_projects` take.
+    # A FAILURE is typed, an EMPTY is empty. Every call in this family routes its
+    # response through `_check_report_status`, so the ways it can go wrong stay
+    # different answers: 401 = the token needs reconfiguring, 403 = not this
+    # caller's to write, 400/422 = the backend read the submission and refused it,
+    # with its own reason. Collapsing them into `None` is what once made a backend
+    # missing `routes/reports.py` read as "check `agentos configure`" — a config
+    # that was fine, and an operator sent to fix it.
+    #
+    # 404 depends on the PATH, which is why `_check_report_status` takes a flag.
+    # On the collection (`/reports/self`) there is no id to be wrong about, so it
+    # means the routes are not deployed. On an item (`/reports/self/{id}`) it is a
+    # documented answer — unknown id, or not this caller's — and comes back as
+    # None. Reading the second as the first would send someone to chase a
+    # deployment over a typo.
+    #
+    # `get_self_report` stays best-effort (None) beyond that, because it is the
+    # poll loop's read: a blip mid-evaluation must not turn a STORED submission
+    # into a reported failure.
+
+    @staticmethod
+    def _backend_detail(resp: httpx.Response) -> str:
+        """The backend's own words for a failure, trimmed to a banner line."""
+        try:
+            body = resp.json()
+        except ValueError:
+            return (resp.text or "").strip()[:300]
+        if isinstance(body, dict):
+            for key in ("detail", "message", "error"):
+                val = body.get(key)
+                if val:
+                    return str(val)[:300]
+        return (resp.text or "").strip()[:300]
+
+    def _check_report_status(self, resp: httpx.Response, url: str, *,
+                             missing_is_absent_feature: bool = True) -> None:
+        """Raise the error the status code actually means. No-op under 400.
+
+        ``missing_is_absent_feature`` is what makes 404 readable. On the COLLECTION
+        paths (``/reports/self``) there is no id to be wrong about, so a 404 can
+        only mean the route is not deployed. On an ITEM path (``/reports/self/{id}``)
+        404 is a documented answer — that submission does not exist, or is not this
+        caller's — and reporting it as a missing feature would send someone to chase
+        a deployment over a typo'd id.
+        """
+        if resp.status_code == 404 and missing_is_absent_feature:
+            raise BackendFeatureMissing("Self-reporting", url)
+        if resp.status_code == 403:
+            raise BackendPermissionDenied(self._backend_detail(resp), url)
+        _check_status(resp.status_code, url)          # 401 / 426 / 5xx
+        if resp.status_code >= 400:                   # 400, 422, everything else
+            raise BackendRejected(self._backend_detail(resp), resp.status_code, url)
 
     async def submit_self_report(
         self,
@@ -1579,8 +1627,9 @@ class BackendClient:
         purpose: an ``UploadFile``'s spooled temp file dies with the request,
         while the evaluation job deliberately outlives it.
 
-        Returns the parsed 202 body (``{id, job_id, status, status_url, …}``)
-        or None on any failure.
+        Returns the parsed 202 body (``{id, job_id, status, status_url, …}``).
+        Raises rather than returning None when the backend answers: a submission
+        that was NOT stored must say why — see `_check_report_status`.
         """
         url = self._url("/api/v1/reports/self")
         headers = {k: v for k, v in self._headers.items() if k.lower() != "content-type"}
@@ -1607,22 +1656,34 @@ class BackendClient:
             # Generous: the request itself uploads every proof's bytes.
             async with httpx.AsyncClient(timeout=180.0) as client:
                 resp = await client.post(url, files=parts, headers=headers)
-            if resp.status_code >= 400:
-                logger.warning("client.submit_self_report failed status=%s body=%s",
-                               resp.status_code, resp.text[:300])
-                return None
+        except httpx.RequestError as exc:
+            logger.warning("client.submit_self_report unreachable err=%s", exc)
+            raise BackendUnreachable(url, str(exc)) from exc
+        if resp.status_code >= 400:
+            logger.warning("client.submit_self_report failed status=%s body=%s",
+                           resp.status_code, resp.text[:300])
+        self._check_report_status(resp, url)
+        try:
             body = resp.json() or {}
-            return body if isinstance(body, dict) else None
-        except Exception as exc:  # noqa: BLE001
-            logger.warning("client.submit_self_report error err=%s", exc)
-            return None
+        except ValueError as exc:
+            raise BackendRejected("the backend returned non-JSON to a submission.",
+                                  resp.status_code, url) from exc
+        return body if isinstance(body, dict) else None
 
     async def get_self_report(self, report_id: str) -> dict | None:
         """GET /api/v1/reports/self/{id} — one submission and its current verdict.
 
         This is what the poll loop reads while evaluation runs server-side;
         `status` moves through `accepted` → `evaluating` → `evaluated` |
-        `evaluation_failed`. None on any failure.
+        `evaluation_failed`.
+
+        None on a TRANSIENT failure (a blip, a 5xx, a dropped connection) — the
+        submission is already stored by the time anyone calls this, and one bad
+        read must not be reported as a lost report. Also None on 404, which on
+        this path is a real answer: no such submission, or not this caller's (the
+        backend scopes the lookup, so the two are deliberately indistinguishable).
+        A backend that refuses the caller (403) or rejects the token (401) raises
+        — those do not come back on the next poll.
         """
         rid = str(report_id or "").strip()
         if not rid:
@@ -1631,21 +1692,31 @@ class BackendClient:
         try:
             async with httpx.AsyncClient(timeout=30.0) as client:
                 resp = await client.get(url, headers=self._headers)
-            if resp.status_code >= 400:
-                logger.warning("client.get_self_report failed id=%s status=%s body=%s",
-                               rid, resp.status_code, resp.text[:200])
-                return None
+        except httpx.RequestError as exc:
+            logger.warning("client.get_self_report unreachable id=%s err=%s", rid, exc)
+            return None
+        if resp.status_code >= 400:
+            logger.warning("client.get_self_report failed id=%s status=%s body=%s",
+                           rid, resp.status_code, resp.text[:200])
+        if resp.status_code in (401, 403, 426):
+            self._check_report_status(resp, url, missing_is_absent_feature=False)
+        if resp.status_code >= 400:
+            # 404 = no such submission; 5xx = a blip the next poll retries.
+            return None
+        try:
             body = resp.json() or {}
-            return body if isinstance(body, dict) else None
-        except Exception as exc:  # noqa: BLE001
-            logger.warning("client.get_self_report error id=%s err=%s", rid, exc)
+        except ValueError:
+            logger.warning("client.get_self_report non-JSON id=%s", rid)
             return None
+        return body if isinstance(body, dict) else None
 
     async def list_self_reports(self, limit: int = 25, user_id: str = "") -> list[dict]:
         """GET /api/v1/reports/self — this caller's submissions, newest first.
 
-        Returns [] on any failure — the panel renders an empty list rather than
-        an error banner, and the CLI says "no submissions yet".
+        An empty list means "this caller has submitted nothing" and nothing
+        else. A backend that cannot answer raises (`_check_report_status`), so
+        "no submissions yet" is never a 404 wearing a friendly face — the state
+        this list is FOR is exactly the state a masked failure imitates.
         """
         url = self._url("/api/v1/reports/self")
         params: dict[str, Any] = {"limit": max(1, min(int(limit or 25), 200))}
@@ -1655,23 +1726,30 @@ class BackendClient:
         try:
             async with httpx.AsyncClient(timeout=30.0) as client:
                 resp = await client.get(url, params=params, headers=self._headers)
-            if resp.status_code >= 400:
-                logger.warning("client.list_self_reports failed status=%s body=%s",
-                               resp.status_code, resp.text[:200])
-                return []
+        except httpx.RequestError as exc:
+            logger.warning("client.list_self_reports unreachable err=%s", exc)
+            raise BackendUnreachable(url, str(exc)) from exc
+        if resp.status_code >= 400:
+            logger.warning("client.list_self_reports failed status=%s body=%s",
+                           resp.status_code, resp.text[:200])
+        self._check_report_status(resp, url)
+        try:
             body = resp.json() or {}
-            rows = body.get("reports") if isinstance(body, dict) else body
-            return [r for r in (rows or []) if isinstance(r, dict)]
-        except Exception as exc:  # noqa: BLE001
-            logger.warning("client.list_self_reports error err=%s", exc)
+        except ValueError:
+            logger.warning("client.list_self_reports non-JSON body")
             return []
+        rows = body.get("reports") if isinstance(body, dict) else body
+        return [r for r in (rows or []) if isinstance(r, dict)]
 
     async def reevaluate_self_report(self, report_id: str) -> dict | None:
         """POST /api/v1/reports/self/{id}/evaluate — score an existing submission again.
 
         The backend REPLACES the stored verdict rather than appending a second
         one (the previous verdict moves into the submission's audit trail), so
-        this is safe to call repeatedly. None on any failure.
+        this is safe to call repeatedly. Raises on a backend answer it cannot use
+        — a re-evaluation that did not happen must say why, same as a submission —
+        except 404, which on this item path means the submission is not there,
+        and comes back as None.
         """
         rid = str(report_id or "").strip()
         if not rid:
@@ -1680,15 +1758,20 @@ class BackendClient:
         try:
             async with httpx.AsyncClient(timeout=60.0) as client:
                 resp = await client.post(url, json={}, headers=self._headers)
-            if resp.status_code >= 400:
-                logger.warning("client.reevaluate_self_report failed id=%s status=%s body=%s",
-                               rid, resp.status_code, resp.text[:300])
-                return None
+        except httpx.RequestError as exc:
+            logger.warning("client.reevaluate_self_report unreachable id=%s err=%s", rid, exc)
+            raise BackendUnreachable(url, str(exc)) from exc
+        if resp.status_code >= 400:
+            logger.warning("client.reevaluate_self_report failed id=%s status=%s body=%s",
+                           rid, resp.status_code, resp.text[:300])
+        if resp.status_code == 404:
+            return None                            # no such submission
+        self._check_report_status(resp, url)
+        try:
             body = resp.json() or {}
-            return body if isinstance(body, dict) else None
-        except Exception as exc:  # noqa: BLE001
-            logger.warning("client.reevaluate_self_report error id=%s err=%s", rid, exc)
+        except ValueError:
             return None
+        return body if isinstance(body, dict) else None
 
     # ── OAuth ─────────────────────────────────────────────────────────
 

{devops_bot_sdk-1.6.26 → devops_bot_sdk-1.6.28}/sdk/exceptions.py

@@ -84,6 +84,23 @@ class BackendPermissionDenied(Exception):
         self.url = url
 
 
+class BackendRejected(Exception):
+    """Raised when the backend answers 4xx with its own reason (400, 422, …).
+
+    Not 401 (bad token), not 403 (not permitted), not 404 (feature absent): the
+    call reached a route that understood it and refused the CONTENT — a future
+    date, an empty body, a proof the content filter blocked. ``detail`` is the
+    backend's own words, so the surface can say WHY rather than guess.
+    """
+    def __init__(self, detail: str = "", status: int = 0, url: str = "") -> None:
+        super().__init__(
+            detail or f"The backend refused the request (HTTP {status} at {url})."
+        )
+        self.detail = detail
+        self.status = status
+        self.url = url
+
+
 class CollectorError(Exception):
     """Raised by collectors when a payload fails size or type validation."""
     def __init__(self, message: str, path: str = "") -> None: