mandri 0.1.0a1__py3-none-any.whl

mandri/adapters/approval/__init__.py

@@ -0,0 +1,9 @@
+from .autopilot import AutopilotApprovalPolicy
+from .manual import ManualApprovalPolicy
+from .yolo import YoloApprovalPolicy
+
+__all__ = [
+    "AutopilotApprovalPolicy",
+    "ManualApprovalPolicy",
+    "YoloApprovalPolicy",
+]

mandri/adapters/approval/autopilot.py

@@ -0,0 +1,150 @@
+import json
+import logging
+
+from mandri.ports.approval import ApprovalDecision
+from mandri.ports.llm import (
+    JsonObjectOutput,
+    LLMProviderPort,
+    LLMRequest,
+    Message,
+    Role,
+    TextPart,
+    ToolCallPart,
+)
+from mandri.prompts.approval import AUTOPILOT_APPROVAL_PROMPT
+
+_logger = logging.getLogger(__name__)
+_SAFE_RISKS = frozenset(("LOW", "MEDIUM"))
+_DECISION_SCHEMA = {
+    "type": "object",
+    "properties": {
+        "tool_call_id": {"type": "string"},
+        "risk": {
+            "type": "string",
+            "enum": ["LOW", "MEDIUM", "HIGH", "UNKNOWN"],
+        },
+        "reason": {"type": "string"},
+    },
+    "required": ["tool_call_id", "risk", "reason"],
+    "additionalProperties": False,
+}
+_VERDICT_SCHEMA = {
+    "type": "object",
+    "properties": {
+        "decisions": {
+            "type": "array",
+            "items": _DECISION_SCHEMA,
+        }
+    },
+    "required": ["decisions"],
+    "additionalProperties": False,
+}
+
+
+class AutopilotApprovalPolicy:
+    def __init__(
+        self,
+        provider: LLMProviderPort,
+        *,
+        model: str,
+    ) -> None:
+        self._provider = provider
+        self._model = model
+
+    async def request(
+        self, calls: tuple[ToolCallPart, ...]
+    ) -> tuple[ApprovalDecision, ...]:
+        if not calls:
+            return ()
+        try:
+            response = await self._provider.generate(self._request(calls))
+            verdicts = _verdicts(response.message, calls)
+        except Exception:
+            _logger.exception(
+                "autopilot approval failed tools=%s",
+                ",".join(call.tool_name for call in calls),
+            )
+            return tuple(
+                ApprovalDecision(
+                    approved=False,
+                    feedback="Autopilot could not assess this tool call",
+                )
+                for _ in calls
+            )
+        return tuple(_decision(risk, reason) for risk, reason in verdicts)
+
+    def _request(self, calls: tuple[ToolCallPart, ...]) -> LLMRequest:
+        payload = json.dumps(
+            {
+                "tool_calls": [
+                    {
+                        "tool_call_id": call.tool_call_id,
+                        "tool": call.tool_name,
+                        "arguments": call.arguments,
+                    }
+                    for call in calls
+                ],
+                "output_format": "json",
+                "output_schema": _VERDICT_SCHEMA,
+            },
+            ensure_ascii=False,
+        )
+        return LLMRequest(
+            model=self._model,
+            messages=(
+                Message(
+                    role=Role.SYSTEM,
+                    parts=(TextPart(text=AUTOPILOT_APPROVAL_PROMPT),),
+                ),
+                Message(role=Role.USER, parts=(TextPart(text=payload),)),
+            ),
+            output=JsonObjectOutput(),
+            max_output_tokens=4096,
+            temperature=0.0,
+        )
+
+
+def _verdicts(
+    message: Message, calls: tuple[ToolCallPart, ...]
+) -> tuple[tuple[str, str], ...]:
+    content = "".join(part.text for part in message.parts if isinstance(part, TextPart))
+    verdict = json.loads(content)
+    if not isinstance(verdict, dict):
+        raise ValueError("autopilot verdict must be an object")
+    decisions = verdict.get("decisions")
+    if not isinstance(decisions, list) or len(decisions) != len(calls):
+        raise ValueError("autopilot verdict count does not match tool calls")
+    by_id = {_decision_id(item): item for item in decisions}
+    if len(by_id) != len(decisions):
+        raise ValueError("autopilot verdict has duplicate tool call ids")
+    return tuple(_risk_reason(by_id.get(call.tool_call_id)) for call in calls)
+
+
+def _decision_id(verdict: object) -> str:
+    if not isinstance(verdict, dict):
+        raise ValueError("autopilot decision must be an object")
+    tool_call_id = verdict.get("tool_call_id")
+    if not isinstance(tool_call_id, str) or not tool_call_id:
+        raise ValueError("autopilot decision has no tool call id")
+    return tool_call_id
+
+
+def _risk_reason(verdict: object) -> tuple[str, str]:
+    if not isinstance(verdict, dict):
+        raise ValueError("autopilot decision must be an object")
+    risk = verdict.get("risk")
+    reason = verdict.get("reason")
+    if risk not in {"LOW", "MEDIUM", "HIGH", "UNKNOWN"}:
+        raise ValueError("autopilot verdict has an invalid risk")
+    if not isinstance(reason, str) or not reason.strip():
+        raise ValueError("autopilot verdict has no reason")
+    return risk, reason.strip()
+
+
+def _decision(risk: str, reason: str) -> ApprovalDecision:
+    if risk in _SAFE_RISKS:
+        return ApprovalDecision(approved=True)
+    return ApprovalDecision(
+        approved=False,
+        feedback=f"Autopilot classified this tool call as {risk}: {reason}",
+    )

