llm-dialog-manager 0.4.7__py3-none-any.whl → 0.5.3__py3-none-any.whl

llm_dialog_manager/clients/__init__.py

@@ -0,0 +1,31 @@
+"""
+LLM API client modules for different services.
+"""
+
+from .base import BaseClient
+from .anthropic_client import AnthropicClient
+from .gemini_client import GeminiClient
+from .openai_client import OpenAIClient
+from .x_client import XClient
+
+def get_client(model_name, api_key=None, base_url=None):
+    """Factory method to get the appropriate client for a given model.
+    
+    Args:
+        model_name: Name of the model (e.g., "claude-3-opus", "gemini-1.5-pro")
+        api_key: Optional API key to use
+        base_url: Optional base URL to use
+        
+    Returns:
+        An instance of the appropriate client class
+    """
+    if "-openai" in model_name:
+        return OpenAIClient(api_key=api_key, base_url=base_url)
+    if "claude" in model_name:
+        return AnthropicClient(api_key=api_key, base_url=base_url)
+    elif "gemini" in model_name:
+        return GeminiClient(api_key=api_key, base_url=base_url)
+    elif "grok" in model_name:
+        return XClient(api_key=api_key, base_url=base_url)
+    else:  # Default to OpenAI client
+        return OpenAIClient(api_key=api_key, base_url=base_url)

llm_dialog_manager/clients/anthropic_client.py

@@ -0,0 +1,143 @@
+"""
+Client implementation for Anthropic Claude models
+"""
+import os
+import logging
+import httpx
+from typing import List, Dict, Optional, Union
+
+import anthropic
+from anthropic import AnthropicVertex, AnthropicBedrock
+
+from ..formatters import AnthropicFormatter
+from .base import BaseClient
+
+logger = logging.getLogger(__name__)
+
+class AnthropicClient(BaseClient):
+    """Client for Anthropic Claude API"""
+    
+    def _get_service_name(self) -> str:
+        return "anthropic"
+    
+    def completion(self, messages, max_tokens=1000, temperature=0.5, 
+                   top_p=1.0, top_k=40, json_format=False, **kwargs):
+        """
+        Generate a completion using Anthropic Claude.
+        
+        Args:
+            messages: List of message dictionaries
+            max_tokens: Maximum number of tokens to generate
+            temperature: Sampling temperature
+            top_p: Nucleus sampling parameter
+            top_k: Top-k sampling parameter
+            json_format: Whether to return JSON
+            **kwargs: Additional model-specific parameters
+            
+        Returns:
+            Generated text response
+        """
+        try:
+            # Get API credentials if not set
+            self.get_credentials()
+            
+            # Format messages for Anthropic API
+            formatter = AnthropicFormatter()
+            system_message, formatted_messages = formatter.format_messages(messages)
+            
+            # Get the model name from kwargs or use default
+            model_name = kwargs.get("model", "claude-3-opus")
+            
+            # Check for Vertex configuration
+            vertex_project_id = os.getenv('VERTEX_PROJECT_ID')
+            vertex_region = os.getenv('VERTEX_REGION')
+            
+            # Check for AWS Bedrock configuration
+            aws_region = os.getenv('AWS_REGION', 'us-east-1')
+            aws_access_key = os.getenv('AWS_ACCESS_KEY_ID')
+            aws_secret_key = os.getenv('AWS_SECRET_ACCESS_KEY')
+            aws_session_token = os.getenv('AWS_SESSION_TOKEN')
+            
+            # Get proxy configuration from environment or default to None
+            http_proxy = os.getenv("HTTP_PROXY")
+            https_proxy = os.getenv("HTTPS_PROXY")
+            
+            # Determine if we should use Bedrock based on model name prefix
+            use_bedrock = "anthropic." in model_name
+            
+            if use_bedrock:
+                logger.info(f"Using AWS Bedrock for model: {model_name}")
+                # Use AWS Bedrock for Claude
+                bedrock_kwargs = {
+                    "aws_region": aws_region
+                }
+                
+                # Only add credentials if explicitly provided
+                if aws_access_key and aws_secret_key:
+                    bedrock_kwargs["aws_access_key"] = aws_access_key
+                    bedrock_kwargs["aws_secret_key"] = aws_secret_key
+                    
+                client = AnthropicBedrock(**bedrock_kwargs)
+                
+                response = client.messages.create(
+                    model=model_name,
+                    max_tokens=max_tokens,
+                    temperature=temperature,
+                    system=system_message,
+                    messages=formatted_messages,
+                    top_p=top_p,
+                    top_k=top_k
+                )
+            elif vertex_project_id and vertex_region:
+                # Use Vertex AI for Claude
+                client = AnthropicVertex(
+                    region=vertex_region,
+                    project_id=vertex_project_id
+                )
+                
+                response = client.messages.create(
+                    model=model_name,
+                    max_tokens=max_tokens,
+                    temperature=temperature,
+                    system=system_message,
+                    messages=formatted_messages,
+                    top_p=top_p,
+                    top_k=top_k
+                )
+            else:
+                # Create httpx client with proxy settings if needed
+                http_options = {}
+                if http_proxy or https_proxy:
+                    proxies = {}
+                    if http_proxy:
+                        proxies["http://"] = http_proxy
+                    if https_proxy:
+                        proxies["https://"] = https_proxy
+                    http_options["proxies"] = proxies
+                
+                # Use direct Anthropic API with proper http client
+                client = anthropic.Anthropic(
+                    api_key=self.api_key, 
+                    base_url=self.base_url,
+                    http_client=httpx.Client(**http_options) if http_options else None
+                )
+                
+                response = client.messages.create(
+                    model=model_name,
+                    max_tokens=max_tokens,
+                    temperature=temperature,
+                    system=system_message,
+                    messages=formatted_messages,
+                    top_p=top_p,
+                    top_k=top_k
+                )
+            
+            # Release API credentials
+            self.release_credentials()
+            
+            return response.content[0].text
+            
+        except Exception as e:
+            logger.error(f"Anthropic API error: {e}")
+            self.report_error()
+            raise

