devorch 0.1.2__py3-none-any.whl

providers/__init__.py

@@ -0,0 +1,130 @@
+from providers.anthropic import AnthropicProvider
+from providers.base import LLMProvider, ModelInfo
+from providers.custom import CustomProvider
+from providers.deepseek import DeepSeekProvider
+from providers.gemini import GeminiProvider
+from providers.github_copilot import GitHubCopilotProvider
+from providers.groq import GroqProvider
+from providers.kimi import KimiProvider
+from providers.lmstudio import LMStudioProvider
+from providers.local import LocalProvider
+from providers.mistral import MistralProvider
+from providers.openai import OpenAIProvider
+from providers.openrouter import OpenRouterProvider
+from providers.together import TogetherProvider
+
+# All available providers
+PROVIDERS: dict[str, type[LLMProvider]] = {
+    "openai": OpenAIProvider,
+    "anthropic": AnthropicProvider,
+    "gemini": GeminiProvider,
+    "local": LocalProvider,
+    "openrouter": OpenRouterProvider,
+    "mistral": MistralProvider,
+    "groq": GroqProvider,
+    "lmstudio": LMStudioProvider,
+    "together": TogetherProvider,
+    "github_copilot": GitHubCopilotProvider,
+    "deepseek": DeepSeekProvider,
+    "kimi": KimiProvider,
+    "custom": CustomProvider,
+}
+
+# Provider descriptions for help
+PROVIDER_INFO = {
+    "openai": "OpenAI - GPT-4o, GPT-4, etc.",
+    "anthropic": "Anthropic - Claude 3.5, Claude 3, etc.",
+    "gemini": "Google - Gemini Pro, Flash, etc.",
+    "local": "Ollama - Local models (llama, mistral, etc.)",
+    "openrouter": "OpenRouter - Access 100+ models via one API",
+    "mistral": "Mistral AI - Mistral Large, Medium, Codestral",
+    "groq": "Groq - Ultra-fast inference (Llama, Mixtral)",
+    "lmstudio": "LM Studio - Run local models with UI",
+    "together": "Together AI - Open source models at scale",
+    "github_copilot": "GitHub Copilot - Multiple models via GitHub subscription",
+    "deepseek": "DeepSeek - Powerful reasoning and coding models",
+    "kimi": "Kimi (Moonshot) - Long context models up to 128K",
+    "custom": "Custom - Any OpenAI-compatible API endpoint",
+}
+
+# Environment variable names for API keys
+PROVIDER_ENV_VARS = {
+    "openai": "OPENAI_API_KEY",
+    "anthropic": "ANTHROPIC_API_KEY",
+    "gemini": "GOOGLE_API_KEY",
+    "local": None,
+    "openrouter": "OPENROUTER_API_KEY",
+    "mistral": "MISTRAL_API_KEY",
+    "groq": "GROQ_API_KEY",
+    "lmstudio": None,
+    "together": "TOGETHER_API_KEY",
+    "github_copilot": "GITHUB_TOKEN",
+    "deepseek": "DEEPSEEK_API_KEY",
+    "kimi": "MOONSHOT_API_KEY",
+    "custom": "CUSTOM_API_KEY",
+}
+
+
+def get_provider(
+    name: str, model: str | None = None, api_key: str | None = None, **kwargs
+) -> LLMProvider:
+    """
+    Factory function to get a provider instance.
+
+    Args:
+        name: Provider name (openai, anthropic, gemini, local)
+        model: Model name (optional, uses provider default)
+        api_key: API key (optional, uses env var)
+        **kwargs: Additional provider-specific arguments (e.g., base_url for local)
+
+    Returns:
+        An LLMProvider instance
+
+    Raises:
+        ValueError: If provider name is unknown
+    """
+    if name not in PROVIDERS:
+        available = ", ".join(PROVIDERS.keys())
+        raise ValueError(f"Unknown provider: {name}. Available: {available}")
+
+    provider_class = PROVIDERS[name]
+
+    init_kwargs = {}
+    if model:
+        init_kwargs["model"] = model
+    if api_key:
+        init_kwargs["api_key"] = api_key
+    init_kwargs.update(kwargs)
+
+    return provider_class(**init_kwargs)
+
+
+def get_default_models(provider_name: str) -> list[str]:
+    """Get default model list for a provider."""
+    if provider_name not in PROVIDERS:
+        return []
+    return PROVIDERS[provider_name].DEFAULT_MODELS
+
+
+__all__ = [
+    "LLMProvider",
+    "ModelInfo",
+    "OpenAIProvider",
+    "AnthropicProvider",
+    "GeminiProvider",
+    "LocalProvider",
+    "OpenRouterProvider",
+    "MistralProvider",
+    "GroqProvider",
+    "LMStudioProvider",
+    "TogetherProvider",
+    "GitHubCopilotProvider",
+    "DeepSeekProvider",
+    "KimiProvider",
+    "CustomProvider",
+    "get_provider",
+    "get_default_models",
+    "PROVIDERS",
+    "PROVIDER_INFO",
+    "PROVIDER_ENV_VARS",
+]

