devops-bot-sdk 1.6.4__tar.gz → 1.6.6__tar.gz

{devops_bot_sdk-1.6.4 → devops_bot_sdk-1.6.6}/PKG-INFO

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

{devops_bot_sdk-1.6.4 → devops_bot_sdk-1.6.6}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.6.4 → devops_bot_sdk-1.6.6}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.6.4
+Version: 1.6.6
 
 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.6.4"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
+__version__ = "1.6.6"   # 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.6.4 → devops_bot_sdk-1.6.6}/sdk/agentd.py

@@ -543,7 +543,7 @@ class AgentDaemon:
         validate) is logged and skipped — it must never prevent PERSONAL
         agents from loading.
         """
-        from sdk.agents.manifest import AgentManifest
+        from sdk.agents.manifest import manifest_from_backend_row
 
         try:
             rows = await self.client.list_department_agents()
@@ -555,13 +555,15 @@ class AgentDaemon:
         for row in rows:
             if row.get("status") != "active":
                 continue
-            try:
-                manifests.append(AgentManifest(**row["manifest"]))
-            except Exception as exc:  # noqa: BLE001
+            # Prompt-based rows: the `manifest` column this used to read was
+            # dropped from the table, so every row raised KeyError here.
+            manifest = manifest_from_backend_row(row)
+            if manifest is None:
                 logger.warning(
-                    "agentd.department_agent_manifest_invalid name=%s err=%s",
-                    row.get("name"), exc,
+                    "agentd.department_agent_not_runnable name=%s", row.get("name"),
                 )
+                continue
+            manifests.append(manifest)
         return manifests
 
     async def watch_tickets(self) -> None:

{devops_bot_sdk-1.6.4 → devops_bot_sdk-1.6.6}/sdk/agents/chat.py

@@ -41,14 +41,60 @@ def _tee_events(log_path, on_event: "EventHandler | None") -> "EventHandler":
 EventHandler = Callable[[dict], Awaitable[None]]
 
 
-def _find_agent(name: str) -> AgentManifest:
-    match = next((m for m in load_agents() if m.name == name), None)
-    if match is None:
-        raise LookupError(
-            f"no local agent named '{name}' — install it first "
-            f"(agentos agent add / default-agents activate)"
-        )
-    return match
+def _find_agent(name: str) -> AgentManifest | None:
+    """A LOCAL manifest by name (``~/.agentos/agents``), or None."""
+    return next((m for m in load_agents() if m.name == name), None)
+
+
+async def resolve_agent(name: str, client=None) -> AgentManifest:
+    """Find the agent to run: local manifest → your backend agents → department.
+
+    The BACKEND is where agents live now — they are authored in the web app, and
+    nothing writes ``~/.agentos/agents`` anymore. Resolving only locally meant
+    every agent the UI could list was unrunnable ("no local agent named …"), for
+    department defaults as much as personal ones. A local manifest still wins when
+    present, so a hand-written one keeps overriding its backend namesake.
+
+    ``client`` lets a caller that already has one pass it in rather than having a
+    second one built here behind its back.
+
+    Raises ``LookupError`` naming every place that was checked and why.
+    """
+    local = _find_agent(name)
+    if local is not None:
+        return local
+
+    from sdk.agents.manifest import manifest_from_backend_row
+
+    if client is None:
+        from sdk.client import BackendClient
+        client = BackendClient.from_config()
+
+    reasons: list[str] = []
+    for label, attr in (("your agents", "list_custom_agents"),
+                        ("department defaults", "list_department_agents")):
+        fetch = getattr(client, attr, None)
+        if fetch is None:
+            continue
+        try:
+            rows = await fetch() or []
+        except Exception as exc:  # noqa: BLE001 — a fetch failure is not "not found"
+            reasons.append(f"{label} could not be fetched ({str(exc) or type(exc).__name__})")
+            continue
+        for row in rows:
+            if row.get("name") == name:
+                manifest = manifest_from_backend_row(row)
+                if manifest is not None:
+                    return manifest
+                reasons.append(
+                    f"'{name}' is in your {label} but its prompt is empty, so there "
+                    f"is no instruction to run — add one in the web app"
+                )
+
+    detail = "; ".join(reasons) if reasons else (
+        "not in ~/.agentos/agents/, your backend agents, or your department defaults"
+    )
+    raise LookupError(f"no agent named '{name}' — {detail}")
 
 
 def _render_conversation(history: list[dict] | None, message: str) -> str:
@@ -87,7 +133,7 @@ async def chat_with_agent(
     ``files_changed``, ``error``). ``claude_code``/``model`` engines run through
     the local Claude executor; ``shell`` runs the composed prompt as a command.
     """
