deepparallel 0.4.2__tar.gz → 0.5.0__tar.gz

{deepparallel-0.4.2 → deepparallel-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.4.2
+Version: 0.5.0
 Summary: DeepParallel - a multi-model agentic coding CLI with cross-model Guardian review, served via Crowe Logic.
 Author-email: Michael Crowe <michael@crowelogic.com>
 License: Apache-2.0

{deepparallel-0.4.2 → deepparallel-0.5.0}/deepparallel/__init__.py

@@ -1,3 +1,3 @@
 """DeepParallel CLI package."""
 
-__version__ = "0.4.2"
+__version__ = "0.5.0"

{deepparallel-0.4.2 → deepparallel-0.5.0}/deepparallel/backend.py

@@ -16,9 +16,14 @@ from urllib.parse import urlparse
 
 import httpx
 
+from . import crowe_id
+
 Chunk = tuple[str, str]  # (channel, text)
 
 _STREAM_TIMEOUT = httpx.Timeout(120.0, connect=10.0)
+# Modal scale-to-zero cold start can take 2-3 min before the first byte, so the
+# read timeout must be generous; connect stays short.
+_MODAL_TIMEOUT = httpx.Timeout(600.0, connect=15.0)
 _CHECK_TIMEOUT = 4.0
 
 
@@ -210,17 +215,24 @@ class AzureBackend:
 class FoundryBackend:
     label = "Foundry control plane"
 
-    def __init__(self, base_url: str, api_key: str, model: str):
+    def __init__(self, base_url: str, api_key: str, model: str, token_provider=None):
         self._base_url = (base_url or "").rstrip("/")
         self._api_key = api_key or ""
         self._model = model
+        # Optional callable returning a fresh bearer (e.g. a Crowe ID
+        # client_credentials token). When set it takes precedence over the static
+        # api_key, so the gateway sees a sovereign agent identity per request.
+        self._token_provider = token_provider
 
     @property
     def _url(self) -> str:
         return f"{self._base_url}/v1/chat/completions"
 
+    def _bearer(self) -> str:
+        return self._token_provider() if self._token_provider else self._api_key
+
     def check(self) -> tuple[bool, str]:
-        if not self._base_url or not self._api_key:
+        if not self._base_url or not (self._api_key or self._token_provider):
             return False, "Foundry base URL or API key not configured."
         try:
             httpx.get(_host(self._base_url), timeout=_CHECK_TIMEOUT)
@@ -237,7 +249,7 @@ class FoundryBackend:
             "max_tokens": max_tokens,
         }
         headers = {
-            "authorization": f"Bearer {self._api_key}",
+            "authorization": f"Bearer {self._bearer()}",
             "content-type": "application/json",
         }
         with httpx.stream(
@@ -257,7 +269,7 @@ class FoundryBackend:
         if tools:
             payload["tools"] = tools
         headers = {
-            "authorization": f"Bearer {self._api_key}",
+            "authorization": f"Bearer {self._bearer()}",
             "content-type": "application/json",
         }
         r = httpx.post(self._url, json=payload, headers=headers, timeout=_STREAM_TIMEOUT)
@@ -275,7 +287,7 @@ class FoundryBackend:
         if tools:
             payload["tools"] = tools
         headers = {
-            "authorization": f"Bearer {self._api_key}",
+            "authorization": f"Bearer {self._bearer()}",
             "content-type": "application/json",
         }
         with httpx.stream(
@@ -285,8 +297,208 @@ class FoundryBackend:
             return (yield from parse_sse_stream(r.iter_lines()))
 
 
+class PaymentRequired(Exception):
+    """The agent's wallet can't cover the call — the x402 rail returned HTTP 402.
+
+    Carries the parsed x402 envelope so callers can see the price + accepted schemes
+    and decide how to fund (top-up) or pay (X-PAYMENT)."""
+
+    def __init__(self, envelope: dict):
+        self.envelope = envelope or {}
+        accepts = self.envelope.get("accepts", [])
+        price = accepts[0].get("maxAmountRequired", "?") if accepts else "?"
+        schemes = ", ".join(a.get("scheme", "") for a in accepts) or "?"
+        super().__init__(
+            f"payment required: {price} micro-USD via [{schemes}] — fund the agent wallet"
+        )
+
+
+class CroweGatewayBackend:
+    """Foundry gateway PAID agent rail (/api/agent/v1/chat by default), Crowe ID auth.
+
+    Targets the x402 agent endpoint that debits the agent's wallet per call (override
+    with CROWE_AGENT_RESOURCE). Native GatewayResponse shape, not the OpenAI-compat
+    /v1 path (which 404s there); non-streaming with no server-side tool-calls, so we
+    adapt it to DeepParallel's streaming seam by yielding the full completion as a
+    single content chunk. The bearer is a Crowe ID client_credentials token from
+    ``token_provider`` (the agent's sovereign identity).
+    """
+
+    label = "Crowe ID agent (Foundry gateway)"
+
+    def __init__(self, base_url: str, model: str, token_provider=None):
+        self._base_url = (base_url or "").rstrip("/")
+        self._model = model
+        self._token_provider = token_provider
+
+    @property
+    def _url(self) -> str:
+        # The PAID x402 agent rail (debits the agent's wallet). Overridable via
+        # CROWE_AGENT_RESOURCE for the legacy non-paid /api/gateway/chat path.
+        import os
+
+        resource = os.environ.get("CROWE_AGENT_RESOURCE", "/api/agent/v1/chat")
+        return f"{self._base_url}{resource}"
+
+    def _bearer(self) -> str:
+        return self._token_provider() if self._token_provider else ""
+
+    def _headers(self) -> dict:
+        return {
+            "authorization": f"Bearer {self._bearer()}",
+            "content-type": "application/json",
+        }
+
+    def check(self) -> tuple[bool, str]:
+        if not self._base_url or not self._token_provider:
+            return False, "Crowe gateway URL or Crowe ID credentials not configured."
+        try:
+            httpx.get(_host(self._base_url), timeout=_CHECK_TIMEOUT)
+        except Exception as e:  # noqa: BLE001 - reachability probe
+            return False, f"Crowe gateway unreachable ({e.__class__.__name__})"
+        return True, f"Crowe ID @ {_host(self._base_url)}"
+
+    def _complete(self, messages, temperature, max_tokens) -> str:
+        payload = {
+            "model": self._model,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+        }
+        r = httpx.post(self._url, json=payload, headers=self._headers(), timeout=_STREAM_TIMEOUT)
+        if r.status_code == 402:
+            # x402 payment-required: surface the machine-readable envelope as an
+            # actionable error (price + schemes) rather than a raw HTTP error.
+            try:
+                envelope = r.json()
+            except Exception:  # noqa: BLE001 - tolerate a non-JSON 402 body
+                envelope = {}
+            raise PaymentRequired(envelope)
+        r.raise_for_status()
+        return r.json().get("content", "")
+
+    def stream_chat(self, messages, temperature, max_tokens):
+        yield ("content", self._complete(messages, temperature, max_tokens))
+
+    def chat(self, messages, tools, temperature, max_tokens) -> dict:
+        # Native gateway endpoint has no tool-calling; tools are ignored.
+        return {"role": "assistant", "content": self._complete(messages, temperature, max_tokens)}
+
+    def stream_chat_tools(self, messages, tools, temperature, max_tokens):
+        # No server-side tool-calls; yields content and returns the final message
+        # (matches the FoundryBackend generator-return contract used by the agent loop).
+        content = self._complete(messages, temperature, max_tokens)
+        yield ("content", content)
+        return {"role": "assistant", "content": content}
+
+
+class ModalBackend:
+    """Gemma 4 Mycelium served on a Modal scale-to-zero GPU (the free base tier).
+
+    OpenAI-compatible /v1/chat/completions, but the Modal web endpoint requires
+    proxy-auth headers (Modal-Key / Modal-Secret) on every request — which is why
+    the gateway, not OWUI, must own this connection."""
+
+    label = "Modal (Mycelium)"
+
+    def __init__(self, endpoint: str, key: str, secret: str, model: str):
+        self._base_url = (endpoint or "").rstrip("/")
+        self._key = key or ""
+        self._secret = secret or ""
+        self._model = model
+
+    @property
+    def _url(self) -> str:
+        return f"{self._base_url}/v1/chat/completions"
+
+    def _headers(self) -> dict:
+        return {
+            "Modal-Key": self._key,
+            "Modal-Secret": self._secret,
+            "content-type": "application/json",
+        }
+
+    def check(self) -> tuple[bool, str]:
+        if not self._base_url or not self._key or not self._secret:
+            return False, "Modal Mycelium endpoint or proxy-auth token not configured."
+        try:
+            httpx.get(_host(self._base_url), timeout=_CHECK_TIMEOUT)
+        except Exception as e:  # noqa: BLE001 - reachability probe
+            return False, f"Modal endpoint unreachable ({e.__class__.__name__})"
+        return True, f"Modal @ {_host(self._base_url)}"
+
+    def stream_chat(self, messages, temperature, max_tokens):
+        payload = {
+            "model": self._model,
+            "messages": messages,
+            "stream": True,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+        }
+        with httpx.stream(
+            "POST", self._url, json=payload, headers=self._headers(), timeout=_MODAL_TIMEOUT
+        ) as r:
+            r.raise_for_status()
+            yield from parse_sse_lines(r.iter_lines())
+
+    def chat(self, messages, tools, temperature, max_tokens) -> dict:
+        payload = {
+            "model": self._model,
+            "messages": messages,
+            "stream": False,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+        }
+        if tools:
+            payload["tools"] = tools
+        r = httpx.post(self._url, json=payload, headers=self._headers(), timeout=_MODAL_TIMEOUT)
+        r.raise_for_status()
+        return _message_from_choice(r.json()["choices"][0])
+
+    def stream_chat_tools(self, messages, tools, temperature, max_tokens):
+        payload = {
+            "model": self._model,
+            "messages": messages,
+            "stream": True,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+        }
+        if tools:
+            payload["tools"] = tools
+        with httpx.stream(
+            "POST", self._url, json=payload, headers=self._headers(), timeout=_MODAL_TIMEOUT
+        ) as r:
+            r.raise_for_status()
+            return (yield from parse_sse_stream(r.iter_lines()))
+
+
+_crowe_providers: dict[tuple, crowe_id.CroweIDTokenProvider] = {}
+
+
+def _crowe_token_provider(settings) -> crowe_id.CroweIDTokenProvider:
+    """One memoized token provider per (issuer, client_id) so fusion's many
+    per-deployment backends share a single cached Crowe ID token."""
+    key = (settings.crowe_id_issuer, settings.crowe_id_client_id)
+    provider = _crowe_providers.get(key)
+    if provider is None:
+        provider = crowe_id.CroweIDTokenProvider(
+            settings.crowe_id_issuer,
+            settings.crowe_id_client_id or "",
+            settings.crowe_id_client_secret or "",
+            audience=settings.crowe_id_audience,
+        )
+        _crowe_providers[key] = provider
+    return provider
+
+
 def resolve_backend(settings) -> Backend:
     """Factory keyed on settings.backend."""
+    if settings.backend == "crowe":
+        return CroweGatewayBackend(
+            settings.gateway_url or "",
+            settings.foundry_model,
+            token_provider=_crowe_token_provider(settings),
+        )
     if settings.backend == "foundry":
         return FoundryBackend(
             settings.foundry_base_url or "",
@@ -305,7 +517,22 @@ def backend_for_deployment(settings, deployment: str) -> Backend:
     """Build a backend targeting a specific deployment/model (for fusion).
 
     Uses the same transport as the active backend, just a different model id.
+    The Modal-served Mycelium model is the exception: it routes to its own
+    endpoint with proxy-auth headers, regardless of the active backend.
     """
+    if settings.mycelium_endpoint and deployment == settings.mycelium_model:
+        return ModalBackend(
+            settings.mycelium_endpoint,
+            settings.mycelium_key or "",
+            settings.mycelium_secret or "",
+            deployment,
+        )
+    if settings.backend == "crowe":
+        return CroweGatewayBackend(
+            settings.gateway_url or "",
+            deployment,
+            token_provider=_crowe_token_provider(settings),
+        )
     if settings.backend == "foundry":
         return FoundryBackend(
             settings.foundry_base_url or "", settings.foundry_api_key or "", deployment