secagentx 3.0.0__py3-none-any.whl

backend/llm/openai_compatible.py

@@ -0,0 +1,51 @@
+"""通用 OpenAI Chat Completions 兼容 Provider。"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import httpx
+
+from .base import LLMConfig
+from .deepseek import DeepSeekProvider
+
+
+class OpenAICompatibleProvider(DeepSeekProvider):
+    """支持任意实现 OpenAI `/chat/completions` 协议的云端或本地服务。"""
+
+    def __init__(self, config: Optional[dict] = None):
+        cfg = config or {}
+        self.config = LLMConfig(
+            api_base=str(cfg.get("api_base", "")).rstrip("/"),
+            api_key=cfg.get("api_key", ""),
+            model=cfg.get("model", ""),
+            temperature=float(cfg.get("temperature", 0.1)),
+            max_tokens=int(cfg.get("max_tokens", 4096)),
+            timeout_seconds=float(cfg.get("timeout_seconds", 60)),
+        )
+        if not self.config.api_base:
+            raise ValueError("OpenAI 兼容 Provider 缺少 api_base")
+        if not self.config.model:
+            raise ValueError("OpenAI 兼容 Provider 缺少 model")
+        self.auth_style = cfg.get("auth_style", "bearer")
+        self.api_version = cfg.get("api_version", "")
+        self.allow_no_key = bool(cfg.get("allow_no_key", False))
+        self._http_client: Optional[httpx.AsyncClient] = None
+
+    @property
+    def client(self) -> httpx.AsyncClient:
+        if self._http_client is None:
+            headers = {"Content-Type": "application/json"}
+            if self.config.api_key and not self.allow_no_key:
+                if self.auth_style == "api-key":
+                    headers["api-key"] = self.config.api_key
+                else:
+                    headers["Authorization"] = f"Bearer {self.config.api_key}"
+            params = {"api-version": self.api_version} if self.api_version else None
+            self._http_client = httpx.AsyncClient(
+                base_url=self.config.api_base,
+                timeout=self.config.timeout_seconds,
+                headers=headers,
+                params=params,
+            )
+        return self._http_client

backend/llm/provider.py

@@ -0,0 +1,217 @@
+import os
+import logging
+import hashlib
+import json
+from typing import Optional
+from .base import LLMInterface
+from .deepseek import DeepSeekProvider
+from .qwen import QwenProvider
+from .openai_compatible import OpenAICompatibleProvider
+from .anthropic_compatible import AnthropicCompatibleProvider
+from .mock import MockLLMProvider, is_mock_key
+from .fallback import FallbackLLMProvider
+
+logger = logging.getLogger("secagentx.llm")
+
+
+def _cache_fingerprint(*values) -> str:
+    """生成稳定且不在缓存键中保留明文 API Key 的配置指纹。"""
+    payload = json.dumps(values, sort_keys=True, ensure_ascii=False, default=repr)
+    return hashlib.sha256(payload.encode("utf-8")).hexdigest()
+
+
+def _resolve_runtime_profile(provider: str, config: dict) -> tuple[str, dict, bool]:
+    """用 onboarding 选定的活动档案覆盖硬编码 Agent Provider。"""
+    active = os.getenv("SECAGENTX_ACTIVE_PROVIDER", "").strip().lower()
+    if not active:
+        return provider, dict(config), False
+    runtime = dict(config)
+    env_map = {
+        "api_base": "SECAGENTX_LLM_API_BASE",
+        "api_key": "SECAGENTX_LLM_API_KEY",
+        "model": "SECAGENTX_LLM_MODEL",
+        "auth_style": "SECAGENTX_LLM_AUTH_STYLE",
+        "api_version": "SECAGENTX_LLM_API_VERSION",
+    }
+    for field, env_name in env_map.items():
+        value = os.getenv(env_name, "")
+        if value:
+            runtime[field] = value
+    runtime["allow_no_key"] = os.getenv("SECAGENTX_LLM_ALLOW_NO_KEY", "").lower() in (
+        "1", "true", "yes",
+    )
+    return active, runtime, True
+
+
+def build_provider(provider: str, config: dict, *, use_runtime_profile: bool = True) -> LLMInterface:
+    """构建单个 LLM 提供者（不含 fallback 包装）。"""
+    if use_runtime_profile:
+        provider, config, _ = _resolve_runtime_profile(provider, config)
+    else:
+        config = dict(config)
+    if provider == "mock":
+        return MockLLMProvider(config)
+    api_key = config.get("api_key") or os.getenv(f"{provider.upper()}_API_KEY", "")
+    config["api_key"] = api_key
+
+    # 企业运行时禁止把缺失凭据静默伪装成真实模型响应。
+    # Mock 只能通过 provider=mock 显式选择；测试代码可继续直接使用 MockLLMProvider。
+    if is_mock_key(api_key) and not config.get("allow_no_key", False):
+        raise ValueError(
+            f"{provider} 未配置有效 API Key；请运行 `secagentx onboard`，"
+            "或显式选择 provider=mock（仅限测试/演示）"
+        )
+
+    if provider == "deepseek":
+        return DeepSeekProvider(config)
+    elif provider == "qwen":
+        return QwenProvider(config)
+    elif provider == "openai_compatible":
+        return OpenAICompatibleProvider(config)
+    elif provider == "anthropic_compatible":
+        return AnthropicCompatibleProvider(config)
+    else:
+        raise ValueError(f"Unknown LLM provider: {provider}")
+
+
+def _build_single_provider(provider: str, config: dict) -> LLMInterface:
+    """向后兼容的内部别名。"""
+    return build_provider(provider, config)
+
+
+class LLMFactory:
+    _instances: dict[str, LLMInterface] = {}
+
+    @classmethod
+    def get_provider(cls, provider: str = "deepseek",
+                     config: Optional[dict] = None,
+                     fallback_config: Optional[dict] = None) -> LLMInterface:
+        """
+        获取 LLM 提供者（自动包装 FallbackLLMProvider）。
+
+        Args:
+            provider: 主 LLM 名称或兼容协议名称
+            config: 主 LLM 配置字典
+            fallback_config: fallback 配置，结构为:
+                {
+                    "enabled": True,
+                    "provider": "qwen",       # 备用 LLM 名称
+                    "config": {...},          # 备用 LLM 配置
+                    "timeout_seconds": 25,    # 超时阈值
+                    "fallback_on_error": True,
+                }
+        """
+        if config is None:
+            config = {}
+
+        provider, config, has_runtime_profile = _resolve_runtime_profile(provider, config)
+        if has_runtime_profile:
+            # onboarding 档案是全局统一路由；避免旧 qwen fallback 再次调用同一接口。
+            fallback_config = None
+
+        key = f"{provider}:{_cache_fingerprint(config, fallback_config)}"
+        if key in cls._instances:
+            return cls._instances[key]
+
+        # 构建主 LLM
+        primary = build_provider(provider, config, use_runtime_profile=False)
+
+        # 检查是否需要包装 FallbackLLMProvider
+        if fallback_config and fallback_config.get("enabled", False):
+            fb_provider_name = fallback_config.get("provider", "")
+            fb_cfg = dict(fallback_config.get("config", {}))
+            if fb_provider_name:
+                # ═══ 修复：fallback 未显式配置时，从主 provider 继承关键字段 ═══
+                # 问题：config.yaml 的 fallback 段常缺少嵌套 config，
+                #       导致 QwenProvider 用默认模型 qwen2.5-72b-instruct（该模型对许多账号 403 access_denied）
+                # 方案：模型只从【同 provider】继承（跨 provider 继承会拿到错误模型名）；
+                #       api_key/api_base 允许跨 provider 继承（环境变量兜底）。
+                if not fb_cfg:
+                    if fb_provider_name == provider:
+                        # 同 provider 兜底：完整继承主配置（含 model）
+                        fb_cfg = dict(config)
+                    else:
+                        # 跨 provider：只继承 api_base / api_key，model 用各 provider 显式配置或默认
+                        fb_cfg = {
+                            k: config.get(k) for k in ("api_base", "api_key")
+                            if config.get(k)
+                        }
+                    logger.warning(
+                        "fallback(%s) 未提供嵌套 config，已从主 provider 继承字段: %s%s",
+                        fb_provider_name, sorted(fb_cfg.keys()),
+                        "（含 model，同 provider）" if fb_provider_name == provider else
+                        "（model 用 fallback provider 默认，建议在 config 显式指定）",
+                    )
+                else:
+                    # 部分提供 → 逐个字段继承缺失项（model 仅同 provider 继承）
+                    for k in ("api_base", "api_key"):
+                        if not fb_cfg.get(k) and config.get(k):
+                            fb_cfg[k] = config[k]
+                    if fb_provider_name == provider and not fb_cfg.get("model") and config.get("model"):
+                        fb_cfg["model"] = config["model"]
+                try:
+                    fallback = build_provider(fb_provider_name, fb_cfg, use_runtime_profile=False)
+                    # ═══ 修复：模型名黑名单校验（防止 403 access_denied 静默失败） ═══
+                    # 必须基于【实际构建出的 fallback 实例】校验 —— 因为 QwenProvider 构造时
+                    # 会用默认 qwen2.5-72b-instruct 填充 fb_cfg 里缺失的 model。
+                    _BLOCKED_MODELS = (
+                        "qwen2.5-72b-instruct", "qwen2.5-7b-instruct",
+                    )
+                    fb_actual_model = getattr(fallback, "config", None)
+                    fb_actual_model = fb_actual_model.model if hasattr(fb_actual_model, "model") else ""
+                    if (fb_actual_model or "").lower() in _BLOCKED_MODELS:
+                        # 同 provider 优先回退主模型；跨 provider 用该 provider 的常用模型
+                        corrected = (
+                            config.get("model") if fb_provider_name == provider
+                            else {"qwen": "qwen-max", "deepseek": "deepseek-chat"}.get(
+                                fb_provider_name, fb_actual_model)
+                        )
+                        logger.warning(
+                            "fallback(%s) 模型 %s 不可用（常见 403 access_denied），"
+                            "已纠正为 %s",
+                            fb_provider_name, fb_actual_model, corrected,
+                        )
+                        fb_cfg["model"] = corrected
+                        fallback = build_provider(fb_provider_name, fb_cfg, use_runtime_profile=False)
+                    wrapper = FallbackLLMProvider(
+                        primary,
+                        fallback,
+                        fallback_on_timeout=fallback_config.get("fallback_on_timeout", True),
+                        fallback_on_error=fallback_config.get("fallback_on_error", True),
+                        timeout_seconds=float(fallback_config.get("timeout_seconds", 30)),
+                    )
+                    logger.info(
+                        "FallbackLLM: primary=%s, fallback=%s, timeout=%.1fs",
+                        provider, fb_provider_name,
+                        float(fallback_config.get("timeout_seconds", 30)),
+                    )
+                    cls._instances[key] = wrapper
+                    return wrapper
+                except Exception as e:
+                    logger.warning("FallbackLLM 构建失败（仅使用主 LLM）: %s", e)
+
+        # 无 fallback 配置或构建失败 → 直接返回主 LLM
+        cls._instances[key] = primary
+        return primary
+
+    @classmethod
+    def get_deepseek(cls, config: Optional[dict] = None,
+                     fallback_config: Optional[dict] = None) -> LLMInterface:
+        return cls.get_provider("deepseek", config, fallback_config)
+
+    @classmethod
+    def get_qwen(cls, config: Optional[dict] = None,
+                 fallback_config: Optional[dict] = None) -> LLMInterface:
+        return cls.get_provider("qwen", config, fallback_config)
+
+    @classmethod
+    def clear(cls):
+        for inst in cls._instances.values():
+            try:
+                import asyncio
+                loop = asyncio.get_event_loop()
+                if loop.is_running():
+                    loop.create_task(inst.close())
+            except RuntimeError:
+                pass
+        cls._instances.clear()

backend/llm/qwen.py

@@ -0,0 +1,218 @@
+import json
+import httpx
+from typing import AsyncGenerator, Optional
+from .base import LLMInterface, LLMConfig, LLMResponse
+
+
+class QwenProvider(LLMInterface):
+    def __init__(self, config: Optional[dict] = None):
+        cfg = config or {}
+        self.config = LLMConfig(
+            api_base=cfg.get("api_base", "https://dashscope.aliyuncs.com/compatible-mode/v1"),
+            api_key=cfg.get("api_key", ""),
+            model=cfg.get("model", "qwen2.5-72b-instruct"),
+            temperature=cfg.get("temperature", 0.3),
+            max_tokens=cfg.get("max_tokens", 4096),
+        )
+        self._http_client: Optional[httpx.AsyncClient] = None
+
+    @property
+    def client(self) -> httpx.AsyncClient:
+        if self._http_client is None:
+            self._http_client = httpx.AsyncClient(
+                base_url=self.config.api_base,
+                timeout=self.config.timeout_seconds,
+                headers={
+                    "Authorization": f"Bearer {self.config.api_key}",
+                    "Content-Type": "application/json",
+                },
+            )
+        return self._http_client
+
+    async def chat(self, messages: list[dict], stream: bool = False) -> LLMResponse:
+        payload = {
+            "model": self.config.model,
+            "messages": messages,
+            "temperature": self.config.temperature,
+            "max_tokens": self.config.max_tokens,
+            "stream": stream,
+        }
+        resp = await self.client.post("/chat/completions", json=payload)
+        resp.raise_for_status()
+        data = resp.json()
+        choice = data["choices"][0]
+        return LLMResponse(
+            content=choice["message"]["content"],
+            usage=data.get("usage", {}),
+            model=data.get("model", self.config.model),
+            finish_reason=choice.get("finish_reason", ""),
+        )
+
+    async def chat_stream(self, messages: list[dict]) -> AsyncGenerator[str, None]:
+        payload = {
+            "model": self.config.model,
+            "messages": messages,
+            "temperature": self.config.temperature,
+            "max_tokens": self.config.max_tokens,
+            "stream": True,
+        }
+        self._last_usage = {}
+        async with self.client.stream("POST", "/chat/completions", json=payload) as resp:
+            resp.raise_for_status()
+            async for line in resp.aiter_lines():
+                if not line.startswith("data: "):
+                    continue
+                chunk = line[6:]
+                if chunk == "[DONE]":
+                    break
+                try:
+                    data = json.loads(chunk)
+                    if "usage" in data and data["usage"]:
+                        self._last_usage = data["usage"]
+                    delta = data["choices"][0].get("delta", {})
+                    content = delta.get("content", "")
+                    if content:
+                        yield content
+                except json.JSONDecodeError:
+                    continue
+
+    async def structured_output(self, messages: list[dict], response_model: type = None) -> dict:
+        payload = {
+            "model": self.config.model,
+            "messages": messages,
+            "temperature": 0.1,
+            "max_tokens": self.config.max_tokens,
+            "response_format": {"type": "json_object"},
+        }
+        resp = await self.client.post("/chat/completions", json=payload)
+        resp.raise_for_status()
+        data = resp.json()
+        content = data["choices"][0]["message"]["content"]
+
+        json_start = content.find("{")
+        json_end = content.rfind("}")
+        if json_start != -1 and json_end != -1:
+            try:
+                return json.loads(content[json_start : json_end + 1])
+            except json.JSONDecodeError:
+                pass
+
+        try:
+            return json.loads(content)
+        except json.JSONDecodeError:
+            # 容错修复：剥围栏/去尾逗号等，仍失败才返回失败标记
+            from ..models.output import repair_json_object
+            repaired = repair_json_object(content)
+            if repaired:
+                return repaired
+            return {"raw": content, "parse_error": True}
+
+    # ═══════════════════════ Function Calling ═══════════════════════
+
+    async def chat_with_tools(
+        self,
+        messages: list[dict],
+        tools: list[dict],
+        tool_choice: str = "auto",
+    ) -> tuple[str, list[dict]]:
+        """
+        Qwen Function Calling
+
+        通义千问 DashScope 兼容模式支持 OpenAI 格式的 tools 参数。
+        """
+        payload = {
+            "model": self.config.model,
+            "messages": messages,
+            "temperature": self.config.temperature,
+            "max_tokens": self.config.max_tokens,
+            "tools": tools,
+            "tool_choice": tool_choice,
+        }
+
+        resp = await self.client.post("/chat/completions", json=payload)
+        resp.raise_for_status()
+        data = resp.json()
+
+        message = data["choices"][0].get("message", {})
+        content = message.get("content", "") or ""
+        tool_calls = message.get("tool_calls", [])
+
+        if "usage" in data:
+            self._last_usage = data["usage"]
+
+        return content, tool_calls
+
+    async def chat_with_tools_stream(
+        self,
+        messages: list[dict],
+        tools: list[dict],
+        tool_choice: str = "auto",
+    ) -> AsyncGenerator[dict, None]:
+        """
+        Qwen 流式 Function Calling
+        """
+        payload = {
+            "model": self.config.model,
+            "messages": messages,
+            "temperature": self.config.temperature,
+            "max_tokens": self.config.max_tokens,
+            "tools": tools,
+            "tool_choice": tool_choice,
+            "stream": True,
+        }
+
+        self._last_usage = {}
+        tool_calls_acc: dict[int, dict] = {}
+
+        async with self.client.stream(
+            "POST", "/chat/completions", json=payload
+        ) as resp:
+            resp.raise_for_status()
+            async for line in resp.aiter_lines():
+                if not line.startswith("data: "):
+                    continue
+                chunk = line[6:]
+                if chunk == "[DONE]":
+                    break
+                try:
+                    data = json.loads(chunk)
+                    if "usage" in data and data["usage"]:
+                        self._last_usage = data["usage"]
+
+                    delta = data["choices"][0].get("delta", {})
+
+                    content = delta.get("content", "")
+                    if content:
+                        yield {"type": "text", "content": content}
+
+                    for tc in delta.get("tool_calls", []):
+                        idx = tc.get("index", 0)
+                        if idx not in tool_calls_acc:
+                            tool_calls_acc[idx] = {
+                                "id": tc.get("id", ""),
+                                "type": "function",
+                                "function": {"name": "", "arguments": ""},
+                            }
+                        if tc.get("id"):
+                            tool_calls_acc[idx]["id"] = tc["id"]
+                        if "function" in tc:
+                            fn = tc["function"]
+                            if fn.get("name"):
+                                tool_calls_acc[idx]["function"]["name"] += fn["name"]
+                            if fn.get("arguments"):
+                                tool_calls_acc[idx]["function"]["arguments"] += fn["arguments"]
+
+                except json.JSONDecodeError:
+                    continue
+
+        if tool_calls_acc:
+            sorted_calls = [
+                tool_calls_acc[i] for i in sorted(tool_calls_acc.keys())
+            ]
+            yield {"type": "tool_calls", "tool_calls": sorted_calls}
+
+    async def close(self):
+        if self._http_client:
+            await self._http_client.aclose()
+            self._http_client = None
+