devops-bot-sdk 1.4.20__tar.gz → 1.4.23__tar.gz

{devops_bot_sdk-1.4.20 → devops_bot_sdk-1.4.23}/PKG-INFO

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

{devops_bot_sdk-1.4.20 → devops_bot_sdk-1.4.23}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.20 → devops_bot_sdk-1.4.23}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devops-bot-sdk"
-version = "1.4.20"
+version = "1.4.23"
 description = "DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app"
 readme = "README.md"
 license = "LicenseRef-Proprietary"

{devops_bot_sdk-1.4.20 → devops_bot_sdk-1.4.23}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.4.20
+Version: 1.4.23
 
 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.4.20"
+__version__ = "1.4.23"
 __author__  = "AgentOS"
 
 from sdk.client import BackendClient

{devops_bot_sdk-1.4.20 → devops_bot_sdk-1.4.23}/sdk/client.py

@@ -36,7 +36,7 @@ from sdk.sse import _check_status, stream_with_reconnect
 
 logger = logging.getLogger(__name__)
 
-SDK_VERSION    = "1.4.20"
+SDK_VERSION    = "1.4.23"
 _POLL_INTERVAL = 3.0
 _POLL_TIMEOUT  = 600.0
 _ORCHESTRATE_TIMEOUT      = 2700.0  # 45 min — covers approval wait + VPS execution time

{devops_bot_sdk-1.4.20 → devops_bot_sdk-1.4.23}/sdk/ipc/handlers.py

