deepparallel 0.2.0__py3-none-any.whl

deepparallel/config.py

@@ -0,0 +1,158 @@
+"""Runtime configuration and model-spec loading.
+
+Pure resolution from os.environ and packaged data files. No network calls,
+no printing, and no .env loading here (cli.py loads .env once at startup).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+_PKG_DIR = Path(__file__).parent
+REGISTRY_PATH = _PKG_DIR / "registry.json"
+SYSTEM_PROMPT_PATH = _PKG_DIR / "system_prompt.txt"
+
+
+@dataclass(frozen=True)
+class Settings:
+    backend: str
+    azure_endpoint: str | None
+    azure_api_key: str | None
+    deployment: str
+    api_version: str
+    foundry_base_url: str | None
+    foundry_api_key: str | None
+    foundry_model: str
+    temperature: float
+    max_tokens: int
+    show_thinking: bool
+    tools_enabled: bool
+    auto_approve: bool
+    max_steps: int
+    shell_timeout: int
+    fusion_mode: str
+    reasoner_deployment: str
+    parallel_deployments: tuple[str, ...]
+    judge_deployment: str
+    guardian_enabled: bool
+    guardian_deployment: str
+
+
+@dataclass(frozen=True)
+class ModelSpec:
+    name: str
+    label: str
+    deployment: str
+    base_family: str
+    context_window: int
+    license: str
+    license_url: str
+
+
+def _bool_env(name: str, default: bool = False) -> bool:
+    raw = os.environ.get(name)
+    if raw is None:
+        return default
+    return raw.strip().lower() in {"1", "true", "yes", "on"}
+
+
+def _float_env(name: str, default: float) -> float:
+    raw = os.environ.get(name)
+    if raw is None:
+        return default
+    try:
+        return float(raw)
+    except ValueError:
+        return default
+
+
+def _list_env(name: str, default: list[str]) -> tuple[str, ...]:
+    raw = os.environ.get(name)
+    if raw is None:
+        return tuple(default)
+    items = [s.strip() for s in raw.split(",") if s.strip()]
+    return tuple(items) if items else tuple(default)
+
+
+def _int_env(name: str, default: int) -> int:
+    raw = os.environ.get(name)
+    if raw is None:
+        return default
+    try:
+        return int(raw)
+    except ValueError:
+        return default
+
+
+def resolve_settings() -> Settings:
+    backend = os.environ.get("DEEPPARALLEL_BACKEND", "azure").strip().lower()
+    if backend not in {"azure", "foundry"}:
+        backend = "azure"
+    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"),
+        temperature=_float_env("DEEPPARALLEL_TEMPERATURE", 0.4),
+        max_tokens=_int_env("DEEPPARALLEL_MAX_TOKENS", 2048),
+        show_thinking=_bool_env("DEEPPARALLEL_THINK", False),
+        tools_enabled=_bool_env("DEEPPARALLEL_TOOLS", True),
+        auto_approve=_bool_env("DEEPPARALLEL_AUTO_APPROVE", False),
+        max_steps=_int_env("DEEPPARALLEL_MAX_STEPS", 12),
+        shell_timeout=_int_env("DEEPPARALLEL_SHELL_TIMEOUT", 120),
+        fusion_mode=(os.environ.get("DEEPPARALLEL_FUSION", "off").strip().lower() or "off"),
+        reasoner_deployment=os.environ.get("DEEPPARALLEL_REASONER_DEPLOYMENT", "DeepSeek-R1-0528"),
+        parallel_deployments=_list_env(
+            "DEEPPARALLEL_PARALLEL_MODELS",
+            ["DeepSeek-V4-Pro", "DeepSeek-R1-0528", "DeepSeek-V4-Flash"],
+        ),
+        judge_deployment=os.environ.get(
+            "DEEPPARALLEL_JUDGE_DEPLOYMENT",
+            os.environ.get("DEEPPARALLEL_DEPLOYMENT", "DeepSeek-V4-Pro"),
+        ),
+        guardian_enabled=_bool_env("DEEPPARALLEL_GUARDIAN", True),
+        # A fast, independent reviewer by default (NOT the reasoner: a reasoning
+        # model spends a small token budget on hidden thinking and returns no
+        # verdict). Differs from the primary author model for a real 2nd opinion.
+        guardian_deployment=os.environ.get("DEEPPARALLEL_GUARDIAN_DEPLOYMENT", "DeepSeek-V4-Flash"),
+    )
+
+
+def missing_required(settings: Settings) -> list[str]:
+    """Names of required env vars unset for the active backend, in display order."""
+    missing: list[str] = []
+    if settings.backend == "azure":
+        if not settings.azure_endpoint:
+            missing.append("AZURE_CORE_ENDPOINT")
+        if not settings.azure_api_key:
+            missing.append("AZURE_CORE_API_KEY")
+    else:
+        if not settings.foundry_base_url:
+            missing.append("FOUNDRY_BASE_URL")
+        if not settings.foundry_api_key:
+            missing.append("FOUNDRY_API_KEY")
+    return missing
+
+
+def load_model_spec() -> ModelSpec:
+    entry = json.loads(REGISTRY_PATH.read_text())["models"][0]
+    return ModelSpec(
+        name=entry["name"],
+        label=entry["label"],
+        deployment=entry["deployment"],
+        base_family=entry["base_family"],
+        context_window=entry["context_window"],
+        license=entry["license"],
+        license_url=entry["license_url"],
+    )
+
+
+def load_system_prompt() -> str:
+    return SYSTEM_PROMPT_PATH.read_text().strip()

deepparallel/fusion.py

@@ -0,0 +1,225 @@
+"""Fusion backends: stack DeepParallel with other models for stronger output.
+
+All strategies compose deepparallel's own `Backend` instances (secondary backends
+pointed at other deployments), so there is no foundry dependency. Modes:
+- ReasonAnswerBackend: a reasoner produces a thinking trace, injected into the
+  primary's answer call.
+"""
+
+from __future__ import annotations
+
+import difflib
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Callable, Iterator
+
+_REASON_NOTE = (
+    "\n\nA separate reasoning model analyzed this request. "
+    "Consider its reasoning, then give your own best answer:\n"
+)
+
+
+def _augment(messages: list[dict], reasoning: str) -> list[dict]:
+    if not reasoning:
+        return messages
+    aug = [dict(m) for m in messages]
+    note = _REASON_NOTE + reasoning
+    if aug and aug[0].get("role") == "system":
+        aug[0] = {**aug[0], "content": (aug[0].get("content") or "") + note}
+    else:
+        aug.insert(0, {"role": "system", "content": note.strip()})
+    return aug
+
+
+class ReasonAnswerBackend:
+    """Run the reasoner first, inject its trace, then answer with the primary."""
+
+    label = "DeepParallel (fusion: reason)"
+
+    def __init__(self, primary, reasoner):
+        self._primary = primary
+        self._reasoner = reasoner
+
+    def check(self) -> tuple[bool, str]:
+        return self._primary.check()
+
+    def _reason(self, messages, temperature, max_tokens) -> str:
+        try:
+            msg = self._reasoner.chat(messages, [], temperature, max_tokens)
+        except Exception:  # noqa: BLE001 - reasoning is best-effort; fall back
+            return ""
+        return (msg.get("reasoning_content") or msg.get("content") or "").strip()
+
+    def chat(self, messages, tools, temperature, max_tokens) -> dict:
+        reasoning = self._reason(messages, temperature, max_tokens)
+        return self._primary.chat(_augment(messages, reasoning), tools, temperature, max_tokens)
+
+    def stream_chat(self, messages, temperature, max_tokens) -> Iterator[tuple[str, str]]:
+        reasoning = self._reason(messages, temperature, max_tokens)
+        yield from self._primary.stream_chat(_augment(messages, reasoning), temperature, max_tokens)
+
+
+_DOUBT = (
+    "not sure",
+    "uncertain",
+    "not certain",
+    "unclear",
+    "cannot determine",
+    "can't determine",
+    "don't have enough",
+    "do not have enough",
+    "more information",
+    "insufficient information",
+)
+
+
+class EscalationBackend:
+    """Answer with the primary; only escalate to the reasoner when the answer
+    signals uncertainty. Cheapest fusion mode on average."""
+
+    label = "DeepParallel (fusion: escalate)"
+
+    def __init__(self, primary, reasoner):
+        self._primary = primary
+        self._reasoner = reasoner
+
+    def check(self) -> tuple[bool, str]:
+        return self._primary.check()
+
+    @staticmethod
+    def _uncertain(content: str) -> bool:
+        low = content.lower()
+        return any(phrase in low for phrase in _DOUBT)
+
+    def chat(self, messages, tools, temperature, max_tokens) -> dict:
+        msg = self._primary.chat(messages, tools, temperature, max_tokens)
+        if msg.get("tool_calls"):
+            return msg  # mid-loop tool turn; never escalate
+        if self._uncertain(msg.get("content") or ""):
+            return ReasonAnswerBackend(self._primary, self._reasoner).chat(
+                messages, tools, temperature, max_tokens
+            )
+        return msg
+
+    def stream_chat(self, messages, temperature, max_tokens) -> Iterator[tuple[str, str]]:
+        yield from self._primary.stream_chat(messages, temperature, max_tokens)
+
+
+def _last_user(messages: list[dict]) -> str:
+    for m in reversed(messages):
+        if m.get("role") == "user":
+            return m.get("content") or ""
+    return ""
+
+
+def _chain_answer(backend, messages, temperature, max_tokens) -> str:
+    try:
+        msg = backend.chat(messages, [], temperature, max_tokens)
+    except Exception as e:  # noqa: BLE001 - one chain failing must not sink the run
+        return f"[error: {type(e).__name__}: {e}]"
+    return (msg.get("content") or msg.get("reasoning_content") or "").strip()
+
+
+def _fallback(results: list[dict]) -> str:
+    valid = [r["content"] for r in results if not r["content"].startswith("[error")]
+    return max(valid, key=len) if valid else "All reasoning chains failed."
+
+
+def _judge(messages, results, judge, temperature, max_tokens) -> str:
+    question = _last_user(messages)
+    blocks = "\n\n".join(
+        f"Candidate {i + 1} ({r['name']}):\n{r['content']}" for i, r in enumerate(results)
+    )
+    judge_messages = [
+        {
+            "role": "system",
+            "content": (
+                "You are a careful judge. Synthesize the single best, correct answer "
+                "from the candidate answers below. Resolve disagreements with sound "
+                "reasoning. Output only the final answer."
+            ),
+        },
+        {
+            "role": "user",
+            "content": f"Question:\n{question}\n\nCandidate answers:\n{blocks}\n\nFinal answer:",
+        },
+    ]
+    try:
+        msg = judge.chat(judge_messages, [], temperature, max_tokens)
+    except Exception:  # noqa: BLE001 - degrade gracefully if the judge fails
+        return _fallback(results)
+    return (msg.get("content") or "").strip() or _fallback(results)
+
+
+def deep_query(
+    messages: list[dict],
+    chains: list[tuple[str, object]],
+    judge,
+    temperature: float,
+    max_tokens: int,
+    on_event: Callable[[str, str], None] | None = None,
+) -> dict:
+    """Fan a prompt out to several model chains in parallel, then synthesize a
+    final answer with a judge. Heavy and slow; for one-shot --deep runs."""
+    order = {name: i for i, (name, _) in enumerate(chains)}
+    results: list[dict] = []
+    with ThreadPoolExecutor(max_workers=min(8, max(1, len(chains)))) as pool:
+        futures = {
+            pool.submit(_chain_answer, backend, messages, temperature, max_tokens): name
+            for name, backend in chains
+        }
+        for future in as_completed(futures):
+            name = futures[future]
+            content = future.result()
+            results.append({"name": name, "content": content})
+            if on_event:
+                on_event(name, content)
+    results.sort(key=lambda r: order.get(r["name"], 0))
+    answer = _judge(messages, results, judge, temperature, max_tokens)
+    return {"answer": answer, "chains": results, "agreement": _agreement(results)}
+
+
+def _agreement(results: list[dict]) -> dict:
+    """Cross-model agreement (NOT correctness) from pairwise answer similarity.
+
+    Zero extra model cost; uses difflib over the candidate answers.
+    """
+    answers = [r["content"] for r in results if not r["content"].startswith("[error")]
+    if len(answers) < 2:
+        return {"level": "n/a", "score": 1.0 if answers else 0.0}
+    ratios = [
+        difflib.SequenceMatcher(None, answers[i], answers[j]).ratio()
+        for i in range(len(answers))
+        for j in range(i + 1, len(answers))
+    ]
+    score = round(sum(ratios) / len(ratios), 2)
+    level = "high" if score >= 0.6 else "medium" if score >= 0.3 else "low"
+    return {"level": level, "score": score}
+
+
+def dual_query(
+    messages: list[dict],
+    left: tuple[str, object],
+    right: tuple[str, object],
+    temperature: float,
+    max_tokens: int,
+    judge=None,
+) -> dict:
+    """Run two models on the same prompt (in parallel) for side-by-side
+    comparison, optionally synthesizing a merged answer with a judge."""
+    pairs = [left, right]
+    answers: dict[str, str] = {}
+    with ThreadPoolExecutor(max_workers=2) as pool:
+        futures = {
+            pool.submit(_chain_answer, backend, messages, temperature, max_tokens): name
+            for name, backend in pairs
+        }
+        for future in as_completed(futures):
+            answers[futures[future]] = future.result()
+    results = [
+        {"name": left[0], "content": answers[left[0]]},
+        {"name": right[0], "content": answers[right[0]]},
+    ]
+    synthesis = None
+    if judge is not None:
+        synthesis = _judge(messages, results, judge, temperature, max_tokens)
+    return {"left": results[0], "right": results[1], "synthesis": synthesis}

deepparallel/licensing.py

@@ -0,0 +1,108 @@
+"""License tiers and offline verification for DeepParallel.
+
+A license key is a signed token `body.signature` where body is
+url-safe-base64(JSON payload) and signature is an Ed25519 signature of the body.
+The CLI embeds the issuer's PUBLIC key and verifies offline, so a key cannot be
+forged without the private issuance key (held server-side, used at Stripe
+fulfillment time).
+
+Open-core split:
+- FREE: the full single-model agent and all tools (bring your own key).
+- PRO/TEAM: the fusion layer - Guardian edit-review, fusion modes, and the
+  --deep multi-model council - which is the paid value.
+
+Enforcement here is the client-side gate; hosted inference is additionally
+gated server-side at the gateway.
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import os
+import time
+from enum import IntEnum
+from pathlib import Path
+
+# Issuer public key (Ed25519, raw, base64). The matching private key is the
+# issuance secret and is never shipped.
+_EMBEDDED_PUBKEY = "I0YYNFwGGUZGD6h15leBEPBQ197Snik+njzxkVf/Owg="
+
+# Paid features -> minimum tier required.
+_FEATURE_TIER: dict[str, "Tier"] = {}
+
+
+class Tier(IntEnum):
+    FREE = 0
+    PRO = 1
+    TEAM = 2
+
+    @property
+    def label(self) -> str:
+        return {0: "Free", 1: "Pro", 2: "Team"}[int(self)]
+
+
+def _b64url_decode(s: str) -> bytes:
+    return base64.urlsafe_b64decode(s + "=" * (-len(s) % 4))
+
+
+def verify_token(token: str, pubkey_b64: str | None = None) -> dict | None:
+    """Return the payload dict if the token is validly signed and unexpired."""
+    if not token or "." not in token:
+        return None
+    try:
+        from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
+    except ImportError:
+        return None
+    body, _, sig = token.partition(".")
+    try:
+        pub = Ed25519PublicKey.from_public_bytes(_b64url_decode(pubkey_b64 or _EMBEDDED_PUBKEY))
+        pub.verify(_b64url_decode(sig), body.encode())
+    except Exception:  # noqa: BLE001 - any failure (bad sig/key/encoding) = invalid
+        return None
+    try:
+        payload = json.loads(_b64url_decode(body))
+    except (ValueError, json.JSONDecodeError):
+        return None
+    exp = payload.get("exp", 0)
+    if exp and time.time() > exp:
+        return None
+    return payload
+
+
+def _license_file_token() -> str | None:
+    path = Path(
+        os.environ.get("DEEPPARALLEL_LICENSE_FILE", "~/.config/deepparallel/license")
+    ).expanduser()
+    try:
+        return path.read_text().strip() or None
+    except OSError:
+        return None
+
+
+def resolve_tier() -> Tier:
+    """Resolve the active tier from the license env var or file. FREE on absence/failure."""
+    token = os.environ.get("DEEPPARALLEL_LICENSE") or _license_file_token()
+    if not token:
+        return Tier.FREE
+    payload = verify_token(token)
+    if not payload:
+        return Tier.FREE
+    name = str(payload.get("tier", "")).upper()
+    return getattr(Tier, name, Tier.FREE) if name in Tier.__members__ else Tier.FREE
+
+
+def tier_allows(have: Tier, need: Tier) -> bool:
+    return int(have) >= int(need)
+
+
+def check_feature(feature: str, have: Tier | None = None) -> tuple[bool, str]:
+    """Return (allowed, message). Paid features need PRO+; message nudges upgrade."""
+    have = resolve_tier() if have is None else have
+    need = _FEATURE_TIER.get(feature, Tier.PRO)
+    if tier_allows(have, need):
+        return True, ""
+    return False, (
+        f"{feature} requires DeepParallel {need.label} (you are on {have.label}). "
+        f"Upgrade at https://deepparallel.dev/pricing"
+    )

deepparallel/registry.json

@@ -0,0 +1,13 @@
+{
+  "models": [
+    {
+      "name": "crowelm-deepparallel",
+      "label": "DeepParallel",
+      "deployment": "DeepSeek-V4-Pro",
+      "base_family": "CroweLM",
+      "context_window": 131072,
+      "license": "Crowe Logic Service Terms",
+      "license_url": "https://crowelogic.com"
+    }
+  ]
+}