deepparallel 0.2.0__tar.gz → 0.3.1__tar.gz

{deepparallel-0.2.0 → deepparallel-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.2.0
+Version: 0.3.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
@@ -22,10 +22,22 @@ Requires-Dist: ruff>=0.6.0; extra == "dev"
 
 # DeepParallel
 
-A focused command-line interface for the DeepParallel model, served via Crowe Logic.
+A multi-model agentic coding CLI with cross-model Guardian review. Many models
+check the work; you ship with a second opinion. Served via Crowe Logic.
 
 ## Install
 
+    uv tool install deepparallel        # recommended
+    # or
+    pipx install deepparallel --python python3.13
+
+Then run `deepparallel` (or the short alias `dp`).
+
+Note: on systems with a broken Homebrew Python 3.14, bare `pipx install` may
+fail to find a usable interpreter - use `uv tool install` or pin `--python`.
+
+### From source
+
     uv venv
     uv pip install -p .venv -e .
 
@@ -53,6 +65,18 @@ Set the backend env vars (a `.env` file in the working directory is loaded autom
     deepparallel doctor          # diagnose config + reachability
     deepparallel run --no-tools "..."   # plain chat, no tools
     deepparallel run --yes "..."        # auto-approve tool actions
+    deepparallel review <file|--diff>   # cross-model review as a CI gate (Pro)
+    deepparallel audit <file>           # supply-chain gate: catch hallucinated deps (Pro)
+
+## Supply-chain gate
+
+LLMs invent package names that don't exist — and attackers register those names
+("slopsquatting"). `deepparallel audit <file>` extracts the dependencies a file
+introduces (imports, requirements.txt, package.json) and checks each against the
+real registry (PyPI / npm), flagging any the registry has never seen. Exit 0
+clean, 2 if a likely-hallucinated package is found — so it gates a commit or PR.
+The Guardian also runs this automatically on every edit: a hallucinated import
+forces a confirmation even under `--yes`.
 
 ## Fusion (stacking models for stronger output)
 
@@ -107,7 +131,7 @@ timeboxed local subprocess.
 | `DEEPPARALLEL_API_VERSION` | Azure API version | `2024-08-01-preview` |
 | `FOUNDRY_BASE_URL` / `FOUNDRY_API_KEY` | control-plane transport | (required for foundry) |
 | `DEEPPARALLEL_TEMPERATURE` | default sampling temperature | `0.4` |
-| `DEEPPARALLEL_MAX_TOKENS` | response cap | `2048` |
+| `DEEPPARALLEL_MAX_TOKENS` | response cap (large enough to write whole files) | `8192` |
 | `DEEPPARALLEL_THINK` | surface reasoning stream | `0` (answer-only) |
 | `DEEPPARALLEL_TOOLS` | enable agent tools | `1` (on) |
 | `DEEPPARALLEL_AUTO_APPROVE` | auto-approve mutating tools | `0` (off) |

{deepparallel-0.2.0 → deepparallel-0.3.1}/README.md

@@ -1,9 +1,21 @@
 # DeepParallel
 
-A focused command-line interface for the DeepParallel model, served via Crowe Logic.
+A multi-model agentic coding CLI with cross-model Guardian review. Many models
+check the work; you ship with a second opinion. Served via Crowe Logic.
 
 ## Install
 
+    uv tool install deepparallel        # recommended
+    # or
+    pipx install deepparallel --python python3.13
+
+Then run `deepparallel` (or the short alias `dp`).
+
+Note: on systems with a broken Homebrew Python 3.14, bare `pipx install` may
+fail to find a usable interpreter - use `uv tool install` or pin `--python`.
+
+### From source
+
     uv venv
     uv pip install -p .venv -e .
 
@@ -31,6 +43,18 @@ Set the backend env vars (a `.env` file in the working directory is loaded autom
     deepparallel doctor          # diagnose config + reachability
     deepparallel run --no-tools "..."   # plain chat, no tools
     deepparallel run --yes "..."        # auto-approve tool actions
+    deepparallel review <file|--diff>   # cross-model review as a CI gate (Pro)
+    deepparallel audit <file>           # supply-chain gate: catch hallucinated deps (Pro)
+
+## Supply-chain gate
+
+LLMs invent package names that don't exist — and attackers register those names
+("slopsquatting"). `deepparallel audit <file>` extracts the dependencies a file
+introduces (imports, requirements.txt, package.json) and checks each against the
+real registry (PyPI / npm), flagging any the registry has never seen. Exit 0
+clean, 2 if a likely-hallucinated package is found — so it gates a commit or PR.
+The Guardian also runs this automatically on every edit: a hallucinated import
+forces a confirmation even under `--yes`.
 
 ## Fusion (stacking models for stronger output)
 
@@ -85,7 +109,7 @@ timeboxed local subprocess.
 | `DEEPPARALLEL_API_VERSION` | Azure API version | `2024-08-01-preview` |
 | `FOUNDRY_BASE_URL` / `FOUNDRY_API_KEY` | control-plane transport | (required for foundry) |
 | `DEEPPARALLEL_TEMPERATURE` | default sampling temperature | `0.4` |
-| `DEEPPARALLEL_MAX_TOKENS` | response cap | `2048` |
+| `DEEPPARALLEL_MAX_TOKENS` | response cap (large enough to write whole files) | `8192` |
 | `DEEPPARALLEL_THINK` | surface reasoning stream | `0` (answer-only) |
 | `DEEPPARALLEL_TOOLS` | enable agent tools | `1` (on) |
 | `DEEPPARALLEL_AUTO_APPROVE` | auto-approve mutating tools | `0` (off) |

{deepparallel-0.2.0 → deepparallel-0.3.1}/deepparallel/__init__.py

@@ -1,3 +1,3 @@
 """DeepParallel CLI package."""
 
-__version__ = "0.2.0"
+__version__ = "0.3.1"

{deepparallel-0.2.0 → deepparallel-0.3.1}/deepparallel/agent.py

@@ -18,6 +18,17 @@ _MAX_TOOL_RESULT = 50_000
 _GATED_PATH_TOOLS = ("write_file", "edit_file")
 _EDIT_TOOLS = ("write_file", "edit_file", "ast_replace_symbol")
 
+# Shown back to the model when a tool call arrives on a response that the API
+# cut off at the token limit (finish_reason=length). The call's arguments, and
+# any file body inside them, are incomplete, so we never apply it.
+_TRUNCATION_HINT = (
+    "Your previous output was cut off by the response token limit "
+    "(finish_reason=length), so this tool call is incomplete and was NOT applied. "
+    "Write large files in smaller pieces: create the file with write_file using "
+    "the first portion, then append the rest with edit_file (or split it across "
+    "files). Do not emit an entire large file in one tool call."
+)
+
 
 def _parse_args(raw: str) -> dict:
     if not raw:
@@ -191,9 +202,30 @@ def _guardian_verdict(guardian, name: str, args: dict) -> str | None:
     return guardian_review(guardian, _guardian_review_content(name, args))
 
 
+def _supply_chain_note(name: str, args: dict) -> str | None:
+    """Best-effort: flag hallucinated/slopsquatted deps an edit introduces."""
+    content = args.get("new_source") or args.get("new_string") or args.get("content") or ""
+    path = args.get("file_path", "")
+    if not content or not path:
+        return None
+    try:
+        from deepparallel import supply_chain
+
+        result = supply_chain.audit(content, path)
+    except Exception:  # noqa: BLE001 - supply-chain check is best-effort
+        return None
+    if result["hallucinated"]:
+        return "not found on the registry (possible hallucination): " + ", ".join(
+            result["hallucinated"]
+        )
+    return None
+
+
 def _approved(name, args, interactive, auto_approve, renderer, guardian=None) -> bool:
     forced = name in _GATED_PATH_TOOLS and _outside_cwd(args)
-    if auto_approve and not forced:
+    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:
         return True
     if not interactive:
         return False
@@ -202,6 +234,8 @@ def _approved(name, args, interactive, auto_approve, renderer, guardian=None) ->
         verdict = _guardian_verdict(guardian, name, args)
         if verdict:
             detail = f"{detail}\n\nGuardian: {verdict}"
+    if sc_note:
+        detail = f"{detail}\n\nSupply-chain: {sc_note}"
     return renderer.confirm(title, detail)
 
 
@@ -250,6 +284,7 @@ def run_agent(
             msg = backend.chat(messages, schemas, settings.temperature, settings.max_tokens)
             streamed = False
         tool_calls = msg.get("tool_calls")
+        truncated = bool(msg.get("_truncated"))
         if not tool_calls:
             content = msg.get("content") or ""
             messages.append({"role": "assistant", "content": content})
@@ -260,13 +295,18 @@ def run_agent(
         messages.append(
             {"role": "assistant", "content": msg.get("content"), "tool_calls": tool_calls}
         )
-        for tc in tool_calls:
+        # A length-truncated response cuts off the final tool call mid-arguments,
+        # so its file body is incomplete. Refuse it and tell the model to chunk.
+        last_idx = len(tool_calls) - 1
+        for i, tc in enumerate(tool_calls):
             name = tc["function"]["name"]
             args = _parse_args(tc["function"].get("arguments", ""))
             meta = registry.get(name)
             renderer.tool_start(name, _preview(args))
             start = time.monotonic()
-            if meta is None:
+            if truncated and i == last_idx:
+                result = json.dumps({"error": _TRUNCATION_HINT})
+            elif meta is None:
                 result = json.dumps({"error": f"unknown tool: {name}"})
             elif "__parse_error__" in args:
                 result = json.dumps({"error": "invalid JSON arguments"})

{deepparallel-0.2.0 → deepparallel-0.3.1}/deepparallel/backend.py

@@ -56,6 +56,7 @@ def parse_sse_stream(lines: Iterator[str]):
     """
     content_parts: list[str] = []
     acc: dict[int, dict] = {}
+    finish_reason: str | None = None
     for raw in lines:
         line = raw.strip()
         if not line or not line.startswith("data:"):
@@ -70,6 +71,8 @@ def parse_sse_stream(lines: Iterator[str]):
         choices = obj.get("choices") or []
         if not choices:
             continue
+        if choices[0].get("finish_reason"):
+            finish_reason = choices[0]["finish_reason"]
         delta = choices[0].get("delta") or {}
         reasoning = delta.get("reasoning_content")
         if reasoning:
@@ -95,6 +98,7 @@ def parse_sse_stream(lines: Iterator[str]):
         "role": "assistant",
         "content": "".join(content_parts) or None,
         "tool_calls": tool_calls,
+        "_truncated": finish_reason == "length",
     }
 
 
@@ -103,6 +107,18 @@ def _host(url: str) -> str:
     return f"{p.scheme}://{p.netloc}" if p.netloc else url
 
 
+def _message_from_choice(choice: dict) -> dict:
+    """Extract the assistant message and flag output-token truncation.
+
+    `finish_reason == "length"` means the model was cut off mid-output. For a
+    tool call that carries file content, that means the arguments (and any file
+    body inside them) are incomplete and must not be applied blindly.
+    """
+    msg = dict(choice.get("message") or {})
+    msg["_truncated"] = choice.get("finish_reason") == "length"
+    return msg
+
+
 class Backend(Protocol):
     label: str
 
@@ -172,7 +188,7 @@ class AzureBackend:
         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 r.json()["choices"][0]["message"]
+        return _message_from_choice(r.json()["choices"][0])
 
     def stream_chat_tools(self, messages, tools, temperature, max_tokens):
         payload = {
@@ -246,7 +262,7 @@ class FoundryBackend:
         }
         r = httpx.post(self._url, json=payload, headers=headers, timeout=_STREAM_TIMEOUT)
         r.raise_for_status()
-        return r.json()["choices"][0]["message"]
+        return _message_from_choice(r.json()["choices"][0])
 
     def stream_chat_tools(self, messages, tools, temperature, max_tokens):
         payload = {

{deepparallel-0.2.0 → deepparallel-0.3.1}/deepparallel/cli.py

@@ -43,7 +43,7 @@ from deepparallel.config import (
     missing_required,
     resolve_settings,
 )
-from deepparallel import licensing
+from deepparallel import licensing, supply_chain
 from deepparallel.fusion import (
     EscalationBackend,
     ReasonAnswerBackend,
@@ -504,6 +504,48 @@ def review(ctx: click.Context, as_diff: bool, path: str | None) -> None:
     sys.exit(verdict_exit_code(verdict))
 
 
+@main.command()
+@click.argument("path", required=True)
+@click.pass_context
+def audit(ctx: click.Context, path: str) -> None:
+    """Supply-chain gate: check a file's dependencies against the real registry.
+
+    Flags hallucinated / slopsquatted packages (names PyPI or npm has never
+    seen) in source files and manifests. Exit code: 0 clean, 2 if a likely
+    hallucinated dependency is found - so it can gate a commit or PR. Paid (Pro+).
+    """
+    ok, msg = licensing.check_feature("audit")
+    if not ok:
+        branding.error(msg)
+        sys.exit(3)
+    try:
+        content = Path(path).expanduser().read_text(encoding="utf-8")
+    except OSError as e:
+        branding.error(f"cannot read {path}: {e}")
+        sys.exit(3)
+    result = supply_chain.audit(content, path)
+    findings = result["findings"]
+    if not findings:
+        console.print(f"[{branding.DIM}]no external dependencies found in {path}[/]")
+        sys.exit(0)
+    for f in findings:
+        glyph = {"ok": branding.CHECK, "missing": branding.CROSS}.get(f["status"], "?")
+        color = {"ok": branding.GREEN_HEX, "missing": branding.RED_HEX}.get(
+            f["status"], branding.DIM
+        )
+        console.print(
+            f"  [{color}]{glyph}[/] {f['name']} [{branding.DIM}]({f['ecosystem']}) · {f['status']}[/]"
+        )
+    if result["hallucinated"]:
+        console.print(
+            f"[bold {branding.RED_HEX}]{branding.CROSS} {len(result['hallucinated'])} "
+            f"possibly hallucinated:[/] {', '.join(result['hallucinated'])}"
+        )
+        sys.exit(2)
+    console.print(f"[{branding.GREEN_HEX}]{branding.CHECK} all dependencies verified[/]")
+    sys.exit(0)
+
+
 @main.command(name="tools")
 def tools_cmd() -> None:
     """List the agent tools available to DeepParallel."""

{deepparallel-0.2.0 → deepparallel-0.3.1}/deepparallel/config.py

@@ -101,7 +101,7 @@ def resolve_settings() -> Settings:
         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),
+        max_tokens=_int_env("DEEPPARALLEL_MAX_TOKENS", 8192),
         show_thinking=_bool_env("DEEPPARALLEL_THINK", False),
         tools_enabled=_bool_env("DEEPPARALLEL_TOOLS", True),
         auto_approve=_bool_env("DEEPPARALLEL_AUTO_APPROVE", False),

{deepparallel-0.2.0 → deepparallel-0.3.1}/deepparallel/licensing.py

@@ -70,6 +70,30 @@ def verify_token(token: str, pubkey_b64: str | None = None) -> dict | None:
     return payload
 
 
+def sign_token(payload: dict, private_key_b64: str) -> str:
+    """Sign a license payload into a `body.signature` token (issuer-side).
+
+    Requires the private issuance key; verify_token() checks it with the public
+    key. Used by the license-issuer (Stripe webhook) and the admin CLI.
+    """
+    from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+
+    priv = Ed25519PrivateKey.from_private_bytes(_b64url_decode_std(private_key_b64))
+    body = base64.urlsafe_b64encode(json.dumps(payload).encode()).decode().rstrip("=")
+    sig = base64.urlsafe_b64encode(priv.sign(body.encode())).decode().rstrip("=")
+    return f"{body}.{sig}"
+
+
+def _b64url_decode_std(s: str) -> bytes:
+    """Decode standard OR url-safe base64 (keys are emitted as standard b64)."""
+    s = s.strip()
+    pad = "=" * (-len(s) % 4)
+    try:
+        return base64.b64decode(s + pad)
+    except Exception:  # noqa: BLE001
+        return base64.urlsafe_b64decode(s + pad)
+
+
 def _license_file_token() -> str | None:
     path = Path(
         os.environ.get("DEEPPARALLEL_LICENSE_FILE", "~/.config/deepparallel/license")

deepparallel-0.3.1/deepparallel/supply_chain.py

@@ -0,0 +1,130 @@
+"""Supply-chain gate: catch hallucinated / slopsquatted dependencies.
+
+LLMs invent package names that don't exist (and attackers register those names).
+This extracts the dependencies a change introduces and checks each against the
+real registry (PyPI / npm). A name the registry has never seen is a likely
+hallucination - blocking it before it lands is the Guardian's supply-chain job.
+
+Network is best-effort: a lookup failure yields "unknown", never a false
+"missing", so an offline run never blocks a legitimate package.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import sys
+
+import httpx
+
+_TIMEOUT = 6.0
+_STDLIB = set(getattr(sys, "stdlib_module_names", set())) | {
+    "__future__",
+    "typing_extensions",
+}
+# Common import-name -> PyPI distribution-name mismatches, so legitimate
+# imports are not flagged as hallucinations.
+_PYPI_ALIASES = {
+    "yaml": "pyyaml",
+    "cv2": "opencv-python",
+    "PIL": "pillow",
+    "bs4": "beautifulsoup4",
+    "sklearn": "scikit-learn",
+    "dotenv": "python-dotenv",
+    "jwt": "pyjwt",
+    "dateutil": "python-dateutil",
+    "git": "gitpython",
+    "serial": "pyserial",
+    "OpenSSL": "pyopenssl",
+    "Crypto": "pycryptodome",
+    "google": "google-api-python-client",
+}
+
+_IMPORT_RE = re.compile(r"^\s*(?:import\s+([a-zA-Z0-9_.]+)|from\s+([a-zA-Z0-9_.]+)\s+import)", re.M)
+_REQ_RE = re.compile(r"^\s*([A-Za-z0-9][A-Za-z0-9._-]*)")
+
+
+def extract_dependencies(content: str, filename: str) -> list[dict]:
+    """Return [{name, ecosystem, raw}] introduced by this content."""
+    fn = filename.rsplit("/", 1)[-1].lower()
+    if fn == "package.json":
+        return _from_package_json(content)
+    if fn in ("requirements.txt",) or fn.startswith("requirements"):
+        return _from_requirements(content)
+    if fn.endswith(".py"):
+        return _from_python(content)
+    return []
+
+
+def _from_python(content: str) -> list[dict]:
+    out, seen = [], set()
+    for imp, frm in _IMPORT_RE.findall(content):
+        mod = (imp or frm).split(".")[0]
+        if not mod or mod.startswith("_") or mod in _STDLIB or mod in seen:
+            continue
+        seen.add(mod)
+        dist = _PYPI_ALIASES.get(mod, mod)
+        out.append({"name": dist, "ecosystem": "pypi", "raw": mod})
+    return out
+
+
+def _from_requirements(content: str) -> list[dict]:
+    out, seen = [], set()
+    for line in content.splitlines():
+        s = line.strip()
+        if not s or s.startswith(("#", "-", "git+", "http")):
+            continue
+        m = _REQ_RE.match(s)
+        if not m:
+            continue
+        name = m.group(1).lower()
+        if name not in seen:
+            seen.add(name)
+            out.append({"name": name, "ecosystem": "pypi", "raw": s})
+    return out
+
+
+def _from_package_json(content: str) -> list[dict]:
+    try:
+        data = json.loads(content)
+    except (ValueError, json.JSONDecodeError):
+        return []
+    out, seen = [], set()
+    for key in ("dependencies", "devDependencies", "peerDependencies"):
+        for name in data.get(key) or {}:
+            if name not in seen:
+                seen.add(name)
+                out.append({"name": name, "ecosystem": "npm", "raw": name})
+    return out
+
+
+def check_exists(name: str, ecosystem: str) -> bool | None:
+    """True if the package exists in its registry, False if not, None on failure."""
+    if ecosystem == "pypi":
+        url = f"https://pypi.org/pypi/{name}/json"
+    elif ecosystem == "npm":
+        url = f"https://registry.npmjs.org/{name}"
+    else:
+        return None
+    try:
+        r = httpx.get(url, timeout=_TIMEOUT, follow_redirects=True)
+    except Exception:  # noqa: BLE001 - network failure is "unknown", not "missing"
+        return None
+    if r.status_code == 200:
+        return True
+    if r.status_code == 404:
+        return False
+    return None
+
+
+def audit(content: str, filename: str) -> dict:
+    """Audit a change's dependencies. Returns findings + the hallucinated list."""
+    findings = []
+    hallucinated = []
+    for dep in extract_dependencies(content, filename):
+        exists = check_exists(dep["name"], dep["ecosystem"])
+        status = "ok" if exists is True else "missing" if exists is False else "unknown"
+        findings.append({"name": dep["name"], "ecosystem": dep["ecosystem"], "status": status})
+        if status == "missing":
+            hallucinated.append(dep["name"])
+    return {"findings": findings, "hallucinated": hallucinated}

{deepparallel-0.2.0 → deepparallel-0.3.1}/deepparallel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.2.0
+Version: 0.3.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
@@ -22,10 +22,22 @@ Requires-Dist: ruff>=0.6.0; extra == "dev"
 
 # DeepParallel
 
-A focused command-line interface for the DeepParallel model, served via Crowe Logic.
+A multi-model agentic coding CLI with cross-model Guardian review. Many models
+check the work; you ship with a second opinion. Served via Crowe Logic.
 
 ## Install
 
+    uv tool install deepparallel        # recommended
+    # or
+    pipx install deepparallel --python python3.13
+
+Then run `deepparallel` (or the short alias `dp`).
+
+Note: on systems with a broken Homebrew Python 3.14, bare `pipx install` may
+fail to find a usable interpreter - use `uv tool install` or pin `--python`.
+
+### From source
+
     uv venv
     uv pip install -p .venv -e .
 
@@ -53,6 +65,18 @@ Set the backend env vars (a `.env` file in the working directory is loaded autom
     deepparallel doctor          # diagnose config + reachability
     deepparallel run --no-tools "..."   # plain chat, no tools
     deepparallel run --yes "..."        # auto-approve tool actions
+    deepparallel review <file|--diff>   # cross-model review as a CI gate (Pro)
+    deepparallel audit <file>           # supply-chain gate: catch hallucinated deps (Pro)
+
+## Supply-chain gate
+
+LLMs invent package names that don't exist — and attackers register those names
+("slopsquatting"). `deepparallel audit <file>` extracts the dependencies a file
+introduces (imports, requirements.txt, package.json) and checks each against the
+real registry (PyPI / npm), flagging any the registry has never seen. Exit 0
+clean, 2 if a likely-hallucinated package is found — so it gates a commit or PR.
+The Guardian also runs this automatically on every edit: a hallucinated import
+forces a confirmation even under `--yes`.
 
 ## Fusion (stacking models for stronger output)
 
@@ -107,7 +131,7 @@ timeboxed local subprocess.
 | `DEEPPARALLEL_API_VERSION` | Azure API version | `2024-08-01-preview` |
 | `FOUNDRY_BASE_URL` / `FOUNDRY_API_KEY` | control-plane transport | (required for foundry) |
 | `DEEPPARALLEL_TEMPERATURE` | default sampling temperature | `0.4` |
-| `DEEPPARALLEL_MAX_TOKENS` | response cap | `2048` |
+| `DEEPPARALLEL_MAX_TOKENS` | response cap (large enough to write whole files) | `8192` |
 | `DEEPPARALLEL_THINK` | surface reasoning stream | `0` (answer-only) |
 | `DEEPPARALLEL_TOOLS` | enable agent tools | `1` (on) |
 | `DEEPPARALLEL_AUTO_APPROVE` | auto-approve mutating tools | `0` (off) |

{deepparallel-0.2.0 → deepparallel-0.3.1}/deepparallel.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ deepparallel/fusion.py
 deepparallel/licensing.py
 deepparallel/registry.json
 deepparallel/renderer.py
+deepparallel/supply_chain.py
 deepparallel/system_prompt.txt
 deepparallel.egg-info/PKG-INFO
 deepparallel.egg-info/SOURCES.txt
@@ -35,8 +36,10 @@ tests/test_branding.py
 tests/test_cli.py
 tests/test_config.py
 tests/test_fusion.py
+tests/test_issuer_signer.py
 tests/test_licensing.py
 tests/test_renderer.py
+tests/test_supply_chain.py
 tests/test_tool_registry.py
 tests/test_tools_codeast.py
 tests/test_tools_edit.py

{deepparallel-0.2.0 → deepparallel-0.3.1}/pyproject.toml

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

{deepparallel-0.2.0 → deepparallel-0.3.1}/tests/test_agent.py

@@ -367,6 +367,54 @@ def test_no_guardian_still_gates():
     assert len(r.confirmed) == 1  # still prompted, just no Guardian line
 
 
+def test_supply_chain_note_on_hallucinated_dep(monkeypatch):
+    from deepparallel import supply_chain
+
+    monkeypatch.setattr(supply_chain, "check_exists", lambda n, e: n != "fakepkg_xyz")
+    reg = _reg_with_edit_and_shell()
+    backend = FakeBackend(
+        [
+            _toolcall("c1", "write_file", '{"file_path": "a.py", "content": "import fakepkg_xyz"}'),
+            _final("done"),
+        ]
+    )
+    r = FakeRenderer(confirm_value=True)
+    run_agent(
+        backend,
+        reg,
+        [{"role": "user", "content": "go"}],
+        _settings(),
+        r,
+        interactive=True,
+        auto_approve=False,
+    )
+    assert any("Supply-chain" in detail and "fakepkg_xyz" in detail for _t, detail in r.confirmed)
+
+
+def test_supply_chain_overrides_auto_approve(monkeypatch):
+    from deepparallel import supply_chain
+
+    monkeypatch.setattr(supply_chain, "check_exists", lambda n, e: n != "fakepkg_xyz")
+    reg = _reg_with_edit_and_shell()
+    backend = FakeBackend(
+        [
+            _toolcall("c1", "write_file", '{"file_path": "a.py", "content": "import fakepkg_xyz"}'),
+            _final("done"),
+        ]
+    )
+    r = FakeRenderer(confirm_value=False)  # user declines once shown
+    run_agent(
+        backend,
+        reg,
+        [{"role": "user", "content": "go"}],
+        _settings(),
+        r,
+        interactive=True,
+        auto_approve=True,  # auto-approve ON, but hallucination forces a prompt
+    )
+    assert len(r.confirmed) == 1
+
+
 def test_bad_json_arguments_do_not_crash():
     reg = _reg_with_safe_tool()
     backend = FakeBackend([_toolcall("c1", "ping", "{not json"), _final("recovered")])
@@ -383,3 +431,73 @@ def test_bad_json_arguments_do_not_crash():
     assert out == "recovered"
     tool_msgs = [m for m in backend.calls[1] if m.get("role") == "tool"]
     assert "error" in tool_msgs[0]["content"].lower()
+
+
+def test_truncated_tool_call_is_not_applied():
+    """A length-truncated write_file (incomplete file body) must be refused,
+    not written, and the model told to chunk the work."""
+    written = []
+
+    reg = ToolRegistry()
+
+    @reg.tool(dangerous=True)
+    def write_file(file_path: str, content: str = "") -> str:
+        """Write a file."""
+        written.append((file_path, content))
+        return '{"success": true}'
+
+    truncated = _toolcall("c1", "write_file", '{"file_path": "big.py", "content": "import os')
+    truncated["_truncated"] = True
+    backend = FakeBackend([truncated, _final("split it up")])
+    r = FakeRenderer(confirm_value=True)
+    out = run_agent(
+        backend,
+        reg,
+        [{"role": "user", "content": "write a huge file"}],
+        _settings(),
+        r,
+        interactive=True,
+        auto_approve=True,  # even auto-approved, a cut-off call is refused
+    )
+    assert out == "split it up"
+    assert written == []  # the half file was never written
+    assert r.confirmed == []  # not even surfaced for approval; just refused
+    tool_msgs = [m for m in backend.calls[1] if m.get("role") == "tool"]
+    assert "cut off" in tool_msgs[0]["content"].lower()
+
+
+def test_non_final_tool_calls_still_run_when_truncated():
+    """Only the last tool call is cut off; earlier complete calls still run."""
+    reg = _reg_with_safe_tool()
+    two_calls = {
+        "role": "assistant",
+        "content": None,
+        "_truncated": True,
+        "tool_calls": [
+            {
+                "id": "c1",
+                "type": "function",
+                "function": {"name": "ping", "arguments": '{"x": "ok"}'},
+            },
+            {
+                "id": "c2",
+                "type": "function",
+                "function": {"name": "ping", "arguments": '{"x": "cut'},
+            },
+        ],
+    }
+    backend = FakeBackend([two_calls, _final("done")])
+    r = FakeRenderer()
+    out = run_agent(
+        backend,
+        reg,
+        [{"role": "user", "content": "go"}],
+        _settings(),
+        r,
+        interactive=True,
+        auto_approve=False,
+    )
+    assert out == "done"
+    tool_msgs = [m for m in backend.calls[1] if m.get("role") == "tool"]
+    assert tool_msgs[0]["content"] == "pong:ok"  # first call ran
+    assert "cut off" in tool_msgs[1]["content"].lower()  # last call refused

{deepparallel-0.2.0 → deepparallel-0.3.1}/tests/test_backend_chat.py

@@ -111,3 +111,28 @@ def test_foundry_chat_uses_bearer_and_model(monkeypatch):
     assert captured["url"].endswith("/v1/chat/completions")
     assert captured["headers"]["authorization"] == "Bearer tok"
     assert captured["json"]["model"] == "DeepSeek-V3-1"
+
+
+_TRUNCATED_MSG = {
+    "choices": [
+        {
+            "finish_reason": "length",
+            "message": {"role": "assistant", "content": "partial output that got cut"},
+        }
+    ]
+}
+
+
+def test_chat_flags_length_truncation(monkeypatch):
+    monkeypatch.setattr(httpx, "post", lambda url, **kw: _FakeResp(_TRUNCATED_MSG))
+    be = AzureBackend("https://x.example.com", "secret", "DeepSeek-V4-Pro", "2024-08-01-preview")
+    msg = be.chat([{"role": "user", "content": "hi"}], [], 0.4, 2048)
+    assert msg["_truncated"] is True
+
+
+def test_chat_not_truncated_on_normal_stop(monkeypatch):
+    stop_msg = {"choices": [{"finish_reason": "stop", "message": {"content": "done"}}]}
+    monkeypatch.setattr(httpx, "post", lambda url, **kw: _FakeResp(stop_msg))
+    be = AzureBackend("https://x.example.com", "secret", "DeepSeek-V4-Pro", "2024-08-01-preview")
+    msg = be.chat([{"role": "user", "content": "hi"}], [], 0.4, 2048)
+    assert msg["_truncated"] is False

{deepparallel-0.2.0 → deepparallel-0.3.1}/tests/test_cli.py

@@ -181,6 +181,40 @@ def test_review_gated_on_free(monkeypatch, tmp_path):
     assert "pro" in result.output.lower() or "upgrade" in result.output.lower()
 
 
+def test_audit_clean_exits_zero(monkeypatch, tmp_path):
+    _set_azure_env(monkeypatch)
+    from deepparallel import supply_chain
+
+    monkeypatch.setattr(supply_chain, "check_exists", lambda n, e: True)
+    f = tmp_path / "app.py"
+    f.write_text("import requests\nimport flask\n")
+    result = CliRunner().invoke(main, ["audit", str(f)])
+    assert result.exit_code == 0
+    assert "verified" in result.output
+
+
+def test_audit_hallucinated_exits_two(monkeypatch, tmp_path):
+    _set_azure_env(monkeypatch)
+    from deepparallel import supply_chain
+
+    monkeypatch.setattr(supply_chain, "check_exists", lambda n, e: n != "totally_fake_pkg")
+    f = tmp_path / "app.py"
+    f.write_text("import requests\nimport totally_fake_pkg\n")
+    result = CliRunner().invoke(main, ["audit", str(f)])
+    assert result.exit_code == 2
+    assert "hallucinated" in result.output.lower()
+    assert "totally_fake_pkg" in result.output
+
+
+def test_audit_gated_on_free(monkeypatch, tmp_path):
+    _set_azure_env(monkeypatch)
+    monkeypatch.setattr(licensing, "resolve_tier", lambda: licensing.Tier.FREE)
+    f = tmp_path / "app.py"
+    f.write_text("import requests\n")
+    result = CliRunner().invoke(main, ["audit", str(f)])
+    assert result.exit_code == 3
+
+
 def test_free_tier_gates_paid_features(monkeypatch):
     _set_azure_env(monkeypatch)
     monkeypatch.setattr(licensing, "resolve_tier", lambda: licensing.Tier.FREE)

{deepparallel-0.2.0 → deepparallel-0.3.1}/tests/test_config.py

@@ -56,7 +56,7 @@ def test_defaults_to_azure(monkeypatch):
     assert s.backend == "azure"
     assert s.deployment == "DeepSeek-V4-Pro"
     assert s.temperature == 0.4
-    assert s.max_tokens == 2048
+    assert s.max_tokens == 8192
     assert s.show_thinking is False
 
 

deepparallel-0.3.1/tests/test_issuer_signer.py

@@ -0,0 +1,54 @@
+"""The issuer function signs tokens the CLI must accept. Guard that contract."""
+
+import base64
+import importlib.util
+import time
+from pathlib import Path
+
+from cryptography.hazmat.primitives import serialization as s
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+
+from deepparallel import licensing
+
+# import functions/issuer/signer.py directly (it has no cloud deps)
+_spec = importlib.util.spec_from_file_location(
+    "issuer_signer",
+    Path(__file__).resolve().parent.parent / "functions" / "issuer" / "signer.py",
+)
+signer = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(signer)
+
+
+def _keys():
+    priv = Ed25519PrivateKey.generate()
+    priv_b64 = base64.b64encode(
+        priv.private_bytes(s.Encoding.Raw, s.PrivateFormat.Raw, s.NoEncryption())
+    ).decode()
+    pub_b64 = base64.b64encode(
+        priv.public_key().public_bytes(s.Encoding.Raw, s.PublicFormat.Raw)
+    ).decode()
+    return priv_b64, pub_b64
+
+
+def test_issuer_token_verifies_in_cli():
+    priv_b64, pub_b64 = _keys()
+    token = signer.make_license("buyer@co.com", "team", priv_b64)
+    payload = licensing.verify_token(token, pub_b64)
+    assert payload is not None
+    assert payload["tier"] == "team"
+    assert payload["email"] == "buyer@co.com"
+    assert payload["exp"] > time.time()
+
+
+def test_price_to_tier_mapping():
+    m = {"price_PRO": "pro", "price_TEAM": "team"}
+    assert signer.price_to_tier("price_PRO", m) == "pro"
+    assert signer.price_to_tier("price_TEAM", m) == "team"
+    assert signer.price_to_tier("price_UNKNOWN", m) == "pro"  # default paid -> pro
+
+
+def test_issuer_token_rejected_by_wrong_pubkey():
+    priv_b64, _ = _keys()
+    _, other_pub = _keys()
+    token = signer.make_license("x@y.com", "pro", priv_b64)
+    assert licensing.verify_token(token, other_pub) is None

{deepparallel-0.2.0 → deepparallel-0.3.1}/tests/test_licensing.py

@@ -90,6 +90,30 @@ def test_tier_ordering_and_allows():
     assert not licensing.tier_allows(Tier.FREE, Tier.PRO)
 
 
+def test_sign_token_roundtrips_with_verify():
+    priv = Ed25519PrivateKey.generate()
+    priv_b64 = base64.b64encode(
+        priv.private_bytes(s.Encoding.Raw, s.PrivateFormat.Raw, s.NoEncryption())
+    ).decode()
+    pub_b64 = base64.b64encode(
+        priv.public_key().public_bytes(s.Encoding.Raw, s.PublicFormat.Raw)
+    ).decode()
+    token = licensing.sign_token({"tier": "team", "email": "x@y.com", "exp": 0}, priv_b64)
+    payload = licensing.verify_token(token, pub_b64)
+    assert payload is not None
+    assert payload["tier"] == "team" and payload["email"] == "x@y.com"
+
+
+def test_sign_token_signature_is_unforgeable():
+    priv = Ed25519PrivateKey.generate()
+    priv_b64 = base64.b64encode(
+        priv.private_bytes(s.Encoding.Raw, s.PrivateFormat.Raw, s.NoEncryption())
+    ).decode()
+    _, other_pub = _keypair()
+    token = licensing.sign_token({"tier": "pro", "exp": 0}, priv_b64)
+    assert licensing.verify_token(token, other_pub) is None  # wrong key rejects
+
+
 def test_feature_gate_messages():
     ok, msg = licensing.check_feature("guardian", Tier.FREE)
     assert ok is False

deepparallel-0.3.1/tests/test_supply_chain.py

@@ -0,0 +1,71 @@
+import httpx
+
+from deepparallel import supply_chain as sc
+
+
+def test_extract_python_imports():
+    code = (
+        "import os\nimport requests\nfrom flask import Flask\nfrom . import local\nimport a.b.c\n"
+    )
+    deps = sc.extract_dependencies(code, "app.py")
+    names = {d["name"] for d in deps}
+    assert "requests" in names and "flask" in names and "a" in names
+    assert "os" not in names  # stdlib excluded
+    assert "local" not in names  # relative import excluded
+    assert all(d["ecosystem"] == "pypi" for d in deps)
+
+
+def test_extract_requirements_txt():
+    deps = sc.extract_dependencies(
+        "requests==2.31\nflask>=2\n# comment\n\nNotARealPkg123\n", "requirements.txt"
+    )
+    names = {d["name"] for d in deps}
+    assert {"requests", "flask", "notarealpkg123"} <= names
+
+
+def test_extract_package_json():
+    pkg = '{"dependencies": {"react": "^18", "left-pad": "1.0.0"}, "devDependencies": {"vitest": "^1"}}'
+    deps = sc.extract_dependencies(pkg, "package.json")
+    names = {(d["name"], d["ecosystem"]) for d in deps}
+    assert ("react", "npm") in names and ("left-pad", "npm") in names and ("vitest", "npm") in names
+
+
+def test_audit_flags_missing_package(monkeypatch):
+    # requests exists (200), hallucinated-pkg does not (404)
+    def fake_get(url, **kw):
+        code = 404 if "hallucinated" in url else 200
+        return httpx.Response(code, request=httpx.Request("GET", url))
+
+    monkeypatch.setattr(httpx, "get", fake_get)
+    out = sc.audit("import requests\nimport hallucinated_pkg\n", "app.py")
+    findings = {f["name"]: f["status"] for f in out["findings"]}
+    assert findings["requests"] == "ok"
+    assert findings["hallucinated_pkg"] == "missing"
+    assert out["hallucinated"] == ["hallucinated_pkg"]
+
+
+def test_audit_degrades_on_network_error(monkeypatch):
+    def boom(url, **kw):
+        raise httpx.ConnectError("offline")
+
+    monkeypatch.setattr(httpx, "get", boom)
+    out = sc.audit("import requests\n", "app.py")
+    # network failure -> unknown, never a false "missing"
+    assert out["findings"][0]["status"] == "unknown"
+    assert out["hallucinated"] == []
+
+
+def test_check_pypi_existence(monkeypatch):
+    monkeypatch.setattr(
+        httpx, "get", lambda url, **kw: httpx.Response(200, request=httpx.Request("GET", url))
+    )
+    assert sc.check_exists("requests", "pypi") is True
+    monkeypatch.setattr(
+        httpx, "get", lambda url, **kw: httpx.Response(404, request=httpx.Request("GET", url))
+    )
+    assert sc.check_exists("nope", "pypi") is False
+
+
+def test_audit_empty_when_no_deps():
+    out = sc.audit("x = 1\nprint(x)\n", "app.py")
+    assert out["findings"] == [] and out["hallucinated"] == []