deepparallel 0.5.7__tar.gz → 0.6.0__tar.gz

{deepparallel-0.5.7 → deepparallel-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.5.7
+Version: 0.6.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.5.7 → deepparallel-0.6.0}/deepparallel/__init__.py

@@ -1,3 +1,3 @@
 """DeepParallel CLI package."""
 
-__version__ = "0.5.7"
+__version__ = "0.6.0"

{deepparallel-0.5.7 → deepparallel-0.6.0}/deepparallel/agent.py

@@ -255,16 +255,29 @@ def _supply_chain_note(name: str, args: dict) -> str | None:
     return None
 
 
-def _approved(name, args, interactive, auto_approve, renderer, guardian=None) -> bool:
+def _approved(name, args, interactive, auto_approve, renderer, guardian=None, mesh_fn=None) -> bool:
     forced = name in _GATED_PATH_TOOLS and _outside_cwd(args)
     sc_note = _supply_chain_note(name, args) if name in _EDIT_TOOLS else None
-    # A hallucinated dependency overrides auto-approve: always surface it.
-    if auto_approve and not forced and not sc_note:
+    # The verification mesh reviews every edit. A BUG verdict blocks the action
+    # and overrides auto-approve, exactly like a hallucinated dependency does.
+    mesh_result = None
+    if mesh_fn is not None and name in _EDIT_TOOLS:
+        try:
+            mesh_result = mesh_fn(_guardian_review_content(name, args))
+        except Exception:  # noqa: BLE001 - the gate is best-effort, never fatal
+            mesh_result = None
+    blocked = bool(mesh_result and mesh_result.get("severity") == "bug")
+    # A hallucinated dependency or a BUG verdict overrides auto-approve.
+    if auto_approve and not forced and not sc_note and not blocked:
         return True
     if not interactive:
         return False
     title, detail = _describe(name, args)
-    if guardian is not None and name in _EDIT_TOOLS:
+    if mesh_result is not None:
+        from deepparallel.mesh import format_panel
+
+        detail = f"{detail}\n\nVerification mesh:\n{format_panel(mesh_result)}"
+    elif guardian is not None and name in _EDIT_TOOLS:
         verdict = _guardian_verdict(guardian, name, args)
         if verdict:
             detail = f"{detail}\n\nGuardian: {verdict}"
@@ -307,6 +320,7 @@ def run_agent(
     max_steps: int | None = None,
     stream: bool = False,
     guardian=None,
+    mesh_fn=None,
     on_event=None,
 ) -> str:
     steps = max_steps if max_steps is not None else settings.max_steps
@@ -346,7 +360,7 @@ def run_agent(
             elif "__parse_error__" in args:
                 result = json.dumps({"error": "invalid JSON arguments"})
             elif meta.dangerous and not _approved(
-                name, args, interactive, auto_approve, renderer, guardian
+                name, args, interactive, auto_approve, renderer, guardian, mesh_fn
             ):
                 result = json.dumps({"error": "denied by user"})
             else:

{deepparallel-0.5.7 → deepparallel-0.6.0}/deepparallel/cli.py

@@ -177,6 +177,22 @@ def _build_guardian(settings: Settings) -> Backend | None:
     return backend_for_deployment(settings, settings.guardian_deployment)
 
 
+def _build_mesh(settings: Settings):
+    """The verification mesh: a parallel reviewer panel that gates every edit.
+
+    Supersedes the single guardian when available. Paid (Pro+) feature; returns
+    a callable ``mesh_fn(content) -> result`` or None on Free / when disabled.
+    """
+    if not settings.guardian_enabled:
+        return None
+    ok, _ = licensing.check_feature("mesh")
+    if not ok:
+        return None
+    from deepparallel import mesh
+
+    return lambda content: mesh.mesh_review(settings, content)
+
+
 def _system_prompt() -> str:
     """System prompt with the long-term memory index injected (recall tier 1)."""
     return load_system_prompt() + memory.index_block()
@@ -293,7 +309,8 @@ def _agent_repl(backend: Backend, settings: Settings, renderer: Renderer) -> Non
     """Interactive agentic loop: tools enabled, conversation persists. The dial
     (/fast //fuse //escalate //deep) swaps the active fusion mode live."""
     registry = get_registry()
-    guardian = _build_guardian(settings)
+    mesh_fn = _build_mesh(settings)
+    guardian = None if mesh_fn else _build_guardian(settings)
     system = _system_prompt()
     messages: list[dict] = [{"role": "system", "content": system}]
     mode = settings.fusion_mode if settings.fusion_mode in ("reason", "escalate") else "off"
@@ -385,6 +402,7 @@ def _agent_repl(backend: Backend, settings: Settings, renderer: Renderer) -> Non
                 auto_approve=auto,
                 stream=True,
                 guardian=guardian,
+                mesh_fn=mesh_fn,
                 on_event=observer if cockpit_on else None,
             )
             if mode in ("reason", "escalate"):
