deepparallel 0.5.0__tar.gz → 0.5.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.5.0
+Version: 0.5.1
 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.5.0 → deepparallel-0.5.1}/deepparallel/__init__.py

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

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

@@ -11,6 +11,8 @@ stream_chat yields (channel, text) tuples where channel is "content" or
 from __future__ import annotations
 
 import json
+import os
+import sys
 from typing import Iterator, Protocol
 from urllib.parse import urlparse
 
@@ -142,6 +144,24 @@ class Backend(Protocol):
     ) -> Iterator[Chunk]: ...
 
 
+def _should_failover(exc: Exception) -> bool:
+    """Fail over to direct Azure only on transport errors or upstream 5xx;
+    a 4xx means the request itself is bad, so retrying elsewhere is pointless."""
+    if isinstance(exc, httpx.TransportError):
+        return True
+    if isinstance(exc, httpx.HTTPStatusError):
+        return exc.response.status_code >= 500
+    return False
+
+
+def _log_failover(label: str, exc: Exception) -> None:
+    sys.stderr.write(
+        f"[deepparallel] {label}: primary endpoint failed "
+        f"({exc.__class__.__name__}); failing over to direct Azure\n"
+    )
+    sys.stderr.flush()
+
+
 class AzureBackend:
     label = "Azure OpenAI"
 
@@ -151,13 +171,56 @@ class AzureBackend:
         self._deployment = deployment
         self._api_version = api_version
 
-    @property
-    def _url(self) -> str:
+    def _build_url(self, endpoint: str) -> str:
+        # Cloudflare AI Gateway azure-openai routes carry the resource in the
+        # path and drop the native "/openai/deployments" segment; native Azure
+        # endpoints keep it.
+        endpoint = endpoint.rstrip("/")
+        if "/azure-openai/" in endpoint:
+            return (
+                f"{endpoint}/{self._deployment}"
+                f"/chat/completions?api-version={self._api_version}"
+            )
         return (
-            f"{self._endpoint}/openai/deployments/{self._deployment}"
+            f"{endpoint}/openai/deployments/{self._deployment}"
             f"/chat/completions?api-version={self._api_version}"
         )
 
+    def _endpoints(self) -> list[str]:
+        # Primary is whatever is configured (typically the Cloudflare AI Gateway
+        # route). When that primary is a gateway route, derive the direct Azure
+        # endpoint from its resource segment and append it as automatic failover:
+        # fail-open, so a gateway outage degrades to direct Azure instead of
+        # taking down every CroweLM request. The failover request is not logged
+        # by the gateway -- the acceptable cost of staying available.
+        eps = [self._endpoint]
+        marker = "/azure-openai/"
+        if marker in self._endpoint:
+            resource = self._endpoint.split(marker, 1)[1].split("/", 1)[0]
+            if resource:
+                eps.append(f"https://{resource}.cognitiveservices.azure.com")
+        return eps
+
+    @property
+    def _url(self) -> str:
+        return self._build_url(self._endpoint)
+
+    @property
+    def _headers(self) -> dict:
+        # cf-aig-* headers configure AI Gateway per-request (no management API
+        # needed). Cache TTL is operationally tunable via DEEPPARALLEL_CACHE_TTL
+        # (seconds; "0" or empty disables caching for this agentic workload).
+        # Ignored by direct Azure on the failover path.
+        headers = {
+            "api-key": self._api_key,
+            "content-type": "application/json",
+        }
+        ttl = os.getenv("DEEPPARALLEL_CACHE_TTL", "300").strip()
+        if ttl and ttl != "0":
+            headers["cf-aig-cache-ttl"] = ttl
+            headers["cf-aig-metadata"] = '{"via":"deepparallel-gateway"}'
+        return headers
+
     def check(self) -> tuple[bool, str]:
         if not self._endpoint or not self._api_key:
             return False, "Azure endpoint or API key not configured."
@@ -167,49 +230,86 @@ class AzureBackend:
             return False, f"Azure endpoint unreachable ({e.__class__.__name__})"
         return True, f"Azure @ {_host(self._endpoint)}"
 