mandri/adapters/approval/batcher.py

@@ -0,0 +1,54 @@
+import asyncio
+
+from mandri.ports.approval import ApprovalDecision, ApprovalPolicyPort
+from mandri.ports.llm import ToolCallPart
+
+
+class ApprovalBatcher:
+    def __init__(self, policy: ApprovalPolicyPort) -> None:
+        self._policy = policy
+        self._decisions: dict[str, ApprovalDecision] = {}
+        self._lock = asyncio.Lock()
+
+    def set_policy(self, policy: ApprovalPolicyPort) -> None:
+        self._policy = policy
+
+    async def request(
+        self,
+        call: ToolCallPart,
+        batch: tuple[ToolCallPart, ...] = (),
+    ) -> ApprovalDecision:
+        async with self._lock:
+            cached = self._decisions.pop(call.tool_call_id, None)
+            if cached is not None:
+                return cached
+            calls = self._unresolved(call, batch)
+            decisions = await self._policy.request(calls)
+            if len(decisions) != len(calls):
+                raise ValueError("approval decision count does not match calls")
+            self._decisions.update(
+                (candidate.tool_call_id, decision)
+                for candidate, decision in zip(calls, decisions, strict=True)
+            )
+            decision = self._decisions.pop(call.tool_call_id, None)
+            if decision is None:
+                raise ValueError("approval batch does not contain requested call")
+            return decision
+
+    def discard(self, tool_call_id: str) -> None:
+        self._decisions.pop(tool_call_id, None)
+
+    def clear(self) -> None:
+        self._decisions.clear()
+
+    def _unresolved(
+        self,
+        call: ToolCallPart,
+        batch: tuple[ToolCallPart, ...],
+    ) -> tuple[ToolCallPart, ...]:
+        calls = {
+            candidate.tool_call_id: candidate
+            for candidate in (*batch, call)
+            if candidate.tool_call_id not in self._decisions
+        }
+        return tuple(calls.values())

mandri/adapters/approval/manual.py

@@ -0,0 +1,19 @@
+from collections.abc import Awaitable, Callable
+
+from mandri.ports.approval import ApprovalDecision
+from mandri.ports.llm import ToolCallPart
+
+type ApprovalPrompt = Callable[[ToolCallPart], Awaitable[ApprovalDecision]]
+
+
+class ManualApprovalPolicy:
+    def __init__(self, prompt: ApprovalPrompt) -> None:
+        self._prompt = prompt
+
+    async def request(
+        self, calls: tuple[ToolCallPart, ...]
+    ) -> tuple[ApprovalDecision, ...]:
+        decisions: list[ApprovalDecision] = []
+        for call in calls:
+            decisions.append(await self._prompt(call))
+        return tuple(decisions)

mandri/adapters/approval/yolo.py

@@ -0,0 +1,9 @@
+from mandri.ports.approval import ApprovalDecision
+from mandri.ports.llm import ToolCallPart
+
+
+class YoloApprovalPolicy:
+    async def request(
+        self, calls: tuple[ToolCallPart, ...]
+    ) -> tuple[ApprovalDecision, ...]:
+        return tuple(ApprovalDecision(approved=True) for _ in calls)

mandri/adapters/config/__init__.py

