devops-bot-sdk 1.4.118__tar.gz → 1.4.119__tar.gz

{devops_bot_sdk-1.4.118 → devops_bot_sdk-1.4.119}/PKG-INFO

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

{devops_bot_sdk-1.4.118 → devops_bot_sdk-1.4.119}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.4.118 → devops_bot_sdk-1.4.119}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -79,7 +79,6 @@ sdk/ui/static/app.js
 sdk/ui/static/custom-agents.html
 sdk/ui/static/default-agents.html
 sdk/ui/static/index.html
-sdk/ui/static/prompt-studio.html
 sdk/ui/static/runs.html
 sdk/ui/static/setup.html
 sdk/ui/static/styles.css

{devops_bot_sdk-1.4.118 → devops_bot_sdk-1.4.119}/sdk/__init__.py

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

@@ -15,9 +15,9 @@ See docs/GUIDE_2_Development_Plan_Custom_Agents.md:
     ``sdk/run_auto.py`` (which only ever drives the Jira To-Do queue) into a
     general-purpose daemon with five components:
         1. manifest loader     — ``sdk.agents.manifest.load_agents()``
-        2. registration        — push every loaded PERSONAL manifest to the
-                                  backend (``BackendClient.register_custom_agent``)
-                                  so dashboards/routing stay in sync
+        2. (removed) registration — the daemon no longer pushes local manifests to
+                                  the backend; agents are authored in the web app
+                                  and the SDK is consume-only (local trigger/run).
         3. department pull     — fetch this user's DEPARTMENT default agents
                                   (``BackendClient.list_department_agents()``)
                                   and materialize them alongside personal
@@ -451,12 +451,11 @@ class AgentDaemon:
         department = await self._load_department_agents()
         self._manifests = personal + department
 
+        # Consume-only: the daemon no longer registers/pushes local manifests to
+        # the backend — agents are authored in the web app and written to the
+        # `agents` table. The daemon just schedules + runs them LOCALLY on trigger.
         for m in personal:
             self._schedule_if_cron(m, job_id=m.name)
-            try:
-                await self.client.register_custom_agent(m.model_dump(mode="json"))
-            except Exception as exc:  # noqa: BLE001 — registration is best-effort
-                logger.warning("agentd.register_failed agent=%s err=%s", m.name, exc)
 
         for m in department:
             # "dept:" job-id prefix avoids colliding with a personal agent

{devops_bot_sdk-1.4.118 → devops_bot_sdk-1.4.119}/sdk/cli.py

@@ -104,10 +104,10 @@ def _print_usage() -> None:
     print("usage: agentos <configure|agent|integration|default-agents|agentd> ...")
     print()
     print("  agentos configure [--rotate]")
-    print("  agentos agent <new|add PATH|list|run NAME|chat NAME MSG|logs NAME|enable NAME|disable NAME|rm NAME>")
+    print("  agentos agent <list|run NAME|chat NAME MSG|logs NAME|enable NAME|disable NAME|rm NAME>")
     print("  agentos agent <set-key NAME KEY[=VALUE]…|keys NAME|rm-key NAME KEY…>   # persistent API keys (custom agents)")
     print("  agentos integration <add PATH|test NAME|list|rm NAME>")
-    print("  agentos default-agents <list|activate NAME|seed PATH|seed-library [SLUG]|enable NAME|disable NAME|rm NAME> [--department-id UUID]")
+    print("  agentos default-agents list [--department-id UUID]   # read-only; agents are created in the web app")
     print("  agentos agentd <start [--foreground]|status>")
 
 
@@ -117,11 +117,13 @@ def _agent_command(args: list[str]) -> None:
     verb = args[0] if args else None
     rest = args[1:]
 
-    if verb == "new":
-        _agent_new()
-        return
-    if verb == "add" and rest:
-        _agent_add(rest[0])
+    # Agent CREATION (`new` / `add`) is not owned by the SDK anymore — agents are
+    # authored in the web app and written to the backend `agents` table. The CLI is
+    # consume-only: list / run / chat / logs / enable / disable / rm / keys.
+    if verb in ("new", "add"):
+        print("`agentos agent new/add` has been removed — agents are created in the "
+              "web app now. Use `agentos agent list` to see yours and `agentos agent "
+              "run <name>` to run one.")
         return
     if verb == "list":
         _agent_list()
@@ -132,10 +134,6 @@ def _agent_command(args: list[str]) -> None:
     if verb == "chat" and len(rest) >= 2:
         _agent_chat(rest[0], " ".join(rest[1:]))
         return
-    if verb == "template":
-        from sdk.agents.prompt_template import render_system_prompt
-        print(render_system_prompt(name=(rest[0] if rest else "my-agent")))
-        return
     if verb == "logs" and rest:
         _agent_logs(rest[0])
         return
@@ -183,80 +181,6 @@ def _agent_chat(name: str, message: str) -> None:
         sys.exit(1)
 
 
-def _register_agent(manifest) -> None:
-    """Register a validated manifest with the backend — shared by `new` and `add`."""
-    from sdk.client import BackendClient
-
-    resp = asyncio.run(
-        BackendClient.from_config().register_custom_agent(manifest.model_dump(mode="json"))
-    )
-    resp = resp or {}
-    agent_id = resp.get("id") or resp.get("agent_id")
-    status = resp.get("status")
-    print(f"registered '{manifest.name}' with backend — id={agent_id} status={status}")
-
-
-def _agent_new() -> None:
-    from sdk.agents.manifest import AGENTS_DIR, AgentManifest, TriggerSpec
-
-    print("AgentOS — New Agent")
-    print("=" * 40)
-    name = input("Name: ").strip()
-    description = input("Description: ").strip()
-    engine = input("Engine [claude_code]: ").strip() or "claude_code"
-    trigger_type = input("Trigger type (schedule/ticket_label/manual/webhook): ").strip()
-
-    trigger_kwargs: dict = {"type": trigger_type}
-    if trigger_type == "schedule":
-        trigger_kwargs["cron"] = input("Cron string: ").strip()
-    elif trigger_type == "ticket_label":
-        trigger_kwargs["ticket_label"] = input("Ticket label: ").strip()
-    # manual / webhook need no extra prompt
-
-    prompt_text = input("Prompt: ").strip()
-
-    try:
-        trigger = TriggerSpec(**trigger_kwargs)
-        manifest = AgentManifest(
-            name=name,
-            description=description,
-            engine=engine,
-            trigger=trigger,
-            prompt=prompt_text,
-        )
-    except Exception as exc:  # noqa: BLE001 — surface pydantic's validation message plainly
-        print(f"error: invalid agent — {exc}")
-        sys.exit(1)
-
-    AGENTS_DIR.mkdir(parents=True, exist_ok=True)
-    dest = AGENTS_DIR / f"{manifest.name}.yaml"
-    dest.write_text(yaml.safe_dump(manifest.model_dump(mode="json"), sort_keys=False))
-    print(f"saved manifest to {dest}")
-
-    _register_agent(manifest)
-
-
-def _agent_add(path: str) -> None:
-    from sdk.agents.manifest import AGENTS_DIR, AgentManifest
-
-    src = Path(path).expanduser()
-    try:
-        raw_text = src.read_text()
-        data = yaml.safe_load(raw_text) or {}
-        manifest = AgentManifest(**data)
-    except Exception as exc:  # noqa: BLE001 — surface a clear validation/IO error
-        print(f"error: invalid agent manifest '{path}' — {exc}")
-        sys.exit(1)
-
-    AGENTS_DIR.mkdir(parents=True, exist_ok=True)
-    dest = AGENTS_DIR / f"{manifest.name}.yaml"
-    if dest.resolve() != src.resolve():
-        dest.write_text(raw_text)
-        print(f"copied manifest to {dest}")
-
-    _register_agent(manifest)
-
-
 def _agent_list() -> None:
     from sdk.agents.manifest import load_agents
     from sdk.client import BackendClient
@@ -543,201 +467,39 @@ def _default_agents_command(args: list[str]) -> None:
     if verb == "list":
         _default_agents_list(_resolve_department_id(dept_id))
         return
-    if verb == "activate" and tail:
-        _default_agents_activate(_resolve_department_id(dept_id), tail[0])
-        return
-    # ── manager verbs (team_lead+ of the department) ──
-    # Gated client-side by role (employees are refused); the backend also enforces.
-    if verb == "seed" and tail:
-        _require_department_manager(verb)
-        _default_agents_seed(_resolve_department_id(dept_id), tail)
-        return
-    if verb == "seed-library":
-        _require_department_manager(verb)
-        _default_agents_seed_library(_resolve_department_id(dept_id), tail)
-        return
-    if verb in ("enable", "disable") and tail:
-        _require_department_manager(verb)
-        _default_agents_set_status(
-            _resolve_department_id(dept_id), tail[0],
-            "active" if verb == "enable" else "disabled",
-        )
-        return
-    if verb == "rm" and tail:
-        _require_department_manager(verb)
-        _default_agents_rm(_resolve_department_id(dept_id), tail[0])
+
+    # Seeding / activating / managing department defaults is not owned by the SDK
+    # anymore — agents are authored in the web app and written to the backend
+    # `agents` table. The CLI is consume-only.
+    if verb in ("seed", "seed-library", "activate", "enable", "disable", "rm"):
+        print(f"`agentos default-agents {verb}` has been removed — department default "
+              "agents are managed in the web app now. Use `agentos default-agents list`.")
         return
 
-    print(
-        "usage: agentos default-agents "
-        "<list|activate NAME|seed PATH|seed-library [SLUG]|enable NAME|disable NAME|rm NAME> "
-        "[--department-id UUID]"
-    )
-    print("  (seed/enable/disable/rm require department-manager rights)")
+    print("usage: agentos default-agents list [--department-id UUID]")
     sys.exit(1)
 
 
-def _default_agents_seed(department_id: str, tail: list[str]) -> None:
-    """Create/update ONE department default from a manifest YAML (manager only).
-
-    Flags: --min-role-tier TIER, --sort-order N, --system.
-    """
-    import yaml
-
-    path = tail[0]
-    min_tier, sort_order, is_system = "employee", 0, False
-    i = 1
-    while i < len(tail):
-        if tail[i] == "--min-role-tier" and i + 1 < len(tail):
-            min_tier = tail[i + 1]; i += 2; continue
-        if tail[i] == "--sort-order" and i + 1 < len(tail):
-            sort_order = int(tail[i + 1]); i += 2; continue
-        if tail[i] == "--system":
-            is_system = True; i += 1; continue
-        i += 1
-
-    from sdk.agents.manifest import AgentManifest
-    from sdk.client import BackendClient
-
-    try:
-        raw = yaml.safe_load(Path(path).expanduser().read_text()) or {}
-        AgentManifest(**raw)  # validate before sending
-    except Exception as exc:  # noqa: BLE001
-        print(f"error: invalid manifest '{path}' — {exc}")
-        sys.exit(1)
-
-    payload = {
-        "manifest": raw,
-        "min_role_tier": min_tier,
-        "is_system_default": is_system,
-        "sort_order": sort_order,
-    }
-    try:
-        result = asyncio.run(
-            BackendClient.from_config().seed_department_default_agent(department_id, payload)
-        )
-    except Exception as exc:  # noqa: BLE001 — surface 403 (not a manager) clearly
-        print(f"error: {exc}")
-        sys.exit(1)
-    print(f"seeded default agent '{raw.get('name')}' into department {department_id} "
-          f"(id={result.get('agent_id')})")
-
-
-def _default_agents_seed_library(department_id: str, tail: list[str]) -> None:
-    """Seed a whole department's bundled library (manager only). SLUG defaults to 'developers'."""
-    from sdk.agents.library import load_department
-    from sdk.client import BackendClient
-
-    slug = tail[0] if tail else "developers"
-    try:
-        templates = load_department(slug)
-    except KeyError:
-        print(f"error: no library department '{slug}'")
-        sys.exit(1)
-
-    client = BackendClient.from_config()
-    ok = 0
-    for t in templates:
-        payload = {
-            "manifest": t.manifest.model_dump(mode="json"),
-            "min_role_tier": t.min_role_tier,
-            "is_system_default": t.is_system_default,
-            "sort_order": t.sort_order,
-        }
-        try:
-            asyncio.run(client.seed_department_default_agent(department_id, payload))
-            print(f"  seeded {t.manifest.name}")
-            ok += 1
-        except Exception as exc:  # noqa: BLE001
-            print(f"  FAILED {t.manifest.name}: {exc}", file=sys.stderr)
-    print(f"seeded {ok}/{len(templates)} '{slug}' agents into department {department_id}")
-
-
-def _default_agents_set_status(department_id: str, name: str, status: str) -> None:
-    from sdk.client import BackendClient
-    try:
-        asyncio.run(
-            BackendClient.from_config().update_department_default_agent(
-                department_id, name, status
-            )
-        )
-    except Exception as exc:  # noqa: BLE001
-        print(f"error: {exc}")
-        sys.exit(1)
-    print(f"default agent '{name}' set to {status}")
-
-
-def _default_agents_rm(department_id: str, name: str) -> None:
-    from sdk.client import BackendClient
-    try:
-        asyncio.run(
-            BackendClient.from_config().delete_department_default_agent(department_id, name)
-        )
-    except Exception as exc:  # noqa: BLE001
-        print(f"error: {exc}")
-        sys.exit(1)
-    print(f"deleted default agent '{name}' from department {department_id}")
-
-
 def _default_agents_list(department_id: str) -> None:
+    """List the caller's department default agents (read-only, new prompt schema)."""
     from sdk.client import BackendClient
     from sdk.exceptions import BackendFeatureMissing
 
     try:
-        agents = asyncio.run(
-            BackendClient.from_config().list_department_default_agents(department_id)
-        )
+        agents = asyncio.run(BackendClient.from_config().list_department_agents())
     except BackendFeatureMissing as exc:
-        # A 404 here means the endpoint isn't deployed — NOT that the department
-        # has no defaults. Say so, so this isn't mistaken for an empty list.
         print(f"error: {exc}")
         sys.exit(1)
     if not agents:
-        print(f"no default agents seeded for department {department_id} "
-              f"(a manager can add them with `agentos default-agents seed …`).")
+        print(f"no department default agents visible for department {department_id}.")
         return
 
-    print(f"{'NAME':<26}{'ENGINE':<13}{'TRIGGER':<14}{'MIN TIER':<11}{'STATUS'}")
+    print(f"{'NAME':<28}{'STATUS':<10}{'SKILLS':<8}SUMMARY")
     for a in agents:
-        print(
-            f"{a.get('name',''):<26}{a.get('engine',''):<13}"
-            f"{a.get('trigger_type',''):<14}{a.get('min_role_tier',''):<11}{a.get('status','')}"
-        )
-
-
-def _default_agents_activate(department_id: str, name: str) -> None:
-    """Clone a department default into the caller's custom agents + install locally."""
-    import yaml as _yaml
-
-    from sdk.agents.library import find_template
-    from sdk.agents.manifest import AGENTS_DIR, SKILLS_DIR
-    from sdk.client import BackendClient
-
-    result = asyncio.run(
-        BackendClient.from_config().activate_department_default_agent(department_id, name)
-    )
-    manifest = result.get("manifest") or {}
-
-    # Install the manifest locally so agentd / `agent run` can execute it.
-    if manifest:
-        AGENTS_DIR.mkdir(parents=True, exist_ok=True)
-        (AGENTS_DIR / f"{name}.yaml").write_text(
-            _yaml.safe_dump(manifest, sort_keys=False)
-        )
-
-    # Copy any skills the template bundles into ~/.agentos/skills.
-    template = find_template(name)
-    copied_skills: list[str] = []
-    if template and template.skills:
-        SKILLS_DIR.mkdir(parents=True, exist_ok=True)
-        for skill_name, path in template.skills.items():
-            (SKILLS_DIR / f"{skill_name}.md").write_text(path.read_text(encoding="utf-8"))
-            copied_skills.append(skill_name)
-
-    print(f"activated '{name}' — cloned to your custom agents (id={result.get('custom_agent_id')})")
-    print(f"  installed manifest to {AGENTS_DIR / (name + '.yaml')}")
-    if copied_skills:
-        print(f"  installed skills: {', '.join(copied_skills)}")
+        prompt = a.get("prompt") or {}
+        summary = (prompt.get("system_prompt") if isinstance(prompt, dict) else "") or ""
+        print(f"{a.get('name',''):<28}{a.get('status',''):<10}"
+              f"{len(a.get('skills') or []):<8}{summary.strip()[:60]}")
 
 
 # ── agentd ───────────────────────────────────────────────────────────────

{devops_bot_sdk-1.4.118 → devops_bot_sdk-1.4.119}/sdk/client.py

@@ -1202,47 +1202,10 @@ class BackendClient:
         _check_status(resp.status_code, self._base_url)
         return resp.json()
 
-    # ── Custom agents ─────────────────────────────────────────────────
-
-    async def register_custom_agent(self, manifest: dict) -> dict:
-        """POST /api/v1/agents/register — register a custom agent manifest.
-
-        Guards the network boundary: a manifest carrying an inline secret is
-        rejected locally before anything is sent — custom-agent secrets stay on
-        the machine where the agent is installed, never in the backend DB.
-        """
-        from sdk.agents.manifest import assert_secret_free
-        assert_secret_free(manifest, "manifest")
-        async with httpx.AsyncClient(timeout=15.0) as client:
-            resp = await client.post(
-                self._url("/api/v1/agents/register"),
-                json=manifest,
-                headers=self._headers,
-            )
-        _check_status(resp.status_code, self._base_url)
-        return resp.json()
-
-    async def register_department_agent(self, manifest: dict) -> dict:
-        """POST /api/v1/department-agents/register — publish a DEPARTMENT default.
-
-        Head-gated server-side (team_lead+ of the caller's own department, or
-        master → 403 otherwise). Same secret-free guard as a custom agent: the
-        manifest may only carry ${ENV_VAR} placeholders, never raw secrets —
-        department agents resolve their keys from the backend/host environment.
-        """
-        from sdk.agents.manifest import assert_secret_free
-        assert_secret_free(manifest, "manifest")
-        url = self._url("/api/v1/department-agents/register")
-        async with httpx.AsyncClient(timeout=15.0) as client:
-            resp = await client.post(url, json=manifest, headers=self._headers)
-        if resp.status_code == 404:
-            raise BackendFeatureMissing("Department agent registration", url)
-        if resp.status_code == 403:
-            raise PermissionError(
-                "only a department manager (team_lead+) may publish a department default agent"
-            )
-        _check_status(resp.status_code, self._base_url)
-        return resp.json()
+    # ── Custom agents (CONSUME-ONLY) ──────────────────────────────────
+    # Agent CREATION is not owned by the SDK anymore — agents are authored in the
+    # web app and written to the backend `agents` table (prompt/secrets/skills).
+    # This client only lists/reads them and manages per-agent status/delete.
 
     async def list_custom_agents(self) -> list[dict]:
         """GET /api/v1/agents — list registered custom agents."""
@@ -1298,66 +1261,10 @@ class BackendClient:
         _check_status(resp.status_code, self._base_url)
         return resp.json().get("agents", [])
 
-    # ── Department default agents ───────────────────────────────────────
-
-    async def list_department_default_agents(self, department_id: str) -> list[dict]:
-        """GET /api/v1/departments/{id}/default-agents — templates the caller can see."""
-        url = self._url(f"/api/v1/departments/{department_id}/default-agents")
-        async with httpx.AsyncClient(timeout=15.0) as client:
-            resp = await client.get(url, headers=self._headers)
-        if resp.status_code == 404:
-            raise BackendFeatureMissing("Department default agents", url)
-        _check_status(resp.status_code, self._base_url)
-        return resp.json().get("agents", [])
-
-    async def seed_department_default_agent(self, department_id: str, payload: dict) -> dict:
-        """POST /api/v1/departments/{id}/default-agents/seed — upsert one template.
-
-        Same secret-free guard as custom-agent registration: default-agent
-        templates are stored sans secrets; ${ENV_VAR} placeholders only.
-        """
-        from sdk.agents.manifest import assert_secret_free
-        assert_secret_free(payload, "default_agent")
-        async with httpx.AsyncClient(timeout=15.0) as client:
-            resp = await client.post(
-                self._url(f"/api/v1/departments/{department_id}/default-agents/seed"),
-                json=payload,
-                headers=self._headers,
-            )
-        _check_status(resp.status_code, self._base_url)
-        return resp.json()
-
-    async def activate_department_default_agent(self, department_id: str, name: str) -> dict:
-        """POST /api/v1/departments/{id}/default-agents/{name}/activate — clone to my custom agents."""
-        async with httpx.AsyncClient(timeout=15.0) as client:
-            resp = await client.post(
-                self._url(f"/api/v1/departments/{department_id}/default-agents/{name}/activate"),
-                headers=self._headers,
-            )
-        _check_status(resp.status_code, self._base_url)
-        return resp.json()
-
-    async def update_department_default_agent(
-        self, department_id: str, name: str, status: str
-    ) -> dict:
-        """PATCH /api/v1/departments/{id}/default-agents/{name} — enable/disable (manager only)."""
-        async with httpx.AsyncClient(timeout=15.0) as client:
-            resp = await client.patch(
-                self._url(f"/api/v1/departments/{department_id}/default-agents/{name}"),
-                json={"status": status},
-                headers=self._headers,
-            )
-        _check_status(resp.status_code, self._base_url)
-        return resp.json()
-
-    async def delete_department_default_agent(self, department_id: str, name: str) -> None:
-        """DELETE /api/v1/departments/{id}/default-agents/{name} — soft-delete (manager only)."""
-        async with httpx.AsyncClient(timeout=15.0) as client:
-            resp = await client.delete(
-                self._url(f"/api/v1/departments/{department_id}/default-agents/{name}"),
-                headers=self._headers,
-            )
-        _check_status(resp.status_code, self._base_url)
+    # NOTE: the legacy per-department "default agents" endpoints
+    # (/departments/{id}/default-agents[/seed|/activate|...]) were retired — that
+    # table never existed. Department defaults are now plain rows in the `agents`
+    # table (relation_type=department), read via `list_department_agents` above.
 
     async def list_connected_services(self) -> list[str]:
         """Best-effort: services the caller has connected (for connector discovery).

{devops_bot_sdk-1.4.118 → devops_bot_sdk-1.4.119}/sdk/ipc/handlers.py

@@ -3957,15 +3957,15 @@ async def handle_orchestrate_auto_local_run(
 async def handle_agent_create(
     client: BackendClient, payload: dict, send: Callable
 ) -> None:
-    """agent:create — register a new custom agent manifest."""
+    """agent:create — REMOVED. Agent creation is not owned by the SDK anymore;
+    agents are authored in the web app and written to the backend `agents` table.
+    """
     thread_id = str(payload.get("thread_id", "agent"))
-    try:
-        result = await client.register_custom_agent(payload["manifest"])
-        await send(Envelope(
-            type="agent.created", thread_id=thread_id, data=result,
-        ).model_dump())
-    except Exception as exc:
-        await send(_error_envelope(thread_id, exc).model_dump())
+    await send(_error_envelope(
+        thread_id,
+        RuntimeError("Agent creation has moved to the web app — the desktop SDK is "
+                     "consume-only (list/run/manage). This action is no longer available."),
+    ).model_dump())
 
 
 async def handle_agent_list(