openprism 0.1.0__py3-none-any.whl

openprism/__init__.py

@@ -0,0 +1,9 @@
+"""OpenPrism — many diverse model voices, split and recombined into one judged answer.
+
+A panel of models (your own provider keys, or any model in opencode) runs in
+parallel; a judge model reconciles them. Two modes:
+  - research: Fusion-style synthesis (consensus / contradictions / gaps -> grounded answer)
+  - code:     best-of-N selection + repair into one final solution
+"""
+
+__version__ = "0.1.0"

openprism/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

openprism/backends/__init__.py

@@ -0,0 +1,10 @@
+"""Model backends — where Prism's panel calls actually go.
+
+- DirectBackend: Prism's own OpenAI-compatible providers (keys in .env / providers.json).
+  Used by Claude Code and the standalone CLI, which have no provider registry to borrow.
+- OpencodeBackend: piggybacks on a running opencode server — every provider/model the
+  user has configured/authed in opencode, with zero hardcoding. Used in opencode.
+"""
+from .base import Backend, ModelInfo, get_backend
+
+__all__ = ["Backend", "ModelInfo", "get_backend"]

openprism/backends/base.py

@@ -0,0 +1,74 @@
+"""Backend interface + factory.
+
+A backend turns a model reference into a completion. Model references are always
+`provider/model`; because some model ids themselves contain slashes
+(e.g. opencode's `requesty/xai/grok-4`), we split on the FIRST slash only.
+"""
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+
+@dataclass
+class ModelInfo:
+    ref: str            # full reference, e.g. "google/gemini-2.5-flash"
+    provider: str       # provider id
+    model: str          # model id (may contain slashes)
+    name: str = ""      # human display name, if known
+    connected: bool = True
+
+
+def split_ref(ref: str, default_provider: str = "") -> tuple[str, str]:
+    """`provider/model` -> (provider, model). Bare ref -> (default_provider, ref)."""
+    if "/" in ref:
+        provider, model = ref.split("/", 1)
+        return provider, model
+    return default_provider, ref
+
+
+class Backend(ABC):
+    """Async backend. Implementations must be safe to call concurrently."""
+
+    name = "base"
+
+    @abstractmethod
+    async def list_models(self) -> list[ModelInfo]:
+        ...
+
+    @abstractmethod
+    async def complete(
+        self, model_ref: str, prompt: str, system: str | None, max_tokens: int,
+        tools: dict | None = None,
+    ) -> tuple[str, int]:
+        """Return (text, total_tokens). Raise on failure — the panel layer
+        catches per-model so one failure never sinks the run. `tools` is a
+        name->bool map for backends that support tool use (opencode); backends
+        that can't (direct raw completions) ignore it."""
+        ...
+
+    async def default_panel(self, mode: str) -> list[str]:
+        """Models to use when the caller gives no explicit panel. Default: the
+        configured preset for `mode`. opencode overrides this dynamically."""
+        from .. import config
+
+        return config.resolve_panel(mode if mode in config.PANELS else None)
+
+    async def aclose(self) -> None:
+        pass
+
+
+def get_backend(name: str | None = None) -> Backend:
+    """Factory. `name` overrides config.BACKEND."""
+    from .. import config
+
+    backend = (name or config.BACKEND).lower()
+    if backend == "opencode":
+        from .opencode import OpencodeBackend
+
+        return OpencodeBackend()
+    if backend == "direct":
+        from .direct import DirectBackend
+
+        return DirectBackend()
+    raise config.PrismError(f"Unknown OPENPRISM_BACKEND: {backend!r} (use 'direct' or 'opencode').")

openprism/backends/direct.py