providers/anthropic.py

@@ -0,0 +1,127 @@
+from anthropic import Anthropic
+
+from providers.base import LLMProvider, ModelInfo
+from schemas.message import LLMResponse, Message, ToolCall
+
+
+class AnthropicProvider(LLMProvider):
+    """Anthropic/Claude provider with tool use support."""
+
+    name = "anthropic"
+
+    DEFAULT_MODELS = [
+        "claude-sonnet-4-20250514",
+        "claude-opus-4-20250514",
+        "claude-3-5-sonnet-20241022",
+        "claude-3-5-haiku-20241022",
+        "claude-3-opus-20240229",
+        "claude-3-sonnet-20240229",
+        "claude-3-haiku-20240307",
+    ]
+
+    def __init__(self, model: str = "claude-sonnet-4-20250514", api_key: str | None = None):
+        self.client = Anthropic(api_key=api_key)
+        self.model = model
+
+    def list_models(self) -> list[ModelInfo]:
+        """Return available Claude models."""
+        # Anthropic doesn't have a models list API, use defaults
+        return [ModelInfo(id=m, name=m) for m in self.DEFAULT_MODELS]
+
+    def generate(
+        self,
+        messages: list[Message],
+        tools: list | None = None,
+        stream: bool = False,
+    ) -> LLMResponse:
+        # Extract system message (Anthropic handles it separately)
+        system_content = None
+        formatted_messages = []
+
+        for msg in messages:
+            if msg.role == "system":
+                system_content = msg.content
+            elif msg.role == "tool":
+                # Anthropic expects tool results as user messages with tool_result blocks
+                formatted_messages.append(
+                    {
+                        "role": "user",
+                        "content": [
+                            {
+                                "type": "tool_result",
+                                "tool_use_id": msg.tool_call_id or msg.name,
+                                "content": msg.content,
+                            }
+                        ],
+                    }
+                )
+            elif msg.role == "assistant":
+                # Check if this was a tool-calling message (has metadata with tool_use_blocks)
+                if msg.metadata and msg.metadata.get("tool_use_blocks"):
+                    # Reconstruct assistant message with tool_use blocks
+                    content = msg.metadata["tool_use_blocks"]
+                else:
+                    content = msg.content
+                formatted_messages.append({"role": "assistant", "content": content})
+            else:
+                # User messages
+                formatted_messages.append({"role": msg.role, "content": msg.content})
+
+        # Format tools for Anthropic (uses input_schema instead of parameters)
+        formatted_tools = None
+        if tools:
+            formatted_tools = []
+            for tool in tools:
+                formatted_tools.append(
+                    {
+                        "name": tool["name"],
+                        "description": tool["description"],
+                        "input_schema": tool.get(
+                            "parameters", {"type": "object", "properties": {}}
+                        ),
+                    }
+                )
+
+        # Build request kwargs
+        kwargs = {
+            "model": self.model,
+            "max_tokens": 4096,
+            "messages": formatted_messages,
+        }
+        if system_content:
+            kwargs["system"] = system_content
+        if formatted_tools:
+            kwargs["tools"] = formatted_tools
+
+        response = self.client.messages.create(**kwargs)
+
+        # Parse response - Anthropic returns content as a list of blocks
+        tool_calls = []
+        text_content = ""
+        tool_use_blocks = []  # Store for reconstructing assistant message later
+
+        for block in response.content:
+            if block.type == "text":
+                text_content += block.text
+            elif block.type == "tool_use":
+                tool_call = ToolCall(
+                    name=block.name,
+                    arguments=block.input,  # Already a dict, not JSON string
+                    id=block.id,
+                )
+                tool_calls.append(tool_call)
+                # Store the block for message reconstruction in history
+                tool_use_blocks.append(
+                    {"type": "tool_use", "id": block.id, "name": block.name, "input": block.input}
+                )
+
+        content = text_content if text_content else "Calling tool..."
+
+        # Store tool_use_blocks in metadata for message reconstruction
+        metadata = {"tool_use_blocks": tool_use_blocks} if tool_use_blocks else None
+
+        return LLMResponse(
+            message=Message(role="assistant", content=content, metadata=metadata),
+            tool_calls=tool_calls if tool_calls else None,
+            raw=response,
+        )

