devops-bot-sdk 1.6.14__tar.gz → 1.6.19__tar.gz

{devops_bot_sdk-1.6.14 → devops_bot_sdk-1.6.19}/PKG-INFO

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

{devops_bot_sdk-1.6.14 → devops_bot_sdk-1.6.19}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.6.14 → devops_bot_sdk-1.6.19}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -12,7 +12,9 @@ sdk/cli.py
 sdk/client.py
 sdk/config.py
 sdk/crucial.py
+sdk/departments.py
 sdk/exceptions.py
+sdk/formats.py
 sdk/git_ops.py
 sdk/github_ingest.py
 sdk/graphify.py
@@ -24,6 +26,7 @@ sdk/scheduler.py
 sdk/sse.py
 sdk/test.py
 sdk/test_pipeline.py
+sdk/ticket_fields.py
 sdk/updater.py
 sdk/vps_health.py
 sdk/agents/__init__.py
@@ -104,14 +107,25 @@ tests/test_agent_schedules.py
 tests/test_agent_workspace_settings.py
 tests/test_agents_connectors_builder.py
 tests/test_allowed_tools_config.py
+tests/test_auto_agent_dispatch.py
+tests/test_client_jira_projects.py
+tests/test_config_token_diagnostics.py
+tests/test_configure_token_owner.py
 tests/test_console_encoding.py
+tests/test_departments.py
+tests/test_epic_inherited_agent_id.py
+tests/test_formats.py
 tests/test_git_action.py
 tests/test_github_ingest.py
 tests/test_health.py
 tests/test_otp_login.py
+tests/test_run_auto_agent_only.py
 tests/test_run_outputs.py
 tests/test_schedule_api.py
 tests/test_scheduler.py
+tests/test_service_token_warning.py
+tests/test_ticket_fields.py
+tests/test_ticket_run_resolve_by_id.py
 tests/test_update_timer.py
 tests/test_updater_extras.py
 tests/test_vps_health.py

{devops_bot_sdk-1.6.14 → devops_bot_sdk-1.6.19}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.6.14
+Version: 1.6.19
 
 Public surface:
   BackendClient.from_config()        — create client from ~/.agentos/config.toml
@@ -19,6 +19,10 @@ Collectors (payload producers — submit via BackendClient.submit_webhook):
   collectors.screenshot.build_webhook_payload(token, project)
   collectors.process.build_webhook_payload(token, project)
 
+Standard artifact formats (house style for generated Epics/Stories/PRDs):
+  formats.EPIC_FORMAT, formats.USER_STORY_FORMAT, formats.PRD_FORMAT
+  formats.FORMAT_VERSION             — generation stamp for the three above
+
 IPC entry point (Electron main process):
   python -m sdk.ipc.electron_bridge   (stdio newline-delimited JSON)
 