+    def _payload(self, messages, stream, temperature, max_tokens) -> dict:
+        # GPT-5 family deployments require `max_completion_tokens` and reject a
+        # custom `temperature` (only the default is accepted) -> they 400 on the
+        # legacy `max_tokens`/`temperature` shape. Everything else uses the
+        # classic params.
+        payload = {"messages": messages, "stream": stream}
+        dep = self._deployment.lower()
+        if dep.startswith("gpt-5") or dep.startswith("gpt-chat"):
+            # GPT-5 family + gpt-chat-latest require max_completion_tokens and
+            # reject a custom temperature (only the default is accepted).
+            payload["max_completion_tokens"] = max_tokens
+        else:
+            payload["temperature"] = temperature
+            payload["max_tokens"] = max_tokens
+        return payload
+
     def stream_chat(self, messages, temperature, max_tokens):
-        payload = {
-            "messages": messages,
-            "stream": True,
-            "temperature": temperature,
-            "max_tokens": max_tokens,
-        }
-        headers = {"api-key": self._api_key, "content-type": "application/json"}
-        with httpx.stream(
-            "POST", self._url, json=payload, headers=headers, timeout=_STREAM_TIMEOUT
-        ) as r:
-            r.raise_for_status()
-            yield from parse_sse_lines(r.iter_lines())
+        payload = self._payload(messages, True, temperature, max_tokens)
+        urls = [self._build_url(e) for e in self._endpoints()]
+        for i, url in enumerate(urls):
+            last = i == len(urls) - 1
+            started = False
+            try:
+                with httpx.stream(
+                    "POST", url, json=payload, headers=self._headers, timeout=_STREAM_TIMEOUT
+                ) as r:
+                    r.raise_for_status()
+                    for chunk in parse_sse_lines(r.iter_lines()):
+                        started = True
+                        yield chunk
+                return
+            except (httpx.TransportError, httpx.HTTPStatusError) as e:
+                if last or started or not _should_failover(e):
+                    raise
+                _log_failover(self.label, e)
+                continue
 
     def chat(self, messages, tools, temperature, max_tokens) -> dict:
-        payload = {
-            "messages": messages,
-            "stream": False,
-            "temperature": temperature,
-            "max_tokens": max_tokens,
-        }
+        payload = self._payload(messages, False, temperature, max_tokens)
         if tools:
             payload["tools"] = tools
-        headers = {"api-key": self._api_key, "content-type": "application/json"}
-        r = httpx.post(self._url, json=payload, headers=headers, timeout=_STREAM_TIMEOUT)
-        r.raise_for_status()
-        return _message_from_choice(r.json()["choices"][0])
+        urls = [self._build_url(e) for e in self._endpoints()]
+        for i, url in enumerate(urls):
+            last = i == len(urls) - 1
+            try:
+                r = httpx.post(url, json=payload, headers=self._headers, timeout=_STREAM_TIMEOUT)
+                r.raise_for_status()
+                return _message_from_choice(r.json()["choices"][0])
+            except (httpx.TransportError, httpx.HTTPStatusError) as e:
+                if last or not _should_failover(e):
+                    raise
+                _log_failover(self.label, e)
+                continue
 
     def stream_chat_tools(self, messages, tools, temperature, max_tokens):
-        payload = {
-            "messages": messages,
-            "stream": True,
-            "temperature": temperature,
-            "max_tokens": max_tokens,
-        }
+        payload = self._payload(messages, True, temperature, max_tokens)
         if tools:
             payload["tools"] = tools
-        headers = {"api-key": self._api_key, "content-type": "application/json"}
-        with httpx.stream(
-            "POST", self._url, json=payload, headers=headers, timeout=_STREAM_TIMEOUT
-        ) as r:
-            r.raise_for_status()
-            return (yield from parse_sse_stream(r.iter_lines()))
+        urls = [self._build_url(e) for e in self._endpoints()]
+        for i, url in enumerate(urls):
+            last = i == len(urls) - 1
+            started = False
+            try:
+                with httpx.stream(
+                    "POST", url, json=payload, headers=self._headers, timeout=_STREAM_TIMEOUT
+                ) as r:
+                    r.raise_for_status()
+                    gen = parse_sse_stream(r.iter_lines())
+                    while True:
+                        try:
+                            chunk = next(gen)
+                        except StopIteration as stop:
+                            return stop.value
+                        started = True
+                        yield chunk
+            except (httpx.TransportError, httpx.HTTPStatusError) as e:
+                if last or started or not _should_failover(e):
+                    raise
+                _log_failover(self.label, e)
+                continue
 
 
 class FoundryBackend:

