stackgen-sdk 0.4.0rc33__tar.gz → 0.4.0rc35__tar.gz

{stackgen_sdk-0.4.0rc33 → stackgen_sdk-0.4.0rc35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: stackgen-sdk
-Version: 0.4.0rc33
+Version: 0.4.0rc35
 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.4.0rc33 → stackgen_sdk-0.4.0rc35}/src/stackgen/_http.py

@@ -122,7 +122,7 @@ def request(
     statuses use the short ``retries`` attempt budget. POST/PATCH fail fast
     unless ``retry_gateway_outage`` is set, which retries only 502/503/504
     and transport errors (a CloudFront drop), not application 500s.
-    Webhook trigger and vault secret store set that flag.
+    Webhook trigger, vault secret store, and org create set that flag.
 
     ``timeout_seconds`` is an optional per-call abort budget. When the deadline
     expires, raises :class:`~stackgen.errors.TimeoutError`. Omit to wait until

{stackgen_sdk-0.4.0rc33 → stackgen_sdk-0.4.0rc35}/src/stackgen/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.4.0rc33'
-__version_tuple__ = version_tuple = (0, 4, 0, 'rc33')
+__version__ = version = '0.4.0rc35'
+__version_tuple__ = version_tuple = (0, 4, 0, 'rc35')
 
 __commit_id__ = commit_id = None

{stackgen_sdk-0.4.0rc33 → stackgen_sdk-0.4.0rc35}/src/stackgen/aiden/__init__.py

@@ -6,6 +6,7 @@ from stackgen.aiden.namespace import AidenNamespace
 from stackgen.aiden.resources import PolicyConflictRule
 from stackgen.aiden.run_status import ExecutionStatus, RunPhase, RunStatus
 from stackgen.aiden.steer import is_steer_response
+from stackgen.aiden.stream_events import normalize_agui_type, parse_execution_event
 from stackgen.aiden.transient import (
     IDEMPOTENT_MUTATION_ATTEMPTS,
     SUBSCRIBE_RECONNECT_MAX,
@@ -47,5 +48,7 @@ __all__ = [
     "is_steer_response",
     "is_transient_failure",
     "is_transient_status",
+    "normalize_agui_type",
+    "parse_execution_event",
     "retry_idempotent_op",
 ]

{stackgen_sdk-0.4.0rc33 → stackgen_sdk-0.4.0rc35}/src/stackgen/aiden/namespace.py

@@ -14,6 +14,7 @@ from stackgen.aiden.integration_secrets import (
 from stackgen.aiden.models import ModelRegistry
 from stackgen.aiden.resources import AidenResources, PolicyConflictRule
 from stackgen.aiden.run_status import RunStatus, build_run_status, require_run_ids
+from stackgen.aiden.stream_events import ExecutionEventStream
 from stackgen.aiden.subscribe import ExecutionSubscribe, SubscribeCompleteResult
 from stackgen.aiden.webhook import WebhookReportJourney, WebhookReportResult
 from stackgen.aiden.webhook_ops import WebhookOps
@@ -35,6 +36,7 @@ class AidenNamespace:
         self._resources = AidenResources(config)
         self._integration_secrets = IntegrationSecretsJourney(config)
         self._subscribe = ExecutionSubscribe(config)
+        self._event_stream = ExecutionEventStream(config)
         self._audit = AuditExportJourney(config)
         self.models = ModelRegistry(config)
 
@@ -322,6 +324,27 @@ class AidenNamespace:
         """GET SSE /guild/api/v1/executions/{traceId}/subscribe until complete."""
         return self._subscribe.wait_for_complete(trace_id, timeout_ms=timeout_ms)
 
+    def stream_execution_events(
+        self,
+        trace_id: str,
+        *,
+        max_reconnects: int | None = None,
+        max_wall_clock_ms: int | None = None,
+        skip_subagents: bool = True,
+    ) -> Iterator[dict[str, Any]]:
+        """Yield AG-UI events for a running execution until top-level RUN_FINISHED.
+
+        Use after :meth:`start_agent_chat`, :meth:`start_ask`, or
+        :meth:`run_workflow` returns a ``trace_id``. Each item has ``type``,
+        ``data``, ``is_subagent``, and the raw CloudEvent.
+        """
+        kwargs: dict[str, Any] = {"skip_subagents": skip_subagents}
+        if max_reconnects is not None:
+            kwargs["max_reconnects"] = max_reconnects
+        if max_wall_clock_ms is not None:
+            kwargs["max_wall_clock_ms"] = max_wall_clock_ms
+        return self._event_stream.stream(trace_id, **kwargs)
+
     def publish_workflow(
         self,
         workflow: WorkflowDefinition,
@@ -583,6 +606,14 @@ class AidenNamespace:
     def list_tools(self, **params: Any) -> list[dict[str, Any]]:
         return self._resources.list_tools(**params)
 
+    def list_agents(self, **params: Any) -> list[dict[str, Any]]:
+        """List agents in the project (for chat target pickers)."""
+        return self._resources.list_agents(**params)
+
+    def list_workflows(self, **params: Any) -> list[dict[str, Any]]:
+        """List workflows in the project (for chat target pickers)."""
+        return self._resources.list_workflows(**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)
 

{stackgen_sdk-0.4.0rc33 → stackgen_sdk-0.4.0rc35}/src/stackgen/aiden/resources.py

@@ -359,6 +359,14 @@ class AidenResources:
     def list_tools(self, **params: Any) -> list[dict[str, Any]]:
         return _http.as_list(self._get("/tools", params))
 
+    def list_agents(self, **params: Any) -> list[dict[str, Any]]:
+        """GET /agents — agents registered in the project."""
+        return _http.as_list(self._get("/agents", params))
+
+    def list_workflows(self, **params: Any) -> list[dict[str, Any]]:
+        """GET /workflows — workflows in the project."""
+        return _http.as_list(self._get("/workflows", params))
+
     def start_agent_chat(self, agent_name: str, body: dict[str, Any]) -> dict[str, Any]:
         record = _as_object(
             self._send(f"/agents/{agent_name}/chat/start", "POST", body),

stackgen_sdk-0.4.0rc35/src/stackgen/aiden/stream_events.py

@@ -0,0 +1,254 @@
+"""Live AG-UI event stream for an execution subscribe SSE.
+
+Yields normalized chat events until a top-level ``RUN_FINISHED``. Control
+frames (``connected``, ``replay_complete``, ``subscribe_end``) are skipped.
+Reconnects on drop / ``subscribe_end: timeout`` so the server can replay.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from typing import Any, Iterator
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+
+from stackgen import _http
+from stackgen.aiden.transient import SUBSCRIBE_RECONNECT_MAX, is_transient_status
+from stackgen.config import StackgenConfig
+from stackgen.logging import get_logger
+
+_log = get_logger("stream_events")
+
+_AGUI_PREFIX = "ai.genie.agui."
+_CONTROL_EVENTS = frozenset({"connected", "replay_complete"})
+
+
+def normalize_agui_type(raw: Any) -> str:
+    text = str(raw or "")
+    if text.startswith(_AGUI_PREFIX):
+        return text[len(_AGUI_PREFIX) :]
+    return text
+
+
+def parse_execution_event(
+    sse_event: str, data_text: str
+) -> dict[str, Any] | str | None:
+    """Parse one SSE data payload.
+
+    Returns an event dict, ``\"subscribe_end_timeout\"``, ``\"subscribe_end\"``,
+    or ``None`` when the frame should be ignored.
+    """
+    if sse_event in _CONTROL_EVENTS:
+        return None
+    if sse_event == "subscribe_end":
+        reason = ""
+        try:
+            obj = json.loads(data_text)
+            if isinstance(obj, dict):
+                reason = _http.text(obj.get("reason"))
+        except (TypeError, ValueError, json.JSONDecodeError):
+            pass
+        return "subscribe_end_timeout" if reason == "timeout" else "subscribe_end"
+    if sse_event in ("error", "RUN_ERROR"):
+        return {
+            "type": "RUN_ERROR",
+            "data": {"message": data_text},
+            "is_subagent": False,
+            "raw": {"sseEvent": sse_event, "data": data_text},
+            "sse_event": sse_event,
+        }
+    try:
+        payload = json.loads(data_text)
+    except (TypeError, ValueError, json.JSONDecodeError):
+        return None
+    if not isinstance(payload, dict):
+        return None
+
+    data_record = payload.get("data") or payload.get("Data") or payload.get("Event") or {}
+    if not isinstance(data_record, dict):
+        data_record = {}
+    nested = data_record.get("Event") or data_record.get("event")
+    if not isinstance(nested, dict):
+        nested = None
+    metadata = (
+        data_record.get("metadata")
+        or data_record.get("Metadata")
+        or payload.get("metadata")
+        or payload.get("Metadata")
+    )
+    if not isinstance(metadata, dict):
+        metadata = None
+    event_type = (
+        normalize_agui_type(payload.get("type"))
+        or normalize_agui_type(payload.get("Type"))
+        or normalize_agui_type(data_record.get("Type"))
+        or normalize_agui_type(data_record.get("type"))
+        or (normalize_agui_type(nested.get("Type")) if nested else "")
+        or (normalize_agui_type(nested.get("type")) if nested else "")
+        or normalize_agui_type(sse_event)
+    )
+    if not event_type:
+        return None
+    body = nested if nested is not None else data_record
+    event_id = _http.text(payload.get("id")) or _http.text(payload.get("Id")) or None
+    return {
+        "type": event_type,
+        "id": event_id or None,
+        "data": body,
+        "metadata": metadata,
+        "is_subagent": bool(metadata and metadata.get("is_subagent") is True),
+        "raw": payload,
+        "sse_event": sse_event,
+    }
+
+
+class ExecutionEventStream:
+    def __init__(self, config: StackgenConfig) -> None:
+        self._config = config
+
+    def stream(
+        self,
+        trace_id: str,
+        *,
+        max_reconnects: int = SUBSCRIBE_RECONNECT_MAX,
+        max_wall_clock_ms: int | None = None,
+        skip_subagents: bool = True,
+    ) -> Iterator[dict[str, Any]]:
+        tid = (trace_id or "").strip()
+        if not tid:
+            raise ValueError("trace_id is required")
+        started = time.monotonic()
+        outage_budget_ms = int(getattr(self._config, "transient_retry_budget_ms", 0) or 0)
+        url = (
+            f"{self._config.aiden_url()}/api/v1/executions/{tid}/subscribe"
+            f"{_http.query(self._config.org_id)}"
+        )
+        headers = {
+            "Authorization": f"Bearer {self._config.api_token}",
+            "Accept": "text/event-stream",
+        }
+        if self._config.org_id:
+            headers["X-Appcd-Org"] = self._config.org_id
+
+        seen_ids: set[str] = set()
+        reconnects = 0
+
+        def can_reconnect(count: int) -> bool:
+            elapsed_ms = (time.monotonic() - started) * 1000
+            return count < max_reconnects or (
+                outage_budget_ms > 0 and elapsed_ms < outage_budget_ms
+            )
+
+        def wall_exceeded() -> bool:
+            if max_wall_clock_ms is None or max_wall_clock_ms <= 0:
+                return False
+            return (time.monotonic() - started) * 1000 >= max_wall_clock_ms
+
+        while not wall_exceeded():
+            try:
+                req = Request(url, headers=headers, method="GET")
+                with urlopen(req, timeout=90) as resp:
+                    status = getattr(resp, "status", None) or resp.getcode()
+                    if status >= 400:
+                        if is_transient_status(status) and can_reconnect(reconnects):
+                            reconnects += 1
+                            _log.warning(
+                                "stream_execution_events reconnect %s after status=%s trace_id=%s",
+                                reconnects,
+                                status,
+                                tid,
+                            )
+                            time.sleep(min(1.0 * 2 ** min(reconnects, 4), 15.0))
+                            continue
+                        raise RuntimeError(f"subscribe status={status}")
+
+                    buf = ""
+                    finished = False
+                    need_reconnect = False
+                    reconnect_reason = ""
+
+                    while not wall_exceeded():
+                        chunk = resp.read(4096)
+                        if not chunk:
+                            need_reconnect = not finished
+                            reconnect_reason = "EOF"
+                            break
+                        buf += chunk.decode("utf-8", errors="replace")
+                        while "\n\n" in buf:
+                            frame, buf = buf.split("\n\n", 1)
+                            event_name = "message"
+                            data_lines: list[str] = []
+                            for line in frame.splitlines():
+                                if line.startswith(":"):
+                                    continue
+                                if line.startswith("event:"):
+                                    event_name = line[6:].strip()
+                                elif line.startswith("data:"):
+                                    data_lines.append(line[5:].lstrip())
+                            if not data_lines:
+                                continue
+                            parsed = parse_execution_event(
+                                event_name, "\n".join(data_lines)
+                            )
+                            if parsed == "subscribe_end_timeout":
+                                need_reconnect = True
+                                reconnect_reason = "subscribe_end: timeout"
+                                break
+                            if parsed == "subscribe_end":
+                                need_reconnect = True
+                                reconnect_reason = "subscribe_end"
+                                break
+                            if not isinstance(parsed, dict):
+                                continue
+                            if skip_subagents and parsed.get("is_subagent"):
+                                continue
+                            eid = parsed.get("id")
+                            if eid:
+                                if eid in seen_ids:
+                                    continue
+                                seen_ids.add(str(eid))
+                            yield parsed
+                            if (
+                                parsed.get("type") == "RUN_FINISHED"
+                                and not parsed.get("is_subagent")
+                            ):
+                                finished = True
+                                break
+                        if finished or need_reconnect:
+                            break
+
+                    if finished:
+                        return
+                    if not need_reconnect or not can_reconnect(reconnects):
+                        return
+                    reconnects += 1
+                    _log.warning(
+                        "stream_execution_events reconnect %s after %s trace_id=%s",
+                        reconnects,
+                        reconnect_reason,
+                        tid,
+                    )
+            except HTTPError as err:
+                status = int(err.code)
+                if is_transient_status(status) and can_reconnect(reconnects):
+                    reconnects += 1
+                    _log.warning(
+                        "stream_execution_events reconnect %s after status=%s trace_id=%s",
+                        reconnects,
+                        status,
+                        tid,
+                    )
+                    time.sleep(min(1.0 * 2 ** min(reconnects, 4), 15.0))
+                    continue
+                raise RuntimeError(f"subscribe status={status}") from err
+            except URLError:
+                if not can_reconnect(reconnects):
+                    raise
+                reconnects += 1
+                _log.warning(
+                    "stream_execution_events reconnect %s after network error trace_id=%s",
+                    reconnects,
+                    tid,
+                )
+                time.sleep(min(1.0 * 2 ** min(reconnects, 4), 15.0))