devops-bot-sdk 1.4.70__tar.gz → 1.4.74__tar.gz

{devops_bot_sdk-1.4.70 → devops_bot_sdk-1.4.74}/PKG-INFO

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

{devops_bot_sdk-1.4.70 → devops_bot_sdk-1.4.74}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.70 → devops_bot_sdk-1.4.74}/pyproject.toml

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

{devops_bot_sdk-1.4.70 → devops_bot_sdk-1.4.74}/sdk/__init__.py

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

{devops_bot_sdk-1.4.70 → devops_bot_sdk-1.4.74}/sdk/client.py

@@ -58,7 +58,7 @@ def _notify_status(task_id: str, status: str) -> None:
             pass
 
 
-SDK_VERSION    = "1.4.70"
+SDK_VERSION    = "1.4.74"
 _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.70 → devops_bot_sdk-1.4.74}/sdk/ipc/handlers.py

@@ -415,6 +415,56 @@ async def _run_with_heartbeat(coro, *, send: Callable, thread_id: str, label: st
             pass
 
 
+async def _run_generation(
+    prompt: str, project_path: str, *, send: Callable, thread_id: str, label: str,
+    github_token: str | None = None, resume_session_id: str | None = None,
+    name: str | None = None,
+):
+    """Run a read-only generation (epic decomposition / PRD) with a heartbeat AND
+    output-token-cap chunking: if a single response is cut off at the per-response
+    output cap, resume the session and continue — concatenating the pieces — so a
+    large result (a big JSON / PRD) completes across chunks instead of truncating.
+    """
+    from sdk import local_exec
+
+    cap = local_exec._MAX_OUTPUT_TOKENS
+    res = await _run_with_heartbeat(
+        local_exec.run_claude_local(
+            prompt, project_path, allowed_tools=_RECON_ALLOWED_TOOLS,
+            github_token=github_token, resume_session_id=resume_session_id, max_output_tokens=cap,
+        ),
+        send=send, thread_id=thread_id, label=label, name=name,
+    )
+    combined = res.get("result") or ""
+    sid = res.get("session_id")
+    chunks = 0
+    while res.get("output_cap_exceeded") and sid and chunks < _MAX_OUTPUT_CAP_RESUMES:
+        chunks += 1
+        cap = min(cap * 2, 128000)
+        await send(Envelope(
+            type="step_update", thread_id=thread_id,
+            data={"status": "running",
+                  "current_step": (f"[{name}] " if name else "") + f"{label}: response hit the "
+                                  f"output-token cap — continuing in chunks (part {chunks + 1})"},
+        ).model_dump())
+        res = await _run_with_heartbeat(
+            local_exec.run_claude_local(
+                "Your previous response was cut off at the output-token limit. Continue "
+                "EXACTLY where you left off — output ONLY the remaining content, with no "
+                "repetition and no preamble, so the two pieces concatenate seamlessly.",
+                project_path, allowed_tools=_RECON_ALLOWED_TOOLS,
+                github_token=github_token, resume_session_id=sid, max_output_tokens=cap,
+            ),
+            send=send, thread_id=thread_id, label=f"{label} (cont.)", name=name,
+        )
+        combined += res.get("result") or ""
+        sid = res.get("session_id") or sid
+    out = dict(res)
+    out["result"] = combined      # the full, reassembled output
+    out["session_id"] = sid
+    return out
+
+
 # ── Epic decomposition ────────────────────────────────────────────────────
 # An EPIC is not coded directly. It is analysed (grounded in the codebase when a
 # project path exists) into a detailed user-story description + an implementation
@@ -547,10 +597,11 @@ def _extract_json_block(text: str | None) -> dict | None:
         return None
     import json as _json
     candidates = re.findall(r"```(?:json)?\s*(\{.*?\})\s*```", text, re.S | re.I)
-    if not candidates:
-        start, end = text.find("{"), text.rfind("}")
-        if start != -1 and end > start:
-            candidates = [text[start:end + 1]]
+    # ALWAYS also consider the widest brace span — covers a missing/late closing
+    # fence, extra prose around the block, or a fenced capture that fails to parse.
+    start, end = text.find("{"), text.rfind("}")
+    if start != -1 and end > start:
+        candidates.append(text[start:end + 1])
     for c in reversed(candidates):
         try:
             obj = _json.loads(c)
@@ -800,15 +851,32 @@ async def _handle_epic(
         await graphify.prepare(project_path)
     except Exception:  # noqa: BLE001
         pass
-    gen = await local_exec.run_claude_local(
+    gen = await _run_generation(
         _build_epic_prompt(jira_key, summary, description, human),
-        project_path, allowed_tools=_RECON_ALLOWED_TOOLS,  # read-only analysis
+        project_path, send=send, thread_id=thread_id,
+        label=f"Epic {jira_key}: generating user stories",
         github_token=await client.github_token(),
     )
-    doc = _extract_json_block(gen.get("result")) if gen.get("ok") else None
+    # A usage-limit hit must stop and retry later. For ANY other outcome, still try
+    # to parse the JSON — the model often produces a valid decomposition even when the
+    # run is flagged is_error (e.g. a stray read-only tool denial during exploration),
+    # and the result then lands in `error`. Don't discard that work over an is_error flag.
+    if gen.get("limit_exceeded"):
+        await client.log_activity(f"Epic {jira_key}: usage limit during decomposition — will retry after reset")
+        await client.move_to_backlog(tid)
+        await send(Envelope(
+            type=Envelope.TYPE_ERROR, thread_id=thread_id,
+            data={"code": "EPIC_DECOMPOSE_LIMIT", "task_id": tid,
+                  "message": "Claude usage limit reached during epic decomposition"},
+        ).model_dump())
+        return
+    doc = _extract_json_block(gen.get("result") or gen.get("error") or "")
     stories = (doc or {}).get("stories") or []
     if not doc or not stories:
-        reason = (gen.get("error") or "could not generate a valid decomposition")[:200]
+        had_output = bool(gen.get("result") or gen.get("error"))
+        reason = ("model output did not contain a parseable decomposition JSON"
+                  if had_output else
+                  (gen.get("error") or "no output from the decomposition run"))[:300]
         await client.log_activity(f"Epic {jira_key}: decomposition failed — {reason}")
         await client.move_to_backlog(tid)
         await send(Envelope(
@@ -1035,12 +1103,15 @@ async def _handle_story(
             await graphify.prepare(project_path)
         except Exception:  # noqa: BLE001
             pass
-        gen = await local_exec.run_claude_local(
+        gen = await _run_generation(
             _build_prd_prompt(jira_key, summary, user_story, human),
-            project_path, allowed_tools=_RECON_ALLOWED_TOOLS,  # read-only analysis
+            project_path, send=send, thread_id=thread_id,
+            label=f"Story {jira_key}: generating PRD",
             github_token=await client.github_token(),
         )
-        prd = (gen.get("result") or "").strip() if gen.get("ok") else ""
+        # Use the output regardless of an is_error flag (a stray read-only tool denial
+        # shouldn't discard a PRD the model actually produced); only a usage limit is fatal.
+        prd = "" if gen.get("limit_exceeded") else (gen.get("result") or "").strip()
         if prd:
             # PRD lives alongside the user story in the (now Task) description.
             new_description = f"{user_story}\n\n---\n\n{_PRD_MARKER}\n\n{prd}"[:20000]
@@ -1471,16 +1542,14 @@ async def _code_one_repo(
                 "code you found. Output ONLY the PRD as Markdown, following this format "
                 "exactly:\n\n" + _PRD_FORMAT
             )
-        prd_res = await _run_with_heartbeat(
-            local_exec.run_claude_local(
-                instruction, repo_path, on_event=_on_event,  # stream tool activity
-                allowed_tools=_RECON_ALLOWED_TOOLS,  # read-only
-                github_token=gh_token, resume_session_id=recon_session,
-            ),
-            send=send, thread_id=thread_id, label="Working on the PRD", name=name,
+        prd_res = await _run_generation(
+            instruction, repo_path, send=send, thread_id=thread_id,
+            label="Working on the PRD", name=name,
+            github_token=gh_token, resume_session_id=recon_session,  # continue the recon session
         )
         recon_session = prd_res.get("session_id") or recon_session
-        prd = (prd_res.get("result") or "").strip() if prd_res.get("ok") else ""
+        # Use the PRD regardless of an is_error flag; only skip on a real usage limit.
+        prd = "" if prd_res.get("limit_exceeded") else (prd_res.get("result") or "").strip()
         if prd:
             enriched = f"{before}{_PRD_MARKER}\n\n{prd}"[:20000]
             pending["user_input"] = enriched   # shared across repos → reused

{devops_bot_sdk-1.4.70 → devops_bot_sdk-1.4.74}/sdk/local_exec.py

@@ -509,10 +509,12 @@ async def run_claude_local(
     result_text = str(result_event.get("result", ""))
     subtype = str(result_event.get("subtype", ""))
 
-    # Claude USAGE/RATE limit: detected from the result/subtype even when the CLI
-    # didn't flag is_error — so a limit-truncated run is NOT treated as success
-    # (which would wrongly mark the ticket Done).
-    limit_hit = _is_limit(result_text) or "limit" in subtype.lower()
+    # Claude USAGE/RATE limit. A real limit ABORTS the run (is_error) with a limit
+    # message, or the CLI flags it in the subtype. Do NOT infer a limit from a
+    # SUCCESSFUL run's result text — a task whose OUTPUT legitimately mentions
+    # "usage limit" / "rate limit" (e.g. building an observability/quota feature)
+    # would otherwise false-positive as a rate-limit hit.
+    limit_hit = "limit" in subtype.lower() or (is_error and _is_limit(result_text))
     reset_epoch = _parse_reset_epoch(result_text)
 
     err_text = None