vtx-coding-agent 0.1.1__py3-none-any.whl

vtx/llm/model_fetcher.py

@@ -0,0 +1,279 @@
+"""Auto-fetch model lists from provider /models endpoints.
+
+When a provider has ``fetch_models: true`` in provider.yaml, this module
+can fetch ``<base_url>/models``, parse the response, and cache the result
+to ``~/.vtx/models/<provider>.json`` with a configurable TTL.
+
+Fetching is opt-in: call ``refresh_provider_models(slug)`` or
+``refresh_all_provider_models()`` to trigger a fetch. The catalog
+only reads from cache, never blocks on network I/O.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import time
+from contextlib import suppress
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+from .models import ApiType, Model
+
+logger = logging.getLogger(__name__)
+
+CACHE_DIR = "models"
+DEFAULT_COOLDOWN = 60  # minutes
+
+
+@dataclass
+class FetchedModel:
+    id: str
+    name: str
+    context_length: int = 0
+    max_output_tokens: int = 0
+    supports_images: bool = False
+
+
+def _get_cache_dir() -> Path:
+    from ..config import get_config_dir
+
+    env = os.environ.get("VTX_MODELS_CACHE_DIR")
+    return Path(env) if env else get_config_dir() / CACHE_DIR
+
+
+def _cache_path(provider_slug: str) -> Path:
+    return _get_cache_dir() / f"{provider_slug}.json"
+
+
+def _read_cache(provider_slug: str) -> list[FetchedModel] | None:
+    path = _cache_path(provider_slug)
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (FileNotFoundError, json.JSONDecodeError, OSError):
+        return None
+
+    fetched_at = data.get("fetched_at", 0)
+    cooldown = data.get("cooldown_minutes", DEFAULT_COOLDOWN) * 60
+    if time.time() - fetched_at > cooldown:
+        return None
+
+    models = []
+    for entry in data.get("models", []):
+        models.append(
+            FetchedModel(
+                id=entry["id"],
+                name=entry.get("name", entry["id"]),
+                context_length=entry.get("context_length", 0),
+                max_output_tokens=entry.get("max_output_tokens", 0),
+                supports_images=entry.get("supports_images", False),
+            )
+        )
+    return models
+
+
+def _write_cache(provider_slug: str, models: list[FetchedModel], cooldown_minutes: int) -> None:
+    path = _cache_path(provider_slug)
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        data = {
+            "fetched_at": time.time(),
+            "cooldown_minutes": cooldown_minutes,
+            "models": [asdict(m) for m in models],
+        }
+        tmp = path.with_suffix(".json.tmp")
+        tmp.write_text(json.dumps(data, indent=2), encoding="utf-8")
+        tmp.replace(path)
+    except OSError as exc:
+        logger.warning("Failed to write model cache for %s: %s", provider_slug, exc)
+
+
+def _resolve_api_key(provider) -> str | None:
+    if provider.api_key_env:
+        key = os.environ.get(provider.api_key_env)
+        if key:
+            return key
+    if provider.api_key_optional:
+        return "vtx-local"
+    return None
+
+
+def _parse_models(raw_models: list[dict[str, Any]], parser_config) -> list[FetchedModel]:
+    models: list[FetchedModel] = []
+    for raw in raw_models:
+        model_id = raw.get(parser_config.id_field, "")
+        if not model_id:
+            continue
+
+        name = raw.get(parser_config.name_field, model_id)
+        if isinstance(name, str) and ":" in name:
+            candidate = name.split(":", 1)[1].strip()
+            if candidate:
+                name = candidate
+
+        context_length = 0
+        ctx_val = raw.get(parser_config.context_field)
+        if ctx_val is not None:
+            with suppress(TypeError, ValueError):
+                context_length = int(ctx_val)
+
+        max_output = 0
+        out_val = raw.get(parser_config.output_field)
+        if out_val is not None:
+            with suppress(TypeError, ValueError):
+                max_output = int(out_val)
+
+        supports_images = False
+        arch = raw.get("architecture")
+        if isinstance(arch, dict):
+            modalities = arch.get("input_modalities", [])
+            supports_images = "image" in modalities if isinstance(modalities, list) else False
+        if not supports_images:
+            modalities = raw.get("input_modalities")
+            supports_images = isinstance(modalities, list) and "image" in modalities
+
+        models.append(
+            FetchedModel(
+                id=model_id,
+                name=name,
+                context_length=context_length,
+                max_output_tokens=max_output,
+                supports_images=supports_images,
+            )
+        )
+
+    return models
+
+
+def _raw_model_list(payload: Any) -> list[dict[str, Any]]:
+    if isinstance(payload, list):
+        return [m for m in payload if isinstance(m, dict)]
+    if isinstance(payload, dict):
+        for key in ("data", "models", "results"):
+            val = payload.get(key)
+            if isinstance(val, list):
+                return [m for m in val if isinstance(m, dict)]
+    return []
+
+
+def _fetch_models_sync(provider) -> list[FetchedModel]:
+    """Fetch models from a provider's /models endpoint (sync, with network)."""
+    if not provider.fetch_models or not provider.base_url:
+        return []
+
+    api_key = _resolve_api_key(provider)
+    base = provider.base_url.rstrip("/")
+    url = f"{base}{provider.models_endpoint}"
+
+    headers = {"Accept": "application/json"}
+    if api_key and api_key != "vtx-local":
+        headers["Authorization"] = f"Bearer {api_key}"
+
+    try:
+        with httpx.Client(timeout=10.0) as client:
+            resp = client.get(url, headers=headers)
+            if resp.status_code >= 400:
+                logger.debug("Failed to fetch models for %s: %s", provider.slug, resp.status_code)
+                return []
+            payload = resp.json()
+    except Exception as exc:
+        logger.debug("Error fetching models for %s: %s", provider.slug, exc)
+        return []
+
+    raw_models = _raw_model_list(payload)
+    if not raw_models:
+        return []
+
+    models = _parse_models(raw_models, provider.model_parser)
+    cooldown = provider.model_parser.cooldown_minutes
+    _write_cache(provider.slug, models, cooldown)
+    return models
+
+
+def refresh_provider_models(slug: str) -> int:
+    """Force-refresh a single provider's model cache. Returns model count."""
+    from .provider_catalog import get
+
+    provider = get(slug)
+    if provider is None or not provider.fetch_models:
+        return 0
+    models = _fetch_models_sync(provider)
+    return len(models)
+
+
+def refresh_all_provider_models() -> dict[str, int]:
+    """Force-refresh all providers. Returns {slug: model_count}."""
+    from .provider_catalog import list_providers
+
+    results: dict[str, int] = {}
+    for p in list_providers():
+        if not p.fetch_models:
+            continue
+        models = _fetch_models_sync(p)
+        results[p.slug] = len(models)
+    return results
+
+
+def get_fetched_models(provider) -> list[Model]:
+    """Get fetched models from cache only (no network). Returns empty if not cached."""
+    if not provider.fetch_models:
+        return []
+
+    cached = _read_cache(provider.slug)
+    if cached is None:
+        return []
+
+    family_to_api = {
+        "openai_compat": ApiType(ApiType.OPENAI_SDK),
+        "anthropic": ApiType(ApiType.ANTHROPIC),
+    }
+
+    from .context_length import context_length_manager
+
+    models: list[Model] = []
+    for entry in cached:
+        limits = context_length_manager.get_limits(entry.id)
+        is_matched = entry.id in context_length_manager._limits or any(
+            entry.id.lower() in k.lower() or k.lower() in entry.id.lower()
+            for k in context_length_manager._limits
+        )
+
+        max_tokens = entry.max_output_tokens or provider.max_tokens
+        supports_images = entry.supports_images or provider.supports_vision
+        supports_thinking = provider.supports_thinking
+        context_window = entry.context_length or None
+
+        if is_matched:
+            if context_window is None or context_window == 0:
+                context_window = limits.context
+            if max_tokens == 0 or max_tokens == provider.max_tokens:
+                max_tokens = limits.output
+            if not supports_thinking:
+                supports_thinking = limits.supports_reasoning
+            if not supports_images:
+                supports_images = limits.supports_vision
+            supports_tools = limits.supports_tools
+            supports_audio = limits.supports_audio
+        else:
+            supports_tools = provider.supports_tools
+            supports_audio = False
+
+        models.append(
+            Model(
+                id=entry.id,
+                provider=provider.slug,
+                api=family_to_api[provider.family],
+                base_url=provider.base_url or "",
+                max_tokens=max_tokens,
+                supports_images=supports_images,
+                supports_thinking=supports_thinking,
+                context_window=context_window,
+                supports_tools=supports_tools,
+                supports_audio=supports_audio,
+            )
+        )
+    return models

