cct-cli 0.7.9.0__py3-none-any.whl

calc_terminal/providers/adapters/gemini_adapter.py

@@ -0,0 +1,101 @@
+"""
+calc_terminal/providers/adapters/gemini_adapter.py
+==================================================
+Google Gemini Provider Adapter with live discovery and Gemini 2.5 support.
+"""
+
+import requests
+from typing import List
+
+from .base import BaseProviderAdapter
+from ...models.schema import ModelInfo
+from ...models.validator import ModelValidator
+
+
+class GeminiAdapter(BaseProviderAdapter):
+    provider_id = "gemini"
+    display_name = "Google Gemini"
+    company = "Google"
+    region = "US"
+    api_base = "https://generativelanguage.googleapis.com/v1beta"
+    authentication_type = "query_param"
+    documentation_url = "https://ai.google.dev/gemini-api/docs/models/gemini"
+
+    CATALOG_MODELS = {
+        "gemini-2.5-pro": {
+            "display_name": "Gemini 2.5 Pro",
+            "family": "Gemini",
+            "version": "2.5",
+            "context_window": 2000000,
+            "max_output_tokens": 65536,
+            "capabilities": ["reasoning", "coding", "vision", "audio", "tools", "streaming", "long_context"],
+            "pricing": {"input_price_per_1m": 1.25, "output_price_per_1m": 5.0},
+            "recommendation_badges": ["Best for Coding", "Best for Research"],
+        },
+        "gemini-2.5-flash": {
+            "display_name": "Gemini 2.5 Flash",
+            "family": "Gemini",
+            "version": "2.5",
+            "context_window": 1000000,
+            "max_output_tokens": 32768,
+            "capabilities": ["reasoning", "coding", "vision", "tools", "streaming", "fast", "long_context"],
+            "pricing": {"input_price_per_1m": 0.1, "output_price_per_1m": 0.4},
+            "recommendation_badges": ["Best Fast Model", "Best Budget Model"],
+        },
+        "gemini-2.0-flash": {
+            "display_name": "Gemini 2.0 Flash",
+            "family": "Gemini",
+            "version": "2.0",
+            "context_window": 1000000,
+            "max_output_tokens": 8192,
+            "capabilities": ["vision", "coding", "tools", "streaming", "fast"],
+            "pricing": {"input_price_per_1m": 0.1, "output_price_per_1m": 0.4},
+            "recommendation_badges": ["Best Fast Model"],
+        },
+        "gemini-2.0-flash-thinking": {
+            "display_name": "Gemini 2.0 Flash Thinking",
+            "family": "Gemini",
+            "version": "2.0",
+            "context_window": 1000000,
+            "max_output_tokens": 65536,
+            "reasoning_levels": ["high"],
+            "capabilities": ["reasoning", "coding", "vision", "tools", "streaming"],
+            "pricing": {"input_price_per_1m": 0.15, "output_price_per_1m": 0.6},
+            "recommendation_badges": ["Best for Reasoning"],
+        },
+    }
+
+    def discover_models(self, timeout: float = 8.0) -> List[ModelInfo]:
+        base = self.get_api_base()
+        key = self.get_api_key()
+        params = {}
+        if key:
+            params["key"] = key
+
+        discovered_ids = []
+        try:
+            resp = requests.get(f"{base}/models", params=params, timeout=timeout)
+            if resp.status_code == 200:
+                models = resp.json().get("models", [])
+                for m in models:
+                    name = str(m.get("name", "")).strip()
+                    if "/" in name:
+                        name = name.split("/")[-1]
+                    if name and not any(name.startswith(x) for x in ("embedding", "aqa", "imagen")):
+                        discovered_ids.append(name)
+        except Exception:
+            pass
+
+        for cat_id in self.CATALOG_MODELS:
+            if cat_id not in discovered_ids:
+                discovered_ids.append(cat_id)
+
+        results = []
+        for mid in discovered_ids:
+            meta = dict(self.CATALOG_MODELS.get(mid, {}))
+            meta["model_id"] = mid
+            meta["endpoint"] = base
+            val = ModelValidator.validate_raw(meta, self.provider_id, self.config)
+            if val.is_valid and val.model_info:
+                results.append(val.model_info)
+        return results

