skill-cert 0.5.4__py3-none-any.whl

adapters/anthropic_compat.py

@@ -0,0 +1,129 @@
+import json
+import time
+from typing import Any
+
+import requests
+
+from .base import ModelAdapter
+
+
+class AnthropicCompatAdapter(ModelAdapter):
+    SUPPORTED_MODELS = [
+        "qwen3.6-plus",
+        "qwen3.5-plus",
+        "qwen3-max-2026-01-23",
+        "qwen3-coder-next",
+        "qwen3-coder-plus",
+        "glm-5",
+        "glm-4.7",
+        "kimi-k2.5",
+        "MiniMax-M2.5",
+    ]
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str,
+        model: str,
+        fallback_model: str | None = None,
+        rpm_limit: int = 60,
+    ):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.model = model
+        self.fallback_model = fallback_model
+        self.session = requests.Session()
+        self.session.headers.update(
+            {
+                "x-api-key": api_key,
+                "Content-Type": "application/json",
+                "anthropic-version": "2023-06-01",
+            }
+        )
+
+    def chat(
+        self,
+        messages: list[dict[str, str]],
+        system: str | None = None,
+        timeout: int = 120,
+    ) -> str:
+        formatted = [
+            {"role": "user" if m["role"] == "user" else "assistant", "content": m["content"]}
+            for m in messages
+            if m["role"] in ("user", "assistant")
+        ]
+        payload = {"model": self.model, "max_tokens": 8192, "messages": formatted}
+        if system:
+            payload["system"] = system
+        return self._request(payload)
+
+    def chat_with_usage(
+        self,
+        messages: list[dict[str, str]],
+        system: str | None = None,
+        timeout: int = 120,
+    ) -> tuple[str, dict[str, int]]:
+        formatted = [
+            {"role": "user" if m["role"] == "user" else "assistant", "content": m["content"]}
+            for m in messages
+            if m["role"] in ("user", "assistant")
+        ]
+        payload = {"model": self.model, "max_tokens": 8192, "messages": formatted}
+        if system:
+            payload["system"] = system
+        return self._request_with_usage(payload)
+
+    def batch_chat(
+        self,
+        requests: list[dict[str, Any]],
+        max_concurrency: int = 5,
+    ) -> list[str]:
+        results = []
+        for req in requests:
+            try:
+                results.append(self.chat(req.get("messages", []), req.get("system")))
+            except Exception as e:
+                results.append(f"ERROR: {e}")
+        return results
+
+    def _request(
+        self,
+        payload: dict[str, Any],
+        max_retries: int = 3,
+    ) -> str:
+        content, _ = self._request_with_usage(payload, max_retries)
+        return content
+
+    def _request_with_usage(
+        self,
+        payload: dict[str, Any],
+        max_retries: int = 3,
+    ) -> tuple[str, dict[str, int]]:
+        for attempt in range(max_retries):
+            try:
+                resp = self.session.post(
+                    f"{self.base_url}/messages",
+                    json=payload,
+                    timeout=120,
+                )
+                resp.raise_for_status()
+                data = resp.json()
+                content = ""
+                for block in data.get("content", []):
+                    if block.get("type") == "text":
+                        content = block["text"]
+                        break
+                if not content:
+                    content = json.dumps(data)
+                usage = data.get("usage", {})
+                token_data = {
+                    "prompt_tokens": usage.get("input_tokens", 0),
+                    "completion_tokens": usage.get("output_tokens", 0),
+                    "total_tokens": usage.get("input_tokens", 0) + usage.get("output_tokens", 0),
+                }
+                return content, token_data
+            except Exception:
+                if attempt == max_retries - 1:
+                    raise
+                time.sleep(2**attempt)
+        raise RuntimeError("Request failed after retries")

adapters/base.py

