devcopilot 0.2.0__py3-none-any.whl

api/gateway_model_ids.py

@@ -0,0 +1,54 @@
+"""Gateway-safe model id encoding for Claude Code model discovery."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+GATEWAY_MODEL_ID_PREFIX = "anthropic"
+
+# Claude Code currently treats any model id containing ``claude-3-`` as not
+# supporting thinking. This intentionally uses that client-side capability
+# heuristic while keeping the real provider/model ref reversible for routing.
+NO_THINKING_GATEWAY_MODEL_ID_PREFIX = "claude-3-freecc-no-thinking"
+
+
+@dataclass(frozen=True, slots=True)
+class DecodedGatewayModelId:
+    provider_id: str
+    provider_model: str
+    force_thinking_enabled: bool | None = None
+
+
+def gateway_model_id(provider_model_ref: str) -> str:
+    """Return the normal Claude Code-discoverable id for a provider/model ref."""
+    return f"{GATEWAY_MODEL_ID_PREFIX}/{provider_model_ref}"
+
+
+def no_thinking_gateway_model_id(provider_model_ref: str) -> str:
+    """Return a Claude Code-discoverable id that disables client thinking."""
+    return f"{NO_THINKING_GATEWAY_MODEL_ID_PREFIX}/{provider_model_ref}"
+
+
+def decode_gateway_model_id(model_name: str) -> DecodedGatewayModelId | None:
+    """Decode a model id advertised by this gateway, if it is one."""
+    prefix, separator, remainder = model_name.partition("/")
+    if not separator:
+        return None
+
+    force_thinking_enabled: bool | None
+    if prefix == GATEWAY_MODEL_ID_PREFIX:
+        force_thinking_enabled = None
+    elif prefix == NO_THINKING_GATEWAY_MODEL_ID_PREFIX:
+        force_thinking_enabled = False
+    else:
+        return None
+
+    provider_id, provider_separator, provider_model = remainder.partition("/")
+    if not provider_separator or not provider_model:
+        return None
+
+    return DecodedGatewayModelId(
+        provider_id=provider_id,
+        provider_model=provider_model,
+        force_thinking_enabled=force_thinking_enabled,
+    )

api/model_catalog.py

@@ -0,0 +1,133 @@
+"""Model-list response construction for Claude-compatible clients."""
+
+from __future__ import annotations
+
+from config.settings import Settings
+from providers.registry import ProviderRegistry
+
+from .gateway_model_ids import gateway_model_id, no_thinking_gateway_model_id
+from .models.responses import ModelResponse, ModelsListResponse
+
+DISCOVERED_MODEL_CREATED_AT = "1970-01-01T00:00:00Z"
+
+
+SUPPORTED_CLAUDE_MODELS = [
+    ModelResponse(
+        id="claude-opus-4-20250514",
+        display_name="Claude Opus 4",
+        created_at="2025-05-14T00:00:00Z",
+    ),
+    ModelResponse(
+        id="claude-sonnet-4-20250514",
+        display_name="Claude Sonnet 4",
+        created_at="2025-05-14T00:00:00Z",
+    ),
+    ModelResponse(
+        id="claude-haiku-4-20250514",
+        display_name="Claude Haiku 4",
+        created_at="2025-05-14T00:00:00Z",
+    ),
+    ModelResponse(
+        id="claude-3-opus-20240229",
+        display_name="Claude 3 Opus",
+        created_at="2024-02-29T00:00:00Z",
+    ),
+    ModelResponse(
+        id="claude-3-5-sonnet-20241022",
+        display_name="Claude 3.5 Sonnet",
+        created_at="2024-10-22T00:00:00Z",
+    ),
+    ModelResponse(
+        id="claude-3-haiku-20240307",
+        display_name="Claude 3 Haiku",
+        created_at="2024-03-07T00:00:00Z",
+    ),
+    ModelResponse(
+        id="claude-3-5-haiku-20241022",
+        display_name="Claude 3.5 Haiku",
+        created_at="2024-10-22T00:00:00Z",
+    ),
+]
+
+
+def build_models_list_response(
+    settings: Settings, provider_registry: ProviderRegistry | None
+) -> ModelsListResponse:
+    """Return configured, cached, and compatibility model ids."""
+    models: list[ModelResponse] = []
+    seen: set[str] = set()
+
+    for ref in settings.configured_chat_model_refs():
+        supports_thinking = None
+        if provider_registry is not None:
+            supports_thinking = provider_registry.cached_model_supports_thinking(
+                ref.provider_id, ref.model_id
+            )
+        _append_provider_model_variants(
+            models,
+            seen,
+            ref.model_ref,
+            supports_thinking=supports_thinking,
+        )
+
+    if provider_registry is not None:
+        for model_info in provider_registry.cached_prefixed_model_infos():
+            _append_provider_model_variants(
+                models,
+                seen,
+                model_info.model_id,
+                supports_thinking=model_info.supports_thinking,
+            )
+
+    for model in SUPPORTED_CLAUDE_MODELS:
+        _append_unique_model(models, seen, model)
+
+    return ModelsListResponse(
+        data=models,
+        first_id=models[0].id if models else None,
+        has_more=False,
+        last_id=models[-1].id if models else None,
+    )
+
+
+def _discovered_model_response(model_id: str, *, display_name: str) -> ModelResponse:
+    return ModelResponse(
+        id=model_id,
+        display_name=display_name,
+        created_at=DISCOVERED_MODEL_CREATED_AT,
+    )
+
+
+def _append_unique_model(
+    models: list[ModelResponse], seen: set[str], model: ModelResponse
+) -> None:
+    if model.id in seen:
+        return
+    seen.add(model.id)
+    models.append(model)
+
+
+def _append_provider_model_variants(
+    models: list[ModelResponse],
+    seen: set[str],
+    provider_model_ref: str,
+    *,
+    supports_thinking: bool | None = None,
+) -> None:
+    if supports_thinking is not False:
+        _append_unique_model(
+            models,
+            seen,
+            _discovered_model_response(
+                gateway_model_id(provider_model_ref),
+                display_name=provider_model_ref,
+            ),
+        )
+    _append_unique_model(
+        models,
+        seen,
+        _discovered_model_response(
+            no_thinking_gateway_model_id(provider_model_ref),
+            display_name=f"{provider_model_ref} (no thinking)",
+        ),
+    )

api/model_router.py

@@ -0,0 +1,125 @@
+"""Model routing for Claude-compatible requests."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from loguru import logger
+
+from config.provider_ids import SUPPORTED_PROVIDER_IDS
+from config.settings import Settings
+
+from .gateway_model_ids import decode_gateway_model_id
+from .models.anthropic import MessagesRequest, TokenCountRequest
+
+
+@dataclass(frozen=True, slots=True)
+class ResolvedModel:
+    original_model: str
+    provider_id: str
+    provider_model: str
+    provider_model_ref: str
+    thinking_enabled: bool
+
+
+@dataclass(frozen=True, slots=True)
+class RoutedMessagesRequest:
+    request: MessagesRequest
+    resolved: ResolvedModel
+
+
+@dataclass(frozen=True, slots=True)
+class RoutedTokenCountRequest:
+    request: TokenCountRequest
+    resolved: ResolvedModel
+
+
+class ModelRouter:
+    """Resolve incoming Claude model names to configured provider/model pairs."""
+
+    def __init__(self, settings: Settings):
+        self._settings = settings
+
+    def resolve(self, claude_model_name: str) -> ResolvedModel:
+        (
+            direct_provider_id,
+            direct_provider_model,
+            force_thinking_enabled,
+        ) = self._direct_provider_model(claude_model_name)
+        if direct_provider_id is not None and direct_provider_model is not None:
+            thinking_enabled = (
+                force_thinking_enabled
+                if force_thinking_enabled is not None
+                else self._settings.resolve_thinking(direct_provider_model)
+            )
+            logger.debug(
+                "MODEL DIRECT: '{}' -> provider='{}' model='{}' thinking={}",
+                claude_model_name,
+                direct_provider_id,
+                direct_provider_model,
+                thinking_enabled,
+            )
+            return ResolvedModel(
+                original_model=claude_model_name,
+                provider_id=direct_provider_id,
+                provider_model=direct_provider_model,
+                provider_model_ref=claude_model_name,
+                thinking_enabled=thinking_enabled,
+            )
+
+        provider_model_ref = self._settings.resolve_model(claude_model_name)
+        thinking_enabled = self._settings.resolve_thinking(claude_model_name)
+        provider_id = Settings.parse_provider_type(provider_model_ref)
+        provider_model = Settings.parse_model_name(provider_model_ref)
+        if provider_model != claude_model_name:
+            logger.debug(
+                "MODEL MAPPING: '{}' -> '{}'", claude_model_name, provider_model
+            )
+        return ResolvedModel(
+            original_model=claude_model_name,
+            provider_id=provider_id,
+            provider_model=provider_model,
+            provider_model_ref=provider_model_ref,
+            thinking_enabled=thinking_enabled,
+        )
+
+    def _direct_provider_model(
+        self, model_name: str
+    ) -> tuple[str | None, str | None, bool | None]:
+        decoded = decode_gateway_model_id(model_name)
+        if decoded is not None:
+            if decoded.provider_id not in SUPPORTED_PROVIDER_IDS:
+                return None, None, None
+            return (
+                decoded.provider_id,
+                decoded.provider_model,
+                decoded.force_thinking_enabled,
+            )
+
+        provider_id, separator, provider_model = model_name.partition("/")
+        if not separator:
+            return None, None, None
+        if provider_id not in SUPPORTED_PROVIDER_IDS:
+            return None, None, None
+        if not provider_model:
+            return None, None, None
+        return provider_id, provider_model, None
+
+    def resolve_messages_request(
+        self, request: MessagesRequest
+    ) -> RoutedMessagesRequest:
+        """Return an internal routed request context."""
+        resolved = self.resolve(request.model)
+        routed = request.model_copy(deep=True)
+        routed.model = resolved.provider_model
+        return RoutedMessagesRequest(request=routed, resolved=resolved)
+
+    def resolve_token_count_request(
+        self, request: TokenCountRequest
+    ) -> RoutedTokenCountRequest:
+        """Return an internal token-count request context."""
+        resolved = self.resolve(request.model)
+        routed = request.model_copy(
+            update={"model": resolved.provider_model}, deep=True
+        )
+        return RoutedTokenCountRequest(request=routed, resolved=resolved)

