prysm1 0.1.0__tar.gz

prysm1-0.1.0/.gitignore

@@ -0,0 +1,52 @@
+# Environment
+.env
+*.env.local
+
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.venv/
+venv/
+
+# Node
+node_modules/
+.next/
+out/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+.DS_Store
+
+# Docker
+*.log
+
+# Outputs
+*.tar.gz
+
+# Database (SQLite — local/runtime state, never commit)
+*.db
+*.db-wal
+*.db-shm
+*.sqlite
+*.sqlite3
+
+# Benchmark data (fetched on demand; third-party licenses, e.g. AIME CC BY-NC-SA 4.0).
+# We ship NO benchmark data in the repo — fetch_aime.py downloads it here at run time.
+backend/eval/data/
+eval/data/
+
+# ── Docs internos sensibles (IP pre-patente) ──
+# Excluidos por precaución (claims de patente sin presentar). Borra estas 2 líneas
+# si quieres versionarlos en tu repo PRIVADO.
+PRYSM-1-MODELO-DE-NEGOCIO.md
+PRYSM-IP-OPORTUNIDADES.md
+
+# Fixture huérfano de eval (ningún código lo referencia). Se mantiene local pero
+# se destrackea para adelgazar el repo; recuperable del historial si se necesita.
+backend/eval/_PILOT_test.pdf

