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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.4.149
+Version: 1.4.150
 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.150}/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.150
 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.150}/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.150
 
 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.150"   # 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.150}/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.150}/sdk/ui/api.py

@@ -929,6 +929,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 +973,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 +1002,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 +1015,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 +1032,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 +1056,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",
     }