calc_terminal/providers/adapters/ollama_adapter.py

@@ -0,0 +1,83 @@
+"""
+calc_terminal/providers/adapters/ollama_adapter.py
+==================================================
+Ollama Provider Adapter for Local and Cloud models.
+"""
+
+import requests
+from typing import List
+
+from .base import BaseProviderAdapter
+from ...models.schema import ModelInfo, AVAILABILITY_LOCAL, AVAILABILITY_CLOUD, AVAILABILITY_OPEN_WEIGHT
+from ...models.validator import ModelValidator
+
+
+class OllamaAdapter(BaseProviderAdapter):
+    provider_id = "ollama"
+    display_name = "Ollama (Local / Cloud)"
+    company = "Ollama"
+    region = "Local"
+    api_base = "http://localhost:11434"
+    authentication_type = "none"
+    documentation_url = "https://ollama.com"
+
+    DEFAULT_FALLBACKS = [
+        "llama3.3", "deepseek-r1", "qwen2.5-coder", "mistral", "phi4", "codellama"
+    ]
+
+    @property
+    def is_local(self) -> bool:
+        base = self.get_api_base()
+        return not ("ollama.ai" in base or "cloud" in base)
+
+    def discover_models(self, timeout: float = 6.0) -> List[ModelInfo]:
+        base = self.get_api_base()
+        models = []
+
+        is_cloud = "ollama.ai" in base or "cloud" in base
+
+        try:
+            resp = requests.get(f"{base}/api/tags", timeout=timeout)
+            if resp.status_code == 200:
+                raw_models = resp.json().get("models", [])
+                for m in raw_models:
+                    name = str(m.get("name", "")).strip()
+                    if name:
+                        meta = {
+                            "model_id": name,
+                            "display_name": f"{name} (Local)" if not is_cloud else f"{name} (Cloud)",
+                            "family": name.split(":")[0].capitalize(),
+                            "availability": AVAILABILITY_CLOUD if is_cloud else AVAILABILITY_LOCAL,
+                            "capabilities": ["chat", "streaming", "local" if not is_cloud else "cloud"],
+                            "tags": ["local" if not is_cloud else "cloud", "open_weight"],
+                            "endpoint": base,
+                            "verified": True,
+                        }
+                        val = ModelValidator.validate_raw(meta, self.provider_id, self.config)
+                        if val.is_valid and val.model_info:
+                            val.model_info.local = not is_cloud
+                            val.model_info.cloud = is_cloud
+                            val.model_info.recommendation_badges = ["Best Local Model"] if not is_cloud else []
+                            models.append(val.model_info)
+        except Exception:
+            pass
+
+        # If local Ollama isn't currently running, return standard installable catalog as preview
+        if not models:
+            for name in self.DEFAULT_FALLBACKS:
+                meta = {
+                    "model_id": name,
+                    "display_name": f"{name} (Ollama)",
+                    "availability": AVAILABILITY_LOCAL,
+                    "capabilities": ["chat", "streaming", "local"],
+                    "tags": ["local", "open_weight"],
+                    "endpoint": base,
+                    "source": "fallback",
+                }
+                val = ModelValidator.validate_raw(meta, self.provider_id, self.config)
+                if val.is_valid and val.model_info:
+                    val.model_info.local = True
+                    val.model_info.cloud = False
+                    models.append(val.model_info)
+
+        return models

calc_terminal/providers/adapters/openai_adapter.py

