vox-code 2.0.0__py3-none-any.whl

voxcli/gui/pet/workers.py

@@ -0,0 +1,54 @@
+"""Background workers for the desktop pet UI."""
+
+from __future__ import annotations
+
+from PySide6.QtCore import QThread, Signal
+
+from ...chat import GuiChatSubmission
+from ...config import GuiModelConfig
+from ...llm.base import Message
+from ...llm.factory import create_from_provider_config
+from ...runtime import SessionController
+
+
+class SessionWorker(QThread):
+    completed = Signal(object)
+    failed = Signal(str)
+
+    def __init__(self, controller: SessionController, line: str | GuiChatSubmission):
+        super().__init__()
+        self._controller = controller
+        self._line = line
+
+    def run(self):
+        try:
+            reply = self._controller.submit(self._line)
+            self.completed.emit(reply)
+        except Exception as exc:
+            self.failed.emit(str(exc))
+
+
+class ModelConnectionTestWorker(QThread):
+    completed = Signal(str)
+    failed = Signal(str)
+
+    def __init__(self, config: GuiModelConfig):
+        super().__init__()
+        self._config = config
+
+    def run(self):
+        try:
+            missing = self._config.validate()
+            if missing:
+                raise ValueError(f"缺少字段: {', '.join(missing)}")
+            client = create_from_provider_config(
+                self._config.provider,
+                self._config.provider_config(),
+            )
+            if client is None:
+                raise RuntimeError(f"无法创建 provider={self._config.provider} 的客户端")
+            response = client.chat([Message.user("Reply with OK only.")])
+            summary = (response.content or "").strip() or "OK"
+            self.completed.emit(f"连接成功: {summary[:48]}")
+        except Exception as exc:
+            self.failed.emit(str(exc))

voxcli/gui/pet_app.py

@@ -0,0 +1,7 @@
+"""Backward-compatible desktop pet entrypoint."""
+
+from __future__ import annotations
+
+from .pet import PetCoordinator, run_pet_app
+
+__all__ = ["PetCoordinator", "run_pet_app"]

voxcli/hitl/__init__.py

@@ -0,0 +1,11 @@
+from .request import ApprovalRequest
+from .result import ApprovalResult
+from .policy import ApprovalPolicy
+from .handler import HitlHandler
+from .terminal_handler import TerminalHitlHandler
+from .tool_registry import HitlToolRegistry
+
+__all__ = [
+    "ApprovalRequest", "ApprovalResult", "ApprovalPolicy",
+    "HitlHandler", "TerminalHitlHandler", "HitlToolRegistry",
+]

voxcli/hitl/handler.py

@@ -0,0 +1,11 @@
+"""HITL 处理器接口"""
+
+from typing import Protocol
+
+from .request import ApprovalRequest
+from .result import ApprovalResult
+
+
+class HitlHandler(Protocol):
+    def request_approval(self, req: ApprovalRequest) -> ApprovalResult:
+        ...

voxcli/hitl/policy.py

@@ -0,0 +1,32 @@
+"""HITL 审批策略 - 定义哪些工具需要人工审批"""
+
+from enum import Enum
+
+
+class ApprovalLevel(Enum):
+    ALWAYS = "ALWAYS"           # 总是需要审批
+    DANGEROUS = "DANGEROUS"     # 危险操作需要审批
+    NEVER = "NEVER"             # 不需要审批
+
+
+# 危险工具列表（与 AuditLog 保持一致）
+_DANGEROUS_TOOLS = {"write_file", "execute_command", "create_project"}
+
+
+class ApprovalPolicy:
+    def __init__(self, mode: str = "auto"):
+        self._mode = mode  # "auto", "always", "never"
+
+    def check(self, tool_name: str) -> ApprovalLevel:
+        if self._mode == "always":
+            return ApprovalLevel.ALWAYS
+        if self._mode == "never":
+            return ApprovalLevel.NEVER
+        return ApprovalLevel.DANGEROUS if tool_name in _DANGEROUS_TOOLS else ApprovalLevel.NEVER
+
+    def set_mode(self, mode: str):
+        self._mode = mode
+
+    @property
+    def mode(self) -> str:
+        return self._mode

voxcli/hitl/request.py

@@ -0,0 +1,13 @@
+"""HITL 审批请求"""
+
+from dataclasses import dataclass, field
+from typing import Dict, Optional
+
+
+@dataclass
+class ApprovalRequest:
+    tool_name: str
+    arguments: Dict[str, str]
+    reason: str
+    request_id: str = ""
+    metadata: Dict[str, str] = field(default_factory=dict)

