devorch 0.1.2__py3-none-any.whl

providers/gemini.py

@@ -0,0 +1,192 @@
+from typing import Any
+
+from google import genai
+from google.genai import types
+
+from providers.base import LLMProvider, ModelInfo
+from schemas.message import LLMResponse, Message, ToolCall
+
+
+class GeminiProvider(LLMProvider):
+    """Google Gemini provider with function calling support using the new google.genai SDK."""
+
+    name = "gemini"
+
+    DEFAULT_MODELS = [
+        "gemini-2.0-flash",
+        "gemini-1.5-pro",
+        "gemini-1.5-flash",
+        "gemini-1.5-flash-8b",
+        "gemini-pro",
+    ]
+
+    def __init__(self, model: str = "gemini-2.0-flash", api_key: str | None = None):
+        self.model_name = model
+        self.model = model
+        self.client = genai.Client(api_key=api_key)
+
+    def list_models(self) -> list[ModelInfo]:
+        """Fetch available models from Gemini API."""
+        try:
+            models = []
+            for m in self.client.models.list():
+                # Filter for models that support content generation
+                if hasattr(m, "supported_actions") and "generateContent" in m.supported_actions:
+                    model_id = (
+                        m.name.replace("models/", "") if m.name.startswith("models/") else m.name
+                    )
+                    models.append(
+                        ModelInfo(
+                            id=model_id,
+                            name=getattr(m, "display_name", model_id),
+                            description=getattr(m, "description", ""),
+                        )
+                    )
+            return models if models else [ModelInfo(id=m, name=m) for m in self.DEFAULT_MODELS]
+        except Exception:
+            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:
+        # Build contents list for the API
+        contents = []
+        system_instruction = None
+
+        for msg in messages:
+            if msg.role == "system":
+                system_instruction = msg.content
+            elif msg.role == "user":
+                contents.append(
+                    types.Content(role="user", parts=[types.Part.from_text(text=msg.content)])
+                )
+            elif msg.role == "assistant":
+                # Check for function call metadata
+                if msg.metadata and msg.metadata.get("function_calls"):
+                    parts = []
+                    if msg.content and msg.content != "Calling tool...":
+                        parts.append(types.Part.from_text(text=msg.content))
+                    for fc in msg.metadata["function_calls"]:
+                        parts.append(
+                            types.Part.from_function_call(name=fc["name"], args=fc["args"])
+                        )
+                    contents.append(types.Content(role="model", parts=parts))
+                else:
+                    contents.append(
+                        types.Content(role="model", parts=[types.Part.from_text(text=msg.content)])
+                    )
+            elif msg.role == "tool":
+                # Tool results use function_response
+                contents.append(
+                    types.Content(
+                        role="user",
+                        parts=[
+                            types.Part.from_function_response(
+                                name=msg.name, response={"result": msg.content}
+                            )
+                        ],
+                    )
+                )
+
+        # Build tools configuration
+        gemini_tools = None
+        if tools:
+            function_declarations = []
+            for tool in tools:
+                params = tool.get("parameters", {"type": "object", "properties": {}})
+                gemini_params = self._convert_params(params)
+                function_declarations.append(
+                    types.FunctionDeclaration(
+                        name=tool["name"], description=tool["description"], parameters=gemini_params
+                    )
+                )
+            gemini_tools = [types.Tool(function_declarations=function_declarations)]
+
+        # Build config
+        config_kwargs = {}
+        if system_instruction:
+            config_kwargs["system_instruction"] = system_instruction
+        if gemini_tools:
+            config_kwargs["tools"] = gemini_tools
+            # Disable automatic function calling - we handle it ourselves
+            config_kwargs["automatic_function_calling"] = types.AutomaticFunctionCallingConfig(
+                disable=True
+            )
+
+        config = types.GenerateContentConfig(**config_kwargs) if config_kwargs else None
+
+        # Generate response
+        try:
+            response = self.client.models.generate_content(
+                model=self.model_name, contents=contents, config=config
+            )
+        except Exception as e:
+            # If tools fail, try without them
+            if gemini_tools and "tool" in str(e).lower():
+                config_no_tools = (
+                    types.GenerateContentConfig(system_instruction=system_instruction)
+                    if system_instruction
+                    else None
+                )
+                response = self.client.models.generate_content(
+                    model=self.model_name, contents=contents, config=config_no_tools
+                )
+            else:
+                raise
+
+        # Parse response
+        tool_calls = []
+        text_content = ""
+        function_call_metadata = []
+
+        if response.candidates and response.candidates[0].content:
+            for part in response.candidates[0].content.parts:
+                if hasattr(part, "text") and part.text:
+                    text_content += part.text
+                if hasattr(part, "function_call") and part.function_call:
+                    fc = part.function_call
+                    # Convert args to dict
+                    args = dict(fc.args) if fc.args else {}
+                    tool_call = ToolCall(
+                        name=fc.name, arguments=args, id=f"gemini_{fc.name}_{len(tool_calls)}"
+                    )
+                    tool_calls.append(tool_call)
+                    function_call_metadata.append({"name": fc.name, "args": args})
+
+        content = text_content if text_content else ("Calling tool..." if tool_calls else "")
+
+        # Store function calls in metadata for history reconstruction
+        metadata = {"function_calls": function_call_metadata} if function_call_metadata else None
+
+        return LLMResponse(
+            message=Message(role="assistant", content=content, metadata=metadata),
+            tool_calls=tool_calls if tool_calls else None,
+            raw=response,
+        )
+
+    def _convert_params(self, params: dict[str, Any]) -> dict[str, Any]:
+        """Convert JSON Schema parameters to Gemini format."""
+        result = {}
+
+        if "type" in params:
+            result["type"] = params["type"].upper()
+
+        if "properties" in params:
+            result["properties"] = {}
+            for key, value in params["properties"].items():
+                prop = {}
+                if "type" in value:
+                    prop["type"] = value["type"].upper()
+                if "description" in value:
+                    prop["description"] = value["description"]
+                if "enum" in value:
+                    prop["enum"] = value["enum"]
+                result["properties"][key] = prop
+
+        if "required" in params:
+            result["required"] = params["required"]
+
+        return result