providers/base.py

@@ -0,0 +1,51 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+from schemas.message import LLMResponse, Message
+
+
+@dataclass
+class ModelInfo:
+    """Information about an available model."""
+
+    id: str
+    name: str
+    context_length: int | None = None
+    description: str | None = None
+
+
+class LLMProvider(ABC):
+    """
+    Base interface for all LLM providers.
+    """
+
+    name: str
+    model: str
+
+    # Default models for this provider (can be overridden)
+    DEFAULT_MODELS: list[str] = []
+
+    @abstractmethod
+    def generate(
+        self,
+        messages: list[Message],
+        tools: list | None = None,
+        stream: bool = False,
+    ) -> LLMResponse:
+        """
+        Generate a response from the model.
+        """
+        pass
+
+    def list_models(self) -> list[ModelInfo]:
+        """
+        List available models for this provider.
+        Override in subclasses to fetch from API.
+        Returns default models if not overridden.
+        """
+        return [ModelInfo(id=m, name=m) for m in self.DEFAULT_MODELS]
+
+    @classmethod
+    def get_default_models(cls) -> list[str]:
+        """Get list of default model IDs."""
+        return cls.DEFAULT_MODELS

providers/custom.py

@@ -0,0 +1,186 @@
+"""
+Custom provider for OpenAI-compatible APIs.
+
+Allows users to connect to any OpenAI-compatible endpoint with custom configuration.
+Perfect for self-hosted models, custom endpoints, or providers not officially supported.
+"""
+
+import json
+import os
+
+from openai import OpenAI
+
+from providers.base import LLMProvider, ModelInfo
+from schemas.message import LLMResponse, Message, ToolCall
+
+
+class CustomProvider(LLMProvider):
+    """
+    Generic OpenAI-compatible provider.
+
+    Can be configured to work with any API that implements the OpenAI chat completions format.
+
+    Examples:
+    - Self-hosted vLLM, TGI, or llama.cpp servers
+    - Custom model endpoints
+    - Provider-specific endpoints not officially supported
+    """
+
+    name = "custom"
+
+    DEFAULT_MODELS = []  # User must specify model
+
+    def __init__(
+        self,
+        model: str,
+        base_url: str,
+        api_key: str | None = None,
+        default_models: list[str] | None = None,
+    ):
+        """
+        Initialize custom provider.
+
+        Args:
+            model: Model name/ID to use
+            base_url: Base URL for the API endpoint (e.g., "http://localhost:8000/v1")
+            api_key: API key (optional, some self-hosted models don't need it)
+            default_models: List of available models (optional)
+        """
+        if not base_url:
+            raise ValueError("base_url is required for custom provider")
+
+        if not model:
+            raise ValueError("model is required for custom provider")
+
+        # Use provided API key or "dummy" for self-hosted models that don't need auth
+        key = api_key or os.getenv("CUSTOM_API_KEY") or "dummy"
+
+        self.client = OpenAI(
+            api_key=key,
+            base_url=base_url,
+        )
+        self.model = model
+        self.base_url = base_url
+
+        # Update default models if provided
+        if default_models:
+            self.DEFAULT_MODELS = default_models
+
+    def list_models(self) -> list[ModelInfo]:
+        """
+        List available models.
+
+        Tries to fetch from API, falls back to configured defaults.
+        """
+        try:
+            response = self.client.models.list()
+            models = []
+            for model in response.data:
+                models.append(
+                    ModelInfo(
+                        id=model.id,
+                        name=model.id,
+                    )
+                )
+            return models if models else [ModelInfo(id=self.model, name=self.model)]
+        except Exception:
+            # If API doesn't support model listing, return configured model
+            if self.DEFAULT_MODELS:
+                return [ModelInfo(id=m, name=m) for m in self.DEFAULT_MODELS]
+            return [ModelInfo(id=self.model, name=self.model)]
+
+    def generate(
+        self,
+        messages: list[Message],
+        tools: list | None = None,
+        stream: bool = False,
+    ) -> LLMResponse:
+        # Format messages for OpenAI-compatible API
+        formatted_messages = []
+        for msg in messages:
+            if msg.role == "tool":
+                formatted_msg = {
+                    "role": "tool",
+                    "content": msg.content,
+                    "tool_call_id": msg.tool_call_id or msg.name,
+                }
+            elif msg.role == "assistant" and msg.metadata and msg.metadata.get("tool_calls"):
+                # Preserve tool_calls in assistant messages
+                formatted_msg = {
+                    "role": "assistant",
+                    "content": msg.content or "",
+                    "tool_calls": msg.metadata["tool_calls"],
+                }
+            else:
+                formatted_msg = {"role": msg.role, "content": msg.content}
+            formatted_messages.append(formatted_msg)
+
+        # Format tools for OpenAI-compatible API
+        formatted_tools = None
+        if tools:
+            formatted_tools = []
+            for tool in tools:
+                formatted_tools.append(
+                    {
+                        "type": "function",
+                        "function": {
+                            "name": tool["name"],
+                            "description": tool["description"],
+                            "parameters": tool.get(
+                                "parameters", {"type": "object", "properties": {}}
+                            ),
+                        },
+                    }
+                )
+
+        # Make the API call
+        try:
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=formatted_messages,
+                tools=formatted_tools if formatted_tools else None,
+                temperature=0.0,
+            )
+
+            choice = response.choices[0]
+            message = choice.message
+
+            tool_calls = []
+            if message.tool_calls:
+                for tc in message.tool_calls:
+                    tool_calls.append(
+                        ToolCall(
+                            id=tc.id,
+                            name=tc.function.name,
+                            arguments=json.loads(tc.function.arguments),
+                        )
+                    )
+
+            return LLMResponse(
+                content=message.content or "",
+                tool_calls=tool_calls,
+                metadata={
+                    "model": response.model,
+                    "usage": {
+                        "prompt_tokens": response.usage.prompt_tokens if response.usage else 0,
+                        "completion_tokens": (
+                            response.usage.completion_tokens if response.usage else 0
+                        ),
+                        "total_tokens": response.usage.total_tokens if response.usage else 0,
+                    },
+                    "tool_calls": [
+                        {
+                            "id": tc.id,
+                            "type": "function",
+                            "function": {
+                                "name": tc.function.name,
+                                "arguments": tc.function.arguments,
+                            },
+                        }
+                        for tc in (message.tool_calls or [])
+                    ],
+                },
+            )
+
+        except Exception as e:
+            raise RuntimeError(f"Error calling custom API at {self.base_url}: {e}") from e

