windcode 0.1.0__py3-none-any.whl

windcode/policy/engine.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+import re
+
+from windcode.config.models import PermissionMode
+from windcode.domain.tools import ToolEffect
+from windcode.policy.models import (
+    ApprovalChoice,
+    PolicyAction,
+    PolicyDecision,
+    PolicyRequest,
+    RiskLevel,
+)
+
+_DANGEROUS_COMMAND = re.compile(
+    r"(?:^|[;&|]\s*)(?:sudo\b|rm\s+-[^\n]*r[^\n]*f|mkfs\b|dd\s+if=|shutdown\b|reboot\b)"
+)
+
+
+def assess_risk(request: PolicyRequest) -> RiskLevel:
+    if ToolEffect.OUTSIDE_WORKSPACE in request.effects:
+        return RiskLevel.CRITICAL
+    if request.command and _DANGEROUS_COMMAND.search(request.command):
+        return RiskLevel.CRITICAL
+    if ToolEffect.NETWORK in request.effects:
+        return RiskLevel.HIGH
+    if ToolEffect.PROCESS in request.effects:
+        return RiskLevel.MEDIUM
+    return RiskLevel.LOW
+
+
+def _approval(reason: str, risk: RiskLevel) -> PolicyDecision:
+    return PolicyDecision(
+        action=PolicyAction.ASK,
+        risk=risk,
+        reason=reason,
+        choices=(
+            ApprovalChoice.ALLOW_ONCE,
+            ApprovalChoice.ALLOW_SESSION,
+            ApprovalChoice.DENY,
+        ),
+    )
+
+
+class PolicyEngine:
+    def __init__(
+        self,
+        mode: PermissionMode,
+        *,
+        sandbox_enabled: bool = True,
+        sandbox_available: bool = True,
+    ) -> None:
+        self.mode = mode
+        self.sandbox_enabled = sandbox_enabled
+        self.sandbox_available = sandbox_available
+        self._session_approvals: set[tuple[str, frozenset[ToolEffect]]] = set()
+
+    @staticmethod
+    def _fingerprint(request: PolicyRequest) -> tuple[str, frozenset[ToolEffect]]:
+        return request.tool_name, request.effects
+
+    def approve_for_session(self, request: PolicyRequest) -> None:
+        self._session_approvals.add(self._fingerprint(request))
+
+    def restore_session_approval(
+        self,
+        tool_name: str,
+        effects: frozenset[ToolEffect],
+    ) -> None:
+        self._session_approvals.add((tool_name, effects))
+
+    def set_mode(self, mode: PermissionMode) -> None:
+        self.mode = mode
+
+    def evaluate(self, request: PolicyRequest) -> PolicyDecision:
+        risk = assess_risk(request)
+        effects = request.effects
+        side_effects = {
+            ToolEffect.WORKSPACE_WRITE,
+            ToolEffect.PROCESS,
+            ToolEffect.NETWORK,
+            ToolEffect.OUTSIDE_WORKSPACE,
+        }
+        if self.mode is PermissionMode.PLAN:
+            if effects & side_effects:
+                return PolicyDecision(
+                    action=PolicyAction.DENY,
+                    risk=risk,
+                    reason="plan mode does not permit side effects",
+                )
+            return PolicyDecision(
+                action=PolicyAction.ALLOW,
+                risk=risk,
+                reason="plan mode permits reading and user interaction",
+            )
+
+        if self._fingerprint(request) in self._session_approvals:
+            return PolicyDecision(
+                action=PolicyAction.ALLOW,
+                risk=risk,
+                reason="matching operation was approved for this session",
+            )
+
+        sandbox_degraded = (
+            ToolEffect.PROCESS in effects and self.sandbox_enabled and not self.sandbox_available
+        )
+        if sandbox_degraded:
+            return _approval("system sandbox is unavailable; explicit approval is required", risk)
+
+        if self.mode is PermissionMode.DEFAULT:
+            if effects & side_effects:
+                return _approval("default mode requires approval for side effects", risk)
+            return PolicyDecision(
+                action=PolicyAction.ALLOW,
+                risk=risk,
+                reason="read-only operation is allowed",
+            )
+
+        if self.mode is PermissionMode.ACCEPT_EDITS:
+            disallowed = effects & {
+                ToolEffect.PROCESS,
+                ToolEffect.NETWORK,
+                ToolEffect.OUTSIDE_WORKSPACE,
+            }
+            if disallowed or risk is RiskLevel.CRITICAL:
+                return _approval("operation exceeds automatic workspace edit permission", risk)
+            return PolicyDecision(
+                action=PolicyAction.ALLOW,
+                risk=risk,
+                reason="workspace edits are allowed in accept_edits mode",
+            )
+
+        return PolicyDecision(
+            action=PolicyAction.ALLOW,
+            risk=risk,
+            reason="full_access mode was explicitly selected",
+        )

