genxai-framework 0.1.0__py3-none-any.whl

genxai/llm/providers/openai.py

@@ -0,0 +1,257 @@
+"""OpenAI LLM provider implementation."""
+
+from typing import Any, Dict, Optional, AsyncIterator
+import os
+import logging
+
+from genxai.llm.base import LLMProvider, LLMResponse
+
+logger = logging.getLogger(__name__)
+
+
+class OpenAIProvider(LLMProvider):
+    """OpenAI LLM provider."""
+
+    def __init__(
+        self,
+        model: str = "gpt-4",
+        api_key: Optional[str] = None,
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize OpenAI provider.
+
+        Args:
+            model: Model name (gpt-4, gpt-3.5-turbo, etc.)
+            api_key: OpenAI API key (defaults to OPENAI_API_KEY env var)
+            temperature: Sampling temperature
+            max_tokens: Maximum tokens to generate
+            **kwargs: Additional OpenAI-specific parameters
+        """
+        super().__init__(model, temperature, max_tokens, **kwargs)
+
+        # Tests expect OpenAIProvider() with no args to raise, even if a global
+        # OPENAI_API_KEY is present in the environment.
+        if api_key is None:
+            raise ValueError(
+                "api_key is required when instantiating OpenAIProvider directly"
+            )
+
+        self.api_key = api_key
+        
+        self._client: Optional[Any] = None
+        self._initialize_client()
+
+    def _initialize_client(self) -> None:
+        """Initialize OpenAI client."""
+        try:
+            from openai import AsyncOpenAI
+            self._client = AsyncOpenAI(api_key=self.api_key)
+            logger.info(f"OpenAI client initialized with model: {self.model}")
+        except ImportError:
+            logger.error(
+                "OpenAI package not installed. Install with: pip install openai"
+            )
+            self._client = None
+        except Exception as e:
+            logger.error(f"Failed to initialize OpenAI client: {e}")
+            self._client = None
+
+    async def generate(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        **kwargs: Any,
+    ) -> LLMResponse:
+        """Generate completion using OpenAI.
+
+        Args:
+            prompt: User prompt
+            system_prompt: System prompt
+            **kwargs: Additional generation parameters
+
+        Returns:
+            LLM response
+
+        Raises:
+            RuntimeError: If client not initialized
+            Exception: If API call fails
+        """
+        if not self._client:
+            raise RuntimeError("OpenAI client not initialized")
+
+        # Build messages
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        messages.append({"role": "user", "content": prompt})
+
+        # Merge parameters
+        params = {
+            "model": self.model,
+            "messages": messages,
+            "temperature": kwargs.get("temperature", self.temperature),
+        }
+        
+        if self.max_tokens:
+            params["max_tokens"] = kwargs.get("max_tokens", self.max_tokens)
+
+        # Tool calling parameters
+        if "tools" in kwargs:
+            params["tools"] = kwargs["tools"]
+        if "tool_choice" in kwargs:
+            params["tool_choice"] = kwargs["tool_choice"]
+
+        # Add additional parameters
+        for key in ["top_p", "frequency_penalty", "presence_penalty", "stop"]:
+            if key in kwargs:
+                params[key] = kwargs[key]
+
+        try:
+            logger.debug(f"Calling OpenAI API with model: {self.model}")
+            response = await self._client.chat.completions.create(**params)
+
+            # Extract response
+            message = response.choices[0].message
+            content = message.content or ""
+            finish_reason = response.choices[0].finish_reason
+
+            # Extract usage
+            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,
+            }
+
+            # Update stats
+            self._update_stats(usage)
+
+            return LLMResponse(
+                content=content,
+                model=response.model,
+                usage=usage,
+                finish_reason=finish_reason,
+                metadata={
+                    "response_id": response.id,
+                    "tool_calls": message.tool_calls if hasattr(message, "tool_calls") else None,
+                },
+            )
+
+        except Exception as e:
+            logger.error(f"OpenAI API call failed: {e}")
+            raise
+
+    async def generate_stream(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[str]:
+        """Generate completion with streaming.
+
+        Args:
+            prompt: User prompt
+            system_prompt: System prompt
+            **kwargs: Additional generation parameters
+
+        Yields:
+            Content chunks
+
+        Raises:
+            RuntimeError: If client not initialized
+        """
+        if not self._client:
+            raise RuntimeError("OpenAI client not initialized")
+
+        # Build messages
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        messages.append({"role": "user", "content": prompt})
+
+        # Merge parameters
+        params = {
+            "model": self.model,
+            "messages": messages,
+            "temperature": kwargs.get("temperature", self.temperature),
+            "stream": True,
+        }
+        
+        if self.max_tokens:
+            params["max_tokens"] = kwargs.get("max_tokens", self.max_tokens)
+
+        try:
+            logger.debug(f"Streaming from OpenAI API with model: {self.model}")
+            stream = await self._client.chat.completions.create(**params)
+
+            async for chunk in stream:
+                if chunk.choices[0].delta.content:
+                    yield chunk.choices[0].delta.content
+
+        except Exception as e:
+            logger.error(f"OpenAI streaming failed: {e}")
+            raise
+
+    async def generate_chat(
+        self,
+        messages: list[Dict[str, str]],
+        **kwargs: Any,
+    ) -> LLMResponse:
+        """Generate completion for chat messages.
+
+        Args:
+            messages: List of message dictionaries
+            **kwargs: Additional generation parameters
+
+        Returns:
+            LLM response
+        """
+        if not self._client:
+            raise RuntimeError("OpenAI client not initialized")
+
+        # Merge parameters
+        params = {
+            "model": self.model,
+            "messages": messages,
+            "temperature": kwargs.get("temperature", self.temperature),
+        }
+        
+        if self.max_tokens:
+            params["max_tokens"] = kwargs.get("max_tokens", self.max_tokens)
+
+        # Tool calling parameters
+        if "tools" in kwargs:
+            params["tools"] = kwargs["tools"]
+        if "tool_choice" in kwargs:
+            params["tool_choice"] = kwargs["tool_choice"]
+
+        try:
+            response = await self._client.chat.completions.create(**params)
+
+            message = response.choices[0].message
+            content = message.content or ""
+            finish_reason = response.choices[0].finish_reason
+
+            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,
+            }
+
+            self._update_stats(usage)
+
+            return LLMResponse(
+                content=content,
+                model=response.model,
+                usage=usage,
+                finish_reason=finish_reason,
+                metadata={
+                    "response_id": response.id,
+                    "tool_calls": message.tool_calls if hasattr(message, "tool_calls") else None,
+                },
+            )
+
+        except Exception as e:
+            logger.error(f"OpenAI chat API call failed: {e}")
+            raise

genxai/llm/routing.py

@@ -0,0 +1,83 @@
+"""Routing wrapper for LLM providers with fallback support."""
+
+from __future__ import annotations
+
+from typing import Any, AsyncIterator, Iterable, List, Optional
+import logging
+
+from genxai.llm.base import LLMProvider, LLMResponse
+
+logger = logging.getLogger(__name__)
+
+
+class RoutedLLMProvider(LLMProvider):
+    """LLM provider wrapper that routes requests through fallback providers."""
+
+    def __init__(
+        self,
+        primary: LLMProvider,
+        fallbacks: Optional[Iterable[LLMProvider]] = None,
+    ) -> None:
+        self._primary = primary
+        self._fallbacks = list(fallbacks or [])
+        super().__init__(
+            model=primary.model,
+            temperature=primary.temperature,
+            max_tokens=primary.max_tokens,
+        )
+
+    @property
+    def providers(self) -> List[LLMProvider]:
+        return [self._primary, *self._fallbacks]
+
+    async def generate(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        **kwargs: Any,
+    ) -> LLMResponse:
+        last_error: Optional[Exception] = None
+        for provider in self.providers:
+            try:
+                response = await provider.generate(
+                    prompt=prompt,
+                    system_prompt=system_prompt,
+                    **kwargs,
+                )
+                self._update_stats(response.usage)
+                return response
+            except Exception as exc:
+                last_error = exc
+                logger.warning(
+                    "Provider %s failed; attempting fallback: %s",
+                    provider,
+                    exc,
+                )
+                continue
+        raise RuntimeError("All LLM providers failed") from last_error
+
+    async def generate_stream(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[str]:
+        last_error: Optional[Exception] = None
+        for provider in self.providers:
+            try:
+                async for chunk in provider.generate_stream(
+                    prompt=prompt,
+                    system_prompt=system_prompt,
+                    **kwargs,
+                ):
+                    yield chunk
+                return
+            except Exception as exc:
+                last_error = exc
+                logger.warning(
+                    "Streaming provider %s failed; attempting fallback: %s",
+                    provider,
+                    exc,
+                )
+                continue
+        raise RuntimeError("All LLM providers failed for streaming") from last_error

genxai/observability/__init__.py

@@ -0,0 +1,6 @@
+"""Observability system for GenXAI."""
+
+from genxai.observability.logging import setup_logging, get_logger
+from genxai.observability.metrics import MetricsCollector
+
+__all__ = ["setup_logging", "get_logger", "MetricsCollector"]

genxai/observability/logging.py

@@ -0,0 +1,327 @@
+"""Structured logging for GenXAI."""
+
+import json
+import logging
+import sys
+from contextvars import ContextVar
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+
+_request_id_ctx: ContextVar[Optional[str]] = ContextVar("genxai_request_id", default=None)
+_workflow_id_ctx: ContextVar[Optional[str]] = ContextVar("genxai_workflow_id", default=None)
+_agent_id_ctx: ContextVar[Optional[str]] = ContextVar("genxai_agent_id", default=None)
+
+
+def set_log_context(
+    *,
+    request_id: Optional[str] = None,
+    workflow_id: Optional[str] = None,
+    agent_id: Optional[str] = None,
+) -> None:
+    """Set context values for structured logging.
+
+    Args:
+        request_id: Request identifier
+        workflow_id: Workflow identifier
+        agent_id: Agent identifier
+    """
+    if request_id is not None:
+        _request_id_ctx.set(request_id)
+    if workflow_id is not None:
+        _workflow_id_ctx.set(workflow_id)
+    if agent_id is not None:
+        _agent_id_ctx.set(agent_id)
+
+
+def clear_log_context() -> None:
+    """Clear logging context values."""
+    _request_id_ctx.set(None)
+    _workflow_id_ctx.set(None)
+    _agent_id_ctx.set(None)
+
+
+def get_log_context() -> Dict[str, Optional[str]]:
+    """Get current logging context values."""
+    return {
+        "request_id": _request_id_ctx.get(),
+        "workflow_id": _workflow_id_ctx.get(),
+        "agent_id": _agent_id_ctx.get(),
+    }
+
+
+class StructuredFormatter(logging.Formatter):
+    """Structured JSON formatter for logs."""
+
+    def format(self, record: logging.LogRecord) -> str:
+        """Format log record as JSON.
+
+        Args:
+            record: Log record
+
+        Returns:
+            JSON formatted log string
+        """
+        log_data = {
+            "timestamp": datetime.fromtimestamp(record.created).isoformat(),
+            "level": record.levelname,
+            "logger": record.name,
+            "message": record.getMessage(),
+            "module": record.module,
+            "function": record.funcName,
+            "line": record.lineno,
+        }
+
+        # Add contextual identifiers
+        log_data.update(get_log_context())
+
+        # Add exception info if present
+        if record.exc_info:
+            log_data["exception"] = self.formatException(record.exc_info)
+
+        # Add extra fields
+        if hasattr(record, "extra"):
+            log_data["extra"] = record.extra
+
+        return json.dumps(log_data)
+
+
+def setup_logging(
+    level: str = "INFO",
+    structured: bool = False,
+    log_file: Optional[str] = None,
+    redact_sensitive: bool = True,
+) -> None:
+    """Set up logging configuration.
+
+    Args:
+        level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        structured: Use structured JSON logging
+        log_file: Optional log file path
+    """
+    # Create formatter
+    if structured:
+        formatter = StructuredFormatter()
+    else:
+        formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+
+    # Console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(formatter)
+    if redact_sensitive:
+        console_handler.addFilter(SensitiveDataFilter())
+
+    # Configure root logger
+    root_logger = logging.getLogger()
+    root_logger.setLevel(getattr(logging, level.upper()))
+    root_logger.addHandler(console_handler)
+
+    # File handler if specified
+    if log_file:
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setFormatter(formatter)
+        if redact_sensitive:
+            file_handler.addFilter(SensitiveDataFilter())
+        root_logger.addHandler(file_handler)
+
+    logging.info(f"Logging configured: level={level}, structured={structured}")
+
+
+def get_logger(name: str, extra: Optional[Dict[str, Any]] = None) -> logging.Logger:
+    """Get a logger with optional extra context.
+
+    Args:
+        name: Logger name
+        extra: Extra context to include in logs
+
+    Returns:
+        Configured logger
+    """
+    base_logger = logging.getLogger(name)
+
+    if extra:
+        # Create adapter with extra context
+        return logging.LoggerAdapter(base_logger, extra)
+
+    return base_logger
+
+
+class LogContext:
+    """Context manager for adding context to logs."""
+
+    def __init__(self, logger: logging.Logger, **context: Any) -> None:
+        """Initialize log context.
+
+        Args:
+            logger: Logger instance
+            **context: Context key-value pairs
+        """
+        self.logger = logger
+        self.context = context
+        self.old_factory = None
+
+    def __enter__(self) -> logging.Logger:
+        """Enter context."""
+        self.old_factory = logging.getLogRecordFactory()
+
+        def record_factory(*args: Any, **kwargs: Any) -> logging.LogRecord:
+            record = self.old_factory(*args, **kwargs)
+            record.extra = self.context
+            return record
+
+        logging.setLogRecordFactory(record_factory)
+        return self.logger
+
+    def __exit__(self, *args: Any) -> None:
+        """Exit context."""
+        if self.old_factory:
+            logging.setLogRecordFactory(self.old_factory)
+
+
+class SensitiveDataFilter(logging.Filter):
+    """Filter to redact sensitive data from logs."""
+    
+    SENSITIVE_PATTERNS = [
+        (r'api[_-]?key["\']?\s*[:=]\s*["\']?([^"\'\\s]+)', 'api_key=***REDACTED***'),
+        (r'password["\']?\s*[:=]\s*["\']?([^"\'\\s]+)', 'password=***REDACTED***'),
+        (r'token["\']?\s*[:=]\s*["\']?([^"\'\\s]+)', 'token=***REDACTED***'),
+        (r'secret["\']?\s*[:=]\s*["\']?([^"\'\\s]+)', 'secret=***REDACTED***'),
+        (r'authorization["\']?\s*[:=]\s*["\']?([^"\'\\s]+)', 'authorization=***REDACTED***'),
+    ]
+    
+    def filter(self, record: logging.LogRecord) -> bool:
+        """Filter and redact sensitive data.
+        
+        Args:
+            record: Log record
+            
+        Returns:
+            True to keep the record
+        """
+        import re
+        
+        message = record.getMessage()
+        
+        for pattern, replacement in self.SENSITIVE_PATTERNS:
+            message = re.sub(pattern, replacement, message, flags=re.IGNORECASE)
+        
+        record.msg = message
+        record.args = ()
+        
+        return True
+
+
+class StructuredLogger:
+    """Structured JSON logger with context."""
+    
+    def __init__(self, name: str):
+        """Initialize structured logger.
+        
+        Args:
+            name: Logger name
+        """
+        self.logger = logging.getLogger(name)
+        self.context: Dict[str, Any] = {}
+    
+    def add_context(self, **kwargs: Any) -> None:
+        """Add context to all log messages.
+        
+        Args:
+            **kwargs: Context key-value pairs
+        """
+        self.context.update(kwargs)
+    
+    def clear_context(self) -> None:
+        """Clear all context."""
+        self.context.clear()
+    
+    def _format_message(self, level: str, message: str, **kwargs: Any) -> str:
+        """Format log message as JSON.
+        
+        Args:
+            level: Log level
+            message: Log message
+            **kwargs: Additional fields
+            
+        Returns:
+            JSON formatted log string
+        """
+        log_entry = {
+            "timestamp": datetime.utcnow().isoformat(),
+            "level": level,
+            "message": message,
+            "context": {**get_log_context(), **self.context},
+            **kwargs
+        }
+        return json.dumps(log_entry)
+    
+    def debug(self, message: str, **kwargs: Any) -> None:
+        """Log debug message.
+        
+        Args:
+            message: Log message
+            **kwargs: Additional fields
+        """
+        self.logger.debug(self._format_message("DEBUG", message, **kwargs))
+    
+    def info(self, message: str, **kwargs: Any) -> None:
+        """Log info message.
+        
+        Args:
+            message: Log message
+            **kwargs: Additional fields
+        """
+        self.logger.info(self._format_message("INFO", message, **kwargs))
+    
+    def warning(self, message: str, **kwargs: Any) -> None:
+        """Log warning message.
+        
+        Args:
+            message: Log message
+            **kwargs: Additional fields
+        """
+        self.logger.warning(self._format_message("WARNING", message, **kwargs))
+    
+    def error(self, message: str, **kwargs: Any) -> None:
+        """Log error message.
+        
+        Args:
+            message: Log message
+            **kwargs: Additional fields
+        """
+        self.logger.error(self._format_message("ERROR", message, **kwargs))
+    
+    def critical(self, message: str, **kwargs: Any) -> None:
+        """Log critical message.
+        
+        Args:
+            message: Log message
+            **kwargs: Additional fields
+        """
+        self.logger.critical(self._format_message("CRITICAL", message, **kwargs))
+    
+    def exception(self, message: str, **kwargs: Any) -> None:
+        """Log exception with traceback.
+        
+        Args:
+            message: Log message
+            **kwargs: Additional fields
+        """
+        import traceback
+        kwargs["traceback"] = traceback.format_exc()
+        self.logger.error(self._format_message("ERROR", message, **kwargs))
+
+
+def get_structured_logger(name: str) -> StructuredLogger:
+    """Get a structured logger instance.
+    
+    Args:
+        name: Logger name
+        
+    Returns:
+        StructuredLogger instance
+    """
+    return StructuredLogger(name)