@@ -0,0 +1,106 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class TokenUsage:
+    input_tokens: int = 0
+    output_tokens: int = 0
+    total_tokens: int = 0
+
+    def to_dict(self) -> dict[str, int]:
+        return {
+            "input_tokens": self.input_tokens,
+            "output_tokens": self.output_tokens,
+            "total_tokens": self.total_tokens,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, int]) -> "TokenUsage":
+        return cls(
+            input_tokens=data.get("input_tokens", 0),
+            output_tokens=data.get("output_tokens", 0),
+            total_tokens=data.get("total_tokens", 0),
+        )
+
+
+@dataclass
+class LLMResponse:
+    text: str
+    token_usage: TokenUsage | None = None
+    latency_ms: float = 0.0
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "text": self.text,
+            "token_usage": self.token_usage.to_dict() if self.token_usage else None,
+            "latency_ms": self.latency_ms,
+        }
+
+
+class ModelAdapter(ABC):
+    """
+    Abstract base class for model adapters.
+    Defines the interface for interacting with different LLM providers.
+    """
+
+    @abstractmethod
+    def chat(
+        self,
+        messages: list[dict[str, str]],
+        system: str | None = None,
+        timeout: int = 120,
+    ) -> str:
+        """
+        Send a chat request to the model.
+
+        Args:
+            messages: List of message dictionaries with 'role' and 'content'
+            system: Optional system message
+            timeout: Request timeout in seconds
+
+        Returns:
+            Model response as a string
+        """
+        pass
+
+    def chat_with_usage(
+        self,
+        messages: list[dict[str, str]],
+        system: str | None = None,
+        timeout: int = 120,
+    ) -> tuple[str, dict[str, int]]:
+        """
+        Send a chat request and return both content and token usage.
+        Default fallback: uses chat() and estimates usage.
+        Override in subclasses for real token counts.
+
+        Returns:
+            Tuple of (response_text, {
+                "prompt_tokens": N,
+                "completion_tokens": N,
+                "total_tokens": N,
+            })
+        """
+        content = self.chat(messages, system, timeout)
+        estimated = len(content.split()) if content else 0
+        return content, {
+            "prompt_tokens": 0,
+            "completion_tokens": estimated,
+            "total_tokens": estimated,
+        }
+
+    @abstractmethod
+    def batch_chat(self, requests: list[dict[str, Any]], max_concurrency: int = 5) -> list[str]:
+        """
+        Send multiple chat requests concurrently.
+
+        Args:
+            requests: List of request dictionaries containing messages, system, timeout
+            max_concurrency: Maximum number of concurrent requests
+
+        Returns:
+            List of model responses in the same order as requests
+        """
+        pass

adapters/factory.py

@@ -0,0 +1,65 @@
+"""Factory for creating model adapters by auto-detecting the correct type from model name."""
+
+import logging
+
+from engine.config import ModelConfig
+
+from .anthropic_compat import AnthropicCompatAdapter
+from .base import ModelAdapter
+from .openai_compat import OpenAICompatAdapter
+
+logger = logging.getLogger(__name__)
+
+
+def _is_known_provider(model_name: str) -> bool:
+    """Check if a model name matches a known provider pattern (case-insensitive)."""
+    return any(kw in model_name for kw in ("claude", "qwen", "deepseek"))
+
+
+def create_adapter(model_config: ModelConfig, rpm_limit: int = 60) -> ModelAdapter:
+    """Create a model adapter by auto-detecting the correct type from the model name.
+
+    Auto-detection rules (checked case-insensitively):
+      - "claude" in model_name → AnthropicCompatAdapter
+      - "qwen" in model_name   → OpenAICompatAdapter (Qwen uses OpenAI-compat API)
+      - "deepseek" in model_name → OpenAICompatAdapter
+      - Any other name          → OpenAICompatAdapter (default, with warning logged)
+
+    Args:
+        model_config: ModelConfig with base_url, api_key, model_name, and optional fallback fields.
+        rpm_limit: Rate limit in requests per minute (default: 60).
+
+    Returns:
+        An initialized ModelAdapter instance.
+    """
+    model_name = model_config.model_name.lower()
+
+    if "claude" in model_name:
+        logger.info("Detected Anthropic-compatible model: %s", model_config.model_name)
+        return AnthropicCompatAdapter(
+            base_url=model_config.base_url,
+            api_key=model_config.api_key,
+            model=model_config.model_name,
+            fallback_model=model_config.fallback_model,
+            rpm_limit=rpm_limit,
+        )
+
+    if "qwen" in model_name:
+        logger.info("Detected Qwen model (OpenAI-compatible): %s", model_config.model_name)
+    elif "deepseek" in model_name:
+        logger.info("Detected DeepSeek model (OpenAI-compatible): %s", model_config.model_name)
+    else:
+        logger.warning(
+            "Unknown model name '%s', falling back to OpenAICompatAdapter",
+            model_config.model_name,
+        )
+
+    return OpenAICompatAdapter(
+        base_url=model_config.base_url,
+        api_key=model_config.api_key,
+        model=model_config.provider_model or model_config.fallback_model or model_config.model_name,
+        fallback_model=model_config.fallback_model,
+        fallback_base_url=model_config.fallback_base_url,
+        fallback_api_key=model_config.fallback_api_key,
+        rpm_limit=rpm_limit,
+    )

