vmcode-cli 1.0.0

package/src/llm/client.py

@@ -0,0 +1,149 @@
+"""LLM client for making API requests to various providers."""
+
+import requests
+from llm import config as config_module
+from llm.config import PROVIDER_REGISTRY, get_provider_config, get_providers
+from llm.providers import get_handler
+from exceptions import LLMConnectionError, LLMResponseError, ConfigurationError
+
+
+class StreamWrapper:
+    """Wraps streaming response generator with cleanup capability."""
+
+    def __init__(self, response, generator):
+        self._response = response
+        self._generator = generator
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        return next(self._generator)
+
+    def close(self):
+        """Close underlying HTTP connection."""
+        if self._response:
+            self._response.close()
+
+
+class LLMClient:
+    def __init__(self, provider=None):
+        """Initialize LLM client.
+
+        Args:
+            provider: Provider name. If None, uses global LLM_PROVIDER from config.
+        """
+        self.provider = provider or config_module.LLM_PROVIDER
+        self.handler = get_handler(self.provider)
+        self.config = self._get_provider_config()
+
+    @property
+    def model(self) -> str:
+        """Return configured model name, if any."""
+        return str(self.config.get("payload", {}).get("model") or "")
+
+    def _get_provider_config(self):
+        """Build provider config from PROVIDER_REGISTRY."""
+        registry = get_provider_config(self.provider)
+        if not registry:
+            raise ConfigurationError(f"Unknown provider: {self.provider}")
+
+        # Build headers using handler
+        headers = self.handler.build_headers(registry)
+
+        # Build payload with model name
+        payload = {}
+        model_name = registry.get("api_model") or registry.get("model")
+        if model_name:
+            payload["model"] = model_name
+
+        return {
+            "url": f"{registry['api_base']}{registry['endpoint']}",
+            "headers": headers,
+            "payload": payload,
+            "error_prefix": registry["error_prefix"],
+            "registry": registry
+        }
+
+    def chat_completion(self, messages, stream=True, tools=None):
+        """Make a chat completion request.
+
+        Args:
+            messages: List of message dicts
+            stream: Whether to stream the response
+            tools: Optional list of tool definitions
+
+        Returns:
+            StreamWrapper if stream=True, else response dict
+        """
+        config = self.config
+        registry = config["registry"]
+
+        # Build payload using handler
+        payload = self.handler.build_payload(registry, messages, tools, stream)
+
+        try:
+            response = requests.post(
+                config["url"],
+                headers=config["headers"],
+                json=payload,
+                stream=stream
+            )
+
+            # For better debugging, include response text on 4xx errors
+            if not response.ok:
+                error_details = response.text if response.text else str(response.status_code)
+                raise LLMConnectionError(
+                    f"Error communicating with {config['error_prefix']}",
+                    details={"provider": self.provider, "original_error": error_details}
+                )
+            response.raise_for_status()
+
+            if stream:
+                return StreamWrapper(
+                    response,
+                    self.handler.parse_stream(response)
+                )
+            else:
+                response_json = response.json()
+                return self.handler.parse_response(response_json)
+
+        except requests.exceptions.RequestException as e:
+            raise LLMConnectionError(
+                f"Error communicating with {config['error_prefix']}",
+                details={"provider": self.provider, "original_error": str(e)}
+            )
+
+    def switch_provider(self, new_provider):
+        """Switch to a different provider.
+
+        Args:
+            new_provider: Name of the provider to switch to.
+
+        Returns:
+            True if successful, False if provider not found.
+        """
+        if new_provider in get_providers():
+            self.provider = new_provider
+            self.handler = get_handler(new_provider)
+            self.config = self._get_provider_config()
+            return True
+        return False
+
+    def sync_provider_from_config(self):
+        """Sync this client's provider and config with the current config.
+
+        This should be called after config is reloaded from disk.
+        """
+        current_provider = config_module.LLM_PROVIDER
+        if self.provider != current_provider:
+            self.provider = current_provider
+            self.handler = get_handler(current_provider)
+            self.config = self._get_provider_config()
+            return True
+        # Even if provider hasn't changed, config values (model, api_key) might have
+        self.config = self._get_provider_config()
+        return False
+
+
+__all__ = ['LLMClient']

package/src/llm/config.py

