stackgen-sdk 0.1.7__tar.gz → 0.2.0__tar.gz

{stackgen_sdk-0.1.7 → stackgen_sdk-0.2.0}/.gitignore

@@ -6,6 +6,7 @@ __pycache__/
 dist/
 build/
 .venv/
+.venv-sync/
 venv/
 .venv/**
 .pytest_cache/
@@ -40,3 +41,4 @@ docs/vendor/
 
 # hatch-vcs generated version module (written at build time)
 clients/python/src/stackgen/_version.py
+.venv-sync/

{stackgen_sdk-0.1.7 → stackgen_sdk-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: stackgen-sdk
-Version: 0.1.7
+Version: 0.2.0
 Summary: StackGen SDK — Aiden, SRE, and Vault from one client
 Project-URL: Homepage, https://appcd-dev.github.io/stackgen-sdk/
 Project-URL: Documentation, https://appcd-dev.github.io/stackgen-sdk/

{stackgen_sdk-0.1.7 → stackgen_sdk-0.2.0}/src/stackgen/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.7'
-__version_tuple__ = version_tuple = (0, 1, 7)
+__version__ = version = '0.2.0'
+__version_tuple__ = version_tuple = (0, 2, 0)
 
 __commit_id__ = commit_id = None

stackgen_sdk-0.2.0/src/stackgen/aiden/models.py

@@ -0,0 +1,225 @@
+"""Aiden model registry — providers and registered models.
+
+Hand-written facade over Guild ``/guild/api/v1/model-providers`` and
+``/guild/api/v1/models`` (see stackgen-guild ``api-docs/openapi.yml``).
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.parse
+from typing import Any
+
+from stackgen import _http
+from stackgen.config import StackgenConfig
+from stackgen.errors import HttpError
+
+
+class ModelRegistry:
+    """CRUD helpers for OpenAI-compatible (and other) model providers/models."""
+
+    def __init__(self, config: StackgenConfig) -> None:
+        self._config = config
+
+    def _org(self) -> str:
+        org = (self._config.org_id or "").strip()
+        if not org:
+            raise ValueError("org_id is required for model registry calls")
+        return org
+
+    def _url(self, path: str) -> str:
+        return f"{self._config.aiden_url()}/api/v1{path}{_http.query(self._org())}"
+
+    def _json(
+        self,
+        method: str,
+        path: str,
+        body: dict[str, Any] | None = None,
+    ) -> Any:
+        payload = None
+        content_type = None
+        if body is not None:
+            payload = json.dumps(body).encode("utf-8")
+            content_type = "application/json"
+        return _http.request(
+            self._url(path),
+            self._config.api_token,
+            method=method,
+            body=payload,
+            content_type=content_type,
+        )
+
+    def list_providers(self) -> list[dict[str, Any]]:
+        """GET /guild/api/v1/model-providers."""
+        return _http.as_list(self._json("GET", "/model-providers"))
+
+    def get_provider(self, name: str) -> dict[str, Any]:
+        """GET /guild/api/v1/model-providers/{name}."""
+        enc = urllib.parse.quote(name, safe="")
+        out = self._json("GET", f"/model-providers/{enc}")
+        if not isinstance(out, dict):
+            raise HttpError(f"unexpected provider payload for {name!r}")
+        return out
+
+    def create_provider(
+        self,
+        *,
+        name: str,
+        provider_type: str = "openai",
+        host: str = "",
+        token_reference: str = "",
+    ) -> dict[str, Any]:
+        """POST /guild/api/v1/model-providers."""
+        body: dict[str, Any] = {"name": name, "provider_type": provider_type}
+        if host:
+            body["host"] = host.rstrip("/")
+        if token_reference:
+            body["token_reference"] = token_reference
+        out = self._json("POST", "/model-providers", body)
+        if not isinstance(out, dict):
+            raise HttpError(f"unexpected create provider payload for {name!r}")
+        return out
+
+    def update_provider(
+        self,
+        name: str,
+        *,
+        host: str | None = None,
+        token_reference: str | None = None,
+        provider_type: str | None = None,
+    ) -> dict[str, Any]:
+        """PUT /guild/api/v1/model-providers/{name}."""
+        body: dict[str, Any] = {}
+        if host is not None:
+            body["host"] = host.rstrip("/")
+        if token_reference is not None:
+            body["token_reference"] = token_reference
+        if provider_type is not None:
+            body["provider_type"] = provider_type
+        enc = urllib.parse.quote(name, safe="")
+        out = self._json("PUT", f"/model-providers/{enc}", body)
+        if not isinstance(out, dict):
+            raise HttpError(f"unexpected update provider payload for {name!r}")
+        return out
+
+    def ensure_provider(
+        self,
+        *,
+        name: str,
+        host: str,
+        provider_type: str = "openai",
+        token_reference: str = "",
+    ) -> dict[str, Any]:
+        """Create provider if missing, then set host (and optional token_reference)."""
+        try:
+            self.create_provider(
+                name=name,
+                provider_type=provider_type,
+                host=host,
+                token_reference=token_reference,
+            )
+        except HttpError as err:
+            if err.status_code != 409:
+                raise
+        return self.update_provider(
+            name,
+            host=host,
+            token_reference=token_reference or None,
+            provider_type=provider_type,
+        )
+
+    def list_models(self, *, provider_name: str = "") -> list[dict[str, Any]]:
+        """GET /guild/api/v1/models."""
+        base = f"{self._config.aiden_url()}/api/v1/models"
+        params: dict[str, str] = {"orgId": self._org()}
+        if provider_name:
+            params["provider_name"] = provider_name
+        q = urllib.parse.urlencode(params)
+        return _http.as_list(
+            _http.request(
+                f"{base}?{q}",
+                self._config.api_token,
+                method="GET",
+            )
+        )
+
+    def get_model(self, name: str) -> dict[str, Any]:
+        """GET /guild/api/v1/models/{name}."""
+        enc = urllib.parse.quote(name, safe="")
+        out = self._json("GET", f"/models/{enc}")
+        if not isinstance(out, dict):
+            raise HttpError(f"unexpected model payload for {name!r}")
+        return out
+
+    def create_model(
+        self,
+        *,
+        name: str,
+        provider_name: str,
+        model_id: str,
+        thinking: bool = False,
+    ) -> dict[str, Any]:
+        """POST /guild/api/v1/models (live-probes the provider host)."""
+        body: dict[str, Any] = {
+            "name": name,
+            "provider_name": provider_name,
+            "model_id": model_id,
+            "thinking": thinking,
+        }
+        out = self._json("POST", "/models", body)
+        if not isinstance(out, dict):
+            raise HttpError(f"unexpected create model payload for {name!r}")
+        return out
+
+    def ensure_model(
+        self,
+        *,
+        name: str,
+        provider_name: str,
+        model_id: str,
+        thinking: bool = False,
+    ) -> dict[str, Any]:
+        """Return existing model or create it (requires reachable provider host)."""
+        try:
+            return self.get_model(name)
+        except HttpError as err:
+            if err.status_code != 404:
+                raise
+        try:
+            return self.create_model(
+                name=name,
+                provider_name=provider_name,
+                model_id=model_id,
+                thinking=thinking,
+            )
+        except HttpError as err:
+            if err.status_code == 409:
+                return self.get_model(name)
+            raise
+
+    def ensure_openai_peft_model(
+        self,
+        *,
+        serve_url: str,
+        model_name: str = "sre-slm-qwen3-32b",
+        provider_name: str = "sre-slm-peft",
+        model_id: str = "sre-slm-qwen3-32b",
+        token_reference: str = "",
+    ) -> dict[str, Any]:
+        """Ensure OpenAI-compatible provider + model pointed at a PEFT serve URL.
+
+        ``serve_url`` should look like ``http://<ip>:8000/v1``. Create model
+        live-probes the host, so PEFT serve must already be up.
+        """
+        provider = self.ensure_provider(
+            name=provider_name,
+            host=serve_url,
+            provider_type="openai",
+            token_reference=token_reference,
+        )
+        model = self.ensure_model(
+            name=model_name,
+            provider_name=provider_name,
+            model_id=model_id,
+        )
+        return {"provider": provider, "model": model}

{stackgen_sdk-0.1.7 → stackgen_sdk-0.2.0}/src/stackgen/aiden/namespace.py

@@ -6,7 +6,10 @@ from pathlib import Path
 from typing import Any
 
 from stackgen.aiden.ask import AskArtifactJourney, AskArtifactResult
+from stackgen.aiden.models import ModelRegistry
+from stackgen.aiden.resources import AidenResources
 from stackgen.aiden.run_status import RunStatus, build_run_status, require_run_ids
+from stackgen.aiden.subscribe import ExecutionSubscribe, SubscribeCompleteResult
 from stackgen.aiden.webhook import WebhookReportJourney, WebhookReportResult
 from stackgen.aiden.webhook_ops import WebhookOps
 from stackgen.aiden.workflow_builder import AgentDefinition, WorkflowDefinition
@@ -24,6 +27,9 @@ class AidenNamespace:
         self._ask = AskArtifactJourney(config)
         self._workflows = WorkflowPublishJourney(config)
         self._webhook_ops = WebhookOps(config)
+        self._resources = AidenResources(config)
+        self._subscribe = ExecutionSubscribe(config)
+        self.models = ModelRegistry(config)
 
     def run_webhook_and_download_report(
         self,
@@ -227,6 +233,12 @@ class AidenNamespace:
         """
         return self._ask.wait_for_execution(trace_id)
 
+    def wait_for_subscribe_complete(
+        self, trace_id: str, *, timeout_ms: int = 10 * 60 * 1000
+    ) -> SubscribeCompleteResult:
+        """GET SSE /guild/api/v1/executions/{traceId}/subscribe until complete."""
+        return self._subscribe.wait_for_complete(trace_id, timeout_ms=timeout_ms)
+
     def publish_workflow(
         self,
         workflow: WorkflowDefinition,
@@ -239,3 +251,154 @@ class AidenNamespace:
         Pass a committed builder from ``create_workflow(...).then(...).commit()``.
         """
         return self._workflows.publish(workflow, agents=agents, approve=approve)
+
+    # Expanded allowlisted surface (thin REST) — delegated to AidenResources.
+    def get_agent(self, name: str) -> dict[str, Any]:
+        return self._resources.get_agent(name)
+
+    def deregister_agent(self, name: str) -> dict[str, Any]:
+        return self._resources.deregister_agent(name)
+
+    def get_agent_health(self, name: str) -> dict[str, Any]:
+        return self._resources.get_agent_health(name)
+
+    def create_webhook(self, body: dict[str, Any]) -> dict[str, Any]:
+        return self._resources.create_webhook(body)
+
+    def get_webhook(self, webhook_id: str) -> dict[str, Any]:
+        return self._resources.get_webhook(webhook_id)
+
+    def delete_webhook(self, webhook_id: str) -> dict[str, Any]:
+        return self._resources.delete_webhook(webhook_id)
+
+    def create_schedule(self, body: dict[str, Any]) -> dict[str, Any]:
+        return self._resources.create_schedule(body)
+
+    def trigger_schedule(self, schedule_id: str) -> dict[str, Any]:
+        return self._resources.trigger_schedule(schedule_id)
+
+    def list_schedule_runs(self, schedule_id: str) -> list[dict[str, Any]]:
+        return self._resources.list_schedule_runs(schedule_id)
+
+    def delete_schedule(self, schedule_id: str) -> dict[str, Any]:
+        return self._resources.delete_schedule(schedule_id)
+
+    def list_integrations(self) -> list[dict[str, Any]]:
+        return self._resources.list_integrations()
+
+    def list_integration_types(self) -> list[dict[str, Any]]:
+        return self._resources.list_integration_types()
+
+    def get_integration(self, name: str) -> dict[str, Any]:
+        return self._resources.get_integration(name)
+
+    def upsert_integration(self, name: str, body: dict[str, Any]) -> dict[str, Any]:
+        return self._resources.upsert_integration(name, body)
+
+    def delete_integration(self, name: str) -> dict[str, Any]:
+        return self._resources.delete_integration(name)
+
+    def test_integration_connection(self, name: str) -> dict[str, Any]:
+        return self._resources.test_integration_connection(name)
+
+    def refresh_integration_tools(self, name: str) -> dict[str, Any]:
+        return self._resources.refresh_integration_tools(name)
+
+    def list_approvals(self, **params: Any) -> list[dict[str, Any]]:
+        return self._resources.list_approvals(**params)
+
+    def resolve_approval(self, approval_id: str, body: dict[str, Any]) -> dict[str, Any]:
+        return self._resources.resolve_approval(approval_id, body)
+
+    def create_policy(self, body: dict[str, Any]) -> dict[str, Any]:
+        return self._resources.create_policy(body)
+
+    def attach_policy(self, agent_name: str, body: dict[str, Any]) -> dict[str, Any]:
+        return self._resources.attach_policy(agent_name, body)
+
+    def detach_policy(self, agent_name: str, policy_id: str) -> dict[str, Any]:
+        return self._resources.detach_policy(agent_name, policy_id)
+
+    def delete_policy(self, policy_id: str) -> dict[str, Any]:
+        return self._resources.delete_policy(policy_id)
+
+    def evaluate_policy(self, body: dict[str, Any]) -> dict[str, Any]:
+        return self._resources.evaluate_policy(body)
+
+    def list_audit_events(self, **params: Any) -> list[dict[str, Any]]:
+        return self._resources.list_audit_events(**params)
+
+    def get_audit_event(self, event_id: str) -> dict[str, Any]:
+        return self._resources.get_audit_event(event_id)
+
+    def list_audit_facets(self, **params: Any) -> dict[str, Any]:
+        return self._resources.list_audit_facets(**params)
+
+    def list_models(self) -> list[dict[str, Any]]:
+        return self._resources.list_models()
+
+    def list_tools(self, **params: Any) -> list[dict[str, Any]]:
+        return self._resources.list_tools(**params)
+
+    def start_agent_chat(self, agent_name: str, body: dict[str, Any]) -> dict[str, Any]:
+        return self._resources.start_agent_chat(agent_name, body)
+
+    def fork_session(
+        self, session_id: str, body: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        return self._resources.fork_session(session_id, body)
+
+    def list_execution_tool_calls(
+        self, trace_id: str, **params: Any
+    ) -> list[dict[str, Any]]:
+        return self._resources.list_execution_tool_calls(trace_id, **params)
+
+    def delete_workflow(self, name: str) -> dict[str, Any]:
+        return self._resources.delete_workflow(name)
+
+    def run_workflow(
+        self, name: str, body: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        return self._resources.run_workflow(name, body)
+
+    def create_knowledge_base(self, body: dict[str, Any]) -> dict[str, Any]:
+        return self._resources.create_knowledge_base(body)
+
+    def delete_knowledge_base(self, knowledge_base_id: str) -> dict[str, Any]:
+        return self._resources.delete_knowledge_base(knowledge_base_id)
+
+    def create_knowledge_document(self, body: dict[str, Any]) -> dict[str, Any]:
+        return self._resources.create_knowledge_document(body)
+
+    def get_knowledge_document(self, document_id: str) -> dict[str, Any]:
+        return self._resources.get_knowledge_document(document_id)
+
+    def list_knowledge_documents(self, **params: Any) -> list[dict[str, Any]]:
+        return self._resources.list_knowledge_documents(**params)
+
+    def delete_knowledge_document(self, document_id: str) -> dict[str, Any]:
+        return self._resources.delete_knowledge_document(document_id)
+
+    def list_knowledge_items(self, **params: Any) -> list[dict[str, Any]]:
+        return self._resources.list_knowledge_items(**params)
+
+    def create_skill(self, body: dict[str, Any]) -> dict[str, Any]:
+        return self._resources.create_skill(body)
+
+    def delete_skill(self, skill_id: str) -> dict[str, Any]:
+        return self._resources.delete_skill(skill_id)
+
+    def create_remote_runner(self, body: dict[str, Any]) -> dict[str, Any]:
+        return self._resources.create_remote_runner(body)
+
+    def get_remote_runner(self, runner_id: str) -> dict[str, Any]:
+        return self._resources.get_remote_runner(runner_id)
+
+    def list_remote_runners(self, **params: Any) -> list[dict[str, Any]]:
+        return self._resources.list_remote_runners(**params)
+
+    def list_remote_runner_tasks(self, runner_id: str) -> list[dict[str, Any]]:
+        return self._resources.list_remote_runner_tasks(runner_id)
+
+    def revoke_remote_runner(self, runner_id: str) -> dict[str, Any]:
+        return self._resources.revoke_remote_runner(runner_id)