-    manifest = _find_agent(name)
+    manifest = await resolve_agent(name)
 
     skills = load_skills()
     skill_text = resolve_skill_text(manifest, skills)
@@ -164,7 +210,7 @@ async def run_agent(
     ``{{variable}}`` is left unfilled — the UI gates the Run button on this, and
     this is the server-side backstop.
     """
-    manifest = _find_agent(name)
+    manifest = await resolve_agent(name)
 
     skills = load_skills()
     skill_text = resolve_skill_text(manifest, skills)

{devops_bot_sdk-1.6.4 → devops_bot_sdk-1.6.6}/sdk/agents/manifest.py

@@ -23,8 +23,14 @@ INTEGRATIONS_DIR = Path.home() / ".agentos" / "integrations"
 # Full-string match: ${ENV_VAR_NAME} — no inline secrets allowed in integration env.
 _ENV_PLACEHOLDER_RE = re.compile(r"^\$\{[A-Za-z_][A-Za-z0-9_]*\}$")
 
-# Agent names: letters, digits, hyphen, underscore only.
-_AGENT_NAME_RE = re.compile(r"^[A-Za-z0-9_-]+$")
+# Agent names. Agents are authored in the WEB APP now, where names are free text
+# — "AI Research Agent", "Jira & Confluence Project Management Agent". A rule of
+# `[A-Za-z0-9_-]+` rejected every one of them, so a backend agent could not be
+# materialized into a manifest and therefore could not be run at all. Spaces and
+# ordinary punctuation are allowed; what stays banned is anything that could
+# escape a path or break a log line, since the name is used to derive filenames
+# (see agents/secrets.py, varstore.py, run_log.py — all of which sanitize too).
+_AGENT_NAME_RE = re.compile(r"^[^\x00-\x1f/\\<>:\"|?*]+$")
 
 # Flags an inline secret like `token: abc123...` in free-text fields while
 # allowing the ${ENV_VAR} placeholder form. Mirrors the backend
@@ -210,6 +216,57 @@ def assert_secret_free(obj: object, _where: str = "payload") -> None:
             )
 
 
+def manifest_from_backend_row(row: dict) -> AgentManifest | None:
+    """Materialize a runnable manifest from a backend prompt-based ``agents`` row.
+
+    Agents are authored in the web app, so the row — not a local YAML file — is
+    what the engine has to run. The row shape (docs/DATABASE_SCHEMA.md §4) is
+    ``{name, status, prompt: {system_prompt, variables:[…]}, skills:[{name,
+    description, …}]}``; there is no ``engine``/``trigger``/``manifest`` column
+    anymore, so those are supplied here:
+
+      * ``engine="claude_code"`` — the only engine a web-app agent targets.
+      * ``trigger=manual`` — the row carries no trigger; scheduled and
+        ticket-label dispatch stay a local-manifest feature.
+
+    Each attached skill's description is folded into the prompt rather than left
+    in ``manifest.skills``: skill names on the row refer to backend ``skills``
+    rows, which ``resolve_skill_text`` (local ``~/.agentos/skills``) would drop as
+    dangling references, silently losing the instruction text.
+
+    Returns ``None`` if the row cannot make a valid manifest (no name, or an empty
+    / too-short prompt), so a malformed row is skipped rather than raising.
+    """
+    name = str((row or {}).get("name") or "").strip()
+    if not name:
+        return None
+
+    prompt_obj = row.get("prompt") or {}
+    if not isinstance(prompt_obj, dict):
+        prompt_obj = {}
+    prompt = str(prompt_obj.get("system_prompt") or "").strip()
+
+    for skill in row.get("skills") or []:
+        if not isinstance(skill, dict):
+            continue
+        s_name = str(skill.get("name") or "").strip()
+        s_body = str(skill.get("description") or "").strip()
+        if s_name and s_body:
+            prompt = f"{prompt}\n\n## Skill: {s_name}\n\n{s_body}"
+
+    try:
+        return AgentManifest(
+            name=name,
+            description=prompt[:200],
+            engine="claude_code",
+            trigger=TriggerSpec(type="manual"),
+            prompt=prompt,
+        )
+    except ValidationError as exc:
+        logger.warning("backend agent '%s' is not runnable: %s", name, exc)
+        return None
+
+
 def load_agents(dir: Path = AGENTS_DIR) -> list[AgentManifest]:
     """Load every agent manifest under `dir`.
 

{devops_bot_sdk-1.6.4 → devops_bot_sdk-1.6.6}/sdk/agents/secrets.py

@@ -34,7 +34,15 @@ SECRETS_DIR = Path.home() / ".agentos" / "agent_secrets"
 
 
 def _path(agent_name: str) -> Path:
-    return SECRETS_DIR / f"{agent_name}.json.enc"
+    """Store file for an agent's keys.
+
+    The name is sanitized because agent names are free text from the web app now
+    ("Jira & Confluence Project Management Agent") — an unsanitized name
+    containing a path separator would resolve outside SECRETS_DIR. Mirrors
+    ``varstore._path`` so the two stores key the same way.
+    """
+    safe = "".join(c for c in (agent_name or "") if c.isalnum() or c in "-_") or "agent"
+    return SECRETS_DIR / f"{safe}.json.enc"
 
 
 def load_secrets(agent_name: str) -> dict[str, str]:

{devops_bot_sdk-1.6.4 → devops_bot_sdk-1.6.6}/sdk/agents/ticket_run.py

@@ -25,15 +25,19 @@ async def resolve_manifest(
 ) -> "AgentManifest | None":
     """Find the agent manifest to run, by ``scope``.
 
-    * ``custom`` (default) — a personal agent from the local manifests
-      (``~/.agentos/agents``).
     * ``department`` — an ACTIVE department default pulled from the backend
-      (``list_department_agents``), materialized read-only (never written back),
-      exactly as ``agentd._load_department_agents`` does.
+      (``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``.
 
-    Returns None when no matching agent is found.
+    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.
     """
-    from sdk.agents.manifest import AgentManifest, load_agents
+    from sdk.agents.chat import resolve_agent
+    from sdk.agents.manifest import manifest_from_backend_row
 
     name = (name or "").strip()
     if scope == "department":
@@ -43,16 +47,13 @@ async def resolve_manifest(
             return None
         for row in rows:
             if row.get("name") == name and row.get("status") == "active":
-                try:
-                    return AgentManifest(**row["manifest"])
-                except Exception:  # noqa: BLE001 — invalid manifest → not runnable
-                    return None
+                return manifest_from_backend_row(row)
         return None
 
-    for m in load_agents():
-        if m.name == name:
-            return m
-    return None
+    try:
+        return await resolve_agent(name, client)
+    except LookupError:
+        return None
 
 
 async def run_on_ticket(

{devops_bot_sdk-1.6.4 → devops_bot_sdk-1.6.6}/sdk/cli.py

@@ -333,35 +333,27 @@ def _agent_run_ticket(name: str, flags: list[str]) -> None:
 
 
 def _agent_run(name: str) -> None:
-    from sdk.agents.manifest import AgentManifest, load_agents
+    """`agentos agent run NAME` — dispatch one run locally.
+
+    Resolution order is shared with the UI and `agent chat` (see
+    ``sdk.agents.chat.resolve_agent``): a local manifest wins, then the caller's
+    own backend agents, then their department defaults. It used to check local
+    manifests and department rows only — and read a `manifest` column the
+    prompt-based `agents` table no longer has — so nothing authored in the web app
+    could be run.
+    """
+    from sdk.agents.chat import resolve_agent
     from sdk.client import BackendClient
     from sdk import agentd
 
     client = BackendClient.from_config()
-
-    matched = next((m for m in load_agents() if m.name == name), None)
-    if matched is not None:
-        asyncio.run(agentd._dispatch_agent_run(matched, client))
-        return
-
-    # Not a local personal agent -- check this user's department defaults
-    # (read-only, pulled from the backend; see AgentDaemon._load_department_agents).
     try:
-        dept_row = next(
-            (r for r in asyncio.run(client.list_department_agents()) if r.get("name") == name),
-            None,
-        )
-    except Exception as exc:  # noqa: BLE001
-        print(f"error: could not fetch department agents ({exc})")
-        sys.exit(1)
-
-    if dept_row is None:
-        print(f"error: no agent named '{name}' (checked ~/.agentos/agents/ and "
-              f"this user's department default agents)")
+        manifest = asyncio.run(resolve_agent(name, client))
+    except LookupError as exc:
+        print(f"error: {exc}")
         sys.exit(1)
 
-    dept_manifest = AgentManifest(**dept_row["manifest"])
-    asyncio.run(agentd._dispatch_agent_run(dept_manifest, client))
+    asyncio.run(agentd._dispatch_agent_run(manifest, client))
 
 
 def _agent_logs(name: str) -> None:

{devops_bot_sdk-1.6.4 → devops_bot_sdk-1.6.6}/tests/test_agent_run_ticket.py

@@ -110,42 +110,84 @@ async def test_policy_always_without_auto_approve_waits_for_human():
 # ── ticket_run helper ───────────────────────────────────────────────────────
 
 class _ResolveClient:
-    def __init__(self, dept_rows=None, tasks=None):
+    def __init__(self, dept_rows=None, tasks=None, custom_rows=None):
         self._dept = dept_rows or []
+        self._custom = custom_rows or []
         self._tasks = tasks or []
 
     async def list_department_agents(self):
         return self._dept
 
+    async def list_custom_agents(self):
+        return self._custom
+
     async def list_tasks_by_keys(self, keys):
         return self._tasks
 
 
+def _row(name, prompt="Extract the latest AI news and summarize it.", status="active",
+         skills=()):
+    """A backend prompt-based ``agents`` row (docs/DATABASE_SCHEMA.md §4).
+
+    There is no ``manifest`` column — it was dropped in the prompt-based
+    migration, which is why reading one made every backend agent unrunnable.
+    """
+    return {"name": name, "status": status,
+            "prompt": {"system_prompt": prompt, "variables": []},
+            "skills": [{"name": n, "description": d} for n, d in skills]}
+
+
 @pytest.mark.asyncio
-async def test_resolve_manifest_custom():
+async def test_resolve_manifest_custom_prefers_local_then_backend():
     m = _stub_manifest()
-    with patch("sdk.agents.manifest.load_agents", return_value=[m]):
+    # A local manifest wins. chat._find_agent binds load_agents at import, so
+    # patch the name the resolver actually calls.
+    with patch("sdk.agents.chat.load_agents", return_value=[m]):
         got = await ticket_run.resolve_manifest(_ResolveClient(), "Tix", scope="custom")
     assert got is m
-    with patch("sdk.agents.manifest.load_agents", return_value=[]):
+
+    # No local manifest → the caller's own backend agents are used.
+    with patch("sdk.agents.chat.load_agents", return_value=[]):
+        client = _ResolveClient(custom_rows=[_row("AI Research Agent")])
+        got = await ticket_run.resolve_manifest(client, "AI Research Agent", scope="custom")
+        assert got is not None and got.name == "AI Research Agent"
+        assert got.engine == "claude_code" and got.trigger.type == "manual"
+
         assert await ticket_run.resolve_manifest(_ResolveClient(), "Nope") is None
 
 
 @pytest.mark.asyncio
 async def test_resolve_manifest_department_active_only():
-    rows = [
-        {"name": "DeptA", "status": "inactive", "manifest": {}},
-        {"name": "DeptA", "status": "active",
-         "manifest": {"name": "DeptA", "prompt": "p", "engine": "claude_code"}},
-    ]
-    client = _ResolveClient(dept_rows=rows)
-    # resolve_manifest does `from sdk.agents.manifest import AgentManifest` at call
-    # time, so patch it on that module; build a stand-in from the manifest dict.
-    with patch("sdk.agents.manifest.AgentManifest", side_effect=lambda **kw: SimpleNamespace(**kw)):
-        got = await ticket_run.resolve_manifest(client, "DeptA", scope="department")
+    rows = [_row("DeptA", status="inactive"), _row("DeptA", status="active")]
+    got = await ticket_run.resolve_manifest(
+        _ResolveClient(dept_rows=rows), "DeptA", scope="department")
     assert got is not None and got.name == "DeptA"
 
 
+@pytest.mark.asyncio
+async def test_resolve_manifest_department_with_empty_prompt_is_not_runnable():
+    """Every department row on the live DB has an empty system_prompt — there is
+    no instruction to execute, so it must not resolve to a bogus manifest."""
+    rows = [_row("Model QA Specialist", prompt="")]
+    got = await ticket_run.resolve_manifest(
+        _ResolveClient(dept_rows=rows), "Model QA Specialist", scope="department")
+    assert got is None
+
+
+@pytest.mark.asyncio
+async def test_backend_skills_are_folded_into_the_prompt():
+    """Skill names on a row point at BACKEND skills rows; left in manifest.skills
+    they would be dropped as dangling local references, losing the text."""
+    client = _ResolveClient(custom_rows=[
+        _row("Researcher", skills=(("web-search", "Search the web for sources."),))])
+    with patch("sdk.agents.chat.load_agents", return_value=[]):
+        got = await ticket_run.resolve_manifest(client, "Researcher", scope="custom")
+    assert got is not None
+    assert "## Skill: web-search" in got.prompt
+    assert "Search the web for sources." in got.prompt
+    assert got.skills == []
+
+
 @pytest.mark.asyncio
 async def test_run_on_ticket_missing_ticket_raises():
     client = _ResolveClient(tasks=[])

{devops_bot_sdk-1.6.4 → devops_bot_sdk-1.6.6}/tests/test_agents_connectors_builder.py

@@ -257,9 +257,23 @@ def test_build_agent_enforce_template_flag():
 
 
 def test_chat_module_finds_missing_agent():
-    from sdk.agents.chat import _find_agent
+    """_find_agent is LOCAL-only and returns None; resolve_agent raises after it
+    has also checked the backend (that is where agents live now)."""
+    import asyncio
+
+    from sdk.agents.chat import _find_agent, resolve_agent
+
+    assert _find_agent("no-such-agent-xyz") is None
+
+    class _NoAgents:
+        async def list_custom_agents(self):
+            return []
+
+        async def list_department_agents(self):
+            return []
+
     with pytest.raises(LookupError):
-        _find_agent("no-such-agent-xyz")
+        asyncio.run(resolve_agent("no-such-agent-xyz", _NoAgents()))
 
 
 def test_save_agent_writes_manifest(tmp_path, monkeypatch):