crabcode 0.1.6__py3-none-win_amd64.whl

crabcode_core/api/__init__.py

@@ -0,0 +1,20 @@
+"""API adapter layer - abstracts multiple LLM backends."""
+
+from crabcode_core.api.base import APIAdapter, StreamChunk, ModelConfig
+from crabcode_core.api.model_info import DEFAULT_CONTEXT_WINDOW, lookup_context_window
+from crabcode_core.api.registry import create_adapter
+from crabcode_core.api.ollama_adapter import OllamaAdapter
+from crabcode_core.api.gemini_adapter import GeminiAdapter
+from crabcode_core.api.azure_adapter import AzureOpenAIAdapter
+
+__all__ = [
+    "APIAdapter",
+    "StreamChunk",
+    "ModelConfig",
+    "create_adapter",
+    "DEFAULT_CONTEXT_WINDOW",
+    "lookup_context_window",
+    "OllamaAdapter",
+    "GeminiAdapter",
+    "AzureOpenAIAdapter",
+]

crabcode_core/api/anthropic_adapter.py

@@ -0,0 +1,648 @@
+"""Anthropic API adapter — primary backend, closest to original behavior."""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Any, AsyncGenerator
+
+import anthropic
+import httpx
+
+from crabcode_core.api.base import (
+    APIAdapter,
+    ModelConfig,
+    StreamChunk,
+    usage_int_field,
+)
+from crabcode_core.logging_utils import get_logger
+from crabcode_core.api.error_logging import response_request_id
+from crabcode_core.paths import get_config_home
+from crabcode_core.types.config import ApiConfig
+from crabcode_core.utf8_sanitize import safe_utf8_json_tree, safe_utf8_str
+from crabcode_core.types.message import (
+    ImageBlock,
+    Message,
+    MessageRole,
+    TextBlock,
+    ThinkingBlock,
+    ToolResultBlock,
+    ToolUseBlock,
+)
+
+logger = get_logger(__name__)
+
+
+ANTHROPIC_VERSION = "2023-06-01"
+
+
+def _anthropic_usage(
+    raw: Any,
+    *,
+    include_input: bool,
+    include_output: bool,
+) -> dict[str, int]:
+    usage: dict[str, int] = {}
+    if include_input:
+        input_tokens, has_input = usage_int_field(raw, "input_tokens")
+        cache_read, has_cache_read = usage_int_field(raw, "cache_read_input_tokens")
+        cache_write, has_cache_write = usage_int_field(raw, "cache_creation_input_tokens")
+        if has_input:
+            usage["input_tokens"] = input_tokens
+            usage["total_input_tokens"] = input_tokens + cache_read + cache_write
+        if has_cache_read:
+            usage["cache_read_tokens"] = cache_read
+        if has_cache_write:
+            usage["cache_write_tokens"] = cache_write
+    if include_output:
+        output_tokens, has_output = usage_int_field(raw, "output_tokens")
+        if has_output:
+            usage["output_tokens"] = output_tokens
+    return usage
+
+
+def _messages_to_api(messages: list[Message]) -> list[dict[str, Any]]:
+    """Convert internal messages to Anthropic API format."""
+    result: list[dict[str, Any]] = []
+    for msg in messages:
+        if msg.role == MessageRole.SYSTEM:
+            continue
+
+        if isinstance(msg.content, str):
+            result.append({"role": msg.role.value, "content": msg.content})
+            continue
+
+        blocks: list[dict[str, Any]] = []
+        for block in msg.content:
+            if isinstance(block, TextBlock):
+                blocks.append({"type": "text", "text": block.text})
+            elif isinstance(block, ToolUseBlock):
+                blocks.append({
+                    "type": "tool_use",
+                    "id": block.id,
+                    "name": block.name,
+                    "input": block.input,
+                })
+            elif isinstance(block, ToolResultBlock):
+                blocks.append({
+                    "type": "tool_result",
+                    "tool_use_id": block.tool_use_id,
+                    "content": block.content,
+                    **({"is_error": True} if block.is_error else {}),
+                })
+            elif isinstance(block, ThinkingBlock):
+                blocks.append({
+                    "type": "thinking",
+                    "thinking": block.thinking,
+                })
+            elif isinstance(block, ImageBlock):
+                blocks.append({
+                    "type": "image",
+                    "source": block.source,
+                })
+
+        if blocks:
+            result.append({"role": msg.role.value, "content": blocks})
+
+    return safe_utf8_json_tree(result)
+
+
+def _tools_to_api(tools: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Convert tool schemas to Anthropic API format."""
+    result = []
+    for tool in tools:
+        api_tool: dict[str, Any] = {
+            "name": tool["name"],
+            "description": tool.get("description", ""),
+            "input_schema": tool.get("input_schema", {"type": "object", "properties": {}}),
+        }
+        result.append(api_tool)
+    return safe_utf8_json_tree(result)
+
+
+class AnthropicAdapter(APIAdapter):
+    """Adapter for Anthropic's Messages API (direct, first-party)."""
+
+    emits_response_item_events = True
+
+    def __init__(self, config: ApiConfig):
+        self.config = config
+        self._cached_context_window: int | None = None
+        api_key = None
+        if config.api_key_env:
+            api_key = os.environ.get(config.api_key_env)
+        if not api_key:
+            api_key = os.environ.get("ANTHROPIC_API_KEY")
+
+        kwargs: dict[str, Any] = {}
+        if api_key:
+            kwargs["api_key"] = api_key
+        if config.base_url:
+            kwargs["base_url"] = config.base_url
+        if config.http_headers:
+            kwargs["default_headers"] = config.http_headers
+
+        from crabcode_core.api.network import sdk_options
+        self.client = anthropic.AsyncAnthropic(**kwargs, **sdk_options(config))
+        self._api_key = api_key
+
+    def _messages_url(self) -> str | None:
+        """Return a Messages API URL for Anthropic-compatible custom endpoints."""
+        if not self.config.base_url:
+            return "https://api.anthropic.com/v1/messages"
+        base = self.config.base_url.rstrip("/")
+        if base.endswith("/v1"):
+            return f"{base}/messages"
+        return f"{base}/v1/messages"
+
+    def _manual_headers(self) -> dict[str, str]:
+        headers: dict[str, str] = {
+            "accept": "text/event-stream",
+            "content-type": "application/json",
+            "anthropic-version": ANTHROPIC_VERSION,
+        }
+        headers.update(self.config.http_headers or {})
+        lower_header_names = {k.lower() for k in headers}
+        if self._api_key and "x-api-key" not in lower_header_names:
+            headers["x-api-key"] = self._api_key
+        return headers
+
+    async def _stream_message_httpx(
+        self,
+        params: dict[str, Any],
+    ) -> AsyncGenerator[StreamChunk, None]:
+        """Stream from Anthropic-compatible routers without SDK helper headers.
+
+        Some Anthropic-compatible proxies reject the Python SDK's stream helper
+        headers and return a JSON error body with HTTP 200. Reading SSE directly
+        keeps the wire format Anthropic-compatible while avoiding those headers.
+        """
+        url = self._messages_url()
+        if not url:
+            return
+
+        payload = dict(params)
+        payload["stream"] = True
+
+        timeout = httpx.Timeout(
+            float(self.config.timeout),
+            connect=min(float(self.config.timeout), 10.0),
+            read=float(self.config.timeout),
+            write=float(self.config.timeout),
+        )
+        from crabcode_core.api.network import http_options
+        async with httpx.AsyncClient(timeout=timeout, **http_options(self.config)) as client:
+            async with client.stream(
+                "POST",
+                url,
+                headers=self._manual_headers(),
+                json=payload,
+            ) as response:
+                content_type = response.headers.get("content-type", "")
+                if response.status_code >= 400:
+                    body = await response.aread()
+                    yield StreamChunk(
+                        type="error",
+                        error_body=body,
+                        error_status_code=response.status_code,
+                        error_request_id=response_request_id(response),
+                        error=(
+                            body.decode("utf-8", errors="replace")
+                            or response.reason_phrase
+                        ),
+                    )
+                    return
+
+                if "text/event-stream" not in content_type.lower():
+                    body = await response.aread()
+                    text = body.decode("utf-8", errors="replace")
+                    error_text = text
+                    try:
+                        data = json.loads(text)
+                        error_text = (
+                            data.get("error", {}).get("message")
+                            if isinstance(data.get("error"), dict)
+                            else data.get("code_msg") or data.get("message") or text
+                        )
+                    except Exception:
+                        pass
+                    yield StreamChunk(
+                        type="error", error=str(error_text), error_body=text,
+                        error_status_code=response.status_code,
+                        error_request_id=response_request_id(response),
+                    )
+                    return
+
+                current_tool_id = ""
+                current_tool_name = ""
+                tool_input_buffer = ""
+                current_block_type = ""
+                current_block_id = ""
+
+                async for raw_line in response.aiter_lines():
+                    if not raw_line.startswith("data:"):
+                        continue
+                    raw_data = raw_line[5:].strip()
+                    if not raw_data or raw_data == "[DONE]":
+                        continue
+                    try:
+                        event = json.loads(raw_data)
+                    except json.JSONDecodeError:
+                        continue
+
+                    event_type = event.get("type", "")
+                    if event_type == "content_block_start":
+                        block = event.get("content_block") or {}
+                        block_type = block.get("type")
+                        current_block_type = str(block_type or "")
+                        current_block_id = str(
+                            block.get("id") or event.get("index") or ""
+                        )
+                        if block_type == "tool_use":
+                            current_tool_id = str(block.get("id") or "")
+                            current_tool_name = str(block.get("name") or "")
+                            tool_input_buffer = ""
+                            yield StreamChunk(
+                                type="tool_use_start",
+                                tool_use_id=current_tool_id,
+                                tool_name=current_tool_name,
+                            )
+
+                    elif event_type == "content_block_delta":
+                        delta = event.get("delta") or {}
+                        delta_type = delta.get("type")
+                        if delta_type == "text_delta":
+                            yield StreamChunk(
+                                type="text",
+                                text=safe_utf8_str(str(delta.get("text") or "")),
+                            )
+                        elif delta_type == "thinking_delta":
+                            yield StreamChunk(
+                                type="thinking",
+                                text=safe_utf8_str(str(delta.get("thinking") or "")),
+                            )
+                        elif delta_type == "input_json_delta":
+                            partial = str(delta.get("partial_json") or "")
+                            tool_input_buffer += partial
+                            yield StreamChunk(
+                                type="tool_use_delta",
+                                tool_use_id=current_tool_id,
+                                tool_input_json=partial,
+                            )
+
+                    elif event_type == "content_block_stop":
+                        if current_tool_id:
+                            yield StreamChunk(
+                                type="tool_use_end",
+                                tool_use_id=current_tool_id,
+                                tool_name=current_tool_name,
+                                tool_input_json=tool_input_buffer,
+                            )
+                            current_tool_id = ""
+                            current_tool_name = ""
+                            tool_input_buffer = ""
+                        yield StreamChunk(
+                            type="response_item_done",
+                            item_id=current_block_id,
+                            item_type=current_block_type,
+                        )
+                        current_block_type = ""
+                        current_block_id = ""
+
+                    elif event_type == "message_delta":
+                        usage = {}
+                        raw_usage = event.get("usage")
+                        if isinstance(raw_usage, dict):
+                            usage = _anthropic_usage(
+                                raw_usage,
+                                include_input=True,
+                                include_output=True,
+                            )
+                        delta = event.get("delta") or {}
+                        yield StreamChunk(
+                            type="message_delta",
+                            stop_reason=str(delta.get("stop_reason") or ""),
+                            usage=usage,
+                        )
+
+                    elif event_type == "message_start":
+                        usage = {}
+                        message = event.get("message") or {}
+                        raw_usage = message.get("usage")
+                        if isinstance(raw_usage, dict):
+                            usage = _anthropic_usage(
+                                raw_usage,
+                                include_input=True,
+                                include_output=True,
+                            )
+                        yield StreamChunk(type="message_start", usage=usage,
+                                          model_id=str(message.get("model") or ""))
+
+                    elif event_type == "message_stop":
+                        yield StreamChunk(type="message_stop")
+
+                    elif event_type == "error":
+                        error = event.get("error") or {}
+                        if isinstance(error, dict):
+                            message = error.get("message") or json.dumps(error, ensure_ascii=False)
+                        else:
+                            message = str(error or event)
+                        yield StreamChunk(
+                            type="error", error=message, error_body=event,
+                            error_status_code=response.status_code,
+                            error_request_id=response_request_id(response),
+                        )
+
+    async def resolve_context_window(self) -> int:
+        """Query the Anthropic Models API for context window, with caching."""
+        from crabcode_core.api.model_info import DEFAULT_CONTEXT_WINDOW, lookup_context_window
+
+        if self.config.context_window:
+            return self.config.context_window
+
+        if self._cached_context_window is not None:
+            return self._cached_context_window
+
+        model = self.config.model
+        if model:
+            try:
+                model_info = await self.client.models.retrieve(model_id=model)
+                window = getattr(model_info, "max_input_tokens", None)
+                if window:
+                    self._cached_context_window = window
+                    return window
+            except Exception:
+                logger.debug("Failed to query Anthropic Models API for %s", model, exc_info=True)
+
+        looked_up = lookup_context_window(model)
+        if looked_up is not None:
+            self._cached_context_window = looked_up
+            return looked_up
+
+        self._cached_context_window = DEFAULT_CONTEXT_WINDOW
+        return DEFAULT_CONTEXT_WINDOW
+
+    def _request_params(
+        self, messages: list[Message], system: list[str],
+        tools: list[dict[str, Any]], config: ModelConfig,
+    ) -> dict[str, Any]:
+        model = config.model or self.config.model
+        if not model:
+            raise ValueError(
+                f"No model configured. Set api.model in {get_config_home() / 'settings.json'} or use the -m flag."
+            )
+
+        system_blocks = safe_utf8_json_tree(
+            [{"type": "text", "text": s} for s in system if s]
+        )
+        # Mark the real static boundary; custom gateways must explicitly opt in.
+        static_count = getattr(system, "static_count", 0)
+        cache_enabled = self.config.prompt_caching == "enabled" or (
+            self.config.prompt_caching == "auto" and type(self) is AnthropicAdapter
+            and not self.config.base_url
+            and str(self.client.base_url).rstrip("/") == "https://api.anthropic.com"
+        )
+        if cache_enabled and static_count:
+            index = sum(bool(s) for s in system[:static_count]) - 1
+            if index >= 0:
+                system_blocks[index]["cache_control"] = {"type": "ephemeral"}
+
+        params: dict[str, Any] = {
+            "model": model,
+            "max_tokens": config.max_tokens,
+            "system": system_blocks,
+            "messages": _messages_to_api(messages),
+        }
+
+        api_tools = _tools_to_api(tools)
+        if api_tools:
+            params["tools"] = api_tools
+
+        if config.thinking_enabled:
+            params["thinking"] = {
+                "type": "enabled",
+                "budget_tokens": config.thinking_budget,
+            }
+
+        if config.reasoning_effort in {"low", "medium", "high", "xhigh", "max"}:
+            params["output_config"] = {"effort": config.reasoning_effort}
+
+        if config.temperature is not None:
+            params["temperature"] = config.temperature
+
+        return params
+
+    async def count_input_tokens(
+        self, messages: list[Message], system: list[str],
+        tools: list[dict[str, Any]], config: ModelConfig,
+    ) -> int | None:
+        # Bedrock/Vertex use different authentication and service endpoints.
+        if isinstance(self, (BedrockAdapter, VertexAdapter)):
+            return None
+        payload = self._request_params(messages, system, tools, config)
+        payload.pop("max_tokens", None)
+        payload.pop("temperature", None)
+        headers = {key: value for key, value in self._manual_headers().items()
+                   if key.lower() != "accept"}
+        headers["accept"] = "application/json"
+        return await self._count_tokens_http(
+            f"{self._messages_url()}/count_tokens", payload, headers,
+        )
+
+    async def stream_message(
+        self,
+        messages: list[Message],
+        system: list[str],
+        tools: list[dict[str, Any]],
+        config: ModelConfig,
+    ) -> AsyncGenerator[StreamChunk, None]:
+        params = self._request_params(messages, system, tools, config)
+
+        transport = self.config.anthropic_stream_transport
+        use_httpx_stream = transport == "httpx" or (
+            transport == "auto" and bool(self.config.base_url)
+        )
+        stream = (
+            self._stream_message_httpx(params) if use_httpx_stream
+            else self._stream_message_sdk(params)
+        )
+        stop_reason = ""
+        completed_tools = 0
+        pending_tool = False
+        try:
+            async for chunk in stream:
+                if chunk.stop_reason:
+                    stop_reason = chunk.stop_reason
+                if chunk.type == "tool_use_start":
+                    pending_tool = True
+                elif chunk.type == "tool_use_end":
+                    pending_tool = False
+                    completed_tools += 1
+                elif chunk.type == "message_stop":
+                    if pending_tool or (stop_reason == "tool_use" and not completed_tools):
+                        yield StreamChunk(
+                            type="error", retryable=True,
+                            error="Anthropic stream ended without a complete declared tool call",
+                        )
+                        return
+                    yield chunk
+                    return
+                yield chunk
+                if chunk.type == "error":
+                    return
+            # HTTP EOF (even HTTP 200 or [DONE]) is not the Messages protocol's
+            # message_stop. Let the query loop checkpoint completed items and
+            # consume its bounded reconnect budget instead of declaring success.
+            yield StreamChunk(
+                type="error", retryable=True,
+                error="Anthropic stream ended before message_stop (incomplete response)",
+            )
+        finally:
+            await stream.aclose()
+
+    async def _stream_message_sdk(
+        self, params: dict[str, Any],
+    ) -> AsyncGenerator[StreamChunk, None]:
+        current_tool_id = ""
+        current_tool_name = ""
+        tool_input_buffer = ""
+        current_block_type = ""
+        current_block_id = ""
+
+        async with self.client.messages.stream(**params) as stream:
+            async for event in stream:
+                event_type = getattr(event, "type", "")
+
+                if event_type == "content_block_start":
+                    block = event.content_block
+                    if hasattr(block, "type"):
+                        current_block_type = str(block.type)
+                        current_block_id = str(
+                            getattr(block, "id", "")
+                            or getattr(event, "index", "")
+                            or ""
+                        )
+                        if block.type == "tool_use":
+                            current_tool_id = block.id
+                            current_tool_name = block.name
+                            tool_input_buffer = ""
+                            yield StreamChunk(
+                                type="tool_use_start",
+                                tool_use_id=block.id,
+                                tool_name=block.name,
+                            )
+                        elif block.type == "thinking":
+                            pass
+                        elif block.type == "text":
+                            pass
+
+                elif event_type == "content_block_delta":
+                    delta = event.delta
+                    if hasattr(delta, "type"):
+                        if delta.type == "text_delta":
+                            yield StreamChunk(type="text", text=safe_utf8_str(delta.text))
+                        elif delta.type == "thinking_delta":
+                            yield StreamChunk(
+                                type="thinking", text=safe_utf8_str(delta.thinking)
+                            )
+                        elif delta.type == "input_json_delta":
+                            tool_input_buffer += delta.partial_json
+                            yield StreamChunk(
+                                type="tool_use_delta",
+                                tool_use_id=current_tool_id,
+                                tool_input_json=delta.partial_json,
+                            )
+
+                elif event_type == "content_block_stop":
+                    if current_tool_id:
+                        yield StreamChunk(
+                            type="tool_use_end",
+                            tool_use_id=current_tool_id,
+                            tool_name=current_tool_name,
+                            tool_input_json=tool_input_buffer,
+                        )
+                        current_tool_id = ""
+                        current_tool_name = ""
+                        tool_input_buffer = ""
+                    yield StreamChunk(
+                        type="response_item_done",
+                        item_id=current_block_id,
+                        item_type=current_block_type,
+                    )
+                    current_block_type = ""
+                    current_block_id = ""
+
+                elif event_type == "message_delta":
+                    usage = {}
+                    if hasattr(event, "usage") and event.usage:
+                        usage = _anthropic_usage(
+                            event.usage,
+                            include_input=True,
+                            include_output=True,
+                        )
+                    stop_reason = getattr(event.delta, "stop_reason", "") or ""
+                    yield StreamChunk(
+                        type="message_delta",
+                        stop_reason=stop_reason,
+                        usage=usage,
+                    )
+
+                elif event_type == "message_start":
+                    usage = {}
+                    if hasattr(event.message, "usage") and event.message.usage:
+                        usage = _anthropic_usage(
+                            event.message.usage,
+                            include_input=True,
+                            include_output=True,
+                        )
+                    yield StreamChunk(type="message_start", usage=usage,
+                                      model_id=str(getattr(event.message, "model", "") or ""))
+
+                elif event_type == "message_stop":
+                    yield StreamChunk(type="message_stop")
+
+    async def count_tokens(
+        self,
+        messages: list[Message],
+        system: list[str],
+    ) -> int:
+        try:
+            result = await self.client.messages.count_tokens(
+                model=self.config.model or "",
+                messages=_messages_to_api(messages),
+                system=[{"type": "text", "text": s} for s in system if s],
+            )
+            return result.input_tokens
+        except Exception:
+            logger.debug("Anthropic token counting failed; using heuristic estimate", exc_info=True)
+            total = sum(len(s) for s in system)
+            for msg in messages:
+                if isinstance(msg.content, str):
+                    total += len(msg.content)
+                else:
+                    for block in msg.content:
+                        if isinstance(block, TextBlock):
+                            total += len(block.text)
+            return total // 4
+
+
+class BedrockAdapter(AnthropicAdapter):
+    """Adapter for Anthropic via AWS Bedrock."""
+
+    def __init__(self, config: ApiConfig):
+        self.config = config
+        from crabcode_core.api.network import sdk_options
+        self.client = anthropic.AsyncAnthropicBedrock(**sdk_options(config))
+
+
+class VertexAdapter(AnthropicAdapter):
+    """Adapter for Anthropic via Google Vertex AI."""
+
+    def __init__(self, config: ApiConfig):
+        from crabcode_core.api.network import sdk_options
+        self.config = config
+        self.client = anthropic.AsyncAnthropicVertex(
+            region=os.environ.get("CLOUD_ML_REGION", "us-east5"),
+            project_id=os.environ.get("ANTHROPIC_VERTEX_PROJECT_ID"),
+            **sdk_options(config),
+        )