vtx/llm/models.py

@@ -0,0 +1,78 @@
+"""
+Model types and catalog.
+
+Model metadata is fetched dynamically via the provider catalog
+and models.dev API. Only the type definitions live here.
+"""
+
+from dataclasses import dataclass
+
+DEFAULT_MAX_TOKENS = 16384
+
+
+class ApiType:
+    OPENAI_COMPLETIONS = "openai-completions"
+    OPENAI_SDK = "openai-sdk"
+    ANTHROPIC = "anthropic"
+
+    _VALUES: frozenset[str] = frozenset({OPENAI_COMPLETIONS, OPENAI_SDK, ANTHROPIC})
+
+    def __init__(self, value: str):
+        if value not in self._VALUES:
+            raise ValueError(f"Invalid ApiType: {value}")
+        self.value = value
+
+    def __eq__(self, other):
+        if isinstance(other, ApiType):
+            return self.value == other.value
+        if isinstance(other, str):
+            return self.value == other
+        return NotImplemented
+
+    def __hash__(self):
+        return hash(self.value)
+
+    def __repr__(self):
+        return f"ApiType({self.value!r})"
+
+
+@dataclass
+class Model:
+    id: str
+    provider: str
+    api: ApiType
+    base_url: str
+    max_tokens: int
+    supports_images: bool
+    supports_thinking: bool
+    context_window: int | None = None
+    supports_tools: bool = True
+    supports_audio: bool = False
+
+
+def get_model(model_id: str, provider: str | None = None) -> Model | None:
+    from .dynamic_models import find_dynamic_model
+    from .provider_catalog import find_model
+
+    model = find_model(model_id, provider)
+    if model is None:
+        model = find_dynamic_model(model_id, provider)
+    return model
+
+
+def get_all_models() -> list[Model]:
+    from .dynamic_models import get_dynamic_models
+    from .provider_catalog import get_all_catalog_models
+
+    merged: list[Model] = get_all_catalog_models()
+    merged.extend(get_dynamic_models())
+    return merged
+
+
+def get_models_by_provider(provider: str) -> list[Model]:
+    return [m for m in get_all_models() if m.provider == provider]
+
+
+def get_max_tokens(model_id: str) -> int:
+    model = get_model(model_id)
+    return model.max_tokens if model else DEFAULT_MAX_TOKENS