prysm1-0.1.0/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: prysm1
+Version: 0.1.0
+Summary: PRYSM — universal AI routing, OpenAI drop-in. One API, every model, always the best one.
+Project-URL: Homepage, https://prysm1.com
+Project-URL: Documentation, https://docs.prysm1.com
+Author: PRYSM
+License: Proprietary
+Keywords: agents,ai,gateway,llm,openai,prysm,routing
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27
+Requires-Dist: openai>=1.40
+Provides-Extra: yaml
+Requires-Dist: pyyaml>=6.0; extra == 'yaml'
+Description-Content-Type: text/markdown
+
+# prysm1 — PRYSM Python SDK
+
+**One API, every model, always the best one.** An OpenAI drop-in: change one line,
+get intelligent routing across 21 models, cost guardrails (AgentGuard), declarative
+config (BRAIN.md), and cryptographic receipts (PrysmProof).
+
+```bash
+pip install prysm1
+```
+
+## Drop-in replacement for OpenAI
+
+`Prysm` subclasses `openai.OpenAI`, so all your existing code works unchanged.
+
+```python
+from prysm import Prysm
+
+client = Prysm()  # api_key from $PRYSM_API_KEY, base_url from $PRYSM_BASE_URL
+
+resp = client.chat.completions.create(
+    model="auto",                       # let PRYSM pick the best model
+    messages=[{"role": "user", "content": "Write a Python quicksort"}],
+)
+print(resp.choices[0].message.content)
+```
+
+### Access the PRYSM extensions
+
+Every response carries a `prysm` block (routing, cost, latency, proof). Use
+`extension()` for clean dot-access:
+
+```python
+import prysm
+
+ext = prysm.extension(resp)
+print(ext.routing.model_display)  # "DeepSeek V3.2"
+print(ext.cost.total_usd)         # 0.000042
+print(ext.proof.proof_hash)       # "sha256:a1b2c3d4..."
+```
+
+## BRAIN.md auto-discovery
+
+Drop a `BRAIN.md` in your project root and the SDK finds it automatically, applying
+your routing rules / cost caps / blocked models on every `complete()` call:
+
+```python
+client = Prysm()                 # discovers ./BRAIN.md (walks up from cwd)
+resp = client.complete("Summarize this contract")   # BRAIN.md applied
+```
+
+Point it explicitly, pass a dict, or disable:
+
+```python
+Prysm(brain="path/to/BRAIN.md")
+Prysm(brain={"max_cost": 0.005, "model": "deepseek-v3.2"})
+Prysm(brain=None)                # ignore BRAIN.md
+```
+
+Validate a BRAIN.md before shipping:
+
+```python
+print(client.validate_brain(open("BRAIN.md").read()))
+# {'valid': True, 'errors': [], 'warnings': [], 'normalized': {...}}
+```
+
+## Helpers
+
+```python
+client.route("debug this function")     # dry-run: which model, est. cost (no call)
+client.usage()                          # your usage stats
+client.savings(baseline="gpt-5.2")      # est. $ saved vs. an all-premium baseline
+client.verify_proof(request_id)         # verify a PrysmProof
+client.models_catalog()                 # 21 models with pricing
+```
+
+## Configuration
+
+| Setting | Argument | Env var | Default |
+|---------|----------|---------|---------|
+| API key | `api_key=` | `PRYSM_API_KEY` | — |
+| Base URL | `base_url=` | `PRYSM_BASE_URL` | `https://api.prysm1.com/v1` |
+| BRAIN.md | `brain=` | — | `"auto"` (discover) |
+
+Get an API key at [prysm1.com](https://prysm1.com). Full docs at
+[docs.prysm1.com](https://docs.prysm1.com).
+
+## Development
+
+```bash
+python tests/test_sdk.py   # no pytest required; runs against the backend in-process
+```
+
+## License
+
+Proprietary.

prysm1-0.1.0/README.md

@@ -0,0 +1,95 @@
+# prysm1 — PRYSM Python SDK
+
+**One API, every model, always the best one.** An OpenAI drop-in: change one line,
+get intelligent routing across 21 models, cost guardrails (AgentGuard), declarative
+config (BRAIN.md), and cryptographic receipts (PrysmProof).
+
+```bash
+pip install prysm1
+```
+
+## Drop-in replacement for OpenAI
+
+`Prysm` subclasses `openai.OpenAI`, so all your existing code works unchanged.
+
+```python
+from prysm import Prysm
+
+client = Prysm()  # api_key from $PRYSM_API_KEY, base_url from $PRYSM_BASE_URL
+
+resp = client.chat.completions.create(
+    model="auto",                       # let PRYSM pick the best model
+    messages=[{"role": "user", "content": "Write a Python quicksort"}],
+)
+print(resp.choices[0].message.content)
+```
+
+### Access the PRYSM extensions
+
+Every response carries a `prysm` block (routing, cost, latency, proof). Use
+`extension()` for clean dot-access:
+
+```python
+import prysm
+
+ext = prysm.extension(resp)
+print(ext.routing.model_display)  # "DeepSeek V3.2"
+print(ext.cost.total_usd)         # 0.000042
+print(ext.proof.proof_hash)       # "sha256:a1b2c3d4..."
+```
+
+## BRAIN.md auto-discovery
+
+Drop a `BRAIN.md` in your project root and the SDK finds it automatically, applying
+your routing rules / cost caps / blocked models on every `complete()` call:
+
+```python
+client = Prysm()                 # discovers ./BRAIN.md (walks up from cwd)
+resp = client.complete("Summarize this contract")   # BRAIN.md applied
+```
+
+Point it explicitly, pass a dict, or disable:
+
+```python
+Prysm(brain="path/to/BRAIN.md")
+Prysm(brain={"max_cost": 0.005, "model": "deepseek-v3.2"})
+Prysm(brain=None)                # ignore BRAIN.md
+```
+
+Validate a BRAIN.md before shipping:
+
+```python
+print(client.validate_brain(open("BRAIN.md").read()))
+# {'valid': True, 'errors': [], 'warnings': [], 'normalized': {...}}
+```
+
+## Helpers
+
+```python
+client.route("debug this function")     # dry-run: which model, est. cost (no call)
+client.usage()                          # your usage stats
+client.savings(baseline="gpt-5.2")      # est. $ saved vs. an all-premium baseline
+client.verify_proof(request_id)         # verify a PrysmProof
+client.models_catalog()                 # 21 models with pricing
+```
+
+## Configuration
+
+| Setting | Argument | Env var | Default |
+|---------|----------|---------|---------|
+| API key | `api_key=` | `PRYSM_API_KEY` | — |
+| Base URL | `base_url=` | `PRYSM_BASE_URL` | `https://api.prysm1.com/v1` |
+| BRAIN.md | `brain=` | — | `"auto"` (discover) |
+
+Get an API key at [prysm1.com](https://prysm1.com). Full docs at
+[docs.prysm1.com](https://docs.prysm1.com).
+
+## Development
+
+```bash
+python tests/test_sdk.py   # no pytest required; runs against the backend in-process
+```
+
+## License
+
+Proprietary.

prysm1-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "prysm1"
+version = "0.1.0"
+description = "PRYSM — universal AI routing, OpenAI drop-in. One API, every model, always the best one."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "Proprietary" }
+authors = [{ name = "PRYSM" }]
+keywords = ["ai", "llm", "routing", "openai", "gateway", "prysm", "agents"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Intended Audience :: Developers",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "openai>=1.40",
+    "httpx>=0.27",
+]
+
+[project.optional-dependencies]
+yaml = ["pyyaml>=6.0"]
+
+[project.scripts]
+prysm = "prysm.cli:main"
+
+[project.urls]
+Homepage = "https://prysm1.com"
+Documentation = "https://docs.prysm1.com"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/prysm"]

prysm1-0.1.0/src/prysm/__init__.py

@@ -0,0 +1,31 @@
+"""
+prysm1 — PRYSM Python SDK.
+
+One API, every model, always the best one. An OpenAI drop-in:
+
+    from prysm import Prysm
+    client = Prysm()
+    resp = client.chat.completions.create(
+        model="auto",
+        messages=[{"role": "user", "content": "Hello"}],
+    )
+    print(prysm.extension(resp).routing.model_display)
+"""
+from .brain import find_brain, load_brain, normalize_brain, parse_brain
+from .client import Prysm
+from .extensions import cost, extension, proof, routing
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Prysm",
+    "extension",
+    "routing",
+    "cost",
+    "proof",
+    "load_brain",
+    "find_brain",
+    "parse_brain",
+    "normalize_brain",
+    "__version__",
+]

prysm1-0.1.0/src/prysm/brain.py

@@ -0,0 +1,208 @@
+"""
+prysm.brain — client-side BRAIN.md discovery + parsing.
+
+Mirrors the server's parser so the SDK can auto-discover a project's BRAIN.md and
+inject it into requests without a network round-trip. Uses PyYAML when present,
+falls back to a dependency-free subset parser.
+"""
+from __future__ import annotations
+
+import os
+from typing import Any, Optional
+
+# BRAIN.md 'when' vocabulary -> canonical router signals.
+SIGNAL_ALIASES = {
+    "code": "code", "coding": "code", "programming": "code", "dev": "code",
+    "write": "write", "writing": "write", "content": "write", "copy": "write", "copywriting": "write",
+    "analysis": "analysis", "research": "analysis", "analyze": "analysis", "analyse": "analysis",
+    "math": "math", "maths": "math", "calculation": "math", "calc": "math",
+    "translate": "translate", "translation": "translate", "i18n": "translate",
+    "realtime": "realtime", "real-time": "realtime", "news": "realtime", "live": "realtime",
+    "simple": "simple", "quick": "simple", "lookup": "simple",
+    "multimodal": "multimodal", "vision": "multimodal", "image": "multimodal", "images": "multimodal",
+    "reasoning": "reasoning", "logic": "reasoning", "reason": "reasoning",
+}
+
+
+def _split_commas(s: str) -> list:
+    out, buf, q = [], "", None
+    for ch in s:
+        if q:
+            buf += ch
+            if ch == q:
+                q = None
+        elif ch in ("'", '"'):
+            q = ch
+            buf += ch
+        elif ch == ",":
+            out.append(buf)
+            buf = ""
+        else:
+            buf += ch
+    if buf.strip():
+        out.append(buf)
+    return out
+
+
+def _coerce(v: str) -> Any:
+    s = v.strip()
+    if not s:
+        return ""
+    if s.startswith("[") and s.endswith("]"):
+        inner = s[1:-1].strip()
+        return [] if not inner else [_coerce(x) for x in _split_commas(inner)]
+    if len(s) >= 2 and s[0] == s[-1] and s[0] in ("'", '"'):
+        return s[1:-1]
+    low = s.lower()
+    if low in ("true", "yes", "on"):
+        return True
+    if low in ("false", "no", "off"):
+        return False
+    if low in ("null", "none", "~"):
+        return None
+    try:
+        return float(s) if ("." in s or "e" in low) else int(s)
+    except ValueError:
+        return s
+
+
+def _strip_inline_comment(line: str) -> str:
+    q = None
+    for i, ch in enumerate(line):
+        if q:
+            if ch == q:
+                q = None
+        elif ch in ("'", '"'):
+            q = ch
+        elif ch == "#" and (i == 0 or line[i - 1] in (" ", "\t")):
+            return line[:i]
+    return line
+
+
+def _parse_subset(text: str) -> dict:
+    data: dict = {}
+    cur_key = None
+    cur_list = None
+    cur_dict = None
+    for raw in text.splitlines():
+        line = _strip_inline_comment(raw)
+        if not line.strip():
+            continue
+        stripped = line.strip()
+        indent = len(line) - len(line.lstrip())
+        if stripped.startswith("- "):
+            item = stripped[2:].strip()
+            if cur_list is None:
+                cur_list = []
+                if cur_key is not None:
+                    data[cur_key] = cur_list
+            if ":" in item and item[0] not in ("'", '"'):
+                k, _, v = item.partition(":")
+                cur_dict = {k.strip(): _coerce(v)}
+                cur_list.append(cur_dict)
+            else:
+                cur_dict = None
+                cur_list.append(_coerce(item))
+            continue
+        if indent > 0 and cur_dict is not None and ":" in stripped:
+            k, _, v = stripped.partition(":")
+            cur_dict[k.strip()] = _coerce(v)
+            continue
+        if ":" in stripped:
+            k, _, v = stripped.partition(":")
+            cur_key = k.strip()
+            cur_list = None
+            cur_dict = None
+            data[cur_key] = _coerce(v.strip()) if v.strip() != "" else None
+    return data
+
+
+def parse_brain(text: str) -> dict:
+    """Parse BRAIN.md text into a raw mapping. Uses PyYAML when available."""
+    if not text or not text.strip():
+        return {}
+    try:
+        import yaml  # type: ignore
+        data = yaml.safe_load(text)
+        if isinstance(data, dict):
+            return data
+    except Exception:
+        pass
+    return _parse_subset(text)
+
+
+def normalize_brain(raw: dict) -> dict:
+    """Map a raw BRAIN.md mapping to the canonical config the router consumes."""
+    raw = raw or {}
+    n: dict = {}
+    if raw.get("name"):
+        n["name"] = raw["name"]
+    if raw.get("version") is not None:
+        n["version"] = raw["version"]
+    if raw.get("model"):
+        n["model"] = raw["model"]
+    cap = raw.get("max_cost", raw.get("max_cost_per_request"))
+    if cap is not None:
+        n["max_cost"] = cap
+    if raw.get("monthly_budget") is not None:
+        n["monthly_budget"] = raw["monthly_budget"]
+    rules = []
+    for r in (raw.get("rules") or []):
+        if isinstance(r, dict) and r.get("when") and r.get("model"):
+            w = str(r["when"]).strip().lower()
+            rules.append({
+                "when": SIGNAL_ALIASES.get(w, w),
+                "model": r["model"],
+                "reason": r.get("reason", ""),
+            })
+    if rules:
+        n["rules"] = rules
+    if raw.get("blocked"):
+        n["blocked"] = [str(x) for x in raw["blocked"]]
+    if raw.get("fallback"):
+        n["fallback"] = [str(x) for x in raw["fallback"]]
+    if raw.get("quality_threshold") is not None:
+        n["quality_threshold"] = raw["quality_threshold"]
+    if raw.get("quality_signals"):
+        n["quality_signals"] = raw["quality_signals"]
+    if raw.get("log_level"):
+        n["log_level"] = raw["log_level"]
+    if raw.get("log_proofs") is not None:
+        n["log_proofs"] = raw["log_proofs"]
+    return n
+
+
+def find_brain(start: Optional[str] = None) -> Optional[str]:
+    """Walk up from `start` (or cwd) looking for a BRAIN.md. Returns its path or None."""
+    d = os.path.abspath(start or os.getcwd())
+    if os.path.isfile(d):  # a file was passed
+        return d if os.path.basename(d) == "BRAIN.md" else None
+    while True:
+        candidate = os.path.join(d, "BRAIN.md")
+        if os.path.isfile(candidate):
+            return candidate
+        parent = os.path.dirname(d)
+        if parent == d:
+            return None
+        d = parent
+
+
+def load_brain(path_or_dir: Optional[str] = None) -> Optional[dict]:
+    """Discover (or read) a BRAIN.md and return its normalized config, or None.
+
+    - None         -> auto-discover by walking up from cwd
+    - a directory  -> auto-discover from there
+    - a file path  -> read that file
+    """
+    path = path_or_dir
+    if path is None or os.path.isdir(path or ""):
+        path = find_brain(path)
+    if not path or not os.path.isfile(path):
+        return None
+    try:
+        with open(path, encoding="utf-8") as f:
+            text = f.read()
+    except OSError:
+        return None
+    normalized = normalize_brain(parse_brain(text))
+    return normalized or None