devops-bot-sdk 1.4.149__tar.gz → 1.4.151__tar.gz

{devops_bot_sdk-1.4.149 → devops_bot_sdk-1.4.151}/PKG-INFO

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

{devops_bot_sdk-1.4.149 → devops_bot_sdk-1.4.151}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.149 → devops_bot_sdk-1.4.151}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.4.149
+Version: 1.4.151
 
 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.149"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
+__version__ = "1.4.151"   # 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

{devops_bot_sdk-1.4.149 → devops_bot_sdk-1.4.151}/sdk/agents/inventory.py

@@ -26,6 +26,7 @@ def _map_backend_agent(row: dict, source: str) -> dict:
     sys_prompt = prompt.get("system_prompt", "") if isinstance(prompt, dict) else ""
     pvars = prompt.get("variables", []) if isinstance(prompt, dict) else []
     return {
+        "id": row.get("id"),                 # backend agentId — used for activity webhook
         "name": row.get("name"),
         "description": sys_prompt[:200],
         "variables": [v.get("name") for v in pvars if isinstance(v, dict) and v.get("name")],

{devops_bot_sdk-1.4.149 → devops_bot_sdk-1.4.151}/sdk/agents/prompt_studio.py

@@ -164,6 +164,57 @@ def build_regenerate_prompt(system_prompt: str, feedback: str = "",
     )
 
 
+_VALIDATE_INPUTS_INSTRUCTION = """You are screening the inputs a user typed to CREATE an AI work agent, BEFORE a system prompt is generated. Decide whether each field is appropriate and meaningful.
+
+Mark a field invalid when it is:
+- offensive, abusive, hateful, harassing, or sexual;
+- gibberish, random characters, or meaningless filler;
+- clearly not what the field is for — in particular a JOB that does not describe an actual task/objective (e.g. a personal message like "shabana I love u", a person's name, or random words), an AGENT NAME that is not a plausible name for an agent, or an AGENT TYPE that is not a sensible category (e.g. developer, documentation, qa, support, data).
+
+Ignore any field whose value is empty. Be reasonable: a short-but-genuine job (e.g. "summarise a repo") is VALID. Only flag inputs that are clearly wrong.
+
+Return ONLY a JSON object, no prose:
+{"valid": true|false, "issues": {"agent_name": "<short polite fix instruction>", "agent_type": "<...>", "job": "<...>"}}
+Include a key in "issues" ONLY for a field you marked invalid; each message is a short, polite instruction to the user (e.g. "Kindly update the Job — it should describe the task the agent will perform."). If everything is fine, return {"valid": true, "issues": {}}.
+
+INPUTS TO SCREEN:
+AGENT NAME: __NAME__
+AGENT TYPE: __TYPE__
+MAIN JOB: __JOB__
+"""
+
+
+def build_validate_inputs_prompt(agent_name: str, agent_type: str, job: str) -> str:
+    """Prompt that asks the engine to screen agent_name/agent_type/job for
+    offensive or meaningless input before generation/regeneration."""
+    return (
+        _VALIDATE_INPUTS_INSTRUCTION
+        .replace("__NAME__", (agent_name or "").strip() or "(empty)")
+        .replace("__TYPE__", (agent_type or "").strip() or "(empty)")
+        .replace("__JOB__", (job or "").strip() or "(empty)")
+    )
+
+
+def parse_validation(model_output: str) -> dict:
+    """Parse the input-screening reply into ``{"valid": bool, "issues": {field: msg}}``.
+
+    Tolerant of fences/prose. Only the three known fields are kept. Defaults to
+    VALID on an unparseable reply so the caller can fail-open (proceed to generate).
+    """
+    data = _extract_json(model_output)
+    if not isinstance(data, dict):
+        return {"valid": True, "issues": {}}
+    raw_issues = data.get("issues") if isinstance(data.get("issues"), dict) else {}
+    issues = {
+        k: str(v).strip()
+        for k, v in raw_issues.items()
+        if k in ("agent_name", "agent_type", "job") and str(v or "").strip()
+    }
+    # Trust an explicit False, but also treat "issues present" as invalid.
+    valid = bool(data.get("valid", True)) and not issues
+    return {"valid": valid, "issues": issues}
+
+
 def parse_generation(model_output: str) -> dict:
     """Parse a generate/regenerate model reply into ``{system_prompt, variables}``.
 

{devops_bot_sdk-1.4.149 → devops_bot_sdk-1.4.151}/sdk/client.py

@@ -37,6 +37,11 @@ from sdk.sse import _check_status, stream_with_reconnect
 
 logger = logging.getLogger(__name__)
 
+# Process-lifetime cache of agent NAME → backend agentId (""=known non-backend).
+# Used by resolve_agent_id so the agent-activity webhook fires only for backend
+# agents without a lookup on every run.
+_AGENT_ID_CACHE: dict[str, str] = {}
+
 # ── Ticket status-change observers ────────────────────────────────────────
 # Best-effort, synchronous hooks fired when the client changes a ticket's backend
 # status (In Progress / Backlog / To Do). The CLI loop registers one to track
@@ -1036,6 +1041,58 @@ class BackendClient:
             logger.warning("client.log_activity error err=%s", exc)
             return False
 
+    async def log_agent_activity(self, activity: str, agent_id: str) -> bool:
+        """POST {ML_GATEWAY_URL}/ml-api/agent-activity — record an agent-activity
+        event for a **backend** agent (body ``{activity, agentId}``). Best-effort;
+        never raises. No-op when ``agent_id`` is empty (local-only agents are not
+        tracked — the backend is the source of truth for agents).
+        """
+        from sdk.config import ML_GATEWAY_URL
+
+        aid = (agent_id or "").strip()
+        if not aid:
+            return False
+        url = f"{ML_GATEWAY_URL.rstrip('/')}/ml-api/agent-activity"
+        headers = {**self._headers, "accept": "*/*", "developer-name": "null", "product": ""}
+        try:
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                resp = await client.post(
+                    url, json={"activity": str(activity), "agentId": aid}, headers=headers,
+                )
+            if resp.status_code >= 400:
+                logger.warning("client.log_agent_activity failed status=%s body=%s",
+                               resp.status_code, resp.text[:200])
+                return False
+            return True
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("client.log_agent_activity error err=%s", exc)
+            return False
+
+    async def resolve_agent_id(self, name: str) -> str | None:
+        """Best-effort backend ``agentId`` for an agent NAME (custom + department).
+
+        Returns None when the name isn't a backend agent (e.g. a local-only manifest)
+        — the caller then skips activity emit, so only backend agents are tracked.
+        Cached per process (the id↔name mapping is stable within a session).
+        """
+        nm = (name or "").strip()
+        if not nm:
+            return None
+        if nm in _AGENT_ID_CACHE:
+            return _AGENT_ID_CACHE[nm] or None
+        rows: list[dict] = []
+        for fetch in (self.list_custom_agents, self.list_department_agents):
+            try:
+                rows += await fetch()
+            except Exception:  # noqa: BLE001 — best-effort across both sources
+                pass
+        for r in rows:
+            if r.get("name") == nm and r.get("id"):
+                _AGENT_ID_CACHE[nm] = str(r["id"])
+                return _AGENT_ID_CACHE[nm]
+        _AGENT_ID_CACHE[nm] = ""     # negative-cache: not a backend agent
+        return None
+
     async def notify_whatsapp(
         self,
         task_id: str,

{devops_bot_sdk-1.4.149 → devops_bot_sdk-1.4.151}/sdk/config.py

@@ -25,7 +25,10 @@ _CONFIG_FILE = _CONFIG_DIR / "config.toml"
 _SENTINEL    = "co_"
 
 AI_DEFAULT_URL = "https://devopsbot-ai.apiswagger.co.uk"
-BE_DEFAULT_URL = "https://devopsbot-be.apiswagger.co.uk"
+# ML backend / gateway — all /ml-api, /tasks-ml, /approvals-ml, agent-activity, etc.
+# now go through the ML gateway (was devopsbot-be.apiswagger.co.uk).
+BE_DEFAULT_URL = "https://gateway-ml.apiswagger.co.uk"
+ML_GATEWAY_URL = "https://gateway-ml.apiswagger.co.uk"
 
 
 # ── Machine-derived Fernet key ────────────────────────────────────────

{devops_bot_sdk-1.4.149 → devops_bot_sdk-1.4.151}/sdk/ui/api.py

@@ -304,6 +304,28 @@ async def logs_stream() -> StreamingResponse:
     )
 
 
+# ── Agent-activity webhook ──────────────────────────────────────────────────
+# Every custom/default agent run/chat records to the LOCAL usage ledger AND emits
+# a `{activity, agentId}` event to the ML gateway (POST /ml-api/agent-activity),
+# which stores it for RBAC-scoped reporting via the chat endpoint. Only agents that
+# exist in the backend (have an agentId) are emitted — local-only agents are skipped.
+# Best-effort: never raises into the run.
+
+async def _emit_agent_activity(name: str, kind: str, result: dict, duration_s: float = 0.0) -> None:
+    try:
+        from sdk.client import BackendClient
+        client = BackendClient.from_config()
+        agent_id = await client.resolve_agent_id(name)
+        if not agent_id:                       # local-only agent → not tracked
+            return
+        verb = "Chatted with" if kind == "chat" else "Ran"
+        status = "ok" if result.get("ok") else "error"
+        detail = f" ({round(duration_s, 1)}s)" if duration_s else ""
+        await client.log_agent_activity(f"{verb} agent '{name}' — {status}{detail}", agent_id)
+    except Exception:  # noqa: BLE001 — activity emit must never break a run
+        pass
+
+
 # ── Agents: catalog, creation, chat, default agents ────────────────────────
 
 @router.get("/connectors", dependencies=[_auth])
@@ -689,12 +711,14 @@ async def agent_chat(body: AgentChatRequest) -> dict:
         started = _time.monotonic()
         result = await _run()
 
+        elapsed = _time.monotonic() - started
         usage_mod.record(
-            name, kind="chat", duration_s=_time.monotonic() - started,
+            name, kind="chat", duration_s=elapsed,
             input_tokens=result.get("input_tokens", 0),
             output_tokens=result.get("output_tokens", 0),
             cost_usd=result.get("cost_usd", 0.0), ok=bool(result.get("ok")),
         )
+        await _emit_agent_activity(name, "chat", result, elapsed)
         return result
 
     # Run detached from this request: navigating away can't kill it. Poll
@@ -732,12 +756,14 @@ async def agent_run(body: AgentRunRequest) -> dict:
         started = _time.monotonic()
         result = await _run()
 
+        elapsed = _time.monotonic() - started
         usage_mod.record(
-            name, kind="run", duration_s=_time.monotonic() - started,
+            name, kind="run", duration_s=elapsed,
             input_tokens=result.get("input_tokens", 0),
             output_tokens=result.get("output_tokens", 0),
             cost_usd=result.get("cost_usd", 0.0), ok=bool(result.get("ok")),
         )
+        await _emit_agent_activity(name, "run", result, elapsed)
         return result
 
     return {"job_id": jobs.start(work())}
@@ -929,6 +955,41 @@ async def _run_prompt_engine(prompt: str) -> str:
     return result.get("result", "") or ""
 
 
+# ── Unified revision format ───────────────────────────────────────────────────
+# Missing / empty required fields → HTTP 422 (Pydantic on the request model,
+# unchanged). When the inputs are PRESENT but need human revision (offensive /
+# meaningless input, or a prompt missing required sections) EVERY endpoint returns
+# the SAME shape — all messages collected into one ``ai_comments`` list:
+#   {"status": "needs_revision", "engine": "claude_code",
+#    "ai_comments": ["<message>", "<message>", ...]}
+# Success responses carry status="ok" and ai_comments=[] so the client always reads
+# the same two fields.
+
+def _needs_revision(ai_comments: list[str]) -> dict:
+    """The single revision envelope used by every agent-prompt endpoint."""
+    return {"status": "needs_revision", "engine": "claude_code", "ai_comments": ai_comments}
+
+
+async def _screen_agent_inputs(agent_name: str, agent_type: str, job: str) -> list[str]:
+    """LLM screen for offensive / meaningless inputs → list of comment messages
+    (empty when the inputs are fine).
+
+    FAIL-OPEN: any engine/parse error → ``[]`` (proceed), so a validator hiccup
+    never blocks a legitimate request.
+    """
+    from sdk.agents.prompt_studio import build_validate_inputs_prompt, parse_validation
+
+    try:
+        verdict = parse_validation(
+            await _run_prompt_engine(build_validate_inputs_prompt(agent_name, agent_type, job))
+        )
+    except Exception:  # noqa: BLE001 — fail-open
+        return []
+    if verdict.get("valid", True):
+        return []
+    return [str(msg).strip() for msg in (verdict.get("issues") or {}).values() if str(msg or "").strip()]
+
+
 @router.post("/agent-prompt/generate", dependencies=[_auth])
 async def agent_prompt_generate(body: AgentPromptGenerateRequest) -> dict:
     """name + type + job → a structured system prompt + {{variables}} (claude_code).
@@ -938,17 +999,24 @@ async def agent_prompt_generate(body: AgentPromptGenerateRequest) -> dict:
     """
     from sdk.agents.prompt_studio import build_generate_prompt, parse_generation
 
+    # Empty agent_name/agent_type/job already 422'd by the request model.
     agent_name = body.agent_name
     agent_type = body.agent_type
     job = body.job
 
+    # Semantic screen (offensive / meaningless) → unified needs_revision. Fail-open.
+    comments = await _screen_agent_inputs(agent_name, agent_type, job)
+    if comments:
+        return _needs_revision(comments)
+
     text = await _run_prompt_engine(
         build_generate_prompt(agent_name, agent_type, job, body.context)
     )
     parsed = parse_generation(text)
     if not parsed["system_prompt"]:
         raise HTTPException(status_code=502, detail="generation returned no system_prompt")
-    return {"agent_name": agent_name, "agent_type": agent_type, "engine": "claude_code", **parsed}
+    return {"status": "ok", "engine": "claude_code", "ai_comments": [],
+            "agent_name": agent_name, "agent_type": agent_type, **parsed}
 
 
 @router.post("/agent-prompt/regenerate", dependencies=[_auth])
@@ -960,6 +1028,12 @@ async def agent_prompt_regenerate(body: PromptRegenerateRequest) -> dict:
     """
     from sdk.agents.prompt_studio import build_regenerate_prompt, parse_generation
 
+    # Empty system_prompt already 422'd by the request model. Screen the agent
+    # metadata (blank fields ignored by the screener; fail-open).
+    comments = await _screen_agent_inputs(body.agent_name, body.agent_type, body.job)
+    if comments:
+        return _needs_revision(comments)
+
     text = await _run_prompt_engine(build_regenerate_prompt(
         body.system_prompt, body.feedback,
         body.agent_name, body.agent_type, body.job,
@@ -967,9 +1041,8 @@ async def agent_prompt_regenerate(body: PromptRegenerateRequest) -> dict:
     parsed = parse_generation(text)
     if not parsed["system_prompt"]:
         raise HTTPException(status_code=502, detail="regeneration returned no system_prompt")
-    return {"agent_name": body.agent_name,
-            "agent_type": body.agent_type,
-            "engine": "claude_code", **parsed}
+    return {"status": "ok", "engine": "claude_code", "ai_comments": [],
+            "agent_name": body.agent_name, "agent_type": body.agent_type, **parsed}
 
 
 @router.post("/agent-prompt/verify", dependencies=[_auth])
@@ -985,6 +1058,7 @@ async def agent_prompt_verify(body: PromptVerifyRequest) -> dict:
     from sdk.agents.prompt_template import check_system_prompt
     from sdk.agents.prompt_vars import extract_variables
 
+    # Too-short system_prompt already 422'd by the request model.
     system_prompt = body.system_prompt
 
     standards = check_system_prompt(system_prompt)
@@ -1008,13 +1082,21 @@ async def agent_prompt_verify(body: PromptVerifyRequest) -> dict:
             "type": str(m.get("type", "string")).strip() or "string",
         })
 
+    # Structural gaps → the SAME unified ai_comments list (all messages together).
+    ai_comments = (
+        [f"Missing required section: {s}." for s in standards["missing_required"]]
+        + [f"Recommended section missing: {s}." for s in standards["missing_recommended"]]
+    )
+
     return {
+        "status": "needs_revision" if standards["missing_required"] else "ok",
+        "engine": "claude_code",
+        "ai_comments": ai_comments,
         "valid": not standards["missing_required"],
         "missing_required": standards["missing_required"],
         "missing_recommended": standards["missing_recommended"],
         "variables": variables,
         "secrets": analysis.get("secrets", []),
-        "engine": "claude_code",
     }
 
 

{devops_bot_sdk-1.4.149 → devops_bot_sdk-1.4.151}/sdk/updater.py

@@ -132,10 +132,10 @@ def _ml_api_base() -> str:
     try:
         from sdk.config import get_base_url
         base = get_base_url()
-        # devopsbot-ai.apiswagger.co.uk  →  devopsbot-be.apiswagger.co.uk
-        return base.replace("devopsbot-ai", "devopsbot-be")
+        # devopsbot-ai.apiswagger.co.uk  →  gateway-ml.apiswagger.co.uk
+        return base.replace("devopsbot-ai.apiswagger.co.uk", "gateway-ml.apiswagger.co.uk")
     except Exception:  # noqa: BLE001
-        return "https://devopsbot-be.apiswagger.co.uk"
+        return "https://gateway-ml.apiswagger.co.uk"
 
 
 def _env_github_token() -> str | None: