cluxion-agentplugin-preprocessing 0.2.0__py3-none-any.whl

cluxion_agentplugin_preprocessing/plugin.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+"""Universal agent plugin entry point (Hermes, Claude, Codex, Grok Build)."""
+
+import json
+from typing import TYPE_CHECKING
+
+from cluxion_agentplugin_preprocessing import runner
+from cluxion_agentplugin_preprocessing.schemas import (
+    BOOTSTRAP_SCHEMA,
+    CLARIFY_SCHEMA,
+    HERMES_CONFIG_SCHEMA,
+    PLAN_SCHEMA,
+    QUEUE_BRIEF_SCHEMA,
+    QUEUE_NEXT_SCHEMA,
+    QUEUE_RECORD_SCHEMA,
+    SERVE_LOCAL_SCHEMA,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+def register(ctx: object) -> None:
+    """Register Cluxion preprocessing tools with the host agent."""
+    ctx.register_tool(
+        name="cluxion_plan",
+        toolset="cluxion",
+        schema=PLAN_SCHEMA,
+        handler=_handle_plan,
+        check_fn=_check_runtime_available,
+        emoji="🧭",
+    )
+    ctx.register_tool(
+        name="cluxion_clarify",
+        toolset="cluxion",
+        schema=CLARIFY_SCHEMA,
+        handler=_handle_clarify,
+        check_fn=_check_runtime_available,
+        emoji="❓",
+    )
+    ctx.register_tool(
+        name="cluxion_bootstrap",
+        toolset="cluxion",
+        schema=BOOTSTRAP_SCHEMA,
+        handler=_handle_bootstrap,
+        check_fn=_check_runtime_available,
+        emoji="🔧",
+    )
+    ctx.register_tool(
+        name="cluxion_serve_local",
+        toolset="cluxion",
+        schema=SERVE_LOCAL_SCHEMA,
+        handler=_handle_serve_local,
+        check_fn=_check_runtime_available,
+        emoji="🖥️",
+    )
+    ctx.register_tool(
+        name="cluxion_hermes_config",
+        toolset="cluxion",
+        schema=HERMES_CONFIG_SCHEMA,
+        handler=_handle_hermes_config,
+        check_fn=_check_runtime_available,
+        emoji="🔌",
+    )
+    ctx.register_tool(
+        name="cluxion_queue_next",
+        toolset="cluxion",
+        schema=QUEUE_NEXT_SCHEMA,
+        handler=_handle_queue_next,
+        check_fn=_check_runtime_available,
+        emoji="➡️",
+    )
+    ctx.register_tool(
+        name="cluxion_queue_record",
+        toolset="cluxion",
+        schema=QUEUE_RECORD_SCHEMA,
+        handler=_handle_queue_record,
+        check_fn=_check_runtime_available,
+        emoji="🧾",
+    )
+    ctx.register_tool(
+        name="cluxion_queue_brief",
+        toolset="cluxion",
+        schema=QUEUE_BRIEF_SCHEMA,
+        handler=_handle_queue_brief,
+        check_fn=_check_runtime_available,
+        emoji="📌",
+    )
+
+
+def _check_runtime_available() -> bool:
+    return runner.runtime_available()
+
+
+def _handle_plan(args: dict[str, object], **_: object) -> str:
+    return _json_result(lambda: runner.plan(args).to_json())
+
+
+def _handle_clarify(args: dict[str, object], **_: object) -> str:
+    return _json_result(lambda: runner.plan(args).to_json())
+
+
+def _handle_bootstrap(args: dict[str, object], **_: object) -> str:
+    return _json_result(lambda: runner.bootstrap(args).to_json())
+
+
+def _handle_serve_local(args: dict[str, object], **_: object) -> str:
+    return _json_result(lambda: runner.serve_local(args).to_json())
+
+
+def _handle_hermes_config(args: dict[str, object], **_: object) -> str:
+    return _json_result(lambda: runner.hermes_config(args).to_json())
+
+
+def _handle_queue_next(args: dict[str, object], **_: object) -> str:
+    return _json_result(lambda: runner.queue_next(args).to_json())
+
+
+def _handle_queue_record(args: dict[str, object], **_: object) -> str:
+    return _json_result(lambda: runner.queue_record(args).to_json())
+
+
+def _handle_queue_brief(args: dict[str, object], **_: object) -> str:
+    return _json_result(lambda: runner.queue_brief(args).to_json())
+
+
+def _json_result(callback: Callable[[], str]) -> str:
+    try:
+        return callback()
+    except ValueError as exc:
+        return json.dumps({"ok": False, "error": str(exc)}, ensure_ascii=False, sort_keys=True)
+
+
+__all__ = ["register"]

cluxion_agentplugin_preprocessing/plugin.yaml

@@ -0,0 +1,13 @@
+name: hermes-cluxion
+version: 0.1.9
+description: "Universal agent preprocessing plugin: honesty contracts, clarification, Rust work queue, resource-aware harness handoff. Connected AI calls cluxion tools; plugin does not own models."
+author: cluxion
+kind: standalone
+provides_tools:
+  - cluxion_bootstrap
+  - cluxion_plan
+  - cluxion_serve_local
+  - cluxion_hermes_config
+  - cluxion_queue_next
+  - cluxion_queue_record
+  - cluxion_queue_brief

cluxion_agentplugin_preprocessing/runner.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+"""Subprocess bridge to an installed cluxion-runtime command."""
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+from contextlib import redirect_stderr, redirect_stdout
+from dataclasses import dataclass
+from io import StringIO
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Mapping, Sequence
+
+    CommandRunner = Callable[[Sequence[str], str | None], subprocess.CompletedProcess[str]]
+
+
+@dataclass(frozen=True)
+class RuntimeResult:
+    """Normalized result returned to Hermes tools."""
+
+    ok: bool
+    command: tuple[str, ...]
+    payload: dict[str, object]
+
+    def to_json(self) -> str:
+        """Return a Hermes tool-compatible JSON string."""
+        return json.dumps({"ok": self.ok, "command": list(self.command), **self.payload}, ensure_ascii=False, sort_keys=True)
+
+
+def runtime_available(binary: str | None = None) -> bool:
+    """Check whether cluxion-runtime is visible to Hermes."""
+    configured_binary = binary or os.environ.get("CLUXION_RUNTIME_BIN")
+    if configured_binary:
+        return shutil.which(configured_binary) is not None
+    return shutil.which("cluxion-runtime") is not None or _runtime_module_available()
+
+
+def plan(payload: Mapping[str, object], *, command_runner: CommandRunner | None = None) -> RuntimeResult:
+    """Run cluxion-runtime plan for a Hermes task."""
+    command = (_runtime_binary(None), "plan", "--json-stdin", "--surface", "hermes")
+    stdin = json.dumps(dict(payload), ensure_ascii=False)
+    return _execute_json(command, stdin, command_runner or _run_command)
+
+
+def bootstrap(payload: Mapping[str, object], *, command_runner: CommandRunner | None = None) -> RuntimeResult:
+    """Run cluxion-runtime bootstrap for local dependencies."""
+    command = [_runtime_binary(None), "bootstrap"]
+    if bool(payload.get("upgrade", False)):
+        command.append("--upgrade")
+    if bool(payload.get("dry_run", False)):
+        command.append("--dry-run")
+    packages = payload.get("packages", [])
+    if isinstance(packages, list):
+        for package in packages:
+            command.extend(("--package", str(package)))
+    return _execute_json(tuple(command), None, command_runner or _run_command)
+
+
+def serve_local(payload: Mapping[str, object], *, command_runner: CommandRunner | None = None) -> RuntimeResult:
+    """Run cluxion-runtime serve-local with dry-run by default."""
+    model = _required_str(payload, "model")
+    command = [
+        _runtime_binary(None),
+        "serve-local",
+        "--model",
+        model,
+        "--host",
+        _str(payload, "host", "127.0.0.1"),
+        "--port",
+        str(_int(payload, "port", 23003)),
+        "--max-tokens",
+        str(_int(payload, "max_tokens", 128_000)),
+    ]
+    if not bool(payload.get("auto_install", True)):
+        command.append("--no-auto-install")
+    if bool(payload.get("upgrade_runtime", False)):
+        command.append("--upgrade-runtime")
+    if not bool(payload.get("start", False)):
+        command.append("--dry-run")
+    return _execute_json(tuple(command), None, command_runner or _run_command)
+
+
+def hermes_config(payload: Mapping[str, object], *, command_runner: CommandRunner | None = None) -> RuntimeResult:
+    """Render Hermes config patch for a local endpoint."""
+    model = _required_str(payload, "model")
+    command = (
+        _runtime_binary(None),
+        "hermes-local-config",
+        "--model",
+        model,
+        "--host",
+        _str(payload, "host", "127.0.0.1"),
+        "--port",
+        str(_int(payload, "port", 23003)),
+        "--context-length",
+        str(_int(payload, "context_length", 131_072)),
+        "--provider-key",
+        _str(payload, "provider_key", "cluxion-local"),
+        "--display-name",
+        _str(payload, "display_name", "Cluxion Local"),
+    )
+    return _execute_json(command, None, command_runner or _run_command)
+
+
+def queue_next(payload: Mapping[str, object], *, command_runner: CommandRunner | None = None) -> RuntimeResult:
+    """Return the next queued segment for Hermes model execution."""
+    command = (_runtime_binary(None), "queue-next", "--work-id", _required_str(payload, "work_id"))
+    return _execute_json(command, None, command_runner or _run_command)
+
+
+def queue_record(payload: Mapping[str, object], *, command_runner: CommandRunner | None = None) -> RuntimeResult:
+    """Record the current Hermes model's result for a queued segment."""
+    command = (
+        _runtime_binary(None),
+        "queue-record",
+        "--work-id",
+        _required_str(payload, "work_id"),
+        "--step-id",
+        _required_str(payload, "step_id"),
+        "--json-stdin",
+    )
+    stdin = json.dumps(
+        {
+            "result": str(payload.get("result", "")),
+            "error": str(payload.get("error", "")),
+            "failed": bool(payload.get("failed", False)),
+        },
+        ensure_ascii=False,
+    )
+    return _execute_json(command, stdin, command_runner or _run_command)
+
+
+def queue_brief(payload: Mapping[str, object], *, command_runner: CommandRunner | None = None) -> RuntimeResult:
+    """Build the final briefing prompt from recorded queued segment results."""
+    command = (_runtime_binary(None), "queue-brief", "--work-id", _required_str(payload, "work_id"))
+    return _execute_json(command, None, command_runner or _run_command)
+
+
+def _execute_json(command: Sequence[str], stdin: str | None, command_runner: CommandRunner) -> RuntimeResult:
+    if shutil.which(command[0]) is None and not _can_run_inprocess(command[0]):
+        return RuntimeResult(False, tuple(command), {"error": "cluxion-runtime not found in PATH"})
+    try:
+        if shutil.which(command[0]) is None:
+            completed = _run_inprocess(command, stdin)
+        else:
+            completed = command_runner(command, stdin)
+    except OSError as exc:
+        return RuntimeResult(False, tuple(command), {"error": str(exc)})
+    if completed.returncode != 0:
+        return RuntimeResult(
+            False,
+            tuple(command),
+            {"error": "cluxion-runtime failed", "stderr": completed.stderr.strip(), "returncode": completed.returncode},
+        )
+    try:
+        parsed = json.loads(completed.stdout)
+    except json.JSONDecodeError as exc:
+        return RuntimeResult(False, tuple(command), {"error": f"invalid JSON from cluxion-runtime: {exc}"})
+    if not isinstance(parsed, dict):
+        return RuntimeResult(False, tuple(command), {"error": "cluxion-runtime returned non-object JSON"})
+    return RuntimeResult(True, tuple(command), {"result": parsed})
+
+
+def _run_command(command: Sequence[str], stdin: str | None) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        list(command),
+        input=stdin,
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+
+
+def _run_inprocess(command: Sequence[str], stdin: str | None) -> subprocess.CompletedProcess[str]:
+    from cluxion_runtime.cli import main as runtime_main
+
+    old_stdin = sys.stdin
+    stdout = StringIO()
+    stderr = StringIO()
+    try:
+        sys.stdin = StringIO(stdin or "")
+        with redirect_stdout(stdout), redirect_stderr(stderr):
+            returncode = runtime_main(list(command[1:]))
+    except Exception as exc:
+        return subprocess.CompletedProcess(list(command), 1, stdout=stdout.getvalue(), stderr=str(exc))
+    finally:
+        sys.stdin = old_stdin
+    return subprocess.CompletedProcess(list(command), int(returncode), stdout=stdout.getvalue(), stderr=stderr.getvalue())
+
+
+def _runtime_binary(binary: str | None) -> str:
+    return binary or os.environ.get("CLUXION_RUNTIME_BIN", "cluxion-runtime")
+
+
+def _runtime_module_available() -> bool:
+    try:
+        import cluxion_runtime.cli
+    except ImportError:
+        return False
+    return cluxion_runtime.cli is not None
+
+
+def _can_run_inprocess(binary: str) -> bool:
+    return binary == "cluxion-runtime" and "CLUXION_RUNTIME_BIN" not in os.environ and _runtime_module_available()
+
+
+def _required_str(payload: Mapping[str, object], key: str) -> str:
+    value = str(payload.get(key, "")).strip()
+    if not value:
+        raise ValueError(f"{key} is required")
+    return value
+
+
+def _str(payload: Mapping[str, object], key: str, default: str) -> str:
+    value = str(payload.get(key, default)).strip()
+    return value or default
+
+
+def _int(payload: Mapping[str, object], key: str, default: int) -> int:
+    try:
+        value = int(payload.get(key, default))
+    except (TypeError, ValueError):
+        return default
+    return value if value > 0 else default
+
+
+__all__ = [
+    "RuntimeResult",
+    "bootstrap",
+    "hermes_config",
+    "plan",
+    "queue_brief",
+    "queue_next",
+    "queue_record",
+    "runtime_available",
+    "serve_local",
+]

cluxion_agentplugin_preprocessing/schemas.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+"""Hermes tool schemas exposed by the Cluxion plugin."""
+
+BOOTSTRAP_SCHEMA = {
+    "name": "cluxion_bootstrap",
+    "description": "Install or upgrade local runtime dependencies such as vllm-mlx.",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "upgrade": {"type": "boolean", "default": False},
+            "dry_run": {"type": "boolean", "default": False},
+            "packages": {
+                "type": "array",
+                "items": {"type": "string"},
+                "default": ["vllm-mlx"],
+            },
+        },
+    },
+}
+
+CLARIFY_SCHEMA = {
+    "name": "cluxion_clarify",
+    "description": "Assess whether user direction is clear. Ask blocking questions before queueing work.",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "prompt": {"type": "string", "description": "Task prompt to assess."},
+            "clarification_answers": {"type": "string", "default": ""},
+            "cwd": {"type": "string", "default": ""},
+        },
+        "required": ["prompt"],
+    },
+}
+
+PLAN_SCHEMA = {
+    "name": "cluxion_plan",
+    "description": "Plan a task through Cluxion honesty preprocessing, clarification, Rust queue, answer policy, and resource admission.",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "prompt": {"type": "string", "description": "Task prompt to plan."},
+            "priority": {
+                "type": "string",
+                "enum": ["critical", "high", "normal", "low"],
+                "default": "normal",
+            },
+            "model_route": {
+                "type": "string",
+                "default": "host/default",
+                "description": "Use host/default unless an explicit local route is requested.",
+            },
+            "expected_ram_mb": {"type": "integer", "minimum": 0, "default": 0},
+            "context_tokens": {"type": "integer", "minimum": 0, "default": 0},
+            "cwd": {"type": "string", "default": ""},
+        },
+        "required": ["prompt"],
+    },
+}
+
+SERVE_LOCAL_SCHEMA = {
+    "name": "cluxion_serve_local",
+    "description": "Prepare or start a Cluxion-managed vLLM-MLX local model endpoint.",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "model": {"type": "string", "description": "Local model id, usually an mlx-community model."},
+            "host": {"type": "string", "default": "127.0.0.1"},
+            "port": {"type": "integer", "minimum": 1, "maximum": 65535, "default": 23003},
+            "max_tokens": {"type": "integer", "minimum": 1, "default": 128000},
+            "auto_install": {"type": "boolean", "default": True},
+            "upgrade_runtime": {"type": "boolean", "default": False},
+            "start": {
+                "type": "boolean",
+                "default": False,
+                "description": "False returns the command without starting the heavy model server.",
+            },
+        },
+        "required": ["model"],
+    },
+}
+
+HERMES_CONFIG_SCHEMA = {
+    "name": "cluxion_hermes_config",
+    "description": "Render Hermes custom provider config for a Cluxion local OpenAI-compatible endpoint.",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "model": {"type": "string", "description": "Local model id."},
+            "host": {"type": "string", "default": "127.0.0.1"},
+            "port": {"type": "integer", "minimum": 1, "maximum": 65535, "default": 23003},
+            "context_length": {"type": "integer", "minimum": 1, "default": 131072},
+            "provider_key": {"type": "string", "default": "cluxion-local"},
+            "display_name": {"type": "string", "default": "Cluxion Local"},
+        },
+        "required": ["model"],
+    },
+}
+
+QUEUE_NEXT_SCHEMA = {
+    "name": "cluxion_queue_next",
+    "description": "Fetch the next queued Cluxion segment so the current Hermes model can process it.",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "work_id": {"type": "string"},
+        },
+        "required": ["work_id"],
+    },
+}
+
+QUEUE_RECORD_SCHEMA = {
+    "name": "cluxion_queue_record",
+    "description": "Record the current Hermes model's result for a queued Cluxion segment.",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "work_id": {"type": "string"},
+            "step_id": {"type": "string"},
+            "result": {"type": "string"},
+            "error": {"type": "string", "default": ""},
+            "failed": {"type": "boolean", "default": False},
+        },
+        "required": ["work_id", "step_id", "result"],
+    },
+}
+
+QUEUE_BRIEF_SCHEMA = {
+    "name": "cluxion_queue_brief",
+    "description": "Build a final briefing prompt after all queued Cluxion segment results are recorded.",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "work_id": {"type": "string"},
+        },
+        "required": ["work_id"],
+    },
+}
+
+__all__ = [
+    "BOOTSTRAP_SCHEMA",
+    "HERMES_CONFIG_SCHEMA",
+    "PLAN_SCHEMA",
+    "QUEUE_BRIEF_SCHEMA",
+    "QUEUE_NEXT_SCHEMA",
+    "QUEUE_RECORD_SCHEMA",
+    "SERVE_LOCAL_SCHEMA",
+]

cluxion_agentplugin_preprocessing-0.2.0.dist-info/METADATA

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: cluxion-agentplugin-preprocessing
+Version: 0.2.0
+Summary: Universal agent plugin for Cluxion preprocessing, honesty contracts, clarification, Rust work queue, and resource-aware harness handoff.
+Project-URL: Homepage, https://github.com/cluxion/cluxion-Agentplugin-preprocessing
+Project-URL: Repository, https://github.com/cluxion/cluxion-Agentplugin-preprocessing
+Project-URL: Issues, https://github.com/cluxion/cluxion-Agentplugin-preprocessing/issues
+Author-email: cluxion <algocean1204@users.noreply.github.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: ai-agent,claude-code,cluxion,codex,hermes-agent,plugin,preprocessing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Plugins
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Requires-Dist: psutil>=5.9
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'
+Requires-Dist: twine>=6.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# cluxion-Agentplugin-preprocessing
+
+범용 에이전트 **전처리 플러그인** — **Hermes, Claude Code, Codex, Grok Build**에서 동일 core로 동작합니다.
+
+**Repository:** https://github.com/cluxion/cluxion-Agentplugin-preprocessing
+
+## 한 줄 요약
+
+작업 시작 전에 **방향·정직함·큐**를 정리합니다. **연결된 AI**가 `cluxion_plan` 등 도구를 호출하고, JSON 계약(`answer_policy`, `host_execution`)에 따라 응답합니다. 플러그인은 추가 LLM 호출 없이 결정론적 plan만 반환합니다.
+
+## 범용 에이전트 + Rust-First
+
+| 계층 | 구현 |
+|------|------|
+| **Rust** (`cluxion-queue`) | SQLite 작업큐, atomic dispatch |
+| **Python** (`cluxion_runtime`, adapter) | harness plan, 전처리, CLI |
+| **Agent adapter** | `adapters/` — Hermes plugin, Claude skill, Codex snippet |
+
+내부 hot path는 **Rust**. Python은 등록·JSON bridge·fallback입니다.
+
+## 이 플러그인의 역할
+
+- **정직함**: context 부족 시 모른다고 답하도록 `answer_policy` 생성
+- **명확화**: 의도가 애매하면 큐 진입 전 질문 (`needs_clarification`)
+- **작업큐**: 긴 입력을 segment로 분할, checksum 보존
+- **리소스 admission**: RAM/CPU 압력에 따른 실행 허용 (결정론적)
+
+**모델·OAuth·provider는 host agent 소유.** Cluxion은 plan·게이트·큐 메타데이터만 반환합니다.
+
+## 연결된 AI가 하는 일
+
+| 단계 | 동작 |
+|------|------|
+| 요청 수신 | `cluxion_plan` 또는 `cluxion-runtime plan` |
+| 명확화 필요 | `clarification.questions`로 사용자에게 질문 |
+| queued 모드 | `cluxion_queue_next` → 처리 → `cluxion_queue_record` → `cluxion_queue_brief` |
+| 응답 | `answer_policy.required_checks` 준수 |
+
+## 설계 요약
+
+```
+User prompt → cluxion_plan → [clarification?] → preprocessing mode
+           → answer_policy + host_execution
+           → (queued) queue_next/record/brief
+```
+
+**설계 원칙**
+
+1. **추가 AI preflight 없음** — 결정론적 plan
+2. 짧은 일반 질문은 `simple_answer` fast path
+3. 불확실 시 fake success 금지 — `needs_clarification`, `unknown_after_check`
+4. **opt-in** — 사용자 동의 없이 권한 확대 없음
+
+## 빠른 시작
+
+```bash
+pip install cluxion-agentplugin-preprocessing
+cluxion-preprocess check
+cluxion-preprocess enable    # Hermes
+```
+
+```bash
+cluxion-runtime plan --surface hermes --prompt "작업 설명"
+```
+
+## 도구 (`cluxion` toolset)
+
+| Tool | 설명 |
+|------|------|
+| `cluxion_plan` | 전처리·방향·큐·리소스 계획 |
+| `cluxion_clarify` | 명확화 질문 목록 |
+| `cluxion_queue_next` / `record` / `brief` | segment 큐 |
+
+## 문서
+
+- [Docs/README.md](Docs/README.md) — **처음 읽는 분** + 목차
+- [Docs/architecture.md](Docs/architecture.md)
+- [Docs/design.md](Docs/design.md)
+- [Docs/installation.md](Docs/installation.md)
+- [Docs/tools.md](Docs/tools.md)
+- [Docs/agent-surfaces.md](Docs/agent-surfaces.md)
+- [Docs/rust-architecture.md](Docs/rust-architecture.md)
+
+## License
+
+Apache-2.0