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

vtx/llm/provider.yaml

@@ -0,0 +1,280 @@
+# LLM Provider Catalog
+# Add new providers here. Each entry defines how to connect to a provider.
+#
+# Fields:
+#   slug:                    Unique identifier
+#   display_name:            Human-readable name
+#   description:             One-line description
+#   family:                  API family - "openai_compat" or "anthropic"
+#   base_url:                API endpoint URL
+#   api_key_env:             Environment variable for API key (null for keyless)
+#   known_models:            Fallback list (used when fetch fails or fetch_models=false)
+#   supports_tools:          Tool calling support (default: true)
+#   supports_vision:         Image input support (default: false)
+#   api_key_optional:        Works without API key (default: false)
+#   is_local:                Local provider (default: false)
+#   max_tokens:              Default max output tokens (default: 8192)
+#   supports_thinking:       Reasoning/thinking support (default: false)
+#   headers:                 Extra request headers, e.g. {"X-Foo": "bar"} (default: {})
+#   openmodelendpoint:       Provider's /models catalog is public (no key needed for
+#                            model discovery). Inference still requires a real key
+#                            unless api_key_optional is also set. (default: false)
+#
+# Auto-fetch fields:
+#   fetch_models:            Fetch model list from /models endpoint (default: false)
+#   models_endpoint:         Path to append to base_url (default: "/models")
+#   model_parser:
+#     array_path:            JSON key containing model array (default: "data")
+#     id_field:              Field for model ID (default: "id")
+#     name_field:            Field for model name (default: "name")
+#     context_field:         Field for context length (default: "context_length")
+#     output_field:          Field for max output tokens (default: "max_completion_tokens")
+#     cooldown_minutes:      Cache TTL in minutes (default: 60)
+
+providers:
+  - slug: openai
+    display_name: OpenAI
+    description: "Official OpenAI API (gpt-4o, gpt-4o-mini, ...)."
+    family: openai_compat
+    base_url: https://api.openai.com/v1
+    api_key_env: OPENAI_API_KEY
+    known_models:
+      - gpt-4o
+      - gpt-4o-mini
+      - gpt-4-turbo
+    supports_vision: true
+    max_tokens: 16384
+    fetch_models: true
+    models_endpoint: /models
+    model_parser:
+      cooldown_minutes: 60
+
+  - slug: anthropic
+    display_name: Anthropic
+    description: Direct Anthropic API.
+    family: anthropic
+    base_url: https://api.anthropic.com
+    api_key_env: ANTHROPIC_API_KEY
+    known_models:
+      - claude-sonnet-4-20250514
+      - claude-3-5-sonnet-20241022
+      - claude-3-5-haiku-20241022
+    supports_vision: true
+    supports_thinking: true
+    max_tokens: 8192
+
+  - slug: deepseek
+    display_name: DeepSeek
+    description: DeepSeek Chat + Reasoner.
+    family: openai_compat
+    base_url: https://api.deepseek.com/v1
+    api_key_env: DEEPSEEK_API_KEY
+    known_models:
+      - deepseek-chat
+      - deepseek-reasoner
+    supports_thinking: true
+    fetch_models: true
+    models_endpoint: /models
+    model_parser:
+      cooldown_minutes: 60
+
+  - slug: zhipu
+    display_name: ZhiPu
+    description: ZhiPu GLM models.
+    family: openai_compat
+    base_url: https://api.z.ai/api/coding/paas/v4
+    api_key_env: ZAI_API_KEY
+    known_models:
+      - glm-5.1
+      - glm-5.2
+    supports_thinking: true
+    fetch_models: true
+    models_endpoint: /models
+    model_parser:
+      cooldown_minutes: 60
+
+  - slug: openrouter
+    display_name: OpenRouter
+    description: "200+ models from every provider, one key."
+    family: openai_compat
+    base_url: https://openrouter.ai/api/v1
+    api_key_env: OPENROUTER_API_KEY
+    known_models:
+      - anthropic/claude-3.5-sonnet
+      - openai/gpt-4o
+      - google/gemini-2.0-flash-exp:free
+    supports_vision: true
+    fetch_models: true
+    models_endpoint: /models
+    model_parser:
+      cooldown_minutes: 60
+
+  - slug: groq
+    display_name: Groq
+    description: Ultra-fast LPU inference.
+    family: openai_compat
+    base_url: https://api.groq.com/openai/v1
+    api_key_env: GROQ_API_KEY
+    known_models:
+      - llama-3.3-70b-versatile
+      - mixtral-8x7b-32768
+    fetch_models: true
+    models_endpoint: /models
+    model_parser:
+      cooldown_minutes: 60
+
+  - slug: together
+    display_name: Together AI
+    description: Open-source models hosted by Together.
+    family: openai_compat
+    base_url: https://api.together.xyz/v1
+    api_key_env: TOGETHER_API_KEY
+    known_models:
+      - meta-llama/Llama-3.3-70B-Instruct-Turbo
+    fetch_models: true
+    models_endpoint: /models
+    model_parser:
+      cooldown_minutes: 60
+
+  - slug: fireworks
+    display_name: Fireworks AI
+    description: Fast open-source inference.
+    family: openai_compat
+    base_url: https://api.fireworks.ai/inference/v1
+    api_key_env: FIREWORKS_API_KEY
+    known_models: []
+    fetch_models: true
+    models_endpoint: /models
+    model_parser:
+      cooldown_minutes: 60
+
+  - slug: mistral
+    display_name: Mistral AI
+    description: Mistral's OpenAI-compatible endpoint.
+    family: openai_compat
+    base_url: https://api.mistral.ai/v1
+    api_key_env: MISTRAL_API_KEY
+    known_models: []
+    fetch_models: true
+    models_endpoint: /models
+    model_parser:
+      cooldown_minutes: 60
+
+  - slug: nvidia
+    display_name: NVIDIA NIM
+    description: NVIDIA inference endpoints.
+    family: openai_compat
+    base_url: https://integrate.api.nvidia.com/v1
+    api_key_env: NVIDIA_API_KEY
+    known_models: []
+    fetch_models: true
+    models_endpoint: /models
+    model_parser:
+      cooldown_minutes: 60
+
+  - slug: deepinfra
+    display_name: DeepInfra
+    description: Serverless GPU inference.
+    family: openai_compat
+    base_url: https://api.deepinfra.com/v1/openai
+    api_key_env: DEEPINFRA_API_KEY
+    known_models: []
+    fetch_models: true
+    models_endpoint: /models
+    model_parser:
+      cooldown_minutes: 60
+
+  - slug: huggingface
+    display_name: Hugging Face
+    description: Hugging Face inference API.
+    family: openai_compat
+    base_url: https://router.huggingface.co/v1
+    api_key_env: HF_TOKEN
+    known_models: []
+    fetch_models: true
+    models_endpoint: /models
+    model_parser:
+      cooldown_minutes: 60
+
+  - slug: ollama
+    display_name: "Ollama (local)"
+    description: Local models served by Ollama.
+    family: openai_compat
+    base_url: http://localhost:11434/v1
+    api_key_env: null
+    known_models: []
+    api_key_optional: true
+    is_local: true
+    openmodelendpoint: true
+    fetch_models: true
+    models_endpoint: /models
+    model_parser:
+      cooldown_minutes: 5
+
+  - slug: aerolink
+    display_name: Aerolink
+    description: Aerolink Anthropic-compatible gateway with auto-fetched model catalog.
+    family: anthropic
+    base_url: https://capi.aerolink.lat
+    api_key_env: ANTHROPIC_API_KEY
+    known_models: []
+    supports_vision: true
+    supports_thinking: true
+    max_tokens: 8192
+    fetch_models: true
+    models_endpoint: /v1/models
+    model_parser:
+      cooldown_minutes: 60
+
+  - slug: airouter
+    display_name: Airouter
+    description: Airouter gateway (free tier + paid models).
+    family: openai_compat
+    base_url: https://api.airouter.in/v1
+    api_key_env: AIROUTER_API_KEY
+    known_models: []
+    fetch_models: true
+    models_endpoint: /models
+    model_parser:
+      cooldown_minutes: 60
+
+  - slug: opencode
+    display_name: OpenCode Zen
+    description: Curated models via OpenCode Zen.
+    family: openai_compat
+    base_url: https://opencode.ai/zen/v1
+    api_key_env: OPENCODE_API_KEY
+    known_models: []
+    openmodelendpoint: true
+    fetch_models: true
+    models_endpoint: /models
+    model_parser:
+      cooldown_minutes: 60
+
+  - slug: kilo
+    display_name: Kilo Gateway
+    description: Kilo AI gateway (free tier + paid models).
+    family: openai_compat
+    base_url: https://api.kilo.ai/api/gateway
+    api_key_env: KILO_API_KEY
+    known_models: []
+    headers:
+      X-KILOCODE-EDITORNAME: vtx
+      User-Agent: vtx
+    openmodelendpoint: true
+    fetch_models: true
+    models_endpoint: /models
+    model_parser:
+      cooldown_minutes: 60
+
+  - slug: tokenrouter
+    display_name: TokenRouter
+    description: TokenRouter gateway.
+    family: openai_compat
+    base_url: https://api.tokenrouter.com/v1
+    api_key_env: TOKENROUTER_API_KEY
+    known_models: []
+    fetch_models: true
+    models_endpoint: /models
+    model_parser:
+      cooldown_minutes: 60

