iac-code 0.1.0__py3-none-any.whl

iac_code/providers/openai_provider.py

@@ -0,0 +1,344 @@
+"""OpenAI Provider implementation with streaming and tool call support."""
+
+from __future__ import annotations
+
+import json
+import uuid
+from collections.abc import AsyncGenerator
+from typing import Any
+
+from openai import AsyncOpenAI
+
+from iac_code.i18n import _
+from iac_code.providers.base import (
+    ContentBlock,
+    Message,
+    NonStreamingResponse,
+    Provider,
+    ToolDefinition,
+)
+from iac_code.providers.thinking import ThinkingFamily, get_thinking_spec, normalize_effort
+from iac_code.types.stream_events import (
+    MessageEndEvent,
+    MessageStartEvent,
+    StreamEvent,
+    TextDeltaEvent,
+    ThinkingDeltaEvent,
+    ToolInputDeltaEvent,
+    ToolUseEndEvent,
+    ToolUseStartEvent,
+    Usage,
+)
+from iac_code.utils.tool_input_parser import parse_tool_input_events
+
+
+class OpenAIProvider(Provider):
+    """Provider implementation for OpenAI API (GPT-4, etc.)."""
+
+    _PROVIDER_KEY = "openai"
+
+    # Subclasses can set this to True for endpoints known to support stream_options
+    supports_stream_options: bool = False
+
+    def __init__(
+        self,
+        model: str,
+        api_key: str | None = None,
+        base_url: str | None = None,
+        client: Any = None,
+        effort: str | None = None,
+    ):
+        self._model = model
+        self._base_url = base_url
+        self._effort = effort
+        # Subclasses may set this before calling super().stream/complete to
+        # inject provider-specific kwargs (e.g. DeepSeek thinking mode).
+        self._extra_request_kwargs: dict[str, Any] = {}
+        if client is not None:
+            self._client = client
+        else:
+            self._client = AsyncOpenAI(api_key=api_key, base_url=base_url)
+
+    def _build_thinking_kwargs(self) -> dict[str, Any]:
+        spec = get_thinking_spec(self._PROVIDER_KEY, self._model)
+        if spec.family is not ThinkingFamily.OPENAI:
+            return {}
+        effort = normalize_effort(self._effort)
+        if effort is None or effort == "auto":
+            return {}
+        allowed = {e.value for e in spec.allowed_efforts}
+        if effort not in allowed:
+            if spec.default_effort is None:
+                return {}
+            effort = spec.default_effort.value
+        return {
+            "reasoning_effort": effort,
+            "extra_body": {"thinking": {"type": "enabled"}},
+        }
+
+    def _effort_request_kwargs(self) -> dict[str, Any]:
+        # Backwards-compatible alias used by the streaming/non-streaming paths.
+        return self._build_thinking_kwargs()
+
+    def get_model_name(self) -> str:
+        return self._model
+
+    # -- Message conversion ----------------------------------------------------
+
+    def _convert_messages(self, messages: list[Message]) -> list[dict[str, Any]]:
+        """Convert unified Message objects to OpenAI API format."""
+        result: list[dict[str, Any]] = []
+        for msg in messages:
+            if isinstance(msg.content, str):
+                result.append({"role": msg.role, "content": msg.content})
+            elif isinstance(msg.content, list):
+                result.extend(self._convert_content_blocks(msg.role, msg.content))
+        return result
+
+    def _convert_content_blocks(self, role: str, blocks: list[ContentBlock]) -> list[dict[str, Any]]:
+        """Convert a list of ContentBlocks into one or more OpenAI messages."""
+        messages: list[dict[str, Any]] = []
+
+        # Group tool_use blocks into a single assistant message with tool_calls
+        tool_uses = [b for b in blocks if b.type == "tool_use"]
+        text_blocks = [b for b in blocks if b.type == "text"]
+        thinking_blocks = [b for b in blocks if b.type == "thinking"]
+        tool_results = [b for b in blocks if b.type == "tool_result"]
+
+        # Assistant message with text and/or tool_calls
+        if role == "assistant" and (text_blocks or tool_uses or thinking_blocks):
+            msg: dict[str, Any] = {"role": "assistant"}
+            if text_blocks:
+                msg["content"] = "".join(b.text or "" for b in text_blocks)
+            else:
+                msg["content"] = None
+            if thinking_blocks:
+                # DeepSeek / Qwen thinking-mode models require the prior-turn
+                # reasoning_content to be echoed back in assistant messages.
+                msg["reasoning_content"] = "".join(b.text or "" for b in thinking_blocks)
+            if tool_uses:
+                msg["tool_calls"] = [
+                    {
+                        "id": b.tool_use_id or "",
+                        "type": "function",
+                        "function": {
+                            "name": b.name or "",
+                            "arguments": json.dumps(b.input or {}),
+                        },
+                    }
+                    for b in tool_uses
+                ]
+            messages.append(msg)
+
+        # Tool result messages (role="tool")
+        for b in tool_results:
+            messages.append(
+                {
+                    "role": "tool",
+                    "tool_call_id": b.tool_use_id or "",
+                    "content": b.content or "",
+                }
+            )
+
+        return messages
+
+    # -- Tool conversion -------------------------------------------------------
+
+    def _convert_tools(self, tools: list[ToolDefinition]) -> list[dict[str, Any]]:
+        """Convert unified ToolDefinition objects to OpenAI function-calling format."""
+        return [
+            {
+                "type": "function",
+                "function": {
+                    "name": t.name,
+                    "description": t.description,
+                    "parameters": t.input_schema,
+                },
+            }
+            for t in tools
+        ]
+
+    # -- Streaming -------------------------------------------------------------
+
+    async def stream(
+        self,
+        messages: list[Message],
+        system: str,
+        tools: list[ToolDefinition] | None = None,
+        max_tokens: int = 8192,
+    ) -> AsyncGenerator[StreamEvent, None]:
+        api_messages: list[dict[str, Any]] = []
+        if system:
+            api_messages.append({"role": "system", "content": system})
+        api_messages.extend(self._convert_messages(messages))
+
+        kwargs: dict[str, Any] = {
+            "model": self._model,
+            "messages": api_messages,
+            "max_tokens": max_tokens,
+            "stream": True,
+        }
+        if self.supports_stream_options:
+            kwargs["stream_options"] = {"include_usage": True}
+        if tools:
+            kwargs["tools"] = self._convert_tools(tools)
+        for k, v in self._effort_request_kwargs().items():
+            kwargs[k] = v
+        for k, v in self._extra_request_kwargs.items():
+            kwargs[k] = v
+
+        message_id = f"msg_{uuid.uuid4().hex[:24]}"
+        yield MessageStartEvent(message_id=message_id)
+
+        # Accumulators for tool calls (index-based)
+        tool_calls_acc: dict[int, dict[str, Any]] = {}
+        stop_reason = "end_turn"
+        usage = Usage()
+        has_content = False
+
+        response = await self._client.chat.completions.create(**kwargs)
+        async for chunk in response:
+            has_content = True
+            # Usage info (final chunk)
+            if chunk.usage is not None:
+                usage = Usage(
+                    input_tokens=chunk.usage.prompt_tokens or 0,
+                    output_tokens=chunk.usage.completion_tokens or 0,
+                )
+
+            if not chunk.choices:
+                continue
+
+            choice = chunk.choices[0]
+
+            # Finish reason
+            if choice.finish_reason:
+                if choice.finish_reason == "tool_calls":
+                    stop_reason = "tool_use"
+                elif choice.finish_reason == "length":
+                    stop_reason = "max_tokens"
+                else:
+                    stop_reason = "end_turn"
+
+            delta = choice.delta
+            if delta is None:
+                continue
+
+            # Reasoning content (DeepSeek V4, Qwen thinking mode via OpenAI-compat)
+            reasoning = getattr(delta, "reasoning_content", None)
+            if reasoning:
+                yield ThinkingDeltaEvent(text=reasoning)
+
+            # Text content
+            if delta.content:
+                yield TextDeltaEvent(text=delta.content)
+
+            # Tool calls (streamed with index-based accumulation)
+            if delta.tool_calls:
+                for tc_delta in delta.tool_calls:
+                    idx = tc_delta.index
+                    if idx not in tool_calls_acc:
+                        tool_calls_acc[idx] = {
+                            "id": tc_delta.id or "",
+                            "name": "",
+                            "arguments": "",
+                        }
+                        if tc_delta.function and tc_delta.function.name:
+                            tool_calls_acc[idx]["name"] = tc_delta.function.name
+                            yield ToolUseStartEvent(
+                                tool_use_id=tool_calls_acc[idx]["id"],
+                                name=tc_delta.function.name,
+                            )
+                    if tc_delta.function and tc_delta.function.arguments:
+                        tool_calls_acc[idx]["arguments"] += tc_delta.function.arguments
+                        yield ToolInputDeltaEvent(
+                            tool_use_id=tool_calls_acc[idx]["id"],
+                            partial_json=tc_delta.function.arguments,
+                        )
+
+        if not has_content:
+            base_url = str(self._base_url or self._client.base_url).rstrip("/")
+            raise RuntimeError(
+                _(
+                    "API returned no data. Please check that your API Base URL is correct (current: {base_url}). "
+                    "Many OpenAI-compatible endpoints require a /v1 suffix (e.g. {base_url}/v1)."
+                ).format(base_url=base_url)
+            )
+
+        # Emit ToolUseEndEvent for each accumulated tool call
+        for idx in sorted(tool_calls_acc):
+            tc = tool_calls_acc[idx]
+            for ev in parse_tool_input_events(tc["id"], tc["name"], tc["arguments"]):
+                yield ev
+
+        yield MessageEndEvent(stop_reason=stop_reason, usage=usage)
+
+    # -- Non-streaming ---------------------------------------------------------
+
+    async def complete(
+        self,
+        messages: list[Message],
+        system: str,
+        tools: list[ToolDefinition] | None = None,
+        max_tokens: int = 8192,
+    ) -> NonStreamingResponse:
+        api_messages: list[dict[str, Any]] = []
+        if system:
+            api_messages.append({"role": "system", "content": system})
+        api_messages.extend(self._convert_messages(messages))
+
+        kwargs: dict[str, Any] = {
+            "model": self._model,
+            "messages": api_messages,
+            "max_tokens": max_tokens,
+        }
+        if tools:
+            kwargs["tools"] = self._convert_tools(tools)
+        for k, v in self._effort_request_kwargs().items():
+            kwargs[k] = v
+        for k, v in self._extra_request_kwargs.items():
+            kwargs[k] = v
+
+        response = await self._client.chat.completions.create(**kwargs)
+        if not hasattr(response, "choices"):
+            base_url = str(self._base_url or self._client.base_url).rstrip("/")
+            raise RuntimeError(
+                _(
+                    "API returned an invalid response. Please check that your "
+                    "API Base URL is correct (current: {base_url}). "
+                    "Many OpenAI-compatible endpoints require a /v1 suffix "
+                    "(e.g. {base_url}/v1)."
+                ).format(base_url=base_url)
+            )
+        choice = response.choices[0]
+        message = choice.message
+
+        text = message.content or ""
+        thinking = getattr(message, "reasoning_content", None) or ""
+        tool_uses: list[dict[str, Any]] = []
+        if message.tool_calls:
+            for tc in message.tool_calls:
+                raw_args = tc.function.arguments or ""
+                for ev in parse_tool_input_events(tc.id, tc.function.name, raw_args):
+                    if isinstance(ev, ToolUseEndEvent):
+                        tool_uses.append({"id": ev.tool_use_id, "name": tc.function.name, "input": ev.input})
+
+        stop_reason = "end_turn"
+        if choice.finish_reason == "tool_calls":
+            stop_reason = "tool_use"
+        elif choice.finish_reason == "length":
+            stop_reason = "max_tokens"
+
+        usage = Usage(
+            input_tokens=response.usage.prompt_tokens if response.usage else 0,
+            output_tokens=response.usage.completion_tokens if response.usage else 0,
+        )
+
+        return NonStreamingResponse(
+            message_id=response.id,
+            text=text,
+            tool_uses=tool_uses,
+            stop_reason=stop_reason,
+            usage=usage,
+            thinking=thinking,
+        )

