devcopilot 0.2.0__py3-none-any.whl

providers/gemini/request.py

@@ -0,0 +1,199 @@
+"""Request builder for Google Gemini API (AI Studio OpenAI-compatible chat completions)."""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import Any, cast
+
+from loguru import logger
+
+from core.anthropic import ReasoningReplayMode, build_base_request_body
+from core.anthropic.conversion import OpenAIConversionError
+from providers.exceptions import InvalidRequestError
+
+GEMINI_SKIP_THOUGHT_SIGNATURE_VALIDATOR = "skip_thought_signature_validator"
+
+
+def _ensure_dict(container: dict[str, Any], key: str) -> dict[str, Any]:
+    value = container.get(key)
+    if isinstance(value, dict):
+        return cast(dict[str, Any], value)
+    nested: dict[str, Any] = {}
+    container[key] = nested
+    return nested
+
+
+def _apply_thinking_config(extra_body: dict[str, Any]) -> None:
+    # OpenAI's SDK merges its ``extra_body`` argument into the request JSON.
+    # Google expects its extension fields under a literal JSON ``extra_body`` key.
+    literal_extra_body = _ensure_dict(extra_body, "extra_body")
+    google_section = _ensure_dict(literal_extra_body, "google")
+    thinking_cfg = _ensure_dict(google_section, "thinking_config")
+    thinking_cfg.setdefault("include_thoughts", True)
+
+
+def _is_gemini_3_model(model: Any) -> bool:
+    return "gemini-3" in str(model).lower()
+
+
+def _thought_signature_from_extra_content(extra_content: Any) -> str | None:
+    if not isinstance(extra_content, dict):
+        return None
+    google = extra_content.get("google")
+    if not isinstance(google, dict):
+        return None
+    signature = google.get("thought_signature")
+    return signature if isinstance(signature, str) and signature else None
+
+
+def _tool_call_thought_signature(tool_call: dict[str, Any]) -> str | None:
+    return _thought_signature_from_extra_content(tool_call.get("extra_content"))
+
+
+def _set_tool_call_thought_signature(tool_call: dict[str, Any], signature: str) -> None:
+    extra_content = tool_call.get("extra_content")
+    if not isinstance(extra_content, dict):
+        extra_content = {}
+        tool_call["extra_content"] = extra_content
+    google = extra_content.get("google")
+    if not isinstance(google, dict):
+        google = {}
+        extra_content["google"] = google
+    google["thought_signature"] = signature
+
+
+def _message_has_standard_user_content(message: dict[str, Any]) -> bool:
+    if message.get("role") != "user":
+        return False
+    content = message.get("content")
+    if isinstance(content, str):
+        return bool(content.strip())
+    if isinstance(content, list):
+        return any(
+            isinstance(part, dict)
+            and isinstance(part.get("text"), str)
+            and bool(part["text"].strip())
+            for part in content
+        )
+    return False
+
+
+def _current_turn_start_index(messages: list[Any]) -> int:
+    for index in range(len(messages) - 1, -1, -1):
+        message = messages[index]
+        if isinstance(message, dict) and _message_has_standard_user_content(message):
+            return index
+    return -1
+
+
+def _apply_cached_tool_call_signatures(
+    messages: list[Any], tool_call_extra_content_by_id: dict[str, dict[str, Any]]
+) -> None:
+    if not tool_call_extra_content_by_id:
+        return
+    for message in messages:
+        if not isinstance(message, dict) or message.get("role") != "assistant":
+            continue
+        tool_calls = message.get("tool_calls")
+        if not isinstance(tool_calls, list):
+            continue
+        for tool_call in tool_calls:
+            if not isinstance(tool_call, dict) or _tool_call_thought_signature(
+                tool_call
+            ):
+                continue
+            tool_call_id = tool_call.get("id")
+            if tool_call_id is None:
+                continue
+            cached_extra_content = tool_call_extra_content_by_id.get(str(tool_call_id))
+            if not cached_extra_content:
+                continue
+            cached_signature = _thought_signature_from_extra_content(
+                cached_extra_content
+            )
+            if cached_signature:
+                tool_call["extra_content"] = deepcopy(cached_extra_content)
+
+
+def _apply_gemini_3_missing_current_turn_signatures(
+    body: dict[str, Any], messages: list[Any]
+) -> None:
+    if not _is_gemini_3_model(body.get("model")):
+        return
+
+    start_index = _current_turn_start_index(messages)
+    for message in messages[start_index + 1 :]:
+        if not isinstance(message, dict) or message.get("role") != "assistant":
+            continue
+        tool_calls = message.get("tool_calls")
+        if not isinstance(tool_calls, list) or not tool_calls:
+            continue
+        first_tool_call = tool_calls[0]
+        if not isinstance(first_tool_call, dict):
+            continue
+        if _tool_call_thought_signature(first_tool_call):
+            continue
+        _set_tool_call_thought_signature(
+            first_tool_call, GEMINI_SKIP_THOUGHT_SIGNATURE_VALIDATOR
+        )
+
+
+def _apply_gemini_tool_call_signatures(
+    body: dict[str, Any],
+    *,
+    tool_call_extra_content_by_id: dict[str, dict[str, Any]] | None,
+) -> None:
+    messages = body.get("messages")
+    if not isinstance(messages, list):
+        return
+    _apply_cached_tool_call_signatures(messages, tool_call_extra_content_by_id or {})
+    _apply_gemini_3_missing_current_turn_signatures(body, messages)
+
+
+def build_request_body(
+    request_data: Any,
+    *,
+    thinking_enabled: bool,
+    tool_call_extra_content_by_id: dict[str, dict[str, Any]] | None = None,
+) -> dict:
+    """Build OpenAI-format request body from an Anthropic request for Gemini."""
+    logger.debug(
+        "GEMINI_REQUEST: conversion start model={} msgs={}",
+        getattr(request_data, "model", "?"),
+        len(getattr(request_data, "messages", [])),
+    )
+    try:
+        body = build_base_request_body(
+            request_data,
+            reasoning_replay=ReasoningReplayMode.REASONING_CONTENT
+            if thinking_enabled
+            else ReasoningReplayMode.DISABLED,
+        )
+    except OpenAIConversionError as exc:
+        raise InvalidRequestError(str(exc)) from exc
+
+    extra_body: dict[str, Any] = {}
+    request_extra = getattr(request_data, "extra_body", None)
+    if isinstance(request_extra, dict):
+        extra_body.update(deepcopy(request_extra))
+
+    if thinking_enabled:
+        _apply_thinking_config(extra_body)
+    else:
+        body["reasoning_effort"] = "none"
+
+    if extra_body:
+        body["extra_body"] = extra_body
+
+    _apply_gemini_tool_call_signatures(
+        body,
+        tool_call_extra_content_by_id=tool_call_extra_content_by_id,
+    )
+
+    logger.debug(
+        "GEMINI_REQUEST: conversion done model={} msgs={} tools={}",
+        body.get("model"),
+        len(body.get("messages", [])),
+        len(body.get("tools", [])),
+    )
+    return body