@@ -518,6 +536,7 @@ def run(
             renderer,
             interactive=False,
             auto_approve=settings.auto_approve,
+            mesh_fn=_build_mesh(settings),
         )
     except Exception as e:  # noqa: BLE001 - surface as friendly message
         branding.error(_translate_error(e))
@@ -614,10 +633,25 @@ def review(ctx: click.Context, as_diff: bool, path: str | None) -> None:
         branding.error("provide a PATH or --diff (with a diff on stdin)")
         sys.exit(3)
     _require_ready(settings)  # validates creds / exits if missing
+    glyphs = {"safe": branding.CHECK, "risky": "!", "bug": branding.CROSS}
+    mesh_ok, _ = licensing.check_feature("mesh")
+    if mesh_ok and settings.guardian_enabled:
+        # Pro: the full verification mesh, one independent reviewer per lens.
+        from deepparallel import mesh as _mesh
+
+        result = _mesh.mesh_review(settings, content)
+        for r in result["lenses"]:
+            g = glyphs.get(r["severity"], "?")
+            console.print(f"  {g} [dim]{r['label']}[/] {r['verdict'] or '(no verdict)'}")
+        verdict = result["verdict"]
+        glyph = glyphs.get(result["severity"], "?")
+        console.print(f"[bold]{glyph} {result['severity'].upper()}[/] {verdict or '(no verdict)'}")
+        sys.exit(verdict_exit_code(verdict))
+    # Free / BYOK: a single independent reviewer.
     guardian = backend_for_deployment(settings, settings.guardian_deployment)
     verdict = guardian_review(guardian, content[:8000])
     severity = verdict_severity(verdict)
-    glyph = {"safe": branding.CHECK, "risky": "!", "bug": branding.CROSS}.get(severity, "?")
+    glyph = glyphs.get(severity, "?")
     console.print(f"[bold]{glyph} {severity.upper()}[/] {verdict or '(no verdict)'}")
     sys.exit(verdict_exit_code(verdict))
 

deepparallel-0.6.0/deepparallel/mesh.py