iac_code/providers/retry.py

@@ -0,0 +1,58 @@
+"""Retry strategy with exponential backoff and jitter."""
+
+from __future__ import annotations
+
+import asyncio
+import math
+import random
+from dataclasses import dataclass
+from typing import Any, Awaitable, Callable
+
+
+class RetryableError(Exception):
+    def __init__(self, message: str, status_code: int | None = None):
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class NonRetryableError(Exception):
+    pass
+
+
+@dataclass
+class RetryConfig:
+    max_retries: int = 5
+    base_delay: float = 0.5
+    max_delay: float = 32.0
+    jitter_factor: float = 0.25
+
+    def calculate_delay(self, attempt: int) -> float:
+        base = min(self.base_delay * math.pow(2, attempt), self.max_delay)
+        jitter = random.random() * self.jitter_factor * base
+        return base + jitter
+
+
+OnRetryCallback = Callable[[int, Exception, float], Awaitable[None]]
+
+
+async def with_retry(
+    operation: Callable[[], Awaitable[Any]],
+    config: RetryConfig,
+    on_retry: OnRetryCallback | None = None,
+) -> Any:
+    last_error: Exception | None = None
+    for attempt in range(config.max_retries + 1):
+        try:
+            return await operation()
+        except NonRetryableError:
+            raise
+        except RetryableError as e:
+            last_error = e
+            if attempt >= config.max_retries:
+                raise
+            delay = config.calculate_delay(attempt)
+            if on_retry:
+                await on_retry(attempt + 1, e, delay)
+            await asyncio.sleep(delay)
+    assert last_error is not None  # pragma: no cover
+    raise last_error  # pragma: no cover

