bareagent-cli 0.1.0__py3-none-any.whl

bareagent/provider/anthropic.py

@@ -0,0 +1,348 @@
+from __future__ import annotations
+
+from typing import Any
+
+import anthropic
+
+from bareagent.provider.base import (
+    BaseLLMProvider,
+    CacheConfig,
+    LLMResponse,
+    StreamEvent,
+    ThinkingConfig,
+    ToolCall,
+)
+
+_PROTECTED_KEYS = frozenset({"model", "messages", "tools", "system", "thinking", "max_tokens"})
+
+# Content-block types that may carry a ``cache_control`` breakpoint. Thinking /
+# redacted_thinking blocks must not, so the conversation breakpoint skips a
+# trailing thinking block rather than risk an API error.
+_CACHEABLE_BLOCK_TYPES = frozenset({"text", "image", "tool_use", "tool_result", "document"})
+
+
+class AnthropicProvider(BaseLLMProvider):
+    def __init__(
+        self,
+        api_key: str,
+        model: str,
+        thinking_config: ThinkingConfig | None = None,
+        cache_config: CacheConfig | None = None,
+    ) -> None:
+        # The app layer (src/core/retry.py) owns retries exclusively; disable
+        # the SDK's built-in retries to avoid 2xN compound amplification.
+        self.client = anthropic.Anthropic(api_key=api_key, max_retries=0)
+        self.model = model
+        self.thinking_config = thinking_config or ThinkingConfig()
+        # None => caching off (legacy byte-identical requests). factory always
+        # passes an instance, so the app defaults to caching ON.
+        self.cache_config = cache_config
+
+    def create(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]],
+        **kwargs: Any,
+    ) -> LLMResponse:
+        params = self._build_request_params(messages, tools, **kwargs)
+        response = self.client.messages.create(**params)
+        return self._parse_response(response)
+
+    def create_stream(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]],
+        **kwargs: Any,
+    ):
+        params = self._build_request_params(messages, tools, **kwargs)
+        with self.client.messages.stream(**params) as stream:
+            for event in stream:
+                if event.type == "content_block_delta" and event.delta.type == "text_delta":
+                    yield StreamEvent(type="text", text=event.delta.text)
+                    continue
+
+                if event.type != "content_block_stop":
+                    continue
+
+                content_block = event.content_block
+                if content_block.type != "tool_use":
+                    continue
+
+                yield StreamEvent(
+                    type="tool_call",
+                    tool_call_id=content_block.id,
+                    name=content_block.name,
+                    input=dict(content_block.input or {}),
+                )
+
+            return self._parse_response(stream.get_final_message())
+
+    def _build_request_params(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]],
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        system_prompt, anthropic_messages = self._convert_messages(messages)
+        max_tokens = int(kwargs.get("max_tokens", 8000))
+        if self.thinking_config.mode in {"enabled", "adaptive"}:
+            max_tokens = max(max_tokens, self.thinking_config.budget_tokens + 1)
+
+        params: dict[str, Any] = {
+            "model": self.model,
+            "messages": anthropic_messages,
+            "max_tokens": max_tokens,
+        }
+        converted_tools = self._convert_tools(tools)
+        system_value: str | list[dict[str, Any]] | None = system_prompt or None
+
+        if self._caching_enabled():
+            cache_control = self._cache_control()
+            # tools render first, then system, then messages; a breakpoint on
+            # the last system block already caches tools+system, but a separate
+            # breakpoint on the last tool gives an independent tools-only cache
+            # segment (cheap insurance, no double-billing). <=3 breakpoints total
+            # (tools, system, last message) — well within Anthropic's max of 4.
+            if converted_tools:
+                converted_tools[-1] = {**converted_tools[-1], "cache_control": cache_control}
+            if system_prompt:
+                system_value = [
+                    {"type": "text", "text": system_prompt, "cache_control": cache_control}
+                ]
+            self._apply_conversation_breakpoint(anthropic_messages, cache_control)
+
+        if converted_tools:
+            params["tools"] = converted_tools
+        if system_value:
+            params["system"] = system_value
+        if self.thinking_config.mode in {"enabled", "adaptive"}:
+            params["thinking"] = {
+                "type": self.thinking_config.mode,
+                "budget_tokens": self.thinking_config.budget_tokens,
+            }
+        params.update({k: v for k, v in kwargs.items() if k not in _PROTECTED_KEYS})
+        return params
+
+    def _caching_enabled(self) -> bool:
+        return self.cache_config is not None and self.cache_config.enabled
+
+    def _cache_control(self) -> dict[str, Any]:
+        control: dict[str, Any] = {"type": "ephemeral"}
+        if self.cache_config is not None and self.cache_config.ttl == "1h":
+            control["ttl"] = "1h"
+        return control
+
+    def _apply_conversation_breakpoint(
+        self,
+        messages: list[dict[str, Any]],
+        cache_control: dict[str, Any],
+    ) -> None:
+        """Attach a ``cache_control`` breakpoint to the last message's last block.
+
+        This is the moving incremental-caching breakpoint: each request only
+        appends a couple of blocks since the previous one, so the 20-block
+        lookback reliably finds the prior cached prefix. The message dicts here
+        are freshly built by ``_convert_messages`` (not shared with the caller),
+        so in-place mutation is safe.
+        """
+        if not messages:
+            return
+        last = messages[-1]
+        content = last.get("content")
+        if isinstance(content, str):
+            if content:
+                last["content"] = [
+                    {"type": "text", "text": content, "cache_control": cache_control}
+                ]
+            return
+        if isinstance(content, list) and content:
+            last_block = content[-1]
+            if last_block.get("type") in _CACHEABLE_BLOCK_TYPES:
+                content[-1] = {**last_block, "cache_control": cache_control}
+
+    def _convert_messages(
+        self,
+        messages: list[dict[str, Any]],
+    ) -> tuple[str | None, list[dict[str, Any]]]:
+        system_parts: list[str] = []
+        converted: list[dict[str, Any]] = []
+
+        for message in messages:
+            role = message["role"]
+            content = message.get("content", "")
+            if role == "system":
+                text = self._stringify_content(content)
+                if text:
+                    system_parts.append(text)
+                continue
+
+            converted.append(
+                {
+                    "role": role,
+                    "content": self._convert_message_content(content),
+                }
+            )
+
+        system_prompt = "\n\n".join(part for part in system_parts if part) or None
+        return system_prompt, converted
+
+    def _convert_message_content(self, content: Any) -> str | list[dict[str, Any]]:
+        if isinstance(content, str):
+            return content
+        if not isinstance(content, list):
+            return str(content)
+
+        converted_blocks: list[dict[str, Any]] = []
+        for block in content:
+            block_type = block.get("type")
+            if block_type == "text":
+                converted_blocks.append({"type": "text", "text": block.get("text", "")})
+                continue
+            if block_type == "tool_use":
+                converted_blocks.append(
+                    {
+                        "type": "tool_use",
+                        "id": block.get("id", ""),
+                        "name": block.get("name", ""),
+                        "input": block.get("input", {}),
+                    }
+                )
+                continue
+            if block_type == "tool_result":
+                result_block: dict[str, Any] = {
+                    "type": "tool_result",
+                    "tool_use_id": block.get("tool_use_id", ""),
+                    "content": self._convert_tool_result_content(block.get("content", "")),
+                }
+                if block.get("is_error"):
+                    result_block["is_error"] = True
+                converted_blocks.append(result_block)
+                continue
+            if block_type == "thinking" and block.get("signature"):
+                converted_blocks.append(
+                    {
+                        "type": "thinking",
+                        "thinking": block.get("thinking", ""),
+                        "signature": block["signature"],
+                    }
+                )
+                continue
+            if block_type == "redacted_thinking":
+                converted_blocks.append(
+                    {
+                        "type": "redacted_thinking",
+                        "data": block.get("data", ""),
+                    }
+                )
+                continue
+
+        return converted_blocks
+
+    def _convert_tool_result_content(self, content: Any) -> str | list[dict[str, Any]]:
+        if isinstance(content, str):
+            return content
+        if isinstance(content, list):
+            blocks: list[dict[str, Any]] = []
+            for item in content:
+                if not isinstance(item, dict):
+                    blocks.append({"type": "text", "text": self._stringify_content(item)})
+                    continue
+                item_type = item.get("type")
+                if item_type == "text":
+                    blocks.append({"type": "text", "text": item.get("text", "")})
+                    continue
+                if item_type == "image":
+                    # BareAgent's internal image shape is already Anthropic-native.
+                    source = item.get("source")
+                    if (
+                        isinstance(source, dict)
+                        and source.get("type") == "base64"
+                        and source.get("data")
+                    ):
+                        blocks.append(
+                            {
+                                "type": "image",
+                                "source": {
+                                    "type": "base64",
+                                    "media_type": source.get("media_type", "image/png"),
+                                    "data": source.get("data", ""),
+                                },
+                            }
+                        )
+                        continue
+                    blocks.append({"type": "text", "text": self._stringify_content(item)})
+                    continue
+                blocks.append({"type": "text", "text": self._stringify_content(item)})
+            return blocks
+        return self._stringify_content(content)
+
+    def _convert_tools(self, tools: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        return [
+            {
+                "name": tool["name"],
+                "description": tool.get("description", ""),
+                "input_schema": tool.get("parameters", {"type": "object", "properties": {}}),
+            }
+            for tool in tools
+        ]
+
+    def _parse_response(self, response: Any) -> LLMResponse:
+        text_parts: list[str] = []
+        thinking_parts: list[str] = []
+        tool_calls: list[ToolCall] = []
+        content_blocks: list[dict[str, Any]] = []
+
+        for block in getattr(response, "content", []):
+            block_type = getattr(block, "type", "")
+            if block_type == "text":
+                text = getattr(block, "text", "")
+                text_parts.append(text)
+                content_blocks.append({"type": "text", "text": text})
+            elif block_type == "thinking":
+                thinking = getattr(block, "thinking", "")
+                signature = getattr(block, "signature", "")
+                thinking_parts.append(thinking)
+                thinking_block: dict[str, Any] = {
+                    "type": "thinking",
+                    "thinking": thinking,
+                }
+                if signature:
+                    thinking_block["signature"] = signature
+                content_blocks.append(thinking_block)
+            elif block_type == "redacted_thinking":
+                content_blocks.append(
+                    {
+                        "type": "redacted_thinking",
+                        "data": getattr(block, "data", ""),
+                    }
+                )
+            elif block_type == "tool_use":
+                tool_input = dict(getattr(block, "input", {}) or {})
+                tool_calls.append(
+                    ToolCall(
+                        id=getattr(block, "id", ""),
+                        name=getattr(block, "name", ""),
+                        input=tool_input,
+                    )
+                )
+                content_blocks.append(
+                    {
+                        "type": "tool_use",
+                        "id": getattr(block, "id", ""),
+                        "name": getattr(block, "name", ""),
+                        "input": tool_input,
+                    }
+                )
+
+        usage = getattr(response, "usage", None)
+        return LLMResponse(
+            text="".join(text_parts),
+            tool_calls=tool_calls,
+            stop_reason=getattr(response, "stop_reason", "") or "",
+            input_tokens=getattr(usage, "input_tokens", 0) or 0,
+            output_tokens=getattr(usage, "output_tokens", 0) or 0,
+            cache_creation_input_tokens=getattr(usage, "cache_creation_input_tokens", 0) or 0,
+            cache_read_input_tokens=getattr(usage, "cache_read_input_tokens", 0) or 0,
+            thinking="\n\n".join(part for part in thinking_parts if part),
+            content_blocks=content_blocks,
+        )

bareagent/provider/base.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+import json
+from abc import ABC, abstractmethod
+from collections.abc import Generator
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+from bareagent.core.fileutil import stringify
+
+
+@dataclass(slots=True)
+class ThinkingConfig:
+    """Extended thinking settings shared across providers."""
+
+    mode: Literal["enabled", "adaptive", "disabled"] = "adaptive"
+    budget_tokens: int = 10000
+
+
+VALID_THINKING_MODES: frozenset[str] = frozenset({"enabled", "adaptive", "disabled"})
+
+
+@dataclass(slots=True)
+class CacheConfig:
+    """Prompt-caching settings (Anthropic explicit ``cache_control`` breakpoints).
+
+    Provider-neutral by name, but today only the Anthropic provider acts on it:
+    OpenAI/DeepSeek cache automatically with no request-side knob. A ``None``
+    cache_config passed to a provider means "caching off" (byte-identical legacy
+    requests); ``factory.create_provider`` always supplies an instance so the app
+    defaults to caching ON.
+    """
+
+    enabled: bool = True
+    ttl: Literal["5m", "1h"] = "5m"
+
+
+VALID_CACHE_TTLS: frozenset[str] = frozenset({"5m", "1h"})
+
+
+@dataclass(slots=True)
+class ToolCall:
+    id: str
+    name: str
+    input: dict[str, Any]
+
+
+@dataclass(slots=True)
+class StreamEvent:
+    type: str
+    text: str = ""
+    tool_call_id: str = ""
+    name: str = ""
+    input: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(slots=True)
+class LLMResponse:
+    text: str
+    stop_reason: str
+    input_tokens: int
+    output_tokens: int
+    # Prompt-caching usage (additive, non-overlapping with input_tokens). For
+    # Anthropic these come straight off the wire; for OpenAI/DeepSeek the
+    # provider normalizes auto-cache hits into cache_read_input_tokens so the
+    # three fields carry one consistent meaning across providers:
+    #   input_tokens  = full-price input (1x)
+    #   cache_read_input_tokens     = served from cache (read discount)
+    #   cache_creation_input_tokens = written to cache (write premium; Anthropic
+    #                                 only — 0 for auto-caching providers)
+    cache_creation_input_tokens: int = 0
+    cache_read_input_tokens: int = 0
+    tool_calls: list[ToolCall] = field(default_factory=list)
+    thinking: str = ""
+    content_blocks: list[dict[str, Any]] = field(default_factory=list)
+
+    @property
+    def has_tool_calls(self) -> bool:
+        return len(self.tool_calls) > 0
+
+    def to_message(self) -> dict[str, Any]:
+        """Convert the normalized response back into an assistant message."""
+        if self.content_blocks:
+            return {
+                "role": "assistant",
+                "content": [dict(block) for block in self.content_blocks],
+            }
+
+        if not self.tool_calls:
+            return {"role": "assistant", "content": self.text}
+
+        content: list[dict[str, Any]] = []
+        if self.text:
+            content.append({"type": "text", "text": self.text})
+        for tool_call in self.tool_calls:
+            content.append(
+                {
+                    "type": "tool_use",
+                    "id": tool_call.id,
+                    "name": tool_call.name,
+                    "input": tool_call.input,
+                }
+            )
+
+        return {"role": "assistant", "content": content}
+
+
+class BaseLLMProvider(ABC):
+    @abstractmethod
+    def create(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]],
+        **kwargs: Any,
+    ) -> LLMResponse:
+        """Create a non-streaming response."""
+
+    @abstractmethod
+    def create_stream(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]],
+        **kwargs: Any,
+    ) -> Generator[StreamEvent, None, LLMResponse]:
+        """Yield streaming events and return the final normalized response."""
+
+    def _stringify_content(self, content: Any) -> str:
+        if isinstance(content, list):
+            text_parts: list[str] = []
+            for block in content:
+                if isinstance(block, dict) and block.get("type") == "text":
+                    text_parts.append(str(block.get("text", "")))
+                else:
+                    text_parts.append(json.dumps(block, ensure_ascii=False, default=str))
+            return "\n".join(part for part in text_parts if part)
+        return stringify(content)