voxcli/hitl/result.py

@@ -0,0 +1,11 @@
+"""HITL 审批结果"""
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class ApprovalResult:
+    approved: bool
+    modified_args: Optional[dict] = None
+    feedback: Optional[str] = None

voxcli/hitl/terminal_handler.py

@@ -0,0 +1,64 @@
+"""终端 HITL 处理器 - 在终端请求用户审批"""
+
+import json
+import sys
+from typing import Optional, Set
+
+from ..util.ansi import heading, subtle, emphasis
+from .request import ApprovalRequest
+from .result import ApprovalResult
+
+
+class TerminalHitlHandler:
+    def __init__(self):
+        self._approve_all = False
+
+    def request_approval(self, req: ApprovalRequest) -> ApprovalResult:
+        if self._approve_all:
+            return ApprovalResult(approved=True)
+
+        print()
+        print(heading("🪪 人工审批"))
+        print(f"  工具: {emphasis(req.tool_name)}")
+        print(f"  参数: {subtle(json.dumps(req.arguments, ensure_ascii=False))}")
+        print(f"  原因: {req.reason}")
+        print()
+
+        while True:
+            try:
+                line = input("  操作 [a]批准 [A]全部批准 [r]拒绝 [s]跳过 [m]修改 → ").strip().lower()
+            except (EOFError, KeyboardInterrupt):
+                print()
+                return ApprovalResult(approved=False, feedback="用户中断输入")
+
+            if line in ("a", ""):
+                return ApprovalResult(approved=True)
+            if line == "a":
+                self._approve_all = True
+                return ApprovalResult(approved=True)
+            if line == "r":
+                return ApprovalResult(approved=False, feedback="用户拒绝")
+            if line == "s":
+                return ApprovalResult(approved=False, feedback="跳过")
+            if line == "m":
+                return self._handle_modify(req)
+            print("  无效选择，请重新输入")
+
+    def _handle_modify(self, req: ApprovalRequest) -> ApprovalResult:
+        print(f"  输入修改后的参数 (JSON)，空行取消修改:")
+        try:
+            modified = input("  > ").strip()
+        except (EOFError, KeyboardInterrupt):
+            return ApprovalResult(approved=False, feedback="用户中断输入")
+
+        if not modified:
+            return ApprovalResult(approved=False, feedback="取消修改")
+
+        try:
+            new_args = json.loads(modified)
+            if not isinstance(new_args, dict):
+                raise ValueError
+            return ApprovalResult(approved=True, modified_args=new_args)
+        except (json.JSONDecodeError, ValueError):
+            print("  JSON 格式无效")
+            return ApprovalResult(approved=False, feedback="JSON 格式无效")

voxcli/hitl/tool_registry.py

@@ -0,0 +1,64 @@
+"""HITL 工具注册表包装器 - 在工具执行前插入审批环节"""
+
+import json
+from typing import List, Optional
+
+from ..tool import ToolRegistry, ToolInvocation, ToolExecutionResult
+from .policy import ApprovalPolicy, ApprovalLevel
+from .terminal_handler import TerminalHitlHandler
+from .request import ApprovalRequest
+
+
+class HitlToolRegistry:
+    def __init__(self, tool_registry: ToolRegistry,
+                 policy: Optional[ApprovalPolicy] = None,
+                 handler: Optional[TerminalHitlHandler] = None):
+        self._registry = tool_registry
+        self._policy = policy or ApprovalPolicy()
+        self._handler = handler or TerminalHitlHandler()
+
+    def set_mode(self, mode: str):
+        self._policy.set_mode(mode)
+
+    def execute_tools(self, invocations: List[ToolInvocation]) -> List[ToolExecutionResult]:
+        approved_invocations: List[ToolInvocation] = []
+
+        for inv in invocations:
+            level = self._policy.check(inv.name)
+            if level == ApprovalLevel.NEVER:
+                approved_invocations.append(inv)
+                continue
+
+            req = ApprovalRequest(
+                tool_name=inv.name,
+                arguments=self._parse_args(inv.arguments_json),
+                reason=f"{level.value} 级别操作",
+                request_id=inv.id,
+            )
+            result = self._handler.request_approval(req)
+
+            if not result.approved:
+                approved_invocations.append(ToolInvocation(
+                    inv.id, inv.name,
+                    f'{{"error": "HITL拒绝了", "reason": "{result.feedback or "用户拒绝"}"}}'
+                ))
+                continue
+
+            if result.modified_args is not None:
+                approved_invocations.append(ToolInvocation(
+                    inv.id, inv.name, json.dumps(result.modified_args)
+                ))
+            else:
+                approved_invocations.append(inv)
+
+        return self._registry.execute_tools(approved_invocations)
+
+    def __getattr__(self, name: str):
+        return getattr(self._registry, name)
+
+    @staticmethod
+    def _parse_args(json_str: str) -> dict:
+        try:
+            return json.loads(json_str)
+        except json.JSONDecodeError:
+            return {}