providers/groq/__init__.py

@@ -0,0 +1,7 @@
+"""Groq Cloud (OpenAI-compat) adapter."""
+
+from providers.defaults import GROQ_DEFAULT_BASE
+
+from .client import GroqProvider
+
+__all__ = ["GROQ_DEFAULT_BASE", "GroqProvider"]

providers/groq/client.py

@@ -0,0 +1,31 @@
+"""Groq provider implementation (OpenAI-compatible chat completions)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from providers.base import ProviderConfig
+from providers.defaults import GROQ_DEFAULT_BASE
+from providers.transports.openai_chat import OpenAIChatTransport
+
+from .request import build_request_body
+
+
+class GroqProvider(OpenAIChatTransport):
+    """Groq API using ``https://api.groq.com/openai/v1/chat/completions``."""
+
+    def __init__(self, config: ProviderConfig):
+        super().__init__(
+            config,
+            provider_name="GROQ",
+            base_url=config.base_url or GROQ_DEFAULT_BASE,
+            api_key=config.api_key,
+        )
+
+    def _build_request_body(
+        self, request: Any, thinking_enabled: bool | None = None
+    ) -> dict:
+        return build_request_body(
+            request,
+            thinking_enabled=self._is_thinking_enabled(request, thinking_enabled),
+        )