{deepparallel-0.5.0 → deepparallel-0.5.1}/deepparallel/cli.py

@@ -495,13 +495,15 @@ def review(ctx: click.Context, as_diff: bool, path: str | None) -> None:
 
     Reviews a file (PATH) or a unified diff (--diff, from stdin) with a second
     model and prints a verdict. Exit code: 0 safe, 1 risky, 2 bug - so it can
-    gate a commit or PR. Paid (Pro+).
+    gate a commit or PR. Free with your own key (DEEPPARALLEL_BACKEND=openai or
+    ollama); Pro unlocks the hosted Crowe Logic model stack.
     """
     settings: Settings = ctx.obj["settings"]
-    ok, msg = licensing.check_feature("review")
-    if not ok:
-        branding.error(msg)
-        sys.exit(3)
+    if not settings.byok:
+        ok, msg = licensing.check_feature("review")
+        if not ok:
+            branding.error(msg)
+            sys.exit(3)
     if as_diff:
         content = sys.stdin.read()
     elif path:

{deepparallel-0.5.0 → deepparallel-0.5.1}/deepparallel/config.py

@@ -45,6 +45,10 @@ class Settings:
     mycelium_key: str | None = None
     mycelium_secret: str | None = None
     mycelium_model: str = "Mcrowe1210/gemma-4-mycelium-e4b"
+    # True when the user brings their own key/model (openai/ollama/foundry):
+    # the FREE tier. review + the agent run unlicensed; only the Crowe-hosted
+    # stack (azure/crowe) is gated to Pro.
+    byok: bool = False
     # Crowe ID agent identity (backend="crowe"): route through the Foundry gateway
     # authenticated by a client_credentials token instead of a raw provider key.
     gateway_url: str | None = None
@@ -102,17 +106,36 @@ def _int_env(name: str, default: int) -> int:
 
 def resolve_settings() -> Settings:
     backend = os.environ.get("DEEPPARALLEL_BACKEND", "azure").strip().lower()
-    if backend not in {"azure", "foundry", "crowe"}:
+    if backend not in {"azure", "foundry", "crowe", "openai", "ollama"}:
         backend = "azure"
+
+    # BYOK (bring-your-own-key) backends are the FREE tier. "openai" and "ollama"
+    # are friendly aliases onto the OpenAI-compatible foundry transport with
+    # sensible defaults, so `dp` works with no Crowe account and no license.
+    foundry_base_url = os.environ.get("FOUNDRY_BASE_URL")
+    foundry_api_key = os.environ.get("FOUNDRY_API_KEY")
+    foundry_model = os.environ.get("DEEPPARALLEL_FOUNDRY_MODEL", "DeepSeek-V3-1")
+    if backend == "openai":
+        foundry_base_url = os.environ.get("OPENAI_BASE_URL", "https://api.openai.com")
+        foundry_api_key = os.environ.get("OPENAI_API_KEY") or foundry_api_key
+        foundry_model = os.environ.get("DEEPPARALLEL_MODEL", "gpt-4o-mini")
+        backend = "foundry"
+    elif backend == "ollama":
+        foundry_base_url = os.environ.get("OLLAMA_HOST", "http://localhost:11434")
+        foundry_api_key = foundry_api_key or "ollama"
+        foundry_model = os.environ.get("DEEPPARALLEL_MODEL", "llama3.1")
+        backend = "foundry"
+    byok = backend == "foundry"
+
     return Settings(
         backend=backend,
         azure_endpoint=os.environ.get("AZURE_CORE_ENDPOINT"),
         azure_api_key=os.environ.get("AZURE_CORE_API_KEY"),
         deployment=os.environ.get("DEEPPARALLEL_DEPLOYMENT", "DeepSeek-V4-Pro"),
         api_version=os.environ.get("DEEPPARALLEL_API_VERSION", "2024-08-01-preview"),
-        foundry_base_url=os.environ.get("FOUNDRY_BASE_URL"),
-        foundry_api_key=os.environ.get("FOUNDRY_API_KEY"),
-        foundry_model=os.environ.get("DEEPPARALLEL_FOUNDRY_MODEL", "DeepSeek-V3-1"),
+        foundry_base_url=foundry_base_url,
+        foundry_api_key=foundry_api_key,
+        foundry_model=foundry_model,
         temperature=_float_env("DEEPPARALLEL_TEMPERATURE", 0.4),
         max_tokens=_int_env("DEEPPARALLEL_MAX_TOKENS", 8192),
         show_thinking=_bool_env("DEEPPARALLEL_THINK", False),
@@ -149,6 +172,7 @@ def resolve_settings() -> Settings:
         crowe_id_client_id=os.environ.get("CROWE_ID_CLIENT_ID"),
         crowe_id_client_secret=os.environ.get("CROWE_ID_CLIENT_SECRET"),
         crowe_id_audience=os.environ.get("CROWE_ID_AUDIENCE"),
+        byok=byok,
     )
 
 

{deepparallel-0.5.0 → deepparallel-0.5.1}/deepparallel/serve.py

@@ -51,16 +51,35 @@ _SCRUB: list[tuple[re.Pattern[str], str]] = [
 # The listing must never leak raw deployment names; chat accepts either the
 # alias or the raw name, so existing callers keep working.
 _MODEL_ALIASES: dict[str, str] = {
+    # DeepSeek family
     "crowelm-apex": "DeepSeek-V4-Pro",
     "crowelm-reason": "DeepSeek-R1-0528",
     "crowelm-flash": "DeepSeek-V4-Flash",
-    "crowelm-vector": "DeepSeek-V3.1",
+    "crowelm-vector": "DeepSeek-V3-1",
+    # GPT family (Azure frontier)
+    "crowelm-zenith": "gpt-5.5",
+    # --- gpt-5.4 family back-burnered (de-prioritized) — uncomment to re-enable ---
+    # "crowelm-prime": "gpt-5.4",
+    # "crowelm-prime-mini": "gpt-5.4-mini",
+    # "crowelm-prime-nano": "gpt-5.4-nano",
+    "crowelm-chat": "gpt-chat-latest",
+    "crowelm-swift": "gpt-4o",
+    # Grok family
     "crowelm-quasar": "grok-4-3",
     "crowelm-quasar-fast": "grok-4-1-fast-reasoning",
-    "crowelm-herald": "cohere-command-a",
+    "crowelm-quasar-lite": "grok-4-1-fast-non-r",
+    "crowelm-quasar-max": "grok-4-20-reasoning",
+    # Kimi family
     "crowelm-eclipse": "Kimi-K2-6",
+    "crowelm-eclipse-lite": "Kimi-K2.5",
+    # Llama family
     "crowelm-titan": "Llama-3-3-70B",
-    "crowelm-swift": "gpt-4o",
+    "crowelm-maverick": "Llama-4-Maverick",
+    "crowelm-scout": "Llama-4-Scout",
+    # Specialist tiers
+    "crowelm-herald": "Cohere-Command-A",
+    "crowelm-forge": "Codestral-2501",
+    "crowelm-router": "model-router",
     # Free base tier: the sovereign Gemma 4 Mycelium model on Modal. Only listed
     # in /v1/models when MODAL_MYCELIUM_ENDPOINT is configured (see below).
     "crowelm-mycelium": "Mcrowe1210/gemma-4-mycelium-e4b",
@@ -174,8 +193,11 @@ def _models_payload(settings) -> dict:
     # this gateway process. Never list raw deployment names; chat still accepts
     # them for existing callers, but discovery should not advertise unknown
     # deployments.
-    configured = _configured_deployments(settings)
-    ids = [alias for alias, deployment in _MODEL_ALIASES.items() if deployment in configured]
+    ids = [
+        alias
+        for alias, deployment in _MODEL_ALIASES.items()
+        if _deployment_available(deployment, settings)
+    ]
     created = int(time.time())
     return {
         "object": "list",

{deepparallel-0.5.0 → deepparallel-0.5.1}/deepparallel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.5.0
+Version: 0.5.1
 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.5.0 → deepparallel-0.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "deepparallel"
-version = "0.5.0"
+version = "0.5.1"
 description = "DeepParallel - a multi-model agentic coding CLI with cross-model Guardian review, served via Crowe Logic."
 readme = "README.md"
 license = { text = "Apache-2.0" }