windcode/policy/models.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from enum import StrEnum
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from windcode.config.models import PermissionMode
+from windcode.domain.tools import ToolEffect
+
+
+class PolicyModel(BaseModel):
+    model_config = ConfigDict(extra="forbid", frozen=True)
+
+
+class RiskLevel(StrEnum):
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+    CRITICAL = "critical"
+
+
+class PolicyAction(StrEnum):
+    ALLOW = "allow"
+    DENY = "deny"
+    ASK = "ask"
+
+
+class ApprovalChoice(StrEnum):
+    ALLOW_ONCE = "allow_once"
+    ALLOW_SESSION = "allow_session"
+    DENY = "deny"
+
+
+class PolicyRequest(PolicyModel):
+    request_id: str = Field(min_length=1)
+    call_id: str = Field(min_length=1)
+    tool_name: str = Field(min_length=1)
+    effects: frozenset[ToolEffect]
+    summary: str = Field(min_length=1)
+    path: str | None = None
+    command: str | None = None
+
+
+class PolicyDecision(PolicyModel):
+    action: PolicyAction
+    risk: RiskLevel
+    reason: str
+    choices: tuple[ApprovalChoice, ...] = ()
+
+
+def summarize_policy_arguments(request: PolicyRequest, *, limit: int = 200) -> str | None:
+    value = request.command or request.path
+    if value is None:
+        return None
+    summary = " ".join(value.split())
+    if len(summary) <= limit:
+        return summary
+    return summary[: limit - 3].rstrip() + "..."
+
+
+__all__ = [
+    "ApprovalChoice",
+    "PermissionMode",
+    "PolicyAction",
+    "PolicyDecision",
+    "PolicyRequest",
+    "RiskLevel",
+    "summarize_policy_arguments",
+]

windcode/providers/__init__.py

@@ -0,0 +1,29 @@
+from windcode.providers.anthropic import AnthropicTransport
+from windcode.providers.base import BaseTransport, ModelTransport
+from windcode.providers.catalog import PROVIDER_PRESETS, ProviderPreset, provider_preset
+from windcode.providers.errors import ProviderError, map_provider_error
+from windcode.providers.openai_compat import OpenAICompatibleTransport
+from windcode.providers.openai_responses import OpenAIResponsesTransport
+from windcode.providers.registry import (
+    ModelTarget,
+    ProviderConfigurationError,
+    TransportRegistry,
+    create_transport,
+)
+
+__all__ = [
+    "PROVIDER_PRESETS",
+    "AnthropicTransport",
+    "BaseTransport",
+    "ModelTarget",
+    "ModelTransport",
+    "OpenAICompatibleTransport",
+    "OpenAIResponsesTransport",
+    "ProviderConfigurationError",
+    "ProviderError",
+    "ProviderPreset",
+    "TransportRegistry",
+    "create_transport",
+    "map_provider_error",
+    "provider_preset",
+]

windcode/providers/_utils.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import cast
+
+
+def get_value(value: object, name: str, default: object = None) -> object:
+    if isinstance(value, Mapping):
+        mapping = cast(Mapping[object, object], value)
+        return mapping.get(name, default)
+    return getattr(value, name, default)
+
+
+def as_string(value: object, default: str = "") -> str:
+    return value if isinstance(value, str) else default
+
+
+def as_int(value: object, default: int = 0) -> int:
+    return value if isinstance(value, int) and not isinstance(value, bool) else default