providers/github_copilot.py

@@ -0,0 +1,196 @@
+"""
+GitHub Copilot provider using the GitHub Copilot API.
+
+Requires GitHub Copilot subscription and authentication.
+Uses OpenAI-compatible API with GitHub's models.
+"""
+
+import json
+import os
+
+from openai import OpenAI
+
+from providers.base import LLMProvider, ModelInfo
+from schemas.message import LLMResponse, Message, ToolCall
+
+
+class GitHubCopilotProvider(LLMProvider):
+    name = "github_copilot"
+
+    DEFAULT_MODELS = [
+        "gpt-4o",
+        "gpt-4o-mini",
+        "claude-3.5-sonnet",
+        "o1-preview",
+        "o1-mini",
+    ]
+
+    def __init__(
+        self,
+        model: str = "gpt-4o",
+        api_key: str | None = None,
+        base_url: str | None = None,
+    ):
+        """
+        Initialize GitHub Copilot provider.
+
+        Args:
+            model: Model to use (gpt-4o, claude-3.5-sonnet, etc.)
+            api_key: GitHub token (defaults to GITHUB_TOKEN env var)
+            base_url: Base URL for the API (defaults to GitHub Copilot API)
+        """
+        # GitHub Copilot uses GitHub tokens, not OpenAI keys
+        token = api_key or os.getenv("GITHUB_TOKEN")
+        if not token:
+            raise ValueError(
+                "GitHub token required. Set GITHUB_TOKEN env var or pass api_key parameter."
+            )
+
+        # GitHub Copilot API endpoint
+        base = base_url or "https://api.githubcopilot.com"
+
+        self.client = OpenAI(
+            api_key=token,
+            base_url=base,
+        )
+        self.model = model
+
+    def list_models(self) -> list[ModelInfo]:
+        """Fetch available models from GitHub Copilot 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:
+            # GitHub Copilot API might not support model listing
+            # Fall back to known available models
+            return self._get_default_models()
+
+    def _get_default_models(self) -> list[ModelInfo]:
+        """Get hardcoded default models as fallback."""
+        return [
+            ModelInfo(
+                id="gpt-4o",
+                name="GPT-4o",
+                description="OpenAI's GPT-4o via GitHub Copilot",
+            ),
+            ModelInfo(
+                id="gpt-4o-mini",
+                name="GPT-4o Mini",
+                description="Faster, cheaper GPT-4o variant",
+            ),
+            ModelInfo(
+                id="claude-3.5-sonnet",
+                name="Claude 3.5 Sonnet",
+                description="Anthropic's Claude 3.5 Sonnet via GitHub Copilot",
+            ),
+            ModelInfo(
+                id="o1-preview",
+                name="OpenAI o1 Preview",
+                description="OpenAI's o1 reasoning model (preview)",
+            ),
+            ModelInfo(
+                id="o1-mini",
+                name="OpenAI o1 Mini",
+                description="Smaller o1 reasoning 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": {}}
+                            ),
+                        },
+                    }
+                )
+
+        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 [])
+                ],
+            },
+        )

providers/groq.py

@@ -0,0 +1,158 @@
+"""
+Groq Provider - Fast AI inference
+https://groq.com/
+"""
+
+import json
+
+import httpx
+
+from providers.base import LLMProvider, ModelInfo
+from schemas.message import LLMResponse, Message, ToolCall
+
+
+class GroqProvider(LLMProvider):
+    """
+    Groq provider for ultra-fast inference.
+    Supports Llama, Mixtral, and Gemma models.
+    """
+
+    name = "groq"
+
+    DEFAULT_MODELS = [
+        "llama-3.1-70b-versatile",
+        "llama-3.1-8b-instant",
+        "llama3-70b-8192",
+        "llama3-8b-8192",
+        "mixtral-8x7b-32768",
+        "gemma2-9b-it",
+        "gemma-7b-it",
+    ]
+
+    BASE_URL = "https://api.groq.com/openai/v1"
+
+    def __init__(
+        self,
+        model: str = "llama-3.1-70b-versatile",
+        api_key: str | None = None,
+    ):
+        self.model = model
+        self.api_key = api_key
+        self.client = httpx.Client(timeout=120.0)
+
+    def _get_headers(self) -> dict:
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+
+    def list_models(self) -> list[ModelInfo]:
+        """Fetch available models from Groq API."""
+        try:
+            response = self.client.get(f"{self.BASE_URL}/models", headers=self._get_headers())
+            response.raise_for_status()
+            data = response.json()
+
+            models = []
+            for model in data.get("data", []):
+                # Filter to active models
+                if model.get("active", True):
+                    models.append(
+                        ModelInfo(
+                            id=model.get("id"),
+                            name=model.get("id"),
+                            context_length=model.get("context_window"),
+                        )
+                    )
+
+            models.sort(key=lambda m: m.id)
+            return models if models else [ModelInfo(id=m, name=m) for m in self.DEFAULT_MODELS]
+
+        except Exception:
+            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:
+        # Format messages for Groq 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
+        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": {}}
+                            ),
+                        },
+                    }
+                )
+
+        payload = {
+            "model": self.model,
+            "messages": formatted_messages,
+            "temperature": 0.0,
+        }
+
+        if formatted_tools:
+            payload["tools"] = formatted_tools
+            payload["tool_choice"] = "auto"
+
+        response = self.client.post(
+            f"{self.BASE_URL}/chat/completions", headers=self._get_headers(), json=payload
+        )
+        response.raise_for_status()
+        data = response.json()
+
+        choice = data["choices"][0]
+        message = choice["message"]
+
+        tool_calls = []
+        if message.get("tool_calls"):
+            for tc in message["tool_calls"]:
+                args = (
+                    json.loads(tc["function"]["arguments"])
+                    if tc["function"].get("arguments")
+                    else {}
+                )
+                tool_call = ToolCall(
+                    name=tc["function"]["name"],
+                    arguments=args,
+                    id=tc.get("id", tc["function"]["name"]),
+                )
+                tool_calls.append(tool_call)
+
+        content = message.get("content") or "Calling tool..."
+
+        return LLMResponse(
+            message=Message(role="assistant", content=content),
+            tool_calls=tool_calls if tool_calls else None,
+            raw=data,
+        )