fix: Agent retries transient transport errors/proxy 5xx with backoff (classify, complete, fail); hide console behind the GUI wizard; 1.2.2

Found in the clean-Windows recovery test: a single TLS handshake failure mid-job failed a whole sync.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

agent/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gti-fiscal-agent"
-version = "1.2.1"
+version = "1.2.2"
 requires-python = ">=3.10"
 dependencies = ["httpx>=0.27,<1"]
 

agent/scripts/run_agent_service.py

@@ -106,7 +106,7 @@ class Config:
         self.poll_interval_seconds = float(env.get("POLL_INTERVAL_SECONDS", "5"))
         # RTC auto-apply is a SEPARATE switch (default OFF): FIREBIRD_WRITES alone never lets the Agent fill cClassTrib.
         self.rtc_auto_apply_max_per_job = int(env.get("RTC_AUTO_APPLY_MAX_PER_JOB", str(_rtc_apply.DEFAULT_MAX_PER_JOB)))
-        self.agent_version = env.get("AGENT_VERSION", "1.2.1")
+        self.agent_version = env.get("AGENT_VERSION", "1.2.2")
         self.schema_fingerprint = env.get("SCHEMA_FINGERPRINT", REFERENCE_SCHEMA_V1)
         self.state_db = env.get("AGENT_STATE_DB", str(AGENT_ROOT / "agent_state.sqlite"))
         # Pilot write authorization: both must be explicitly set by the installer for
@@ -348,7 +348,7 @@ def execute_job(job, config, executor, state, env):
             "fiscal_context": fiscal_context,
             "rtc_auto_apply": rtc_apply,
             "fiscal_mode": getattr(config, "fiscal_mode", None),
-            "release_version": env.get("AGENT_VERSION") or "1.2.1",
+            "release_version": env.get("AGENT_VERSION") or "1.2.2",
             "products_total": len(products),
             "products_changed": len(to_process),
             "products_processed": summary["processed"],
@@ -506,7 +506,7 @@ def run(config, env, *, max_iterations=None, stopper=None):
 def enforce_startup_preflight(env):
     """Full read-only preflight at startup (Hub, auth, Firebird, capabilities, company context, guards). Fail closed."""
     from gti_fiscal_agent.preflight import run_preflight
-    report = run_preflight(env, agent_version=env.get("AGENT_VERSION") or "1.2.1")
+    report = run_preflight(env, agent_version=env.get("AGENT_VERSION") or "1.2.2")
     logger.info("startup preflight: %s", json.dumps({k: report[k] for k in ("PREFLIGHT", "blockers", "fiscal_mode", "effective_firebird_writes")}, ensure_ascii=False))
     print(json.dumps({"PREFLIGHT": report["PREFLIGHT"], "blockers": report["blockers"]}, ensure_ascii=False))
     if report["PREFLIGHT"] != "PASS":

agent/src/gti_fiscal_agent/client.py

@@ -1,5 +1,29 @@
+import time
+
 import httpx
 
+TRANSIENT_STATUS = (502, 503, 504)   # reverse proxy / Hub restarting
+BACKOFF_SECONDS = (1, 2, 4, 8)       # 5 attempts in total
+
+
+def _resilient(send):
+    """Runs one idempotent HTTP call, retrying transport failures (connect/TLS/read/protocol errors) and proxy 502/503/504 with backoff, so a network blip in
+    the middle of a long job does not throw the whole job (and minutes of classification) away. Non-transient errors (4xx) are returned untouched."""
+    last = None
+    for attempt in range(len(BACKOFF_SECONDS) + 1):
+        try:
+            response = send()
+            if response.status_code not in TRANSIENT_STATUS or attempt == len(BACKOFF_SECONDS):
+                return response
+            last = None
+        except httpx.TransportError as error:
+            last = error
+            if attempt == len(BACKOFF_SECONDS):
+                raise
+        time.sleep(BACKOFF_SECONDS[attempt])
+    raise last  # pragma: no cover
+
+
 class HubClient:
     def __init__(self, url, token, chunk_size=25): self.url, self.token, self.chunk_size = url.rstrip("/"), token, chunk_size
     def _headers(self): return {"Authorization": f"Bearer {self.token}"}
