devops-bot-sdk 1.4.71__tar.gz → 1.4.76__tar.gz

{devops_bot_sdk-1.4.71 → devops_bot_sdk-1.4.76}/PKG-INFO

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

{devops_bot_sdk-1.4.71 → devops_bot_sdk-1.4.76}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.71 → devops_bot_sdk-1.4.76}/pyproject.toml

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

{devops_bot_sdk-1.4.71 → devops_bot_sdk-1.4.76}/sdk/__init__.py

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

{devops_bot_sdk-1.4.71 → devops_bot_sdk-1.4.76}/sdk/client.py

@@ -58,7 +58,7 @@ def _notify_status(task_id: str, status: str) -> None:
             pass
 
 
-SDK_VERSION    = "1.4.71"
+SDK_VERSION    = "1.4.76"
 _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.71 → devops_bot_sdk-1.4.76}/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
@@ -574,19 +624,17 @@ def _extract_email(text: str | None) -> str | None:
 
 
 def _epic_inherited_fields(task: dict) -> dict:
-    """Parent-Epic fields a child Task should inherit (drops empties)."""
-    def _date(v: object) -> str | None:
-        s = str(v or "")
-        return s[:10] if s else None   # ISO datetime → YYYY-MM-DD
+    """Parent-Epic fields a child Task should inherit (drops empties).
 
+    Time-related fields (startDate, dueDate, slaTarget) are intentionally NOT
+    inherited/sent — they're optional on the POST and left for the backend/board to
+    set, so the create call never carries a stale or wrongly-formatted date.
+    """
     fields = {
         "projectKey": task.get("projectKey"),
         "priority": task.get("priority"),
         "assigneeEmail": (task.get("assignee") or {}).get("email"),
         "teamId": task.get("teamId"),
-        "startDate": _date(task.get("startDate")),
-        "dueDate": _date(task.get("dueDate")),
-        "slaTarget": task.get("slaTarget"),
     }
     sprint = task.get("sprint") or {}
     if sprint.get("jiraSprintId"):
@@ -801,9 +849,10 @@ 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(),
     )
     # A usage-limit hit must stop and retry later. For ANY other outcome, still try
@@ -1052,12 +1101,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]
@@ -1488,16 +1540,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
@@ -2943,6 +2993,60 @@ async def _poll_fresh_approval(
     return "timeout"
 
 
+async def _gate_transform_approval(
+    client: BackendClient, tid: str, jira_key: str, summary: str | None, action: str,
+    send: Callable, thread_id: str, should_stop: Callable[[], bool] | None,
+) -> str:
+    """Human-approval gate for a non-coding TRANSFORM (Epic decomposition /
+    Story→Task conversion) when agentMode=True. Sends the WhatsApp request and WAITS
+    for the decision. Returns 'approved' | 'rejected' | 'stopped'. On a 15-min timeout
+    the ticket goes to Backlog and we keep polling for a late reply. Does NOT change
+    ticket status itself — the handler owns that (an Epic marks itself In Progress; a
+    Story never does)."""
+    label = jira_key or tid
+    wa_summary = summary or jira_key or "task"
+    await send(Envelope(
+        type=Envelope.TYPE_AWAITING_APPROVAL, thread_id=thread_id,
+        data={"jira_key": jira_key, "task_id": tid,
+              "current_step": f"{label}: awaiting approval to {action}"},
+    ).model_dump())
+
+    async def _send_wa() -> bool:
+        ok = await client.notify_whatsapp(
+            tid, f"Approval needed for {label}: {action} — reply on WhatsApp to approve or reject.",
+            summary=wa_summary,
+        )
+        note = "approval request sent" if ok else "approval request FAILED to send"
+        await send(Envelope(
+            type="step_update", thread_id=thread_id,
+            data={"current_step": f"{label}: {note}"},
+        ).model_dump())
+        try:
+            await client.log_activity(f"Task {tid}: {note} ({action})")
+        except Exception:  # noqa: BLE001
+            pass
+        return ok
+
+    await _send_wa()
+    decision = await _poll_approval(
+        client, tid, should_stop,
+        fallback_notify=_send_wa, fallback_after_s=_FIRST_GATE_WA_FALLBACK_S,
+    )
+    if decision == "timeout":
+        await client.move_to_backlog(tid)
+        await send(Envelope(
+            type="step_update", thread_id=thread_id,
+            data={"current_step": f"{label}: no approval in 15m — Backlog; polling for late approval"},
+        ).model_dump())
+        while True:
+            if should_stop is not None and should_stop():
+                return "stopped"
+            late = await client.approval_status(tid)
+            if late in ("approved", "rejected"):
+                return late
+            await asyncio.sleep(_APPROVAL_POLL_INTERVAL_S)
+    return decision
+
 
 async def handle_orchestrate_auto_local_run(
     client: BackendClient, payload: dict, send: Callable,
@@ -3053,6 +3157,27 @@ async def handle_orchestrate_auto_local_run(
                     if not await _validate_ticket_or_reject(client, task, "epic", payload, send, thread_id):
                         processed += 1
                         continue
+                    # agentMode gate: wait for human approval before decomposing.
+                    if agent_mode:
+                        dec = await _gate_transform_approval(
+                            client, tid, jira_key, task.get("summary"),
+                            "decompose this Epic into user stories",
+                            send, thread_id, should_stop,
+                        )
+                        if dec == "stopped":
+                            await send(Envelope(
+                                type=Envelope.TYPE_DONE, thread_id=thread_id,
+                                data={"mode": "orchestrate-auto-local", "status": "paused",
+                                      "processed": processed, "task_count": total},
+                            ).model_dump())
+                            return
+                        if dec != "approved":
+                            await send(Envelope(
+                                type="step_update", thread_id=thread_id,
+                                data={"current_step": f"{jira_key}: {dec} — Epic not decomposed"},
+                            ).model_dump())
+                            processed += 1
+                            continue
                     await _handle_epic(client, task, payload, send, thread_id)
                 except Exception as exc:  # noqa: BLE001
                     logger.warning("auto_local.epic_failed task=%s err=%s", tid, exc)
@@ -3075,6 +3200,27 @@ async def handle_orchestrate_auto_local_run(
                     ):
                         processed += 1
                         continue
+                    # agentMode gate: wait for human approval before converting Story→Task.
+                    if agent_mode:
+                        dec = await _gate_transform_approval(
+                            client, tid, jira_key, task.get("summary"),
+                            "convert this Story into a Task",
+                            send, thread_id, should_stop,
+                        )
+                        if dec == "stopped":
+                            await send(Envelope(
+                                type=Envelope.TYPE_DONE, thread_id=thread_id,
+                                data={"mode": "orchestrate-auto-local", "status": "paused",
+                                      "processed": processed, "task_count": total},
+                            ).model_dump())
+                            return
+                        if dec != "approved":
+                            await send(Envelope(
+                                type="step_update", thread_id=thread_id,
+                                data={"current_step": f"{jira_key}: {dec} — Story not converted"},
+                            ).model_dump())
+                            processed += 1
+                            continue
                     new_desc = await _handle_story(client, task, payload, send, thread_id)
                 except Exception as exc:  # noqa: BLE001
                     logger.warning("auto_local.story_failed task=%s err=%s", tid, exc)

{devops_bot_sdk-1.4.71 → devops_bot_sdk-1.4.76}/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