dominus-sdk-python 2.7.0__tar.gz → 2.7.2__tar.gz

{dominus_sdk_python-2.7.0 → dominus_sdk_python-2.7.2}/PKG-INFO

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

{dominus_sdk_python-2.7.0 → dominus_sdk_python-2.7.2}/dominus/__init__.py

@@ -140,7 +140,7 @@ from .errors import (
     TimeoutError as DominusTimeoutError,
 )
 
-__version__ = "2.7.0"
+__version__ = "2.7.2"
 __all__ = [
     # Main SDK instance
     "dominus",

{dominus_sdk_python-2.7.0 → dominus_sdk_python-2.7.2}/dominus/namespaces/ai.py

@@ -49,11 +49,90 @@ if TYPE_CHECKING:
     from ..start import Dominus
 
 
+# ========================================
+# Gateway-routed API helper
+# ========================================
+
+class GatewayMixin:
+    """
+    Mixin that provides gateway-routed API calls.
+
+    All AI namespace methods route through the gateway's /svc/* endpoints
+    which proxy to agent-runtime's /api/* endpoints.
+    """
+    _client: "Dominus"
+
+    async def _api(
+        self,
+        endpoint: str,
+        method: str = "POST",
+        body: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """Make gateway-routed API request."""
+        return await self._client._request(
+            endpoint=endpoint,
+            method=method,
+            body=body,
+            use_gateway=True
+        )
+
+    async def _api_stream(
+        self,
+        endpoint: str,
+        body: Optional[Dict[str, Any]] = None,
+        on_chunk: Optional[Any] = None,
+        timeout: float = 300.0
+    ):
+        """Make gateway-routed streaming request."""
+        async for chunk in self._client._stream_request(
+            endpoint=endpoint,
+            body=body,
+            on_chunk=on_chunk,
+            timeout=timeout,
+            use_gateway=True
+        ):
+            yield chunk
+
+    async def _api_upload(
+        self,
+        endpoint: str,
+        file_bytes: bytes,
+        filename: str,
+        content_type: str = "application/octet-stream",
+        additional_fields: Optional[Dict[str, str]] = None,
+        timeout: float = 60.0
+    ) -> Dict[str, Any]:
+        """Make gateway-routed binary upload."""
+        return await self._client._binary_upload(
+            endpoint=endpoint,
+            file_bytes=file_bytes,
+            filename=filename,
+            content_type=content_type,
+            additional_fields=additional_fields,
+            timeout=timeout,
+            use_gateway=True
+        )
+
+    async def _api_download(
+        self,
+        endpoint: str,
+        body: Optional[Dict[str, Any]] = None,
+        timeout: float = 60.0
+    ) -> bytes:
+        """Make gateway-routed binary download."""
+        return await self._client._binary_download(
+            endpoint=endpoint,
+            body=body,
+            timeout=timeout,
+            use_gateway=True
+        )
+
+
 # ========================================
 # RAG Sub-namespace
 # ========================================
 
-class RagSubNamespace:
+class RagSubNamespace(GatewayMixin):
     """
     RAG corpus management sub-namespace.
 
@@ -65,7 +144,7 @@ class RagSubNamespace:
 
     async def list(self) -> List[Dict[str, Any]]:
         """List all corpora."""
-        result = await self._client._request(
+        result = await self._api(
             endpoint="/api/rag",
             method="GET"
         )
@@ -91,21 +170,21 @@ class RagSubNamespace:
         if embedding_model:
             body["embedding_model"] = embedding_model
 
-        return await self._client._request(
+        return await self._api(
             endpoint=f"/api/rag/{slug}/ensure",
             body=body if body else {}
         )
 
     async def stats(self, slug: str) -> Dict[str, Any]:
         """Get corpus statistics."""
-        return await self._client._request(
+        return await self._api(
             endpoint=f"/api/rag/{slug}/stats",
             method="GET"
         )
 
     async def drop(self, slug: str) -> Dict[str, Any]:
         """Drop/delete a corpus."""
-        return await self._client._request(
+        return await self._api(
             endpoint=f"/api/rag/{slug}",
             method="DELETE"
         )
@@ -122,7 +201,7 @@ class RagSubNamespace:
         if category:
             body["category"] = category
 
-        return await self._client._request(
+        return await self._api(
             endpoint=f"/api/rag/{slug}/entries",
             body=body
         )
@@ -132,7 +211,11 @@ class RagSubNamespace:
         slug: str,
         identifier: str,
         content: str,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
         category: Optional[str] = None,
+        subcategory: Optional[str] = None,
+        source_reference: Optional[Dict[str, Any]] = None,
         metadata: Optional[Dict[str, Any]] = None
     ) -> Dict[str, Any]:
         """
@@ -141,17 +224,29 @@ class RagSubNamespace:
         Args:
             slug: Corpus identifier
             identifier: Entry identifier (unique within corpus)
-            content: Text content to embed
+            content: Text content to embed (stored as content_markdown)
+            name: Optional human-readable name
+            description: Optional brief description
             category: Optional category for filtering
+            subcategory: Optional subcategory
+            source_reference: Optional source attribution
             metadata: Optional metadata dict
         """
-        body: Dict[str, Any] = {"content": content}
+        body: Dict[str, Any] = {"content_markdown": content}
+        if name:
+            body["name"] = name
+        if description:
+            body["description"] = description
         if category:
             body["category"] = category
+        if subcategory:
+            body["subcategory"] = subcategory
+        if source_reference:
+            body["source_reference"] = source_reference
         if metadata:
             body["metadata"] = metadata
 
-        return await self._client._request(
+        return await self._api(
             endpoint=f"/api/rag/{slug}/{identifier}",
             method="PUT",
             body=body
@@ -159,14 +254,14 @@ class RagSubNamespace:
 
     async def get(self, slug: str, identifier: str) -> Dict[str, Any]:
         """Get a specific entry."""
-        return await self._client._request(
+        return await self._api(
             endpoint=f"/api/rag/{slug}/{identifier}",
             method="GET"
         )
 
     async def delete(self, slug: str, identifier: str) -> Dict[str, Any]:
         """Delete an entry."""
-        return await self._client._request(
+        return await self._api(
             endpoint=f"/api/rag/{slug}/{identifier}",
             method="DELETE"
         )
@@ -181,11 +276,30 @@ class RagSubNamespace:
 
         Args:
             slug: Corpus identifier
-            entries: List of {"identifier", "content", "category", "metadata"} dicts
+            entries: List of entry dicts with:
+                - identifier: string (required)
+                - content: string (required) - Will be sent as content_markdown
+                - name: string (optional)
+                - description: string (optional)
+                - category: string (optional)
+                - subcategory: string (optional)
+                - source_reference: dict (optional)
+                - metadata: dict (optional)
+
+        Returns:
+            Dict with "processed", "failed", "errors" counts
         """
-        return await self._client._request(
+        # Transform 'content' to 'content_markdown' for API compatibility
+        transformed = []
+        for entry in entries:
+            e = dict(entry)
+            if "content" in e and "content_markdown" not in e:
+                e["content_markdown"] = e.pop("content")
+            transformed.append(e)
+
+        return await self._api(
             endpoint=f"/api/rag/{slug}/bulk",
-            body={"entries": entries}
+            body={"entries": transformed}
         )
 
     async def search(
@@ -222,7 +336,7 @@ class RagSubNamespace:
         if filters:
             body["filters"] = filters
 
-        result = await self._client._request(
+        result = await self._api(
             endpoint=f"/api/rag/{slug}/search",
             body=body
         )
@@ -251,7 +365,7 @@ class RagSubNamespace:
         if rerank_model:
             body["rerank_model"] = rerank_model
 
-        result = await self._client._request(
+        result = await self._api(
             endpoint=f"/api/rag/{slug}/search/rerank",
             body=body
         )
@@ -277,7 +391,7 @@ class RagSubNamespace:
             chunk_size: Chunk size for splitting (default: 1000 chars)
             chunk_overlap: Overlap between chunks (default: 200 chars)
         """
-        return await self._client._binary_upload(
+        return await self._api_upload(
             endpoint=f"/api/rag/{slug}/ingest",
             file_bytes=content,
             filename=filename,
@@ -290,7 +404,7 @@ class RagSubNamespace:
 
     async def delete_document(self, slug: str, document_id: str) -> Dict[str, Any]:
         """Delete a document and all its chunks."""
-        return await self._client._request(
+        return await self._api(
             endpoint=f"/api/rag/{slug}/document/{document_id}",
             method="DELETE"
         )
@@ -300,7 +414,7 @@ class RagSubNamespace:
 # Artifacts Sub-namespace
 # ========================================
 
-class ArtifactsSubNamespace:
+class ArtifactsSubNamespace(GatewayMixin):
     """
     Artifacts sub-namespace for conversation artifact management.
     """
@@ -311,16 +425,12 @@ class ArtifactsSubNamespace:
     async def get(
         self,
         artifact_id: str,
-        conversation_id: Optional[str] = None
+        conversation_id: str
     ) -> Dict[str, Any]:
         """Get artifact by ID."""
-        body: Dict[str, Any] = {"artifact_id": artifact_id}
-        if conversation_id:
-            body["conversation_id"] = conversation_id
-
-        return await self._client._request(
-            endpoint=f"/api/agent/artifacts/{artifact_id}",
-            body=body
+        return await self._api(
+            endpoint=f"/api/agent/artifacts/{artifact_id}?conversation_id={conversation_id}",
+            method="GET"
         )
 
     async def create(
@@ -328,67 +438,54 @@ class ArtifactsSubNamespace:
         name: str,
         content: str,
         conversation_id: str,
-        artifact_type: str = "text",
+        artifact_type: str = "text/plain",
+        is_base64: bool = False,
         metadata: Optional[Dict[str, Any]] = None
     ) -> Dict[str, Any]:
         """
         Create a new artifact.
 
         Args:
-            name: Artifact name/filename
-            content: Artifact content (text or base64 for binary)
+            name: Artifact key/filename
+            content: Artifact content (text or base64-encoded for binary)
             conversation_id: Associated conversation ID
-            artifact_type: Type of artifact (text, code, image, etc.)
-            metadata: Optional metadata dict
+            artifact_type: MIME content type (e.g., "text/plain", "text/html", "image/png")
+            is_base64: If True, content is base64-encoded binary
+            metadata: Optional metadata dict (not stored, for SDK use)
         """
         body: Dict[str, Any] = {
-            "name": name,
+            "key": name,
             "content": content,
             "conversation_id": conversation_id,
-            "type": artifact_type
+            "content_type": artifact_type,
+            "is_base64": is_base64
         }
-        if metadata:
-            body["metadata"] = metadata
 
-        return await self._client._request(
+        return await self._api(
             endpoint="/api/agent/artifacts",
             body=body
         )
 
     async def list(
         self,
-        conversation_id: str,
-        limit: int = 100,
-        offset: int = 0
+        conversation_id: str
     ) -> List[Dict[str, Any]]:
         """List artifacts for a conversation."""
-        body: Dict[str, Any] = {
-            "conversation_id": conversation_id,
-            "limit": limit,
-            "offset": offset
-        }
-
-        result = await self._client._request(
-            endpoint="/api/agent/artifacts",
-            method="GET",
-            body=body
+        result = await self._api(
+            endpoint=f"/api/agent/artifacts?conversation_id={conversation_id}",
+            method="GET"
         )
         return result.get("artifacts", result) if isinstance(result, dict) else result
 
     async def delete(
         self,
         artifact_id: str,
-        conversation_id: Optional[str] = None
+        conversation_id: str
     ) -> Dict[str, Any]:
         """Delete an artifact."""
-        body: Dict[str, Any] = {}
-        if conversation_id:
-            body["conversation_id"] = conversation_id
-
-        return await self._client._request(
-            endpoint=f"/api/agent/artifacts/{artifact_id}",
-            method="DELETE",
-            body=body if body else None
+        return await self._api(
+            endpoint=f"/api/agent/artifacts/{artifact_id}?conversation_id={conversation_id}",
+            method="DELETE"
         )
 
 
@@ -396,7 +493,7 @@ class ArtifactsSubNamespace:
 # Results Sub-namespace
 # ========================================
 
-class ResultsSubNamespace:
+class ResultsSubNamespace(GatewayMixin):
     """
     Async results sub-namespace for polling async operation results.
     """
@@ -415,7 +512,7 @@ class ResultsSubNamespace:
             Dict with "status" (pending|running|completed|failed),
             "result" (if completed), "error" (if failed)
         """
-        return await self._client._request(
+        return await self._api(
             endpoint=f"/api/results/{result_key}",
             method="GET"
         )
@@ -460,7 +557,7 @@ class ResultsSubNamespace:
 # Workflow Sub-namespace
 # ========================================
 
-class WorkflowSubNamespace:
+class WorkflowSubNamespace(GatewayMixin):
     """
     Multi-agent workflow orchestration sub-namespace.
     """
@@ -499,7 +596,7 @@ class WorkflowSubNamespace:
         if webhook_url:
             body["webhook_url"] = webhook_url
 
-        return await self._client._request(
+        return await self._api(
             endpoint="/api/orchestration/execute",
             body=body
         )
@@ -517,7 +614,7 @@ class WorkflowSubNamespace:
         Returns:
             Dict with "valid", "errors" (if invalid)
         """
-        return await self._client._request(
+        return await self._api(
             endpoint="/api/orchestration/validate",
             body={"definition": workflow_definition}
         )
@@ -529,7 +626,7 @@ class WorkflowSubNamespace:
         offset: int = 0
     ) -> List[Dict[str, Any]]:
         """Get messages from an execution."""
-        result = await self._client._request(
+        result = await self._api(
             endpoint=f"/api/orchestration/messages/{execution_id}",
             body={"limit": limit, "offset": offset}
         )
@@ -545,7 +642,7 @@ class WorkflowSubNamespace:
         if from_timestamp:
             body["from"] = from_timestamp
 
-        result = await self._client._request(
+        result = await self._api(
             endpoint=f"/api/orchestration/events/{execution_id}",
             body=body if body else None
         )
@@ -553,14 +650,14 @@ class WorkflowSubNamespace:
 
     async def status(self, execution_id: str) -> Dict[str, Any]:
         """Get execution status."""
-        return await self._client._request(
+        return await self._api(
             endpoint=f"/api/orchestration/status/{execution_id}",
             method="GET"
         )
 
     async def output(self, execution_id: str) -> Dict[str, Any]:
         """Get final execution output."""
-        return await self._client._request(
+        return await self._api(
             endpoint=f"/api/orchestration/output/{execution_id}",
             method="GET"
         )
@@ -570,7 +667,7 @@ class WorkflowSubNamespace:
 # Main AI Namespace
 # ========================================
 
-class AiNamespace:
+class AiNamespace(GatewayMixin):
     """
     Unified AI namespace for agent-runtime operations.
 
@@ -656,7 +753,7 @@ class AiNamespace:
         if tool_endpoint:
             body["tool_endpoint"] = tool_endpoint
 
-        return await self._client._request(
+        return await self._api(
             endpoint="/api/agent/run",
             body=body
         )
@@ -722,7 +819,7 @@ class AiNamespace:
         if tool_endpoint:
             body["tool_endpoint"] = tool_endpoint
 
-        async for chunk in self._client._stream_request(
+        async for chunk in self._api_stream(
             endpoint="/api/agent/stream",
             body=body,
             on_chunk=on_chunk,
@@ -796,7 +893,7 @@ class AiNamespace:
         if webhook_url:
             body["webhook_url"] = webhook_url
 
-        return await self._client._request(
+        return await self._api(
             endpoint="/api/agent/run-async",
             body=body
         )
@@ -820,11 +917,11 @@ class AiNamespace:
         Returns:
             List of history messages
         """
-        result = await self._client._request(
-            endpoint=f"/api/agent/history/{conversation_id}",
-            body={"limit": limit}
+        result = await self._api(
+            endpoint=f"/api/agent/history/{conversation_id}?limit={limit}",
+            method="GET"
         )
-        return result.get("history", result) if isinstance(result, dict) else result
+        return result.get("messages", result) if isinstance(result, dict) else result
 
     # ========================================
     # LLM Completions
@@ -832,58 +929,79 @@ class AiNamespace:
 
     async def complete(
         self,
-        messages: List[Dict[str, Any]],
+        messages: Optional[List[Dict[str, Any]]] = None,
         provider: str = "claude",
         model: str = "claude-sonnet-4-5",
         conversation_id: Optional[str] = None,
         temperature: float = 0.7,
         max_tokens: Optional[int] = None,
         system_prompt: Optional[str] = None,
+        user_prompt: Optional[str] = None,
         timeout: float = 120.0
     ) -> Dict[str, Any]:
         """
         Blocking LLM completion.
 
         Args:
-            messages: List of message dicts with "role" and "content"
+            messages: List of message dicts with "role" and "content" (optional)
             provider: LLM provider ("claude" or "openai")
             model: Model identifier
             conversation_id: Optional conversation ID
             temperature: Temperature (0-2, default: 0.7)
             max_tokens: Maximum tokens to generate
-            system_prompt: Optional system prompt
+            system_prompt: System prompt (required if messages not provided)
+            user_prompt: User prompt (required if messages not provided)
             timeout: Request timeout in seconds
 
         Returns:
             Dict with "content", "model", "usage", etc.
+
+        Note:
+            Either provide `messages` OR both `system_prompt` and `user_prompt`.
+            If messages provided, the last user message becomes user_prompt,
+            and system messages become system_prompt.
         """
+        # Convert messages to system_prompt/user_prompt if needed
+        if messages and not user_prompt:
+            for msg in messages:
+                if msg.get("role") == "system":
+                    system_prompt = msg.get("content", system_prompt)
+                elif msg.get("role") == "user":
+                    user_prompt = msg.get("content")
+
+        if not system_prompt:
+            system_prompt = "You are a helpful assistant."
+
+        if not user_prompt:
+            raise ValueError("Either 'messages' with a user message or 'user_prompt' is required")
+
         body: Dict[str, Any] = {
-            "messages": messages,
             "provider": provider,
             "model": model,
+            "system_prompt": system_prompt,
+            "user_prompt": user_prompt,
             "temperature": temperature
         }
         if conversation_id:
             body["conversation_id"] = conversation_id
         if max_tokens:
             body["max_tokens"] = max_tokens
-        if system_prompt:
-            body["system_prompt"] = system_prompt
 
-        return await self._client._request(
+        return await self._api(
             endpoint="/api/llm/complete",
             body=body
         )
 
     async def complete_stream(
         self,
-        messages: List[Dict[str, Any]],
+        messages: Optional[List[Dict[str, Any]]] = None,
         provider: str = "claude",
         model: str = "claude-sonnet-4-5",
         conversation_id: Optional[str] = None,
         temperature: float = 0.7,
         max_tokens: Optional[int] = None,
         system_prompt: Optional[str] = None,
+        user_prompt: Optional[str] = None,
         on_chunk: Optional[Callable[[Dict[str, Any]], None]] = None,
         timeout: float = 120.0
     ) -> AsyncGenerator[Dict[str, Any], None]:
@@ -891,33 +1009,47 @@ class AiNamespace:
         Streaming LLM completion.
 
         Args:
-            messages: List of message dicts
+            messages: List of message dicts (optional)
             provider: LLM provider
             model: Model identifier
             conversation_id: Optional conversation ID
             temperature: Temperature (0-2)
             max_tokens: Maximum tokens
-            system_prompt: Optional system prompt
+            system_prompt: System prompt (required if messages not provided)
+            user_prompt: User prompt (required if messages not provided)
             on_chunk: Optional callback for each chunk
             timeout: Request timeout
 
         Yields:
             Streaming chunks with "content" delta
         """
+        # Convert messages to system_prompt/user_prompt if needed
+        if messages and not user_prompt:
+            for msg in messages:
+                if msg.get("role") == "system":
+                    system_prompt = msg.get("content", system_prompt)
+                elif msg.get("role") == "user":
+                    user_prompt = msg.get("content")
+
+        if not system_prompt:
+            system_prompt = "You are a helpful assistant."
+
+        if not user_prompt:
+            raise ValueError("Either 'messages' with a user message or 'user_prompt' is required")
+
         body: Dict[str, Any] = {
-            "messages": messages,
             "provider": provider,
             "model": model,
+            "system_prompt": system_prompt,
+            "user_prompt": user_prompt,
             "temperature": temperature
         }
         if conversation_id:
             body["conversation_id"] = conversation_id
         if max_tokens:
             body["max_tokens"] = max_tokens
-        if system_prompt:
-            body["system_prompt"] = system_prompt
 
-        async for chunk in self._client._stream_request(
+        async for chunk in self._api_stream(
             endpoint="/api/llm/stream",
             body=body,
             on_chunk=on_chunk,
@@ -970,7 +1102,7 @@ class AiNamespace:
         if webhook_url:
             body["webhook_url"] = webhook_url
 
-        return await self._client._request(
+        return await self._api(
             endpoint="/api/llm/complete-async",
             body=body
         )
@@ -996,7 +1128,7 @@ class AiNamespace:
         Returns:
             Dict with "text", "confidence", "language", "duration"
         """
-        return await self._client._binary_upload(
+        return await self._api_upload(
             endpoint="/api/agent/stt",
             file_bytes=audio,
             filename=f"audio.{format}",
@@ -1023,7 +1155,7 @@ class AiNamespace:
         Returns:
             Raw audio bytes (NOT base64 encoded)
         """
-        return await self._client._binary_download(
+        return await self._api_download(
             endpoint="/api/agent/tts",
             body={
                 "text": text,
@@ -1070,7 +1202,7 @@ class AiNamespace:
         if context:
             body["context"] = context
 
-        return await self._client._request(
+        return await self._api(
             endpoint="/api/session/setup",
             body=body
         )

{dominus_sdk_python-2.7.0 → dominus_sdk_python-2.7.2}/dominus/start.py

@@ -59,15 +59,17 @@ from typing import Optional, Any, Dict, List
 _VALIDATED = False
 _TOKEN: Optional[str] = None
 _BASE_URL: Optional[str] = None
+_GATEWAY_URL: Optional[str] = None
 _VALIDATION_ERROR: Optional[str] = None
 
 
 # === MODULE-LEVEL INITIALIZATION ===
 from .helpers.auth import _resolve_token
-from .config.endpoints import BASE_URL
+from .config.endpoints import BASE_URL, GATEWAY_URL
 
 _TOKEN = _resolve_token()
 _BASE_URL = BASE_URL
+_GATEWAY_URL = GATEWAY_URL
 
 # Initialize cache encryption
 from .helpers.cache import dominus_cache
@@ -365,10 +367,11 @@ class Dominus:
         endpoint: str,
         method: str = "POST",
         body: Optional[Dict[str, Any]] = None,
-        user_token: Optional[str] = None
+        user_token: Optional[str] = None,
+        use_gateway: bool = False
     ) -> Dict[str, Any]:
         """
-        Make an HTTP request to the orchestrator.
+        Make an HTTP request to the orchestrator or gateway.
 
         If user_token is provided, uses that JWT directly (for user-authenticated requests).
         Otherwise, uses the service token flow (PSK -> JWT).
@@ -378,6 +381,7 @@ class Dominus:
             method: HTTP method (GET, POST, PUT, DELETE)
             body: Request body (will be base64-encoded)
             user_token: Optional user JWT for user-authenticated requests
+            use_gateway: If True, route through gateway (/api/* -> /svc/*)
 
         Returns:
             Response data dict
@@ -391,6 +395,10 @@ class Dominus:
         def _b64_decode(s: str) -> dict:
             return json.loads(base64.b64decode(s.encode('utf-8')).decode('utf-8'))
 
+        # Transform endpoint for gateway routing
+        if use_gateway and endpoint.startswith("/api/"):
+            endpoint = "/svc/" + endpoint[5:]  # /api/llm/complete -> /svc/llm/complete
+
         # Determine which JWT to use
         if user_token:
             # Use the provided user JWT directly (no validation needed - orchestrator validates it)
@@ -426,8 +434,11 @@ class Dominus:
         # Prepare body
         body_b64 = _b64_encode(body or {})
 
+        # Select base URL
+        base_url = _GATEWAY_URL if use_gateway else _BASE_URL
+
         # 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) as client:
             if method == "GET":
                 response = await client.get(endpoint)
             elif method == "DELETE":
@@ -454,16 +465,18 @@ class Dominus:
         endpoint: str,
         body: Optional[Dict[str, Any]] = None,
         on_chunk: Optional[Any] = None,
-        timeout: float = 300.0
+        timeout: float = 300.0,
+        use_gateway: bool = False
     ):
         """
-        Make an SSE streaming request to the orchestrator.
+        Make an SSE streaming request to the orchestrator or gateway.
 
         Args:
             endpoint: API endpoint path (e.g., "/api/agent/stream")
             body: Request body (will be base64-encoded)
             on_chunk: Optional callback for each chunk
             timeout: Request timeout in seconds (default: 300s for long operations)
+            use_gateway: If True, route through gateway (/api/* -> /svc/*)
 
         Yields:
             Parsed JSON chunks from SSE stream
@@ -474,6 +487,10 @@ class Dominus:
         def _b64_encode(d: dict) -> str:
             return base64.b64encode(json.dumps(d).encode()).decode()
 
+        # Transform endpoint for gateway routing
+        if use_gateway and endpoint.startswith("/api/"):
+            endpoint = "/svc/" + endpoint[5:]
+
         # Validate and get JWT
         if _VALIDATION_ERROR:
             raise RuntimeError(_VALIDATION_ERROR)
@@ -499,7 +516,8 @@ class Dominus:
 
         from .helpers.sse import stream_sse
 
-        async with httpx.AsyncClient(base_url=_BASE_URL, timeout=timeout) as client:
+        base_url = _GATEWAY_URL if use_gateway else _BASE_URL
+        async with httpx.AsyncClient(base_url=base_url, timeout=timeout) as client:
             async with client.stream("POST", endpoint, content=body_b64, headers=headers) as response:
                 response.raise_for_status()
                 async for chunk in stream_sse(response, on_chunk):
@@ -512,7 +530,8 @@ class Dominus:
         filename: str,
         content_type: str = "application/octet-stream",
         additional_fields: Optional[Dict[str, str]] = None,
-        timeout: float = 60.0
+        timeout: float = 60.0,
+        use_gateway: bool = False
     ) -> Dict[str, Any]:
         """
         Upload binary file via multipart/form-data (no base64 encoding).
@@ -526,6 +545,7 @@ class Dominus:
             content_type: MIME type (default: application/octet-stream)
             additional_fields: Optional additional form fields
             timeout: Request timeout in seconds
+            use_gateway: If True, route through gateway (/api/* -> /svc/*)
 
         Returns:
             Response data dict
@@ -535,6 +555,10 @@ class Dominus:
         def _b64_decode(s: str) -> dict:
             return json.loads(base64.b64decode(s.encode('utf-8')).decode('utf-8'))
 
+        # Transform endpoint for gateway routing
+        if use_gateway and endpoint.startswith("/api/"):
+            endpoint = "/svc/" + endpoint[5:]
+
         if _VALIDATION_ERROR:
             raise RuntimeError(_VALIDATION_ERROR)
 
@@ -557,7 +581,8 @@ class Dominus:
         files = {"file": (filename, file_bytes, content_type)}
         data = additional_fields or {}
 
-        async with httpx.AsyncClient(base_url=_BASE_URL, headers=headers, timeout=timeout) as client:
+        base_url = _GATEWAY_URL if use_gateway else _BASE_URL
+        async with httpx.AsyncClient(base_url=base_url, headers=headers, timeout=timeout) as client:
             response = await client.post(endpoint, files=files, data=data)
 
         response.raise_for_status()
@@ -578,7 +603,8 @@ class Dominus:
         self,
         endpoint: str,
         body: Optional[Dict[str, Any]] = None,
-        timeout: float = 60.0
+        timeout: float = 60.0,
+        use_gateway: bool = False
     ) -> bytes:
         """
         Download binary content (no base64 encoding in response).
@@ -589,6 +615,7 @@ class Dominus:
             endpoint: API endpoint path (e.g., "/api/agent/tts")
             body: Request body (will be base64-encoded for auth)
             timeout: Request timeout in seconds
+            use_gateway: If True, route through gateway (/api/* -> /svc/*)
 
         Returns:
             Raw binary bytes
@@ -598,6 +625,10 @@ class Dominus:
         def _b64_encode(d: dict) -> str:
             return base64.b64encode(json.dumps(d).encode()).decode()
 
+        # Transform endpoint for gateway routing
+        if use_gateway and endpoint.startswith("/api/"):
+            endpoint = "/svc/" + endpoint[5:]
+
         if _VALIDATION_ERROR:
             raise RuntimeError(_VALIDATION_ERROR)
 
@@ -620,7 +651,8 @@ class Dominus:
 
         body_b64 = _b64_encode(body or {})
 
-        async with httpx.AsyncClient(base_url=_BASE_URL, headers=headers, timeout=timeout) as client:
+        base_url = _GATEWAY_URL if use_gateway else _BASE_URL
+        async with httpx.AsyncClient(base_url=base_url, headers=headers, timeout=timeout) as client:
             response = await client.post(endpoint, content=body_b64)
 
         response.raise_for_status()

{dominus_sdk_python-2.7.0 → dominus_sdk_python-2.7.2}/dominus_sdk_python.egg-info/PKG-INFO

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

{dominus_sdk_python-2.7.0 → dominus_sdk_python-2.7.2}/pyproject.toml

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