@@ -7,14 +31,9 @@ class HubClient:
         results = []
         for start in range(0, len(products), self.chunk_size):
             chunk = products[start:start + self.chunk_size]
-            # Small chunks + generous timeout + one retry: a large first sync must survive a
-            # slow Hub / reverse-proxy read timeout instead of failing the whole job.
-            for attempt in (1, 2):
-                try:
-                    response = httpx.post(f"{self.url}/v1/classify/batch", json={"products": chunk}, headers=self._headers(), timeout=120)
-                    break
-                except httpx.ReadTimeout:
-                    if attempt == 2: raise
+            # Small chunks + generous timeout + retry with backoff on any transport error or proxy 5xx: a large first sync must survive
+            # a slow Hub, a reverse-proxy read timeout or a TLS/network blip instead of failing the whole job.
+            response = _resilient(lambda: httpx.post(f"{self.url}/v1/classify/batch", json={"products": chunk}, headers=self._headers(), timeout=120))
             response.raise_for_status(); results.extend(response.json()["results"])
         return results
     def get_json(self, path):
@@ -48,8 +67,8 @@ class HubClient:
         response = httpx.get(f"{self.url}/v1/jobs/{job_id}", headers=self._headers(), timeout=15)
         response.raise_for_status(); return response.json()
     def complete_job(self, job_id, result_summary):
-        response = httpx.post(f"{self.url}/v1/jobs/{job_id}/complete", json={"result_summary": result_summary}, headers=self._headers(), timeout=15)
+        response = _resilient(lambda: httpx.post(f"{self.url}/v1/jobs/{job_id}/complete", json={"result_summary": result_summary}, headers=self._headers(), timeout=30))
         response.raise_for_status(); return response.json()
     def fail_job(self, job_id, error):
-        response = httpx.post(f"{self.url}/v1/jobs/{job_id}/fail", json={"error": str(error)}, headers=self._headers(), timeout=15)
+        response = _resilient(lambda: httpx.post(f"{self.url}/v1/jobs/{job_id}/fail", json={"error": str(error)}, headers=self._headers(), timeout=30))
         response.raise_for_status(); return response.json()

agent/src/gti_fiscal_agent/preflight.py

@@ -9,7 +9,7 @@ import os
 import sqlite3
 from pathlib import Path
 
-AGENT_VERSION_DEFAULT = "1.2.1"
+AGENT_VERSION_DEFAULT = "1.2.2"
 REQUIRED_ENV = ("GTI_HUB_URL", "AGENT_TOKEN", "FIREBIRD_DATABASE_PATH", "FB_USER", "FB_PASSWORD")
 REQUIRED_CAPABILITIES = ("supports_ncm", "supports_ipi", "supports_cest")
 FISCAL_MODES = ("DRY_RUN", "AUTO_APPLY")

agent/tests/test_client.py

@@ -32,3 +32,32 @@ def test_identity_requests_authenticated_identity_only(monkeypatch):
 
     assert calls["url"] == "https://hub.example/v1/agents/me/identity"
     assert calls["headers"] == {"Authorization": "Bearer test-agent-token"}
+
+
+def test_transport_errors_and_proxy_5xx_are_retried_but_client_errors_are_not(monkeypatch):
+    import httpx
+    from gti_fiscal_agent import client as c
+    monkeypatch.setattr(c.time, "sleep", lambda s: None)
+    calls = {"n": 0}
+
+    def flaky():
+        calls["n"] += 1
+        if calls["n"] == 1:
+            raise httpx.ConnectError("ssl handshake failure")
+        if calls["n"] == 2:
+            return httpx.Response(502)
+        return httpx.Response(200, json={"ok": True})
+
+    assert c._resilient(flaky).status_code == 200 and calls["n"] == 3
+    calls["n"] = 0
+    assert c._resilient(lambda: (calls.__setitem__("n", calls["n"] + 1), httpx.Response(401))[1]).status_code == 401 and calls["n"] == 1     # 4xx: no retry
+    calls["n"] = 0
+
+    def always_down():
+        calls["n"] += 1
+        raise httpx.ConnectError("down")
+
+    import pytest
+    with pytest.raises(httpx.ConnectError):
+        c._resilient(always_down)
+    assert calls["n"] == 5                                                                                                                    # bounded: 5 attempts, then the job fails cleanly