deepparallel 0.2.0__py3-none-any.whl

deepparallel/__init__.py

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

deepparallel/agent.py

@@ -0,0 +1,286 @@
+"""The agentic tool-calling loop.
+
+UI-agnostic: it drives a backend (`chat`) and a tool registry, and surfaces
+activity through an injected renderer. Dangerous tools are gated; the loop
+terminates on a content answer or a step cap.
+"""
+
+from __future__ import annotations
+
+import difflib
+import json
+import time
+from pathlib import Path
+
+from deepparallel.tools.registry import coerce_args
+
+_MAX_TOOL_RESULT = 50_000
+_GATED_PATH_TOOLS = ("write_file", "edit_file")
+_EDIT_TOOLS = ("write_file", "edit_file", "ast_replace_symbol")
+
+
+def _parse_args(raw: str) -> dict:
+    if not raw:
+        return {}
+    try:
+        value = json.loads(raw)
+    except json.JSONDecodeError:
+        return {"__parse_error__": raw[:2000]}
+    return value if isinstance(value, dict) else {}
+
+
+def _plural(n: int, sing: str, plur: str) -> str:
+    return f"{n} {sing if n == 1 else plur}"
+
+
+def _summarize_result(name: str, result: str) -> str:
+    """A short, human-readable summary of a tool result for the UI.
+
+    The model still receives the full result; this is only what the user sees
+    on the tool card, so it must be legible rather than raw truncated JSON.
+    """
+    try:
+        obj = json.loads(result)
+    except (json.JSONDecodeError, ValueError):
+        obj = None
+    if isinstance(obj, dict) and "error" in obj:
+        return f"error: {str(obj['error'])[:100]}"
+    if isinstance(obj, dict):
+        if name == "list_dir":
+            return _plural(len(obj.get("entries", [])), "entry", "entries")
+        if name in ("glob", "grep"):
+            return _plural(len(obj.get("matches", [])), "match", "matches")
+        if name == "web_search":
+            return _plural(len(obj.get("results", [])), "result", "results")
+        if name == "ast_symbols":
+            return _plural(len(obj.get("symbols", [])), "symbol", "symbols")
+        if name == "write_file":
+            return f"wrote {obj.get('bytes', 0)} bytes"
+        if name == "edit_file":
+            return "edited"
+        if name == "ast_replace_symbol":
+            return "replaced"
+        if name == "run_shell":
+            lines = (obj.get("stdout") or "").count("\n")
+            return f"rc {obj.get('return_code')} · {_plural(lines, 'line', 'lines')}"
+        if name == "run_code":
+            return f"rc {obj.get('exit_code')} · {obj.get('sandbox', '')}"
+        if name == "web_fetch":
+            title = (obj.get("title") or "").strip()
+            chars = len(obj.get("text") or "")
+            return f'"{title[:40]}" · {chars} chars' if title else f"{chars} chars"
+        if name == "ast_show_symbol":
+            return _plural((obj.get("source") or "").count("\n") + 1, "line", "lines")
+        if name == "analyze_image":
+            return f"{len(obj.get('description') or '')} chars"
+        return next(iter(obj)) if obj else "ok"
+    if name == "read_file":
+        return _plural(result.count("\n") + 1, "line", "lines") if result else "0 lines"
+    return " ".join(result.split())[:80]
+
+
+def _preview(args: dict) -> str:
+    try:
+        s = json.dumps(args)
+    except (TypeError, ValueError):
+        s = str(args)
+    return s[:80]
+
+
+def _outside_cwd(args: dict) -> bool:
+    p = args.get("file_path")
+    if not p:
+        return False
+    try:
+        Path(p).expanduser().resolve().relative_to(Path.cwd().resolve())
+        return False
+    except ValueError:
+        return True
+
+
+def _diff_preview(name: str, args: dict) -> str:
+    path = args.get("file_path", "")
+    try:
+        target = Path(path).expanduser().resolve()
+        old = target.read_text(encoding="utf-8") if target.is_file() else ""
+    except OSError:
+        old = ""
+    if name == "write_file":
+        new = args.get("content", "")
+        if args.get("content_b64"):
+            import base64
+
+            try:
+                new = base64.b64decode(args["content_b64"]).decode("utf-8", errors="replace")
+            except Exception:  # noqa: BLE001
+                new = "<base64 payload>"
+    else:
+        new = old.replace(args.get("old_string", ""), args.get("new_string", ""), 1)
+    diff = difflib.unified_diff(old.splitlines(), new.splitlines(), lineterm="", n=2)
+    text = "\n".join(list(diff)[:60])
+    return text or f"write {path}"
+
+
+def _describe(name: str, args: dict) -> tuple[str, str]:
+    if name == "run_shell":
+        cmd = args.get("command", "")
+        return (
+            f"run shell: {cmd[:60]}",
+            f"command: {cmd}\ncwd: {args.get('working_directory') or '.'}",
+        )
+    if name in _GATED_PATH_TOOLS:
+        return f"{name}: {args.get('file_path', '')}", _diff_preview(name, args)
+    return name, json.dumps(args)[:500]
+
+
+def _guardian_review_content(name: str, args: dict) -> str:
+    if name in _GATED_PATH_TOOLS:
+        return _diff_preview(name, args)
+    return (
+        f"Replace symbol '{args.get('name', '')}' in {args.get('file_path', '')} with:\n"
+        f"{(args.get('new_source') or '')[:4000]}"
+    )
+
+
+def guardian_review(guardian, content: str) -> str | None:
+    """Ask an independent model to review a code change/snippet. Returns a
+    one-line verdict ('safe', 'risky: ...', 'bug: ...') or None on failure."""
+    prompt = (
+        "You are an independent code reviewer giving a second opinion on a proposed "
+        "change. Reply with exactly one line: 'VERDICT: safe', 'VERDICT: risky: <reason>', "
+        f"or 'VERDICT: bug: <reason>'. Be terse.\n\nProposed change:\n{content}\n\nVerdict:"
+    )
+    messages = [{"role": "user", "content": prompt}]
+    msg = None
+    for _ in range(2):  # one retry: review runs against a sometimes-flaky API
+        try:
+            msg = guardian.chat(messages, [], 0.0, 512)
+            break
+        except Exception:  # noqa: BLE001 - review is best-effort
+            msg = None
+    if msg is None:
+        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 verdict_severity(verdict: str | None) -> str:
+    """Classify a verdict string into safe | risky | bug | unknown."""
+    if not verdict:
+        return "unknown"
+    head = verdict.strip().lower()
+    if head.startswith("safe"):
+        return "safe"
+    if head.startswith("risky"):
+        return "risky"
+    if head.startswith("bug"):
+        return "bug"
+    return "unknown"
+
+
+def verdict_exit_code(verdict: str | None) -> int:
+    """Exit code for `review` as a PR gate: 0 safe, 1 risky, 2 bug, 0 unknown."""
+    return {"safe": 0, "risky": 1, "bug": 2, "unknown": 0}[verdict_severity(verdict)]
+
+
+def _guardian_verdict(guardian, name: str, args: dict) -> str | None:
+    return guardian_review(guardian, _guardian_review_content(name, args))
+
+
+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:
+        return True
+    if not interactive:
+        return False
+    title, detail = _describe(name, args)
+    if guardian is not None and name in _EDIT_TOOLS:
+        verdict = _guardian_verdict(guardian, name, args)
+        if verdict:
+            detail = f"{detail}\n\nGuardian: {verdict}"
+    return renderer.confirm(title, detail)
+
+
+def _stream_turn(backend, messages, schemas, settings, renderer):
+    """Drive one streaming turn: stream content tokens live and capture the
+    assembled message (with any tool_calls) from the generator's return value."""
+    captured = {"msg": {"role": "assistant", "content": "", "tool_calls": None}}
+
+    def content_tokens():
+        gen = backend.stream_chat_tools(
+            messages, schemas, settings.temperature, settings.max_tokens
+        )
+        while True:
+            try:
+                channel, text = next(gen)
+            except StopIteration as stop:
+                captured["msg"] = stop.value
+                return
+            if channel == "content":
+                yield text
+
+    renderer.answer_stream(content_tokens())
+    return captured["msg"], True
+
+
+def run_agent(
+    backend,
+    registry,
+    messages,
+    settings,
+    renderer,
+    *,
+    interactive: bool,
+    auto_approve: bool,
+    max_steps: int | None = None,
+    stream: bool = False,
+    guardian=None,
+) -> str:
+    steps = max_steps if max_steps is not None else settings.max_steps
+    schemas = registry.schemas()
+    can_stream = stream and hasattr(backend, "stream_chat_tools")
+    for _ in range(steps):
+        if can_stream:
+            msg, streamed = _stream_turn(backend, messages, schemas, settings, renderer)
+        else:
+            msg = backend.chat(messages, schemas, settings.temperature, settings.max_tokens)
+            streamed = False
+        tool_calls = msg.get("tool_calls")
+        if not tool_calls:
+            content = msg.get("content") or ""
+            messages.append({"role": "assistant", "content": content})
+            if not streamed:
+                renderer.answer(content)
+            return content
+
+        messages.append(
+            {"role": "assistant", "content": msg.get("content"), "tool_calls": tool_calls}
+        )
+        for tc in 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:
+                result = json.dumps({"error": f"unknown tool: {name}"})
+            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
+            ):
+                result = json.dumps({"error": "denied by user"})
+            else:
+                try:
+                    result = registry.call(name, **coerce_args(meta.parameters, args))
+                except Exception as e:  # noqa: BLE001 - surface tool failure to model
+                    result = json.dumps({"error": f"{type(e).__name__}: {e}"})
+            result = str(result)[:_MAX_TOOL_RESULT]
+            ok = '"error"' not in result[:30]
+            renderer.tool_result(ok, _summarize_result(name, result), time.monotonic() - start)
+            messages.append({"role": "tool", "tool_call_id": tc["id"], "content": result})
+    return f"Reached the {steps}-step limit without a final answer."

