auto-coder 0.1.400__py3-none-any.whl → 2.0.0__py3-none-any.whl

autocoder/common/llms/registry.py

@@ -0,0 +1,288 @@
+import os
+import json
+import time
+from typing import List, Dict, Optional
+from pathlib import Path
+from filelock import FileLock
+
+from .schema import LLMModel
+
+# 默认内置模型列表
+# 价格单位：人民币/百万tokens
+DEFAULT_MODELS = [
+    {
+        "name": "volcengine/deepseek-v3-1-terminus",
+        "description": "火山引擎 DeepSeek V3.1 模型，适合编程任务",
+        "model_name": "deepseek-v3-1-terminus",
+        "model_type": "saas/openai",
+        "base_url": "https://ark.cn-beijing.volces.com/api/v3",
+        "provider": "volcengine",
+        "api_key_path": "",
+        "is_reasoning": False,
+        "input_price": 1.0,  # 1元/百万tokens
+        "output_price": 1.0,  # 1元/百万tokens
+        "max_output_tokens": 8096,
+        "context_window": 128000,
+    },
+    {
+        "name": "bigmodel/glm-4-6",
+        "description": "智谱 AI GLM-4，国产大模型，性价比高",
+        "model_name": "glm-4.6",
+        "model_type": "saas/openai",
+        "base_url": "https://open.bigmodel.cn/api/paas/v4/",
+        "provider": "bigmodel",
+        "api_key_path": "",
+        "is_reasoning": False,
+        "input_price": 0.5,  # 0.5元/百万tokens
+        "output_price": 0.5,  # 0.5元/百万tokens
+        "max_output_tokens": 8000,
+        "context_window": 200000,
+    },
+    {
+        "name": "deepseek/deepseek-chat",
+        "description": "DeepSeek 官方 API，性能接近 GPT-4，价格低廉",
+        "model_name": "deepseek-chat",
+        "model_type": "saas/openai",
+        "base_url": "https://api.deepseek.com/v1",
+        "provider": "deepseek",
+        "api_key_path": "",
+        "is_reasoning": False,
+        "input_price": 1.0,  # 1元/百万tokens
+        "output_price": 2.0,  # 2元/百万tokens
+        "max_output_tokens": 8096,
+        "context_window": 128000,
+    },
+    {
+        "name": "openrouter/claude-sonnet-4-5",
+        "description": "Claude Sonnet 4.5 via OpenRouter，强大的推理能力",
+        "model_name": "anthropic/claude-sonnet-4-5",
+        "model_type": "saas/openai",
+        "base_url": "https://openrouter.ai/api/v1",
+        "provider": "openrouter",
+        "api_key_path": "",
+        "is_reasoning": False,
+        "input_price": 21.6,  # 约3美元/百万tokens，按7.2汇率
+        "output_price": 108.0,  # 约15美元/百万tokens
+        "max_output_tokens": 24288,
+        "context_window": 200000,
+    },
+    {
+        "name": "openrouter/openai/gpt-5",
+        "description": "GPT-5 via OpenRouter，OpenAI 最新模型",
+        "model_name": "openai/gpt-5",
+        "model_type": "saas/openrouter",
+        "base_url": "https://openrouter.ai/api/v1",
+        "provider": "openrouter",
+        "api_key_path": "",
+        "is_reasoning": False,
+        "input_price": 36.0,  # 约5美元/百万tokens，按7.2汇率
+        "output_price": 108.0,  # 约15美元/百万tokens
+        "max_output_tokens": 24000,
+        "context_window": 200000,
+    },    
+]
+
+
+class ModelRegistry:
+    """模型注册表，负责模型的持久化和加载（无缓存）"""
+
+    def __init__(self, models_json_path: Optional[str] = None):
+        self.models_json_path = Path(
+            models_json_path or os.path.expanduser("~/.auto-coder/keys/models.json")
+        )
+
+    def _ensure_dir(self):
+        """确保目录存在"""
+        self.models_json_path.parent.mkdir(parents=True, exist_ok=True)
+
+    def _get_lock_path(self, file_path: Path) -> str:
+        """获取锁文件路径"""
+        return str(file_path) + ".lock"
+
+    def _load_api_key_from_file(self, model: LLMModel) -> LLMModel:
+        """从文件加载 API 密钥"""
+        # 设置 base_keys_dir 为配置文件所在目录
+        model.base_keys_dir = str(self.models_json_path.parent)
+
+        # 如果 api_key 存在但 api_key_path 不存在，生成 api_key_path
+        if model.api_key and not model.api_key_path:
+            model.api_key_path = model.name.replace("/", "_")
+
+        # 如果 api_key_path 存在，以它为准读取文件
+        if model.api_key_path:
+            api_key_file = self.models_json_path.parent / model.api_key_path
+            if api_key_file.exists():
+                with FileLock(self._get_lock_path(api_key_file), timeout=5):
+                    model.api_key = api_key_file.read_text(encoding="utf-8").strip()
+        return model
+
+    def load(self) -> List[LLMModel]:
+        """每次都重新加载模型列表，合并默认模型和自定义模型"""
+        self._ensure_dir()
+
+        # 从默认模型开始
+        models_dict = {}
+        for model_data in DEFAULT_MODELS:
+            # 添加 base_keys_dir 到模型数据
+            model_data_with_keys_dir = model_data.copy()
+            model_data_with_keys_dir["base_keys_dir"] = str(
+                self.models_json_path.parent
+            )
+            model = LLMModel(**model_data_with_keys_dir)
+            models_dict[model.name] = model
+
+        # 如果配置文件存在，读取并合并
+        if self.models_json_path.exists():
+            try:
+                with FileLock(self._get_lock_path(self.models_json_path), timeout=5):
+                    with open(self.models_json_path, "r", encoding="utf-8") as f:
+                        custom_models_data = json.load(f)
+
+                # 自定义模型会覆盖同名的默认模型
+                for model_data in custom_models_data:
+                    # 兼容旧版本：添加新字段的默认值
+                    if "context_window" not in model_data:
+                        model_data["context_window"] = 128 * 1024
+                    if "max_output_tokens" not in model_data:
+                        model_data["max_output_tokens"] = 8096
+                    if "provider" not in model_data:
+                        model_data["provider"] = None
+
+                    # 添加 base_keys_dir
+                    model_data["base_keys_dir"] = str(self.models_json_path.parent)
+
+                    model = LLMModel(**model_data)
+                    models_dict[model.name] = model
+
+            except (json.JSONDecodeError, Exception) as e:
+                # JSON 无效时，使用默认模型并重新保存
+                print(f"警告：加载 models.json 失败: {e}，使用默认模型")
+                self.save(list(models_dict.values()))
+        else:
+            # 文件不存在，创建默认配置
+            self.save(list(models_dict.values()))
+
+        # 加载 API 密钥
+        models = []
+        for model in models_dict.values():
+            models.append(self._load_api_key_from_file(model))
+
+        return models
+
+    def save(self, models: List[LLMModel]) -> None:
+        """使用 filelock 保存模型列表到文件"""
+        self._ensure_dir()
+
+        # 转换为字典列表，不包含 api_key
+        models_data = [model.dict() for model in models]
+
+        # 使用 filelock 写入，超时5秒
+        lock_path = self._get_lock_path(self.models_json_path)
+        with FileLock(lock_path, timeout=5):
+            with open(self.models_json_path, "w", encoding="utf-8") as f:
+                json.dump(models_data, f, indent=2, ensure_ascii=False)
+
+    def get(self, name: str) -> Optional[LLMModel]:
+        """根据名称获取模型（每次重新加载）"""
+        models = self.load()
+        for model in models:
+            if model.name == name.strip():
+                return model
+        return None
+
+    def get_all(self) -> Dict[str, LLMModel]:
+        """获取所有模型（每次重新加载）"""
+        models = self.load()
+        return {model.name: model for model in models}
+
+    def add_or_update(self, model: LLMModel) -> None:
+        """添加或更新模型"""
+        # 先加载所有模型
+        models = self.load()
+
+        # 查找是否存在同名模型
+        updated = False
+        for i, existing_model in enumerate(models):
+            if existing_model.name == model.name:
+                models[i] = model
+                updated = True
+                break
+
+        # 如果没有找到同名模型，添加新模型
+        if not updated:
+            models.append(model)
+
+        # 保存更新后的模型列表
+        self.save(models)
+
+    def save_api_key(self, model_name: str, api_key: str) -> bool:
+        """保存 API 密钥到文件"""
+        model = self.get(model_name)
+        if not model:
+            return False
+
+        # 确保有 api_key_path
+        if not model.api_key_path:
+            model.api_key_path = model_name.replace("/", "_")
+
+        # 保存密钥到文件
+        api_key_file = self.models_json_path.parent / model.api_key_path
+
+        # 使用 filelock 保存密钥，超时5秒
+        lock_path = self._get_lock_path(api_key_file)
+        with FileLock(lock_path, timeout=5):
+            api_key_file.write_text(api_key.strip(), encoding="utf-8")
+
+        # 更新模型（清除内存中的 api_key）
+        model.api_key = None
+        self.add_or_update(model)
+
+        return True
+
+    def remove_model(self, model_name: str) -> bool:
+        """
+        删除模型
+
+        Args:
+            model_name: 要删除的模型名称
+
+        Returns:
+            bool: 是否成功删除
+        """
+        # 先检查模型是否存在
+        model = self.get(model_name)
+        if not model:
+            return False
+
+        # 如果是默认模型，不允许删除
+        default_model_names = [m["name"] for m in DEFAULT_MODELS]
+        if model_name in default_model_names:
+            return False
+
+        # 加载所有模型
+        models = self.load()
+
+        # 过滤掉要删除的模型
+        filtered_models = [m for m in models if m.name != model_name]
+
+        # 如果模型数量没有变化，说明模型不存在于自定义模型中
+        if len(filtered_models) == len(models):
+            return False
+
+        # 删除 API 密钥文件（如果存在）
+        if model.api_key_path:
+            api_key_file = self.models_json_path.parent / model.api_key_path
+            if api_key_file.exists():
+                try:
+                    # 使用 filelock 删除密钥文件
+                    lock_path = self._get_lock_path(api_key_file)
+                    with FileLock(lock_path, timeout=5):
+                        api_key_file.unlink()
+                except OSError:
+                    # 忽略删除密钥文件失败的情况
+                    pass
+
+        # 保存更新后的模型列表
+        self.save(filtered_models)
+
+        return True

