windcode 0.1.0__py3-none-any.whl

windcode/providers/errors.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import asyncio
+from typing import cast
+
+import aiohttp
+
+from windcode.domain.errors import ErrorCategory, WindcodeError
+
+
+class ProviderError(WindcodeError):
+    def __init__(
+        self,
+        message: str,
+        category: ErrorCategory,
+        *,
+        status_code: int | None = None,
+    ) -> None:
+        super().__init__(message, category)
+        self.status_code = status_code
+
+
+def _status_code(error: BaseException) -> int | None:
+    value = getattr(error, "status_code", None)
+    if isinstance(value, int):
+        return value
+    response = getattr(error, "response", None)
+    value = getattr(response, "status", None)
+    return value if isinstance(value, int) else None
+
+
+def _category_from_status(status: int, message: str) -> ErrorCategory:
+    if status in {401, 403}:
+        return ErrorCategory.AUTHENTICATION
+    if status == 429:
+        return ErrorCategory.RATE_LIMIT
+    if status in {408, 409, 425}:
+        return ErrorCategory.NETWORK
+    if status >= 500:
+        return ErrorCategory.SERVER
+    lowered = message.casefold()
+    if status == 400 and any(
+        phrase in lowered for phrase in ("context length", "context window", "too many tokens")
+    ):
+        return ErrorCategory.CONTEXT_OVERFLOW
+    if status in {400, 404, 405, 422}:
+        return ErrorCategory.INVALID_REQUEST
+    return ErrorCategory.INTERNAL
+
+
+def map_provider_error(error: BaseException) -> WindcodeError:
+    if isinstance(error, WindcodeError):
+        return error
+    if isinstance(error, asyncio.CancelledError):
+        return ProviderError("model request cancelled", ErrorCategory.CANCELLED)
+    if isinstance(error, (TimeoutError, aiohttp.ClientConnectionError)):
+        return ProviderError(str(error) or "model network request failed", ErrorCategory.NETWORK)
+    if isinstance(error, aiohttp.ClientError):
+        status = _status_code(error)
+        category = (
+            _category_from_status(status, str(error))
+            if status is not None
+            else ErrorCategory.NETWORK
+        )
+        return ProviderError(str(error), category, status_code=status)
+
+    status = _status_code(error)
+    if status is not None:
+        return ProviderError(
+            str(error),
+            _category_from_status(status, str(error)),
+            status_code=status,
+        )
+
+    class_name = type(error).__name__.casefold()
+    if "authentication" in class_name or "permission" in class_name:
+        category = ErrorCategory.AUTHENTICATION
+    elif "ratelimit" in class_name or "rate_limit" in class_name:
+        category = ErrorCategory.RATE_LIMIT
+    elif "connection" in class_name or "timeout" in class_name:
+        category = ErrorCategory.NETWORK
+    elif "content" in class_name and ("filter" in class_name or "policy" in class_name):
+        category = ErrorCategory.CONTENT_POLICY
+    elif "badrequest" in class_name or "invalidrequest" in class_name:
+        category = _category_from_status(400, str(error))
+    else:
+        category = ErrorCategory.INTERNAL
+    return ProviderError(str(error), category, status_code=cast(int | None, status))
+
+
+def error_from_http_status(status_code: int, message: str) -> ProviderError:
+    return ProviderError(
+        message,
+        _category_from_status(status_code, message),
+        status_code=status_code,
+    )

windcode/providers/openai_compat.py

@@ -0,0 +1,231 @@
+from __future__ import annotations
+
+import json
+from collections.abc import AsyncIterator, Callable, Mapping
+from typing import cast
+
+import aiohttp
+
+from windcode.domain.errors import ErrorCategory
+from windcode.domain.messages import (
+    AttachmentBlock,
+    Message,
+    ReasoningBlock,
+    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 ProviderError, error_from_http_status, map_provider_error
+
+ChunkFactory = Callable[[ModelRequest], AsyncIterator[Mapping[str, object]]]
+
+
+def build_chat_messages(
+    messages: tuple[Message, ...], system_prompt: str
+) -> list[dict[str, object]]:
+    converted: list[dict[str, object]] = []
+    if system_prompt:
+        converted.append({"role": "system", "content": system_prompt})
+    for message in messages:
+        text_parts: list[str] = []
+        tool_calls: list[dict[str, object]] = []
+        tool_results: list[ToolResultBlock] = []
+        for block in message.content:
+            if isinstance(block, TextBlock):
+                text_parts.append(block.text)
+            elif isinstance(block, ReasoningBlock):
+                text_parts.append(block.summary)
+            elif isinstance(block, AttachmentBlock):
+                text_parts.append(f"[attachment: {block.description or block.reference}]")
+            elif isinstance(block, ToolCallBlock):
+                tool_calls.append(
+                    {
+                        "id": block.call_id,
+                        "type": "function",
+                        "function": {
+                            "name": block.name,
+                            "arguments": json.dumps(block.arguments, separators=(",", ":")),
+                        },
+                    }
+                )
+            else:
+                tool_results.append(block)
+        if text_parts or tool_calls:
+            item: dict[str, object] = {
+                "role": message.role.value,
+                "content": "\n".join(text_parts) or None,
+            }
+            if tool_calls:
+                item["tool_calls"] = tool_calls
+            converted.append(item)
+        for result in tool_results:
+            converted.append(
+                {"role": "tool", "tool_call_id": result.call_id, "content": result.content}
+            )
+    return converted
+
+
+def build_chat_tools(request: ModelRequest) -> list[dict[str, object]]:
+    return [
+        {
+            "type": "function",
+            "function": {
+                "name": tool.name,
+                "description": tool.description,
+                "parameters": tool.parameters,
+            },
+        }
+        for tool in request.tools
+    ]
+
+
+def _mapping(value: object) -> Mapping[str, object]:
+    if not isinstance(value, Mapping):
+        return {}
+    raw = cast(Mapping[object, object], value)
+    return {str(key): child for key, child in raw.items()}
+
+
+class OpenAICompatibleTransport(BaseTransport):
+    name = "openai_compatible"
+
+    def __init__(
+        self,
+        *,
+        api_key: str,
+        base_url: str,
+        session: aiohttp.ClientSession | None = None,
+        chunk_factory: ChunkFactory | None = None,
+    ) -> None:
+        super().__init__()
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self._session = session
+        self._owns_session = session is None
+        self._chunk_factory = chunk_factory or self._http_chunks
+        if session is not None:
+            self._owns_session = False
+
+    async def _get_session(self) -> aiohttp.ClientSession:
+        if self._session is None:
+            self._session = aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=None))
+            self.add_close_callback(self._session.close)
+        return self._session
+
+    async def _http_chunks(self, request: ModelRequest) -> AsyncIterator[Mapping[str, object]]:
+        session = await self._get_session()
+        url = (
+            self.base_url
+            if self.base_url.endswith("/chat/completions")
+            else f"{self.base_url}/chat/completions"
+        )
+        body: dict[str, object] = {
+            "model": request.model,
+            "messages": build_chat_messages(request.messages, request.system_prompt),
+            "tools": build_chat_tools(request),
+            "stream": True,
+            "stream_options": {"include_usage": True},
+        }
+        if request.max_output_tokens is not None:
+            body["max_tokens"] = request.max_output_tokens
+        headers = {"Authorization": f"Bearer {self.api_key}", "Accept": "text/event-stream"}
+        async with session.post(url, json=body, headers=headers) as response:
+            if response.status >= 400:
+                message = await response.text()
+                raise error_from_http_status(response.status, message)
+            async for raw_line in response.content:
+                line = raw_line.decode("utf-8", errors="strict").strip()
+                if not line or line.startswith(":") or not line.startswith("data:"):
+                    continue
+                data = line.removeprefix("data:").strip()
+                if data == "[DONE]":
+                    return
+                try:
+                    decoded = json.loads(data)
+                except json.JSONDecodeError as exc:
+                    raise ProviderError(f"invalid SSE JSON: {exc}", ErrorCategory.NETWORK) from exc
+                if not isinstance(decoded, Mapping):
+                    raise ProviderError("SSE payload must be an object", ErrorCategory.NETWORK)
+                raw = cast(Mapping[object, object], decoded)
+                yield {str(key): value for key, value in raw.items()}
+
+    async def stream(self, request: ModelRequest) -> AsyncIterator[ModelEvent]:
+        self.ensure_open()
+        usage = Usage()
+        calls: dict[int, tuple[str, str]] = {}
+        completed = False
+        try:
+            async for chunk in self._chunk_factory(request):
+                error = get_value(chunk, "error")
+                if error is not None:
+                    message = as_string(get_value(error, "message"), "provider returned an error")
+                    raise ProviderError(message, ErrorCategory.INVALID_REQUEST)
+                raw_usage = get_value(chunk, "usage")
+                if raw_usage is not None:
+                    prompt_details = get_value(raw_usage, "prompt_tokens_details")
+                    usage = Usage(
+                        input_tokens=as_int(get_value(raw_usage, "prompt_tokens")),
+                        output_tokens=as_int(get_value(raw_usage, "completion_tokens")),
+                        cache_read_tokens=as_int(get_value(prompt_details, "cached_tokens")),
+                    )
+                    yield ModelUsage(usage)
+                raw_choices = get_value(chunk, "choices", [])
+                if not isinstance(raw_choices, list) or not raw_choices:
+                    continue
+                choices = cast(list[object], raw_choices)
+                choice = choices[0]
+                delta = get_value(choice, "delta", {})
+                text = as_string(get_value(delta, "content"))
+                if text:
+                    yield TextDelta(text)
+                reasoning = as_string(
+                    get_value(delta, "reasoning_content", get_value(delta, "reasoning", ""))
+                )
+                if reasoning:
+                    yield ReasoningDelta(reasoning)
+                raw_tool_calls_value = get_value(delta, "tool_calls", [])
+                if isinstance(raw_tool_calls_value, list):
+                    raw_tool_calls = cast(list[object], raw_tool_calls_value)
+                    for raw_call in raw_tool_calls:
+                        call = _mapping(raw_call)
+                        index = as_int(get_value(call, "index"))
+                        function = get_value(call, "function", {})
+                        previous_id, previous_name = calls.get(index, ("", ""))
+                        call_id = as_string(get_value(call, "id"), previous_id)
+                        name = as_string(get_value(function, "name"), previous_name)
+                        calls[index] = (call_id, name)
+                        yield ToolCallDelta(
+                            call_id,
+                            name,
+                            as_string(get_value(function, "arguments")),
+                        )
+                finish_reason = as_string(get_value(choice, "finish_reason"))
+                if finish_reason:
+                    reason = {
+                        "tool_calls": StopReason.TOOL_USE,
+                        "length": StopReason.MAX_TOKENS,
+                        "content_filter": StopReason.CONTENT_FILTER,
+                        "stop": StopReason.STOP,
+                    }.get(finish_reason, StopReason.STOP)
+                    yield ModelCompleted(reason, usage)
+                    completed = True
+            if not completed:
+                raise ProviderError(
+                    "chat completion stream ended without a finish reason",
+                    ErrorCategory.NETWORK,
+                )
+        except BaseException as exc:
+            raise map_provider_error(exc) from exc

windcode/providers/openai_responses.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+import json
+from collections.abc import AsyncIterator, Callable
+from typing import cast
+
+from openai import AsyncOpenAI, DefaultAioHttpClient
+from openai.types.responses import ResponseInputParam, ToolParam
+
+from windcode.domain.messages import (
+    AttachmentBlock,
+    Message,
+    ReasoningBlock,
+    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 _message_text(message: Message) -> str:
+    parts: list[str] = []
+    for block in message.content:
+        if isinstance(block, TextBlock):
+            parts.append(block.text)
+        elif isinstance(block, ReasoningBlock):
+            parts.append(block.summary)
+        elif isinstance(block, AttachmentBlock):
+            parts.append(f"[attachment: {block.description or block.reference}]")
+    return "\n".join(parts)
+
+
+def build_responses_input(messages: tuple[Message, ...]) -> ResponseInputParam:
+    items: list[object] = []
+    for message in messages:
+        text = _message_text(message)
+        if text:
+            items.append({"type": "message", "role": message.role.value, "content": text})
+        for block in message.content:
+            if isinstance(block, ToolCallBlock):
+                items.append(
+                    {
+                        "type": "function_call",
+                        "call_id": block.call_id,
+                        "name": block.name,
+                        "arguments": json.dumps(block.arguments, separators=(",", ":")),
+                    }
+                )
+            elif isinstance(block, ToolResultBlock):
+                items.append(
+                    {
+                        "type": "function_call_output",
+                        "call_id": block.call_id,
+                        "output": block.content,
+                    }
+                )
+    return cast(ResponseInputParam, items)
+
+
+def build_responses_tools(request: ModelRequest) -> list[ToolParam]:
+    return [
+        cast(
+            ToolParam,
+            {
+                "type": "function",
+                "name": tool.name,
+                "description": tool.description,
+                "parameters": tool.parameters,
+                "strict": True,
+            },
+        )
+        for tool in request.tools
+    ]
+
+
+class OpenAIResponsesTransport(BaseTransport):
+    name = "openai_responses"
+
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        base_url: str | None = None,
+        stream_factory: RawStreamFactory | None = None,
+    ) -> None:
+        super().__init__()
+        self._client: AsyncOpenAI | None = None
+        if stream_factory is None:
+            http_client = DefaultAioHttpClient()
+            self._client = AsyncOpenAI(
+                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("OpenAI client is not configured")
+        stream = await self._client.responses.create(
+            model=request.model,
+            instructions=request.system_prompt,
+            input=build_responses_input(request.messages),
+            tools=build_responses_tools(request),
+            max_output_tokens=request.max_output_tokens,
+            stream=True,
+            store=False,
+        )
+        async for event in stream:
+            yield event
+
+    async def stream(self, request: ModelRequest) -> AsyncIterator[ModelEvent]:
+        self.ensure_open()
+        usage = Usage()
+        calls: dict[str, tuple[str, str]] = {}
+        completed = False
+        try:
+            async for event in self._stream_factory(request):
+                event_type = as_string(get_value(event, "type"))
+                if event_type == "response.output_text.delta":
+                    yield TextDelta(as_string(get_value(event, "delta")))
+                elif event_type in {
+                    "response.reasoning_summary_text.delta",
+                    "response.reasoning_text.delta",
+                }:
+                    yield ReasoningDelta(as_string(get_value(event, "delta")))
+                elif event_type == "response.output_item.added":
+                    item = get_value(event, "item")
+                    if as_string(get_value(item, "type")) == "function_call":
+                        item_id = as_string(
+                            get_value(item, "id", get_value(event, "output_index", ""))
+                        )
+                        call_id = as_string(get_value(item, "call_id", item_id))
+                        name = as_string(get_value(item, "name"))
+                        calls[item_id] = (call_id, name)
+                        arguments = as_string(get_value(item, "arguments"))
+                        yield ToolCallDelta(call_id, name, arguments)
+                elif event_type == "response.function_call_arguments.delta":
+                    item_id = as_string(
+                        get_value(event, "item_id", get_value(event, "output_index", ""))
+                    )
+                    call_id, name = calls.get(item_id, (item_id, ""))
+                    yield ToolCallDelta(call_id, name, as_string(get_value(event, "delta")))
+                elif event_type in {"response.completed", "response.incomplete"}:
+                    response = get_value(event, "response")
+                    raw_usage = get_value(response, "usage")
+                    input_details = get_value(raw_usage, "input_tokens_details")
+                    usage = Usage(
+                        input_tokens=as_int(get_value(raw_usage, "input_tokens")),
+                        output_tokens=as_int(get_value(raw_usage, "output_tokens")),
+                        cache_read_tokens=as_int(get_value(input_details, "cached_tokens")),
+                    )
+                    yield ModelUsage(usage)
+                    if event_type == "response.incomplete":
+                        reason = StopReason.MAX_TOKENS
+                    elif calls:
+                        reason = StopReason.TOOL_USE
+                    else:
+                        reason = StopReason.STOP
+                    yield ModelCompleted(reason, usage)
+                    completed = True
+                elif event_type == "response.failed":
+                    response = get_value(event, "response")
+                    error = get_value(response, "error", get_value(event, "error"))
+                    message = as_string(get_value(error, "message"), "OpenAI response failed")
+                    raise RuntimeError(message)
+            if not completed:
+                yield ModelCompleted(StopReason.STOP, usage)
+        except BaseException as exc:
+            raise map_provider_error(exc) from exc

windcode/providers/registry.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import os
+from collections.abc import Mapping
+from dataclasses import dataclass
+
+from windcode.auth import CredentialStore
+from windcode.config.models import AppConfig, ProviderConfig, ProviderProtocol
+from windcode.providers.anthropic import AnthropicTransport
+from windcode.providers.base import ModelTransport
+from windcode.providers.openai_compat import OpenAICompatibleTransport
+from windcode.providers.openai_responses import OpenAIResponsesTransport
+
+
+class ProviderConfigurationError(ValueError):
+    pass
+
+
+@dataclass(frozen=True, slots=True)
+class ModelTarget:
+    provider: str
+    model: str
+    transport: ModelTransport
+
+
+def create_transport(config: ProviderConfig, api_key: str) -> ModelTransport:
+    if config.protocol is ProviderProtocol.ANTHROPIC_MESSAGES:
+        return AnthropicTransport(api_key=api_key, base_url=config.base_url)
+    if config.protocol is ProviderProtocol.OPENAI_RESPONSES:
+        return OpenAIResponsesTransport(api_key=api_key, base_url=config.base_url)
+    if config.base_url is None:
+        raise ProviderConfigurationError("openai_compatible provider requires base_url")
+    return OpenAICompatibleTransport(api_key=api_key, base_url=config.base_url)
+
+
+class TransportRegistry:
+    def __init__(self) -> None:
+        self._targets: dict[str, ModelTarget] = {}
+
+    @classmethod
+    def from_config(
+        cls,
+        config: AppConfig,
+        *,
+        environ: Mapping[str, str] | None = None,
+        credential_store: CredentialStore | None = None,
+        allow_missing: bool = False,
+    ) -> TransportRegistry:
+        registry = cls()
+        environment = os.environ if environ is None else environ
+        for alias, provider in config.providers.items():
+            api_key = environment.get(provider.api_key_env) if provider.api_key_env else None
+            if not api_key and provider.credential_id and credential_store is not None:
+                api_key = credential_store.get(provider.credential_id)
+            if not api_key:
+                if allow_missing:
+                    continue
+                sources: list[str] = []
+                if provider.api_key_env:
+                    sources.append(f"环境变量 {provider.api_key_env}")
+                if provider.credential_id:
+                    sources.append(f"已保存凭据 {provider.credential_id}")
+                raise ProviderConfigurationError(
+                    f"provider {alias!r} 缺少 API Key, 请设置{' 或更新'.join(sources)}"
+                )
+            registry.register(alias, provider.model, create_transport(provider, api_key))
+        return registry
+
+    def register(
+        self,
+        alias: str,
+        model: str,
+        transport: ModelTransport,
+        *,
+        replace: bool = False,
+    ) -> None:
+        if alias in self._targets and not replace:
+            raise ValueError(f"transport alias already registered: {alias}")
+        self._targets[alias] = ModelTarget(alias, model, transport)
+
+    def get(self, alias: str) -> ModelTarget:
+        try:
+            return self._targets[alias]
+        except KeyError as exc:
+            raise KeyError(f"unknown transport alias: {alias}") from exc
+
+    @property
+    def aliases(self) -> tuple[str, ...]:
+        return tuple(self._targets)
+
+    def resolve_chain(self, config: AppConfig) -> tuple[ModelTarget, ...]:
+        if config.primary_provider is None:
+            raise ProviderConfigurationError("no primary_provider is configured")
+        aliases = (config.primary_provider, *config.fallback_chain)
+        if len(set(aliases)) != len(aliases):
+            raise ProviderConfigurationError("provider fallback chain contains a cycle")
+        return tuple(self.get(alias) for alias in aliases)
+
+    async def aclose(self) -> None:
+        closed: set[int] = set()
+        for target in reversed(tuple(self._targets.values())):
+            identity = id(target.transport)
+            if identity not in closed:
+                await target.transport.aclose()
+                closed.add(identity)

windcode/runtime/__init__.py

@@ -0,0 +1,15 @@
+from windcode.runtime.control import BudgetExceeded, RunBudgets, RunControl
+from windcode.runtime.event_bus import EventBus
+from windcode.runtime.loop import AgentLoop
+from windcode.runtime.scheduler import ScheduledCall, ScheduledResult, ToolScheduler
+
+__all__ = [
+    "AgentLoop",
+    "BudgetExceeded",
+    "EventBus",
+    "RunBudgets",
+    "RunControl",
+    "ScheduledCall",
+    "ScheduledResult",
+    "ToolScheduler",
+]