@@ -0,0 +1,77 @@
+"""DirectBackend — Prism's own OpenAI-compatible providers.
+
+Providers come from config.load_providers() (the Alibaba Coding Plan from .env by
+default, plus anything in providers.json). Used by Claude Code and the CLI, which
+have no host provider registry to borrow. A bare model id (no slash) resolves to
+the default provider, preserving the original single-provider behaviour.
+"""
+from __future__ import annotations
+
+from openai import AsyncOpenAI
+
+from .. import config
+from .base import Backend, ModelInfo, split_ref
+
+
+class DirectBackend(Backend):
+    name = "direct"
+
+    def __init__(self) -> None:
+        self.providers = config.load_providers()
+        if not self.providers:
+            raise config.PrismError(
+                "No providers configured. Set ALIBABA_API_KEY in .env (or add "
+                "providers.json), or use OPENPRISM_BACKEND=opencode."
+            )
+        self.default_provider = config.DEFAULT_PROVIDER or next(iter(self.providers))
+        if self.default_provider not in self.providers:
+            import sys
+
+            fallback = next(iter(self.providers))
+            print(f"openprism: OPENPRISM_DEFAULT_PROVIDER={self.default_provider!r} is not "
+                  f"configured; using {fallback!r} for bare model ids", file=sys.stderr)
+            self.default_provider = fallback
+        self._clients: dict[str, AsyncOpenAI] = {}
+
+    def _client(self, provider_id: str) -> AsyncOpenAI:
+        if provider_id not in self.providers:
+            raise config.PrismError(
+                f"Provider {provider_id!r} not configured. Known: {list(self.providers)}"
+            )
+        if provider_id not in self._clients:
+            p = self.providers[provider_id]
+            self._clients[provider_id] = AsyncOpenAI(api_key=p.api_key, base_url=p.base_url)
+        return self._clients[provider_id]
+
+    async def list_models(self) -> list[ModelInfo]:
+        out: list[ModelInfo] = []
+        for pid, p in self.providers.items():
+            for m in p.models:
+                ref = m if pid == self.default_provider else f"{pid}/{m}"
+                out.append(ModelInfo(ref=ref, provider=pid, model=m))
+        return out
+
+    async def complete(
+        self, model_ref: str, prompt: str, system: str | None, max_tokens: int,
+        tools: dict | None = None,
+    ) -> tuple[str, int]:
+        # `tools` is ignored: direct providers are plain completions. Panelist tool
+        # use (web/fetch) requires the opencode backend.
+        provider_id, model = split_ref(model_ref, self.default_provider)
+        client = self._client(provider_id)
+        messages = ([{"role": "system", "content": system}] if system else []) + [
+            {"role": "user", "content": prompt}
+        ]
+        resp = await client.chat.completions.create(
+            model=model, messages=messages, max_tokens=max_tokens
+        )
+        if not getattr(resp, "choices", None):
+            raise RuntimeError(f"{model}: provider returned no choices")
+        text = resp.choices[0].message.content or ""
+        usage = getattr(resp, "usage", None)
+        tokens = getattr(usage, "total_tokens", 0) if usage else 0
+        return text, tokens
+
+    async def aclose(self) -> None:
+        for client in self._clients.values():
+            await client.close()

openprism/backends/opencode.py

