aria-code 0.52.0__py3-none-any.whl

aria_code/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}"}

aria_code/providers/llm/autoconfig.py

@@ -0,0 +1,213 @@
+"""按用户的**实际环境**生成 providers.yaml，而不是发一份通用模板。
+
+为什么不是写死一份文档让用户照抄：通用模板对每个人都是"差不多但不对"——
+装了 Ollama 的人不需要被告知怎么配 OpenAI，配了 DEEPSEEK_API_KEY 的人不该看到
+一堆用不上的占位符，而真正卡住他的（本地服务没起来 / key 名字拼错）模板里
+一个字都不会提。
+
+这里的做法是先探测再生成：
+  - 本地推理服务（Ollama / LM Studio）是否在跑、跑着哪些模型
+  - 哪些 provider 的环境变量已经设了
+  - 用户已有的配置文件里声明过什么
+
+然后产出一份**只包含这台机器上真的能用的东西**的配置，并把"还差什么、
+去哪拿"作为注释写进同一个文件——用户不必在文档和配置之间来回对照。
+
+探测全部是只读的：不发请求到任何云端 provider（那需要消耗用户的额度，也会
+把 key 泄给一次纯粹的探活），只查本地端口和环境变量。云端 provider 的判定
+标准就是"环境变量在不在"，这跟 registry 实际取 key 的方式完全一致。
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import socket
+import urllib.error
+import urllib.request
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+from urllib.parse import urlparse
+
+__all__ = ["Finding", "probe_environment", "render_providers_yaml", "suggest_default_chain"]
+
+# (provider id, 环境变量, 默认模型, 去哪拿 key)
+_CLOUD_PROVIDERS: List[tuple] = [
+    ("deepseek",    "DEEPSEEK_API_KEY",    "deepseek-chat",                  "https://platform.deepseek.com/api_keys"),
+    ("siliconflow", "SILICONFLOW_API_KEY", "deepseek-ai/DeepSeek-V3",        "https://cloud.siliconflow.cn/account/ak"),
+    ("dashscope",   "DASHSCOPE_API_KEY",   "qwen-plus",                      "https://bailian.console.aliyun.com/"),
+    ("moonshot",    "MOONSHOT_API_KEY",    "moonshot-v1-8k",                 "https://platform.moonshot.cn/console/api-keys"),
+    ("zhipu",       "ZHIPUAI_API_KEY",     "glm-4-flash",                    "https://open.bigmodel.cn/usercenter/apikeys"),
+    ("openai",      "OPENAI_API_KEY",      "gpt-4o-mini",                    "https://platform.openai.com/api-keys"),
+    ("anthropic",   "ANTHROPIC_API_KEY",   "claude-3-5-haiku-latest",        "https://console.anthropic.com/settings/keys"),
+    ("groq",        "GROQ_API_KEY",        "llama-3.3-70b-versatile",        "https://console.groq.com/keys"),
+    ("together",    "TOGETHER_API_KEY",    "meta-llama/Llama-3.3-70B-Instruct-Turbo", "https://api.together.xyz/settings/api-keys"),
+]
+
+# 本地推理服务：(provider id, 默认地址, 列模型的路径)
+_LOCAL_PROVIDERS: List[tuple] = [
+    ("ollama",   os.environ.get("OLLAMA_BASE_URL",   "http://localhost:11434"), "/api/tags"),
+    ("lmstudio", os.environ.get("LMSTUDIO_BASE_URL", "http://localhost:1234"),  "/v1/models"),
+]
+
+
+@dataclass
+class Finding:
+    """一个 provider 的探测结果。"""
+    provider: str
+    kind: str                       # "local" | "cloud"
+    available: bool
+    detail: str = ""
+    models: List[str] = field(default_factory=list)
+    env_key: Optional[str] = None
+    signup_url: str = ""
+    base_url: str = ""
+
+
+def _port_open(url: str, timeout: float = 0.4) -> bool:
+    """只做 TCP 探活。比发 HTTP 请求快得多，且本地服务没起来时能立刻返回，
+    不会让整个探测卡在连接超时上。"""
+    parsed = urlparse(url)
+    host = parsed.hostname or "localhost"
+    port = parsed.port or (443 if parsed.scheme == "https" else 80)
+    try:
+        with socket.create_connection((host, port), timeout=timeout):
+            return True
+    except (OSError, ValueError):
+        return False
+
+
+def _fetch_json(url: str, timeout: float = 1.5) -> Optional[dict]:
+    try:
+        with urllib.request.urlopen(url, timeout=timeout) as resp:
+            return json.loads(resp.read())
+    except (urllib.error.URLError, OSError, ValueError, json.JSONDecodeError):
+        return None
+
+
+def _local_models(provider: str, base_url: str, path: str) -> List[str]:
+    payload = _fetch_json(base_url.rstrip("/") + path)
+    if not payload:
+        return []
+    if provider == "ollama":
+        return [m.get("name", "") for m in payload.get("models", []) if m.get("name")]
+    return [m.get("id", "") for m in payload.get("data", []) if m.get("id")]
+
+
+def probe_environment(*, check_local: bool = True) -> List[Finding]:
+    """探测这台机器上有什么。只读、不消耗任何额度。"""
+    findings: List[Finding] = []
+
+    if check_local:
+        for provider, base_url, path in _LOCAL_PROVIDERS:
+            if not _port_open(base_url):
+                findings.append(Finding(
+                    provider=provider, kind="local", available=False,
+                    base_url=base_url,
+                    detail=f"{base_url} 未监听（服务没启动，或端口不是默认值）",
+                ))
+                continue
+            models = _local_models(provider, base_url, path)
+            findings.append(Finding(
+                provider=provider, kind="local", available=bool(models),
+                base_url=base_url, models=models,
+                detail=(f"在跑，{len(models)} 个模型" if models
+                        else "端口通但没列出模型（可能还没 pull 过任何模型）"),
+            ))
+
+    for provider, env_key, _model, signup in _CLOUD_PROVIDERS:
+        has_key = bool(os.environ.get(env_key, "").strip())
+        findings.append(Finding(
+            provider=provider, kind="cloud", available=has_key,
+            env_key=env_key, signup_url=signup,
+            detail=(f"{env_key} 已设置" if has_key else f"{env_key} 未设置"),
+        ))
+
+    return findings
+
+
+def suggest_default_chain(findings: List[Finding]) -> tuple[Optional[str], List[str]]:
+    """按探测结果给出 default 与 fallback 链。
+
+    排序原则：本地优先（零成本、不出网、隐私最好），其次是已配好 key 的云端。
+    没配 key 的一律不进链——把用不了的东西写进 fallback 只会在真正需要兜底时
+    连续失败几次才走到能用的那个。
+    """
+    local_ready = [f for f in findings if f.kind == "local" and f.available]
+    cloud_ready = [f for f in findings if f.kind == "cloud" and f.available]
+
+    chain: List[str] = []
+    for f in local_ready:
+        model = f.models[0] if f.models else ""
+        chain.append(f"{f.provider}/{model}" if model else f.provider)
+
+    cloud_default = {p: m for p, _e, m, _s in _CLOUD_PROVIDERS}
+    for f in cloud_ready:
+        chain.append(f"{f.provider}/{cloud_default.get(f.provider, '')}".rstrip("/"))
+
+    return (chain[0] if chain else None), chain[1:]
+
+
+def render_providers_yaml(findings: List[Finding]) -> str:
+    """生成配置文本。缺什么、去哪拿，作为注释写在同一个文件里。"""
+    default, fallback = suggest_default_chain(findings)
+    lines: List[str] = [
+        "# ~/.aria/providers.yaml",
+        "# 由 `aria-code /providers init` 按本机实际环境生成。",
+        "# 密钥一律不写在这里——只写环境变量名，值放 ~/.aria/.env。",
+        "",
+    ]
+
+    if not default:
+        lines += [
+            "# ⚠️ 这台机器上暂时没有可用的模型来源。最快的两条路：",
+            "#   1. 本地（免费、离线可用）：",
+            "#        brew install ollama && ollama serve && ollama pull qwen2.5:7b",
+            "#   2. 云端：拿一个 key 写进 ~/.aria/.env，然后重跑 /providers init",
+            "",
+            "llm:",
+            "  default: ollama/qwen2.5:7b   # 装好 Ollama 后即可用",
+            "",
+        ]
+    else:
+        lines += ["llm:", f"  default: {default}"]
+        if fallback:
+            lines.append("  fallback:")
+            lines += [f"    - {item}" for item in fallback]
+        else:
+            lines += [
+                "  # 只探测到一个可用来源，暂无 fallback。多配一个 key 可以让",
+                "  # 默认来源故障时自动切换。",
+            ]
+        lines.append("")
+
+    ready_local = [f for f in findings if f.kind == "local" and f.available]
+    if ready_local:
+        lines.append("# ── 本机检测到的本地模型 ─────────────────────────────")
+        for f in ready_local:
+            preview = ", ".join(f.models[:6]) + (" …" if len(f.models) > 6 else "")
+            lines.append(f"#   {f.provider} @ {f.base_url} → {preview}")
+        lines.append("")
+
+    missing = [f for f in findings if f.kind == "cloud" and not f.available]
+    if missing:
+        lines.append("# ── 还没配的云端 provider（想用哪个就取哪个 key）────────")
+        lines.append("#   把值写进 ~/.aria/.env，格式 KEY=值（不要加引号）")
+        for f in missing:
+            lines.append(f"#   {f.env_key:<22} {f.signup_url}")
+        lines.append("")
+
+    lines += [
+        "# ── 接入未列出的服务（自建 vLLM / 内网网关 / 任意 OpenAI 兼容端点）──",
+        "# 取消注释并改成你自己的地址即可；之后 mycorp/<model> 就能用在上面的",
+        "# default 和 fallback 里。",
+        "#",
+        "# model_providers:",
+        "#   mycorp:",
+        "#     base_url: http://192.168.1.50:8000/v1",
+        "#     env_key: MYCORP_LLM_TOKEN        # 只写变量名，不写值",
+        "#     env_key_instructions: 找基础架构组申请",
+        "#     model: qwen-72b",
+        "",
+    ]
+    return "\n".join(lines)

aria_code/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})"