windcode/providers/anthropic.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+import json
+from collections.abc import AsyncIterator, Callable
+from typing import cast
+
+from anthropic import AsyncAnthropic, DefaultAioHttpClient
+from anthropic.types import MessageParam, ToolUnionParam
+
+from windcode.domain.messages import (
+    AttachmentBlock,
+    Message,
+    ReasoningBlock,
+    Role,
+    TextBlock,
+    ToolCallBlock,
+    ToolResultBlock,
+)
+from windcode.domain.models import (
+    ModelCompleted,
+    ModelEvent,
+    ModelRequest,
+    ModelUsage,
+    ReasoningDelta,
+    StopReason,
+    TextDelta,
+    ToolCallDelta,
+    Usage,
+)
+from windcode.providers._utils import as_int, as_string, get_value
+from windcode.providers.base import BaseTransport
+from windcode.providers.errors import map_provider_error
+
+RawStreamFactory = Callable[[ModelRequest], AsyncIterator[object]]
+
+
+def _content_block(block: object) -> dict[str, object]:
+    if isinstance(block, TextBlock):
+        return {"type": "text", "text": block.text}
+    if isinstance(block, ReasoningBlock):
+        return {"type": "text", "text": block.summary}
+    if isinstance(block, ToolCallBlock):
+        return {
+            "type": "tool_use",
+            "id": block.call_id,
+            "name": block.name,
+            "input": block.arguments,
+        }
+    if isinstance(block, ToolResultBlock):
+        return {
+            "type": "tool_result",
+            "tool_use_id": block.call_id,
+            "content": block.content,
+            "is_error": block.is_error,
+        }
+    if isinstance(block, AttachmentBlock):
+        return {
+            "type": "text",
+            "text": f"[attachment: {block.description or block.reference}]",
+        }
+    raise TypeError(f"unsupported content block: {type(block).__name__}")
+
+
+def build_anthropic_messages(messages: tuple[Message, ...]) -> list[MessageParam]:
+    converted: list[MessageParam] = []
+    for message in messages:
+        if message.role is Role.SYSTEM:
+            continue
+        role = "assistant" if message.role is Role.ASSISTANT else "user"
+        converted.append(
+            cast(
+                MessageParam,
+                {"role": role, "content": [_content_block(block) for block in message.content]},
+            )
+        )
+    return converted
+
+
+def build_anthropic_tools(request: ModelRequest) -> list[ToolUnionParam]:
+    return [
+        cast(
+            ToolUnionParam,
+            {
+                "name": tool.name,
+                "description": tool.description,
+                "input_schema": tool.parameters,
+            },
+        )
+        for tool in request.tools
+    ]
+
+
+def _stop_reason(value: object) -> StopReason:
+    raw = as_string(value)
+    return {
+        "end_turn": StopReason.STOP,
+        "stop_sequence": StopReason.STOP,
+        "tool_use": StopReason.TOOL_USE,
+        "max_tokens": StopReason.MAX_TOKENS,
+        "refusal": StopReason.CONTENT_FILTER,
+    }.get(raw, StopReason.STOP)
+
+
+class AnthropicTransport(BaseTransport):
+    name = "anthropic_messages"
+
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        base_url: str | None = None,
+        stream_factory: RawStreamFactory | None = None,
+    ) -> None:
+        super().__init__()
+        self._client: AsyncAnthropic | None = None
+        if stream_factory is None:
+            http_client = DefaultAioHttpClient()
+            self._client = AsyncAnthropic(
+                api_key=api_key,
+                base_url=base_url,
+                max_retries=0,
+                http_client=http_client,
+            )
+            self.add_close_callback(self._client.close)
+            self._stream_factory = self._sdk_stream
+        else:
+            self._stream_factory = stream_factory
+
+    async def _sdk_stream(self, request: ModelRequest) -> AsyncIterator[object]:
+        if self._client is None:
+            raise RuntimeError("Anthropic client is not configured")
+        stream = await self._client.messages.create(
+            model=request.model,
+            messages=build_anthropic_messages(request.messages),
+            system=request.system_prompt,
+            tools=build_anthropic_tools(request),
+            max_tokens=request.max_output_tokens or 4096,
+            stream=True,
+        )
+        async for event in stream:
+            yield event
+
+    def _convert_event(self, event: object, usage: Usage) -> tuple[list[ModelEvent], Usage, bool]:
+        event_type = as_string(get_value(event, "type"))
+        emitted: list[ModelEvent] = []
+        completed = False
+        if event_type == "message_start":
+            raw_usage = get_value(get_value(event, "message"), "usage")
+            usage = Usage(
+                input_tokens=as_int(get_value(raw_usage, "input_tokens")),
+                output_tokens=usage.output_tokens,
+                cache_read_tokens=as_int(get_value(raw_usage, "cache_read_input_tokens")),
+                cache_write_tokens=as_int(get_value(raw_usage, "cache_creation_input_tokens")),
+            )
+            emitted.append(ModelUsage(usage))
+        elif event_type == "content_block_start":
+            block = get_value(event, "content_block")
+            if as_string(get_value(block, "type")) == "tool_use":
+                initial = get_value(block, "input", {})
+                arguments = "" if initial == {} else json.dumps(initial, separators=(",", ":"))
+                emitted.append(
+                    ToolCallDelta(
+                        call_id=as_string(get_value(block, "id")),
+                        name=as_string(get_value(block, "name")),
+                        arguments_delta=arguments,
+                    )
+                )
+        elif event_type == "content_block_delta":
+            delta = get_value(event, "delta")
+            delta_type = as_string(get_value(delta, "type"))
+            if delta_type == "text_delta":
+                emitted.append(TextDelta(as_string(get_value(delta, "text"))))
+            elif delta_type in {"thinking_delta", "signature_delta"}:
+                summary = as_string(get_value(delta, "thinking", get_value(delta, "signature", "")))
+                emitted.append(ReasoningDelta(summary))
+            elif delta_type == "input_json_delta":
+                emitted.append(
+                    ToolCallDelta(
+                        call_id="",
+                        name="",
+                        arguments_delta=as_string(get_value(delta, "partial_json")),
+                    )
+                )
+        elif event_type == "message_delta":
+            raw_usage = get_value(event, "usage")
+            usage = Usage(
+                input_tokens=usage.input_tokens,
+                output_tokens=as_int(get_value(raw_usage, "output_tokens"), usage.output_tokens),
+                cache_read_tokens=usage.cache_read_tokens,
+                cache_write_tokens=usage.cache_write_tokens,
+            )
+            emitted.append(ModelUsage(usage))
+            emitted.append(
+                ModelCompleted(
+                    reason=_stop_reason(get_value(get_value(event, "delta"), "stop_reason")),
+                    usage=usage,
+                )
+            )
+            completed = True
+        return emitted, usage, completed
+
+    async def stream(self, request: ModelRequest) -> AsyncIterator[ModelEvent]:
+        self.ensure_open()
+        usage = Usage()
+        completed = False
+        try:
+            async for raw_event in self._stream_factory(request):
+                events, usage, just_completed = self._convert_event(raw_event, usage)
+                completed = completed or just_completed
+                for event in events:
+                    yield event
+            if not completed:
+                yield ModelCompleted(StopReason.STOP, usage)
+        except BaseException as exc:
+            raise map_provider_error(exc) from exc

