devops-bot-sdk 1.4.22__tar.gz → 1.4.24__tar.gz

{devops_bot_sdk-1.4.22 → devops_bot_sdk-1.4.24}/PKG-INFO

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

{devops_bot_sdk-1.4.22 → devops_bot_sdk-1.4.24}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.22 → devops_bot_sdk-1.4.24}/pyproject.toml

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

{devops_bot_sdk-1.4.22 → devops_bot_sdk-1.4.24}/sdk/__init__.py

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

{devops_bot_sdk-1.4.22 → devops_bot_sdk-1.4.24}/sdk/client.py

@@ -36,7 +36,7 @@ from sdk.sse import _check_status, stream_with_reconnect
 
 logger = logging.getLogger(__name__)
 
-SDK_VERSION    = "1.4.22"
+SDK_VERSION    = "1.4.24"
 _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.22 → devops_bot_sdk-1.4.24}/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.
@@ -1832,13 +1871,23 @@ async def handle_orchestrate_auto_local_run(
                                 ).model_dump())
                                 return
                             continue  # re-run this ticket from phase 1
-                        # Out of retries — leave it in Backlog for a later run.
+                        # Out of retries. The usage/session limit is ACCOUNT-WIDE, so
+                        # every remaining ticket would hit the same wall and burn its
+                        # own retry budget (up to 6h each). Pause the whole run instead
+                        # of marching on — this ticket and the rest stay in To Do/
+                        # Backlog, and `agentos-auto resume` picks them up after reset.
                         await send(Envelope(
                             type="step_update", thread_id=thread_id,
-                            data={"current_step": f"{jira_key}: usage limit — max retries reached, "
-                                                  f"left in Backlog"},
+                            data={"current_step": f"{jira_key}: usage limit — max retries reached; "
+                                                  f"pausing run (resume after the window resets)"},
                         ).model_dump())
-                        break
+                        await send(Envelope(
+                            type=Envelope.TYPE_DONE, thread_id=thread_id,
+                            data={"mode": "orchestrate-auto-local", "status": "paused",
+                                  "reason": "usage_limit", "processed": processed,
+                                  "task_count": total},
+                        ).model_dump())
+                        return
 
                     processed += 1
                     break

{devops_bot_sdk-1.4.22 → devops_bot_sdk-1.4.24}/sdk/local_exec.py

@@ -23,7 +23,7 @@ import os
 import re
 import shutil
 import sys
-from datetime import datetime
+from datetime import datetime, timedelta
 from pathlib import Path
 from typing import Any, Awaitable, Callable
 
@@ -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.
@@ -69,9 +86,21 @@ _LIMIT_MARKERS = (
     "usage limit reached", "usage limit", "rate limit", "rate_limit",
     "too many requests", "limit will reset", "limit reached", "overloaded_error",
     "resets at", "429",
+    # Newer Claude Code CLI wording: "You've hit your session limit · resets 10:20pm
+    # (Asia/Karachi)" and "You've hit your usage limit". Without these the message
+    # fell through to the generic-failure path and the auto-loop never waited for
+    # the window to reset — every following ticket hit the same limit and cascaded
+    # to Backlog.
+    "session limit", "you've hit your", "youve hit your",
 )
 # A unix-seconds reset timestamp claude sometimes appends (e.g. "...reached|1719500400").
 _RESET_EPOCH_RE = re.compile(r"\b(1[6-9]\d{8}|20\d{8})\b")
+# A wall-clock reset the CLI prints instead, e.g. "resets 10:20pm (Asia/Karachi)"
+# or "resets at 10pm". Captures hour, optional minutes, am/pm, optional IANA tz.
+_RESET_CLOCK_RE = re.compile(
+    r"reset[s]?\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*([ap]m)\b(?:\s*\(([^)]+)\))?",
+    re.IGNORECASE,
+)
 # Fallback wait when the limit message carries no reset time (env-tunable).
 _LIMIT_DEFAULT_WAIT_S = _f("AGENTOS_LIMIT_DEFAULT_WAIT_S", 60 * 60.0)   # 1 h
 
@@ -82,7 +111,15 @@ def _is_limit(text: str | None) -> bool:
 
 
 def _parse_reset_epoch(text: str | None) -> int | None:
-    """A unix-seconds reset time embedded in a limit message, if present."""
+    """A unix-seconds reset time embedded in a limit message, if present.
+
+    Handles two shapes the CLI uses:
+      1. A literal unix timestamp (e.g. "...reached|1719500400").
+      2. A wall-clock time (e.g. "resets 10:20pm (Asia/Karachi)") — resolved to
+         the next future occurrence of that time in the named tz (local tz when
+         none/unknown). Returns None when neither is present, so callers fall
+         back to the default wait.
+    """
     if not text:
         return None
     m = _RESET_EPOCH_RE.search(text)
@@ -91,7 +128,33 @@ def _parse_reset_epoch(text: str | None) -> int | None:
             return int(m.group(1))
         except ValueError:
             return None
-    return None
+    return _parse_reset_clock(text)
+
+
+def _parse_reset_clock(text: str) -> int | None:
+    """Resolve a 'resets 10:20pm (Asia/Karachi)'-style reset to a unix epoch."""
+    m = _RESET_CLOCK_RE.search(text)
+    if not m:
+        return None
+    try:
+        hour = int(m.group(1)) % 12          # 12am → 0, 12pm → 0 (+12 below)
+        minute = int(m.group(2) or 0)
+        if m.group(3).lower() == "pm":
+            hour += 12
+        tz = None
+        if m.group(4):
+            try:
+                from zoneinfo import ZoneInfo
+                tz = ZoneInfo(m.group(4).strip())
+            except Exception:  # noqa: BLE001 — unknown tz → local time
+                tz = None
+        now = datetime.now(tz)
+        target = now.replace(hour=hour, minute=minute, second=0, microsecond=0)
+        if target <= now:                    # already passed today → next day
+            target += timedelta(days=1)
+        return int(target.timestamp())
+    except Exception:  # noqa: BLE001 — never let reset parsing break limit handling
+        return None
 
 
 # ── Per-run claude log file (on the user's machine, local-timezone stamps) ──
@@ -162,6 +225,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 +255,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 +328,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 +499,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 +534,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),
     })