aria-code 4.1.3__py3-none-any.whl

providers/llm/anthropic.py

@@ -0,0 +1,184 @@
+"""
+providers/llm/anthropic.py — Anthropic Claude Provider
+=======================================================
+支持 claude-3-5-sonnet / claude-3-haiku / claude-3-opus 等。
+支持流式 thinking（扩展思考模式）。
+
+需要设置: ANTHROPIC_API_KEY=sk-ant-...
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from typing import Any, AsyncIterator, Dict, List, Optional
+
+from .base import BaseLLMProvider, Message, ProviderConfig
+
+logger = logging.getLogger(__name__)
+
+_ANTHROPIC_API_URL = "https://api.anthropic.com/v1/messages"
+_ANTHROPIC_VERSION = "2023-06-01"
+
+
+class AnthropicProvider(BaseLLMProvider):
+
+    provider_name     = "anthropic"
+    supports_tools    = True
+    supports_thinking = True    # claude-3-5-sonnet 支持 extended thinking
+    local             = False
+
+    DEFAULT_MODEL = "claude-3-5-haiku-latest"
+
+    def __init__(self, config: ProviderConfig):
+        super().__init__(config)
+        self.api_key = config.api_key or os.getenv("ANTHROPIC_API_KEY", "")
+        self.model   = config.model or self.DEFAULT_MODEL
+
+    async def is_available(self) -> bool:
+        return bool(self.api_key)
+
+    # Minimum system-prompt length (chars) to bother caching.
+    # Prompts shorter than this don't benefit from prompt caching.
+    _CACHE_MIN_CHARS = 1024
+
+    def _build_cached_system(self, system_text: str) -> list:
+        """
+        Wrap a long system prompt in a cache_control block so Anthropic
+        caches it across calls.  Returns the `system` field value (a list
+        of content blocks, or a plain string for short prompts).
+
+        Anthropic prompt caching docs:
+          https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching
+        """
+        if len(system_text) < self._CACHE_MIN_CHARS:
+            return system_text  # type: ignore[return-value]
+        return [
+            {
+                "type": "text",
+                "text": system_text,
+                "cache_control": {"type": "ephemeral"},
+            }
+        ]
+
+    async def stream(
+        self,
+        messages: List[Message],
+        tools: Optional[List[Dict]] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        cancel_event=None,
+    ) -> AsyncIterator[Dict[str, Any]]:
+        import aiohttp
+
+        temp     = temperature if temperature is not None else self.config.temperature
+        n_tokens = max_tokens  if max_tokens  is not None else self.config.max_tokens
+
+        # Anthropic 格式：system 单独提取
+        system_parts = [m.content for m in messages if m.role == "system"]
+        system_text  = "\n\n".join(system_parts) if system_parts else None
+        anthro_msgs  = [
+            {"role": m.role, "content": m.content}
+            for m in messages if m.role != "system"
+        ]
+
+        payload: Dict[str, Any] = {
+            "model":      self.model,
+            "max_tokens": n_tokens,
+            "messages":   anthro_msgs,
+            "stream":     True,
+        }
+        if system_text:
+            # Use prompt caching for long system prompts to reduce TTFT and cost
+            payload["system"] = self._build_cached_system(system_text)
+        if temp > 0:
+            payload["temperature"] = temp
+        if tools:
+            payload["tools"] = [
+                {
+                    "name":         t.get("name"),
+                    "description":  t.get("description", ""),
+                    "input_schema": t.get("parameters", {"type": "object", "properties": {}}),
+                }
+                for t in tools
+            ]
+
+        headers = {
+            "x-api-key":           self.api_key,
+            "anthropic-version":   _ANTHROPIC_VERSION,
+            "anthropic-beta":      "prompt-caching-2024-07-31",
+            "content-type":        "application/json",
+        }
+
+        proxy = (os.getenv("HTTPS_PROXY") or os.getenv("https_proxy")
+                 or os.getenv("HTTP_PROXY")  or os.getenv("http_proxy"))
+        try:
+            async with aiohttp.ClientSession() as sess:
+                async with sess.post(
+                    _ANTHROPIC_API_URL, json=payload, headers=headers,
+                    proxy=proxy,
+                    timeout=aiohttp.ClientTimeout(total=self.config.timeout)
+                ) as resp:
+                    if resp.status != 200:
+                        body = await resp.text()
+                        yield {"type": "error",
+                               "message": f"Anthropic HTTP {resp.status}: {body[:300]}"}
+                        return
+
+                    _pending_tool_name = ""
+                    _pending_tool_args = ""
+
+                    async for raw in resp.content:
+                        if cancel_event and cancel_event.is_set():
+                            return
+                        line = raw.decode("utf-8", errors="ignore").strip()
+                        if not line or not line.startswith("data:"):
+                            continue
+
+                        try:
+                            data = json.loads(line[5:].strip())
+                        except json.JSONDecodeError:
+                            continue
+
+                        etype = data.get("type", "")
+
+                        # 思考 token（扩展思考模式）
+                        if etype == "content_block_start":
+                            cb = data.get("content_block", {})
+                            if cb.get("type") == "thinking":
+                                yield {"type": "thinking", "text": cb.get("thinking", "")}
+                            elif cb.get("type") == "tool_use":
+                                _pending_tool_name = cb.get("name", "")
+                                _pending_tool_args = ""
+
+                        elif etype == "content_block_delta":
+                            delta = data.get("delta", {})
+                            dt    = delta.get("type", "")
+                            if dt == "text_delta":
+                                yield {"type": "token", "text": delta.get("text", "")}
+                            elif dt == "thinking_delta":
+                                yield {"type": "thinking", "text": delta.get("thinking", "")}
+                            elif dt == "input_json_delta":
+                                _pending_tool_args += delta.get("partial_json", "")
+
+                        elif etype == "content_block_stop":
+                            if _pending_tool_name:
+                                try:
+                                    args = json.loads(_pending_tool_args)
+                                except Exception:
+                                    args = {"_raw": _pending_tool_args}
+                                yield {"type": "tool_call",
+                                       "name": _pending_tool_name,
+                                       "arguments": args}
+                                _pending_tool_name = ""
+                                _pending_tool_args = ""
+
+                        elif etype == "message_stop":
+                            yield {"type": "done"}
+                            return
+
+        except aiohttp.ClientConnectorError as e:
+            yield {"type": "error", "message": f"Anthropic 连接失败: {e}"}
+        except Exception as e:
+            yield {"type": "error", "message": f"Anthropic 错误: {e}"}

providers/llm/base.py

@@ -0,0 +1,139 @@
+"""
+providers/llm/base.py — LLM Provider 统一抽象基类
+==================================================
+所有 provider（本地/云端）实现同一接口，上层代码无需关心具体后端。
+
+事件类型 (stream yields):
+    {"type": "token",     "text": "..."}          # 文本增量
+    {"type": "thinking",  "text": "..."}          # 思考过程 (Claude/DeepSeek-R1)
+    {"type": "tool_call", "name": "...", "arguments": {...}}  # 工具调用
+    {"type": "done",      "text": "完整响应"}      # 流结束
+    {"type": "error",     "message": "..."}       # 错误
+"""
+
+from __future__ import annotations
+
+import os
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Any, AsyncIterator, Dict, List, Optional
+
+
+@dataclass
+class Message:
+    role: str       # "system" | "user" | "assistant" | "tool"
+    content: str
+    name: Optional[str] = None        # tool name (for role=tool)
+    tool_call_id: Optional[str] = None
+
+
+@dataclass
+class ProviderConfig:
+    """可由 providers.yaml / 环境变量 / CLI 参数覆盖"""
+    name:        str
+    api_key:     Optional[str]   = None
+    base_url:    Optional[str]   = None
+    model:       Optional[str]   = None
+    temperature: float           = 0.3
+    max_tokens:  int             = 4096
+    timeout:     int             = 120
+    # 扩展字段（各 provider 可自定义）
+    extra:       Dict[str, Any]  = field(default_factory=dict)
+
+    @classmethod
+    def from_env(cls, name: str, **defaults) -> "ProviderConfig":
+        """从环境变量自动读取 API Key（DEEPSEEK_API_KEY / OPENAI_API_KEY 等）"""
+        key_map = {
+            "deepseek":    "DEEPSEEK_API_KEY",
+            "openai":      "OPENAI_API_KEY",
+            "anthropic":   "ANTHROPIC_API_KEY",
+            "groq":        "GROQ_API_KEY",
+            "together":    "TOGETHER_API_KEY",
+            "dashscope":   "DASHSCOPE_API_KEY",
+            "siliconflow": "SILICONFLOW_API_KEY",
+            "moonshot":    "MOONSHOT_API_KEY",
+            "zhipu":       "ZHIPUAI_API_KEY",
+        }
+        env_var = key_map.get(name.lower())
+        api_key = os.getenv(env_var, "") if env_var else ""
+        return cls(name=name, api_key=api_key or None, **defaults)
+
+    def is_configured(self) -> bool:
+        """判断 provider 是否可用（本地 provider 无需 api_key）"""
+        _local = {"ollama", "lmstudio", "vllm", "llamacpp", "jan"}
+        if self.name.lower() in _local:
+            return True
+        return bool(self.api_key)
+
+
+class BaseLLMProvider(ABC):
+    """
+    所有 LLM provider 的统一基类。
+
+    子类只需实现 `stream()` 方法；`complete()` 会自动聚合流结果。
+    """
+
+    # 子类声明这些属性
+    provider_name: str = "base"
+    supports_tools: bool = False
+    supports_thinking: bool = False
+    local: bool = False          # True = 本地运行，不需要 api_key
+
+    def __init__(self, config: ProviderConfig):
+        self.config = config
+
+    # ── 必须实现 ──────────────────────────────────────────────────────────────
+
+    @abstractmethod
+    async def stream(
+        self,
+        messages: List[Message],
+        tools: Optional[List[Dict]] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        cancel_event=None,
+    ) -> AsyncIterator[Dict[str, Any]]:
+        """
+        流式生成 token。
+
+        每次 yield 一个事件 dict（见模块文档中的事件类型）。
+        """
+        ...
+        yield {}  # 让 Python 识别为 async generator
+
+    # ── 默认实现（子类可覆盖）────────────────────────────────────────────────
+
+    async def complete(
+        self,
+        messages: List[Message],
+        tools: Optional[List[Dict]] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """聚合 stream() 事件，返回完整响应 dict。"""
+        full_text = ""
+        tool_calls = []
+        async for event in self.stream(
+            messages, tools=tools,
+            temperature=temperature, max_tokens=max_tokens,
+        ):
+            t = event.get("type")
+            if t == "token":
+                full_text += event.get("text", "")
+            elif t == "tool_call":
+                tool_calls.append({
+                    "name": event.get("name"),
+                    "arguments": event.get("arguments", {}),
+                })
+            elif t == "error":
+                return {"success": False, "error": event.get("message"),
+                        "response": full_text, "tool_calls": tool_calls}
+        return {"success": True, "response": full_text, "tool_calls": tool_calls}
+
+    async def is_available(self) -> bool:
+        """检查 provider 是否在线/可用（子类覆盖以做实际探测）"""
+        return self.config.is_configured()
+
+    def __repr__(self) -> str:
+        model = self.config.model or "default"
+        return f"{self.__class__.__name__}(model={model})"

providers/llm/ollama.py

@@ -0,0 +1,128 @@
+"""
+providers/llm/ollama.py — Ollama 本地 LLM Provider
+====================================================
+连接本地运行的 Ollama 服务，支持工具调用（native + text-based fallback）。
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any, AsyncIterator, Dict, List, Optional
+
+from .base import BaseLLMProvider, Message, ProviderConfig
+
+logger = logging.getLogger(__name__)
+
+
+class OllamaProvider(BaseLLMProvider):
+
+    provider_name    = "ollama"
+    supports_tools   = True
+    supports_thinking = False
+    local            = True
+
+    DEFAULT_URL = "http://localhost:11434"
+
+    def __init__(self, config: ProviderConfig):
+        super().__init__(config)
+        self.base_url = config.base_url or self.DEFAULT_URL
+        self.model    = config.model or "qwen2.5:7b"
+
+    async def is_available(self) -> bool:
+        """探测 Ollama 服务是否在线"""
+        import urllib.request
+        for url in [self.base_url,
+                    self.base_url.replace("localhost", "127.0.0.1")]:
+            try:
+                urllib.request.urlopen(f"{url}/api/tags", timeout=2).close()
+                return True
+            except Exception:
+                continue
+        return False
+
+    async def list_models(self) -> List[str]:
+        """返回已安装的模型列表"""
+        import urllib.request, json as _json
+        try:
+            with urllib.request.urlopen(f"{self.base_url}/api/tags", timeout=3) as r:
+                data = _json.loads(r.read())
+                return [m["name"] for m in data.get("models", [])]
+        except Exception:
+            return []
+
+    async def stream(
+        self,
+        messages: List[Message],
+        tools: Optional[List[Dict]] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        cancel_event=None,
+    ) -> AsyncIterator[Dict[str, Any]]:
+        import aiohttp
+
+        temp     = temperature if temperature is not None else self.config.temperature
+        n_tokens = max_tokens  if max_tokens  is not None else self.config.max_tokens
+
+        payload = {
+            "model":   self.model,
+            "messages": [{"role": m.role, "content": m.content} for m in messages],
+            "stream":  True,
+            "options": {"temperature": temp, "num_predict": n_tokens, "num_ctx": 32768},
+        }
+        if tools:
+            # 只有支持 native tool call 的模型才注入（其他走 text-based 解析）
+            payload["tools"] = tools
+
+        url = f"{self.base_url}/api/chat"
+        try:
+            async with aiohttp.ClientSession() as sess:
+                async with sess.post(
+                    url, json=payload,
+                    timeout=aiohttp.ClientTimeout(total=self.config.timeout)
+                ) as resp:
+                    if resp.status != 200:
+                        body = await resp.text()
+                        yield {"type": "error",
+                               "message": f"Ollama HTTP {resp.status}: {body[:200]}"}
+                        return
+
+                    async for raw in resp.content:
+                        if cancel_event and cancel_event.is_set():
+                            return
+                        line = raw.decode("utf-8", errors="ignore").strip()
+                        if not line:
+                            continue
+                        try:
+                            data = json.loads(line)
+                        except json.JSONDecodeError:
+                            continue
+
+                        # Native tool calls
+                        tc_list = (data.get("message") or {}).get("tool_calls") or []
+                        for tc in tc_list:
+                            fn = tc.get("function") or {}
+                            args = fn.get("arguments", {})
+                            if isinstance(args, str):
+                                try:
+                                    args = json.loads(args)
+                                except json.JSONDecodeError:
+                                    args = {"_raw": args}
+                            yield {"type": "tool_call",
+                                   "name": fn.get("name", ""),
+                                   "arguments": args}
+
+                        # Text token
+                        token = (data.get("message") or {}).get("content", "")
+                        if token:
+                            yield {"type": "token", "text": token}
+
+                        if data.get("done"):
+                            yield {"type": "done"}
+                            return
+
+        except aiohttp.ClientConnectorError as e:
+            yield {"type": "error",
+                   "message": f"Ollama 连接失败 ({self.base_url}): {e}"}
+        except Exception as e:
+            yield {"type": "error", "message": f"Ollama 错误: {e}"}