bareagent/provider/factory.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import logging
+import os
+from typing import Any, Literal, cast
+
+from bareagent.provider.anthropic import AnthropicProvider
+from bareagent.provider.base import (
+    VALID_CACHE_TTLS,
+    VALID_THINKING_MODES,
+    BaseLLMProvider,
+    CacheConfig,
+    ThinkingConfig,
+)
+from bareagent.provider.openai import OpenAIProvider
+from bareagent.provider.presets import resolve_preset
+
+
+def _resolve_api_key(provider_config: Any) -> str:
+    """Resolve the API key, preferring an explicit plaintext key.
+
+    Priority: ``provider_config.api_key`` (explicit plaintext, used as-is) ->
+    ``provider_config.api_key_env`` (an ``sk-`` value is treated as plaintext,
+    otherwise it names an environment variable). Fixes non-``sk-`` prefixed
+    keys (qwen/glm) being misread as env var names.
+    """
+    explicit_key = getattr(provider_config, "api_key", None)
+    if explicit_key:
+        return str(explicit_key)
+
+    api_key_env = getattr(provider_config, "api_key_env", "")
+    if not api_key_env:
+        raise ValueError(
+            "Provider config is missing both 'api_key' and 'api_key_env'. "
+            "Please provide the API key directly via 'api_key', or specify the "
+            "environment variable name that holds it via 'api_key_env'."
+        )
+    if api_key_env.startswith("sk-"):
+        return api_key_env
+    api_key = os.getenv(api_key_env)
+    if not api_key:
+        raise ValueError(f"Missing API key in environment variable: {api_key_env}")
+    return api_key
+
+
+def create_provider(config: Any) -> BaseLLMProvider:
+    provider_config = getattr(config, "provider", None)
+    if provider_config is None:
+        raise ValueError("Config is missing a provider section.")
+
+    provider_name = str(getattr(provider_config, "name", "")).strip().lower()
+    model = getattr(provider_config, "model", "")
+    api_key = _resolve_api_key(provider_config)
+
+    preset = resolve_preset(provider_name)
+    if preset is None:
+        raise ValueError(f"Unknown provider: {provider_name}")
+
+    if preset.route == "anthropic":
+        return AnthropicProvider(
+            api_key=api_key,
+            model=model,
+            thinking_config=_build_thinking_config(getattr(config, "thinking", None)),
+            cache_config=_build_cache_config(getattr(config, "cache", None)),
+        )
+
+    base_url = getattr(provider_config, "base_url", None) or preset.default_base_url
+    return OpenAIProvider(
+        api_key=api_key,
+        model=model,
+        base_url=base_url,
+        wire_api=getattr(provider_config, "wire_api", None),
+    )
+
+
+def _validated_thinking_mode(mode: str) -> Literal["enabled", "adaptive", "disabled"]:
+    if mode not in VALID_THINKING_MODES:
+        logging.warning("Invalid thinking mode %r, falling back to 'adaptive'", mode)
+        return "adaptive"
+    return cast(Literal["enabled", "adaptive", "disabled"], mode)
+
+
+def _validated_cache_ttl(ttl: str) -> Literal["5m", "1h"]:
+    if ttl not in VALID_CACHE_TTLS:
+        logging.warning("Invalid cache ttl %r, falling back to '5m'", ttl)
+        return "5m"
+    return cast(Literal["5m", "1h"], ttl)
+
+
+def _build_cache_config(raw_config: Any) -> CacheConfig:
+    """Coerce a config-supplied cache section into a :class:`CacheConfig`.
+
+    ``None`` (e.g. a namespace without a cache attribute) yields the default
+    enabled instance so the app defaults to caching ON.
+    """
+    if raw_config is None:
+        return CacheConfig()
+    if isinstance(raw_config, CacheConfig):
+        return CacheConfig(
+            enabled=bool(raw_config.enabled),
+            ttl=_validated_cache_ttl(raw_config.ttl),
+        )
+    if isinstance(raw_config, dict):
+        return CacheConfig(
+            enabled=bool(raw_config.get("enabled", True)),
+            ttl=_validated_cache_ttl(str(raw_config.get("ttl", "5m"))),
+        )
+    return CacheConfig(
+        enabled=bool(getattr(raw_config, "enabled", True)),
+        ttl=_validated_cache_ttl(str(getattr(raw_config, "ttl", "5m"))),
+    )
+
+
+def _build_thinking_config(raw_config: Any) -> ThinkingConfig:
+    if raw_config is None:
+        return ThinkingConfig()
+    if isinstance(raw_config, ThinkingConfig):
+        return ThinkingConfig(
+            mode=_validated_thinking_mode(raw_config.mode),
+            budget_tokens=raw_config.budget_tokens,
+        )
+    if isinstance(raw_config, dict):
+        return ThinkingConfig(
+            mode=_validated_thinking_mode(str(raw_config.get("mode", "adaptive"))),
+            budget_tokens=int(raw_config.get("budget_tokens", 10000)),
+        )
+    return ThinkingConfig(
+        mode=_validated_thinking_mode(str(getattr(raw_config, "mode", "adaptive"))),
+        budget_tokens=int(getattr(raw_config, "budget_tokens", 10000)),
+    )