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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: stackgen-sdk
-Version: 0.1.7
+Version: 0.1.8
 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.1.8}/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.1.8'
+__version_tuple__ = version_tuple = (0, 1, 8)
 
 __commit_id__ = commit_id = None

stackgen_sdk-0.1.8/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.1.8}/src/stackgen/aiden/namespace.py

@@ -6,6 +6,7 @@ from pathlib import Path
 from typing import Any
 
 from stackgen.aiden.ask import AskArtifactJourney, AskArtifactResult
+from stackgen.aiden.models import ModelRegistry
 from stackgen.aiden.run_status import RunStatus, build_run_status, require_run_ids
 from stackgen.aiden.webhook import WebhookReportJourney, WebhookReportResult
 from stackgen.aiden.webhook_ops import WebhookOps
@@ -24,6 +25,7 @@ class AidenNamespace:
         self._ask = AskArtifactJourney(config)
         self._workflows = WorkflowPublishJourney(config)
         self._webhook_ops = WebhookOps(config)
+        self.models = ModelRegistry(config)
 
     def run_webhook_and_download_report(
         self,

{stackgen_sdk-0.1.7 → stackgen_sdk-0.1.8}/src/stackgen/config.py

@@ -58,7 +58,10 @@ class StackgenConfig:
         """
         base = os.environ.get("STACKGEN_URL", "").strip()
         token = os.environ.get("STACKGEN_TOKEN", "").strip()
-        project = os.environ.get("STACKGEN_PROJECT", "").strip()
+        project = (
+            os.environ.get("STACKGEN_PROJECT", "").strip()
+            or os.environ.get("STACKGEN_ORG_ID", "").strip()
+        )
         if not base:
             raise ValueError("STACKGEN_URL is required")
         if not token: