aiecs 1.0.1__py3-none-any.whl → 1.7.17__py3-none-any.whl

aiecs/llm/base_client.py

@@ -1,99 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Dict, Any, Optional, List, AsyncGenerator
-from dataclasses import dataclass
-import time
-import logging
-
-logger = logging.getLogger(__name__)
-
-@dataclass
-class LLMMessage:
-    role: str  # "system", "user", "assistant"
-    content: str
-
-@dataclass
-class LLMResponse:
-    content: str
-    provider: str
-    model: str
-    tokens_used: Optional[int] = None
-    prompt_tokens: Optional[int] = None
-    completion_tokens: Optional[int] = None
-    cost_estimate: Optional[float] = None
-    response_time: Optional[float] = None
-
-    def __post_init__(self):
-        """Ensure consistency of token data"""
-        # If there are detailed token information but no total, calculate the total
-        if self.prompt_tokens is not None and self.completion_tokens is not None and self.tokens_used is None:
-            self.tokens_used = self.prompt_tokens + self.completion_tokens
-
-        # If only total is available but no detailed information, try to estimate (cannot accurately allocate in this case)
-        elif self.tokens_used is not None and self.prompt_tokens is None and self.completion_tokens is None:
-            # In this case we cannot accurately allocate, keep as is
-            pass
-
-class LLMClientError(Exception):
-    """Base exception for LLM client errors"""
-    pass
-
-class ProviderNotAvailableError(LLMClientError):
-    """Raised when a provider is not available or misconfigured"""
-    pass
-
-class RateLimitError(LLMClientError):
-    """Raised when rate limit is exceeded"""
-    pass
-
-class BaseLLMClient(ABC):
-    """Abstract base class for all LLM provider clients"""
-
-    def __init__(self, provider_name: str):
-        self.provider_name = provider_name
-        self.logger = logging.getLogger(f"{__name__}.{provider_name}")
-
-    @abstractmethod
-    async def generate_text(
-        self,
-        messages: List[LLMMessage],
-        model: Optional[str] = None,
-        temperature: float = 0.7,
-        max_tokens: Optional[int] = None,
-        **kwargs
-    ) -> LLMResponse:
-        """Generate text using the provider's API"""
-        pass
-
-    @abstractmethod
-    async def stream_text(
-        self,
-        messages: List[LLMMessage],
-        model: Optional[str] = None,
-        temperature: float = 0.7,
-        max_tokens: Optional[int] = None,
-        **kwargs
-    ) -> AsyncGenerator[str, None]:
-        """Stream text generation using the provider's API"""
-        pass
-
-    @abstractmethod
-    async def close(self):
-        """Clean up resources"""
-        pass
-
-    async def __aenter__(self):
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        await self.close()
-
-    def _count_tokens_estimate(self, text: str) -> int:
-        """Rough token count estimation (4 chars ≈ 1 token for English)"""
-        return len(text) // 4
-
-    def _estimate_cost(self, model: str, input_tokens: int, output_tokens: int, token_costs: Dict) -> float:
-        """Estimate the cost of the API call"""
-        if model in token_costs:
-            costs = token_costs[model]
-            return (input_tokens * costs["input"] + output_tokens * costs["output"]) / 1000
-        return 0.0

aiecs/llm/openai_client.py

@@ -1,125 +0,0 @@
-import asyncio
-import logging
-from typing import Dict, Any, Optional, List, AsyncGenerator
-from openai import AsyncOpenAI
-from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
-import httpx
-
-from .base_client import BaseLLMClient, LLMMessage, LLMResponse, ProviderNotAvailableError, RateLimitError
-from aiecs.config.config import get_settings
-
-logger = logging.getLogger(__name__)
-
-class OpenAIClient(BaseLLMClient):
-    """OpenAI provider client"""
-
-    def __init__(self):
-        super().__init__("OpenAI")
-        self.settings = get_settings()
-        self._client: Optional[AsyncOpenAI] = None
-
-        # Token cost estimates (USD per 1K tokens)
-        self.token_costs = {
-            "gpt-4": {"input": 0.03, "output": 0.06},
-            "gpt-4-turbo": {"input": 0.01, "output": 0.03},
-            "gpt-3.5-turbo": {"input": 0.0015, "output": 0.002},
-            "gpt-4o": {"input": 0.005, "output": 0.015},
-            "gpt-4o-mini": {"input": 0.00015, "output": 0.0006},
-        }
-
-    def _get_client(self) -> AsyncOpenAI:
-        """Lazy initialization of OpenAI client"""
-        if not self._client:
-            if not self.settings.openai_api_key:
-                raise ProviderNotAvailableError("OpenAI API key not configured")
-            self._client = AsyncOpenAI(api_key=self.settings.openai_api_key)
-        return self._client
-
-    @retry(
-        stop=stop_after_attempt(3),
-        wait=wait_exponential(multiplier=1, min=4, max=10),
-        retry=retry_if_exception_type((httpx.RequestError, RateLimitError))
-    )
-    async def generate_text(
-        self,
-        messages: List[LLMMessage],
-        model: Optional[str] = None,
-        temperature: float = 0.7,
-        max_tokens: Optional[int] = None,
-        **kwargs
-    ) -> LLMResponse:
-        """Generate text using OpenAI API"""
-        client = self._get_client()
-        model = model or "gpt-4-turbo"
-
-        # Convert to OpenAI message format
-        openai_messages = [{"role": msg.role, "content": msg.content} for msg in messages]
-
-        try:
-            response = await client.chat.completions.create(
-                model=model,
-                messages=openai_messages,
-                temperature=temperature,
-                max_tokens=max_tokens,
-                **kwargs
-            )
-
-            content = response.choices[0].message.content
-            tokens_used = response.usage.total_tokens if response.usage else None
-
-            # Estimate cost
-            input_tokens = response.usage.prompt_tokens if response.usage else 0
-            output_tokens = response.usage.completion_tokens if response.usage else 0
-            cost = self._estimate_cost(model, input_tokens, output_tokens, self.token_costs)
-
-            return LLMResponse(
-                content=content,
-                provider=self.provider_name,
-                model=model,
-                tokens_used=tokens_used,
-                cost_estimate=cost
-            )
-
-        except Exception as e:
-            if "rate_limit" in str(e).lower():
-                raise RateLimitError(f"OpenAI rate limit exceeded: {str(e)}")
-            raise
-
-    async def stream_text(
-        self,
-        messages: List[LLMMessage],
-        model: Optional[str] = None,
-        temperature: float = 0.7,
-        max_tokens: Optional[int] = None,
-        **kwargs
-    ) -> AsyncGenerator[str, None]:
-        """Stream text using OpenAI API"""
-        client = self._get_client()
-        model = model or "gpt-4-turbo"
-
-        openai_messages = [{"role": msg.role, "content": msg.content} for msg in messages]
-
-        try:
-            stream = await client.chat.completions.create(
-                model=model,
-                messages=openai_messages,
-                temperature=temperature,
-                max_tokens=max_tokens,
-                stream=True,
-                **kwargs
-            )
-
-            async for chunk in stream:
-                if chunk.choices[0].delta.content:
-                    yield chunk.choices[0].delta.content
-
-        except Exception as e:
-            if "rate_limit" in str(e).lower():
-                raise RateLimitError(f"OpenAI rate limit exceeded: {str(e)}")
-            raise
-
-    async def close(self):
-        """Clean up resources"""
-        if self._client:
-            await self._client.close()
-            self._client = None

aiecs/llm/vertex_client.py