adapters/openai_compat.py

@@ -0,0 +1,200 @@
+import logging
+from typing import Any
+
+import httpx
+
+from .base import ModelAdapter
+
+logger = logging.getLogger(__name__)
+
+
+class OpenAICompatAdapter(ModelAdapter):
+    """Adapter for OpenAI-compatible APIs — uses sync httpx.Client for thread safety.
+    Supports fallback to a different endpoint when primary is unreachable."""
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str,
+        model: str,
+        fallback_model: str | None = None,
+        fallback_base_url: str | None = None,
+        fallback_api_key: str | None = None,
+        rpm_limit: int = 60,
+    ):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.model = model
+        self.fallback_model = fallback_model
+        self.fallback_base_url = fallback_base_url.rstrip("/") if fallback_base_url else None
+        self.fallback_api_key = fallback_api_key
+        self._has_fallback = bool(
+            self.fallback_model and self.fallback_base_url and self.fallback_api_key
+        )
+        # Force HTTP/1.1 to avoid HTTP/2 negotiation issues with some proxies
+        self.client = httpx.Client(
+            timeout=httpx.Timeout(120.0),
+            http1=True,
+            http2=False,
+        )
+
+    @staticmethod
+    def _extract_error_detail(response: httpx.Response) -> str:
+        """Extract error detail from API response body, if available."""
+        try:
+            body = response.json()
+            msg = body.get("error", {}).get("message", "") or body.get("message", "")
+            if msg:
+                return msg[:200]
+        except Exception:
+            pass
+        return response.text[:200] if response.text else "No detail provided"
+
+    def _call_with_usage(
+        self,
+        messages: list[dict[str, str]],
+        model: str,
+        timeout: int,
+        base_url: str | None = None,
+        api_key: str | None = None,
+        use_requests_fallback: bool = False,
+    ) -> tuple[str, dict[str, int]]:
+        use_base = base_url or self.base_url
+        use_key = api_key or self.api_key
+
+        headers = {"Authorization": f"Bearer {use_key}", "Content-Type": "application/json"}
+
+        payload = {"model": model, "messages": messages, "temperature": 0.0}
+
+        try:
+            response = self.client.post(
+                f"{use_base}/chat/completions", headers=headers, json=payload, timeout=timeout
+            )
+        except httpx.ConnectError as e:
+            # Fallback to requests when httpx SSL fails (corporate proxy compatibility)
+            if not use_requests_fallback:
+                logger.warning(f"httpx SSL failed, falling back to requests: {e}")
+                import requests as _requests
+
+                response = _requests.post(  # type: ignore[assignment]
+                    f"{use_base}/chat/completions", headers=headers, json=payload, timeout=timeout
+                )
+                if response.status_code == 401:
+                    raise RuntimeError("Invalid API key")
+                elif response.status_code == 404:
+                    raise RuntimeError("Model not found")
+                elif response.status_code == 429:
+                    raise RuntimeError("Insufficient quota")
+                else:
+                    response.raise_for_status()
+
+                result = response.json()
+                content = result["choices"][0]["message"]["content"]
+                usage = result.get("usage", {})
+                token_data = {
+                    "prompt_tokens": usage.get("prompt_tokens", 0),
+                    "completion_tokens": usage.get("completion_tokens", 0),
+                    "total_tokens": usage.get("total_tokens", 0),
+                }
+                return content, token_data
+            raise
+
+        if response.status_code == 401:
+            raise RuntimeError("Invalid API key")
+        elif response.status_code == 400:
+            detail = self._extract_error_detail(response)
+            raise RuntimeError(
+                f"API returned 400 for model '{model}'. "
+                f"Verify the model name matches the API endpoint's expected format. "
+                f"Detail: {detail}"
+            )
+        elif response.status_code == 404:
+            raise RuntimeError("Model not found")
+        elif response.status_code == 429:
+            raise RuntimeError("Insufficient quota")
+        else:
+            response.raise_for_status()
+
+        result = response.json()
+        content = result["choices"][0]["message"]["content"]
+        usage = result.get("usage", {})
+        token_data = {
+            "prompt_tokens": usage.get("prompt_tokens", 0),
+            "completion_tokens": usage.get("completion_tokens", 0),
+            "total_tokens": usage.get("total_tokens", 0),
+        }
+        return content, token_data
+
+    def _call_with_usage_sync(
+        self, messages: list[dict[str, str]], system: str | None = None, timeout: int = 120
+    ) -> tuple[str, dict[str, int]]:
+        prepared_messages = []
+        if system:
+            prepared_messages.append({"role": "system", "content": system})
+        prepared_messages.extend(messages)
+
+        return self._call_with_usage_with_fallback(prepared_messages, self.model, timeout)
+
+    def _call_with_usage_with_fallback(
+        self, messages: list[dict[str, str]], model: str, timeout: int
+    ) -> tuple[str, dict[str, int]]:
+        try:
+            return self._call_with_usage(messages, model, timeout, use_requests_fallback=True)
+        except (httpx.ConnectError, httpx.ConnectTimeout, OSError) as e:
+            if self._has_fallback:
+                logger.warning(
+                    f"Primary endpoint unreachable ({self.base_url}, {self.model}), "
+                    f"falling back to {self.fallback_base_url}/{self.fallback_model}: {e}"
+                )
+                return self._call_with_usage(
+                    messages,
+                    self.fallback_model or model,
+                    timeout,
+                    base_url=self.fallback_base_url,
+                    api_key=self.fallback_api_key,
+                    use_requests_fallback=True,
+                )
+            raise
+
+    def chat(
+        self,
+        messages: list[dict[str, str]],
+        system: str | None = None,
+        timeout: int = 120,
+    ) -> str:
+        content, _ = self._call_with_usage_sync(messages, system, timeout)
+        return content
+
+    def chat_with_usage(
+        self,
+        messages: list[dict[str, str]],
+        system: str | None = None,
+        timeout: int = 120,
+    ) -> tuple[str, dict[str, int]]:
+        return self._call_with_usage_sync(messages, system, timeout)
+
+    def batch_chat(self, requests: list[dict[str, Any]], max_concurrency: int = 5) -> list[str]:
+        from concurrent.futures import ThreadPoolExecutor, as_completed
+
+        results: list[str] = []
+        with ThreadPoolExecutor(max_workers=max_concurrency) as executor:
+            futures = {
+                executor.submit(
+                    self.chat,
+                    req.get("messages", []),
+                    req.get("system"),
+                    req.get("timeout", 120),
+                ): i
+                for i, req in enumerate(requests)
+            }
+            result_map: dict[int, str] = {}
+            for future in as_completed(futures):
+                result_map[futures[future]] = future.result()
+            results = [result_map[i] for i in range(len(requests))]
+        return results
+
+    def __del__(self):
+        try:
+            self.client.close()
+        except Exception:
+            pass