llm_dialog_manager/clients/base.py

@@ -0,0 +1,65 @@
+"""
+Base client interface for LLM APIs
+"""
+from abc import ABC, abstractmethod
+from typing import List, Dict, Optional, Union
+import logging
+
+from ..key_manager import key_manager
+
+logger = logging.getLogger(__name__)
+
+class BaseClient(ABC):
+    """Base class for LLM API clients"""
+    
+    def __init__(self, api_key=None, base_url=None):
+        """
+        Initialize client with optional API key and base URL.
+        
+        Args:
+            api_key: Optional API key to use 
+            base_url: Optional base URL for API requests
+        """
+        self.api_key = api_key
+        self.base_url = base_url
+        self.service_name = self._get_service_name()
+    
+    @abstractmethod
+    def _get_service_name(self) -> str:
+        """Return the service name for this client (e.g., 'openai', 'anthropic')"""
+        pass
+    
+    def get_credentials(self):
+        """Get API credentials from key manager if not set"""
+        if not self.api_key:
+            self.api_key, self.base_url = key_manager.get_config(self.service_name)
+    
+    def release_credentials(self):
+        """Release API credentials in key manager"""
+        if self.api_key:
+            key_manager.release_config(self.service_name, self.api_key)
+    
+    def report_error(self):
+        """Report API error to key manager"""
+        if self.api_key:
+            key_manager.report_error(self.service_name, self.api_key)
+    
+    @abstractmethod
+    def completion(self, messages, max_tokens=1000, temperature=0.5, 
+                   top_p=1.0, top_k=40, json_format=False, **kwargs):
+        """
+        Generate a completion for the given messages.
+        
+        Args:
+            messages: List of message dictionaries
+            max_tokens: Maximum number of tokens to generate
+            temperature: Sampling temperature
+            top_p: Nucleus sampling parameter
+            top_k: Top-k sampling parameter
+            json_format: Whether to return JSON
+            **kwargs: Additional model-specific parameters
+            
+        Returns:
+            Generated text response
+        """
+        pass

llm_dialog_manager/clients/gemini_client.py

