dgc-sdk 0.5.2__tar.gz

dgc_sdk-0.5.2/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: dgc-sdk
+Version: 0.5.2
+Summary: Embed the DGC coding harness in applications and CI
+Author: Mohit Kalra
+License: Apache-2.0
+Project-URL: Homepage, https://vibedgc.com/sdk/
+Project-URL: Documentation, https://docs.vibedgc.com/sdk
+Project-URL: Repository, https://github.com/OpenPeach-ai/dgc
+Project-URL: Issues, https://github.com/OpenPeach-ai/dgc/issues
+Project-URL: Release, https://github.com/OpenPeach-ai/dgc/releases/tag/sdk-v0.5.2
+Keywords: dgc,agent,sdk,coding-agent
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# dgc-sdk
+
+Python facade over a managed `dgc serve` process. Protocol v14 / CLI 0.41.5. Frozen 0.5.2.
+
+```bash
+python3 -m pip install dgc-sdk
+```
+
+That installs **this** package (`import dgc_sdk`). It is not PyPI `dgc` (an unrelated clustering library). Until the index has this release, use the GitHub wheel:
+
+```bash
+python3 -m pip install \
+  "https://github.com/OpenPeach-ai/dgc/releases/download/sdk-v0.5.2/dgc_sdk-0.5.2-py3-none-any.whl"
+```
+
+```python
+from pathlib import Path
+from dgc_sdk import DGC, QuestionAnswer, define_tool
+
+with DGC(state_dir=Path("/tmp/dgc-sdk-state"), model="demo-model",
+         base_url="http://127.0.0.1:11434/v1") as dgc:
+    session = dgc.session(
+        cwd=".",
+        permissions={"mode": "default", "unhandled": "deny"},
+        on_permission=lambda req: "deny",
+        on_question=lambda req: {req.questions[0].id: QuestionAnswer(selected=(0,))}
+        if req.questions else "dismiss",
+    )
+    result = session.run("Summarize this repository. Do not edit files.")
+    print(result.status, result.final_text)
+    session.close()
+    restored = dgc.resume(latest=True, cwd=".", permissions={"mode": "default", "unhandled": "deny"})
+    print(restored.session_id, restored.history().get("items") and "history ok")
+```
+
+From a clone: `pip install -e sdk/python`. The wheel still needs a DGC runtime (`python -m dgc serve`, CLI 0.41.5). Set `inherit_user_state=False` in production.

dgc_sdk-0.5.2/README.md

@@ -0,0 +1,36 @@
+# dgc-sdk
+
+Python facade over a managed `dgc serve` process. Protocol v14 / CLI 0.41.5. Frozen 0.5.2.
+
+```bash
+python3 -m pip install dgc-sdk
+```
+
+That installs **this** package (`import dgc_sdk`). It is not PyPI `dgc` (an unrelated clustering library). Until the index has this release, use the GitHub wheel:
+
+```bash
+python3 -m pip install \
+  "https://github.com/OpenPeach-ai/dgc/releases/download/sdk-v0.5.2/dgc_sdk-0.5.2-py3-none-any.whl"
+```
+
+```python
+from pathlib import Path
+from dgc_sdk import DGC, QuestionAnswer, define_tool
+
+with DGC(state_dir=Path("/tmp/dgc-sdk-state"), model="demo-model",
+         base_url="http://127.0.0.1:11434/v1") as dgc:
+    session = dgc.session(
+        cwd=".",
+        permissions={"mode": "default", "unhandled": "deny"},
+        on_permission=lambda req: "deny",
+        on_question=lambda req: {req.questions[0].id: QuestionAnswer(selected=(0,))}
+        if req.questions else "dismiss",
+    )
+    result = session.run("Summarize this repository. Do not edit files.")
+    print(result.status, result.final_text)
+    session.close()
+    restored = dgc.resume(latest=True, cwd=".", permissions={"mode": "default", "unhandled": "deny"})
+    print(restored.session_id, restored.history().get("items") and "history ok")
+```
+
+From a clone: `pip install -e sdk/python`. The wheel still needs a DGC runtime (`python -m dgc serve`, CLI 0.41.5). Set `inherit_user_state=False` in production.

dgc_sdk-0.5.2/dgc_sdk/__init__.py

@@ -0,0 +1,40 @@
+"""DGC SDK for embedding the harness in applications and CI.
+
+Local package. Not published. Version with the TypeScript SDK when the contract changes.
+"""
+
+from ._mcp_bridge import define_tool
+from ._version import PROTOCOL, REQUIRES_CLI, __version__
+from .audit import redact, redact_text
+from .client import AsyncDGC, AsyncRunHandle, AsyncSession, DGC
+from .policy import RuntimePolicy
+from .retry import RetryPolicy
+from .usage import Pricing, cost_usd
+from .errors import (
+    DGCConfigError, DGCError, DGCProtocolError, DGCRuntimeError, DGCTimeoutError,
+    DGCUnsupportedError,
+)
+from .session import RunHandle, Session
+from .types import (
+    AgentInfo, Artifact, Checkpoint, FileChange, Goal, HookInfo, McpInputRequest, McpInputResponse,
+    McpServerInfo, Monitor, OnMcpInput, OnPermission, OnPlan, OnQuestion, PermissionAction,
+    PermissionMode, PermissionPolicy, PermissionRequest, PermissionRule, PlanAction, PlanRequest,
+    Question, QuestionAnswer, QuestionOption, QuestionRequest, RunEvent, RunResult, RunStatus,
+    SandboxPolicy, SandboxRequirement, SessionInfo, SkillInfo, TaskItem, TaskStatus, ToolRecord,
+    ToolSpec, UnhandledPolicy, VerificationResult,
+)
+
+__all__ = [
+    "PROTOCOL", "REQUIRES_CLI", "__version__",
+    "AgentInfo", "Artifact", "AsyncDGC", "AsyncRunHandle", "AsyncSession", "Checkpoint", "DGC",
+    "Pricing", "RetryPolicy", "RuntimePolicy", "cost_usd", "redact", "redact_text",
+    "DGCConfigError", "DGCError", "DGCProtocolError", "DGCRuntimeError", "DGCTimeoutError",
+    "DGCUnsupportedError", "FileChange", "Goal", "HookInfo", "McpInputRequest", "McpInputResponse",
+    "McpServerInfo", "Monitor", "OnMcpInput", "OnPermission", "OnPlan", "OnQuestion",
+    "PermissionAction", "PermissionMode", "PermissionPolicy", "PermissionRequest",
+    "PermissionRule", "PlanAction", "PlanRequest",
+    "Question", "QuestionAnswer", "QuestionOption", "QuestionRequest", "RunEvent", "RunHandle",
+    "RunResult", "RunStatus", "SandboxPolicy", "SandboxRequirement", "Session", "SessionInfo",
+    "SkillInfo", "TaskItem", "TaskStatus", "ToolRecord", "ToolSpec", "UnhandledPolicy",
+    "VerificationResult", "define_tool",
+]

dgc_sdk-0.5.2/dgc_sdk/_mcp_bridge.py