providers/groq/request.py

@@ -0,0 +1,83 @@
+"""Request builder for Groq (OpenAI-compatible chat completions).
+
+See Groq docs: https://console.groq.com/docs/openai — ``messages[].name`` and
+unsupported token fields yield 400; ``max_completion_tokens`` is preferred over
+deprecated ``max_tokens``.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from loguru import logger
+
+from core.anthropic import ReasoningReplayMode, build_base_request_body
+from core.anthropic.conversion import OpenAIConversionError
+from providers.exceptions import InvalidRequestError
+
+_GROQ_UNSUPPORTED_TOP_KEYS = frozenset({"logprobs", "logit_bias", "top_logprobs"})
+
+
+def _strip_message_names(messages: Any) -> None:
+    """Remove ``name`` from each chat message (Groq rejects ``messages[].name``)."""
+    if not isinstance(messages, list):
+        return
+    for msg in messages:
+        if isinstance(msg, dict):
+            msg.pop("name", None)
+
+
+def _strip_unsupported_body_keys(body: dict[str, Any]) -> None:
+    for key in _GROQ_UNSUPPORTED_TOP_KEYS:
+        body.pop(key, None)
+
+
+def _normalize_max_completion_tokens(body: dict[str, Any]) -> None:
+    if "max_completion_tokens" in body:
+        body.pop("max_tokens", None)
+        return
+    if "max_tokens" in body and body["max_tokens"] is not None:
+        body["max_completion_tokens"] = body.pop("max_tokens")
+
+
+def _normalize_n_candidates(body: dict[str, Any]) -> None:
+    """Groq only supports ``n`` = 1; coerce if present."""
+    if body.get("n") is None:
+        return
+    body["n"] = 1
+
+
+def build_request_body(request_data: Any, *, thinking_enabled: bool) -> dict:
+    """Build OpenAI-format request body from an Anthropic request for Groq."""
+    logger.debug(
+        "GROQ_REQUEST: conversion start model={} msgs={}",
+        getattr(request_data, "model", "?"),
+        len(getattr(request_data, "messages", [])),
+    )
+    try:
+        body = build_base_request_body(
+            request_data,
+            reasoning_replay=ReasoningReplayMode.REASONING_CONTENT
+            if thinking_enabled
+            else ReasoningReplayMode.DISABLED,
+        )
+    except OpenAIConversionError as exc:
+        raise InvalidRequestError(str(exc)) from exc
+
+    request_extra = getattr(request_data, "extra_body", None)
+    if isinstance(request_extra, dict) and request_extra:
+        merged = dict(request_extra)
+        body["extra_body"] = merged
+
+    _strip_message_names(body.get("messages"))
+    _strip_unsupported_body_keys(body)
+    _normalize_max_completion_tokens(body)
+    _normalize_n_candidates(body)
+
+    logger.debug(
+        "GROQ_REQUEST: conversion done model={} msgs={} tools={}",
+        body.get("model"),
+        len(body.get("messages", [])),
+        len(body.get("tools", [])),
+    )
+    return body

providers/kimi/__init__.py

@@ -0,0 +1,10 @@
+"""Kimi (Moonshot) provider exports."""
+
+from providers.defaults import KIMI_DEFAULT_BASE
+
+from .client import KimiProvider
+
+__all__ = [
+    "KIMI_DEFAULT_BASE",
+    "KimiProvider",
+]

providers/kimi/client.py

@@ -0,0 +1,53 @@
+"""Kimi (Moonshot) provider using native Anthropic-compatible Messages."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from providers.base import ProviderConfig
+from providers.defaults import KIMI_DEFAULT_BASE
+from providers.transports.anthropic_messages import AnthropicMessagesTransport
+
+from .request import build_request_body
+
+_MOONSHOT_OPENAI_MODELS_URL = "https://api.moonshot.ai/v1/models"
+_ANTHROPIC_VERSION = "2023-06-01"
+
+
+class KimiProvider(AnthropicMessagesTransport):
+    """Kimi provider using Anthropic-compatible Messages at api.moonshot.ai/anthropic/v1."""
+
+    def __init__(self, config: ProviderConfig):
+        super().__init__(
+            config,
+            provider_name="KIMI",
+            default_base_url=KIMI_DEFAULT_BASE,
+        )
+
+    def _build_request_body(
+        self, request: Any, thinking_enabled: bool | None = None
+    ) -> dict:
+        return build_request_body(
+            request,
+            thinking_enabled=self._is_thinking_enabled(request, thinking_enabled),
+        )
+
+    def _request_headers(self) -> dict[str, str]:
+        return {
+            "Accept": "text/event-stream",
+            "Authorization": f"Bearer {self._api_key}",
+            "Content-Type": "application/json",
+            "anthropic-version": _ANTHROPIC_VERSION,
+        }
+
+    async def _send_model_list_request(self) -> httpx.Response:
+        """Models are listed from the OpenAI-compat root, not ``/anthropic/v1``."""
+        return await self._client.get(
+            _MOONSHOT_OPENAI_MODELS_URL,
+            headers=self._model_list_headers(),
+        )
+
+    def _model_list_headers(self) -> dict[str, str]:
+        return {"Authorization": f"Bearer {self._api_key}"}

