devops-bot-sdk 1.6.32__tar.gz → 1.6.33__tar.gz

{devops_bot_sdk-1.6.32 → devops_bot_sdk-1.6.33}/PKG-INFO

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

{devops_bot_sdk-1.6.32 → devops_bot_sdk-1.6.33}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.6.32 → devops_bot_sdk-1.6.33}/sdk/__init__.py

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

@@ -467,9 +467,17 @@ async def submit_and_evaluate(
         # PR, an Outlook thread or an internal dashboard comes back 404 and is
         # scored `unverifiable` — the work punished for where its evidence lives.
         # This machine is the one with the credentials, so it reads the page and
-        # attaches what it read; the URL still travels too, so the record keeps
-        # the link a human would click.
-        extra, notes = await _resolve_link_proofs(client, urls)
+        # sends what it read INSTEAD of the link.
+        #
+        # Instead, not as well as. Sending both means the backend still fetches
+        # the URL, still 404s on it, and the submission carries two contradictory
+        # judgements of one piece of evidence: the link "unverifiable" beside the
+        # text of that same link "supports". That is not merely noisy — the
+        # evaluator reads the phantom failure as missing evidence and marks the
+        # criterion PARTIAL for it, so a link that WAS read costs score for not
+        # having been read. A URL that could not be resolved here still travels,
+        # because the backend may reach something this machine cannot.
+        extra, notes, urls = await _resolve_link_proofs(client, urls)
         files.extend(extra)
         for note in notes:
             mirror(note)
@@ -671,15 +679,21 @@ def _link_slug(url: str) -> str:
 
 async def _resolve_link_proofs(
     client: Any, urls: list[str],
-) -> tuple[list[tuple[str, bytes, str]], list[str]]:
-    """Read each URL proof with this machine's credentials. ``(files, notes)``.
-
-    Each link that opens becomes an extra ``text/plain`` file proof carrying the
-    page and a header naming the source and the route that read it. That shape is
-    deliberate: the backend already stores file proofs and already extracts them,
-    so evidence the SDK gathered flows through exactly the pipeline evidence the
-    person uploaded does — no new route, no new contract, and it keeps working
-    against a backend that has never heard of this module.
+) -> tuple[list[tuple[str, bytes, str]], list[str], list[str]]:
+    """Read each URL proof with this machine's credentials.
+
+    Returns ``(files, notes, unresolved)`` — the pages that were read, anything
+    worth telling the operator, and the URLs to still send AS urls because
+    nothing here could open them.
+
+    Each link that opens becomes a ``text/plain`` file proof carrying the page and
+    a header naming the source and the route that read it, and is then dropped
+    from the URL list. That shape is deliberate: the backend already stores file
+    proofs and already extracts them, so evidence the SDK gathered flows through
+    exactly the pipeline evidence the person uploaded does — no new route, no new
+    contract, and it keeps working against a backend that has never heard of this
+    module. The link itself is not lost: it is the ``Source:`` line of the file
+    and the file's own name.
 
     Sequential, not gathered. The browser route drives ONE ``agent-browser``
     daemon through a stateful open-then-snapshot pair; two concurrent resolutions
@@ -690,7 +704,7 @@ async def _resolve_link_proofs(
     the behaviour that existed before this, so the worst case is the old one.
     """
     if not urls or not resolve_links_enabled():
-        return [], []
+        return [], [], list(urls)
 
     from sdk import url_access
 
@@ -707,6 +721,7 @@ async def _resolve_link_proofs(
 
     files: list[tuple[str, bytes, str]] = []
     notes: list[str] = []
+    unresolved: list[str] = []
     loop = asyncio.get_running_loop()
     deadline = loop.time() + _RESOLVE_BUDGET_S
     for index, url in enumerate(urls, start=1):
@@ -715,6 +730,7 @@ async def _resolve_link_proofs(
             notes.append(f"Proof link {url} was left for the backend to fetch — the "
                          f"{int(_RESOLVE_BUDGET_S)}s budget for reading links locally "
                          f"was already spent.")
+            unresolved.append(url)
             continue
         try:
             res = await asyncio.wait_for(
@@ -723,15 +739,18 @@ async def _resolve_link_proofs(
         except asyncio.TimeoutError:
             logger.info("self_report.resolve_timeout url=%s", url)
             notes.append(f"Proof link {url} timed out being read locally.")
+            unresolved.append(url)
             continue
         except Exception as exc:  # noqa: BLE001 — resolve_url is not supposed to
             logger.warning("self_report.resolve_failed url=%s err=%s", url, exc)
             notes.append(f"Proof link could not be read locally ({url}) — {exc}")
+            unresolved.append(url)
             continue
         if not res.ok:
             logger.info("self_report.link_unresolved url=%s tried=%s reason=%s",
                         url, ",".join(res.attempts), res.reason)
             notes.append(f"Proof link {url} {res.reason}")
+            unresolved.append(url)
             continue
         body = res.text[:_RESOLVED_MAX_CHARS]
         truncated = "\n\n[truncated — the page was longer than this excerpt]" \
@@ -746,7 +765,7 @@ async def _resolve_link_proofs(
         files.append((f"link-{index}-{_link_slug(url)}.txt", content, "text/plain"))
         logger.info("self_report.link_resolved url=%s via=%s chars=%d",
                     url, res.via, len(body))
-    return files, notes
+    return files, notes, unresolved
 
 
 def _proof_record(p: Proof) -> dict[str, Any]:

{devops_bot_sdk-1.6.32 → devops_bot_sdk-1.6.33}/tests/test_self_report.py

@@ -1109,7 +1109,6 @@ class TestLinkProofsAreResolvedLocally:
         backend, _ = self._submit()
 
         sent = backend.submits[0]
-        assert sent["proof_urls"] == [self.URL], "the link a human would click was dropped"
         assert len(sent["files"]) == 1, "the page the SDK read was not attached"
         name, body, ctype = sent["files"][0]
         text = body.decode()
@@ -1120,6 +1119,29 @@ class TestLinkProofsAreResolvedLocally:
         assert f"Source: {self.URL}" in text
         assert "via: github-api" in text
 
+    def test_a_resolved_link_is_NOT_also_sent_as_a_url(self, monkeypatch):
+        """The regression: sending both made one link two contradictory proofs.
+
+        The backend fetches proof URLs server-side and anonymously. Left in the
+        list, a link that WAS read here is fetched there, 404s, and lands beside
+        its own successfully-read text as `unverifiable` — and the evaluator
+        marks the criterion PARTIAL for the missing evidence, so a link that was
+        read costs score for not having been read.
+        """
+        from sdk.url_access import Resolved
+
+        self._resolver(monkeypatch, Resolved(text="pull #118 … merged", via="github-api"))
+        backend, _ = self._submit()
+
+        sent = backend.submits[0]
+        assert sent["proof_urls"] == [], (
+            "the resolved link was also sent as a URL — the backend will 404 on it "
+            "and contradict the evidence the SDK just read")
+        # …and the link is still recoverable, from the name and from the file.
+        name, body, _ = sent["files"][0]
+        assert self.URL.rsplit("/", 1)[-1] in name      # …/pull/115 -> "…-115.txt"
+        assert self.URL in body.decode()
+
     def test_a_link_that_stays_shut_changes_nothing(self, monkeypatch):
         """The old behaviour is the floor: the backend still gets the URL."""
         from sdk.url_access import Resolved