@@ -0,0 +1,3 @@
+from .toml import TomlConfig
+
+__all__ = ["TomlConfig"]

mandri/adapters/config/toml/__init__.py

@@ -0,0 +1,39 @@
+from .decode import (
+    _approval_mode,
+    _model_config,
+    _non_negative_int,
+    _optional_string,
+    _orchestrator,
+    _positive_int,
+    _providers,
+    _required_string,
+    _role,
+    _table,
+    _user_profile,
+    from_toml,
+)
+from .encode import (
+    _serialize_role,
+    to_toml,
+)
+from .store import (
+    TomlConfig,
+)
+
+__all__ = [
+    "TomlConfig",
+    "_approval_mode",
+    "_model_config",
+    "_non_negative_int",
+    "_optional_string",
+    "_orchestrator",
+    "_positive_int",
+    "_providers",
+    "_required_string",
+    "_role",
+    "_serialize_role",
+    "_table",
+    "_user_profile",
+    "from_toml",
+    "to_toml",
+]

mandri/adapters/config/toml/decode.py

@@ -0,0 +1,195 @@
+from typing import Any, Literal, cast
+
+from mandri.ports.approval import ApprovalMode
+from mandri.ports.config import (
+    AgentConfig,
+    ApprovalConfig,
+    AttachmentConfig,
+    BackgroundConfig,
+    MandriConfig,
+    ModelConfig,
+    ModelRole,
+    ProviderConfig,
+    ProviderKind,
+    ToolTimeoutOverride,
+    UserPreferences,
+    UserProfileConfig,
+)
+
+
+def from_toml(data: dict[str, Any]) -> MandriConfig:
+    user_profile = _user_profile(data)
+    attachments = _table(data, "attachments")
+    agents = _table(data, "agents")
+    approval = _table(data, "approval")
+    background = _table(data, "background")
+    tool_timeouts = _table(data, "tool_timeouts")
+    user_preferences = _table(data, "user_preferences")
+    models = _table(data, "models")
+    orchestrator = _orchestrator(data, models)
+    return MandriConfig(
+        orchestrator=orchestrator,
+        judge=_role(models, "judge"),
+        opencode=_role(models, "opencode"),
+        codex=_role(models, "codex"),
+        claude=_role(models, "claude"),
+        user_profile=UserProfileConfig(
+            profile_update_interval=_positive_int(
+                user_profile,
+                "profile_update_interval",
+                5,
+            ),
+            user_profile_char_limit=_positive_int(
+                user_profile,
+                "user_profile_char_limit",
+                1375,
+            ),
+        ),
+        attachments=AttachmentConfig(
+            max_text_file_bytes=_positive_int(
+                attachments, "max_text_file_bytes", 128 * 1024
+            ),
+            max_total_text_bytes=_positive_int(
+                attachments, "max_total_text_bytes", 256 * 1024
+            ),
+        ),
+        agents=AgentConfig(
+            max_output_chars=_positive_int(
+                agents,
+                "max_output_chars",
+                AgentConfig().max_output_chars,
+            )
+        ),
+        approval=ApprovalConfig(mode=_approval_mode(approval)),
+        background=BackgroundConfig(
+            max_concurrent=_positive_int(
+                background,
+                "max_concurrent",
+                BackgroundConfig().max_concurrent,
+            ),
+            default_timeout_seconds=_non_negative_int(
+                background,
+                "default_timeout_seconds",
+                BackgroundConfig().default_timeout_seconds,
+            ),
+        ),
+        tool_timeouts=[
+            ToolTimeoutOverride(
+                tool_name=tool_name,
+                timeout_seconds=_non_negative_int(
+                    tool_timeouts,
+                    tool_name,
+                    ToolTimeoutOverride().timeout_seconds,
+                ),
+            )
+            for tool_name in tool_timeouts
+        ],
+        user_preferences=UserPreferences(
+            prompt=_optional_string(user_preferences, "prompt")
+        ),
+        providers=_providers(data),
+    )
+
+
+def _providers(data: dict[str, Any]) -> tuple[ProviderConfig, ...]:
+    raw = _table(data, "providers")
+    providers: list[ProviderConfig] = []
+    for provider_id, value in raw.items():
+        if not isinstance(value, dict):
+            raise ValueError(f"provider config must be a table: {provider_id}")
+        kind = _required_string(value, "kind", f"providers.{provider_id}")
+        if kind not in {"lmstudio", "openrouter", "opencode", "openai-compatible"}:
+            raise ValueError(f"invalid provider kind: {kind}")
+        providers.append(
+            ProviderConfig(
+                id=provider_id,
+                kind=cast(ProviderKind, kind),
+                name=_optional_string(value, "name"),
+                base_url=_optional_string(value, "base_url"),
+            )
+        )
+    return tuple(providers)
+
+
+def _user_profile(data: dict[str, Any]) -> dict[str, Any]:
+    if "user_profile" in data:
+        return _table(data, "user_profile")
+    return _table(data, "memory")
+
+
+def _table(data: dict[str, Any], key: str) -> dict[str, Any]:
+    value = data.get(key, {})
+    if not isinstance(value, dict):
+        raise ValueError(f"config section must be a table: {key}")
+    return value
+
+
+def _orchestrator(data: dict[str, Any], models: dict[str, Any]) -> ModelConfig:
+    if "orchestrator" in models:
+        config = _role(models, "orchestrator")
+        if config is None:
+            raise ValueError("missing orchestrator config")
+        return config
+    if "model" in data:
+        legacy = _table(data, "model")
+        if not legacy:
+            return ModelConfig()
+        return _model_config(legacy, "model")
+    return ModelConfig()
+
+
+def _role(data: dict[str, Any], role: ModelRole) -> ModelConfig | None:
+    if role not in data:
+        return None
+    return _model_config(_table(data, role), role)
+
+
+def _model_config(
+    data: dict[str, Any], role: ModelRole | Literal["model"]
+) -> ModelConfig:
+    provider = _required_string(data, "provider", role)
+    if provider == "native" and role not in {"codex", "claude"}:
+        raise ValueError(f"native provider is not supported for role: {role}")
+    return ModelConfig(
+        provider=provider,
+        model=_required_string(data, "model", role),
+        reasoning_effort=_optional_string(data, "reasoning_effort"),
+    )
+
+
+def _optional_string(data: dict[str, Any], key: str) -> str | None:
+    value = data.get(key)
+    if value is None:
+        return None
+    if not isinstance(value, str):
+        raise ValueError(f"config value must be a string: {key}")
+    return value or None
+
+
+def _required_string(data: dict[str, Any], key: str, section: str) -> str:
+    value = _optional_string(data, key)
+    if value is None:
+        raise ValueError(f"config value is required: {section}.{key}")
+    return value
+
+
+def _positive_int(data: dict[str, Any], key: str, default: int) -> int:
+    value = data.get(key, default)
+    if not isinstance(value, int) or isinstance(value, bool) or value <= 0:
+        raise ValueError(f"config value must be a positive integer: {key}")
+    return value
+
+
+def _non_negative_int(data: dict[str, Any], key: str, default: int) -> int:
+    value = data.get(key, default)
+    if not isinstance(value, int) or isinstance(value, bool) or value < 0:
+        raise ValueError(f"config value must be a non-negative integer: {key}")
+    return value
+
+
+def _approval_mode(data: dict[str, Any]) -> ApprovalMode:
+    value = _optional_string(data, "mode") or ApprovalMode.MANUAL.value
+    try:
+        return ApprovalMode(value)
+    except ValueError as exc:
+        raise ValueError(f"invalid approval mode: {value}") from exc

mandri/adapters/config/toml/encode.py

@@ -0,0 +1,95 @@
+import json
+
+from mandri.ports.config import (
+    BackgroundConfig,
+    MandriConfig,
+    ModelConfig,
+    ModelRole,
+)
+
+
+def to_toml(config: MandriConfig) -> str:
+    lines: list[str] = []
+    preferences_prompt = config.user_preferences.prompt
+    if preferences_prompt is not None:
+        value = json.dumps(preferences_prompt, ensure_ascii=False)
+        lines.extend(("[user_preferences]", f"prompt = {value}", ""))
+    for provider in config.providers:
+        lines.extend(
+            (
+                f"[providers.{json.dumps(provider.id)}]",
+                f"kind = {json.dumps(provider.kind)}",
+            )
+        )
+        if provider.name is not None:
+            lines.append(f"name = {json.dumps(provider.name, ensure_ascii=False)}")
+        if provider.base_url is not None:
+            lines.append(f"base_url = {json.dumps(provider.base_url)}")
+        lines.append("")
+    for role in ("orchestrator", "judge", "opencode", "codex", "claude"):
+        model = config.configured_role(role)
+        if model is not None:
+            lines.extend(_serialize_role(role, model))
+    lines.extend(
+        (
+            "[user_profile]",
+            (
+                "profile_update_interval = "
+                f"{config.user_profile.profile_update_interval}"
+            ),
+            (
+                "user_profile_char_limit = "
+                f"{config.user_profile.user_profile_char_limit}"
+            ),
+            "",
+            "[attachments]",
+            f"max_text_file_bytes = {config.attachments.max_text_file_bytes}",
+            f"max_total_text_bytes = {config.attachments.max_total_text_bytes}",
+            "",
+            "[agents]",
+            f"max_output_chars = {config.agents.max_output_chars}",
+            "",
+            "[approval]",
+            f"mode = {json.dumps(config.approval.mode.value)}",
+            "",
+        )
+    )
+    if config.background != BackgroundConfig():
+        lines.extend(
+            (
+                "[background]",
+                f"max_concurrent = {config.background.max_concurrent}",
+                (
+                    "default_timeout_seconds = "
+                    f"{config.background.default_timeout_seconds}"
+                ),
+                "",
+            )
+        )
+    if config.tool_timeouts:
+        lines.append("[tool_timeouts]")
+        lines.extend(
+            f"{json.dumps(override.tool_name)} = {override.timeout_seconds}"
+            for override in config.tool_timeouts
+        )
+        lines.append("")
+    return "\n".join(lines)
+
+
+def _serialize_role(role: ModelRole, config: ModelConfig) -> list[str]:
+    if config.provider is None:
+        raise ValueError(f"config value is required: {role}.provider")
+    if config.model is None:
+        raise ValueError(f"config value is required: {role}.model")
+    if config.provider == "native" and role not in {"codex", "claude"}:
+        raise ValueError(f"native provider is not supported for role: {role}")
+    lines = [
+        f"[models.{role}]",
+        f"provider = {json.dumps(config.provider, ensure_ascii=False)}",
+        f"model = {json.dumps(config.model, ensure_ascii=False)}",
+    ]
+    if config.reasoning_effort is not None:
+        value = json.dumps(config.reasoning_effort, ensure_ascii=False)
+        lines.append(f"reasoning_effort = {value}")
+    lines.append("")
+    return lines