@@ -0,0 +1,165 @@
+"""The verification mesh: N independent models review a proposed change in
+parallel, then a guardian synthesizes the final gate verdict.
+
+This generalizes the single-model ``guardian_review`` into the multi-lens panel
+the hosted /review endpoint already uses (correctness, security, edge cases,
+maintainability) and is the gate the agent loop consults before any mutating
+action. It reuses the same parallel fan-out shape as ``fusion.deep_query`` and
+emits :mod:`deepparallel.session` events so a trace view can render the panel.
+
+Pure review: it never executes anything. It returns structured verdicts and a
+decision (allow | hold | block) the caller enforces.
+"""
+
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from deepparallel import session
+from deepparallel.backend import backend_for_deployment
+
+# Four independent lenses, mirroring the hosted reviewer panel. Each model is
+# asked for exactly one verdict line so the result is cheap to parse and gate.
+_VERDICT_SHAPE = (
+    " Reply with exactly one line: 'VERDICT: safe', 'VERDICT: risky: <reason>', "
+    "or 'VERDICT: bug: <reason>'. No preamble, no markdown."
+)
+LENSES = (
+    {"key": "correctness", "label": "Correctness",
+     "sys": "Independently review this proposed change for correctness and logic errors."},
+    {"key": "security", "label": "Security",
+     "sys": "Independently review this proposed change for security vulnerabilities "
+            "(injection, auth, secrets, unsafe input)."},
+    {"key": "edge", "label": "Edge cases",
+     "sys": "Independently review this proposed change for edge cases and failure "
+            "modes the author likely missed."},
+    {"key": "maintainability", "label": "Maintainability",
+     "sys": "Independently review this proposed change for clarity and "
+            "maintainability problems."},
+)
+
+_SEVERITY_RANK = {"safe": 0, "unknown": 1, "risky": 2, "bug": 3}
+
+
+def verdict_severity(verdict: str | None) -> str:
+    """Classify a verdict string into safe | risky | bug | unknown."""
+    if not verdict:
+        return "unknown"
+    head = verdict.strip().lower()
+    for sev in ("safe", "risky", "bug"):
+        if head.startswith(sev):
+            return sev
+    return "unknown"
+
+
+def mesh_decision(severity: str) -> str:
+    """Map a severity to a gate decision: allow | hold | block."""
+    return {"bug": "block", "risky": "hold"}.get(severity, "allow")
+
+
+def _parse_verdict(msg: dict | None) -> str | None:
+    if not msg:
+        return None
+    text = (msg.get("content") or msg.get("reasoning_content") or "").strip()
+    for line in text.splitlines():
+        s = line.strip()
+        if s.upper().startswith("VERDICT:"):
+            return s.split(":", 1)[1].strip()
+    return text.splitlines()[0][:120] if text else None
+
+
+def _review_one(backend, lens: dict, content: str) -> str | None:
+    prompt = (
+        f"You are an independent code reviewer. {lens['sys']}{_VERDICT_SHAPE}\n\n"
+        f"Proposed change:\n{content}\n\nVerdict:"
+    )
+    messages = [{"role": "user", "content": prompt}]
+    for _ in range(2):  # one retry: reviewers run against a sometimes-flaky API
+        try:
+            return _parse_verdict(backend.chat(messages, [], 0.0, 256))
+        except Exception:  # noqa: BLE001 - one lens failing must not sink the gate
+            continue
+    return None
+
+
+def _reviewer_chains(settings):
+    """One backend per lens, drawn from the configured council deployments so
+    the lenses are model-diverse; falls back to the guardian deployment."""
+    deps = list(settings.parallel_deployments) or [settings.guardian_deployment]
+    return [
+        (lens, backend_for_deployment(settings, deps[i % len(deps)]))
+        for i, lens in enumerate(LENSES)
+    ]
+
+
+def _guardian_synthesis(settings, content: str, lenses: list[dict]) -> str | None:
+    blocks = "\n".join(f"{r['label']}: {r['verdict'] or '(no verdict)'}" for r in lenses)
+    prompt = (
+        "Several reviewers independently checked a proposed code change; their "
+        "verdicts are below. Issue the final gate verdict, weighing the most "
+        f"severe valid concern.{_VERDICT_SHAPE}\n\n"
+        f"Reviewer verdicts:\n{blocks}\n\nThe change:\n{content}\n\nFinal verdict:"
+    )
+    messages = [{"role": "user", "content": prompt}]
+    for _ in range(2):
+        try:
+            v = _parse_verdict(backend_for_deployment(settings, settings.guardian_deployment)
+                               .chat(messages, [], 0.0, 256))
+            if v:
+                return v
+        except Exception:  # noqa: BLE001 - degrade to the worst lens verdict
+            break
+    return _worst_verdict(lenses)
+
+
+def _worst_verdict(lenses: list[dict]) -> str | None:
+    """Fallback final verdict: the single most severe lens verdict."""
+    ranked = sorted(lenses, key=lambda r: _SEVERITY_RANK.get(r["severity"], 1), reverse=True)
+    return ranked[0]["verdict"] if ranked else None
+
+
+def mesh_review(settings, content: str, *, on_event=None, max_chars: int = 8000) -> dict:
+    """Run the parallel verification mesh over ``content``.
+
+    Returns ``{lenses, verdict, severity, decision}`` where ``lenses`` is a list
+    of ``{key, label, verdict, severity}`` and ``decision`` is allow|hold|block.
+    ``on_event`` (optional) receives :mod:`deepparallel.session` events.
+    """
+    content = (content or "")[:max_chars]
+    chains = _reviewer_chains(settings)
+    if on_event:
+        on_event(session.verify_start(content.splitlines()[0][:80] if content else "change"))
+
+    results: list[dict | None] = [None] * len(chains)
+    with ThreadPoolExecutor(max_workers=min(8, max(1, len(chains)))) as pool:
+        futures = {
+            pool.submit(_review_one, backend, lens, content): (i, lens)
+            for i, (lens, backend) in enumerate(chains)
+        }
+        for future in as_completed(futures):
+            i, lens = futures[future]
+            v = future.result()
+            sev = verdict_severity(v)
+            results[i] = {"key": lens["key"], "label": lens["label"], "verdict": v, "severity": sev}
+            if on_event:
+                on_event(session.verdict(lens["label"], v, sev))
+
+    lenses = [r for r in results if r is not None]
+    final = _guardian_synthesis(settings, content, lenses)
+    fsev = verdict_severity(final)
+    decision = mesh_decision(fsev)
+    if on_event:
+        on_event(session.gate(decision, final, fsev))
+    return {"lenses": lenses, "verdict": final, "severity": fsev, "decision": decision}
+
+
+def format_panel(result: dict) -> str:
+    """A compact multi-line rendering of a mesh result for a confirm card / CLI."""
+    glyph = {"safe": "✓", "risky": "!", "bug": "✗", "unknown": "?"}
+    lines = [
+        f"  {glyph.get(r['severity'], '?')} {r['label']}: {r['verdict'] or '(no verdict)'}"
+        for r in result.get("lenses", [])
+    ]
+    final = result.get("verdict") or "(no verdict)"
+    lines.append(f"  = Gate [{result.get('decision', 'allow').upper()}]: {final}")
+    return "\n".join(lines)