@@ -0,0 +1,159 @@
+"""
+calc_terminal/providers/adapters/openai_adapter.py
+=================================================
+OpenAI Provider Adapter with live discovery and 2026 model coverage.
+
+Includes native metadata for:
+  - GPT-6 Astra (gpt-6-astra):
+      * Reasoning levels: low, medium, high, xhigh, max
+      * Context window: 1,050,000 tokens
+      * Max output tokens: 128,000 tokens
+      * Capabilities: reasoning, coding, vision, computer_use, research,
+        document_workflows, tools, streaming, long_context
+  - GPT-5.6 series (Sol, Terra, Luna)
+  - o3 and o1 series (o3, o3-mini, o1, o1-mini)
+  - GPT-4o and GPT-4o-mini
+"""
+
+import requests
+from typing import List, Optional
+
+from .base import BaseProviderAdapter
+from ...models.schema import ModelInfo, STATUS_ACTIVE, AVAILABILITY_PAID_API
+from ...models.validator import ModelValidator
+
+
+class OpenAIAdapter(BaseProviderAdapter):
+    provider_id = "openai"
+    display_name = "OpenAI"
+    company = "OpenAI"
+    region = "US"
+    api_base = "https://api.openai.com/v1"
+    authentication_type = "bearer_token"
+    documentation_url = "https://platform.openai.com/docs/models"
+
+    # Known flagship catalog specifications
+    CATALOG_MODELS = {
+        "gpt-6-astra": {
+            "display_name": "GPT-6 Astra",
+            "family": "GPT",
+            "version": "6",
+            "release_date": "2026-03",
+            "context_window": 1050000,
+            "max_output_tokens": 128000,
+            "reasoning_levels": ["low", "medium", "high", "xhigh", "max"],
+            "modalities": ["text", "image"],
+            "capabilities": [
+                "reasoning", "coding", "vision", "computer_use", "research",
+                "document_workflows", "tools", "streaming", "long_context"
+            ],
+            "pricing": {"input_price_per_1m": 5.0, "output_price_per_1m": 20.0},
+            "recommendation_badges": ["Best for Coding", "Best for Reasoning", "Best Agent Model"],
+        },
+        "gpt-5.6-sol": {
+            "display_name": "GPT-5.6 Sol",
+            "family": "GPT",
+            "version": "5.6",
+            "context_window": 512000,
+            "max_output_tokens": 64000,
+            "capabilities": ["reasoning", "coding", "vision", "tools", "streaming", "long_context"],
+            "pricing": {"input_price_per_1m": 2.5, "output_price_per_1m": 10.0},
+            "recommendation_badges": ["Best for Reasoning"],
+        },
+        "gpt-5.6-terra": {
+            "display_name": "GPT-5.6 Terra",
+            "family": "GPT",
+            "version": "5.6",
+            "context_window": 256000,
+            "max_output_tokens": 32000,
+            "capabilities": ["coding", "vision", "tools", "streaming", "fast"],
+            "pricing": {"input_price_per_1m": 1.0, "output_price_per_1m": 4.0},
+            "recommendation_badges": ["Best Fast Model"],
+        },
+        "gpt-5.6-luna": {
+            "display_name": "GPT-5.6 Luna",
+            "family": "GPT",
+            "version": "5.6",
+            "context_window": 128000,
+            "max_output_tokens": 16000,
+            "capabilities": ["chat", "coding", "tools", "fast"],
+            "pricing": {"input_price_per_1m": 0.3, "output_price_per_1m": 1.2},
+            "recommendation_badges": ["Best Budget Model"],
+        },
+        "o3": {
+            "display_name": "o3",
+            "family": "o-series",
+            "context_window": 200000,
+            "max_output_tokens": 100000,
+            "reasoning_levels": ["low", "medium", "high"],
+            "capabilities": ["reasoning", "coding", "vision", "tools", "streaming"],
+            "pricing": {"input_price_per_1m": 10.0, "output_price_per_1m": 40.0},
+            "recommendation_badges": ["Best for Reasoning"],
+        },
+        "o3-mini": {
+            "display_name": "o3-mini",
+            "family": "o-series",
+            "context_window": 200000,
+            "max_output_tokens": 65536,
+            "reasoning_levels": ["low", "medium", "high"],
+            "capabilities": ["reasoning", "coding", "tools", "streaming", "fast"],
+            "pricing": {"input_price_per_1m": 1.1, "output_price_per_1m": 4.4},
+            "recommendation_badges": ["Best for Coding", "Best for Reasoning"],
+        },
+        "gpt-4o": {
+            "display_name": "GPT-4o",
+            "family": "GPT",
+            "version": "4o",
+            "context_window": 128000,
+            "max_output_tokens": 16384,
+            "capabilities": ["vision", "coding", "tools", "streaming", "audio"],
+            "pricing": {"input_price_per_1m": 2.5, "output_price_per_1m": 10.0},
+        },
+        "gpt-4o-mini": {
+            "display_name": "GPT-4o-mini",
+            "family": "GPT",
+            "version": "4o",
+            "context_window": 128000,
+            "max_output_tokens": 16384,
+            "capabilities": ["vision", "coding", "tools", "streaming", "fast"],
+            "pricing": {"input_price_per_1m": 0.15, "output_price_per_1m": 0.6},
+            "recommendation_badges": ["Best Fast Model"],
+        },
+    }
+
+    def discover_models(self, timeout: float = 8.0) -> List[ModelInfo]:
+        """Query official OpenAI /models API with catalog enrichment."""
+        base = self.get_api_base()
+        key = self.get_api_key()
+        headers = {"Content-Type": "application/json"}
+        if key:
+            headers["Authorization"] = f"Bearer {key}"
+
+        discovered_ids = []
+        try:
+            resp = requests.get(f"{base}/models", headers=headers, timeout=timeout)
+            if resp.status_code == 200:
+                data = resp.json().get("data", [])
+                for item in data:
+                    mid = str(item.get("id", "")).strip()
+                    # Filter out non-chat / internal embedding / TTS endpoints
+                    if mid and not any(mid.startswith(x) for x in ("dall-e", "text-embedding", "tts", "whisper", "babbage", "davinci")):
+                        discovered_ids.append(mid)
+        except Exception:
+            pass
+
+        # Always include our verified catalog specs even if live endpoint temporarily drops or has rate-limits
+        for cat_id in self.CATALOG_MODELS:
+            if cat_id not in discovered_ids:
+                discovered_ids.append(cat_id)
+
+        results = []
+        for mid in discovered_ids:
+            meta = dict(self.CATALOG_MODELS.get(mid, {}))
+            meta["model_id"] = mid
+            meta["endpoint"] = base
+            val = ModelValidator.validate_raw(meta, self.provider_id, self.config)
+            if val.is_valid and val.model_info:
+                results.append(val.model_info)
+
+        return results