@@ -0,0 +1,255 @@
+"""OpencodeBackend — piggyback on opencode's provider layer.
+
+Talks to a local opencode HTTP server. Every provider/model the user has
+configured/authed in opencode is available, discovered live from `/provider` —
+NO hardcoded providers or models. opencode does all auth; Prism never sees keys.
+
+Server resolution:
+  1. OPENPRISM_OPENCODE_URL if set.
+  2. otherwise http://127.0.0.1:<OPENPRISM_OPENCODE_PORT or 4096>; if nothing is
+     listening there and autoserve is on (default), spawn `opencode serve` and
+     wait for it — reusing the user's existing auth.json.
+
+A completion = POST /session then POST /session/:id/message with tools disabled,
+which returns a clean (non-agentic) model answer. Each panelist gets its own
+session so panelists never see each other's context.
+"""
+from __future__ import annotations
+
+import atexit
+import os
+import shutil
+import subprocess
+import tempfile
+import threading
+import time
+from urllib.parse import urlsplit
+
+import httpx
+
+from .. import config
+from .base import Backend, ModelInfo, split_ref
+
+
+def _find_opencode() -> str | None:
+    """Locate the opencode binary. The MCP server is launched by a host with a
+    minimal PATH that often misses bun/npm shims, so check common install dirs."""
+    exe = shutil.which("opencode")
+    if exe:
+        return exe
+    candidates = [
+        "~/.opencode/bin/opencode", "~/.bun/bin/opencode", "~/.local/bin/opencode",
+        "/usr/local/bin/opencode", "/opt/homebrew/bin/opencode",
+    ]
+    for c in candidates:
+        p = os.path.expanduser(c)
+        if os.path.exists(p):
+            return p
+    return None
+
+
+# A server we spawn ourselves is shared across backend instances (the MCP server
+# builds a fresh backend per tool call) and torn down once at process exit — so we
+# don't spawn/kill a server on every call or leak orphans.
+_SHARED_SERVER: subprocess.Popen | None = None
+_SPAWN_LOCK = threading.Lock()
+
+
+def _shutdown_shared_server() -> None:
+    global _SHARED_SERVER
+    if _SHARED_SERVER is not None:
+        _SHARED_SERVER.terminate()
+        try:
+            _SHARED_SERVER.wait(timeout=5)
+        except Exception:  # noqa: BLE001
+            _SHARED_SERVER.kill()
+        _SHARED_SERVER = None
+
+
+atexit.register(_shutdown_shared_server)
+
+
+class OpencodeBackend(Backend):
+    name = "opencode"
+
+    def __init__(self) -> None:
+        self.base_url = config.OPENCODE_URL.rstrip("/")
+        scheme = urlsplit(self.base_url).scheme
+        if scheme not in ("http", "https"):
+            raise config.PrismError(
+                f"OPENPRISM_OPENCODE_URL must be http(s), got {self.base_url!r}."
+            )
+        self._client = httpx.AsyncClient(
+            base_url=self.base_url,
+            timeout=httpx.Timeout(config.PANEL_TIMEOUT, connect=10.0),
+            auth=(("opencode", config.OPENCODE_PASSWORD) if config.OPENCODE_PASSWORD else None),
+        )
+        self._ensure_server()
+
+    @property
+    def _auth(self):
+        return ("opencode", config.OPENCODE_PASSWORD) if config.OPENCODE_PASSWORD else None
+
+    # --- server lifecycle ---
+    def _reachable(self) -> bool:
+        try:
+            with httpx.Client(base_url=self.base_url, timeout=2.0, auth=self._auth) as c:
+                return c.get("/provider").status_code == 200
+        except Exception:  # noqa: BLE001
+            return False
+
+    def _ensure_server(self) -> None:
+        # Use an already-running server (the user's TUI/serve, or one we spawned
+        # earlier this process) if reachable at the configured URL.
+        if self._reachable():
+            return
+        if not config.OPENCODE_AUTOSERVE:
+            raise config.PrismError(
+                f"No opencode server reachable at {self.base_url} and autoserve is off. "
+                "Start `opencode serve` or set OPENPRISM_OPENCODE_URL."
+            )
+        global _SHARED_SERVER
+        port = urlsplit(self.base_url).port
+        if not port:
+            raise config.PrismError(
+                f"Can't derive a port from OPENPRISM_OPENCODE_URL={self.base_url!r} to autospawn; "
+                "set OPENPRISM_OPENCODE_PORT or point at a running server."
+            )
+        exe = _find_opencode()
+        if not exe:
+            raise config.PrismError(
+                "`opencode` binary not found (checked PATH, ~/.opencode/bin, ~/.bun/bin, "
+                "etc.) — install opencode or set OPENPRISM_OPENCODE_URL to a running server."
+            )
+        # Serialise the check-then-spawn so concurrent backends don't race to start
+        # two servers on the same port.
+        with _SPAWN_LOCK:
+            if self._reachable():  # another thread may have started it
+                return
+            # Capture stderr so a startup failure (port clash, bad argv, crash) has
+            # a diagnostic instead of vanishing into DEVNULL.
+            log = tempfile.NamedTemporaryFile(
+                prefix="openprism-opencode-", suffix=".log", mode="w+", delete=False
+            )
+            # Spawn once per process; persists for reuse, cleaned up at exit.
+            _SHARED_SERVER = subprocess.Popen(
+                [exe, "serve", "--port", str(port)],
+                stdout=subprocess.DEVNULL, stderr=log,
+            )
+            for _ in range(40):  # ~20s
+                if self._reachable():
+                    return
+                time.sleep(0.5)
+        try:
+            log.flush()
+            log.seek(0)
+            tail = log.read()[-800:].strip()
+        except Exception:  # noqa: BLE001
+            tail = ""
+        raise config.PrismError(
+            f"Spawned `opencode serve` but it never came up on {self.base_url}."
+            + (f"\n--- opencode stderr ---\n{tail}" if tail else "")
+        )
+
+    # --- Backend interface ---
+    async def list_models(self) -> list[ModelInfo]:
+        r = await self._client.get("/provider")
+        r.raise_for_status()
+        data = r.json()
+        connected = set(data.get("connected", []))
+        out: list[ModelInfo] = []
+        for p in data.get("all", []):
+            pid = p["id"]
+            for mid, m in (p.get("models") or {}).items():
+                out.append(ModelInfo(
+                    ref=f"{pid}/{mid}", provider=pid, model=mid,
+                    name=(m or {}).get("name", ""), connected=pid in connected,
+                ))
+        return out
+
+    # Model id/name substrings that mark a non-chat model (skip in auto panels).
+    _NON_CHAT = (
+        "embed", "embedding", "rerank", "whisper", "tts", "image", "video",
+        "ocr", "guard", "moderation",
+    )
+
+    async def default_panel(self, mode: str) -> list[str]:
+        """Pick a diverse default: one chat model from each of up to 4 distinct
+        model FAMILIES (not just providers) — so the panel is genuinely diverse,
+        never two models from the same family. The user normally specifies their own."""
+        models = [m for m in await self.list_models() if m.connected]
+
+        def is_chat(m: ModelInfo) -> bool:
+            s = f"{m.model} {m.name}".lower()
+            return not any(k in s for k in self._NON_CHAT)
+
+        picked: list[str] = []
+        seen_families: set[str] = set()
+        for m in models:
+            if not is_chat(m):
+                continue
+            fam = config.model_family(m.ref)
+            if fam in seen_families:
+                continue
+            seen_families.add(fam)
+            picked.append(m.ref)
+            if len(picked) >= 4:
+                break
+        if not picked:
+            raise config.PrismError(
+                "No connected chat models in opencode to build a default panel — "
+                "specify a panel of provider/model refs."
+            )
+        return picked
+
+    async def complete(
+        self, model_ref: str, prompt: str, system: str | None, max_tokens: int,
+        tools: dict | None = None,
+    ) -> tuple[str, int]:
+        provider_id, model = split_ref(model_ref)
+        if not provider_id:
+            raise config.PrismError(
+                f"opencode model ref must be 'provider/model', got {model_ref!r}."
+            )
+        sess = await self._client.post("/session", json={"title": "openprism"})
+        sess.raise_for_status()
+        sid = sess.json().get("id")
+        if not sid:
+            raise RuntimeError(f"opencode/{model_ref}: session create returned no id ({sess.text[:200]})")
+        # opencode enables ALL tools by default; `tools` is an explicit name->bool
+        # allow/deny map. None = omit = opencode defaults (every tool). The panel
+        # layer passes a restricted map (web + read-only) so panelists can browse
+        # but cannot run bash/edit/write. Each panelist gets its own session.
+        body = {
+            "model": {"providerID": provider_id, "modelID": model},
+            "parts": [{"type": "text", "text": prompt}],
+        }
+        if tools is not None:
+            body["tools"] = tools
+        if system:
+            body["system"] = system
+        try:
+            r = await self._client.post(f"/session/{sid}/message", json=body)
+            r.raise_for_status()
+            d = r.json()
+        finally:
+            # Don't litter the user's opencode history with a session per panelist.
+            try:
+                await self._client.delete(f"/session/{sid}")
+            except Exception:  # noqa: BLE001 — best-effort cleanup
+                pass
+        info = d.get("info", {})
+        err = info.get("error")
+        if err:
+            msg = (err.get("data") or {}).get("message") or err.get("name") or "unknown error"
+            raise RuntimeError(f"opencode/{model_ref}: {msg}")
+        text = "".join(
+            p.get("text", "") for p in d.get("parts", []) if p.get("type") == "text"
+        ).strip()
+        tokens = (info.get("tokens") or {}).get("total", 0)
+        return text, tokens
+
+    async def aclose(self) -> None:
+        # Only close this instance's HTTP client. Any server we spawned is shared
+        # and lives until process exit (see _shutdown_shared_server / atexit).
+        await self._client.aclose()