{deepparallel-0.5.7 → deepparallel-0.6.0}/deepparallel/serve.py

@@ -21,12 +21,72 @@ persona/scrub layer stay identical, so the IDE never has to change.
 from __future__ import annotations
 
 import json
+import os
 import re
 import time
+import uuid
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
 
-from deepparallel.backend import backend_for_deployment
+from deepparallel import memory, session as S
+from deepparallel.backend import backend_for_deployment, resolve_backend
 from deepparallel.config import load_system_prompt, resolve_settings
+from deepparallel.renderer import Renderer
+
+
+def _sessions_dir() -> Path:
+    d = Path(os.environ.get("DEEPPARALLEL_SESSIONS_DIR", "~/.config/deepparallel/sessions")).expanduser()
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+class SessionRenderer(Renderer):
+    """Maps the agent loop's renderer calls onto the canonical session schema,
+    so /v1/session emits the exact same events as the in-process run."""
+
+    def __init__(self, send):
+        self._send = send          # send(event_dict) -> stamps seq + writes SSE
+        self._step = 0
+        self._last_tool = "tool"
+
+    def answer(self, text: str) -> None:
+        if text:
+            self._send(S.answer(text))
+
+    def answer_stream(self, chunks) -> str:
+        full = ""
+        for c in chunks:
+            full += c
+            self._send(S.token(c))
+        return full
+
+    def tool_start(self, name: str, args_preview: str) -> None:
+        self._step += 1
+        self._last_tool = name
+        self._send(S.step(self._step, intent=name))
+        self._send(S.tool_call(name, args_preview))
+
+    def tool_result(self, ok: bool, summary: str, duration_s: float) -> None:
+        self._send(S.tool_result(self._last_tool, summary, ok))
+        self._send(S.step_done(self._step))
+
+    def confirm(self, action_title: str, detail: str) -> bool:
+        # Non-interactive: auto-approve. The mesh gate (a BUG verdict) is what
+        # actually blocks an edit, and it streams verdict/gate events of its own.
+        return True
+
+    def error(self, msg: str) -> None:
+        self._send(S.error(msg))
+
+    def reasoning(self, text: str) -> None:
+        if text:
+            self._send(S.token(text, channel="reasoning"))
+
+    def welcome(self, *args, **kwargs) -> None:
+        pass  # no banner on the wire
+
+    def attribution_footer(self, *args, **kwargs) -> None:
+        pass  # no footer on the wire
 from deepparallel.dsml import DSMLStreamFilter, strip_dsml
 from deepparallel.routing import (
     RoutingTable,
@@ -262,10 +322,14 @@ def _make_handler(
             if self.path.rstrip("/") in ("/health", "/healthz"):
                 self._json(200, {"status": "ok"})
                 return
+            if self.path.startswith("/v1/session/"):
+                self._replay_session(self.path.rstrip("/").rsplit("/", 1)[-1])
+                return
             self._json(404, {"error": {"message": "not found"}})
 
         def do_POST(self):
-            if self.path.rstrip("/") != "/v1/chat/completions":
+            path = self.path.rstrip("/")
+            if path not in ("/v1/chat/completions", "/v1/session"):
                 self._json(404, {"error": {"message": "not found"}})
                 return
             length = int(self.headers.get("Content-Length", 0))
@@ -274,6 +338,9 @@ def _make_handler(
             except json.JSONDecodeError:
                 self._json(400, {"error": {"message": "invalid JSON body"}})
                 return
+            if path == "/v1/session":
+                self._run_session(req)
+                return
 
             model = req.get("model") or "crowelm-apex"
             # Tier routing: principal tier from the bearer (paid) or its absence
@@ -357,6 +424,85 @@ def _make_handler(
                 },
             )
 
+        def _run_session(self, req):
+            """Run a full plan->act->verify agent session and stream the canonical
+            session.py event schema as SSE. The first end-to-end session over HTTP."""
+            prompt = str(req.get("prompt") or req.get("input") or "").strip()
+            if not prompt:
+                self._json(400, {"error": {"message": "missing 'prompt'"}})
+                return
+            from deepparallel import licensing, mesh as M
+            from deepparallel.agent import run_agent
+            from deepparallel.tools import get_registry
+
+            self.send_response(200)
+            self.send_header("Content-Type", "text/event-stream")
+            self.send_header("Cache-Control", "no-cache")
+            self.send_header("Connection", "keep-alive")
+            self.end_headers()
+
+            sid = "sess_" + uuid.uuid4().hex[:12]
+            transcript: list[dict] = []
+
+            def sink(ev):
+                transcript.append(ev)
+                self.wfile.write(S.to_sse(ev).encode())
+                self.wfile.flush()
+
+            stream = S.EventStream(sink)  # stamps seq, swallows write errors if client drops
+            send = stream.emit
+
+            try:
+                send(S.start(sid, goal=prompt))
+                sys_prompt = load_system_prompt() + memory.index_block()
+                messages = [
+                    {"role": "system", "content": sys_prompt},
+                    {"role": "user", "content": prompt},
+                ]
+                backend = resolve_backend(settings)
+                registry = get_registry()
+                mesh_fn = None
+                if getattr(settings, "guardian_enabled", False) and licensing.check_feature("mesh")[0]:
+                    mesh_fn = lambda content: M.mesh_review(settings, content, on_event=send)
+                renderer = SessionRenderer(send)
+                run_agent(
+                    backend, registry, messages, settings, renderer,
+                    interactive=False, auto_approve=True, stream=True,
+                    max_steps=req.get("max_steps"), mesh_fn=mesh_fn,
+                )
+                send(S.done())
+            except Exception as e:  # noqa: BLE001 - report, then close cleanly
+                try:
+                    send(S.error(f"{type(e).__name__}: {e}"))
+                    send(S.done("error"))
+                except Exception:
+                    pass
+            try:
+                (_sessions_dir() / (sid + ".jsonl")).write_text(
+                    "\n".join(json.dumps(e) for e in transcript), encoding="utf-8"
+                )
+            except Exception:
+                pass
+
+        def _replay_session(self, sid):
+            """Replay a stored session transcript as SSE (resumption / sharing)."""
+            safe = re.sub(r"[^a-zA-Z0-9_]", "", sid or "")
+            path = _sessions_dir() / (safe + ".jsonl")
+            if not safe or not path.is_file():
+                self._json(404, {"error": {"message": "session not found"}})
+                return
+            self.send_response(200)
+            self.send_header("Content-Type", "text/event-stream")
+            self.send_header("Cache-Control", "no-cache")
+            self.end_headers()
+            try:
+                for line in path.read_text(encoding="utf-8").splitlines():
+                    if line.strip():
+                        self.wfile.write(("data: " + line + "\n\n").encode())
+                self.wfile.flush()
+            except (BrokenPipeError, OSError):
+                pass
+
     return Handler
 
 

deepparallel-0.6.0/deepparallel/session.py

@@ -0,0 +1,132 @@
+"""Canonical DeepParallel agent-session event schema.
+
+One event vocabulary shared by every surface (CLI, hosted API, desktop, web).
+It generalizes the hosted /review SSE stream (start / token / verdict / done)
+into a full agent-session stream so a single trace view can render a run on any
+surface: the council plan, each tool step, and the verification-mesh verdicts.
+
+Events are plain dicts with a ``type`` discriminator and a monotonic ``seq``
+(assigned by an :class:`EventStream`). ``to_sse`` serializes one event to a
+Server-Sent-Events frame so the same producer feeds an HTTP stream or a local
+renderer.
+"""
+
+from __future__ import annotations
+
+import json
+from itertools import count
+from typing import Any, Callable, Iterable
+
+# --- event factories ---------------------------------------------------------
+# Each returns a bare dict; an EventStream stamps `seq`. Keep payloads small and
+# JSON-serializable so they cross the wire unchanged.
+
+
+def start(session_id: str | None = None, goal: str | None = None) -> dict:
+    return _e("start", session_id=session_id, goal=goal)
+
+
+def plan(text: str, agreement: dict | None = None) -> dict:
+    """The council's synthesized plan (and optional cross-model agreement)."""
+    return _e("plan", text=text, agreement=agreement)
+
+
+def chain(name: str, content: str) -> dict:
+    """One council chain's raw answer (a single parallel reasoning stream)."""
+    return _e("chain", name=name, content=content)
+
+
+def step(index: int, intent: str | None = None) -> dict:
+    return _e("step", index=index, intent=intent)
+
+
+def token(text: str, channel: str = "content") -> dict:
+    return _e("token", text=text, channel=channel)
+
+
+def tool_call(name: str, preview: str) -> dict:
+    return _e("tool_call", name=name, preview=preview)
+
+
+def tool_result(name: str, summary: str, ok: bool) -> dict:
+    return _e("tool_result", name=name, summary=summary, ok=ok)
+
+
+def verify_start(action: str) -> dict:
+    """The verification mesh has begun reviewing a proposed action."""
+    return _e("verify_start", action=action)
+
+
+def verdict(lens: str, verdict_text: str | None, severity: str) -> dict:
+    """One independent reviewer's verdict for a single lens."""
+    return _e("verdict", lens=lens, verdict=verdict_text, severity=severity)
+
+
+def gate(decision: str, verdict_text: str | None, severity: str) -> dict:
+    """The guardian's final gate: decision is allow | hold | block."""
+    return _e("gate", decision=decision, verdict=verdict_text, severity=severity)
+
+
+def step_done(index: int) -> dict:
+    return _e("step_done", index=index)
+
+
+def answer(text: str) -> dict:
+    return _e("answer", text=text)
+
+
+def error(message: str) -> dict:
+    return _e("error", message=message)
+
+
+def done(status: str = "ok") -> dict:
+    return _e("done", status=status)
+
+
+def _e(type_: str, **fields: Any) -> dict:
+    """Build an event, dropping None-valued fields to keep frames compact."""
+    ev = {"type": type_}
+    ev.update({k: v for k, v in fields.items() if v is not None})
+    return ev
+
+
+# --- serialization / streaming ----------------------------------------------
+
+EVENT_TYPES = (
+    "start", "plan", "chain", "step", "token", "tool_call", "tool_result",
+    "verify_start", "verdict", "gate", "step_done", "answer", "error", "done",
+)
+
+
+def to_sse(event: dict) -> str:
+    """Serialize one event to a Server-Sent-Events ``data:`` frame."""
+    return "data: " + json.dumps(event, ensure_ascii=False) + "\n\n"
+
+
+class EventStream:
+    """Stamps a monotonic ``seq`` on each event and forwards it to a sink.
+
+    The sink is any ``callable(dict) -> None`` (write to an HTTP response, push
+    to a renderer, append to a JSONL trace). Use as ``emit(session.plan(...))``.
+    """
+
+    def __init__(self, sink: Callable[[dict], None] | None = None):
+        self._sink = sink
+        self._seq = count()
+
+    def emit(self, event: dict) -> dict:
+        event = {**event, "seq": next(self._seq)}
+        if self._sink is not None:
+            try:
+                self._sink(event)
+            except Exception:  # noqa: BLE001 - observation must never break a run
+                pass
+        return event
+
+    __call__ = emit
+
+
+def sse_stream(events: Iterable[dict]) -> Iterable[str]:
+    """Adapt an iterable of events into SSE frames."""
+    for ev in events:
+        yield to_sse(ev)

{deepparallel-0.5.7 → deepparallel-0.6.0}/deepparallel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.5.7
+Version: 0.6.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.5.7 → deepparallel-0.6.0}/deepparallel.egg-info/SOURCES.txt

@@ -15,11 +15,13 @@ deepparallel/dsml.py
 deepparallel/fusion.py
 deepparallel/licensing.py
 deepparallel/memory.py
+deepparallel/mesh.py
 deepparallel/registry.json
 deepparallel/renderer.py
 deepparallel/routing.example.json
 deepparallel/routing.py
 deepparallel/serve.py
+deepparallel/session.py
 deepparallel/supply_chain.py
 deepparallel/system_prompt.txt
 deepparallel/userinput.py
@@ -71,6 +73,7 @@ tests/test_research.py
 tests/test_research_provider.py
 tests/test_routing.py
 tests/test_serve.py
+tests/test_serve_session.py
 tests/test_spinner_color.py
 tests/test_supply_chain.py
 tests/test_tool_registry.py

{deepparallel-0.5.7 → deepparallel-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "deepparallel"
-version = "0.5.7"
+version = "0.6.0"
 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" }

{deepparallel-0.5.7 → deepparallel-0.6.0}/tests/test_cli.py

@@ -138,6 +138,9 @@ class _GuardianStub:
 
 def test_review_file_safe_exits_zero(monkeypatch, tmp_path):
     _set_azure_env(monkeypatch)
+    # Test the single-guardian exit-code contract deterministically, regardless of
+    # any ambient license (the multi-model mesh path has its own coverage).
+    monkeypatch.setattr(licensing, "check_feature", lambda feature, *a, **k: (feature != "mesh", ""))
     f = tmp_path / "ok.py"
     f.write_text("def add(a, b):\n    return a + b\n")
     monkeypatch.setattr(climod, "resolve_backend", lambda s: _GuardianStub("safe"))
@@ -149,6 +152,7 @@ def test_review_file_safe_exits_zero(monkeypatch, tmp_path):
 
 def test_review_bug_exits_two(monkeypatch, tmp_path):
     _set_azure_env(monkeypatch)
+    monkeypatch.setattr(licensing, "check_feature", lambda feature, *a, **k: (feature != "mesh", ""))
     f = tmp_path / "bad.py"
     f.write_text("def f(u):\n    return u.balance\n")
     monkeypatch.setattr(climod, "resolve_backend", lambda s: _GuardianStub("bug: null deref"))
@@ -162,6 +166,7 @@ def test_review_bug_exits_two(monkeypatch, tmp_path):
 
 def test_review_diff_from_stdin(monkeypatch):
     _set_azure_env(monkeypatch)
+    monkeypatch.setattr(licensing, "check_feature", lambda feature, *a, **k: (feature != "mesh", ""))
     monkeypatch.setattr(climod, "resolve_backend", lambda s: _GuardianStub("risky: no test"))
     monkeypatch.setattr(
         climod, "backend_for_deployment", lambda s, d: _GuardianStub("risky: no test")

{deepparallel-0.5.7 → deepparallel-0.6.0}/tests/test_serve.py

@@ -49,29 +49,34 @@ def _ids(payload):
     return [entry["id"] for entry in payload["data"]]
 
 
-def test_models_payload_lists_only_configured_public_aliases():
+# The gateway lists the full public CroweLM catalog (a fixed alias set),
+# independent of which upstream deployments the local settings configured. The
+# security-critical invariant: no raw upstream deployment name ever leaks.
+_RAW_MARKERS = ("DeepSeek", "Kimi", "grok", "gpt-", "Llama", "Mistral", "Granite", "Qwen", "Cohere", "command-")
+
+
+def test_models_payload_lists_public_aliases_no_raw_leak():
     ids = _ids(_models_payload(_settings()))
 
-    assert ids == ["crowelm-apex", "crowelm-reason", "crowelm-flash"]
-    assert "crowelm-quasar" not in ids
-    assert "DeepSeek-V4-Pro" not in ids
+    assert {"crowelm-apex", "crowelm-reason", "crowelm-flash"} <= set(ids)
+    assert all(i.startswith("crowelm-") for i in ids)
+    assert not any(marker in i for i in ids for marker in _RAW_MARKERS)
 
 
-def test_models_payload_includes_additional_configured_aliases():
-    settings = _settings(
-        parallel_deployments=("DeepSeek-V4-Pro", "Kimi-K2-6"),
-        judge_deployment="grok-4-3",
+def test_models_payload_is_stable_across_configured_deployments():
+    base = _ids(_models_payload(_settings()))
+    other = _ids(
+        _models_payload(
+            _settings(parallel_deployments=("DeepSeek-V4-Pro", "Kimi-K2-6"), judge_deployment="grok-4-3")
+        )
     )
 
-    ids = _ids(_models_payload(settings))
-
-    assert "crowelm-apex" in ids
-    assert "crowelm-eclipse" in ids
-    assert "crowelm-quasar" in ids
-    assert "crowelm-titan" not in ids
+    # the public catalog does not depend on local deployment config
+    assert base == other
+    assert "crowelm-apex" in base
 
 
-def test_models_endpoint_returns_filtered_model_list():
+def test_models_endpoint_returns_public_catalog():
     settings = _settings(
         parallel_deployments=("DeepSeek-V4-Pro", "Kimi-K2-6"),
         reasoner_deployment="",
@@ -91,7 +96,8 @@ def test_models_endpoint_returns_filtered_model_list():
     handler_cls.do_GET(handler)
 
     assert captured["code"] == 200
-    assert _ids(captured["payload"]) == ["crowelm-apex", "crowelm-eclipse"]
+    ids = _ids(captured["payload"])
+    assert "crowelm-apex" in ids and all(i.startswith("crowelm-") for i in ids)
 
 
 def test_chat_accepts_public_alias_and_raw_deployment_for_compatibility():

deepparallel-0.6.0/tests/test_serve_session.py

@@ -0,0 +1,40 @@
+"""The /v1/session endpoint maps the agent loop onto the canonical session
+schema. These tests are deterministic (no model calls): they exercise the
+renderer-to-event mapping and the request validation directly."""
+
+from deepparallel import serve, session
+
+
+def test_session_renderer_emits_canonical_schema():
+    events = []
+    r = serve.SessionRenderer(events.append)
+
+    r.tool_start("write_file", "calc.py")
+    r.tool_result(True, "wrote 42 bytes", 0.12)
+    full = r.answer_stream(iter(["hel", "lo"]))
+    r.answer("final")
+
+    assert full == "hello"
+    types = [e["type"] for e in events]
+    # an act step: tool_call -> tool_result, bracketed by step / step_done
+    assert types.index("step") < types.index("tool_call") < types.index("tool_result")
+    assert "step_done" in types
+    # streamed tokens, one event per chunk
+    assert types.count("token") == 2
+    # the tool_result carries the tool name and ok flag
+    tr = next(e for e in events if e["type"] == "tool_result")
+    assert tr["name"] == "write_file" and tr["ok"] is True
+
+
+def test_session_renderer_confirm_auto_approves():
+    # non-interactive: confirm never blocks (the mesh gate does the blocking)
+    r = serve.SessionRenderer(lambda e: None)
+    assert r.confirm("write_file", "diff") is True
+
+
+def test_session_event_factories_roundtrip_sse():
+    frame = session.to_sse(session.gate("block", "bug: sqli", "bug"))
+    assert frame.startswith("data: ") and frame.endswith("\n\n")
+    import json
+    payload = json.loads(frame[len("data: "):].strip())
+    assert payload["type"] == "gate" and payload["decision"] == "block" and payload["severity"] == "bug"