api/models/__init__.py

@@ -0,0 +1,45 @@
+"""API models exports."""
+
+from .anthropic import (
+    ContentBlockImage,
+    ContentBlockRedactedThinking,
+    ContentBlockText,
+    ContentBlockThinking,
+    ContentBlockToolResult,
+    ContentBlockToolUse,
+    Message,
+    MessagesRequest,
+    Role,
+    SystemContent,
+    ThinkingConfig,
+    TokenCountRequest,
+    Tool,
+)
+from .responses import (
+    MessagesResponse,
+    ModelResponse,
+    ModelsListResponse,
+    TokenCountResponse,
+    Usage,
+)
+
+__all__ = [
+    "ContentBlockImage",
+    "ContentBlockRedactedThinking",
+    "ContentBlockText",
+    "ContentBlockThinking",
+    "ContentBlockToolResult",
+    "ContentBlockToolUse",
+    "Message",
+    "MessagesRequest",
+    "MessagesResponse",
+    "ModelResponse",
+    "ModelsListResponse",
+    "Role",
+    "SystemContent",
+    "ThinkingConfig",
+    "TokenCountRequest",
+    "TokenCountResponse",
+    "Tool",
+    "Usage",
+]

api/models/anthropic.py

@@ -0,0 +1,234 @@
+"""Pydantic models for Anthropic-compatible requests."""
+
+from enum import StrEnum
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+
+# =============================================================================
+# Content Block Types
+# =============================================================================
+class Role(StrEnum):
+    user = "user"
+    assistant = "assistant"
+    system = "system"
+
+
+class _AnthropicBlockBase(BaseModel):
+    """Pass through provider fields (e.g. ``cache_control``) for native transports."""
+
+    model_config = ConfigDict(extra="allow")
+
+
+class ContentBlockText(_AnthropicBlockBase):
+    type: Literal["text"]
+    text: str
+
+
+class ContentBlockImage(_AnthropicBlockBase):
+    type: Literal["image"]
+    source: dict[str, Any]
+
+
+class ContentBlockDocument(_AnthropicBlockBase):
+    """Anthropic document block (e.g. PDF files via the Files API)."""
+
+    type: Literal["document"]
+    source: dict[str, Any]
+
+
+class ContentBlockToolUse(_AnthropicBlockBase):
+    type: Literal["tool_use"]
+    id: str
+    name: str
+    input: dict[str, Any]
+
+
+class ContentBlockToolResult(_AnthropicBlockBase):
+    type: Literal["tool_result"]
+    tool_use_id: str
+    content: str | list[Any] | dict[str, Any]
+
+
+class ContentBlockThinking(_AnthropicBlockBase):
+    type: Literal["thinking"]
+    thinking: str
+    signature: str | None = None
+
+
+class ContentBlockRedactedThinking(_AnthropicBlockBase):
+    type: Literal["redacted_thinking"]
+    data: str
+
+
+class ContentBlockServerToolUse(_AnthropicBlockBase):
+    """Anthropic server-side tool invocation (e.g. ``web_search``, ``web_fetch``)."""
+
+    type: Literal["server_tool_use"]
+    id: str
+    name: str
+    input: dict[str, Any]
+
+
+class ContentBlockWebSearchToolResult(_AnthropicBlockBase):
+    type: Literal["web_search_tool_result"]
+    tool_use_id: str
+    content: Any
+
+
+class ContentBlockWebFetchToolResult(_AnthropicBlockBase):
+    type: Literal["web_fetch_tool_result"]
+    tool_use_id: str
+    content: Any
+
+
+class SystemContent(_AnthropicBlockBase):
+    type: Literal["text"]
+    text: str
+
+
+def _text_system_block(text: str) -> dict[str, str]:
+    return {"type": "text", "text": text}
+
+
+def _merge_system_values(existing: Any, additions: list[Any]) -> Any:
+    values = [existing] if existing is not None else []
+    values.extend(additions)
+
+    if all(isinstance(value, str) for value in values):
+        return "\n\n".join(value for value in values if value)
+
+    blocks: list[Any] = []
+    for value in values:
+        if isinstance(value, str):
+            blocks.append(_text_system_block(value))
+        elif isinstance(value, list):
+            blocks.extend(value)
+        else:
+            blocks.append(value)
+    return blocks
+
+
+def _normalize_system_role_messages(data: Any) -> Any:
+    if not isinstance(data, dict):
+        return data
+
+    messages = data.get("messages")
+    if not isinstance(messages, list):
+        return data
+
+    system_contents: list[Any] = []
+    normalized_messages: list[Any] = []
+    for message in messages:
+        role = message.get("role") if isinstance(message, dict) else None
+        if role == Role.system:
+            system_contents.append(message.get("content", ""))
+            continue
+        normalized_messages.append(message)
+
+    if not system_contents:
+        return data
+
+    normalized = dict(data)
+    normalized["messages"] = normalized_messages
+    normalized["system"] = _merge_system_values(
+        normalized.get("system"), system_contents
+    )
+    return normalized
+
+
+# =============================================================================
+# Message Types
+# =============================================================================
+class Message(BaseModel):
+    role: Literal["user", "assistant"]
+    content: (
+        str
+        | list[
+            ContentBlockText
+            | ContentBlockImage
+            | ContentBlockDocument
+            | ContentBlockToolUse
+            | ContentBlockToolResult
+            | ContentBlockThinking
+            | ContentBlockRedactedThinking
+            | ContentBlockServerToolUse
+            | ContentBlockWebSearchToolResult
+            | ContentBlockWebFetchToolResult
+        ]
+    )
+    reasoning_content: str | None = None
+
+
+class Tool(_AnthropicBlockBase):
+    name: str
+    # Anthropic server tools (e.g. web_search beta tools) include a ``type`` and
+    # may omit ``input_schema`` because the provider owns the schema.
+    type: str | None = None
+    description: str | None = None
+    input_schema: dict[str, Any] | None = None
+
+
+class ThinkingConfig(BaseModel):
+    enabled: bool | None = True
+    type: str | None = None
+    budget_tokens: int | None = None
+
+
+# =============================================================================
+# Request Models
+# =============================================================================
+class MessagesRequest(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    @model_validator(mode="before")
+    @classmethod
+    def normalize_system_role_messages(cls, data: Any) -> Any:
+        return _normalize_system_role_messages(data)
+
+    model: str
+    # Internal routing / debug: accepted on parse but not serialized to providers.
+    original_model: str | None = Field(default=None, exclude=True)
+    resolved_provider_model: str | None = Field(default=None, exclude=True)
+    max_tokens: int | None = None
+    messages: list[Message]
+    system: str | list[SystemContent] | None = None
+    stop_sequences: list[str] | None = None
+    stream: bool | None = True
+    temperature: float | None = None
+    top_p: float | None = None
+    top_k: int | None = None
+    metadata: dict[str, Any] | None = None
+    tools: list[Tool] | None = None
+    tool_choice: dict[str, Any] | None = None
+    thinking: ThinkingConfig | None = None
+    # Native Anthropic / SDK client hints: ignored (not forwarded) for OpenAI Chat conversion.
+    context_management: dict[str, Any] | None = None
+    output_config: dict[str, Any] | None = None
+    mcp_servers: list[dict[str, Any]] | None = None
+    extra_body: dict[str, Any] | None = None
+    # Beta feature flags sent by Claude Code as a body field; accepted but never forwarded.
+    betas: list[str] | None = Field(default=None, exclude=True)
+
+
+class TokenCountRequest(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    @model_validator(mode="before")
+    @classmethod
+    def normalize_system_role_messages(cls, data: Any) -> Any:
+        return _normalize_system_role_messages(data)
+
+    model: str
+    original_model: str | None = Field(default=None, exclude=True)
+    resolved_provider_model: str | None = Field(default=None, exclude=True)
+    messages: list[Message]
+    system: str | list[SystemContent] | None = None
+    tools: list[Tool] | None = None
+    thinking: ThinkingConfig | None = None
+    tool_choice: dict[str, Any] | None = None
+    context_management: dict[str, Any] | None = None
+    output_config: dict[str, Any] | None = None
+    mcp_servers: list[dict[str, Any]] | None = None
+    betas: list[str] | None = Field(default=None, exclude=True)

api/models/openai_responses.py

@@ -0,0 +1,28 @@
+"""Pydantic models for OpenAI Responses-compatible ingress."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+
+class OpenAIResponsesRequest(BaseModel):
+    """Permissive subset of the OpenAI Responses API request shape."""
+
+    model_config = ConfigDict(extra="allow")
+
+    model: str
+    input: Any = None
+    instructions: str | None = None
+    tools: list[dict[str, Any]] | None = None
+    tool_choice: Any = None
+    parallel_tool_calls: bool | None = None
+    stream: bool | None = True
+    temperature: float | None = None
+    top_p: float | None = None
+    max_output_tokens: int | None = None
+    metadata: dict[str, Any] | None = None
+    reasoning: dict[str, Any] | None = None
+    previous_response_id: str | None = None
+    store: bool | None = None

api/models/responses.py

@@ -0,0 +1,60 @@
+"""Pydantic models for API responses."""
+
+from typing import Any, Literal
+
+from pydantic import BaseModel
+
+from .anthropic import (
+    ContentBlockRedactedThinking,
+    ContentBlockText,
+    ContentBlockThinking,
+    ContentBlockToolUse,
+)
+
+
+class TokenCountResponse(BaseModel):
+    input_tokens: int
+
+
+class ModelResponse(BaseModel):
+    object: Literal["model"] = "model"
+    created: int = 0
+    owned_by: str = "devcopilot"
+    created_at: str
+    display_name: str
+    id: str
+    type: Literal["model"] = "model"
+
+
+class ModelsListResponse(BaseModel):
+    object: Literal["list"] = "list"
+    data: list[ModelResponse]
+    first_id: str | None
+    has_more: bool
+    last_id: str | None
+
+
+class Usage(BaseModel):
+    input_tokens: int
+    output_tokens: int
+    cache_creation_input_tokens: int = 0
+    cache_read_input_tokens: int = 0
+
+
+class MessagesResponse(BaseModel):
+    id: str
+    model: str
+    role: Literal["assistant"] = "assistant"
+    content: list[
+        ContentBlockText
+        | ContentBlockToolUse
+        | ContentBlockThinking
+        | ContentBlockRedactedThinking
+        | dict[str, Any]
+    ]
+    type: Literal["message"] = "message"
+    stop_reason: (
+        Literal["end_turn", "max_tokens", "stop_sequence", "tool_use"] | None
+    ) = None
+    stop_sequence: str | None = None
+    usage: Usage