mandri/adapters/config/toml/store.py

@@ -0,0 +1,37 @@
+import asyncio
+import tomllib
+from pathlib import Path
+from typing import Any
+
+from mandri.adapters.filesystem import atomic_write_text
+from mandri.ports.config import (
+    MandriConfig,
+)
+
+from .decode import (
+    from_toml,
+)
+from .encode import (
+    to_toml,
+)
+
+
+class TomlConfig:
+    def __init__(self, path: Path) -> None:
+        self._path = path
+        self._lock = asyncio.Lock()
+
+    async def load(self) -> MandriConfig:
+        if not await asyncio.to_thread(self._path.is_file):
+            return MandriConfig()
+        data = await asyncio.to_thread(self._read)
+        return from_toml(data)
+
+    async def save(self, config: MandriConfig) -> None:
+        content = to_toml(config)
+        async with self._lock:
+            await asyncio.to_thread(atomic_write_text, self._path, content)
+
+    def _read(self) -> dict[str, Any]:
+        with self._path.open("rb") as handle:
+            return tomllib.load(handle)

mandri/adapters/credentials/__init__.py

@@ -0,0 +1,4 @@
+from .permissions import credentials_file_is_private
+from .toml import TomlCredentials
+
+__all__ = ["TomlCredentials", "credentials_file_is_private"]

mandri/adapters/credentials/permissions.py

@@ -0,0 +1,26 @@
+import os
+import stat
+from pathlib import Path
+
+if os.name == "nt":
+    from .windows_acl import restrict_windows_file, windows_file_is_private
+else:
+
+    def restrict_windows_file(path: Path) -> None:
+        raise OSError(f"Windows ACLs are unavailable for {path}")
+
+    def windows_file_is_private(path: Path) -> bool:
+        return False
+
+
+def restrict_credentials_file(path: Path) -> None:
+    if os.name == "nt":
+        restrict_windows_file(path)
+        return
+    os.chmod(path, 0o600)
+
+
+def credentials_file_is_private(path: Path) -> bool:
+    if os.name == "nt":
+        return windows_file_is_private(path)
+    return stat.S_IMODE(path.stat().st_mode) == 0o600