calc_terminal/providers/adapters/other_adapters.py

@@ -0,0 +1,246 @@
+"""
+calc_terminal/providers/adapters/other_adapters.py
+==================================================
+Adapters for xAI (Grok), Mistral, Cohere, Meta, and Generic OpenAI-compatible endpoints.
+"""
+
+import requests
+from typing import List, Dict, Any
+
+from .base import BaseProviderAdapter
+from ...models.schema import ModelInfo, AVAILABILITY_PAID_API, AVAILABILITY_OPEN_WEIGHT
+from ...models.validator import ModelValidator
+
+
+class XAIAdapter(BaseProviderAdapter):
+    provider_id = "xai"
+    display_name = "xAI (Grok)"
+    company = "xAI"
+    region = "US"
+    api_base = "https://api.x.ai/v1"
+    authentication_type = "bearer_token"
+    documentation_url = "https://docs.x.ai"
+
+    catalog = {
+        "grok-3": {
+            "display_name": "Grok 3",
+            "family": "Grok",
+            "version": "3",
+            "context_window": 131072,
+            "max_output_tokens": 16384,
+            "capabilities": ["reasoning", "coding", "vision", "tools", "streaming"],
+            "pricing": {"input_price_per_1m": 3.0, "output_price_per_1m": 15.0},
+            "recommendation_badges": ["Best for Reasoning"],
+        },
+        "grok-3-mini": {
+            "display_name": "Grok 3 Mini",
+            "family": "Grok",
+            "version": "3",
+            "context_window": 131072,
+            "max_output_tokens": 16384,
+            "capabilities": ["coding", "tools", "streaming", "fast"],
+            "pricing": {"input_price_per_1m": 0.3, "output_price_per_1m": 1.5},
+            "recommendation_badges": ["Best Fast Model"],
+        },
+        "grok-2": {
+            "display_name": "Grok 2",
+            "family": "Grok",
+            "version": "2",
+            "context_window": 131072,
+            "max_output_tokens": 8192,
+            "capabilities": ["vision", "coding", "tools", "streaming"],
+            "pricing": {"input_price_per_1m": 2.0, "output_price_per_1m": 10.0},
+        },
+    }
+
+    def discover_models(self, timeout: float = 8.0) -> List[ModelInfo]:
+        base = self.get_api_base()
+        key = self.get_api_key()
+        headers = {"Content-Type": "application/json"}
+        if key:
+            headers["Authorization"] = f"Bearer {key}"
+
+        discovered_ids = []
+        try:
+            resp = requests.get(f"{base}/models", headers=headers, timeout=timeout)
+            if resp.status_code == 200:
+                for item in resp.json().get("data", []):
+                    mid = str(item.get("id", "")).strip()
+                    if mid:
+                        discovered_ids.append(mid)
+        except Exception:
+            pass
+
+        for cat_id in self.catalog:
+            if cat_id not in discovered_ids:
+                discovered_ids.append(cat_id)
+
+        results = []
+        for mid in discovered_ids:
+            meta = dict(self.catalog.get(mid, {}))
+            meta["model_id"] = mid
+            meta["endpoint"] = base
+            val = ModelValidator.validate_raw(meta, self.provider_id, self.config)
+            if val.is_valid and val.model_info:
+                results.append(val.model_info)
+        return results
+
+
+class MistralAdapter(BaseProviderAdapter):
+    provider_id = "mistral"
+    display_name = "Mistral AI"
+    company = "Mistral AI"
+    region = "EU"
+    api_base = "https://api.mistral.ai/v1"
+    authentication_type = "bearer_token"
+    documentation_url = "https://docs.mistral.ai/getting-started/models/models_overview/"
+
+    catalog = {
+        "mistral-large-latest": {
+            "display_name": "Mistral Large (Latest)",
+            "family": "Mistral",
+            "context_window": 128000,
+            "max_output_tokens": 8192,
+            "capabilities": ["reasoning", "coding", "tools", "streaming"],
+            "pricing": {"input_price_per_1m": 2.0, "output_price_per_1m": 6.0},
+            "recommendation_badges": ["Best for Coding"],
+        },
+        "codestral-latest": {
+            "display_name": "Codestral (Latest)",
+            "family": "Mistral",
+            "context_window": 256000,
+            "max_output_tokens": 16384,
+            "capabilities": ["coding", "tools", "streaming", "fast"],
+            "pricing": {"input_price_per_1m": 0.3, "output_price_per_1m": 0.9},
+            "recommendation_badges": ["Best for Coding"],
+        },
+        "mistral-small-latest": {
+            "display_name": "Mistral Small (Latest)",
+            "family": "Mistral",
+            "context_window": 128000,
+            "max_output_tokens": 8192,
+            "capabilities": ["chat", "fast", "tools", "streaming"],
+            "pricing": {"input_price_per_1m": 0.1, "output_price_per_1m": 0.3},
+            "recommendation_badges": ["Best Fast Model"],
+        },
+    }
+
+    def discover_models(self, timeout: float = 8.0) -> List[ModelInfo]:
+        base = self.get_api_base()
+        key = self.get_api_key()
+        headers = {"Content-Type": "application/json"}
+        if key:
+            headers["Authorization"] = f"Bearer {key}"
+
+        discovered_ids = []
+        try:
+            resp = requests.get(f"{base}/models", headers=headers, timeout=timeout)
+            if resp.status_code == 200:
+                for item in resp.json().get("data", []):
+                    mid = str(item.get("id", "")).strip()
+                    if mid:
+                        discovered_ids.append(mid)
+        except Exception:
+            pass
+
+        for cat_id in self.catalog:
+            if cat_id not in discovered_ids:
+                discovered_ids.append(cat_id)
+
+        results = []
+        for mid in discovered_ids:
+            meta = dict(self.catalog.get(mid, {}))
+            meta["model_id"] = mid
+            meta["endpoint"] = base
+            val = ModelValidator.validate_raw(meta, self.provider_id, self.config)
+            if val.is_valid and val.model_info:
+                results.append(val.model_info)
+        return results
+
+
+class CohereAdapter(BaseProviderAdapter):
+    provider_id = "cohere"
+    display_name = "Cohere"
+    company = "Cohere"
+    region = "CA"
+    api_base = "https://api.cohere.com/v2"
+    authentication_type = "bearer_token"
+    documentation_url = "https://docs.cohere.com/v2/docs/models"
+
+    catalog = {
+        "command-r-plus": {
+            "display_name": "Command R+",
+            "family": "Command",
+            "context_window": 128000,
+            "max_output_tokens": 4096,
+            "capabilities": ["reasoning", "coding", "tools", "streaming"],
+            "pricing": {"input_price_per_1m": 2.5, "output_price_per_1m": 10.0},
+        },
+        "command-r": {
+            "display_name": "Command R",
+            "family": "Command",
+            "context_window": 128000,
+            "max_output_tokens": 4096,
+            "capabilities": ["coding", "tools", "streaming", "fast"],
+            "pricing": {"input_price_per_1m": 0.5, "output_price_per_1m": 1.5},
+            "recommendation_badges": ["Best Fast Model"],
+        },
+    }
+
+    def discover_models(self, timeout: float = 8.0) -> List[ModelInfo]:
+        base = self.get_api_base()
+        key = self.get_api_key()
+        headers = {"Content-Type": "application/json"}
+        if key:
+            headers["Authorization"] = f"Bearer {key}"
+
+        discovered_ids = []
+        try:
+            resp = requests.get(f"{base}/models", headers=headers, timeout=timeout)
+            if resp.status_code == 200:
+                for item in resp.json().get("models", []):
+                    mid = str(item.get("name", "")).strip()
+                    if mid:
+                        discovered_ids.append(mid)
+        except Exception:
+            pass
+
+        for cat_id in self.catalog:
+            if cat_id not in discovered_ids:
+                discovered_ids.append(cat_id)
+
+        results = []
+        for mid in discovered_ids:
+            meta = dict(self.catalog.get(mid, {}))
+            meta["model_id"] = mid
+            meta["endpoint"] = base
+            val = ModelValidator.validate_raw(meta, self.provider_id, self.config)
+            if val.is_valid and val.model_info:
+                results.append(val.model_info)
+        return results
+
+
+class GenericOpenAIAdapter(BaseProviderAdapter):
+    """Fallback adapter for any OpenAI-compatible provider."""
+
+    def discover_models(self, timeout: float = 8.0) -> List[ModelInfo]:
+        base = self.get_api_base()
+        key = self.get_api_key()
+        headers = {"Content-Type": "application/json"}
+        if key:
+            headers["Authorization"] = f"Bearer {key}"
+
+        discovered = []
+        try:
+            resp = requests.get(f"{base}/models", headers=headers, timeout=timeout)
+            if resp.status_code == 200:
+                for item in resp.json().get("data", []):
+                    mid = str(item.get("id", "")).strip()
+                    if mid:
+                        meta = {"model_id": mid, "endpoint": base}
+                        val = ModelValidator.validate_raw(meta, self.provider_id, self.config)
+                        if val.is_valid and val.model_info:
+                            discovered.append(val.model_info)
+        except Exception:
+            pass
+        return discovered