iac_code/providers/stream_watchdog.py

@@ -0,0 +1,47 @@
+"""Streaming idle timeout watchdog."""
+
+from __future__ import annotations
+
+import time
+from types import TracebackType
+
+
+class StreamIdleTimeoutError(Exception):
+    def __init__(self, idle_timeout: float):
+        super().__init__(f"Stream idle for more than {idle_timeout}s")
+        self.idle_timeout = idle_timeout
+
+
+class StreamWatchdog:
+    def __init__(self, idle_timeout: float = 90.0):
+        self._idle_timeout = idle_timeout
+        self._last_ping: float = 0.0
+        self._running = False
+
+    def start(self) -> None:
+        self._last_ping = time.monotonic()
+        self._running = True
+
+    def stop(self) -> None:
+        self._running = False
+
+    def ping(self) -> None:
+        """Record activity and check for idle timeout.
+
+        Raises StreamIdleTimeoutError if the time since the last ping
+        exceeds the idle timeout threshold.
+        """
+        now = time.monotonic()
+        if self._running and self._last_ping > 0:
+            if now - self._last_ping > self._idle_timeout:
+                raise StreamIdleTimeoutError(self._idle_timeout)
+        self._last_ping = now
+
+    async def __aenter__(self) -> StreamWatchdog:
+        self.start()
+        return self
+
+    async def __aexit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+    ) -> None:
+        self.stop()