@@ -0,0 +1,78 @@
+"""
+Client implementation for Google Gemini models
+"""
+import os
+import logging
+from typing import List, Dict, Optional, Union
+
+import google.generativeai as genai
+
+from ..formatters import GeminiFormatter
+from .base import BaseClient
+
+logger = logging.getLogger(__name__)
+
+class GeminiClient(BaseClient):
+    """Client for Google Gemini API"""
+    
+    def _get_service_name(self) -> str:
+        return "gemini"
+    
+    def completion(self, messages, max_tokens=1000, temperature=0.5, 
+                   top_p=1.0, top_k=40, json_format=False, **kwargs):
+        """
+        Generate a completion using Google Gemini.
+        
+        Args:
+            messages: List of message dictionaries
+            max_tokens: Maximum number of tokens to generate
+            temperature: Sampling temperature
+            top_p: Nucleus sampling parameter
+            top_k: Top-k sampling parameter
+            json_format: Whether to return JSON
+            **kwargs: Additional model-specific parameters
+            
+        Returns:
+            Generated text response
+        """
+        try:
+            # Get API credentials if not set
+            self.get_credentials()
+            
+            # Configure Google API
+            genai.configure(api_key=self.api_key)
+            
+            # Format messages for Gemini API
+            formatter = GeminiFormatter()
+            system_message, formatted_messages = formatter.format_messages(messages)
+            
+            # Create model configuration
+            model = genai.GenerativeModel(
+                model_name=kwargs.get("model", "gemini-1.5-pro"),
+                generation_config={
+                    "max_output_tokens": max_tokens,
+                    "temperature": temperature,
+                    "top_p": top_p,
+                    "top_k": top_k
+                },
+                system_instruction=system_message
+            )
+            
+            # Generate response
+            if json_format:
+                response = model.generate_content(
+                    formatted_messages,
+                    generation_config={"response_mime_type": "application/json"}
+                )
+            else:
+                response = model.generate_content(formatted_messages)
+            
+            # Release API credentials
+            self.release_credentials()
+            
+            return response.text
+            
+        except Exception as e:
+            logger.error(f"Gemini API error: {e}")
+            self.report_error()
+            raise

llm_dialog_manager/clients/openai_client.py

@@ -0,0 +1,97 @@
+"""
+Client implementation for OpenAI models
+"""
+import os
+import logging
+import httpx
+from typing import List, Dict, Optional, Union
+
+import openai
+
+from ..formatters import OpenAIFormatter
+from .base import BaseClient
+
+logger = logging.getLogger(__name__)
+
+class OpenAIClient(BaseClient):
+    """Client for OpenAI API"""
+    
+    def _get_service_name(self) -> str:
+        return "openai"
+    
+    def completion(self, messages, max_tokens=1000, temperature=0.5, 
+                   top_p=1.0, top_k=40, json_format=False, **kwargs):
+        """
+        Generate a completion using OpenAI API.
+        
+        Args:
+            messages: List of message dictionaries
+            max_tokens: Maximum number of tokens to generate
+            temperature: Sampling temperature
+            top_p: Nucleus sampling parameter
+            top_k: Top-k sampling parameter (not used for OpenAI)
+            json_format: Whether to return JSON
+            **kwargs: Additional model-specific parameters
+            
+        Returns:
+            Generated text response
+        """
+        try:
+            # Get API credentials if not set
+            self.get_credentials()
+            
+            # Format messages for OpenAI API
+            formatter = OpenAIFormatter()
+            _, formatted_messages = formatter.format_messages(messages)
+            
+            # Get proxy configuration from environment or default to None
+            http_proxy = os.getenv("HTTP_PROXY")
+            https_proxy = os.getenv("HTTPS_PROXY")
+            
+            # Create httpx client with proxy settings if needed
+            http_options = {}
+            if http_proxy or https_proxy:
+                proxies = {}
+                if http_proxy:
+                    proxies["http://"] = http_proxy
+                if https_proxy:
+                    proxies["https://"] = https_proxy
+                http_options["proxies"] = proxies
+            
+            # Create OpenAI client with proper configuration
+            client = openai.OpenAI(
+                api_key=self.api_key, 
+                base_url=self.base_url,
+                http_client=httpx.Client(**http_options) if http_options else None
+            )
+            
+            # Process model name
+            model = kwargs.get("model", "gpt-4")
+            if model.endswith("-openai"):
+                model = model[:-7]  # Remove last 7 characters ("-openai")
+            
+            # Create base parameters
+            params = {
+                "model": model,
+                "messages": formatted_messages,
+                "max_tokens": max_tokens,
+                "temperature": temperature,
+                "top_p": top_p
+            }
+            
+            # Add optional parameters
+            if json_format:
+                params["response_format"] = {"type": "json_object"}
+            
+            # Generate completion
+            response = client.chat.completions.create(**params)
+            
+            # Release API credentials
+            self.release_credentials()
+            
+            return response.choices[0].message.content
+            
+        except Exception as e:
+            logger.error(f"OpenAI API error: {e}")
+            self.report_error()
+            raise