voxcli/llm/base.py

@@ -0,0 +1,93 @@
+"""LLM 客户端接口与消息类型"""
+
+from dataclasses import dataclass, field
+from typing import Optional, Protocol, Sequence
+
+from ..chat import ChatAttachment
+
+
+@dataclass
+class ToolCall:
+    id: str
+    name: str
+    arguments: str
+
+
+@dataclass
+class ToolDef:
+    name: str
+    description: str
+    parameters: dict
+
+
+@dataclass
+class Message:
+    role: str  # system, user, assistant, tool
+    content: Optional[str] = None
+    attachments: tuple[ChatAttachment, ...] = field(default_factory=tuple)
+    reasoning_content: Optional[str] = None
+    tool_calls: Optional[list[ToolCall]] = None
+    tool_call_id: Optional[str] = None
+
+    @classmethod
+    def system(cls, content: str) -> "Message":
+        return cls(role="system", content=content)
+
+    @classmethod
+    def user(
+        cls,
+        content: str,
+        attachments: Optional[Sequence[ChatAttachment]] = None,
+    ) -> "Message":
+        return cls(role="user", content=content, attachments=tuple(attachments or ()))
+
+    @classmethod
+    def assistant(cls, content: str = "", reasoning_content: Optional[str] = None,
+                  tool_calls: Optional[list[ToolCall]] = None) -> "Message":
+        return cls(role="assistant", content=content, reasoning_content=reasoning_content,
+                   tool_calls=tool_calls)
+
+    @classmethod
+    def tool(cls, tool_call_id: str, content: str) -> "Message":
+        return cls(role="tool", content=content, tool_call_id=tool_call_id)
+
+
+@dataclass
+class ChatResponse:
+    role: str = "assistant"
+    content: Optional[str] = None
+    reasoning_content: Optional[str] = None
+    tool_calls: Optional[list[ToolCall]] = None
+    input_tokens: int = 0
+    output_tokens: int = 0
+
+    @property
+    def has_tool_calls(self) -> bool:
+        return bool(self.tool_calls)
+
+
+class StreamListener(Protocol):
+    def on_reasoning_delta(self, delta: str): ...
+    def on_content_delta(self, delta: str): ...
+
+
+class StreamListenerNoOp:
+    def on_reasoning_delta(self, delta: str): pass
+    def on_content_delta(self, delta: str): pass
+
+
+STREAM_LISTENER_NOOP = StreamListenerNoOp()
+
+
+class LlmClient(Protocol):
+    def chat(self, messages: list[Message], tools: Optional[list[ToolDef]] = None,
+             listener: StreamListener = STREAM_LISTENER_NOOP) -> ChatResponse: ...
+
+    @property
+    def model_name(self) -> str: ...
+
+    @property
+    def provider_name(self) -> str: ...
+
+    @property
+    def supports_image_inputs(self) -> bool: ...