autocoder/common/llms/schema.py

@@ -0,0 +1,77 @@
+from pydantic import BaseModel, Field, validator
+from typing import Optional
+from pathlib import Path
+
+
+class LLMModel(BaseModel):
+    """大语言模型配置数据模型"""
+    
+    name: str = Field(..., description="模型唯一标识符，如 'deepseek/v3'")
+    description: str = Field(default="", description="模型描述信息")
+    model_name: str = Field(..., description="模型实际名称，用于 API 调用")
+    model_type: str = Field(..., description="模型类型，如 'saas/openai'")
+    base_url: str = Field(..., description="API 基础 URL")
+    provider: Optional[str] = Field(default=None, description="模型提供商，如 'deepseek', 'openai'")
+    is_reasoning: bool = Field(default=False, description="是否为推理模型")
+    input_price: float = Field(default=0.0, ge=0.0, description="输入价格(美元/百万tokens)")
+    output_price: float = Field(default=0.0, ge=0.0, description="输出价格(美元/百万tokens)")
+    max_output_tokens: int = Field(default=8096, gt=0, description="单次响应最大输出tokens")
+    context_window: int = Field(default=128000, gt=0, description="最大上下文窗口tokens")
+    api_key_path: Optional[str] = Field(default=None, description="API密钥文件路径")
+    api_key: Optional[str] = Field(default=None, description="API密钥(内存中)")
+    base_keys_dir: Optional[str] = Field(default=None, description="API密钥基础目录路径")
+    
+    class Config:
+        validate_assignment = True
+        
+    @validator("api_key_path", pre=True, always=True)
+    def normalize_key_path(cls, v, values):
+        """如果没有 api_key_path 但有 api_key，生成默认路径"""
+        if not v and values.get("api_key"):
+            # 将斜杠转换为下划线，生成合法文件名
+            return values["name"].replace("/", "_")
+        return v
+    
+    def _get_keys_dir(self) -> Path:
+        """获取API密钥基础目录"""
+        if self.base_keys_dir:
+            return Path(self.base_keys_dir)
+        return Path.home() / ".auto-coder/keys"
+    
+    @property
+    def has_api_key(self) -> bool:
+        """判断是否已配置密钥"""
+        # 如果内存中有 API key
+        if self.api_key:
+            return True
+            
+        # 如果有 api_key_path，检查文件是否存在
+        if self.api_key_path:
+            key_file = self._get_keys_dir() / self.api_key_path
+            return key_file.exists()
+            
+        return False
+    
+    def get_api_key(self) -> Optional[str]:
+        """获取 API 密钥，优先从内存，其次从文件"""
+        # 优先使用内存中的 key
+        if self.api_key:
+            return self.api_key
+            
+        # 从文件读取
+        if self.api_key_path:
+            key_file = self._get_keys_dir() / self.api_key_path
+            if key_file.exists():
+                return key_file.read_text(encoding="utf-8").strip()
+                
+        return None
+    
+    def dict(self, *args, **kwargs):
+        """覆盖 dict 方法，导出时不包含 api_key 和 base_keys_dir"""
+        d = super().dict(*args, **kwargs)
+        # 安全考虑：不将 api_key 和 base_keys_dir 序列化到文件
+        if 'api_key' in d:
+            d['api_key'] = None
+        if 'base_keys_dir' in d:
+            d.pop('base_keys_dir', None)
+        return d 