adapters/pricing.py

@@ -0,0 +1,73 @@
+"""Model pricing table — converts token usage to $ cost."""
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+_MODEL_PRICING = {
+    # Anthropic Claude family (per 1M tokens)
+    "claude-sonnet-4-5-20250514": {"input_per_m": 3.0, "output_per_m": 15.0},
+    "claude-sonnet-4-20250514": {"input_per_m": 3.0, "output_per_m": 15.0},
+    "claude-opus-4-20250514": {"input_per_m": 15.0, "output_per_m": 75.0},
+    "claude-opus-4-1-20250805": {"input_per_m": 15.0, "output_per_m": 75.0},
+    "claude-haiku-4-20250514": {"input_per_m": 0.8, "output_per_m": 4.0},
+    # OpenAI GPT family
+    "gpt-5": {"input_per_m": 1.25, "output_per_m": 10.0},
+    "gpt-5-mini": {"input_per_m": 0.25, "output_per_m": 2.0},
+    "gpt-4o": {"input_per_m": 2.5, "output_per_m": 10.0},
+    "gpt-4o-mini": {"input_per_m": 0.15, "output_per_m": 0.6},
+    # Qwen family
+    "qwen3.6-plus": {"input_per_m": 0.3, "output_per_m": 0.9},
+    "qwen3.5-plus": {"input_per_m": 0.3, "output_per_m": 0.9},
+    "qwen3-coder-plus": {"input_per_m": 0.3, "output_per_m": 0.9},
+    "qwen3-coder-next": {"input_per_m": 0.4, "output_per_m": 1.2},
+    # DeepSeek
+    "deepseek-chat": {"input_per_m": 0.14, "output_per_m": 0.56},
+    "deepseek-reasoner": {"input_per_m": 0.55, "output_per_m": 2.19},
+    # Google Gemini
+    "gemini-2.5-pro": {"input_per_m": 1.25, "output_per_m": 10.0},
+    "gemini-2.5-flash": {"input_per_m": 0.15, "output_per_m": 0.6},
+    # Whalecloud LOCAL (free — local deployment)
+    "LOCAL/Qwen3.5-122B-A10B": {"input_per_m": 0.0, "output_per_m": 0.0},
+    "LOCAL/MiniMax-M2.7": {"input_per_m": 0.0, "output_per_m": 0.0},
+}
+
+
+class ModelPricing:
+    def __init__(self):
+        self.models: dict[str, dict[str, float]] = dict(_MODEL_PRICING)
+
+    def get_model_price(self, model_name: str) -> dict[str, float] | None:
+        price = self.models.get(model_name)
+        if price is not None:
+            return price
+        for known_name, known_price in self.models.items():
+            if model_name.startswith(known_name):
+                logger.warning(
+                    "Model '%s' not in pricing table, falling back to prefix match '%s'",
+                    model_name,
+                    known_name,
+                )
+                return known_price
+        return None
+
+    def add_model(self, model_name: str, input_per_m: float, output_per_m: float):
+        self.models[model_name] = {"input_per_m": input_per_m, "output_per_m": output_per_m}
+
+    def calculate_cost(self, prompt_tokens: int, completion_tokens: int, model_name: str) -> float:
+        price = self.get_model_price(model_name)
+        if price is None:
+            return 0.0
+        return (prompt_tokens / 1_000_000) * price["input_per_m"] + (
+            completion_tokens / 1_000_000
+        ) * price["output_per_m"]
+
+
+_pricing_instance: ModelPricing | None = None
+
+
+def get_pricing() -> ModelPricing:
+    global _pricing_instance
+    if _pricing_instance is None:
+        _pricing_instance = ModelPricing()
+    return _pricing_instance

engine/__init__.py

@@ -0,0 +1,4 @@
+from engine.analyzer import parse_skill_md
+from engine.deadline import Deadline, PhaseTimer
+
+__all__ = ["Deadline", "PhaseTimer", "parse_skill_md"]