deepparallel/backend.py

@@ -0,0 +1,302 @@
+"""HTTP transports for DeepParallel.
+
+Two interchangeable backends behind one streaming seam:
+- AzureBackend: direct Azure OpenAI chat-completions deployment.
+- FoundryBackend: Crowe Logic Foundry control plane (/v1/chat/completions).
+
+stream_chat yields (channel, text) tuples where channel is "content" or
+"thinking", so reasoning visibility stays a rendering decision in cli.py.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Iterator, Protocol
+from urllib.parse import urlparse
+
+import httpx
+
+Chunk = tuple[str, str]  # (channel, text)
+
+_STREAM_TIMEOUT = httpx.Timeout(120.0, connect=10.0)
+_CHECK_TIMEOUT = 4.0
+
+
+def parse_sse_lines(lines: Iterator[str]) -> Iterator[Chunk]:
+    """Parse OpenAI-style SSE lines into (channel, text) chunks."""
+    for raw in lines:
+        line = raw.strip()
+        if not line or not line.startswith("data:"):
+            continue
+        data = line[len("data:") :].strip()
+        if data == "[DONE]":
+            return
+        try:
+            obj = json.loads(data)
+        except json.JSONDecodeError:
+            continue
+        choices = obj.get("choices") or []
+        if not choices:
+            continue
+        delta = choices[0].get("delta") or {}
+        reasoning = delta.get("reasoning_content")
+        if reasoning:
+            yield ("thinking", reasoning)
+        content = delta.get("content")
+        if content:
+            yield ("content", content)
+
+
+def parse_sse_stream(lines: Iterator[str]):
+    """Parse a streaming chat completion that may include tool calls.
+
+    Yields ("content"|"thinking", text) deltas for live rendering, and returns
+    (via StopIteration.value) the fully assembled assistant message with any
+    tool_calls accumulated across chunks.
+    """
+    content_parts: list[str] = []
+    acc: dict[int, dict] = {}
+    for raw in lines:
+        line = raw.strip()
+        if not line or not line.startswith("data:"):
+            continue
+        data = line[len("data:") :].strip()
+        if data == "[DONE]":
+            break
+        try:
+            obj = json.loads(data)
+        except json.JSONDecodeError:
+            continue
+        choices = obj.get("choices") or []
+        if not choices:
+            continue
+        delta = choices[0].get("delta") or {}
+        reasoning = delta.get("reasoning_content")
+        if reasoning:
+            yield ("thinking", reasoning)
+        content = delta.get("content")
+        if content:
+            content_parts.append(content)
+            yield ("content", content)
+        for tc in delta.get("tool_calls") or []:
+            idx = tc.get("index", 0)
+            slot = acc.setdefault(
+                idx, {"id": "", "type": "function", "function": {"name": "", "arguments": ""}}
+            )
+            if tc.get("id"):
+                slot["id"] = tc["id"]
+            fn = tc.get("function") or {}
+            if fn.get("name"):
+                slot["function"]["name"] = fn["name"]
+            if fn.get("arguments"):
+                slot["function"]["arguments"] += fn["arguments"]
+    tool_calls = [acc[i] for i in sorted(acc)] or None
+    return {
+        "role": "assistant",
+        "content": "".join(content_parts) or None,
+        "tool_calls": tool_calls,
+    }
+
+
+def _host(url: str) -> str:
+    p = urlparse(url)
+    return f"{p.scheme}://{p.netloc}" if p.netloc else url
+
+
+class Backend(Protocol):
+    label: str
+
+    def check(self) -> tuple[bool, str]: ...
+
+    def stream_chat(
+        self, messages: list[dict], temperature: float, max_tokens: int
+    ) -> Iterator[Chunk]: ...
+
+    def chat(
+        self, messages: list[dict], tools: list[dict], temperature: float, max_tokens: int
+    ) -> dict: ...
+
+    def stream_chat_tools(
+        self, messages: list[dict], tools: list[dict], temperature: float, max_tokens: int
+    ) -> Iterator[Chunk]: ...
+
+
+class AzureBackend:
+    label = "Azure OpenAI"
+
+    def __init__(self, endpoint: str, api_key: str, deployment: str, api_version: str):
+        self._endpoint = (endpoint or "").rstrip("/")
+        self._api_key = api_key or ""
+        self._deployment = deployment
+        self._api_version = api_version
+
+    @property
+    def _url(self) -> str:
+        return (
+            f"{self._endpoint}/openai/deployments/{self._deployment}"
+            f"/chat/completions?api-version={self._api_version}"
+        )
+
+    def check(self) -> tuple[bool, str]:
+        if not self._endpoint or not self._api_key:
+            return False, "Azure endpoint or API key not configured."
+        try:
+            httpx.get(_host(self._endpoint), timeout=_CHECK_TIMEOUT)
+        except Exception as e:  # noqa: BLE001 - reachability probe
+            return False, f"Azure endpoint unreachable ({e.__class__.__name__})"
+        return True, f"Azure @ {_host(self._endpoint)}"
+
+    def stream_chat(self, messages, temperature, max_tokens):
+        payload = {
+            "messages": messages,
+            "stream": True,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+        }
+        headers = {"api-key": self._api_key, "content-type": "application/json"}
+        with httpx.stream(
+            "POST", self._url, json=payload, headers=headers, timeout=_STREAM_TIMEOUT
+        ) as r:
+            r.raise_for_status()
+            yield from parse_sse_lines(r.iter_lines())
+
+    def chat(self, messages, tools, temperature, max_tokens) -> dict:
+        payload = {
+            "messages": messages,
+            "stream": False,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+        }
+        if tools:
+            payload["tools"] = tools
+        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"]
+
+    def stream_chat_tools(self, messages, tools, temperature, max_tokens):
+        payload = {
+            "messages": messages,
+            "stream": True,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+        }
+        if tools:
+            payload["tools"] = tools
+        headers = {"api-key": self._api_key, "content-type": "application/json"}
+        with httpx.stream(
+            "POST", self._url, json=payload, headers=headers, timeout=_STREAM_TIMEOUT
+        ) as r:
+            r.raise_for_status()
+            return (yield from parse_sse_stream(r.iter_lines()))
+
+
+class FoundryBackend:
+    label = "Foundry control plane"
+
+    def __init__(self, base_url: str, api_key: str, model: str):
+        self._base_url = (base_url or "").rstrip("/")
+        self._api_key = api_key or ""
+        self._model = model
+
+    @property
+    def _url(self) -> str:
+        return f"{self._base_url}/v1/chat/completions"
+
+    def check(self) -> tuple[bool, str]:
+        if not self._base_url or not self._api_key:
+            return False, "Foundry base URL or API key not configured."
+        try:
+            httpx.get(_host(self._base_url), timeout=_CHECK_TIMEOUT)
+        except Exception as e:  # noqa: BLE001 - reachability probe
+            return False, f"Foundry endpoint unreachable ({e.__class__.__name__})"
+        return True, f"Foundry @ {_host(self._base_url)}"
+
+    def stream_chat(self, messages, temperature, max_tokens):
+        payload = {
+            "model": self._model,
+            "messages": messages,
+            "stream": True,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+        }
+        headers = {
+            "authorization": f"Bearer {self._api_key}",
+            "content-type": "application/json",
+        }
+        with httpx.stream(
+            "POST", self._url, json=payload, headers=headers, timeout=_STREAM_TIMEOUT
+        ) as r:
+            r.raise_for_status()
+            yield from parse_sse_lines(r.iter_lines())
+
+    def chat(self, messages, tools, temperature, max_tokens) -> dict:
+        payload = {
+            "model": self._model,
+            "messages": messages,
+            "stream": False,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+        }
+        if tools:
+            payload["tools"] = tools
+        headers = {
+            "authorization": f"Bearer {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"]
+
+    def stream_chat_tools(self, messages, tools, temperature, max_tokens):
+        payload = {
+            "model": self._model,
+            "messages": messages,
+            "stream": True,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+        }
+        if tools:
+            payload["tools"] = tools
+        headers = {
+            "authorization": f"Bearer {self._api_key}",
+            "content-type": "application/json",
+        }
+        with httpx.stream(
+            "POST", self._url, json=payload, headers=headers, timeout=_STREAM_TIMEOUT
+        ) as r:
+            r.raise_for_status()
+            return (yield from parse_sse_stream(r.iter_lines()))
+
+
+def resolve_backend(settings) -> Backend:
+    """Factory keyed on settings.backend."""
+    if settings.backend == "foundry":
+        return FoundryBackend(
+            settings.foundry_base_url or "",
+            settings.foundry_api_key or "",
+            settings.foundry_model,
+        )
+    return AzureBackend(
+        settings.azure_endpoint or "",
+        settings.azure_api_key or "",
+        settings.deployment,
+        settings.api_version,
+    )
+
+
+def backend_for_deployment(settings, deployment: str) -> Backend:
+    """Build a backend targeting a specific deployment/model (for fusion).
+
+    Uses the same transport as the active backend, just a different model id.
+    """
+    if settings.backend == "foundry":
+        return FoundryBackend(
+            settings.foundry_base_url or "", settings.foundry_api_key or "", deployment
+        )
+    return AzureBackend(
+        settings.azure_endpoint or "",
+        settings.azure_api_key or "",
+        deployment,
+        settings.api_version,
+    )