@@ -296,8 +296,14 @@ async def _run_local_pipeline(
             body["user_id"] = derived
 
     # 1. Kick off the background run (server plans, gates — does NOT execute).
+    # The kickoff sends background=True and should return a session_id quickly, but
+    # under load the backend can take well over 30s to ack — which previously raised
+    # a (blank-message) ReadTimeout that sent the whole ticket to Backlog. Connect
+    # fast, but allow a generous read window so a slow-but-working ack isn't killed.
     import httpx
-    async with httpx.AsyncClient(timeout=30.0) as http:
+    _kick_read_s = float(os.getenv("AGENTOS_ORCHESTRATE_KICKOFF_TIMEOUT_S", "") or 120.0)
+    _kick_timeout = httpx.Timeout(_kick_read_s, connect=15.0)
+    async with httpx.AsyncClient(timeout=_kick_timeout) as http:
         resp = await http.post(client._url("/api/v1/orchestrate"), json=body, headers=client._headers)
     if resp.status_code >= 400:
         await send(_error_envelope(thread_id, RuntimeError(f"orchestrate failed: {resp.status_code} {resp.text[:200]}")).model_dump())
@@ -560,6 +566,36 @@ async def _code_one_repo(
         )
         session_id = result.get("session_id") or session_id
 
+    # 4b. output-token-cap recovery. A single assistant turn that would exceed the
+    # CLI's per-response output cap aborts the run ("response exceeded the N output
+    # token maximum"). Resume the session with a doubled cap and an instruction to
+    # emit the work in smaller chunks, so a large dump finishes across turns instead
+    # of failing the ticket.
+    cap_resumes = 0
+    next_cap = local_exec._MAX_OUTPUT_TOKENS
+    while (not result.get("ok")) and result.get("output_cap_exceeded") \
+            and session_id and cap_resumes < _MAX_OUTPUT_CAP_RESUMES:
+        cap_resumes += 1
+        next_cap = min(next_cap * 2, 128000)  # CLI/model output ceiling
+        await send(Envelope(
+            type="step_update", thread_id=thread_id,
+            data={"status": "running",
+                  "current_step": f"[{name}] Response exceeded output-token cap — "
+                                  f"resuming with cap {next_cap} and chunked output "
+                                  f"(attempt {cap_resumes}/{_MAX_OUTPUT_CAP_RESUMES})"},
+        ).model_dump())
+        result = await local_exec.run_claude_local(
+            "Your previous response was cut off because it exceeded the output-token "
+            "limit for a single turn. Continue from where you left off and finish the "
+            "task. Keep each response within the limit: write results incrementally to "
+            "files in smaller steps rather than emitting one very large response, and "
+            "avoid dumping large content back as chat text.",
+            repo_path, on_event=_on_event,
+            github_token=gh_token, resume_session_id=session_id,
+            approval_dir=approval_dir, max_output_tokens=next_cap,
+        )
+        session_id = result.get("session_id") or session_id
+
     # 5. mid-run crucial-decision gate
     if agent_mode and session_id:
         from sdk import crucial
@@ -1529,6 +1565,9 @@ _FIRST_GATE_TIMEOUT_S = 900.0
 _APPROVAL_POLL_TIMEOUT_S = 1200.0
 # Max times a single ticket's session is resumed after a context overflow.
 _MAX_CONTEXT_RESUMES = 3
+# Max times a ticket's session is resumed after hitting the per-response output-token
+# cap, each time with a doubled cap, to let a large turn finish across chunks.
+_MAX_OUTPUT_CAP_RESUMES = 3
 # Max mid-run crucial-decision approval gates per ticket (safety bound).
 _MAX_CRUCIAL_GATES = 10
 # Max times a ticket is retried after hitting the Claude usage limit.
@@ -1843,12 +1882,19 @@ async def handle_orchestrate_auto_local_run(
                     processed += 1
                     break
             except Exception as exc:  # noqa: BLE001 — isolate per-ticket failures
-                logger.warning("orchestrate_auto.task_failed", extra={"task_id": tid, "error": str(exc)})
-                await client.log_activity(f"Task {tid}: unexpected error — {str(exc)[:200]}")
+                # str(exc) is EMPTY for some exceptions (notably TimeoutError /
+                # asyncio.TimeoutError / CancelledError), which used to render as a
+                # blank "failed —  (continuing)" with no clue to the cause. Always
+                # prefix the exception type so the real reason is visible; log the
+                # full repr for after-the-fact debugging.
+                detail = f"{type(exc).__name__}: {exc}".rstrip(": ")
+                logger.warning("orchestrate_auto.task_failed",
+                               extra={"task_id": tid, "error": repr(exc)})
+                await client.log_activity(f"Task {tid}: unexpected error — {detail[:200]}")
                 await client.move_to_backlog(tid)
                 await send(Envelope(
                     type="step_update", thread_id=thread_id,
-                    data={"current_step": f"{jira_key or tid}: failed — {str(exc)[:160]} (continuing)"},
+                    data={"current_step": f"{jira_key or tid}: failed — {detail[:160]} (continuing)"},
                 ).model_dump())
                 continue
 

{devops_bot_sdk-1.4.20 → devops_bot_sdk-1.4.23}/sdk/local_exec.py

@@ -62,6 +62,23 @@ _CONTEXT_MARKERS = (
     "token limit", "prompt is too long", "exceeds the maximum", "context_length_exceeded",
 )
 
+# Markers that indicate the CLI's per-response OUTPUT-token cap was hit — distinct
+# from a context overflow (input side) and a usage/rate limit (account side). The
+# CLI aborts a single assistant turn that would exceed CLAUDE_CODE_MAX_OUTPUT_TOKENS
+# (default 32000). We raise that cap below and, if it's still hit, resume the
+# session to finish the turn in smaller chunks.
+_OUTPUT_CAP_MARKERS = (
+    "output token maximum", "max_output_tokens", "claude_code_max_output_tokens",
+    "max output tokens", "output_tokens exceed",
+)
+
+# Per-response output-token cap handed to the CLI via CLAUDE_CODE_MAX_OUTPUT_TOKENS.
+# The CLI default is 32000, which a large single dump (e.g. extracting a whole
+# taxonomy from a spreadsheet) can blow past, failing the whole ticket. 64000 is a
+# safe headroom for the Opus/Sonnet families. Env-tunable; a value the user already
+# exported in the environment is respected and never overridden.
+_MAX_OUTPUT_TOKENS = int(_f("AGENTOS_MAX_OUTPUT_TOKENS", 64000.0))
+
 # Markers that indicate the Claude USAGE/RATE limit (the N-hour window) was hit —
 # distinct from a context overflow. The run didn't fail on the task; the account
 # is throttled until the window resets.
@@ -162,6 +179,12 @@ def _ctx_exceeded(text: str | None) -> bool:
     low = (text or "").lower()
     return any(m in low for m in _CONTEXT_MARKERS)
 
+
+def _output_cap_exceeded(text: str | None) -> bool:
+    """True when the CLI aborted because the response hit the per-turn output cap."""
+    low = (text or "").lower()
+    return any(m in low for m in _OUTPUT_CAP_MARKERS)
+
 EventHandler = Callable[[dict], Awaitable[None]]
 
 
@@ -186,6 +209,7 @@ async def run_claude_local(
     resume_session_id: str | None = None,
     approval_dir: str | None = None,
     idle_timeout: float = _IDLE_TIMEOUT_S,
+    max_output_tokens: int | None = None,
 ) -> dict[str, Any]:
     """Run the local `claude` CLI non-interactively against ``project_path``.
 
@@ -258,6 +282,16 @@ async def run_claude_local(
     # `git clone https://github.com/owner/repo` authenticates — without touching
     # the user's global git config. Tokens stay in the subprocess env only.
     env = dict(os.environ)
+
+    # Raise the CLI's per-response output-token cap. Without this the CLI errors
+    # out ("Claude's response exceeded the 32000 output token maximum") the moment
+    # a single assistant turn would exceed 32000 tokens — a large dump (extracting
+    # a whole taxonomy, generating many files at once) fails the entire ticket.
+    # A value the operator already exported wins; the `max_output_tokens` override
+    # lets a retry escalate the cap after a cap-exceeded run (see handlers.py).
+    if "CLAUDE_CODE_MAX_OUTPUT_TOKENS" not in env or max_output_tokens:
+        env["CLAUDE_CODE_MAX_OUTPUT_TOKENS"] = str(max_output_tokens or _MAX_OUTPUT_TOKENS)
+
     if github_token:
         env["GH_TOKEN"] = github_token
         env["GITHUB_TOKEN"] = github_token
@@ -419,6 +453,7 @@ async def run_claude_local(
             "cost_usd": 0.0, "files_changed": files_changed,
             "session_id": session_id, "context_exceeded": _ctx_exceeded(err),
             "limit_exceeded": _is_limit(err), "limit_reset_epoch": _parse_reset_epoch(err),
+            "output_cap_exceeded": _output_cap_exceeded(err),
         })
 
     usage = result_event.get("usage") or {}
@@ -453,4 +488,5 @@ async def run_claude_local(
         "context_exceeded": is_error and _ctx_exceeded(err_text),
         "limit_exceeded": limit_hit,
         "limit_reset_epoch": reset_epoch,
+        "output_cap_exceeded": is_error and _output_cap_exceeded(err_text),
     })