@@ -1,186 +0,0 @@
-import asyncio
-import logging
-import os
-from typing import Dict, Any, Optional, List, AsyncGenerator
-from vertexai.generative_models import GenerativeModel, HarmCategory, HarmBlockThreshold
-import vertexai
-from google.oauth2 import service_account
-
-from .base_client import BaseLLMClient, LLMMessage, LLMResponse, ProviderNotAvailableError, RateLimitError
-from aiecs.config.config import get_settings
-
-logger = logging.getLogger(__name__)
-
-class VertexAIClient(BaseLLMClient):
-    """Vertex AI provider client"""
-
-    def __init__(self):
-        super().__init__("Vertex")
-        self.settings = get_settings()
-        self._initialized = False
-
-        # Token cost estimates (USD per 1K tokens)
-        self.token_costs = {
-            "gemini-2.5-pro": {"input": 0.00125, "output": 0.00375},
-            "gemini-2.5-flash": {"input": 0.000075, "output": 0.0003},
-        }
-
-    def _init_vertex_ai(self):
-        """Lazy initialization of Vertex AI with proper authentication"""
-        if not self._initialized:
-            if not self.settings.vertex_project_id:
-                raise ProviderNotAvailableError("Vertex AI project ID not configured")
-
-            try:
-                # Set up Google Cloud authentication
-                credentials = None
-
-                # Check if GOOGLE_APPLICATION_CREDENTIALS is configured
-                if self.settings.google_application_credentials:
-                    credentials_path = self.settings.google_application_credentials
-                    if os.path.exists(credentials_path):
-                        # Set the environment variable for Google Cloud SDK
-                        os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = credentials_path
-                        self.logger.info(f"Using Google Cloud credentials from: {credentials_path}")
-                    else:
-                        self.logger.warning(f"Google Cloud credentials file not found: {credentials_path}")
-                        raise ProviderNotAvailableError(f"Google Cloud credentials file not found: {credentials_path}")
-                elif 'GOOGLE_APPLICATION_CREDENTIALS' in os.environ:
-                    self.logger.info("Using Google Cloud credentials from environment variable")
-                else:
-                    self.logger.warning("No Google Cloud credentials configured. Using default authentication.")
-
-                # Initialize Vertex AI
-                vertexai.init(
-                    project=self.settings.vertex_project_id,
-                    location=getattr(self.settings, 'vertex_location', 'us-central1')
-                )
-                self._initialized = True
-                self.logger.info(f"Vertex AI initialized for project {self.settings.vertex_project_id}")
-
-            except Exception as e:
-                raise ProviderNotAvailableError(f"Failed to initialize Vertex AI: {str(e)}")
-
-    async def generate_text(
-        self,
-        messages: List[LLMMessage],
-        model: Optional[str] = None,
-        temperature: float = 0.7,
-        max_tokens: Optional[int] = None,
-        **kwargs
-    ) -> LLMResponse:
-        """Generate text using Vertex AI"""
-        self._init_vertex_ai()
-        model_name = model or "gemini-2.5-pro"
-
-        try:
-            # Use the stable Vertex AI API
-            model_instance = GenerativeModel(model_name)
-
-            # Convert messages to Vertex AI format
-            if len(messages) == 1 and messages[0].role == "user":
-                prompt = messages[0].content
-            else:
-                # For multi-turn conversations, combine messages
-                prompt = "\n".join([f"{msg.role}: {msg.content}" for msg in messages])
-
-            response = await asyncio.get_event_loop().run_in_executor(
-                None,
-                lambda: model_instance.generate_content(
-                    prompt,
-                    generation_config={
-                        "temperature": temperature,
-                        "max_output_tokens": max_tokens or 8192,  # Increased to account for thinking tokens
-                        "top_p": 0.95,
-                        "top_k": 40,
-                    },
-                    safety_settings={
-                        HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE,
-                        HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE,
-                        HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
-                        HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE,
-                    }
-                )
-            )
-
-            # Handle response content safely
-            try:
-                content = response.text
-                self.logger.debug(f"Vertex AI response received: {content[:100]}...")
-            except ValueError as ve:
-                # Handle cases where response has no content (safety filters, etc.)
-                self.logger.warning(f"Vertex AI response error: {str(ve)}")
-                self.logger.debug(f"Full response object: {response}")
-
-                # Check if response has candidates but no text
-                if hasattr(response, 'candidates') and response.candidates:
-                    candidate = response.candidates[0]
-                    self.logger.debug(f"Candidate finish_reason: {getattr(candidate, 'finish_reason', 'unknown')}")
-
-                    # If finish_reason is MAX_TOKENS, it might be due to thinking tokens
-                    if hasattr(candidate, 'finish_reason') and candidate.finish_reason == 'MAX_TOKENS':
-                        content = "[Response truncated due to token limit - consider increasing max_tokens for Gemini 2.5 models]"
-                        self.logger.warning("Response truncated due to MAX_TOKENS - Gemini 2.5 uses thinking tokens")
-                    elif "no parts" in str(ve).lower() or "safety filters" in str(ve).lower():
-                        content = "[Response blocked by safety filters or has no content]"
-                        self.logger.warning(f"Vertex AI response blocked or empty: {str(ve)}")
-                    else:
-                        content = f"[Response error: {str(ve)}]"
-                else:
-                    content = f"[Response error: {str(ve)}]"
-
-            # Vertex AI doesn't provide detailed token usage in the response
-            tokens_used = self._count_tokens_estimate(prompt + content)
-            cost = self._estimate_cost(
-                model_name,
-                self._count_tokens_estimate(prompt),
-                self._count_tokens_estimate(content),
-                self.token_costs
-            )
-
-            return LLMResponse(
-                content=content,
-                provider=self.provider_name,
-                model=model_name,
-                tokens_used=tokens_used,
-                cost_estimate=cost
-            )
-
-        except Exception as e:
-            if "quota" in str(e).lower() or "limit" in str(e).lower():
-                raise RateLimitError(f"Vertex AI quota exceeded: {str(e)}")
-            # Handle specific Vertex AI response errors
-            if "cannot get the response text" in str(e).lower() or "safety filters" in str(e).lower():
-                self.logger.warning(f"Vertex AI response issue: {str(e)}")
-                # Return a response indicating the issue
-                return LLMResponse(
-                    content="[Response unavailable due to safety filters or content policy]",
-                    provider=self.provider_name,
-                    model=model_name,
-                    tokens_used=self._count_tokens_estimate(prompt),
-                    cost_estimate=0.0
-                )
-            raise
-
-    async def stream_text(
-        self,
-        messages: List[LLMMessage],
-        model: Optional[str] = None,
-        temperature: float = 0.7,
-        max_tokens: Optional[int] = None,
-        **kwargs
-    ) -> AsyncGenerator[str, None]:
-        """Stream text using Vertex AI (simulated streaming)"""
-        # Vertex AI streaming is more complex, for now fall back to non-streaming
-        response = await self.generate_text(messages, model, temperature, max_tokens, **kwargs)
-
-        # Simulate streaming by yielding words
-        words = response.content.split()
-        for word in words:
-            yield word + " "
-            await asyncio.sleep(0.05)  # Small delay to simulate streaming
-
-    async def close(self):
-        """Clean up resources"""
-        # Vertex AI doesn't require explicit cleanup
-        self._initialized = False

