devcopilot 0.2.0__py3-none-any.whl

providers/transports/anthropic_messages/transport.py

@@ -0,0 +1,236 @@
+"""Shared transport for providers with native Anthropic Messages endpoints."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Iterator
+from typing import Any, Literal
+
+import httpx
+
+from config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
+from core.anthropic import iter_provider_stream_error_sse_events
+from core.anthropic.native_messages_request import (
+    build_base_native_anthropic_request_body,
+)
+from core.anthropic.native_sse_block_policy import (
+    NativeSseBlockPolicyState,
+    transform_native_sse_block_event,
+)
+from providers.base import BaseProvider, ProviderConfig
+from providers.error_mapping import (
+    extract_provider_error_detail,
+    map_error,
+    user_visible_message_for_mapped_provider_error,
+)
+from providers.model_listing import (
+    ProviderModelInfo,
+    extract_openai_model_ids,
+    model_infos_from_ids,
+)
+from providers.rate_limit import GlobalRateLimiter
+
+from .http import maybe_await_aclose, model_list_json, raise_for_status_with_body
+from .stream import AnthropicMessagesStreamRunner
+
+StreamChunkMode = Literal["line", "event"]
+
+
+class AnthropicMessagesTransport(BaseProvider):
+    """Base class for providers that stream from an Anthropic-compatible endpoint."""
+
+    stream_chunk_mode: StreamChunkMode = "line"
+
+    def __init__(
+        self,
+        config: ProviderConfig,
+        *,
+        provider_name: str,
+        default_base_url: str,
+    ):
+        super().__init__(config)
+        self._provider_name = provider_name
+        self._api_key = config.api_key
+        self._base_url = (config.base_url or default_base_url).rstrip("/")
+        self._global_rate_limiter = GlobalRateLimiter.get_scoped_instance(
+            provider_name.lower(),
+            rate_limit=config.rate_limit,
+            rate_window=config.rate_window,
+            max_concurrency=config.max_concurrency,
+        )
+        self._client = httpx.AsyncClient(
+            base_url=self._base_url,
+            proxy=config.proxy or None,
+            timeout=httpx.Timeout(
+                config.http_read_timeout,
+                connect=config.http_connect_timeout,
+                read=config.http_read_timeout,
+                write=config.http_write_timeout,
+            ),
+        )
+
+    async def cleanup(self) -> None:
+        """Release HTTP client resources."""
+        await self._client.aclose()
+
+    async def list_model_ids(self) -> frozenset[str]:
+        """Return model ids from an OpenAI-compatible ``/models`` endpoint."""
+        return frozenset(info.model_id for info in await self.list_model_infos())
+
+    async def list_model_infos(self) -> frozenset[ProviderModelInfo]:
+        """Return model ids plus optional metadata from a ``/models`` endpoint."""
+        response = await self._send_model_list_request()
+        try:
+            payload = model_list_json(response, provider_name=self._provider_name)
+            return self._extract_model_infos_from_model_list_payload(payload)
+        finally:
+            await maybe_await_aclose(response)
+
+    async def _send_model_list_request(self) -> httpx.Response:
+        """Query the provider endpoint that advertises available model ids."""
+        return await self._client.get(
+            "/models",
+            headers=self._model_list_headers(),
+        )
+
+    def _model_list_headers(self) -> dict[str, str]:
+        """Return headers for model-list requests."""
+        return {}
+
+    def _extract_model_ids_from_model_list_payload(
+        self, payload: Any
+    ) -> frozenset[str]:
+        """Parse the provider model-list response body."""
+        return extract_openai_model_ids(payload, provider_name=self._provider_name)
+
+    def _extract_model_infos_from_model_list_payload(
+        self, payload: Any
+    ) -> frozenset[ProviderModelInfo]:
+        """Parse provider model metadata; default to unknown capabilities."""
+        return model_infos_from_ids(
+            self._extract_model_ids_from_model_list_payload(payload)
+        )
+
+    def _request_headers(self) -> dict[str, str]:
+        """Return headers for the native messages request."""
+        return {"Content-Type": "application/json"}
+
+    def _build_request_body(
+        self, request: Any, thinking_enabled: bool | None = None
+    ) -> dict:
+        """Build a native Anthropic request body."""
+        thinking_enabled = self._is_thinking_enabled(request, thinking_enabled)
+        return self._build_request_body_with_resolved_thinking(
+            request,
+            thinking_enabled=thinking_enabled,
+        )
+
+    def _build_request_body_with_resolved_thinking(
+        self, request: Any, *, thinking_enabled: bool
+    ) -> dict:
+        """Build a native Anthropic request body after thinking is resolved."""
+        return build_base_native_anthropic_request_body(
+            request,
+            default_max_tokens=ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS,
+            thinking_enabled=thinking_enabled,
+        )
+
+    async def _send_stream_request(self, body: dict) -> httpx.Response:
+        """Create a streaming messages response."""
+        request = self._client.build_request(
+            "POST",
+            "/messages",
+            json=body,
+            headers=self._request_headers(),
+        )
+        return await self._client.send(request, stream=True)
+
+    async def _raise_for_status(
+        self, response: httpx.Response, *, req_tag: str
+    ) -> None:
+        """Raise for non-200 responses after attaching safe error metadata."""
+        await raise_for_status_with_body(
+            response,
+            provider_name=self._provider_name,
+            req_tag=req_tag,
+            log_api_error_tracebacks=self._config.log_api_error_tracebacks,
+        )
+
+    def _new_stream_state(self, request: Any, *, thinking_enabled: bool) -> Any:
+        """Return per-stream provider state for event transformation."""
+        if self.stream_chunk_mode == "line":
+            return NativeSseBlockPolicyState()
+        return None
+
+    def _transform_stream_event(
+        self,
+        event: str,
+        state: Any,
+        *,
+        thinking_enabled: bool,
+    ) -> str | None:
+        """Transform or drop a grouped SSE event before yielding it downstream."""
+        if isinstance(state, NativeSseBlockPolicyState):
+            return transform_native_sse_block_event(
+                event, state, thinking_enabled=thinking_enabled
+            )
+        return event
+
+    def _get_error_message(self, error: Exception, request_id: str | None) -> str:
+        """Map an exception into a user-facing provider error message."""
+        mapped_error = map_error(error, rate_limiter=self._global_rate_limiter)
+        return user_visible_message_for_mapped_provider_error(
+            mapped_error,
+            provider_name=self._provider_name,
+            read_timeout_s=self._config.http_read_timeout,
+            detail=extract_provider_error_detail(error),
+            request_id=request_id,
+        )
+
+    async def _validated_stream_send(
+        self, body: dict, *, req_tag: str
+    ) -> httpx.Response:
+        """Send request and raise mapped HTTP errors before yielding body chunks."""
+        send_response = await self._send_stream_request(body)
+        if send_response.status_code != 200:
+            try:
+                await self._raise_for_status(send_response, req_tag=req_tag)
+            finally:
+                if not send_response.is_closed:
+                    await maybe_await_aclose(send_response)
+        return send_response
+
+    def _emit_error_events(
+        self,
+        *,
+        request: Any,
+        input_tokens: int,
+        error_message: str,
+        sent_any_event: bool,
+    ) -> Iterator[str]:
+        """Emit the same Anthropic message lifecycle used by OpenAI-chat providers."""
+        yield from iter_provider_stream_error_sse_events(
+            request=request,
+            input_tokens=input_tokens,
+            error_message=error_message,
+            sent_any_event=sent_any_event,
+            log_raw_sse_events=self._config.log_raw_sse_events,
+        )
+
+    async def stream_response(
+        self,
+        request: Any,
+        input_tokens: int = 0,
+        *,
+        request_id: str | None = None,
+        thinking_enabled: bool | None = None,
+    ) -> AsyncIterator[str]:
+        """Stream response via a native Anthropic-compatible messages endpoint."""
+        runner = AnthropicMessagesStreamRunner(
+            self,
+            request=request,
+            input_tokens=input_tokens,
+            request_id=request_id,
+            thinking_enabled=thinking_enabled,
+        )
+        async for event in runner.run():
+            yield event

providers/transports/openai_chat/__init__.py

@@ -0,0 +1,5 @@
+"""OpenAI-compatible chat transport family."""
+
+from .transport import OpenAIChatTransport
+
+__all__ = ["OpenAIChatTransport"]

providers/transports/openai_chat/recovery.py

@@ -0,0 +1,217 @@
+"""OpenAI-chat stream recovery event construction."""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable, Iterator
+from typing import Any
+
+from core.anthropic import SSEBuilder
+from core.anthropic.stream_recovery import (
+    MIDSTREAM_RECOVERY_ATTEMPTS,
+    accept_tool_json_repair,
+    continuation_suffix,
+    is_retryable_stream_error,
+    make_openai_text_recovery_body,
+    make_openai_tool_repair_body,
+    parse_complete_tool_input,
+    tool_schemas_by_name,
+)
+from core.trace import trace_event
+
+from .tool_calls import all_started_tools_complete, started_tool_states
+
+CreateStream = Callable[[dict[str, Any]], Awaitable[tuple[Any, dict[str, Any]]]]
+
+
+class OpenAIChatRecovery:
+    """Construct recovery events for interrupted OpenAI-chat streams."""
+
+    def __init__(self, *, provider_name: str, create_stream: CreateStream) -> None:
+        self._provider_name = provider_name
+        self._create_stream = create_stream
+
+    async def collect_text(self, body: dict[str, Any]) -> tuple[str, str]:
+        """Collect text/reasoning from an internal recovery request."""
+        last_error: Exception | None = None
+        for attempt in range(MIDSTREAM_RECOVERY_ATTEMPTS):
+            try:
+                stream, _ = await self._create_stream(body)
+                text_parts: list[str] = []
+                thinking_parts: list[str] = []
+                async for chunk in stream:
+                    if not getattr(chunk, "choices", None):
+                        continue
+                    choice = chunk.choices[0]
+                    delta = choice.delta
+                    if delta is None:
+                        continue
+                    reasoning = getattr(delta, "reasoning_content", None)
+                    if isinstance(reasoning, str) and reasoning:
+                        thinking_parts.append(reasoning)
+                    content = getattr(delta, "content", None)
+                    if isinstance(content, str) and content:
+                        text_parts.append(content)
+                return "".join(text_parts), "".join(thinking_parts)
+            except Exception as error:
+                last_error = error
+                if not is_retryable_stream_error(error):
+                    raise
+                trace_event(
+                    stage="provider",
+                    event="provider.recovery.retry",
+                    source="provider",
+                    provider=self._provider_name,
+                    recovery_kind="openai_text",
+                    attempt=attempt + 1,
+                    max_attempts=MIDSTREAM_RECOVERY_ATTEMPTS,
+                    exc_type=type(error).__name__,
+                )
+        if last_error is not None:
+            raise last_error
+        return "", ""
+
+    async def events(
+        self,
+        *,
+        body: dict[str, Any],
+        sse: SSEBuilder,
+        request: Any,
+        request_id: str | None,
+        error: Exception,
+        tool_argument_alias_buffers: dict[int, str],
+    ) -> list[str] | None:
+        """Build recovery events, or return None when recovery is impossible."""
+        if not is_retryable_stream_error(error):
+            return None
+
+        if sse.blocks.has_emitted_tool_block():
+            if not all_started_tools_complete(sse, request):
+                repair_events = await self._repair_tool_args(
+                    body=body,
+                    sse=sse,
+                    request=request,
+                    tool_argument_alias_buffers=tool_argument_alias_buffers,
+                )
+                if repair_events is None:
+                    return None
+            else:
+                repair_events = []
+            events = list(repair_events)
+            events.extend(sse.close_all_blocks())
+            events.append(sse.message_delta("tool_use", sse.estimate_output_tokens()))
+            events.append(sse.message_stop())
+            trace_event(
+                stage="provider",
+                event="provider.recovery.tool_salvaged",
+                source="provider",
+                provider=self._provider_name,
+                request_id=request_id,
+            )
+            return events
+
+        partial_text = sse.accumulated_text
+        partial_thinking = sse.accumulated_reasoning
+        if not partial_text and not partial_thinking:
+            return None
+
+        recovery_body = make_openai_text_recovery_body(body, partial_text)
+        text, thinking = await self.collect_text(recovery_body)
+        text_suffix = continuation_suffix(partial_text, text)
+        thinking_suffix = continuation_suffix(partial_thinking, thinking)
+        events: list[str] = []
+        if thinking_suffix:
+            for event in sse.ensure_thinking_block():
+                events.append(event)
+            events.append(sse.emit_thinking_delta(thinking_suffix))
+        if text_suffix:
+            for event in sse.ensure_text_block():
+                events.append(event)
+            events.append(sse.emit_text_delta(text_suffix))
+        if not events:
+            return None
+        events.extend(sse.close_all_blocks())
+        events.append(sse.message_delta("end_turn", sse.estimate_output_tokens()))
+        events.append(sse.message_stop())
+        trace_event(
+            stage="provider",
+            event="provider.recovery.continued",
+            source="provider",
+            provider=self._provider_name,
+            request_id=request_id,
+        )
+        return events
+
+    def emit_error_tail(self, sse: SSEBuilder, error_message: str) -> Iterator[str]:
+        """Emit the canonical OpenAI-chat final error tail."""
+        yield from sse.close_all_blocks()
+        if sse.blocks.has_emitted_tool_block():
+            yield sse.emit_top_level_error(error_message)
+        else:
+            yield from sse.emit_error(error_message)
+        yield sse.message_delta("end_turn", 1)
+        yield sse.message_stop()
+
+    async def _repair_tool_args(
+        self,
+        *,
+        body: dict[str, Any],
+        sse: SSEBuilder,
+        request: Any,
+        tool_argument_alias_buffers: dict[int, str],
+    ) -> list[str] | None:
+        schemas = tool_schemas_by_name(request)
+        events: list[str] = []
+        for tool_index, state in started_tool_states(sse):
+            emitted_prefix = "".join(state.contents)
+            repair_prefix = emitted_prefix
+            if not repair_prefix and state.name == "Task" and state.task_arg_buffer:
+                repair_prefix = state.task_arg_buffer
+            if not repair_prefix and tool_index in tool_argument_alias_buffers:
+                repair_prefix = tool_argument_alias_buffers[tool_index]
+            if (
+                parse_complete_tool_input(repair_prefix, state.name, schemas)
+                is not None
+            ):
+                if not emitted_prefix:
+                    yield_text = repair_prefix
+                    if yield_text:
+                        events.append(sse.emit_tool_delta(tool_index, yield_text))
+                continue
+
+            schema = schemas.get(state.name)
+            recovery_body = make_openai_tool_repair_body(
+                body,
+                tool_name=state.name,
+                prefix=repair_prefix,
+                input_schema=schema.input_schema if schema is not None else None,
+            )
+            accepted_suffix: str | None = None
+            for attempt in range(MIDSTREAM_RECOVERY_ATTEMPTS):
+                text, _ = await self.collect_text(recovery_body)
+                repair = accept_tool_json_repair(
+                    repair_prefix,
+                    text,
+                    tool_name=state.name,
+                    schemas=schemas,
+                )
+                if repair is not None:
+                    accepted_suffix = repair.suffix
+                    trace_event(
+                        stage="provider",
+                        event="provider.recovery.tool_repaired",
+                        source="provider",
+                        provider=self._provider_name,
+                        tool_name=state.name,
+                        attempt=attempt + 1,
+                    )
+                    break
+            if accepted_suffix is None:
+                return None
+            to_emit = (
+                accepted_suffix if emitted_prefix else repair_prefix + accepted_suffix
+            )
+            if to_emit:
+                events.append(sse.emit_tool_delta(tool_index, to_emit))
+        if not all_started_tools_complete(sse, request):
+            return None
+        return events