voxcli/llm/factory.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+"""LLM 客户端工厂 - 从环境变量读取模型配置"""
+
+import os
+import logging
+from typing import Optional
+
+from ..config import ProviderConfig, pai_config
+from .base import LlmClient
+from .openai_compatible import OpenAiCompatibleClient
+from .ollama_client import OllamaClient
+
+logger = logging.getLogger(__name__)
+
+# 默认模型映射
+_DEFAULT_MODELS = {
+    "glm": "glm-5.1",
+    "deepseek": "deepseek-chat",
+    "qwen": "qwen-plus",
+    "ollama": "qwen2.5:7b",
+    "codex": "gpt-5-codex",
+    "claude-code": "claude-sonnet-4-20250514",
+}
+
+# base_url 映射
+_DEFAULT_URLS = {
+    "glm": "https://open.bigmodel.cn/api/paas/v4/chat/completions",
+    "deepseek": "https://api.deepseek.com/chat/completions",
+    "qwen": "https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions",
+    "ollama": "http://localhost:11434",
+    "codex": "",
+    "claude-code": "",
+}
+
+# env key 映射
+_ENV_KEYS = {
+    "glm": (("GLM_API_KEY",), ("GLM_MODEL",), ("GLM_BASE_URL",)),
+    "deepseek": (("DEEPSEEK_API_KEY",), ("DEEPSEEK_MODEL",), ("DEEPSEEK_BASE_URL",)),
+    "qwen": (
+        ("QWEN_API_KEY", "DASHSCOPE_API_KEY"),
+        ("QWEN_MODEL", "DASHSCOPE_MODEL"),
+        ("QWEN_BASE_URL", "DASHSCOPE_BASE_URL"),
+    ),
+    "ollama": (None, ("OLLAMA_MODEL",), ("OLLAMA_BASE_URL",)),
+    "codex": (None, None, None),
+    "claude-code": (None, None, None),
+}
+
+
+def _env(keys: str | tuple[str, ...] | None, default: str = "") -> str:
+    if keys is None:
+        return default
+    if isinstance(keys, str):
+        keys = (keys,)
+    for key in keys:
+        value = os.environ.get(key, "").strip()
+        if value:
+            return value
+    return default
+
+
+def default_model_for(provider: str) -> str:
+    return _DEFAULT_MODELS.get(provider.lower().strip(), "")
+
+
+def default_base_url_for(provider: str) -> str:
+    return _DEFAULT_URLS.get(provider.lower().strip(), "")
+
+
+def _config_value(provider: str, field: str) -> str:
+    provider_config = pai_config.providers.get(provider.lower())
+    if provider_config is None:
+        return ""
+    return provider_config.get(field, "")
+
+
+def _normalize_base_url(provider: str, base_url: str) -> str:
+    normalized = (base_url or "").strip().rstrip("/")
+    if not normalized:
+        return normalized
+    if provider == "qwen" and normalized.endswith("/compatible-mode/v1"):
+        return normalized + "/chat/completions"
+    return normalized
+
+
+def _build_client(provider: str, model: str, base_url: str, api_key: str) -> Optional[LlmClient]:
+    if provider == "ollama":
+        if not model:
+            logger.warning("No model for ollama")
+            return None
+        return OllamaClient(model=model, base_url=base_url or _DEFAULT_URLS["ollama"])
+
+    if not api_key:
+        logger.warning("No API key for %s", provider)
+        return None
+
+    if not model:
+        logger.warning("No model for %s", provider)
+        return None
+
+    return OpenAiCompatibleClient(
+        api_key=api_key,
+        model=model,
+        base_url=base_url,
+        provider_name=provider,
+    )
+
+
+def create(provider: str, model_name: Optional[str] = None) -> Optional[LlmClient]:
+    """根据 provider 名称创建 LLM 客户端，优先读取环境变量，其次读取全局配置。"""
+    provider = provider.lower().strip()
+    keys = _ENV_KEYS.get(provider)
+    if keys is None:
+        logger.warning("Unknown provider: %s", provider)
+        return None
+
+    api_key_key, model_key, url_key = keys
+
+    # 模型名：优先参数 > env > 全局配置 > 默认值
+    model = model_name or _env(model_key)
+    if not model:
+        model = _config_value(provider, "model")
+    if not model:
+        model = _DEFAULT_MODELS.get(provider, "")
+
+    # base_url：优先 env > 全局配置 > 默认值
+    base_url = _env(url_key)
+    if not base_url:
+        base_url = _config_value(provider, "base_url")
+    if not base_url:
+        base_url = _DEFAULT_URLS.get(provider, "")
+    base_url = _normalize_base_url(provider, base_url)
+
+    # OpenAI 兼容：需要 api_key
+    api_key = _env(api_key_key)
+    if not api_key:
+        api_key = _config_value(provider, "api_key")
+
+    return _build_client(provider, model, base_url, api_key)
+
+
+def create_from_provider_config(provider: str, config: ProviderConfig) -> Optional[LlmClient]:
+    """根据显式 provider 配置创建客户端，不读取全局配置。"""
+    normalized = provider.lower().strip()
+    if normalized not in _ENV_KEYS:
+        logger.warning("Unknown provider: %s", provider)
+        return None
+    model = config.model.strip() or default_model_for(normalized)
+    base_url = _normalize_base_url(
+        normalized,
+        config.base_url.strip() or _DEFAULT_URLS.get(normalized, ""),
+    )
+    api_key = config.api_key.strip()
+    return _build_client(normalized, model, base_url, api_key)
+
+
+def create_from_config() -> Optional[LlmClient]:
+    """依次尝试 active preset → default provider → common fallbacks."""
+    preset = pai_config.get_model_preset(pai_config.active_model_preset)
+    if preset is not None:
+        client = create(preset.provider, preset.model)
+        if client is not None:
+            return client
+
+    default = pai_config.default_provider_name
+    if default:
+        client = create(default)
+        if client is not None:
+            return client
+
+    # 回退遍历
+    for provider in ("glm", "deepseek", "qwen", "ollama"):
+        client = create(provider)
+        if client is not None:
+            return client
+
+    return None