@@ -0,0 +1,445 @@
+import os
+import platform
+from pathlib import Path
+import yaml
+
+# Provider selection - loaded from config (see after PROVIDER_REGISTRY definition)
+
+CONFIG_PATH = Path(__file__).resolve().parents[2] / "config.yaml"
+
+# Environment variable names for API keys (env vars take precedence over config file)
+ENV_API_KEYS = {
+    'ANTHROPIC_API_KEY': os.environ.get('ANTHROPIC_API_KEY'),
+    'OPENAI_API_KEY': os.environ.get('OPENAI_API_KEY'),
+    'GLM_API_KEY': os.environ.get('GLM_API_KEY'),
+    'GEMINI_API_KEY': os.environ.get('GEMINI_API_KEY'),
+    'OPENROUTER_API_KEY': os.environ.get('OPENROUTER_API_KEY'),
+    'KIMI_API_KEY': os.environ.get('KIMI_API_KEY'),
+    'MINIMAX_API_KEY': os.environ.get('MINIMAX_API_KEY'),
+}
+
+# Detect platform for llama.cpp paths
+_IS_WINDOWS = platform.system() == "Windows"
+_IS_LINUX = platform.system() == "Linux"
+
+# Set llama.cpp paths based on platform
+if _IS_WINDOWS:
+    _LLAMA_SERVER_NAME = "llama-server.exe"
+    _LLAMA_BUILD_DIR = "build"
+elif _IS_LINUX:
+    _LLAMA_SERVER_NAME = "llama-server"
+    _LLAMA_BUILD_DIR = "build-linux"
+else:
+    # Fallback for macOS or other platforms
+    _LLAMA_SERVER_NAME = "llama-server"
+    _LLAMA_BUILD_DIR = "build"
+
+def _load_config():
+    """Load config from YAML file, with environment variable overrides for API keys.
+    
+    Environment variables take precedence over values in config.yaml.
+    """
+    config_path = Path(__file__).resolve().parents[2] / "config.yaml"
+    if not config_path.exists():
+        return {}
+    try:
+        config = yaml.safe_load(config_path.read_text(encoding="utf-8-sig")) or {}
+    except yaml.YAMLError:
+        config = {}
+    
+    # Override API keys from environment variables (env vars take precedence)
+    for key, env_value in ENV_API_KEYS.items():
+        if env_value:  # Only override if env var is set and non-empty
+            config[key] = env_value
+    
+    return config
+
+
+_CONFIG = _load_config()
+
+# Cache for provider registry (built once at module load)
+_provider_registry_cache = None
+_cached_provider = None
+
+
+def _get_provider_registry():
+    """Build PROVIDER_REGISTRY from current config (cached)."""
+    global _provider_registry_cache
+    if _provider_registry_cache is not None:
+        return _provider_registry_cache
+
+    # Helper function to get model-specific pricing
+    def get_model_cost(provider_name: str, model_name: str, cost_key_in: str, cost_key_out: str, default_in: float, default_out: float) -> tuple[float, float]:
+        """Get model-specific cost from MODEL_PRICES."""
+        model_prices = _CONFIG.get("MODEL_PRICES", {})
+        if model_name in model_prices:
+            model_cost = model_prices[model_name]
+            return float(model_cost.get("cost_in", 0.0)), float(model_cost.get("cost_out", 0.0))
+        return 0.0, 0.0
+
+    _provider_registry_cache = {
+        "local": {
+            "type": "local",
+            "api_key": None,
+            "model": _CONFIG.get("LOCAL_MODEL_PATH", ""),
+            "api_model": "model",
+            "api_base": "http://127.0.0.1:8080",
+            "endpoint": "/v1/chat/completions",
+            "error_prefix": "local server",
+            "config_keys": {
+                "LOCAL_MODEL_PATH": "",
+                "LOCAL_SERVER_PATH": str(
+                    Path(__file__).resolve().parents[2] /
+                    f"llama.cpp/{_LLAMA_BUILD_DIR}/bin/{_LLAMA_SERVER_NAME}"
+                ),
+            },
+            "extra": {
+                "host": "127.0.0.1",
+                "port": 8080,
+            },
+            "default_temperature": 0.1,
+            "default_top_p": 0.9,
+            "allow_top_p": True,
+            "allow_temperature": True,
+            "cost_in": 0.0,
+            "cost_out": 0.0
+        },
+        "openrouter": {
+            "type": "api",
+            "api_key": _CONFIG.get("OPENROUTER_API_KEY", ""),
+            "model": _CONFIG.get("OPENROUTER_MODEL", ""),
+            "api_base": _CONFIG.get("OPENROUTER_API_BASE", "https://openrouter.ai/api/v1"),
+            "endpoint": "/chat/completions",
+            "error_prefix": "OpenRouter",
+            "headers_extra": {
+                "HTTP-Referer": "http://localhost:8080",
+                "X-Title": "Chat App"
+            },
+            "config_keys": {
+                "OPENROUTER_API_KEY": "",
+                "OPENROUTER_MODEL": "",
+                "OPENROUTER_API_BASE": "https://openrouter.ai/api/v1",
+            },
+            "default_temperature": 0.1,
+            "default_top_p": 0.9,
+            "allow_top_p": True,
+            "allow_temperature": True,
+            "cost_in": get_model_cost("openrouter", _CONFIG.get("OPENROUTER_MODEL", ""),
+                                     "", "", 0.0, 0.0)[0],
+            "cost_out": get_model_cost("openrouter", _CONFIG.get("OPENROUTER_MODEL", ""),
+                                      "", "", 0.0, 0.0)[1]
+        },
+        "glm": {
+            "type": "api",
+            "api_key": _CONFIG.get("GLM_API_KEY", ""),
+            "model": _CONFIG.get("GLM_MODEL", ""),
+            "api_base": _CONFIG.get("GLM_API_BASE", "https://open.bigmodel.cn/api/paas/v4"),
+            "endpoint": "/chat/completions",
+            "error_prefix": "GLM",
+            "config_keys": {
+                "GLM_API_KEY": "",
+                "GLM_MODEL": "",
+                "GLM_API_BASE": "https://open.bigmodel.cn/api/paas/v4",
+            },
+            "default_temperature": 0.1,
+            "default_top_p": 0.9,
+            "allow_top_p": True,
+            "allow_temperature": True,
+            "cost_in": get_model_cost("glm", _CONFIG.get("GLM_MODEL", ""),
+                                     "", "", 0.0, 0.0)[0],
+            "cost_out": get_model_cost("glm", _CONFIG.get("GLM_MODEL", ""),
+                                      "", "", 0.0, 0.0)[1]
+        },
+        "openai": {
+            "type": "api",
+            "api_key": _CONFIG.get("OPENAI_API_KEY", ""),
+            "model": _CONFIG.get("OPENAI_MODEL", ""),
+            "api_base": _CONFIG.get("OPENAI_API_BASE", "https://api.openai.com/v1"),
+            "endpoint": "/chat/completions",
+            "error_prefix": "OpenAI",
+            "config_keys": {
+                "OPENAI_API_KEY": "",
+                "OPENAI_MODEL": "",
+                "OPENAI_API_BASE": "https://api.openai.com/v1",
+            },
+            "default_temperature": 0.1,
+            "default_top_p": 0.9,
+            "allow_top_p": False,
+            "allow_temperature": False,
+            "cost_in": get_model_cost("openai", _CONFIG.get("OPENAI_MODEL", ""),
+                                     "", "", 0.0, 0.0)[0],
+            "cost_out": get_model_cost("openai", _CONFIG.get("OPENAI_MODEL", ""),
+                                      "", "", 0.0, 0.0)[1]
+        },
+        "gemini": {
+            "type": "api",
+            "api_key": _CONFIG.get("GEMINI_API_KEY", ""),
+            "model": _CONFIG.get("GEMINI_MODEL", ""),
+            "api_base": _CONFIG.get("GEMINI_API_BASE", "https://generativelanguage.googleapis.com/v1beta"),
+            "endpoint": "/chat/completions",
+            "error_prefix": "Gemini",
+            "config_keys": {
+                "GEMINI_API_KEY": "",
+                "GEMINI_MODEL": "",
+                "GEMINI_API_BASE": "https://generativelanguage.googleapis.com/v1beta",
+            },
+            "default_temperature": 0.1,
+            "default_top_p": 0.9,
+            "allow_top_p": True,
+            "allow_temperature": True,
+            "cost_in": get_model_cost("gemini", _CONFIG.get("GEMINI_MODEL", ""),
+                                     "", "", 0.0, 0.0)[0],
+            "cost_out": get_model_cost("gemini", _CONFIG.get("GEMINI_MODEL", ""),
+                                      "", "", 0.0, 0.0)[1]
+        },
+        "minimax": {
+            "type": "api",
+            "api_key": _CONFIG.get("MINIMAX_API_KEY", ""),
+            "model": _CONFIG.get("MINIMAX_MODEL", ""),
+            "api_base": _CONFIG.get("MINIMAX_API_BASE", "https://api.minimax.chat/v1"),
+            "endpoint": "/chat/completions",
+            "error_prefix": "MiniMax",
+            "config_keys": {
+                "MINIMAX_API_KEY": "",
+                "MINIMAX_MODEL": "",
+                "MINIMAX_API_BASE": "https://api.minimax.chat/v1",
+            },
+            "default_temperature": 0.1,
+            "default_top_p": 0.9,
+            "allow_top_p": True,
+            "allow_temperature": True,
+            "cost_in": get_model_cost("minimax", _CONFIG.get("MINIMAX_MODEL", ""),
+                                     "", "", 0.0, 0.0)[0],
+            "cost_out": get_model_cost("minimax", _CONFIG.get("MINIMAX_MODEL", ""),
+                                      "", "", 0.0, 0.0)[1]
+        },
+        "anthropic": {
+            "type": "api",
+            "api_key": _CONFIG.get("ANTHROPIC_API_KEY", ""),
+            "model": _CONFIG.get("ANTHROPIC_MODEL", ""),
+            "api_base": _CONFIG.get("ANTHROPIC_API_BASE", "https://api.anthropic.com/v1"),
+            "endpoint": "/messages",
+            "error_prefix": "Anthropic",
+            "headers_extra": {
+                "anthropic-version": "2023-06-01"
+            },
+            "config_keys": {
+                "ANTHROPIC_API_KEY": "",
+                "ANTHROPIC_MODEL": "",
+                "ANTHROPIC_API_BASE": "https://api.anthropic.com/v1",
+            },
+            "default_temperature": 0.1,
+            "default_top_p": 0.9,
+            "allow_top_p": False,
+            "allow_temperature": True,
+            "max_tokens": 4096,
+            "cost_in": get_model_cost("anthropic", _CONFIG.get("ANTHROPIC_MODEL", ""),
+                                     "", "", 0.0, 0.0)[0],
+            "cost_out": get_model_cost("anthropic", _CONFIG.get("ANTHROPIC_MODEL", ""),
+                                      "", "", 0.0, 0.0)[1]
+        },
+        "kimi": {
+            "type": "api",
+            "api_key": _CONFIG.get("KIMI_API_KEY", ""),
+            "model": _CONFIG.get("KIMI_MODEL", ""),
+            "api_base": _CONFIG.get("KIMI_API_BASE", "https://api.moonshot.cn/v1"),
+            "endpoint": "/chat/completions",
+            "error_prefix": "Kimi",
+            "config_keys": {
+                "KIMI_API_KEY": "",
+                "KIMI_MODEL": "",
+                "KIMI_API_BASE": "https://api.moonshot.cn/v1",
+            },
+            "default_temperature": 0.1,
+            "default_top_p": 0.9,
+            "allow_top_p": True,
+            "allow_temperature": True,
+            "cost_in": get_model_cost("kimi", _CONFIG.get("KIMI_MODEL", ""),
+                                     "", "", 0.0, 0.0)[0],
+            "cost_out": get_model_cost("kimi", _CONFIG.get("KIMI_MODEL", ""),
+                                      "", "", 0.0, 0.0)[1]
+        },
+        "vmcode_free": {
+            "type": "api",
+            "api_key": "",
+            "model": "z-ai/glm-4.5-air:free",
+            "api_base": _CONFIG.get("VMCODE_FREE_API_BASE", "https://vmcode-five.vercel.app"),
+            "endpoint": "/chat",
+            "error_prefix": "vmCode Free",
+            "config_keys": {
+                "VMCODE_FREE_API_BASE": "https://vmcode-five.vercel.app",
+            },
+            "default_temperature": 0.7,
+            "default_top_p": 0.9,
+            "allow_top_p": True,
+            "allow_temperature": True,
+            "cost_in": 0.0,
+            "cost_out": 0.0
+        },
+    }
+    return _provider_registry_cache
+
+
+def _get_provider():
+    """Get the current provider from config (cached)."""
+    global _cached_provider
+    if _cached_provider is not None:
+        return _cached_provider
+
+    last_provider = _CONFIG.get("LAST_PROVIDER")
+    if last_provider and last_provider in _provider_registry_cache:
+        _cached_provider = last_provider
+        return _cached_provider
+    _cached_provider = "glm"
+    return _cached_provider
+
+
+def reload_config():
+    """Reload config from disk and invalidate caches.
+    
+    Reloads both the config.yaml file and environment variables.
+    
+    Note: This is a manual operation - call after config changes.
+    """
+    global _CONFIG, _provider_registry_cache, _cached_provider, PROVIDER_REGISTRY, LLM_PROVIDER
+    _CONFIG = _load_config()
+    _provider_registry_cache = None
+    _cached_provider = None
+    # Rebuild module-level variables
+    PROVIDER_REGISTRY = _get_provider_registry()
+    LLM_PROVIDER = _get_provider()
+
+
+def get_providers():
+    """Get list of available providers.
+
+    Returns:
+        list: List of provider names from PROVIDER_REGISTRY.
+    """
+    return list(PROVIDER_REGISTRY.keys())
+
+
+# ============================================================================
+# PROVIDER REGISTRY - Centralized provider configuration
+# ============================================================================
+
+# Build provider registry and export as module-level constants (loaded once)
+PROVIDER_REGISTRY = _get_provider_registry()
+LLM_PROVIDER = _get_provider()
+
+
+__all__ = [
+    "CONFIG_PATH",
+    "PROVIDER_REGISTRY",
+    "get_providers",
+    "LLM_PROVIDER",
+    "TOOLS_ENABLED",
+    "TOOLS_REQUIRE_CONFIRMATION",
+    "WEB_SEARCH_REQUIRE_CONFIRMATION",
+    "APPROVE_MODES",
+    "APPROVE_MODE_LABELS",
+    "INTERACTION_MODES",
+    "INTERACTION_MODE_LABELS",
+    "LEARNING_MODES",
+    "LEARNING_MODE_LABELS",
+    "PLAN_TYPES",
+    "PLAN_TYPE_LABELS",
+    "ALLOWED_COMMANDS",
+    "get_provider_config",
+    "generate_config_template",
+    "reload_config",
+]
+
+
+def generate_config_template():
+    """Generate default template for config.json from provider registry."""
+    template = {}
+    for provider, config in PROVIDER_REGISTRY.items():
+        if "config_keys" in config:
+            template.update(config["config_keys"])
+    return template
+
+# Tooling configuration
+TOOLS_ENABLED = True
+TOOLS_REQUIRE_CONFIRMATION = False
+WEB_SEARCH_REQUIRE_CONFIRMATION = False
+
+# Tool approval modes
+APPROVE_MODES = ("safe", "accept_edits")
+APPROVE_MODE_LABELS = {
+    "safe": "Safe",
+    "accept_edits": "Accept Edits",
+}
+
+# Interaction modes
+INTERACTION_MODES = ("edit", "plan", "learn")
+INTERACTION_MODE_LABELS = {
+    "edit": "Edit (Full Access)",
+    "plan": "Plan (Read-Only)",
+    "learn": "Learn (Read-Only)"
+}
+
+# Learning modes (sub-modes for Learn interaction mode)
+LEARNING_MODES = ("succinct", "balanced", "verbose")
+LEARNING_MODE_LABELS = {
+    "succinct": "Succinct",
+    "balanced": "Balanced",
+    "verbose": "Verbose"
+}
+
+# Plan types (planning behavior options for Plan interaction mode)
+PLAN_TYPES = ("feature", "refactor", "debug", "optimize")
+PLAN_TYPE_LABELS = {
+    "feature": "Feature",
+    "refactor": "Refactor",
+    "debug": "Debug",
+    "optimize": "Optimize"
+}
+
+# Commands that do NOT require approval (safe, read-only commands)
+ALLOWED_COMMANDS = [
+    # System queries
+    "which", "whereis", "type", "pwd",
+    
+    # System info (read-only)
+    "ps", "pgrep", "pidof",               # Process info
+    "df", "du", "free",                    # Resource info
+    "uname", "hostname", "uptime",         # System info
+    "env", "printenv", "export",          # Environment (read operations)
+    "lscpu", "lsblk", "lsof",              # Hardware info
+    "date", "cal", "uptime",               # Time/date
+    
+    # Network query (read-only)
+    "ping", "nslookup", "dig", "ss", "ip", "ifconfig",
+    
+    # Package query (read-only only - install/upgrade requires approval)
+    "pacman", "dpkg", "apt-cache", "rpm", "dnf", "yum",
+    
+    # Text utilities (read-only operations)
+    "grep", "egrep", "fgrep", "sed", "awk",
+    "cut", "sort", "head", "tail", "wc", "tr", "uniq",
+    
+    # Development queries
+    "python", "python3", "node", "npm", "pip",  # When used for queries (version, help, etc.)
+    
+    # Computer agent debugging tools
+    "file", "stat",                           # File inspection
+    "md5sum", "sha256sum",                    # File checksums
+    "systemctl", "service",                   # Service management
+    "journalctl", "dmesg",                    # System logs
+    "ltrace",                                 # Library call tracer
+    "netstat",                                # Network connections (legacy)
+    "apt-show", "dpkg-query",                 # Package info queries
+]
+
+
+def get_provider_config(provider: str):
+    """Retrieve the configuration dictionary for a given provider.
+
+    Args:
+        provider (str): Provider name (e.g., 'local', 'openrouter', 'glm', 'openai').
+
+    Returns:
+        dict: Provider config from the PROVIDER_REGISTRY.
+    """
+    return PROVIDER_REGISTRY.get(provider, {})