vtx/llm/oauth/__init__.py

@@ -0,0 +1,59 @@
+from .copilot import (
+    COPILOT_HEADERS,
+    CopilotCredentials,
+    clear_credentials,
+    get_base_url_from_token,
+    get_copilot_auth_path,
+    get_valid_token,
+    is_copilot_logged_in,
+    load_credentials,
+    login,
+)
+from .dynamic import (
+    DynamicProviderStatus,
+    clear_api_key,
+    get_dynamic_api_key,
+    get_dynamic_auth_path,
+    get_provider_status,
+    has_api_key,
+    load_api_key,
+    save_api_key,
+)
+from .openai import (
+    OpenAICredentials,
+    clear_openai_credentials,
+    get_openai_auth_path,
+    get_valid_openai_credentials,
+    get_valid_openai_token,
+    is_openai_logged_in,
+    load_openai_credentials,
+)
+from .openai import login as openai_login
+
+__all__ = [
+    "COPILOT_HEADERS",
+    "CopilotCredentials",
+    "DynamicProviderStatus",
+    "OpenAICredentials",
+    "clear_api_key",
+    "clear_credentials",
+    "clear_openai_credentials",
+    "get_base_url_from_token",
+    "get_copilot_auth_path",
+    "get_dynamic_api_key",
+    "get_dynamic_auth_path",
+    "get_openai_auth_path",
+    "get_provider_status",
+    "get_valid_openai_credentials",
+    "get_valid_openai_token",
+    "get_valid_token",
+    "has_api_key",
+    "is_copilot_logged_in",
+    "is_openai_logged_in",
+    "load_api_key",
+    "load_credentials",
+    "load_openai_credentials",
+    "login",
+    "openai_login",
+    "save_api_key",
+]