llm_dialog_manager/clients/x_client.py

@@ -0,0 +1,83 @@
+"""
+Client implementation for X.AI (Grok) models
+"""
+import os
+import logging
+import openai
+from typing import List, Dict, Optional, Union
+
+from ..formatters import OpenAIFormatter
+from .base import BaseClient
+
+logger = logging.getLogger(__name__)
+
+class XClient(BaseClient):
+    """Client for X.AI (Grok) API"""
+    
+    def _get_service_name(self) -> str:
+        return "x"
+    
+    def completion(self, messages, max_tokens=1000, temperature=0.5, 
+                   top_p=1.0, top_k=40, json_format=False, **kwargs):
+        """
+        Generate a completion using X.AI (Grok) API.
+        
+        Args:
+            messages: List of message dictionaries
+            max_tokens: Maximum number of tokens to generate
+            temperature: Sampling temperature
+            top_p: Nucleus sampling parameter
+            top_k: Top-k sampling parameter
+            json_format: Whether to return JSON
+            **kwargs: Additional model-specific parameters
+            
+        Returns:
+            Generated text response
+        """
+        try:
+            # Get API credentials if not set
+            self.get_credentials()
+            
+            # Format messages for X.AI API using OpenAI formatter
+            # (X.AI uses the same message format as OpenAI)
+            formatter = OpenAIFormatter()
+            _, formatted_messages = formatter.format_messages(messages)
+            
+            # Set default base URL if not already set
+            if not self.base_url:
+                self.base_url = "https://api.x.ai/v1"
+            
+            # Initialize OpenAI client
+            client = openai.OpenAI(
+                api_key=self.api_key,
+                base_url=self.base_url
+            )
+            
+            # Process model name
+            model = kwargs.get("model", "grok-3-beta")
+            
+            # Create base parameters
+            params = {
+                "model": model,
+                "messages": formatted_messages,
+                "max_tokens": max_tokens,
+                "temperature": temperature,
+                "top_p": top_p,
+            }
+            
+            # Add optional parameters
+            if json_format:
+                params["response_format"] = {"type": "json_object"}
+            
+            # Generate completion using OpenAI client
+            response = client.chat.completions.create(**params)
+            
+            # Release API credentials
+            self.release_credentials()
+            
+            return response.choices[0].message.content
+            
+        except Exception as e:
+            logger.error(f"X.AI API error: {e}")
+            self.report_error()
+            raise

llm_dialog_manager/formatters/__init__.py

@@ -0,0 +1,27 @@
+"""
+Message formatters for different LLM services.
+"""
+
+from .base import BaseMessageFormatter
+from .anthropic import AnthropicFormatter
+from .gemini import GeminiFormatter
+from .openai import OpenAIFormatter
+from .x import XFormatter
+
+def get_formatter(model_name):
+    """Factory method to get the appropriate formatter for a given model.
+    
+    Args:
+        model_name: Name of the model (e.g., "claude-3-opus", "gemini-1.5-pro")
+        
+    Returns:
+        An instance of the appropriate formatter class
+    """
+    if "claude" in model_name:
+        return AnthropicFormatter()
+    elif "gemini" in model_name:
+        return GeminiFormatter()
+    elif "grok" in model_name:
+        return XFormatter()
+    else:  # Default to OpenAI formatter
+        return OpenAIFormatter()

llm_dialog_manager/formatters/anthropic.py