voxcli/llm/ollama_client.py

@@ -0,0 +1,137 @@
+"""Ollama 本地模型客户端"""
+
+import json
+import logging
+from typing import Optional
+
+import httpx
+
+from .base import (
+    LlmClient, Message, ChatResponse, ToolCall, ToolDef,
+    StreamListener, STREAM_LISTENER_NOOP,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class OllamaClient(LlmClient):
+    def __init__(self, model: str, base_url: str = "http://localhost:11434"):
+        self._model = model
+        self._base_url = base_url.rstrip("/")
+        self._http = httpx.Client(timeout=httpx.Timeout(300.0, connect=10.0))
+
+    @property
+    def model_name(self) -> str:
+        return self._model
+
+    @property
+    def provider_name(self) -> str:
+        return "ollama"
+
+    @property
+    def supports_image_inputs(self) -> bool:
+        return False
+
+    def _build_request(self, messages: list[Message],
+                       tools: Optional[list[ToolDef]] = None) -> dict:
+        body: dict = {
+            "model": self._model,
+            "stream": True,
+            "messages": [],
+        }
+        for msg in messages:
+            if msg.attachments:
+                raise RuntimeError("当前 Ollama GUI 会话暂不支持图片输入，请切换到 OpenAI Compatible 模型。")
+            m: dict = {"role": msg.role}
+            if msg.content is not None:
+                m["content"] = msg.content
+            if msg.tool_calls:
+                m["tool_calls"] = [
+                    {
+                        "id": tc.id,
+                        "type": "function",
+                        "function": {"name": tc.name, "arguments": tc.arguments},
+                    }
+                    for tc in msg.tool_calls
+                ]
+            if msg.tool_call_id:
+                m["tool_call_id"] = msg.tool_call_id
+            body["messages"].append(m)
+        if tools:
+            body["tools"] = [
+                {
+                    "type": "function",
+                    "function": {
+                        "name": t.name,
+                        "description": t.description,
+                        "parameters": t.parameters,
+                    },
+                }
+                for t in tools
+            ]
+        return body
+
+    def chat(self, messages: list[Message], tools: Optional[list[ToolDef]] = None,
+             listener: StreamListener = STREAM_LISTENER_NOOP) -> ChatResponse:
+        body = self._build_request(messages, tools)
+        resp = self._http.post(f"{self._base_url}/api/chat", json=body)
+        resp.raise_for_status()
+
+        content_parts: list[str] = []
+        tool_calls_acc: dict[int, dict] = {}
+
+        for line in resp.iter_lines():
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                chunk = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+
+            if chunk.get("done"):
+                break
+
+            delta = chunk.get("message", {})
+            if delta.get("content"):
+                content_parts.append(delta["content"])
+                listener.on_content_delta(delta["content"])
+            if delta.get("tool_calls"):
+                self._merge_ollama_tool_calls(tool_calls_acc, delta["tool_calls"])
+
+        content = "".join(content_parts) or None
+        tool_calls = self._build_tool_calls(tool_calls_acc) or None
+
+        return ChatResponse(
+            role="assistant",
+            content=content,
+            tool_calls=tool_calls,
+        )
+
+    @staticmethod
+    def _merge_ollama_tool_calls(acc: dict[int, dict], tool_calls: list[dict]):
+        for tc in tool_calls:
+            idx = len(acc)
+            if idx not in acc:
+                acc[idx] = {"id": f"call_{idx}", "name": "", "arguments": ""}
+            fn = tc.get("function", {})
+            if fn.get("name"):
+                acc[idx]["name"] = fn["name"]
+            if fn.get("arguments"):
+                acc[idx]["arguments"] = json.dumps(fn["arguments"], ensure_ascii=False)
+
+    @staticmethod
+    def _build_tool_calls(acc: dict[int, dict]) -> list[ToolCall]:
+        if not acc:
+            return []
+        result = []
+        for idx in sorted(acc.keys()):
+            entry = acc[idx]
+            if not entry["id"]:
+                continue
+            result.append(ToolCall(
+                id=entry["id"],
+                name=entry["name"],
+                arguments=entry["arguments"],
+            ))
+        return result