windcode/providers/base.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import AsyncIterator, Awaitable, Callable
+from typing import Protocol, runtime_checkable
+
+from windcode.domain.models import ModelEvent, ModelRequest
+
+
+@runtime_checkable
+class ModelTransport(Protocol):
+    name: str
+
+    def stream(self, request: ModelRequest) -> AsyncIterator[ModelEvent]: ...
+
+    async def aclose(self) -> None: ...
+
+
+class BaseTransport(ABC):
+    name: str
+
+    def __init__(self) -> None:
+        self._close_callbacks: list[Callable[[], Awaitable[None]]] = []
+        self._closed = False
+
+    @property
+    def closed(self) -> bool:
+        return self._closed
+
+    def add_close_callback(self, callback: Callable[[], Awaitable[None]]) -> None:
+        self._close_callbacks.append(callback)
+
+    @abstractmethod
+    def stream(self, request: ModelRequest) -> AsyncIterator[ModelEvent]:
+        raise NotImplementedError
+
+    async def aclose(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+        for callback in reversed(self._close_callbacks):
+            await callback()
+
+    def ensure_open(self) -> None:
+        if self._closed:
+            raise RuntimeError(f"transport {self.name} is closed")

windcode/providers/catalog.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from windcode.config.models import ProviderConfig, ProviderProtocol
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderPreset:
+    id: str
+    name: str
+    protocol: ProviderProtocol
+    api_key_env: str
+    base_url: str
+
+
+PROVIDER_PRESETS: tuple[ProviderPreset, ...] = (
+    ProviderPreset(
+        "openai",
+        "OpenAI",
+        ProviderProtocol.OPENAI_RESPONSES,
+        "OPENAI_API_KEY",
+        "https://api.openai.com/v1",
+    ),
+    ProviderPreset(
+        "anthropic",
+        "Anthropic",
+        ProviderProtocol.ANTHROPIC_MESSAGES,
+        "ANTHROPIC_API_KEY",
+        "https://api.anthropic.com",
+    ),
+    ProviderPreset(
+        "deepseek",
+        "DeepSeek",
+        ProviderProtocol.OPENAI_COMPATIBLE,
+        "DEEPSEEK_API_KEY",
+        "https://api.deepseek.com/v1",
+    ),
+    ProviderPreset(
+        "moonshotai",
+        "Moonshot AI",
+        ProviderProtocol.OPENAI_COMPATIBLE,
+        "MOONSHOT_API_KEY",
+        "https://api.moonshot.ai/v1",
+    ),
+    ProviderPreset(
+        "siliconflow",
+        "SiliconFlow",
+        ProviderProtocol.OPENAI_COMPATIBLE,
+        "SILICONFLOW_API_KEY",
+        "https://api.siliconflow.com/v1",
+    ),
+    ProviderPreset(
+        "openrouter",
+        "OpenRouter",
+        ProviderProtocol.OPENAI_COMPATIBLE,
+        "OPENROUTER_API_KEY",
+        "https://openrouter.ai/api/v1",
+    ),
+    ProviderPreset(
+        "zhipuai",
+        "Zhipu AI",
+        ProviderProtocol.OPENAI_COMPATIBLE,
+        "ZHIPU_API_KEY",
+        "https://open.bigmodel.cn/api/paas/v4",
+    ),
+    ProviderPreset(
+        "alibaba",
+        "Alibaba Cloud",
+        ProviderProtocol.OPENAI_COMPATIBLE,
+        "DASHSCOPE_API_KEY",
+        "https://dashscope.aliyuncs.com/compatible-mode/v1",
+    ),
+    ProviderPreset(
+        "groq",
+        "Groq",
+        ProviderProtocol.OPENAI_COMPATIBLE,
+        "GROQ_API_KEY",
+        "https://api.groq.com/openai/v1",
+    ),
+    ProviderPreset(
+        "mistral",
+        "Mistral",
+        ProviderProtocol.OPENAI_COMPATIBLE,
+        "MISTRAL_API_KEY",
+        "https://api.mistral.ai/v1",
+    ),
+    ProviderPreset(
+        "xai", "xAI", ProviderProtocol.OPENAI_COMPATIBLE, "XAI_API_KEY", "https://api.x.ai/v1"
+    ),
+    ProviderPreset(
+        "google",
+        "Google Gemini",
+        ProviderProtocol.OPENAI_COMPATIBLE,
+        "GEMINI_API_KEY",
+        "https://generativelanguage.googleapis.com/v1beta/openai",
+    ),
+)
+
+PRESETS_BY_ID = {preset.id: preset for preset in PROVIDER_PRESETS}
+
+
+def provider_preset(config: ProviderConfig) -> ProviderPreset | None:
+    if config.provider_id is not None:
+        preset = PRESETS_BY_ID.get(config.provider_id)
+        if preset is not None:
+            return preset
+    normalized_url = (config.base_url or "").rstrip("/").casefold()
+    for preset in PROVIDER_PRESETS:
+        if (
+            config.protocol is preset.protocol
+            and normalized_url == preset.base_url.rstrip("/").casefold()
+        ):
+            return preset
+    if config.protocol is ProviderProtocol.OPENAI_RESPONSES:
+        return PRESETS_BY_ID["openai"]
+    if config.protocol is ProviderProtocol.ANTHROPIC_MESSAGES:
+        return PRESETS_BY_ID["anthropic"]
+    return None