@@ -0,0 +1,248 @@
+"""stdio ↔ Unix-socket relay so DGC can spawn an MCP server that lives in the SDK process.
+
+``python -m dgc_sdk._mcp_bridge SOCKET`` copies NDJSON in both directions. The SDK host speaks
+MCP on the accepted socket (initialize, tools/list, tools/call).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import socket
+import sys
+import threading
+from collections.abc import Callable, Mapping
+from pathlib import Path
+from typing import Any
+
+
+def _sdk_version() -> str:
+    try:
+        from ._version import __version__
+        return __version__
+    except ImportError:
+        text = Path(__file__).with_name("_version.py").read_text(encoding="utf-8")
+        for line in text.splitlines():
+            if line.startswith("__version__"):
+                return line.split('"', 2)[1]
+        return "0.0.0"
+
+
+def relay(socket_path: str) -> int:
+    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    sock.connect(socket_path)
+
+    def stdin_to_sock() -> None:
+        try:
+            while True:
+                line = sys.stdin.buffer.readline()
+                if not line:
+                    break
+                sock.sendall(line)
+        except OSError:
+            pass
+        try:
+            sock.shutdown(socket.SHUT_WR)
+        except OSError:
+            pass
+
+    threading.Thread(target=stdin_to_sock, daemon=True).start()
+    try:
+        while True:
+            chunk = sock.recv(65536)
+            if not chunk:
+                break
+            sys.stdout.buffer.write(chunk)
+            sys.stdout.buffer.flush()
+    except OSError:
+        pass
+    return 0
+
+
+class ToolHub:
+    """Accept one MCP stdio proxy and dispatch ``tools/call`` to host handlers."""
+
+    def __init__(self, socket_path: str, tools: SequenceToolMap):
+        self.socket_path = socket_path
+        self.tools = {item.name: item for item in tools}
+        self._server: socket.socket | None = None
+        self._thread: threading.Thread | None = None
+
+    def start(self) -> None:
+        if os.path.exists(self.socket_path):
+            os.unlink(self.socket_path)
+        server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        server.bind(self.socket_path)
+        server.listen(4)
+        server.settimeout(1.0)
+        self._server = server
+        self._thread = threading.Thread(target=self._accept, name="dgc-sdk-mcp", daemon=True)
+        self._thread.start()
+
+    def close(self) -> None:
+        if self._server is not None:
+            try:
+                self._server.close()
+            except OSError:
+                pass
+        if os.path.exists(self.socket_path):
+            try:
+                os.unlink(self.socket_path)
+            except OSError:
+                pass
+
+    def _accept(self) -> None:
+        assert self._server is not None
+        while True:
+            try:
+                conn, _addr = self._server.accept()
+            except TimeoutError:
+                continue
+            except OSError:
+                return
+            threading.Thread(target=self._serve, args=(conn,), daemon=True).start()
+
+    def _serve(self, conn: socket.socket) -> None:
+        buf = b""
+        try:
+            while True:
+                chunk = conn.recv(65536)
+                if not chunk:
+                    return
+                buf += chunk
+                while b"\n" in buf:
+                    line, buf = buf.split(b"\n", 1)
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        message = json.loads(line.decode("utf-8"))
+                    except (UnicodeDecodeError, json.JSONDecodeError):
+                        continue
+                    reply = self._handle(message)
+                    if reply is not None:
+                        conn.sendall((json.dumps(reply, separators=(",", ":")) + "\n").encode())
+        except OSError:
+            return
+        finally:
+            try:
+                conn.close()
+            except OSError:
+                pass
+
+    def _handle(self, message: Mapping[str, Any]) -> dict[str, Any] | None:
+        method = str(message.get("method") or "")
+        mid = message.get("id")
+        if method == "initialize":
+            return {
+                "jsonrpc": "2.0", "id": mid,
+                "result": {
+                    "protocolVersion": "2025-11-25",
+                    "capabilities": {"tools": {}},
+                    "serverInfo": {"name": "dgc-sdk", "version": _sdk_version()},
+                },
+            }
+        if method in ("notifications/initialized", "notifications/cancelled"):
+            return None
+        if method == "ping":
+            return {"jsonrpc": "2.0", "id": mid, "result": {}}
+        if method == "tools/list":
+            tools = []
+            for spec in self.tools.values():
+                tools.append({
+                    "name": spec.name,
+                    "description": spec.description,
+                    "inputSchema": dict(spec.input_schema) or {"type": "object", "properties": {}},
+                })
+            return {"jsonrpc": "2.0", "id": mid, "result": {"tools": tools}}
+        if method == "tools/call":
+            params = message.get("params") if isinstance(message.get("params"), dict) else {}
+            name = str(params.get("name") or "")
+            arguments = params.get("arguments") if isinstance(params.get("arguments"), dict) else {}
+            spec = self.tools.get(name)
+            if spec is None:
+                return {"jsonrpc": "2.0", "id": mid, "error": {
+                    "code": -32601, "message": f"unknown tool {name}"}}
+            try:
+                result = self._call_handler(spec, arguments)
+            except TimeoutError:
+                return {"jsonrpc": "2.0", "id": mid, "result": {
+                    "content": [{"type": "text", "text": "tool error: TimeoutError: handler exceeded timeout"}],
+                    "isError": True,
+                }}
+            except Exception as exc:
+                return {"jsonrpc": "2.0", "id": mid, "result": {
+                    "content": [{"type": "text", "text": f"tool error: {type(exc).__name__}: {exc}"}],
+                    "isError": True,
+                }}
+            text = result if isinstance(result, str) else json.dumps(result, ensure_ascii=False)
+            return {"jsonrpc": "2.0", "id": mid, "result": {
+                "content": [{"type": "text", "text": text[:120_000]}],
+                "isError": False,
+            }}
+        if mid is not None:
+            return {"jsonrpc": "2.0", "id": mid, "error": {
+                "code": -32601, "message": f"unsupported method {method}"}}
+        return None
+
+    def _call_handler(self, spec, arguments):
+        timeout = getattr(spec, "timeout", None)
+        if timeout is None:
+            return spec.handler(arguments)
+        box: list = []
+        error: list = []
+
+        def worker() -> None:
+            try:
+                box.append(spec.handler(arguments))
+            except Exception as exc:
+                error.append(exc)
+
+        thread = threading.Thread(target=worker, daemon=True)
+        thread.start()
+        thread.join(float(timeout))
+        if thread.is_alive():
+            raise TimeoutError("handler exceeded timeout")
+        if error:
+            raise error[0]
+        return box[0] if box else None
+
+
+# Imported after types to keep this module usable as ``python -m``.
+try:
+    from .types import ToolSpec
+    SequenceToolMap = list[ToolSpec]
+except Exception:  # pragma: no cover - running as a frozen proxy
+    ToolSpec = Any  # type: ignore[misc,assignment]
+    SequenceToolMap = list
+
+
+def define_tool(name: str, description: str, input_schema: Mapping[str, Any],
+                handler: Callable[[Mapping[str, Any]], Any],
+                timeout: float | None = 30.0) -> "ToolSpec":
+    from .errors import DGCConfigError
+    from .types import ToolSpec as Spec
+    if not name or not isinstance(name, str) or not name.replace("_", "").replace("-", "").isalnum():
+        raise DGCConfigError("tool name must be a non-empty identifier")
+    if not description or not isinstance(description, str):
+        raise DGCConfigError("tool description is required")
+    if not isinstance(input_schema, Mapping):
+        raise DGCConfigError("tool input_schema must be an object")
+    if not callable(handler):
+        raise DGCConfigError("tool handler must be callable")
+    if timeout is not None and (not isinstance(timeout, (int, float)) or timeout <= 0):
+        raise DGCConfigError("tool timeout must be a positive number of seconds")
+    return Spec(name=name, description=description, input_schema=dict(input_schema),
+                handler=handler, timeout=None if timeout is None else float(timeout))
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = sys.argv[1:] if argv is None else argv
+    if not args:
+        sys.stderr.write("usage: python -m dgc_sdk._mcp_bridge SOCKET\n")
+        return 2
+    return relay(args[0])
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

dgc_sdk-0.5.2/dgc_sdk/_version.py

@@ -0,0 +1,5 @@
+"""Local SDK version. Bump with the TypeScript package when the contract changes."""
+
+__version__ = "0.5.2"
+PROTOCOL = 14
+REQUIRES_CLI = "0.41.3"

dgc_sdk-0.5.2/dgc_sdk/audit.py

@@ -0,0 +1,86 @@
+"""Run audit log with secret redaction. Stored in the isolated state_dir, not host ~/.dgc."""
+from __future__ import annotations
+
+import json
+import re
+import threading
+import time
+from pathlib import Path
+from typing import Any, Mapping
+
+_SECRET_RE = re.compile(
+    r"(?i)(sk-[A-Za-z0-9]{8,}|bearer\s+[A-Za-z0-9._\-]+|api[_-]?key\s*[:=]\s*\S+|"
+    r"authorization\s*[:=]\s*\S+|x-api-key\s*[:=]\s*\S+)"
+)
+_KEYISH = re.compile(r"(?i)(api_key|token|secret|password|authorization|passwd)")
+
+
+def redact_text(value: str) -> str:
+    return _SECRET_RE.sub("[redacted]", value)
+
+
+def redact(value: Any) -> Any:
+    if isinstance(value, str):
+        return redact_text(value)
+    if isinstance(value, Mapping):
+        out = {}
+        for key, item in value.items():
+            if _KEYISH.search(str(key)):
+                out[str(key)] = "[redacted]"
+            else:
+                out[str(key)] = redact(item)
+        return out
+    if isinstance(value, list):
+        return [redact(item) for item in value[:80]]
+    if isinstance(value, tuple):
+        return [redact(item) for item in value[:80]]
+    if isinstance(value, (int, float, bool)) or value is None:
+        return value
+    return redact_text(str(value)[:2000])
+
+
+class AuditLog:
+    def __init__(self, directory: Path):
+        self.directory = Path(directory)
+        self.directory.mkdir(parents=True, exist_ok=True)
+        self._lock = threading.Lock()
+
+    def path_for(self, session_id: str) -> Path:
+        stem = "".join(ch if ch.isalnum() or ch in "-_" else "_" for ch in (session_id or "unknown"))[:80]
+        return self.directory / f"{stem or 'unknown'}.jsonl"
+
+    def append(self, session_id: str, run_id: str, kind: str, payload: Mapping[str, Any],
+               *, do_redact: bool = True) -> None:
+        body = redact(dict(payload)) if do_redact else dict(payload)
+        row = {
+            "ts": time.time(),
+            "session_id": session_id,
+            "run_id": run_id,
+            "type": kind,
+            "payload": body,
+        }
+        line = json.dumps(row, ensure_ascii=False, default=str) + "\n"
+        path = self.path_for(session_id)
+        with self._lock:
+            with path.open("a", encoding="utf-8") as handle:
+                handle.write(line)
+
+    def export(self, session_id: str | None = None, *, redact_output: bool = True) -> list[dict[str, Any]]:
+        paths = [self.path_for(session_id)] if session_id else sorted(self.directory.glob("*.jsonl"))
+        rows: list[dict[str, Any]] = []
+        for path in paths:
+            if not path.is_file():
+                continue
+            with path.open(encoding="utf-8") as handle:
+                for line in handle:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        row = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+                    if redact_output:
+                        row = redact(row)
+                    rows.append(row)
+        return rows