providers/deepseek.py

@@ -0,0 +1,170 @@
+"""
+DeepSeek AI provider.
+
+DeepSeek provides powerful reasoning and coding models with OpenAI-compatible API.
+"""
+
+import json
+
+from openai import OpenAI
+
+from providers.base import LLMProvider, ModelInfo
+from schemas.message import LLMResponse, Message, ToolCall
+
+
+class DeepSeekProvider(LLMProvider):
+    name = "deepseek"
+
+    DEFAULT_MODELS = [
+        "deepseek-chat",
+        "deepseek-coder",
+        "deepseek-reasoner",
+    ]
+
+    def __init__(
+        self,
+        model: str = "deepseek-chat",
+        api_key: str | None = None,
+        base_url: str = "https://api.deepseek.com",
+    ):
+        """
+        Initialize DeepSeek provider.
+
+        Args:
+            model: Model to use (deepseek-chat, deepseek-coder, deepseek-reasoner)
+            api_key: DeepSeek API key (defaults to DEEPSEEK_API_KEY env var)
+            base_url: Base URL for the API
+        """
+        self.client = OpenAI(api_key=api_key, base_url=base_url)
+        self.model = model
+
+    def list_models(self) -> list[ModelInfo]:
+        """Fetch available models from DeepSeek API."""
+        try:
+            response = self.client.models.list()
+            models = []
+            for model in response.data:
+                models.append(
+                    ModelInfo(
+                        id=model.id,
+                        name=model.id,
+                        description=getattr(model, "description", None),
+                    )
+                )
+            return models if models else self._get_default_models()
+        except Exception:
+            # Fallback to default models if API call fails
+            return self._get_default_models()
+
+    def _get_default_models(self) -> list[ModelInfo]:
+        """Get hardcoded default models as fallback."""
+        return [
+            ModelInfo(
+                id="deepseek-chat",
+                name="DeepSeek Chat",
+                context_length=64000,
+                description="General-purpose conversational model",
+            ),
+            ModelInfo(
+                id="deepseek-coder",
+                name="DeepSeek Coder",
+                context_length=64000,
+                description="Specialized coding model",
+            ),
+            ModelInfo(
+                id="deepseek-reasoner",
+                name="DeepSeek Reasoner",
+                context_length=64000,
+                description="Advanced reasoning model (R1 series)",
+            ),
+        ]
+
+    def generate(
+        self,
+        messages: list[Message],
+        tools: list | None = None,
+        stream: bool = False,
+    ) -> LLMResponse:
+        # Format messages for OpenAI-compatible API
+        formatted_messages = []
+        for msg in messages:
+            if msg.role == "tool":
+                formatted_msg = {
+                    "role": "tool",
+                    "content": msg.content,
+                    "tool_call_id": msg.tool_call_id or msg.name,
+                }
+            elif msg.role == "assistant" and msg.metadata and msg.metadata.get("tool_calls"):
+                formatted_msg = {
+                    "role": "assistant",
+                    "content": msg.content or "",
+                    "tool_calls": msg.metadata["tool_calls"],
+                }
+            else:
+                formatted_msg = {"role": msg.role, "content": msg.content}
+            formatted_messages.append(formatted_msg)
+
+        # Format tools
+        formatted_tools = None
+        if tools:
+            formatted_tools = []
+            for tool in tools:
+                formatted_tools.append(
+                    {
+                        "type": "function",
+                        "function": {
+                            "name": tool["name"],
+                            "description": tool["description"],
+                            "parameters": tool.get(
+                                "parameters", {"type": "object", "properties": {}}
+                            ),
+                        },
+                    }
+                )
+
+        response = self.client.chat.completions.create(
+            model=self.model,
+            messages=formatted_messages,
+            tools=formatted_tools,
+            temperature=0.0,
+        )
+
+        choice = response.choices[0]
+        message = choice.message
+
+        tool_calls = []
+        if message.tool_calls:
+            for tc in message.tool_calls:
+                tool_calls.append(
+                    ToolCall(
+                        id=tc.id,
+                        name=tc.function.name,
+                        arguments=json.loads(tc.function.arguments),
+                    )
+                )
+
+        return LLMResponse(
+            content=message.content or "",
+            tool_calls=tool_calls,
+            metadata={
+                "model": response.model,
+                "usage": {
+                    "prompt_tokens": response.usage.prompt_tokens if response.usage else 0,
+                    "completion_tokens": (
+                        response.usage.completion_tokens if response.usage else 0
+                    ),
+                    "total_tokens": response.usage.total_tokens if response.usage else 0,
+                },
+                "tool_calls": [
+                    {
+                        "id": tc.id,
+                        "type": "function",
+                        "function": {
+                            "name": tc.function.name,
+                            "arguments": tc.function.arguments,
+                        },
+                    }
+                    for tc in (message.tool_calls or [])
+                ],
+            },
+        )