@@ -0,0 +1,76 @@
+"""
+Message formatter for Anthropic Claude models
+"""
+import io
+import base64
+from typing import List, Dict, Union, Optional
+from PIL import Image
+
+from .base import BaseMessageFormatter
+
+class AnthropicFormatter(BaseMessageFormatter):
+    """Formatter for Anthropic Claude API messages"""
+    
+    def format_messages(self, messages: List[Dict[str, Union[str, List[Union[str, Image.Image, Dict]]]]]) -> tuple:
+        """
+        Format messages for the Anthropic Claude API.
+        
+        Args:
+            messages: List of message dictionaries in standard format
+            
+        Returns:
+            A tuple containing (system_message, formatted_messages)
+            where system_message is extracted as a separate string
+        """
+        formatted = []
+        system_msg = ""
+        
+        # Extract system message if present
+        if messages and messages[0]["role"] == "system":
+            system_msg = messages[0]["content"]
+            messages = messages[1:]
+            
+        for msg in messages:
+            content = msg["content"]
+            if isinstance(content, str):
+                formatted.append({"role": msg["role"], "content": content})
+            elif isinstance(content, list):
+                # Combine content blocks into a single message
+                combined_content = []
+                for block in content:
+                    if isinstance(block, str):
+                        combined_content.append({"type": "text", "text": block})
+                    elif isinstance(block, Image.Image):
+                        # For Claude, convert PIL.Image to base64
+                        buffered = io.BytesIO()
+                        block.save(buffered, format="PNG")
+                        image_base64 = base64.b64encode(buffered.getvalue()).decode("utf-8")
+                        combined_content.append({
+                            "type": "image",
+                            "source": {
+                                "type": "base64",
+                                "media_type": "image/png",
+                                "data": image_base64
+                            }
+                        })
+                    elif isinstance(block, dict):
+                        if block.get("type") == "image_url":
+                            combined_content.append({
+                                "type": "image",
+                                "source": {
+                                    "type": "url",
+                                    "url": block["image_url"]["url"]
+                                }
+                            })
+                        elif block.get("type") == "image_base64":
+                            combined_content.append({
+                                "type": "image",
+                                "source": {
+                                    "type": "base64",
+                                    "media_type": block["image_base64"]["media_type"],
+                                    "data": block["image_base64"]["data"]
+                                }
+                            })
+                formatted.append({"role": msg["role"], "content": combined_content})
+                
+        return system_msg, formatted

llm_dialog_manager/formatters/base.py

@@ -0,0 +1,23 @@
+"""
+Base message formatter interface
+"""
+from abc import ABC, abstractmethod
+from typing import List, Dict, Union, Optional
+from PIL import Image
+
+class BaseMessageFormatter(ABC):
+    """Base class for message formatters"""
+    
+    @abstractmethod
+    def format_messages(self, messages: List[Dict[str, Union[str, List[Union[str, Image.Image, Dict]]]]]) -> tuple:
+        """
+        Format messages for the specific LLM API.
+        
+        Args:
+            messages: List of message dictionaries in standard format
+            
+        Returns:
+            A tuple containing (system_message, formatted_messages)
+            where system_message can be None if not used by the API
+        """
+        pass

llm_dialog_manager/formatters/gemini.py

@@ -0,0 +1,59 @@
+"""
+Message formatter for Google Gemini models
+"""
+from typing import List, Dict, Union, Optional
+from PIL import Image
+
+from .base import BaseMessageFormatter
+
+class GeminiFormatter(BaseMessageFormatter):
+    """Formatter for Google Gemini API messages"""
+    
+    def format_messages(self, messages: List[Dict[str, Union[str, List[Union[str, Image.Image, Dict]]]]]) -> tuple:
+        """
+        Format messages for the Google Gemini API.
+        
+        Args:
+            messages: List of message dictionaries in standard format
+            
+        Returns:
+            A tuple containing (system_message, formatted_messages)
+            where system_message is extracted separately
+        """
+        system_msg = None
+        formatted = []
+        
+        for msg in messages:
+            # Extract system message if present
+            if msg["role"] == "system":
+                system_msg = msg["content"] if isinstance(msg["content"], str) else str(msg["content"])
+                continue
+                
+            content = msg["content"]
+            if isinstance(content, str):
+                formatted.append({"role": msg["role"], "parts": [content]})
+            elif isinstance(content, list):
+                parts = []
+                for block in content:
+                    if isinstance(block, str):
+                        parts.append(block)
+                    elif isinstance(block, Image.Image):
+                        parts.append(block)  # Gemini supports PIL.Image directly
+                    elif isinstance(block, dict):
+                        if block.get("type") == "image_url":
+                            parts.append({
+                                "inline_data": {
+                                    "mime_type": "image/jpeg",
+                                    "data": block["image_url"]["url"]
+                                }
+                            })
+                        elif block.get("type") == "image_base64":
+                            parts.append({
+                                "inline_data": {
+                                    "mime_type": block["image_base64"]["media_type"],
+                                    "data": block["image_base64"]["data"]
+                                }
+                            })
+                formatted.append({"role": msg["role"], "parts": parts})
+                
+        return system_msg, formatted