providers/kimi/request.py

@@ -0,0 +1,42 @@
+"""Native Anthropic Messages request builder for Kimi (Moonshot)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from loguru import logger
+
+from config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
+from core.anthropic.native_messages_request import (
+    build_base_native_anthropic_request_body,
+)
+from providers.exceptions import InvalidRequestError
+
+
+def build_request_body(request_data: Any, *, thinking_enabled: bool) -> dict:
+    """Build JSON for Kimi Anthropic-compat ``POST …/messages``."""
+    logger.debug(
+        "KIMI_REQUEST: native build model={} msgs={}",
+        getattr(request_data, "model", "?"),
+        len(getattr(request_data, "messages", [])),
+    )
+
+    body = build_base_native_anthropic_request_body(
+        request_data,
+        default_max_tokens=ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS,
+        thinking_enabled=thinking_enabled,
+    )
+    extra = getattr(request_data, "extra_body", None)
+    if extra:
+        raise InvalidRequestError(
+            "Kimi native Messages API does not support extra_body on requests."
+        )
+    body["stream"] = True
+
+    logger.debug(
+        "KIMI_REQUEST: build done model={} msgs={} tools={}",
+        body.get("model"),
+        len(body.get("messages", [])),
+        len(body.get("tools", [])),
+    )
+    return body

providers/llamacpp/__init__.py

@@ -0,0 +1,3 @@
+from .client import LlamaCppProvider
+
+__all__ = ["LlamaCppProvider"]

providers/llamacpp/client.py

@@ -0,0 +1,16 @@
+"""Llama.cpp provider implementation."""
+
+from providers.base import ProviderConfig
+from providers.defaults import LLAMACPP_DEFAULT_BASE
+from providers.transports.anthropic_messages import AnthropicMessagesTransport
+
+
+class LlamaCppProvider(AnthropicMessagesTransport):
+    """Llama.cpp provider using native Anthropic Messages endpoint."""
+
+    def __init__(self, config: ProviderConfig):
+        super().__init__(
+            config,
+            provider_name="LLAMACPP",
+            default_base_url=LLAMACPP_DEFAULT_BASE,
+        )

providers/lmstudio/__init__.py

@@ -0,0 +1,5 @@
+"""LM Studio provider - Anthropic-compatible local API."""
+
+from .client import LMStudioProvider
+
+__all__ = ["LMStudioProvider"]

providers/lmstudio/client.py

@@ -0,0 +1,16 @@
+"""LM Studio provider implementation."""
+
+from providers.base import ProviderConfig
+from providers.defaults import LMSTUDIO_DEFAULT_BASE
+from providers.transports.anthropic_messages import AnthropicMessagesTransport
+
+
+class LMStudioProvider(AnthropicMessagesTransport):
+    """LM Studio provider using native Anthropic Messages endpoint."""
+
+    def __init__(self, config: ProviderConfig):
+        super().__init__(
+            config,
+            provider_name="LMSTUDIO",
+            default_base_url=LMSTUDIO_DEFAULT_BASE,
+        )

providers/mistral/__init__.py

@@ -0,0 +1,7 @@
+"""Mistral La Plateforme provider exports."""
+
+from providers.defaults import MISTRAL_DEFAULT_BASE
+
+from .client import MistralProvider
+
+__all__ = ["MISTRAL_DEFAULT_BASE", "MistralProvider"]

providers/mistral/client.py

@@ -0,0 +1,31 @@
+"""Mistral La Plateforme provider implementation (OpenAI-compatible chat completions)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from providers.base import ProviderConfig
+from providers.defaults import MISTRAL_DEFAULT_BASE
+from providers.transports.openai_chat import OpenAIChatTransport
+
+from .request import build_request_body
+
+
+class MistralProvider(OpenAIChatTransport):
+    """Mistral API using ``https://api.mistral.ai/v1/chat/completions``."""
+
+    def __init__(self, config: ProviderConfig):
+        super().__init__(
+            config,
+            provider_name="MISTRAL",
+            base_url=config.base_url or MISTRAL_DEFAULT_BASE,
+            api_key=config.api_key,
+        )
+
+    def _build_request_body(
+        self, request: Any, thinking_enabled: bool | None = None
+    ) -> dict:
+        return build_request_body(
+            request,
+            thinking_enabled=self._is_thinking_enabled(request, thinking_enabled),
+        )