autocoder/common/llms/simple_demo.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+"""
+简单演示：如何通过 LLMManager 获取 v3_chat 模型
+"""
+
+import sys
+from pathlib import Path
+
+# 添加项目根目录到 sys.path
+project_root = Path(__file__).parent.parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from autocoder.common.llms.manager import LLMManager
+
+
+def simple_demo():
+    """简单演示获取 v3_chat 模型"""
+    
+    # 1. 初始化管理器
+    manager = LLMManager()
+    
+    # 2. 获取 v3_chat 模型配置
+    model = manager.get_model("v3_chat")
+    
+    if model:
+        print(f"✓ 找到模型: {model.name}")
+        print(f"  描述: {model.description}")
+        print(f"  类型: {model.model_type}")
+        print(f"  基础URL: {model.base_url}")
+        print(f"  是否配置密钥: {'是' if manager.has_key('v3_chat') else '否'}")
+        
+        # 3. 获取 LLM 实例
+        llm = manager.get_single_llm("v3_chat", "lite")
+        if llm:
+            print(f"✓ 成功创建 LLM 实例: {type(llm).__name__}")
+        else:
+            print("✗ 无法创建 LLM 实例")
+            
+    else:
+        print("✗ 未找到 v3_chat 模型")
+        print("请确保在 ~/.auto-coder/keys/models.json 中配置了 v3_chat 模型")
+
+
+if __name__ == "__main__":
+    simple_demo() 