vtx/llm/provider_catalog.py

@@ -0,0 +1,230 @@
+"""Load LLM provider catalog from provider.yaml."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import yaml
+
+from .models import ApiType, Model
+
+
+@dataclass(frozen=True)
+class ModelParserConfig:
+    array_path: str = "data"
+    id_field: str = "id"
+    name_field: str = "name"
+    context_field: str = "context_length"
+    output_field: str = "max_completion_tokens"
+    cooldown_minutes: int = 60
+
+
+@dataclass(frozen=True)
+class ProviderInfo:
+    slug: str
+    display_name: str
+    description: str
+    family: str
+    base_url: str | None = None
+    api_key_env: str | None = None
+    known_models: tuple[str, ...] = ()
+    supports_tools: bool = True
+    supports_vision: bool = False
+    api_key_optional: bool = False
+    is_local: bool = False
+    max_tokens: int = 8192
+    supports_thinking: bool = False
+    fetch_models: bool = False
+    models_endpoint: str = "/models"
+    headers: dict[str, str] = field(default_factory=dict)
+    openmodelendpoint: bool = False
+    model_parser: ModelParserConfig = field(default_factory=ModelParserConfig)
+
+
+_YAML_PATH = Path(__file__).parent / "provider.yaml"
+_cache: dict[str, ProviderInfo] | None = None
+_order_cache: list[str] | None = None
+
+
+def _load() -> dict[str, ProviderInfo]:
+    global _cache
+    if _cache is not None:
+        return _cache
+
+    with open(_YAML_PATH, encoding="utf-8") as f:
+        data = yaml.safe_load(f)
+
+    providers: dict[str, ProviderInfo] = {}
+    for entry in data.get("providers", []):
+        parser_data = entry.get("model_parser") or {}
+        parser = ModelParserConfig(
+            array_path=parser_data.get("array_path", "data"),
+            id_field=parser_data.get("id_field", "id"),
+            name_field=parser_data.get("name_field", "name"),
+            context_field=parser_data.get("context_field", "context_length"),
+            output_field=parser_data.get("output_field", "max_completion_tokens"),
+            cooldown_minutes=parser_data.get("cooldown_minutes", 60),
+        )
+        p = ProviderInfo(
+            slug=entry["slug"],
+            display_name=entry["display_name"],
+            description=entry["description"],
+            family=entry["family"],
+            base_url=entry.get("base_url"),
+            api_key_env=entry.get("api_key_env"),
+            known_models=tuple(entry.get("known_models", [])),
+            supports_tools=entry.get("supports_tools", True),
+            supports_vision=entry.get("supports_vision", False),
+            api_key_optional=entry.get("api_key_optional", False),
+            is_local=entry.get("is_local", False),
+            max_tokens=entry.get("max_tokens", 8192),
+            supports_thinking=entry.get("supports_thinking", False),
+            fetch_models=entry.get("fetch_models", False),
+            models_endpoint=entry.get("models_endpoint", "/models"),
+            headers=entry.get("headers") or {},
+            openmodelendpoint=entry.get("openmodelendpoint", False),
+            model_parser=parser,
+        )
+        providers[p.slug] = p
+
+    _cache = providers
+    return _cache
+
+
+def _get_order() -> list[str]:
+    global _order_cache
+    if _order_cache is not None:
+        return _order_cache
+    with open(_YAML_PATH, encoding="utf-8") as f:
+        data = yaml.safe_load(f)
+    _order_cache = [e["slug"] for e in data.get("providers", [])]
+    return _order_cache
+
+
+DEFAULT_PROVIDER_SLUG = "openai"
+
+
+def get(slug: str) -> ProviderInfo | None:
+    return _load().get(slug)
+
+
+def list_providers() -> list[ProviderInfo]:
+    order = _get_order()
+    providers = _load()
+    return [providers[s] for s in order if s in providers]
+
+
+def detect_provider_from_env() -> ProviderInfo:
+    providers = _load()
+    order = _get_order()
+
+    explicit = os.getenv("VTX_PROVIDER", "").strip().lower()
+    if explicit and explicit in providers:
+        return providers[explicit]
+
+    for slug in order:
+        p = providers[slug]
+        if p.is_local:
+            continue
+        if p.api_key_env and os.getenv(p.api_key_env):
+            return p
+
+    for slug in order:
+        p = providers[slug]
+        if p.is_local and p.api_key_optional:
+            return p
+
+    return providers[DEFAULT_PROVIDER_SLUG]
+
+
+def is_provider_configured(p: ProviderInfo) -> bool:
+    if p.api_key_optional:
+        return True
+    if p.api_key_env is None:
+        return True
+    return bool(os.getenv(p.api_key_env))
+
+
+def _provider_info_to_model(p: ProviderInfo, model_id: str) -> Model:
+    family_to_api = {
+        "openai_compat": ApiType(ApiType.OPENAI_SDK),
+        "anthropic": ApiType(ApiType.ANTHROPIC),
+    }
+    from .context_length import context_length_manager
+
+    limits = context_length_manager.get_limits(model_id)
+    is_matched = model_id in context_length_manager._limits or any(
+        model_id.lower() in k.lower() or k.lower() in model_id.lower()
+        for k in context_length_manager._limits
+    )
+
+    if is_matched:
+        max_tokens = limits.output
+        supports_images = limits.supports_vision
+        supports_thinking = limits.supports_reasoning
+        context_window = limits.context
+        supports_tools = limits.supports_tools
+        supports_audio = limits.supports_audio
+    else:
+        max_tokens = p.max_tokens
+        supports_images = p.supports_vision
+        supports_thinking = p.supports_thinking
+        context_window = limits.context
+        supports_tools = p.supports_tools
+        supports_audio = False
+
+    return Model(
+        id=model_id,
+        provider=p.slug,
+        api=family_to_api[p.family],
+        base_url=p.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,
+    )
+
+
+def get_all_catalog_models() -> list[Model]:
+    from .model_fetcher import get_fetched_models
+
+    models: list[Model] = []
+    for p in _load().values():
+        fetched = get_fetched_models(p)
+        if fetched:
+            models.extend(fetched)
+        else:
+            for model_id in p.known_models:
+                models.append(_provider_info_to_model(p, model_id))
+    return models
+
+
+def find_model(model_id: str, provider: str | None = None) -> Model | None:
+    from .model_fetcher import get_fetched_models
+
+    providers = _load()
+    if provider:
+        p = providers.get(provider)
+        if p:
+            fetched = get_fetched_models(p)
+            if fetched:
+                for m in fetched:
+                    if m.id == model_id:
+                        return m
+            if model_id in p.known_models:
+                return _provider_info_to_model(p, model_id)
+
+    for p in providers.values():
+        fetched = get_fetched_models(p)
+        if fetched:
+            for m in fetched:
+                if m.id == model_id:
+                    return m
+        if model_id in p.known_models:
+            return _provider_info_to_model(p, model_id)
+
+    return None

vtx/llm/providers/__init__.py

@@ -0,0 +1,45 @@
+from ..base import BaseProvider
+from ..models import ApiType
+
+PROVIDER_API_BY_NAME: dict[str, ApiType] = {
+    "openai": ApiType(ApiType.OPENAI_SDK),
+    "anthropic": ApiType(ApiType.ANTHROPIC),
+    "zhipu": ApiType(ApiType.OPENAI_SDK),
+    "deepseek": ApiType(ApiType.OPENAI_SDK),
+    "airouter": ApiType(ApiType.OPENAI_SDK),
+    "opencode": ApiType(ApiType.OPENAI_SDK),
+    "kilo": ApiType(ApiType.OPENAI_SDK),
+    "tokenrouter": ApiType(ApiType.OPENAI_SDK),
+    "openrouter": ApiType(ApiType.OPENAI_SDK),
+    "ollama": ApiType(ApiType.OPENAI_SDK),
+    "aerolink": ApiType(ApiType.ANTHROPIC),
+}
+
+
+def resolve_provider_api_type(provider: str | None) -> ApiType:
+    if provider is None:
+        return ApiType(ApiType.OPENAI_SDK)
+    api_type = PROVIDER_API_BY_NAME.get(provider)
+    if api_type is None:
+        return ApiType(ApiType.OPENAI_SDK)
+    return api_type
+
+
+def get_provider_class(api_type: ApiType) -> type[BaseProvider]:
+    match api_type.value:
+        case ApiType.OPENAI_SDK:
+            from .openai_sdk import OpenAISDKProvider
+
+            return OpenAISDKProvider
+        case ApiType.ANTHROPIC:
+            from .anthropic_sdk import AnthropicSDKProvider
+
+            return AnthropicSDKProvider
+        case ApiType.OPENAI_COMPLETIONS:
+            from .openai_sdk import OpenAISDKProvider
+
+            return OpenAISDKProvider
+    raise ValueError(f"Unsupported API type: {api_type.value}")
+
+
+__all__ = ["PROVIDER_API_BY_NAME", "get_provider_class", "resolve_provider_api_type"]