llm-dialog-manager 0.4.7__tar.gz → 0.5.3__tar.gz

{llm_dialog_manager-0.4.7 → llm_dialog_manager-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: llm_dialog_manager
-Version: 0.4.7
+Version: 0.5.3
 Summary: A Python package for managing LLM chat conversation history
 Author-email: xihajun <work@2333.fun>
 License: MIT
@@ -103,7 +103,7 @@ XAI_API_KEY=your-x-key
 from llm_dialog_manager import Agent
 
 # Initialize an agent with a specific model
-agent = Agent("claude-2.1", memory_enabled=True)
+agent = Agent("ep-20250319212209-j6tfj-openai", memory_enabled=True)
 
 # Add messages and generate responses
 agent.add_message("system", "You are a helpful assistant")

{llm_dialog_manager-0.4.7 → llm_dialog_manager-0.5.3}/README.md

@@ -55,7 +55,7 @@ XAI_API_KEY=your-x-key
 from llm_dialog_manager import Agent
 
 # Initialize an agent with a specific model
-agent = Agent("claude-2.1", memory_enabled=True)
+agent = Agent("ep-20250319212209-j6tfj-openai", memory_enabled=True)
 
 # Add messages and generate responses
 agent.add_message("system", "You are a helpful assistant")

llm_dialog_manager-0.5.3/llm_dialog_manager/__init__.py

@@ -0,0 +1,20 @@
+"""
+LLM Dialog Manager
+
+A modular framework for building conversational AI applications with
+support for multiple LLM providers.
+"""
+
+__version__ = "0.5.3"
+
+from .agent import Agent
+from .chat_history import ChatHistory
+from .key_manager import key_manager
+
+# Import factory functions for easy access
+from .clients import get_client
+from .formatters import get_formatter
+
+# Setup environment by default
+from .utils.environment import load_env_vars
+load_env_vars()

llm_dialog_manager-0.5.3/llm_dialog_manager/agent.py

@@ -0,0 +1,189 @@
+"""
+Agent class for managing LLM conversations
+"""
+# Standard library imports
+import uuid
+import logging
+from typing import List, Dict, Optional, Union
+from PIL import Image
+
+# Local imports
+from .chat_history import ChatHistory
+from .clients import get_client
+from .utils.environment import load_env_vars
+from .utils.image_tools import load_image_from_path, load_image_from_url, create_image_content_block
+
+# Setup logging
+logger = logging.getLogger(__name__)
+
+# Load environment variables
+load_env_vars()
+
+class Agent:
+    """
+    Agent class for managing conversations with LLMs.
+    
+    This class provides a high-level interface for interacting with different
+    LLM providers through a unified API.
+    """
+    
+    def __init__(self, model_name: str, 
+                 messages: Optional[Union[str, List[Dict[str, Union[str, List[Union[str, Image.Image, Dict]]]]]]] = None, 
+                 memory_enabled: bool = False, 
+                 api_key: Optional[str] = None,
+                 base_url: Optional[str] = None) -> None:
+        """
+        Initialize an Agent instance.
+        
+        Args:
+            model_name: Name of the LLM model to use
+            messages: Optional initial messages or system prompt
+            memory_enabled: Whether to enable conversation memory
+            api_key: Optional API key to use
+            base_url: Optional base URL for API requests
+        """
+        self.id = f"{model_name}-{uuid.uuid4().hex[:8]}"
+        self.model_name = model_name
+        self.history = ChatHistory(messages) if messages else ChatHistory()
+        self.memory_enabled = memory_enabled
+        self.client = get_client(model_name, api_key=api_key, base_url=base_url)
+        self.repo_content = []
+    
+    def add_message(self, role: str, content: Union[str, List[Union[str, Image.Image, Dict]]]):
+        """
+        Add a message to the conversation.
+        
+        Args:
+            role: Message role ('system', 'user', or 'assistant')
+            content: Message content (text, image, or mixed content)
+        """
+        self.history.add_message(content, role)
+    
+    def add_user_message(self, content: Union[str, List[Union[str, Image.Image, Dict]]]):
+        """
+        Add a user message to the conversation.
+        
+        Args:
+            content: Message content (text, image, or mixed content)
+        """
+        self.history.add_user_message(content)
+    
+    def add_assistant_message(self, content: Union[str, List[Union[str, Image.Image, Dict]]]):
+        """
+        Add an assistant message to the conversation.
+        
+        Args:
+            content: Message content (text, image, or mixed content)
+        """
+        self.history.add_assistant_message(content)
+    
+    def add_image(self, image_path: Optional[str] = None, 
+                 image_url: Optional[str] = None, 
+                 media_type: Optional[str] = "image/jpeg"):
+        """
+        Add an image to the conversation.
+        
+        Either image_path or image_url must be provided.
+        
+        Args:
+            image_path: Path to a local image file
+            image_url: URL of an image
+            media_type: MIME type of the image
+        
+        Returns:
+            The image content block that was added
+        """
+        if not (image_path or image_url):
+            raise ValueError("Either image_path or image_url must be provided.")
+        
+        if image_path:
+            image = load_image_from_path(image_path)
+        else:
+            image = load_image_from_url(image_url)
+        
+        return create_image_content_block(image, media_type)
+    
+    def generate_response(self, max_tokens=3585, temperature=0.7, 
+                         top_p=1.0, top_k=40, json_format=False, **kwargs):
+        """
+        Generate a response from the agent.
+        
+        Args:
+            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 enable JSON output format
+            **kwargs: Additional model-specific parameters
+        
+        Returns:
+            The generated response text
+        """
+        response = self.client.completion(
+            messages=self.history.messages,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            top_p=top_p,
+            top_k=top_k,
+            json_format=json_format,
+            model=self.model_name,
+            **kwargs
+        )
+        
+        # Add the response to history
+        if not json_format:
+            self.add_assistant_message(response)
+        
+        return response
+    
+    def save_conversation(self, filename=None):
+        """
+        Save the conversation history to a file.
+        
+        Args:
+            filename: Optional filename to save to
+        """
+        if filename is None:
+            filename = f"conversation_{self.id}.json"
+        
+        import json
+        
+        # Convert any PIL.Image objects to base64 for serialization
+        serializable_history = []
+        for msg in self.history.messages:
+            role = msg["role"]
+            content = msg["content"]
+            
+            if isinstance(content, str):
+                serializable_history.append({"role": role, "content": content})
+            elif isinstance(content, list):
+                serializable_content = []
+                for item in content:
+                    if isinstance(item, str):
+                        serializable_content.append(item)
+                    elif isinstance(item, Image.Image):
+                        serializable_content.append(create_image_content_block(item))
+                    elif isinstance(item, dict):
+                        serializable_content.append(item)
+                serializable_history.append({"role": role, "content": serializable_content})
+        
+        with open(filename, 'w') as f:
+            json.dump(serializable_history, f, indent=2)
+        
+        return filename
+    
+    def load_conversation(self, filename):
+        """
+        Load a conversation from a file.
+        
+        Args:
+            filename: Path to the conversation file
+        """
+        import json
+        
+        with open(filename, 'r') as f:
+            history = json.load(f)
+        
+        self.history = ChatHistory(history)
+        
+        return self.history

llm_dialog_manager-0.5.3/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-0.5.3/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-0.5.3/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-0.5.3/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-0.5.3/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