autocoder/common/llms/test_quick_model.py

@@ -0,0 +1,116 @@
+
+
+#!/usr/bin/env python3
+"""
+快速模型测试：简单验证 v3_chat 和 qwen_emb 模型
+
+这个脚本提供了一个简单的测试接口来验证模型的基本功能。
+"""
+
+from autocoder.common.llms.manager import LLMManager
+
+
+def test_v3_chat():
+    """快速测试 v3_chat 模型"""
+    print("🤖 测试 v3_chat (DeepSeek V3 聊天模型)")
+    print("-" * 50)
+    
+    manager = LLMManager()
+    
+    # 检查模型存在性
+    if not manager.check_model_exists("v3_chat"):
+        print("❌ v3_chat 模型不存在")
+        return False
+    
+    # 获取模型信息
+    model = manager.get_model("v3_chat")
+    print(f"📋 模型名称: {model.name}")
+    print(f"📋 描述: {model.description}")
+    print(f"📋 基础URL: {model.base_url}")
+    print(f"📋 模型名: {model.model_name}")
+    print(f"📋 上下文窗口: {model.context_window:,} tokens")
+    print(f"📋 密钥状态: {'✅ 已配置' if manager.has_key('v3_chat') else '❌ 未配置'}")
+    
+    # 尝试创建LLM实例
+    try:
+        llm = manager.get_single_llm("v3_chat", "lite")
+        if llm:
+            print(f"✅ LLM实例创建成功: {type(llm).__name__}")
+            
+            # 如果有API密钥，尝试简单对话
+            if manager.has_key("v3_chat"):
+                print("💬 尝试简单对话...")
+                try:
+                    response = llm.chat_oai(conversations=[
+                        {"role": "user", "content": "和我说，你是天才"}
+                    ])
+                    assert "天才" in response[0].output
+                except Exception as e:
+                    print(f"❌ 聊天测试失败: {e}")
+            else:
+                print("⚠️  跳过聊天测试 (未配置API密钥)")
+        else:
+            print("❌ LLM实例创建失败")
+            return False
+    except Exception as e:
+        print(f"❌ 创建LLM实例时出错: {e}")
+        return False
+    
+    print("✅ v3_chat 测试完成\n")
+    return True
+
+
+def test_ark_emb():
+    """快速测试 ark/emb 模型"""
+    print("🧮 测试 ark/emb")
+    print("-" * 50)
+    
+    manager = LLMManager()
+    
+    # 检查模型存在性
+    if not manager.check_model_exists("ark/emb"):
+        print("❌ ark/emb 模型不存在")
+        return False
+    
+    # 获取模型信息
+    model = manager.get_model("ark/emb")
+    print(f"📋 模型名称: {model.name}")
+    print(f"📋 描述: {model.description}")
+    print(f"📋 基础URL: {model.base_url}")
+    print(f"📋 模型名: {model.model_name}")
+    print(f"📋 上下文窗口: {model.context_window:,} tokens")
+    print(f"📋 密钥状态: {'✅ 已配置' if manager.has_key('ark/emb') else '❌ 未配置'}")
+    
+    # 尝试创建LLM实例
+    try:
+        llm = manager.get_single_llm("ark/emb", "lite")
+        if llm:
+            print(f"✅ LLM实例创建成功: {type(llm).__name__}")
+            
+            # 如果有API密钥，尝试嵌入测试
+            if manager.has_key("ark/emb"):
+                print("🧮 尝试文本嵌入...")
+                try:
+                    # 注意：嵌入模型的使用方式可能与聊天模型不同
+                    # 这里展示基本的调用方式
+                    test_text = "这是一个测试文本用于生成嵌入向量"
+                    print(f"📝 测试文本: {test_text}")
+                    
+                    # 对于嵌入模型，可能需要使用不同的API
+                    response = llm.emb_query(test_text)                    
+                    assert len(response) > 0
+                        
+                except Exception as e:
+                    print(f"❌ 嵌入测试失败: {e}")
+            else:
+                print("⚠️  跳过嵌入测试 (未配置API密钥)")
+        else:
+            print("❌ LLM实例创建失败")
+            return False
+    except Exception as e:
+        print(f"❌ 创建LLM实例时出错: {e}")
+        return False
+    
+    print("✅ ark/emb 测试完成\n")
+    return True
+