@@ -30,7 +34,7 @@ Rules:
   - All data egress through submit_webhook only
 """
 
-__version__ = "1.6.14"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
+__version__ = "1.6.19"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
 __author__  = "AgentOS"   # sdk.client.SDK_VERSION and the UI server version all read this.
 
 from sdk.client import BackendClient
@@ -41,6 +45,12 @@ from sdk.exceptions import (
     CollectorError,
     TokenNotConfigured,
 )
+from sdk.formats import (
+    EPIC_FORMAT,
+    FORMAT_VERSION,
+    PRD_FORMAT,
+    USER_STORY_FORMAT,
+)
 from sdk.models.envelope import Envelope
 
 __all__ = [
@@ -52,4 +62,8 @@ __all__ = [
     "BackendVersionTooOld",
     "CollectorError",
     "TokenNotConfigured",
+    "EPIC_FORMAT",
+    "USER_STORY_FORMAT",
+    "PRD_FORMAT",
+    "FORMAT_VERSION",
 ]

{devops_bot_sdk-1.6.14 → devops_bot_sdk-1.6.19}/sdk/agentd.py

@@ -346,10 +346,20 @@ async def _dispatch_agent_run(
     if skill_text:
         prompt_text = f"{prompt_text}\n\n{skill_text}"
 
+    # When a TICKET triggered this run, the backend must drive ITS ML_TASK_FLOW
+    # lifecycle — that flow is a no-op unless `jira_task_id` is set (see
+    # sdk/models/requests.py). Without it nothing ever moves the ticket out of
+    # "To Do", so the next auto pass re-fetches and re-executes the same agent
+    # forever. A scheduled (task=None) run has no ticket and stays session-only,
+    # exactly as before. It also makes `_on_status_update` below address the
+    # TICKET id rather than the session id on the approval_reply round-trip.
+    jira_task_id = str((task or {}).get("id") or "") or None
+
     req = OrchestrateRequest(
         user_input=prompt_text,
         local_execution=True,
         dev_engine="claude_code",
+        jira_task_id=jira_task_id,
         metadata={"custom_agent_id": manifest.name, "custom_agent_name": manifest.name},
     )
 
@@ -420,6 +430,7 @@ async def _dispatch_agent_run(
                 manifest.name, _activity_kind, local_result,
                 time.monotonic() - _started, client=client,
                 detail=f"task {task_id}" if task_id else "",
+                task_id=task_id or "",
             )
             outcome.update({
                 "task_id": task_id,
@@ -435,6 +446,7 @@ async def _dispatch_agent_run(
             await activity.record_run(
                 manifest.name, _activity_kind, {"ok": False, "error": str(exc)},
                 0.0, client=client, detail=f"task {task_id}" if task_id else "",
+                task_id=task_id or "",
             )
             return
 

{devops_bot_sdk-1.6.14 → devops_bot_sdk-1.6.19}/sdk/agents/activity.py

@@ -63,11 +63,15 @@ def describe(name: str, kind: str, result: dict | None, duration_s: float = 0.0,
 
 
 async def emit(name: str, kind: str, result: dict | None, duration_s: float = 0.0,
-               *, client: "BackendClient | None" = None, detail: str = "") -> bool:
-    """Emit ONE ``{activity, agentId}`` event for a finished agent run.
+               *, client: "BackendClient | None" = None, detail: str = "",
+               task_id: str = "") -> bool:
+    """Emit ONE ``{activity, agentId[, taskId]}`` event for a finished agent run.
 
     Returns True when the webhook accepted it, False otherwise (unknown agent,
     no token, backend down) — never raises.
+
+    ``task_id`` attributes a ticket-triggered run to its ticket. A scheduled or
+    CLI run has no ticket and omits it.
     """
     try:
         if client is None:
@@ -78,6 +82,7 @@ async def emit(name: str, kind: str, result: dict | None, duration_s: float = 0.
             return False
         return await client.log_agent_activity(
             describe(name, kind, result, duration_s, detail), agent_id,
+            task_id=task_id,
         )
     except Exception as exc:  # noqa: BLE001 — activity emit must never break a run
         logger.debug("activity emit failed agent=%s err=%s", name, exc)
@@ -85,7 +90,8 @@ async def emit(name: str, kind: str, result: dict | None, duration_s: float = 0.
 
 
 async def record_run(name: str, kind: str, result: dict | None, duration_s: float = 0.0,
-                     *, client: "BackendClient | None" = None, detail: str = "") -> None:
+                     *, client: "BackendClient | None" = None, detail: str = "",
+                     task_id: str = "") -> None:
     """Record a finished run to BOTH sinks: local ledger, then platform feed.
 
     The ledger write happens first and independently of the webhook, so a
@@ -107,4 +113,5 @@ async def record_run(name: str, kind: str, result: dict | None, duration_s: floa
     except Exception as exc:  # noqa: BLE001 — ledger write must never break a run
         logger.debug("activity ledger write failed agent=%s err=%s", name, exc)
 
-    await emit(name, kind, res, duration_s, client=client, detail=detail)
+    await emit(name, kind, res, duration_s, client=client, detail=detail,
+               task_id=task_id)

devops_bot_sdk-1.6.19/sdk/agents/ticket_run.py

@@ -0,0 +1,325 @@
+"""On-demand "run an agent ON a Jira ticket" — the manual counterpart to the
+``agentd`` ``ticket_label`` trigger.
+
+The daemon fires an agent when a To-Do ticket carries its label; this module
+lets a human pick an agent AND a ticket and run it now (from the UI, the API, or
+the CLI). It reuses the exact same engine — ``agentd._dispatch_agent_run`` — so
+the ticket's fields fill the agent's ``{{variables}}`` and the work is planned,
+gated, executed locally, and reported back to the platform against that ticket.
+
+Because a human initiated the run, ``auto_approve=True`` is passed: the GO-AHEAD
+is sent immediately, skipping the agent's ``approval.policy`` WhatsApp gate for
+this single run.
+"""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, NamedTuple
+
+if TYPE_CHECKING:
+    from sdk.agents.manifest import AgentManifest
+    from sdk.client import BackendClient
+
+# Process-lifetime cache of backend agentId → (row, source) for the agents this
+# caller may run — the INVERSE of ``_AGENT_ID_CACHE`` in sdk/client.py (name→id),
+# and cached for the same reason: one run pass touches many tickets that share an
+# agentId, and each would otherwise cost a pair of list GETs.
+#
+# ``("", …)`` — an empty ``source`` — is the NEGATIVE entry: "no agent with this id
+# is visible to me". Negative caching is what keeps thirty tickets pointing at a
+# revoked agent from re-fetching both lists thirty times. It is only ever written
+# once absence has actually been ESTABLISHED (both lists read without error) — see
+# ``_load_agent_index``'s ``complete`` flag.
+_AGENT_BY_ID_CACHE: dict[str, tuple[dict[str, Any], str]] = {}
+
+# The two caller-scoped sources, in precedence order, with the provenance label
+# each one stamps. These labels are the same strings ``sdk/agents/inventory.py``
+# and ``sdk/ui/api.py`` already use, so a caller can compare them directly.
+#
+# ``list_department_agents`` covers department defaults AND org-wide common agents
+# in ONE response (the backend's ``department.list_for_department`` ORs both
+# filters), which is why there is no third source here.
+_ID_SOURCES: tuple[tuple[str, str, str], ...] = (
+    ("your agents", "list_custom_agents", "custom"),
+    ("department defaults", "list_department_agents", "default"),
+)
+
+
+class ResolvedAgent(NamedTuple):
+    """A backend agent this caller is entitled to run, and where it came from.
+
+    A ``NamedTuple`` rather than a field on ``AgentManifest``: the manifest is a
+    closed model shared with local YAML agents, which have no backend provenance
+    to report. ``source`` is ``"custom"`` or ``"default"``.
+    """
+
+    agent_id: str
+    manifest: AgentManifest
+    source: str
+
+
+def _is_deleted(row: dict[str, Any]) -> bool:
+    """True when the row is soft-deleted, in any of the spellings a row may use.
+
+    Defensive: the list endpoints are expected to exclude soft-deleted rows
+    server-side, but a manifest resolved here is dispatched with the agent's
+    secrets injected as engine env, so the gate is re-asserted locally rather than
+    trusted. Fails closed — an unrecognised truthy value counts as deleted.
+    """
+    return any(row.get(key) for key in ("deleted_at", "deletedAt", "is_deleted", "isDeleted"))
+
+
+async def _load_agent_index(
+    client: BackendClient, reasons: list[str] | None = None,
+) -> tuple[bool, int]:
+    """Warm ``_AGENT_BY_ID_CACHE`` from both caller-scoped lists.
+
+    Returns ``(complete, visible)`` — whether BOTH sources were read without
+    error, and how many rows were indexed. ``complete`` is what lets the caller
+    tell "this agent is not mine" from "I could not find out": only the former may
+    be negative-cached for the process lifetime.
+
+    Per-source failures are tolerated and recorded, never raised: a
+    department-list outage must not hide a custom hit, and vice versa — the same
+    posture ``chat.resolve_agent`` takes. A client missing one of the methods
+    entirely (an older client, or a test fake) is skipped, and also counts as
+    incomplete.
+
+    ``_ID_SOURCES`` is walked in precedence order and a row already written in
+    THIS pass is not overwritten, so a custom agent wins an id collision with a
+    department one. A row written by an EARLIER pass is refreshed, which is also
+    how a negative entry is upgraded once the agent becomes visible.
+    """
+    def _note(reason: str) -> None:
+        if reasons is not None:
+            reasons.append(reason)
+
+    complete = True
+    seen: set[str] = set()
+
+    for label, attr, source in _ID_SOURCES:
+        fetch = getattr(client, attr, None)
+        if fetch is None:
+            complete = False
+            continue
+        try:
+            rows = await fetch() or []
+        except Exception as exc:  # noqa: BLE001 — a fetch failure is not "not mine"
+            # str() is EMPTY on some httpx errors (ReadTimeout) — name the class then.
+            complete = False
+            _note(f"{label} could not be fetched ({str(exc) or type(exc).__name__})")
+            continue
+        for row in rows:
+            if not isinstance(row, dict):
+                continue
+            row_id = str(row.get("id") or "").strip()
+            if not row_id or row_id in seen:
+                continue
+            seen.add(row_id)
+            _AGENT_BY_ID_CACHE[row_id] = (row, source)
+
+    return complete, len(seen)
+
+
+async def resolve_manifest_by_id(
+    client: BackendClient, agent_id: str, reasons: list[str] | None = None,
+) -> ResolvedAgent | None:
+    """Find the runnable manifest for a ticket's ``agentId``, scoped to the caller.
+
+    The counterpart to :func:`resolve_manifest`, which resolves by NAME. A ticket
+    carries an id, so this walks the id instead — but the important difference is
+    not the key, it is the SCOPE.
+
+    **Scope is the authorisation check.** The only agents reachable here are those
+    in the union of ``list_custom_agents()`` (the caller's own) and
+    ``list_department_agents()`` (their department defaults plus org-wide common
+    agents — one response covers both). Membership in that union IS the
+    entitlement: no ``relation_id`` comparison, no department-id argument, and
+    deliberately no fetch-by-id endpoint. An id that exists platform-side but is
+    absent from both responses is simply unresolvable, and nothing further is
+    tried. That matters because a resolved manifest carries a system prompt and is
+    handed to ``agentd._dispatch_agent_run``, which runs it on THIS machine with
+    the agent's resolved secrets injected as engine env — so a broader lookup
+    would be a privilege escalation, not a convenience.
+
+    There is also no local-manifest fallback (``resolve_manifest``'s ``custom``
+    scope has one): a hand-written ``~/.agentos/agents`` YAML has no backend id,
+    so it is unreachable by id by construction — and honouring a local override
+    here would let a local file stand in for an agent the caller may not run.
+
+    Returns ``None`` — never a manifest — for a blank id, an id in neither list, a
+    non-``active`` status, a soft-deleted row, or a row with no usable prompt. Pass
+    ``reasons``, a list this appends to, to learn WHICH: exactly as with
+    ``resolve_manifest``, "not yours", "your token is not valid so the list could
+    not be read", "it is paused" and "it has no prompt" are four different
+    problems that all end in ``None``, and they demand different fixes.
+
+    Results are memoised for the process lifetime, positive AND negative, so N
+    tickets sharing one agentId cost one pair of list GETs. The runnability gate
+    below runs on EVERY call rather than at cache-fill time, so a cached-but-paused
+    agent answers ``None`` every time — from cache, with no extra fetch.
+    """
+    from sdk.agents.manifest import manifest_from_backend_row
+
+    def _note(reason: str) -> None:
+        if reasons is not None:
+            reasons.append(reason)
+
+    aid = str(agent_id or "").strip()
+    if not aid:
+        # No network call: a ticket with no agentId is not a lookup failure.
+        _note("the ticket carries no agentId, so there is nothing to resolve")
+        return None
+
+    entry = _AGENT_BY_ID_CACHE.get(aid)
+    if entry is None:
+        complete, visible = await _load_agent_index(client, reasons)
+        entry = _AGENT_BY_ID_CACHE.get(aid)
+        if entry is None:
+            if complete:
+                # Absence is ESTABLISHED — safe to remember.
+                _AGENT_BY_ID_CACHE[aid] = ({}, "")
+                _note(f"no agent with id '{aid}' is in your own agents or your "
+                      f"department defaults ({visible} visible to you)")
+            else:
+                # A source went unread, so absence was never established. Do NOT
+                # cache it: a three-minute outage must not become a
+                # process-lifetime "this agent does not exist". The per-source
+                # reasons are already recorded by _load_agent_index.
+                _note(f"'{aid}' could not be looked up")
+            return None
+
+    row, source = entry
+    if not source:
+        _note(f"no agent with id '{aid}' is in your own agents or your department defaults")
+        return None
+
+    name = str(row.get("name") or "").strip() or aid
+    if _is_deleted(row):
+        _note(f"agent '{name}' (id {aid}) has been deleted")
+        return None
+
+    status = str(row.get("status") or "").strip()
+    if status.lower() != "active":
+        # Strict, like _AgentRow.is_active and agentd._load_department_agents —
+        # NOT scheduler._agent_is_active's lenient "blank means active" variant,
+        # which exists to keep schedules alive through a backend hiccup. Nothing
+        # is guessed on the path that hands an agent its secrets.
+        _note(f"agent '{name}' (id {aid}) is not active (status={status or 'unknown'})")
+        return None
+
+    manifest = manifest_from_backend_row(row)
+    if manifest is None:
+        _note(f"agent '{name}' (id {aid}) has no usable prompt, so there is "
+              f"no instruction to run")
+        return None
+
+    return ResolvedAgent(agent_id=aid, manifest=manifest, source=source)
+
+
+async def resolve_manifest(
+    client: "BackendClient", name: str, scope: str = "custom", department_id: str = "",
+    reasons: list[str] | None = None,
+) -> "AgentManifest | None":
+    """Find the agent manifest to run, by ``scope``.
+
+    * ``department`` — an ACTIVE department default pulled from the backend
+      (``list_department_agents``) and materialized read-only (never written back).
+    * ``custom`` (default) — a local manifest, then the caller's own backend
+      agents, then their department defaults, via ``chat.resolve_agent``.
+
+    Backend rows are prompt-based (``prompt.system_prompt`` + attached skills);
+    the ``manifest`` column this used to read no longer exists on the table, so
+    reading it raised ``KeyError`` and made every department agent unrunnable.
+
+    Returns None when no matching agent is found, so the caller reports it. Pass
+    ``reasons`` — a list this appends to — to learn WHY: "not found" and "your
+    token is not valid so the agent list could not be read" and "the agent exists
+    but has no prompt" are three very different problems that all end in None, and
+    a bare "was not found" sends the user hunting for a typo that isn't there.
+    """
+    from sdk.agents.chat import resolve_agent
+    from sdk.agents.manifest import manifest_from_backend_row
+
+    def _note(reason: str) -> None:
+        if reasons is not None:
+            reasons.append(reason)
+
+    name = (name or "").strip()
+    if scope == "department":
+        try:
+            rows = await client.list_department_agents()
+        except Exception as exc:  # noqa: BLE001 — a fetch failure is not "not found"
+            # str() is EMPTY on some httpx errors (ReadTimeout) — name the class then.
+            _note(f"department defaults could not be fetched "
+                  f"({str(exc) or type(exc).__name__})")
+            return None
+        for row in rows:
+            if row.get("name") == name and row.get("status") == "active":
+                manifest = manifest_from_backend_row(row)
+                if manifest is None:
+                    _note(f"'{name}' is a department default but its prompt is empty, "
+                          f"so there is no instruction to run")
+                return manifest
+        _note(f"no ACTIVE department default named '{name}' "
+              f"({len(rows)} department agent(s) visible to you)")
+        return None
+
+    try:
+        return await resolve_agent(name, client)
+    except LookupError as exc:
+        # resolve_agent names every source it checked and why each one missed —
+        # keep that, it is the whole diagnosis.
+        _note(str(exc))
+        return None
+
+
+async def run_on_ticket(
+    client: "BackendClient", name: str, ticket_key: str = "",
+    scope: str = "custom", department_id: str = "",
+    variables: dict | None = None, secrets: dict | None = None,
+) -> dict:
+    """Run agent ``name`` (``scope``) now, OPTIONALLY against a Jira ticket.
+
+    * ``ticket_key`` — optional. When given, the ticket record is fetched (any
+      board status — a targeted run may re-run a Done ticket) and its fields fill
+      the agent's ``{{variables}}``. When omitted, the agent runs without a ticket.
+    * ``variables`` — optional EPHEMERAL ``{{var}}`` values for this run; they win
+      over ticket-derived values and are never persisted.
+    * ``secrets`` — optional EPHEMERAL env secrets for this run only; injected for
+      the engine invocation and never written to the agent's stored keys.
+
+    Resolves the manifest and dispatches through the shared pipeline with
+    ``auto_approve=True``. Returns the dispatch outcome dict
+    (``{status, task_id, result, ok, error}``).
+
+    Raises ``ValueError`` when the agent — or an explicitly-named ticket — cannot
+    be found, so the caller reports a clear message. For the agent, that message
+    carries the resolver's REASON (unreadable agent list vs. genuinely absent vs.
+    present-but-promptless): they demand different fixes and used to be
+    indistinguishable behind one "was not found".
+    """
+    from sdk.agentd import _dispatch_agent_run
+
+    key = (ticket_key or "").strip()
+    task: dict | None = None
+    if key:
+        records = await client.list_tasks_by_keys([key])
+        if not records:
+            raise ValueError(f"Jira ticket '{key}' was not found.")
+        task = records[0]
+
+    reasons: list[str] = []
+    manifest = await resolve_manifest(
+        client, name, scope=scope, department_id=department_id, reasons=reasons,
+    )
+    if manifest is None:
+        detail = " — ".join(reasons)
+        raise ValueError(
+            f"Agent '{name}' could not be run (scope={scope})"
+            + (f" — {detail}." if detail else ".")
+        )
+
+    return await _dispatch_agent_run(
+        manifest, client, task, auto_approve=True,
+        extra_variables=variables or None, extra_secrets=secrets or None,
+    )