openprism/cli.py

@@ -0,0 +1,106 @@
+"""Prism CLI.
+
+  openprism "question"                       # research synthesis (default 4-house panel)
+  openprism "task" --mode code               # best-of-N + repair (coder panel)
+  openprism "q" --panel research-lean        # use a preset
+  openprism "q" --panel qwen3.7-plus,glm-5   # ad-hoc panel
+  openprism --bakeoff qwen3.7-plus qwen3-max-2026-01-23 "your test prompt"
+  openprism --list                           # show presets + known models
+"""
+import argparse
+import sys
+
+from . import config
+from .config import PrismError
+from .pipeline import bakeoff, run
+
+# Windows consoles default to cp1252 and choke on model output / glyphs.
+try:
+    sys.stdout.reconfigure(encoding="utf-8")
+    sys.stderr.reconfigure(encoding="utf-8")
+except (AttributeError, ValueError):
+    pass
+
+
+def _print_result(result) -> None:
+    print("\n" + "=" * 70)
+    print(f"OPENPRISM | mode={result.mode} | judge={result.judge_backend}")
+    print(result.status_line())
+    print("Panel:")
+    print(result.panel_summary())
+    print("=" * 70 + "\n")
+    print(result.final)
+    print()
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = sys.argv[1:] if argv is None else argv
+    if argv and argv[0] == "doctor":
+        from .doctor import run_doctor
+
+        return run_doctor()
+    if argv and argv[0] == "init":
+        from .init_cmd import run_init
+
+        ip = argparse.ArgumentParser(prog="openprism init",
+                                     description="Generate MCP config for a host.")
+        ip.add_argument("--host", help="claude-code | opencode | cursor | windsurf | gemini | codex")
+        ip.add_argument("--backend", default="opencode", choices=["direct", "opencode"])
+        ip.add_argument("--judge-backend", dest="judge_backend", default=None)
+        ip.add_argument("--judge-model", dest="judge_model", default=None)
+        ip.add_argument("--local", action="store_true",
+                        help="launch from this checkout instead of uvx")
+        ip.add_argument("--pypi", action="store_true",
+                        help="emit the published-package form (after PyPI publish) instead of uvx-from-git")
+        ip.add_argument("--ref", default=None,
+                        help="pin the uvx-from-git launch to a tag/branch/sha (recommended)")
+        ip.add_argument("--write", action="store_true", help="merge into the host's config file")
+        ip.add_argument("--print", action="store_true", help="print the config block (default)")
+        return run_init(ip.parse_args(argv[1:]))
+
+    p = argparse.ArgumentParser(prog="openprism", description="Multi-model panel + judge.")
+    p.add_argument("question", nargs="*", help="the question / task")
+    p.add_argument("--mode", choices=["research", "code"], default="research")
+    p.add_argument("--panel", help="preset name or comma-separated model ids")
+    p.add_argument("--bakeoff", nargs=2, metavar=("MODEL_A", "MODEL_B"),
+                   help="compare two models on the question; judge picks a winner")
+    p.add_argument("--list", action="store_true", help="list presets and known models")
+    args = p.parse_args(argv)
+
+    if args.list:
+        print("Panel presets:")
+        for name, models in config.PANELS.items():
+            print(f"  {name:<16} {', '.join(models)}")
+        print("\nKnown models:")
+        for m in config.KNOWN_MODELS:
+            print(f"  {m}")
+        return 0
+
+    question = " ".join(args.question).strip()
+    if not question:
+        p.error("no question given")
+
+    try:
+        if args.bakeoff:
+            a, b = args.bakeoff
+            verdict, responses = bakeoff(question, a, b)
+            print("\n" + "=" * 70)
+            print(f"BAKE-OFF | {a}  vs  {b}")
+            for r in responses:
+                tag = f"{r.latency:.1f}s" if r.ok else f"FAILED: {r.error}"
+                print(f"  {r.model:<22} {tag}")
+            print("=" * 70 + "\n")
+            print(verdict)
+            print()
+            return 0
+
+        result = run(question, mode=args.mode, panel_spec=args.panel)
+        _print_result(result)
+        return 0
+    except PrismError as e:
+        print(f"openprism: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())