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

llm_dialog_manager/__init__.py

@@ -5,7 +5,7 @@ A modular framework for building conversational AI applications with
 support for multiple LLM providers.
 """
 
-__version__ = "0.5.0"
+__version__ = "0.5.3"
 
 from .agent import Agent
 from .chat_history import ChatHistory

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

llm_dialog_manager/formatters/openai.py

@@ -0,0 +1,67 @@
+"""
+Message formatter for OpenAI models
+"""
+import io
+import base64
+from typing import List, Dict, Union, Optional
+from PIL import Image
+
+from .base import BaseMessageFormatter
+
+class OpenAIFormatter(BaseMessageFormatter):
+    """Formatter for OpenAI API messages"""
+    
+    def format_messages(self, messages: List[Dict[str, Union[str, List[Union[str, Image.Image, Dict]]]]]) -> tuple:
+        """
+        Format messages for the OpenAI API.
+        
+        Args:
+            messages: List of message dictionaries in standard format
+            
+        Returns:
+            A tuple containing (None, formatted_messages)
+            since OpenAI handles system messages in the message list
+        """
+        formatted = []
+        
+        for msg in messages:
+            content = msg["content"]
+            if isinstance(content, str):
+                formatted.append({"role": msg["role"], "content": content})
+            elif isinstance(content, list):
+                # For OpenAI with multimodal models like GPT-4V
+                formatted_content = []
+                
+                for block in content:
+                    if isinstance(block, str):
+                        formatted_content.append({"type": "text", "text": block})
+                    elif isinstance(block, Image.Image):
+                        # Convert PIL.Image to base64
+                        buffered = io.BytesIO()
+                        block.save(buffered, format="PNG")
+                        image_base64 = base64.b64encode(buffered.getvalue()).decode("utf-8")
+                        formatted_content.append({
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:image/png;base64,{image_base64}"
+                            }
+                        })
+                    elif isinstance(block, dict):
+                        if block.get("type") == "image_url":
+                            formatted_content.append({
+                                "type": "image_url",
+                                "image_url": {
+                                    "url": block["image_url"]["url"]
+                                }
+                            })
+                        elif block.get("type") == "image_base64":
+                            formatted_content.append({
+                                "type": "image_url",
+                                "image_url": {
+                                    "url": f"data:{block['image_base64']['media_type']};base64,{block['image_base64']['data']}"
+                                }
+                            })
+                
+                formatted.append({"role": msg["role"], "content": formatted_content})
+                
+        return None, formatted

llm_dialog_manager/formatters/x.py

@@ -0,0 +1,77 @@
+"""
+Message formatter for X.AI (Grok) models
+"""
+from typing import List, Dict, Union, Optional
+from PIL import Image
+import io
+import base64
+
+from .base import BaseMessageFormatter
+
+class XFormatter(BaseMessageFormatter):
+    """Formatter for X.AI (Grok) API messages"""
+    
+    def format_messages(self, messages: List[Dict[str, Union[str, List[Union[str, Image.Image, Dict]]]]]) -> tuple:
+        """
+        Format messages for the X.AI (Grok) API.
+        
+        Args:
+            messages: List of message dictionaries in standard format
+            
+        Returns:
+            A tuple containing (system_message, formatted_messages)
+        """
+        system_msg = None
+        formatted = []
+        
+        for msg in messages:
+            # Extract system message if present, similar to many other APIs
+            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"], "content": content})
+            elif isinstance(content, list):
+                # Grok API format may need adjustments as it evolves
+                combined_content = []
+                
+                for block in content:
+                    if isinstance(block, str):
+                        combined_content.append({"type": "text", "text": block})
+                    elif isinstance(block, Image.Image):
+                        # 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",
+                            "image": {
+                                "type": "base64",
+                                "media_type": "image/png",
+                                "data": image_base64
+                            }
+                        })
+                    elif isinstance(block, dict):
+                        if block.get("type") == "image_url":
+                            combined_content.append({
+                                "type": "image",
+                                "image": {
+                                    "type": "url",
+                                    "url": block["image_url"]["url"]
+                                }
+                            })
+                        elif block.get("type") == "image_base64":
+                            combined_content.append({
+                                "type": "image",
+                                "image": {
+                                    "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/utils/__init__.py

@@ -0,0 +1,3 @@
+"""
+Utility modules for the LLM dialog manager.
+"""

llm_dialog_manager/utils/environment.py

@@ -0,0 +1,66 @@
+"""
+Environment utilities for LLM Dialog Manager
+"""
+import os
+import logging
+from pathlib import Path
+from dotenv import load_dotenv
+
+logger = logging.getLogger(__name__)
+
+def load_env_vars(env_path=None):
+    """
+    Load environment variables from .env file.
+    
+    Args:
+        env_path: Optional path to .env file
+    
+    Returns:
+        True if env vars were loaded, False otherwise
+    """
+    try:
+        # Default to .env in the current directory or parent directory
+        if not env_path:
+            if os.path.exists(".env"):
+                env_path = ".env"
+            elif os.path.exists("../.env"):
+                env_path = "../.env"
+            else:
+                # Try to find .env in parent directories
+                current_dir = Path.cwd()
+                for parent in current_dir.parents:
+                    potential_path = parent / ".env"
+                    if potential_path.exists():
+                        env_path = str(potential_path)
+                        break
+        
+        if env_path and os.path.exists(env_path):
+            load_dotenv(env_path)
+            logger.info(f"Loaded environment variables from {env_path}")
+            
+            # Log detected providers without showing sensitive data
+            providers = []
+            if os.getenv("OPENAI_API_KEY"):
+                providers.append("OpenAI")
+            if os.getenv("ANTHROPIC_API_KEY"):
+                providers.append("Anthropic")
+            if os.getenv("AWS_ACCESS_KEY_ID") and os.getenv("AWS_SECRET_ACCESS_KEY"):
+                providers.append("AWS Bedrock (for anthropic.* models)")
+            if os.getenv("VERTEX_PROJECT_ID") and os.getenv("VERTEX_REGION"):
+                providers.append("Anthropic Vertex")
+            if os.getenv("GEMINI_API_KEY"):
+                providers.append("Google Gemini")
+            if os.getenv("XAI_API_KEY"):
+                providers.append("X.AI Grok")
+            
+            if providers:
+                logger.info(f"Detected LLM providers: {', '.join(providers)}")
+            
+            return True
+        else:
+            logger.warning(f"Environment file not found: {env_path}")
+            return False
+    
+    except Exception as e:
+        logger.error(f"Error loading environment variables: {e}")
+        return False

llm_dialog_manager/utils/image_tools.py

@@ -0,0 +1,81 @@
+"""
+Image handling utilities for LLM dialog manager
+"""
+import base64
+import io
+from typing import Optional
+import requests
+from PIL import Image
+
+def load_image_from_path(image_path: str) -> Image.Image:
+    """
+    Load an image from a local file path.
+    
+    Args:
+        image_path: Path to the local image file
+        
+    Returns:
+        PIL.Image object
+    """
+    try:
+        image = Image.open(image_path)
+        # Store the filename for reference
+        image.filename = image_path
+        return image
+    except Exception as e:
+        raise ValueError(f"Failed to load image from {image_path}: {e}")
+
+def load_image_from_url(image_url: str) -> Image.Image:
+    """
+    Load an image from a URL.
+    
+    Args:
+        image_url: URL to the image
+        
+    Returns:
+        PIL.Image object
+    """
+    try:
+        response = requests.get(image_url, stream=True)
+        response.raise_for_status()
+        image = Image.open(io.BytesIO(response.content))
+        # Store the URL for reference
+        image.filename = image_url
+        return image
+    except Exception as e:
+        raise ValueError(f"Failed to load image from {image_url}: {e}")
+
+def encode_image_to_base64(image: Image.Image, format: str = "PNG") -> str:
+    """
+    Convert a PIL.Image to base64 string.
+    
+    Args:
+        image: PIL.Image object
+        format: Image format (default: PNG)
+        
+    Returns:
+        Base64-encoded string
+    """
+    buffered = io.BytesIO()
+    image.save(buffered, format=format)
+    return base64.b64encode(buffered.getvalue()).decode("utf-8")
+
+def create_image_content_block(image: Image.Image, media_type: str = "image/png") -> dict:
+    """
+    Create a standard image content block for messages.
+    
+    Args:
+        image: PIL.Image object
+        media_type: MIME type of the image
+        
+    Returns:
+        Dictionary with image information
+    """
+    image_base64 = encode_image_to_base64(image)
+    return {
+        "type": "image_base64",
+        "image_base64": {
+            "media_type": media_type,
+            "data": image_base64
+        }
+    }

llm_dialog_manager/utils/logging.py

@@ -0,0 +1,35 @@
+"""
+Logging configuration utilities
+"""
+import logging
+import sys
+
+def setup_logging(level=logging.INFO, log_file=None):
+    """
+    Configure logging for the application.
+    
+    Args:
+        level: Logging level (default: INFO)
+        log_file: Optional file path to write logs to
+    """
+    # Create logger
+    logger = logging.getLogger('llm_dialog_manager')
+    logger.setLevel(level)
+    
+    # Create formatter
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    
+    # Create console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(level)
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+    
+    # Create file handler if log_file specified
+    if log_file:
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setLevel(level)
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+    
+    return logger

{llm_dialog_manager-0.5.0.dist-info → llm_dialog_manager-0.5.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: llm_dialog_manager
-Version: 0.5.0
+Version: 0.5.3
 Summary: A Python package for managing LLM chat conversation history
 Author-email: xihajun <work@2333.fun>
 License: MIT

llm_dialog_manager-0.5.3.dist-info/RECORD

@@ -0,0 +1,25 @@
+llm_dialog_manager/__init__.py,sha256=T4hzIO_4IANFIcjmF0iEJ-_h7LR1_AT13kj5dc3hH-I,463
+llm_dialog_manager/agent.py,sha256=Am2p9fClcHC75_Yjz6b1bof_KeUYmJocATQIQ-KKcr0,6472
+llm_dialog_manager/chat_history.py,sha256=DKKRnj_M6h-4JncnH6KekMTghX7vMgdN3J9uOwXKzMU,10347
+llm_dialog_manager/key_manager.py,sha256=shvxmn4zUtQx_p-x1EFyOmnk-WlhigbpKtxTKve-zXk,4421
+llm_dialog_manager/clients/__init__.py,sha256=f8NFm-9bXUJUrFy37FxpJlyyCqVwHPu3VUtfNdKUVmE,1114
+llm_dialog_manager/clients/anthropic_client.py,sha256=5Zqyosoy60JkWI0cjQAxJ9Uk4bcqHrVEXkauEfC8Egs,5404
+llm_dialog_manager/clients/base.py,sha256=hSkuLLKrdyoKMCRpPav5qbsKLaJLQ9gtMDSxxdAHdII,2107
+llm_dialog_manager/clients/gemini_client.py,sha256=AwIVJubdawrNa4DobCKE0KdtwuLU5XzmOtN_I-SzStY,2540
+llm_dialog_manager/clients/openai_client.py,sha256=8glZbLaUQw2gftOgMeV0TN6aTJ--2LuRxn7wiCK8K4Q,3266
+llm_dialog_manager/clients/x_client.py,sha256=rTaEU9NWTws2XIqfNQt1vysT_fdhWCMAGpfF1onMU6c,2688
+llm_dialog_manager/formatters/__init__.py,sha256=LdvQOhkGbF5_iT7Lu6kTssXKRXtuQTq9LluK4CSplws,787
+llm_dialog_manager/formatters/anthropic.py,sha256=0xFDooeEYq4DO1RWiGxbhuiL_DwtDdUNLEuiJyXbQnQ,3247
+llm_dialog_manager/formatters/base.py,sha256=YBpnfR4Pc7-P4TbCVNe4Q6pOUq9mXwQQR1U9X1NSmwE,711
+llm_dialog_manager/formatters/gemini.py,sha256=im-ZPGOkwDiWcgDFC2d0owKmpdKJ9wiLh5treoV2E-4,2425
+llm_dialog_manager/formatters/openai.py,sha256=i6AAORyEkjRQwXAf9QkKBIxZGtD7a2k0CvcPbilSjBQ,2807
+llm_dialog_manager/formatters/x.py,sha256=qxZdidngZUDp0DazYbolye9BnjsL8MMniLVdlaJ_uik,3248
+llm_dialog_manager/utils/__init__.py,sha256=ta2BdLF2CSzlbk5ZwArzar4E7eip4reQjMAncvY7qhQ,52
+llm_dialog_manager/utils/environment.py,sha256=8jRTe1_JL24Wz4SdX968XKx8vJMA4-NrZtHhXv-9PJM,2322
+llm_dialog_manager/utils/image_tools.py,sha256=Q23gpY-JY0MIGOVWnLl-QS2IrpCMBiyzn2Zu0dWov1c,2110
+llm_dialog_manager/utils/logging.py,sha256=38E_k3OSz7CNFg3ZsildR7IMtn3CzWro7IRY-Sj7dcc,989
+llm_dialog_manager-0.5.3.dist-info/licenses/LICENSE,sha256=vWGbYgGuWpWrXL8-xi6pNcX5UzD6pWoIAZmcetyfbus,1064
+llm_dialog_manager-0.5.3.dist-info/METADATA,sha256=sUFwt6A0CwO5hGGf6iAgctBJwm2T6-CVG2hhWHBU2hk,4236
+llm_dialog_manager-0.5.3.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+llm_dialog_manager-0.5.3.dist-info/top_level.txt,sha256=u2EQEXW0NGAt0AAHT7jx1odXZ4rZfjcgbmJhvKFuMkI,19
+llm_dialog_manager-0.5.3.dist-info/RECORD,,

llm_dialog_manager-0.5.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-llm_dialog_manager/__init__.py,sha256=npNlH7E4TPUhiX5WNGa-OGwXx38OJ3ofZ6lh5f399Kk,463
-llm_dialog_manager/agent.py,sha256=Am2p9fClcHC75_Yjz6b1bof_KeUYmJocATQIQ-KKcr0,6472
-llm_dialog_manager/chat_history.py,sha256=DKKRnj_M6h-4JncnH6KekMTghX7vMgdN3J9uOwXKzMU,10347
-llm_dialog_manager/key_manager.py,sha256=shvxmn4zUtQx_p-x1EFyOmnk-WlhigbpKtxTKve-zXk,4421
-llm_dialog_manager-0.5.0.dist-info/licenses/LICENSE,sha256=vWGbYgGuWpWrXL8-xi6pNcX5UzD6pWoIAZmcetyfbus,1064
-llm_dialog_manager-0.5.0.dist-info/METADATA,sha256=L-bvieVTyqHeCtxtKeQtHUZ-5vwT8_4XAVsAorNLxLA,4236
-llm_dialog_manager-0.5.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-llm_dialog_manager-0.5.0.dist-info/top_level.txt,sha256=u2EQEXW0NGAt0AAHT7jx1odXZ4rZfjcgbmJhvKFuMkI,19
-llm_dialog_manager-0.5.0.dist-info/RECORD,,