providers/mistral/request.py

@@ -0,0 +1,37 @@
+"""Request builder for Mistral La Plateforme (OpenAI-compatible chat completions)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from loguru import logger
+
+from core.anthropic import ReasoningReplayMode, build_base_request_body
+from core.anthropic.conversion import OpenAIConversionError
+from providers.exceptions import InvalidRequestError
+
+
+def build_request_body(request_data: Any, *, thinking_enabled: bool) -> dict:
+    """Build OpenAI-format request body from Anthropic request for Mistral."""
+    logger.debug(
+        "MISTRAL_REQUEST: conversion start model={} msgs={}",
+        getattr(request_data, "model", "?"),
+        len(getattr(request_data, "messages", [])),
+    )
+    try:
+        body = build_base_request_body(
+            request_data,
+            reasoning_replay=ReasoningReplayMode.REASONING_CONTENT
+            if thinking_enabled
+            else ReasoningReplayMode.DISABLED,
+        )
+    except OpenAIConversionError as exc:
+        raise InvalidRequestError(str(exc)) from exc
+
+    logger.debug(
+        "MISTRAL_REQUEST: conversion done model={} msgs={} tools={}",
+        body.get("model"),
+        len(body.get("messages", [])),
+        len(body.get("tools", [])),
+    )
+    return body

providers/model_listing.py

@@ -0,0 +1,133 @@
+"""Provider model-list response parsing helpers."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping, Sequence
+from dataclasses import dataclass
+from typing import Any
+
+from providers.exceptions import ModelListResponseError
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderModelInfo:
+    """Internal provider model metadata used for gateway model-list shaping."""
+
+    model_id: str
+    supports_thinking: bool | None = None
+
+
+def model_infos_from_ids(
+    model_ids: Iterable[str], *, supports_thinking: bool | None = None
+) -> frozenset[ProviderModelInfo]:
+    """Build unknown-capability model metadata from plain provider model ids."""
+    return frozenset(
+        ProviderModelInfo(model_id=model_id, supports_thinking=supports_thinking)
+        for model_id in model_ids
+        if model_id.strip()
+    )
+
+
+def extract_openai_model_ids(payload: Any, *, provider_name: str) -> frozenset[str]:
+    """Extract model ids from an OpenAI-compatible ``/models`` response."""
+    data = _field(payload, "data")
+    if not _is_sequence(data):
+        raise _malformed(provider_name, "expected top-level data array")
+
+    model_ids: set[str] = set()
+    for item in data:
+        model_id = _field(item, "id")
+        if not isinstance(model_id, str) or not model_id.strip():
+            raise _malformed(provider_name, "expected every data item to include id")
+        model_ids.add(model_id)
+
+    if not model_ids:
+        raise _malformed(provider_name, "response did not include any model ids")
+    return frozenset(model_ids)
+
+
+def extract_openrouter_tool_model_ids(
+    payload: Any, *, provider_name: str
+) -> frozenset[str]:
+    """Extract OpenRouter model ids that advertise tool-use support."""
+    return frozenset(
+        info.model_id
+        for info in extract_openrouter_tool_model_infos(
+            payload, provider_name=provider_name
+        )
+    )
+
+
+def extract_openrouter_tool_model_infos(
+    payload: Any, *, provider_name: str
+) -> frozenset[ProviderModelInfo]:
+    """Extract OpenRouter tool-capable model ids with thinking capability metadata."""
+    data = _field(payload, "data")
+    if not _is_sequence(data):
+        raise _malformed(provider_name, "expected top-level data array")
+
+    model_infos: set[ProviderModelInfo] = set()
+    for item in data:
+        model_id = _field(item, "id")
+        if not isinstance(model_id, str) or not model_id.strip():
+            raise _malformed(provider_name, "expected every data item to include id")
+
+        supported_parameters = _field(item, "supported_parameters")
+        if not _is_sequence(supported_parameters):
+            continue
+        supported_parameter_names = {
+            param for param in supported_parameters if isinstance(param, str)
+        }
+        if supported_parameter_names.isdisjoint({"tools", "tool_choice"}):
+            continue
+        model_infos.add(
+            ProviderModelInfo(
+                model_id=model_id,
+                supports_thinking="reasoning" in supported_parameter_names,
+            )
+        )
+
+    return frozenset(model_infos)
+
+
+def extract_ollama_model_ids(payload: Any, *, provider_name: str) -> frozenset[str]:
+    """Extract model ids from Ollama's native ``/api/tags`` response."""
+    models = _field(payload, "models")
+    if not _is_sequence(models):
+        raise _malformed(provider_name, "expected top-level models array")
+
+    model_ids: set[str] = set()
+    for item in models:
+        item_ids: list[str] = []
+        for key in ("model", "name"):
+            value = _field(item, key)
+            if isinstance(value, str) and value.strip():
+                item_ids.append(value)
+        if not item_ids:
+            raise _malformed(
+                provider_name,
+                "expected every models item to include model or name",
+            )
+        model_ids.update(item_ids)
+
+    if not model_ids:
+        raise _malformed(provider_name, "response did not include any model ids")
+    return frozenset(model_ids)
+
+
+def _field(item: Any, name: str) -> Any:
+    if isinstance(item, Mapping):
+        return item.get(name)
+    return getattr(item, name, None)
+
+
+def _is_sequence(value: Any) -> bool:
+    return isinstance(value, Sequence) and not isinstance(
+        value, str | bytes | bytearray
+    )
+
+
+def _malformed(provider_name: str, reason: str) -> ModelListResponseError:
+    return ModelListResponseError(
+        f"{provider_name} model-list response is malformed: {reason}"
+    )