dominus-sdk-python 2.8.0__tar.gz → 2.9.0__tar.gz

{dominus_sdk_python-2.8.0 → dominus_sdk_python-2.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dominus-sdk-python
-Version: 2.8.0
+Version: 2.9.0
 Summary: Python SDK for the Dominus Orchestrator Platform
 Author-email: CareBridge Systems <dev@carebridge.io>
 License: Proprietary

{dominus_sdk_python-2.8.0 → dominus_sdk_python-2.9.0}/dominus/config/endpoints.py

@@ -30,6 +30,33 @@ ARCHITECT_URL = BASE_URL
 ORCHESTRATOR_URL = BASE_URL
 WARDEN_URL = BASE_URL
 
+# Proxy configuration (optional)
+# DOMINUS_* variants take precedence over standard HTTP_PROXY/HTTPS_PROXY
+HTTP_PROXY = os.environ.get("DOMINUS_HTTP_PROXY") or os.environ.get("HTTP_PROXY")
+HTTPS_PROXY = os.environ.get("DOMINUS_HTTPS_PROXY") or os.environ.get("HTTPS_PROXY")
+
+
+def get_proxy_config() -> dict | None:
+    """
+    Get proxy configuration for httpx clients.
+
+    Returns a dict suitable for httpx's `proxies` parameter, or None if no proxy is configured.
+
+    Environment variables (in order of precedence):
+        - DOMINUS_HTTP_PROXY / DOMINUS_HTTPS_PROXY (SDK-specific)
+        - HTTP_PROXY / HTTPS_PROXY (standard)
+
+    Returns:
+        Dict mapping protocol to proxy URL, or None if no proxies configured.
+        Example: {"http://": "http://proxy:8080", "https://": "http://proxy:8080"}
+    """
+    proxies = {}
+    if HTTP_PROXY:
+        proxies["http://"] = HTTP_PROXY
+    if HTTPS_PROXY:
+        proxies["https://"] = HTTPS_PROXY
+    return proxies if proxies else None
+
 
 def get_gateway_url() -> str:
     """

{dominus_sdk_python-2.8.0 → dominus_sdk_python-2.9.0}/dominus/helpers/core.py

@@ -16,6 +16,10 @@ from .cache import dominus_cache, sovereign_circuit_breaker, exponential_backoff
 # Max retries for HTTP requests (reduced from implicit to explicit)
 MAX_RETRIES = 3
 
+# Mutex for JWT refresh to prevent race conditions
+# When multiple concurrent coroutines need a new JWT, only one will mint
+_jwt_refresh_lock = asyncio.Lock()
+
 # Type alias
 DominusResponse = dict[str, Any]
 
@@ -103,11 +107,12 @@ async def _fetch_jwks() -> dict:
     if _cached_jwks and time.time() - _jwks_cache_time < _JWKS_CACHE_TTL:
         return _cached_jwks
 
-    from ..config.endpoints import get_gateway_url
+    from ..config.endpoints import get_gateway_url, get_proxy_config
     gateway_url = get_gateway_url()
+    proxy_config = get_proxy_config()
 
     try:
-        async with httpx.AsyncClient(timeout=10.0) as client:
+        async with httpx.AsyncClient(timeout=10.0, proxies=proxy_config) as client:
             response = await client.get(f"{gateway_url}/jwt/jwks")
             response.raise_for_status()
 
@@ -329,8 +334,9 @@ async def _get_service_jwt(psk_token: str, base_url: str) -> str:
     Raises:
         RuntimeError: If circuit is open or auth fails after retries
     """
-    from ..config.endpoints import get_gateway_url
+    from ..config.endpoints import get_gateway_url, get_proxy_config
     gateway_url = get_gateway_url()
+    proxy_config = get_proxy_config()
 
     # Circuit breaker check
     if not sovereign_circuit_breaker.can_execute():
@@ -357,7 +363,7 @@ async def _get_service_jwt(psk_token: str, base_url: str) -> str:
 
     for attempt in range(JWT_MINT_RETRIES):
         try:
-            async with httpx.AsyncClient(base_url=gateway_url, headers=headers, timeout=30.0) as client:
+            async with httpx.AsyncClient(base_url=gateway_url, headers=headers, timeout=30.0, proxies=proxy_config) as client:
                 response = await client.post("/jwt/mint", content=body_b64)
 
                 # Check for retryable status codes before raise_for_status
@@ -455,43 +461,56 @@ def _get_architect_url(psk_token: str = None, sovereign_url: str = None, environ
 async def _ensure_valid_jwt(psk_token: str, sovereign_url: str) -> str:
     """
     Ensure we have a valid JWT, fetching and caching if needed.
-    
+
+    Thread-safe via asyncio.Lock to prevent duplicate mints when
+    multiple concurrent coroutines need a new JWT.
+
     Cache key: "jwt:self:service"
     Cache TTL: 14 minutes (JWT lifetime is 15 minutes)
     Refresh when <60 seconds remain.
-    
+
     Args:
         psk_token: PSK token (DOMINUS_TOKEN)
         sovereign_url: Sovereign base URL
-        
+
     Returns:
         Valid JWT token string
     """
     cache_key = "jwt:self:service"
-    
-    # Check cache
+
+    # Fast path: check cache without lock
     cached_jwt = dominus_cache.get(cache_key)
     if cached_jwt:
         try:
-            # Decode payload to check expiry
             payload = _decode_jwt_payload(cached_jwt)
             exp = payload.get("exp", 0)
             current_time = int(time.time())
-            
-            # Refresh if <60 seconds remain
             if exp - current_time > 60:
                 return cached_jwt
         except Exception:
-            # If decode fails, fetch new JWT
             pass
-    
-    # Fetch new JWT
-    jwt = await _get_service_jwt(psk_token, sovereign_url)
-    
-    # Cache for 14 minutes (840 seconds)
-    dominus_cache.set(cache_key, jwt, ttl=840)
-    
-    return jwt
+
+    # Slow path: acquire lock and refresh
+    async with _jwt_refresh_lock:
+        # Double-check cache (another coroutine may have refreshed while we waited)
+        cached_jwt = dominus_cache.get(cache_key)
+        if cached_jwt:
+            try:
+                payload = _decode_jwt_payload(cached_jwt)
+                exp = payload.get("exp", 0)
+                current_time = int(time.time())
+                if exp - current_time > 60:
+                    return cached_jwt
+            except Exception:
+                pass
+
+        # Fetch new JWT
+        jwt = await _get_service_jwt(psk_token, sovereign_url)
+
+        # Cache for 14 minutes (840 seconds)
+        dominus_cache.set(cache_key, jwt, ttl=840)
+
+        return jwt
 
 
 def verify_token_format(token: str) -> bool:
@@ -524,12 +543,16 @@ async def health_check_all(base_url: str) -> dict:
     Returns:
         Health status dict with service results
     """
+    from ..config.endpoints import get_proxy_config
+    proxy_config = get_proxy_config()
+
     results = {}
 
     # Check orchestrator via /api/health
+    # Timeout: 15s to handle cold starts on Cloud Run
     try:
         start = time.time()
-        async with httpx.AsyncClient(base_url=base_url, timeout=5.0) as client:
+        async with httpx.AsyncClient(base_url=base_url, timeout=15.0, proxies=proxy_config) as client:
             response = await client.get("/api/health")
             response.raise_for_status()
 
@@ -587,32 +610,35 @@ async def execute_with_retry(
 ) -> DominusResponse:
     """
     Execute HTTP request with retry logic.
-    
+
     Args:
         route_info: (method, path, requires_auth, cacheable)
         base_url: Base URL for API
         token: Auth token (if needed)
         kwargs: Request parameters
-        
+
     Returns:
         Response dict
     """
+    from ..config.endpoints import get_proxy_config
+    proxy_config = get_proxy_config()
+
     method, path, requires_auth, cacheable = route_info
-    
+
     # Check cache first
     if cacheable and kwargs:
         cache_key = f"{path}:{str(sorted(kwargs.items()))}"
         cached = dominus_cache.get(cache_key)
         if cached:
             return cached
-    
+
     # Validate token
     if requires_auth and not token:
         raise RuntimeError(
             "DOMINUS_TOKEN not set. "
             "Set the environment variable: export DOMINUS_TOKEN=your_token"
         )
-    
+
     # Retry loop with exponential backoff and jitter
     for attempt in range(MAX_RETRIES):
         try:
@@ -620,7 +646,7 @@ async def execute_with_retry(
             headers = {}
             if requires_auth:
                 headers["Authorization"] = f"Bearer {_b64_token(token)}"
-            
+
             # Prepare body (encode if auth required and kwargs provided)
             # For auth routes: send raw base64 string as text/plain (matches middleware expectation)
             # For non-auth routes: send JSON as normal
@@ -630,9 +656,9 @@ async def execute_with_retry(
                 body = body_b64
             else:
                 body = kwargs if kwargs else {}
-            
+
             # Make request
-            async with httpx.AsyncClient(base_url=base_url, headers=headers, timeout=30.0) as client:
+            async with httpx.AsyncClient(base_url=base_url, headers=headers, timeout=30.0, proxies=proxy_config) as client:
                 if method == "GET":
                     response = await client.get(path, params=kwargs if kwargs else None)
                 else:
@@ -720,6 +746,9 @@ async def execute_bridge_call(
     Returns:
         Response data (the "data" field from successful response)
     """
+    from ..config.endpoints import get_proxy_config
+    proxy_config = get_proxy_config()
+
     # Check cache first
     if cacheable and params:
         cache_key = f"bridge:{method}:{str(sorted(params.items()))}"
@@ -749,7 +778,7 @@ async def execute_bridge_call(
     # Retry loop with exponential backoff and jitter
     for attempt in range(MAX_RETRIES):
         try:
-            async with httpx.AsyncClient(base_url=base_url, headers=headers, timeout=30.0) as client:
+            async with httpx.AsyncClient(base_url=base_url, headers=headers, timeout=30.0, proxies=proxy_config) as client:
                 response = await client.post(endpoint, content=body_b64)
 
             response.raise_for_status()
@@ -878,8 +907,9 @@ async def _execute_auth_call(
     Returns:
         Response data
     """
-    from ..config.endpoints import get_gateway_url
+    from ..config.endpoints import get_gateway_url, get_proxy_config
     gateway_url = get_gateway_url()
+    proxy_config = get_proxy_config()
 
     headers = {
         "Content-Type": "text/plain"
@@ -901,7 +931,7 @@ async def _execute_auth_call(
     else:
         endpoint = "/jwt/mint"
 
-    async with httpx.AsyncClient(base_url=gateway_url, headers=headers, timeout=30.0) as client:
+    async with httpx.AsyncClient(base_url=gateway_url, headers=headers, timeout=30.0, proxies=proxy_config) as client:
         # JWKS uses GET (public endpoint), other auth endpoints use POST
         if method == "auth.jwks":
             response = await client.get(endpoint)

{dominus_sdk_python-2.8.0 → dominus_sdk_python-2.9.0}/dominus/namespaces/__init__.py

@@ -1,4 +1,4 @@
-"""Dominus SDK Namespaces v2.7"""
+"""Dominus SDK Namespaces v2.8"""
 from .secrets import SecretsNamespace
 from .db import DbNamespace
 from .redis import RedisNamespace
@@ -10,6 +10,7 @@ from .open import OpenNamespace
 from .health import HealthNamespace
 from .portal import PortalNamespace
 from .courier import CourierNamespace
+from .workflow import WorkflowNamespace
 from .ai import (
     AiNamespace,
     RagSubNamespace,
@@ -30,6 +31,7 @@ __all__ = [
     "HealthNamespace",
     "PortalNamespace",
     "CourierNamespace",
+    "WorkflowNamespace",
     "AiNamespace",
     "RagSubNamespace",
     "ArtifactsSubNamespace",

dominus_sdk_python-2.9.0/dominus/namespaces/workflow.py

@@ -0,0 +1,522 @@
+"""
+Workflow Namespace - Workflow management operations.
+
+Provides CRUD operations for workflows, categories/pipelines, and templates.
+Routes through gateway to dominus-workflow-manager service.
+
+Usage:
+    from dominus import dominus
+
+    # Workflow CRUD
+    workflow = await dominus.workflow.save(
+        name="My Workflow",
+        yaml_content="name: My Workflow\nnodes: []",
+        description="A test workflow"
+    )
+    workflows = await dominus.workflow.list()
+    workflow = await dominus.workflow.get(workflow_id, include_content=True)
+    await dominus.workflow.delete(workflow_id)
+
+    # Categories (execution pipelines)
+    category = await dominus.workflow.create_category(
+        name="Intake Pipeline",
+        description="Patient intake workflow sequence"
+    )
+    await dominus.workflow.add_to_category(category_id, workflow_id)
+    categories = await dominus.workflow.list_categories()
+
+    # Templates
+    templates = await dominus.workflow.list_templates()
+    await dominus.workflow.copy_template(template_id)
+
+    # Execution
+    result = await dominus.workflow.execute(workflow_id, context={"key": "value"})
+    result = await dominus.workflow.execute_async(workflow_id, callback_url="...")
+    result = await dominus.workflow.execute_category(category_id)
+"""
+from typing import Any, Dict, List, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..start import Dominus
+
+
+class WorkflowNamespace:
+    """
+    Workflow management namespace.
+
+    Provides operations for workflow CRUD, categories/pipelines, templates,
+    and execution via the dominus-workflow-manager service.
+    """
+
+    def __init__(self, client: "Dominus"):
+        self._client = client
+
+    async def _api(
+        self,
+        endpoint: str,
+        method: str = "POST",
+        body: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """Make gateway-routed API request to workflow-manager."""
+        return await self._client._request(
+            endpoint=endpoint,
+            method=method,
+            body=body,
+            use_gateway=True
+        )
+
+    # ========================================
+    # Workflow CRUD
+    # ========================================
+
+    async def save(
+        self,
+        name: str,
+        yaml_content: str,
+        workflow_id: Optional[str] = None,
+        tenant_slug: Optional[str] = None,
+        description: Optional[str] = None,
+        category_id: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        is_template: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Save a workflow (create or update).
+
+        Args:
+            name: Workflow display name
+            yaml_content: YAML workflow definition
+            workflow_id: Optional ID for updates (omit for create)
+            tenant_slug: Optional tenant scope
+            description: Optional description
+            category_id: Optional category to assign
+            tags: Optional list of tags
+            is_template: Whether this is a template
+
+        Returns:
+            Dict with workflow metadata
+        """
+        body: Dict[str, Any] = {
+            "name": name,
+            "yaml_content": yaml_content,
+        }
+        if workflow_id:
+            body["workflow_id"] = workflow_id
+        if tenant_slug:
+            body["tenant_slug"] = tenant_slug
+        if description:
+            body["description"] = description
+        if category_id:
+            body["category_id"] = category_id
+        if tags:
+            body["tags"] = tags
+        if is_template:
+            body["is_template"] = is_template
+
+        return await self._api(
+            endpoint="/api/workflow/workflows",
+            body=body
+        )
+
+    async def get(
+        self,
+        workflow_id: str,
+        include_content: bool = False
+    ) -> Dict[str, Any]:
+        """
+        Get a workflow by ID.
+
+        Args:
+            workflow_id: Workflow UUID
+            include_content: Whether to include YAML content
+
+        Returns:
+            Dict with workflow metadata and optionally content
+        """
+        endpoint = f"/api/workflow/workflows/{workflow_id}"
+        if include_content:
+            endpoint += "?include_content=true"
+        return await self._api(endpoint=endpoint, method="GET")
+
+    async def list(
+        self,
+        tenant_slug: Optional[str] = None,
+        category_id: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        is_template: Optional[bool] = None,
+        search: Optional[str] = None,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> List[Dict[str, Any]]:
+        """
+        List workflows.
+
+        Args:
+            tenant_slug: Filter by tenant
+            category_id: Filter by category
+            tags: Filter by tags (any match)
+            is_template: Filter by template status
+            search: Search in name/description
+            limit: Max results
+            offset: Pagination offset
+
+        Returns:
+            List of workflow metadata dicts
+        """
+        body: Dict[str, Any] = {"limit": limit, "offset": offset}
+        if tenant_slug:
+            body["tenant_slug"] = tenant_slug
+        if category_id:
+            body["category_id"] = category_id
+        if tags:
+            body["tags"] = tags
+        if is_template is not None:
+            body["is_template"] = is_template
+        if search:
+            body["search"] = search
+
+        result = await self._api(
+            endpoint="/api/workflow/workflows/list",
+            body=body
+        )
+        return result.get("workflows", result) if isinstance(result, dict) else result
+
+    async def delete(self, workflow_id: str) -> Dict[str, Any]:
+        """
+        Delete a workflow.
+
+        Args:
+            workflow_id: Workflow UUID
+
+        Returns:
+            Dict with deletion status
+        """
+        return await self._api(
+            endpoint=f"/api/workflow/workflows/{workflow_id}",
+            method="DELETE"
+        )
+
+    # ========================================
+    # Categories (Execution Pipelines)
+    # ========================================
+
+    async def create_category(
+        self,
+        name: str,
+        tenant_slug: Optional[str] = None,
+        description: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Create a category (execution pipeline).
+
+        Args:
+            name: Category display name
+            tenant_slug: Optional tenant scope
+            description: Optional description
+
+        Returns:
+            Dict with category metadata
+        """
+        body: Dict[str, Any] = {"name": name}
+        if tenant_slug:
+            body["tenant_slug"] = tenant_slug
+        if description:
+            body["description"] = description
+
+        return await self._api(
+            endpoint="/api/workflow/categories",
+            body=body
+        )
+
+    async def get_category(
+        self,
+        category_id: str,
+        include_workflows: bool = False
+    ) -> Dict[str, Any]:
+        """
+        Get a category by ID.
+
+        Args:
+            category_id: Category UUID
+            include_workflows: Whether to include workflow list
+
+        Returns:
+            Dict with category metadata and optionally workflows
+        """
+        endpoint = f"/api/workflow/categories/{category_id}"
+        if include_workflows:
+            endpoint += "?include_workflows=true"
+        return await self._api(endpoint=endpoint, method="GET")
+
+    async def list_categories(
+        self,
+        tenant_slug: Optional[str] = None,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> List[Dict[str, Any]]:
+        """
+        List categories.
+
+        Args:
+            tenant_slug: Filter by tenant
+            limit: Max results
+            offset: Pagination offset
+
+        Returns:
+            List of category metadata dicts
+        """
+        body: Dict[str, Any] = {"limit": limit, "offset": offset}
+        if tenant_slug:
+            body["tenant_slug"] = tenant_slug
+
+        result = await self._api(
+            endpoint="/api/workflow/categories/list",
+            body=body
+        )
+        return result.get("categories", result) if isinstance(result, dict) else result
+
+    async def delete_category(self, category_id: str) -> Dict[str, Any]:
+        """
+        Delete a category.
+
+        Args:
+            category_id: Category UUID
+
+        Returns:
+            Dict with deletion status
+        """
+        return await self._api(
+            endpoint=f"/api/workflow/categories/{category_id}",
+            method="DELETE"
+        )
+
+    async def add_to_category(
+        self,
+        category_id: str,
+        workflow_id: str,
+        position: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """
+        Add a workflow to a category.
+
+        Args:
+            category_id: Category UUID
+            workflow_id: Workflow UUID
+            position: Optional position in execution order
+
+        Returns:
+            Dict with operation status
+        """
+        body: Dict[str, Any] = {"workflow_id": workflow_id}
+        if position is not None:
+            body["position"] = position
+
+        return await self._api(
+            endpoint=f"/api/workflow/categories/{category_id}/workflows",
+            body=body
+        )
+
+    async def remove_from_category(
+        self,
+        category_id: str,
+        workflow_id: str,
+    ) -> Dict[str, Any]:
+        """
+        Remove a workflow from a category.
+
+        Args:
+            category_id: Category UUID
+            workflow_id: Workflow UUID
+
+        Returns:
+            Dict with operation status
+        """
+        return await self._api(
+            endpoint=f"/api/workflow/categories/{category_id}/workflows/{workflow_id}",
+            method="DELETE"
+        )
+
+    async def reorder_category(
+        self,
+        category_id: str,
+        workflow_order: List[str],
+    ) -> Dict[str, Any]:
+        """
+        Reorder workflows in a category.
+
+        Args:
+            category_id: Category UUID
+            workflow_order: List of workflow IDs in desired order
+
+        Returns:
+            Dict with operation status
+        """
+        return await self._api(
+            endpoint=f"/api/workflow/categories/{category_id}/reorder",
+            body={"workflow_order": workflow_order}
+        )
+
+    # ========================================
+    # Templates
+    # ========================================
+
+    async def list_templates(
+        self,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> List[Dict[str, Any]]:
+        """
+        List available templates.
+
+        Args:
+            limit: Max results
+            offset: Pagination offset
+
+        Returns:
+            List of template metadata dicts
+        """
+        result = await self._api(
+            endpoint="/api/workflow/templates",
+            method="GET"
+        )
+        return result.get("templates", result) if isinstance(result, dict) else result
+
+    async def get_template(
+        self,
+        template_id: str,
+        include_content: bool = False
+    ) -> Dict[str, Any]:
+        """
+        Get a template by ID.
+
+        Args:
+            template_id: Template UUID
+            include_content: Whether to include YAML content
+
+        Returns:
+            Dict with template metadata and optionally content
+        """
+        endpoint = f"/api/workflow/templates/{template_id}"
+        if include_content:
+            endpoint += "?include_content=true"
+        return await self._api(endpoint=endpoint, method="GET")
+
+    async def copy_template(
+        self,
+        template_id: str,
+        name: Optional[str] = None,
+        tenant_slug: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Copy a template to create a new workflow.
+
+        Args:
+            template_id: Template UUID to copy
+            name: Optional name for the new workflow
+            tenant_slug: Optional tenant scope
+
+        Returns:
+            Dict with new workflow metadata
+        """
+        body: Dict[str, Any] = {}
+        if name:
+            body["name"] = name
+        if tenant_slug:
+            body["tenant_slug"] = tenant_slug
+
+        return await self._api(
+            endpoint=f"/api/workflow/templates/{template_id}/copy",
+            body=body
+        )
+
+    # ========================================
+    # Execution
+    # ========================================
+
+    async def execute(
+        self,
+        workflow_id: str,
+        context: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Execute a workflow synchronously.
+
+        Args:
+            workflow_id: Workflow UUID
+            context: Optional initial context/variables
+
+        Returns:
+            Dict with execution result
+        """
+        body: Dict[str, Any] = {
+            "workflow_id": workflow_id,
+            "async_mode": False,
+        }
+        if context:
+            body["context"] = context
+
+        return await self._api(
+            endpoint="/api/workflow/execute/workflow",
+            body=body
+        )
+
+    async def execute_async(
+        self,
+        workflow_id: str,
+        context: Optional[Dict[str, Any]] = None,
+        callback_url: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Execute a workflow asynchronously.
+
+        Args:
+            workflow_id: Workflow UUID
+            context: Optional initial context/variables
+            callback_url: URL to POST results to when complete
+
+        Returns:
+            Dict with execution_id for tracking
+        """
+        body: Dict[str, Any] = {
+            "workflow_id": workflow_id,
+            "async_mode": True,
+        }
+        if context:
+            body["context"] = context
+        if callback_url:
+            body["callback_url"] = callback_url
+
+        return await self._api(
+            endpoint="/api/workflow/execute/workflow",
+            body=body
+        )
+
+    async def execute_category(
+        self,
+        category_id: str,
+        context: Optional[Dict[str, Any]] = None,
+        callback_url: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Execute a category/pipeline (all workflows in sequence).
+
+        Categories always execute asynchronously.
+
+        Args:
+            category_id: Category UUID
+            context: Optional initial context/variables
+            callback_url: URL to POST results to when complete
+
+        Returns:
+            Dict with execution_id for tracking
+        """
+        body: Dict[str, Any] = {"category_id": category_id}
+        if context:
+            body["context"] = context
+        if callback_url:
+            body["callback_url"] = callback_url
+
+        return await self._api(
+            endpoint="/api/workflow/execute/category",
+            body=body
+        )

{dominus_sdk_python-2.8.0 → dominus_sdk_python-2.9.0}/dominus/start.py

@@ -355,6 +355,10 @@ class Dominus:
         from .namespaces.ai import AiNamespace
         self.ai = AiNamespace(self)
 
+        # Workflow namespace (workflow-manager service)
+        from .namespaces.workflow import WorkflowNamespace
+        self.workflow = WorkflowNamespace(self)
+
         # Cache for JWT public key
         self._public_key_cache = None
 

{dominus_sdk_python-2.8.0 → dominus_sdk_python-2.9.0}/dominus_sdk_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dominus-sdk-python
-Version: 2.8.0
+Version: 2.9.0
 Summary: Python SDK for the Dominus Orchestrator Platform
 Author-email: CareBridge Systems <dev@carebridge.io>
 License: Proprietary

{dominus_sdk_python-2.8.0 → dominus_sdk_python-2.9.0}/dominus_sdk_python.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ dominus/namespaces/portal.py
 dominus/namespaces/redis.py
 dominus/namespaces/secrets.py
 dominus/namespaces/secure.py
+dominus/namespaces/workflow.py
 dominus/namespaces/oracle/__init__.py
 dominus/namespaces/oracle/audio_capture.py
 dominus/namespaces/oracle/oracle_websocket.py

{dominus_sdk_python-2.8.0 → dominus_sdk_python-2.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dominus-sdk-python"
-version = "2.8.0"
+version = "2.9.0"
 description = "Python SDK for the Dominus Orchestrator Platform"
 readme = "README.md"
 license = {text = "Proprietary"}