iac_code/providers/thinking.py

@@ -0,0 +1,164 @@
+"""Centralized thinking-mode registry keyed by (provider_key, model_name).
+
+Two-layer registry: outer key is the provider key (matches ``auth.py``
+``key_name`` and ``settings.yml`` ``providers.<key>``); inner key is the model
+name. The same model name can appear under multiple providers with different
+specs — e.g. ``deepseek-v4-pro`` is ``OPENAI`` family on the official DeepSeek
+endpoint but ``DASHSCOPE`` family when proxied through Aliyun's compatible-mode
+service.
+
+Wire-format assembly lives in each provider subclass's
+``_build_thinking_kwargs()``. This module only declares capabilities.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+
+class EffortLevel(Enum):
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+    XHIGH = "xhigh"
+    MAX = "max"
+    AUTO = "auto"
+
+
+EFFORT_ORDER: list[EffortLevel] = [
+    EffortLevel.LOW,
+    EffortLevel.MEDIUM,
+    EffortLevel.HIGH,
+    EffortLevel.XHIGH,
+    EffortLevel.MAX,
+    EffortLevel.AUTO,
+]
+
+
+EFFORT_SYMBOLS: dict[EffortLevel, str] = {
+    EffortLevel.LOW: "◆",
+    EffortLevel.MEDIUM: "◆◆",
+    EffortLevel.HIGH: "◆◆◆",
+    EffortLevel.XHIGH: "◆◆◆◆",
+    EffortLevel.MAX: "◆◆◆◆◆",
+    EffortLevel.AUTO: "◆",
+}
+
+
+class ThinkingFamily(Enum):
+    """The model's thinking protocol family. Wire format depends on provider."""
+
+    NONE = "none"
+    ANTHROPIC = "anthropic"
+    OPENAI = "openai"  # reasoning_effort + extra_body.thinking.type=enabled
+    DASHSCOPE = "dashscope"  # extra_body.enable_thinking [+ thinking_budget]
+
+
+@dataclass(frozen=True)
+class ThinkingSpec:
+    family: ThinkingFamily
+    allowed_efforts: tuple[EffortLevel, ...] = ()
+    default_effort: EffortLevel | None = None
+    default_thinking_budget: int | None = None  # reserved; not yet emitted
+
+    @property
+    def supports_effort(self) -> bool:
+        return bool(self.allowed_efforts)
+
+    @property
+    def effort_range(self) -> tuple[EffortLevel, EffortLevel] | None:
+        if not self.allowed_efforts:
+            return None
+        return self.allowed_efforts[0], self.allowed_efforts[-1]
+
+
+# ---------------------------------------------------------------------------
+# Per-(provider, model) registry
+# ---------------------------------------------------------------------------
+
+
+_OPENAI_EFFORTS: tuple[EffortLevel, ...] = (
+    EffortLevel.LOW,
+    EffortLevel.MEDIUM,
+    EffortLevel.HIGH,
+    EffortLevel.XHIGH,
+)
+
+_ANTHROPIC_EFFORTS: tuple[EffortLevel, ...] = (
+    EffortLevel.LOW,
+    EffortLevel.MEDIUM,
+    EffortLevel.HIGH,
+    EffortLevel.XHIGH,
+    EffortLevel.MAX,
+    EffortLevel.AUTO,
+)
+
+# DeepSeek V4 accepts only high/max — XHIGH is intentionally skipped.
+_DEEPSEEK_EFFORTS: tuple[EffortLevel, ...] = (EffortLevel.HIGH, EffortLevel.MAX)
+
+
+_NONE_SPEC = ThinkingSpec(family=ThinkingFamily.NONE)
+
+
+MODEL_THINKING: dict[str, dict[str, ThinkingSpec]] = {
+    "anthropic": {
+        "claude-opus-4-7": ThinkingSpec(ThinkingFamily.ANTHROPIC, _ANTHROPIC_EFFORTS, EffortLevel.HIGH),
+        "claude-opus-4-6": ThinkingSpec(ThinkingFamily.ANTHROPIC, _ANTHROPIC_EFFORTS, EffortLevel.HIGH),
+        "claude-sonnet-4-6": ThinkingSpec(ThinkingFamily.ANTHROPIC, _ANTHROPIC_EFFORTS, EffortLevel.HIGH),
+        "claude-sonnet-4-6-1m": ThinkingSpec(ThinkingFamily.ANTHROPIC, _ANTHROPIC_EFFORTS, EffortLevel.HIGH),
+        "claude-haiku-4-5-20251001": ThinkingSpec(ThinkingFamily.ANTHROPIC, _ANTHROPIC_EFFORTS, EffortLevel.HIGH),
+    },
+    "openai": {
+        "gpt-5.5": ThinkingSpec(ThinkingFamily.OPENAI, _OPENAI_EFFORTS, EffortLevel.HIGH),
+        "gpt-5.4": ThinkingSpec(ThinkingFamily.OPENAI, _OPENAI_EFFORTS, EffortLevel.HIGH),
+        "gpt-5.4-mini": ThinkingSpec(ThinkingFamily.OPENAI, _OPENAI_EFFORTS, EffortLevel.HIGH),
+        "gpt-5.3-codex": ThinkingSpec(ThinkingFamily.OPENAI, _OPENAI_EFFORTS, EffortLevel.HIGH),
+        "gpt-5.2": ThinkingSpec(ThinkingFamily.OPENAI, _OPENAI_EFFORTS, EffortLevel.HIGH),
+    },
+    "deepseek": {
+        "deepseek-v4-pro": ThinkingSpec(ThinkingFamily.OPENAI, _DEEPSEEK_EFFORTS, EffortLevel.HIGH),
+        "deepseek-v4-flash": ThinkingSpec(ThinkingFamily.OPENAI, _DEEPSEEK_EFFORTS, EffortLevel.HIGH),
+    },
+    "dashscope": {
+        "qwen3.6-max-preview": ThinkingSpec(ThinkingFamily.DASHSCOPE),
+        "qwen3.6-plus": ThinkingSpec(ThinkingFamily.DASHSCOPE),
+        "qwen3.5-plus": ThinkingSpec(ThinkingFamily.DASHSCOPE),
+        "qwen3.5-flash": ThinkingSpec(ThinkingFamily.DASHSCOPE),
+        "qwq-plus": ThinkingSpec(ThinkingFamily.DASHSCOPE),
+        "kimi-k2.6": ThinkingSpec(ThinkingFamily.DASHSCOPE),
+        "glm-5.1": ThinkingSpec(ThinkingFamily.DASHSCOPE),
+        "deepseek-v4-pro": ThinkingSpec(ThinkingFamily.DASHSCOPE, _DEEPSEEK_EFFORTS, EffortLevel.HIGH),
+        "deepseek-v4-flash": ThinkingSpec(ThinkingFamily.DASHSCOPE, _DEEPSEEK_EFFORTS, EffortLevel.HIGH),
+    },
+    "dashscope_token_plan": {
+        "qwen3.6-plus": ThinkingSpec(ThinkingFamily.DASHSCOPE),
+        "deepseek-v3.2": ThinkingSpec(ThinkingFamily.DASHSCOPE),
+        "glm-5": ThinkingSpec(ThinkingFamily.DASHSCOPE),
+        "MiniMax-M2.5": ThinkingSpec(ThinkingFamily.DASHSCOPE),
+    },
+}
+
+
+def get_thinking_spec(provider_key: str, model: str) -> ThinkingSpec:
+    """Return spec for (provider_key, model). Unknown combos → ``NONE`` spec."""
+    return MODEL_THINKING.get(provider_key, {}).get(model, _NONE_SPEC)
+
+
+def normalize_effort(effort: str | None) -> str | None:
+    """Lowercased, stripped effort string; empty returns None."""
+    if effort is None:
+        return None
+    value = effort.strip().lower()
+    return value or None
+
+
+# Anthropic extended-thinking budget tokens per effort level.
+# Used by ``AnthropicProvider._build_thinking_kwargs``.
+ANTHROPIC_BUDGET: dict[str, int] = {
+    "low": 1024,
+    "medium": 4096,
+    "high": 16384,
+    "xhigh": 32000,
+    "max": 64000,
+}

iac_code/services/__init__.py

@@ -0,0 +1 @@
+__all__: list[str] = []