aiecs/llm/xai_client.py

@@ -1,184 +0,0 @@
-import json
-import asyncio
-import logging
-from typing import Dict, Any, Optional, List, AsyncGenerator
-from openai import AsyncOpenAI
-from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
-
-from .base_client import BaseLLMClient, LLMMessage, LLMResponse, ProviderNotAvailableError, RateLimitError
-from aiecs.config.config import get_settings
-
-logger = logging.getLogger(__name__)
-
-class XAIClient(BaseLLMClient):
-    """xAI (Grok) provider client"""
-
-    def __init__(self):
-        super().__init__("xAI")
-        self.settings = get_settings()
-        self._openai_client: Optional[AsyncOpenAI] = None
-
-        # Enhanced model mapping for all Grok models
-        self.model_map = {
-            # Legacy Grok models
-            "grok-beta": "grok-beta",
-            "grok": "grok-beta",
-
-            # Current Grok models
-            "Grok 2": "grok-2",
-            "grok-2": "grok-2",
-            "Grok 2 Vision": "grok-2-vision",
-            "grok-2-vision": "grok-2-vision",
-
-            # Grok 3 models
-            "Grok 3 Normal": "grok-3",
-            "grok-3": "grok-3",
-            "Grok 3 Fast": "grok-3-fast",
-            "grok-3-fast": "grok-3-fast",
-
-            # Grok 3 Mini models
-            "Grok 3 Mini Normal": "grok-3-mini",
-            "grok-3-mini": "grok-3-mini",
-            "Grok 3 Mini Fast": "grok-3-mini-fast",
-            "grok-3-mini-fast": "grok-3-mini-fast",
-
-            # Grok 3 Reasoning models
-            "Grok 3 Reasoning Normal": "grok-3-reasoning",
-            "grok-3-reasoning": "grok-3-reasoning",
-            "Grok 3 Reasoning Fast": "grok-3-reasoning-fast",
-            "grok-3-reasoning-fast": "grok-3-reasoning-fast",
-
-            # Grok 3 Mini Reasoning models
-            "Grok 3 Mini Reasoning Normal": "grok-3-mini-reasoning",
-            "grok-3-mini-reasoning": "grok-3-mini-reasoning",
-            "Grok 3 Mini Reasoning Fast": "grok-3-mini-reasoning-fast",
-            "grok-3-mini-reasoning-fast": "grok-3-mini-reasoning-fast",
-
-            # Grok 4 models
-            "Grok 4 Normal": "grok-4",
-            "grok-4": "grok-4",
-            "Grok 4 Fast": "grok-4-fast",
-            "grok-4-fast": "grok-4-fast",
-            "Grok 4 0709": "grok-4-0709",
-            "grok-4-0709": "grok-4-0709",
-        }
-
-    def _get_openai_client(self) -> AsyncOpenAI:
-        """Lazy initialization of OpenAI client for XAI"""
-        if not self._openai_client:
-            api_key = self._get_api_key()
-            self._openai_client = AsyncOpenAI(
-                api_key=api_key,
-                base_url="https://api.x.ai/v1",
-                timeout=360.0  # Override default timeout with longer timeout for reasoning models
-            )
-        return self._openai_client
-
-    def _get_api_key(self) -> str:
-        """Get API key with backward compatibility"""
-        # Support both xai_api_key and grok_api_key for backward compatibility
-        api_key = getattr(self.settings, 'xai_api_key', None) or getattr(self.settings, 'grok_api_key', None)
-        if not api_key:
-            raise ProviderNotAvailableError("xAI API key not configured")
-        return api_key
-
-    @retry(
-        stop=stop_after_attempt(3),
-        wait=wait_exponential(multiplier=1, min=4, max=10),
-        retry=retry_if_exception_type((Exception, RateLimitError))
-    )
-    async def generate_text(
-        self,
-        messages: List[LLMMessage],
-        model: Optional[str] = None,
-        temperature: float = 0.7,
-        max_tokens: Optional[int] = None,
-        **kwargs
-    ) -> LLMResponse:
-        """Generate text using xAI API via OpenAI library (supports all Grok models)"""
-        # Check API key availability
-        api_key = self._get_api_key()
-        if not api_key:
-            raise ProviderNotAvailableError("xAI API key is not configured.")
-
-        client = self._get_openai_client()
-
-        selected_model = model or "grok-4"  # Default to grok-4 as in the example
-        api_model = self.model_map.get(selected_model, selected_model)
-
-        # Convert to OpenAI format
-        openai_messages = [{"role": msg.role, "content": msg.content} for msg in messages]
-
-        try:
-            completion = await client.chat.completions.create(
-                model=api_model,
-                messages=openai_messages,
-                temperature=temperature,
-                max_tokens=max_tokens,
-                **kwargs
-            )
-
-            content = completion.choices[0].message.content
-            tokens_used = completion.usage.total_tokens if completion.usage else None
-
-            return LLMResponse(
-                content=content,
-                provider=self.provider_name,
-                model=selected_model,
-                tokens_used=tokens_used,
-                cost_estimate=0.0  # xAI pricing not available yet
-            )
-
-        except Exception as e:
-            if "rate limit" in str(e).lower() or "429" in str(e):
-                raise RateLimitError(f"xAI rate limit exceeded: {str(e)}")
-            logger.error(f"xAI API error: {str(e)}")
-            raise
-
-    async def stream_text(
-        self,
-        messages: List[LLMMessage],
-        model: Optional[str] = None,
-        temperature: float = 0.7,
-        max_tokens: Optional[int] = None,
-        **kwargs
-    ) -> AsyncGenerator[str, None]:
-        """Stream text using xAI API via OpenAI library (supports all Grok models)"""
-        # Check API key availability
-        api_key = self._get_api_key()
-        if not api_key:
-            raise ProviderNotAvailableError("xAI API key is not configured.")
-
-        client = self._get_openai_client()
-
-        selected_model = model or "grok-4"  # Default to grok-4
-        api_model = self.model_map.get(selected_model, selected_model)
-
-        # Convert to OpenAI format
-        openai_messages = [{"role": msg.role, "content": msg.content} for msg in messages]
-
-        try:
-            stream = await client.chat.completions.create(
-                model=api_model,
-                messages=openai_messages,
-                temperature=temperature,
-                max_tokens=max_tokens,
-                stream=True,
-                **kwargs
-            )
-
-            async for chunk in stream:
-                if chunk.choices[0].delta.content is not None:
-                    yield chunk.choices[0].delta.content
-
-        except Exception as e:
-            if "rate limit" in str(e).lower() or "429" in str(e):
-                raise RateLimitError(f"xAI rate limit exceeded: {str(e)}")
-            logger.error(f"xAI API streaming error: {str(e)}")
-            raise
-
-    async def close(self):
-        """Clean up resources"""
-        if self._openai_client:
-            await self._openai_client.close()
-            self._openai_client = None