iatoolkit 0.3.9__py3-none-any.whl → 0.107.4__py3-none-any.whl

iatoolkit/infra/llm_providers/openai_adapter.py

@@ -0,0 +1,124 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+import logging
+from typing import Dict, List, Optional
+from iatoolkit.infra.llm_response import LLMResponse, ToolCall, Usage
+from iatoolkit.common.exceptions import IAToolkitException
+import html
+from typing import List
+
+class OpenAIAdapter:
+    """Adaptador para la API de OpenAI"""
+
+    def __init__(self, openai_client):
+        self.client = openai_client
+
+    def create_response(self,
+                        model: str,
+                        input: List[Dict],
+                        previous_response_id: Optional[str] = None,
+                        context_history: Optional[List[Dict]] = None,
+                        tools: Optional[List[Dict]] = None,
+                        text: Optional[Dict] = None,
+                        reasoning: Optional[Dict] = None,
+                        tool_choice: str = "auto") -> LLMResponse:
+        """Llamada a la API de OpenAI y mapeo a estructura común"""
+        try:
+            # Preparar parámetros para OpenAI
+            params = {
+                'model': model,
+                'input': input
+            }
+
+            if previous_response_id:
+                params['previous_response_id'] = previous_response_id
+            if tools:
+                params['tools'] = tools
+            if text:
+                params['text'] = text
+            if reasoning:
+                params['reasoning'] = reasoning
+            if tool_choice != "auto":
+                params['tool_choice'] = tool_choice
+
+            # Llamar a la API de OpenAI
+            openai_response = self.client.responses.create(**params)
+
+            # Mapear la respuesta a estructura común
+            return self._map_openai_response(openai_response)
+
+        except Exception as e:
+            error_message = f"Error calling OpenAI API: {str(e)}"
+            logging.error(error_message)
+
+            raise IAToolkitException(IAToolkitException.ErrorType.LLM_ERROR, error_message)
+
+    def _map_openai_response(self, openai_response) -> LLMResponse:
+        """Mapear respuesta de OpenAI a estructura común"""
+        # Mapear tool calls
+        tool_calls = []
+        if hasattr(openai_response, 'output') and openai_response.output:
+            for tool_call in openai_response.output:
+                if hasattr(tool_call, 'type') and tool_call.type == "function_call":
+                    tool_calls.append(ToolCall(
+                        call_id=getattr(tool_call, 'call_id', ''),
+                        type=tool_call.type,
+                        name=getattr(tool_call, 'name', ''),
+                        arguments=getattr(tool_call, 'arguments', '{}')
+                    ))
+
+        # Mapear usage
+        usage = Usage(
+            input_tokens=openai_response.usage.input_tokens if openai_response.usage else 0,
+            output_tokens=openai_response.usage.output_tokens if openai_response.usage else 0,
+            total_tokens=openai_response.usage.total_tokens if openai_response.usage else 0
+        )
+
+        # Reasoning content extracted from Responses output items (type="reasoning")
+        reasoning_list = self._extract_reasoning_content(openai_response)
+        reasoning_str = "\n".join(reasoning_list)
+
+        return LLMResponse(
+            id=openai_response.id,
+            model=openai_response.model,
+            status=openai_response.status,
+            output_text=getattr(openai_response, 'output_text', ''),
+            output=tool_calls,
+            usage=usage,
+            reasoning_content=reasoning_str
+        )
+
+    def _extract_reasoning_content(self, openai_response) -> List[str]:
+        """
+        Extract reasoning summaries (preferred) or reasoning content fragments from Responses API output.
+
+        Format required by caller:
+          1. reason is ...
+          2. reason is ...
+        """
+        reasons: List[str] = []
+
+        output_items = getattr(openai_response, "output", None) or []
+        for item in output_items:
+            if getattr(item, "type", None) != "reasoning":
+                continue
+
+            # 1) Preferred: reasoning summaries (requires reasoning={"summary":"auto"} or similar)
+            summary = getattr(item, "summary", None) or []
+            for s in summary:
+                text = getattr(s, "text", None)
+                if text:
+                    reasons.append(str(text).strip())
+
+            # 2) Fallback: some responses may carry reasoning content in "content"
+            # (e.g., content parts like {"type":"reasoning_text","text":"..."}).
+            content = getattr(item, "content", None) or []
+            for c in content:
+                text = getattr(c, "text", None)
+                if text:
+                    reasons.append(str(text).strip())
+
+        return reasons

iatoolkit/infra/llm_proxy.py

@@ -0,0 +1,268 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+
+from iatoolkit.services.configuration_service import ConfigurationService
+from iatoolkit.infra.llm_providers.openai_adapter import OpenAIAdapter
+from iatoolkit.infra.llm_providers.gemini_adapter import GeminiAdapter
+from iatoolkit.infra.llm_providers.deepseek_adapter import DeepseekAdapter
+# from iatoolkit.infra.llm_providers.anthropic_adapter import AnthropicAdapter
+from iatoolkit.common.exceptions import IAToolkitException
+from iatoolkit.common.util import Utility
+from iatoolkit.infra.llm_response import LLMResponse
+from iatoolkit.common.model_registry import ModelRegistry
+
+from openai import OpenAI         # For OpenAI and xAI (OpenAI-compatible)
+# from anthropic import Anthropic  # For Claude (Anthropic)
+
+from typing import Dict, List, Any, Tuple
+import os
+import threading
+from injector import inject
+
+
+class LLMProxy:
+    """
+    Proxy for routing calls to the correct LLM adapter and managing the creation of LLM clients.
+    """
+
+    # Class-level cache for low-level clients (per provider + API key)
+    _clients_cache: Dict[Tuple[str, str], Any] = {}
+    _clients_cache_lock = threading.Lock()
+
+    # Provider identifiers
+    PROVIDER_OPENAI = "openai"
+    PROVIDER_GEMINI = "gemini"
+    PROVIDER_DEEPSEEK = "deepseek"
+    PROVIDER_XAI = "xai"
+    PROVIDER_ANTHROPIC = "anthropic"
+
+    @inject
+    def __init__(
+        self,
+        util: Utility,
+        configuration_service: ConfigurationService,
+        model_registry: ModelRegistry,
+    ):
+        """
+        Init a new instance of the proxy. It can be a base factory or a working instance with configured clients.
+        Pre-built clients can be injected for tests or special environments.
+        """
+        self.util = util
+        self.configuration_service = configuration_service
+        self.model_registry = model_registry
+
+        # adapter cache por provider
+        self.adapters: Dict[str, Any] = {}
+
+    # -------------------------------------------------------------------------
+    # Public API
+    # -------------------------------------------------------------------------
+
+    def create_response(self, company_short_name: str, model: str, input: List[Dict], **kwargs) -> LLMResponse:
+        """
+        Route the call to the correct adapter based on the model name.
+        This method is the single entry point used by the rest of the application.
+        """
+        if not company_short_name:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.API_KEY,
+                "company_short_name is required in kwargs to resolve LLM credentials."
+            )
+
+        # Determine the provider based on the model name
+        provider = self._resolve_provider_from_model(model)
+
+        adapter = self._get_or_create_adapter(
+            provider=provider,
+            company_short_name=company_short_name,
+        )
+
+        # Delegate to the adapter (OpenAI, Gemini, DeepSeek, xAI, Anthropic, etc.)
+        return adapter.create_response(model=model, input=input, **kwargs)
+
+    # -------------------------------------------------------------------------
+    # Provider resolution
+    # -------------------------------------------------------------------------
+
+    def _resolve_provider_from_model(self, model: str) -> str:
+        """
+        Determine which provider must be used for a given model name.
+        This uses Utility helper methods, so you can keep all naming logic in one place.
+        """
+        provider_key = self.model_registry.get_provider(model)
+
+        if provider_key == "openai":
+            return self.PROVIDER_OPENAI
+        if provider_key == "gemini":
+            return self.PROVIDER_GEMINI
+        if provider_key == "deepseek":
+            return self.PROVIDER_DEEPSEEK
+        if provider_key == "xai":
+            return self.PROVIDER_XAI
+        if provider_key == "anthropic":
+            return self.PROVIDER_ANTHROPIC
+
+        raise IAToolkitException(
+            IAToolkitException.ErrorType.MODEL,
+            f"Unknown or unsupported model: {model}"
+        )
+
+    # -------------------------------------------------------------------------
+    # Adapter management
+    # -------------------------------------------------------------------------
+
+    def _get_or_create_adapter(self, provider: str, company_short_name: str) -> Any:
+        """
+        Return an adapter instance for the given provider.
+        If none exists yet, create it using a cached or new low-level client.
+        """
+        # If already created, just return it
+        if provider in self.adapters and self.adapters[provider] is not None:
+            return self.adapters[provider]
+
+        # Otherwise, create a low-level client from configuration
+        api_key = self._get_api_key_from_config(company_short_name, provider)
+        client = self._get_or_create_client(provider, api_key)
+
+        # Wrap client with the correct adapter
+        if provider == self.PROVIDER_OPENAI:
+            adapter = OpenAIAdapter(client)
+        elif provider == self.PROVIDER_GEMINI:
+            adapter = GeminiAdapter(client)
+        elif provider == self.PROVIDER_DEEPSEEK:
+            adapter = DeepseekAdapter(client)
+        else:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.MODEL,
+                f"Provider not supported in _get_or_create_adapter: {provider}"
+            )
+
+        '''
+        elif provider == self.PROVIDER_XAI:
+            adapter = XAIAdapter(client)
+        elif provider == self.PROVIDER_ANTHROPIC:
+            adapter = AnthropicAdapter(client)
+        '''
+        self.adapters[provider] = adapter
+        return adapter
+
+    # -------------------------------------------------------------------------
+    # Client cache
+    # -------------------------------------------------------------------------
+
+    def _get_or_create_client(self, provider: str, api_key: str) -> Any:
+        """
+        Return a low-level client for the given provider and API key.
+        Uses a class-level cache to avoid recreating clients.
+        """
+        cache_key = (provider, api_key or "")
+
+        with self._clients_cache_lock:
+            if cache_key in self._clients_cache:
+                return self._clients_cache[cache_key]
+
+            client = self._create_client_for_provider(provider, api_key)
+            self._clients_cache[cache_key] = client
+            return client
+
+    def _create_client_for_provider(self, provider: str, api_key: str) -> Any:
+        """
+        Actually create the low-level client for a provider.
+        This is the only place where provider-specific client construction lives.
+        """
+        if provider == self.PROVIDER_OPENAI:
+            # Standard OpenAI client for GPT models
+            return OpenAI(api_key=api_key)
+
+        if provider == self.PROVIDER_XAI:
+            # xAI Grok is OpenAI-compatible; we can use the OpenAI client with a different base_url.
+            return OpenAI(
+                api_key=api_key,
+                base_url="https://api.x.ai/v1",
+            )
+
+        if provider == self.PROVIDER_DEEPSEEK:
+            # Example: if you use the official deepseek client or OpenAI-compatible wrapper
+            # return DeepSeekAPI(api_key=api_key)
+
+            # We use OpenAI client with a DeepSeek base_url:
+            return OpenAI(
+                api_key=api_key,
+                base_url="https://api.deepseek.com",
+            )
+
+        if provider == self.PROVIDER_GEMINI:
+            # Example placeholder: you may already have a Gemini client factory elsewhere.
+            # Here you could create and configure the Gemini client (e.g. google.generativeai).
+            #
+            import google.generativeai as genai
+
+            genai.configure(api_key=api_key)
+            return genai
+        if provider == self.PROVIDER_ANTHROPIC:
+            # Example using Anthropic official client:
+            #
+            # from anthropic import Anthropic
+            # return Anthropic(api_key=api_key)
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.API_KEY,
+                "Anthropic client creation must be implemented in _create_client_for_provider."
+            )
+
+        raise IAToolkitException(
+            IAToolkitException.ErrorType.MODEL,
+            f"Provider not supported in _create_client_for_provider: {provider}"
+        )
+
+    # -------------------------------------------------------------------------
+    # Configuration helpers
+    # -------------------------------------------------------------------------
+    def _get_api_key_from_config(self, company_short_name: str, provider: str) -> str:
+        """
+        Read the LLM API key from company configuration and environment variables.
+
+        Resolución de prioridad:
+        1. llm.provider_api_keys[provider] -> env var específica por proveedor.
+        2. llm.api-key                      -> env var global (compatibilidad hacia atrás).
+        """
+        llm_config = self.configuration_service.get_configuration(company_short_name, "llm")
+
+        if not llm_config:
+            # Mantener compatibilidad con los tests: el mensaje debe indicar
+            # que no hay API key configurada.
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.API_KEY,
+                f"Company '{company_short_name}' doesn't have an API key configured."
+            )
+
+        provider_keys = llm_config.get("provider_api_keys") or {}
+        env_var_name = None
+
+        # 1) Intentar api-key específica por proveedor (si existe el bloque provider_api_keys)
+        if provider_keys and isinstance(provider_keys, dict):
+            env_var_name = provider_keys.get(provider)
+
+        # 2) Fallback: usar api-key global si no hay específica
+        if not env_var_name and llm_config.get("api-key"):
+            env_var_name = llm_config["api-key"]
+
+        if not env_var_name:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.API_KEY,
+                f"Company '{company_short_name}' doesn't have an API key configured "
+                f"for provider '{provider}'."
+            )
+
+        api_key_value = os.getenv(env_var_name, "")
+
+        if not api_key_value:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.API_KEY,
+                f"Environment variable '{env_var_name}' for company '{company_short_name}' "
+                f"and provider '{provider}' is not set or is empty."
+            )
+
+        return api_key_value

iatoolkit/infra/llm_response.py

@@ -0,0 +1,45 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from dataclasses import dataclass
+from typing import Dict, List, Any, Optional
+
+@dataclass
+class ToolCall:
+    """Representa una llamada a herramienta en formato común"""
+    call_id: str
+    type: str  # 'function_call'
+    name: str
+    arguments: str
+
+
+@dataclass
+class Usage:
+    """Información de uso de tokens en formato común"""
+    input_tokens: int
+    output_tokens: int
+    total_tokens: int
+
+
+@dataclass
+class LLMResponse:
+    """Estructura común para respuestas de diferentes LLMs"""
+    id: str
+    model: str
+    status: str  # 'completed', 'failed', etc.
+    output_text: str
+    output: List[ToolCall]  # lista de tool calls
+    usage: Usage
+    reasoning_content: str = None # campo opcional para Chain of Thought
+
+
+    def __post_init__(self):
+        """Asegura que output sea una lista"""
+        if self.output is None:
+            self.output = []
+
+        if self.reasoning_content is None:
+            self.reasoning_content = ""
+

iatoolkit/infra/redis_session_manager.py

@@ -0,0 +1,122 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+import logging
+import os
+import redis
+import json
+from urllib.parse import urlparse
+
+
+class RedisSessionManager:
+    """
+    SessionManager que usa Redis directamente para datos persistentes como llm_history.
+    Separado de Flask session para tener control total sobre el ciclo de vida de los datos.
+    """
+    _client = None
+
+    @classmethod
+    def _get_client(cls):
+        if cls._client is None:
+            # Usar exactamente los mismos parámetros que Flask-Session
+            url = urlparse(os.environ.get("REDIS_URL"))
+            cls._client = redis.Redis(
+                host=url.hostname,
+                port=url.port,
+                password=url.password,
+                ssl=(url.scheme == "rediss"),
+                ssl_cert_reqs=None,
+                decode_responses=True  # Importante para strings
+            )
+            # verify connection
+            cls._client.ping()
+            info = cls._client.info(section="server")
+            db = cls._client.connection_pool.connection_kwargs.get('db', 0)
+        return cls._client
+
+    @classmethod
+    def set(cls, key: str, value: str, **kwargs):
+        """
+        Método set flexible que pasa argumentos opcionales (como ex, nx)
+        directamente al cliente de redis.
+        """
+        client = cls._get_client()
+        # Pasa todos los argumentos de palabra clave adicionales al cliente real
+        result = client.set(key, value, **kwargs)
+        return result
+
+    @classmethod
+    def get(cls, key: str, default: str = ""):
+        client = cls._get_client()
+        value = client.get(key)
+        result = value if value is not None else default
+        return result
+
+    @classmethod
+    def hset(cls, key: str, field: str, value: str):
+        """
+        Establece un campo en un Hash de Redis.
+        """
+        client = cls._get_client()
+        return client.hset(key, field, value)
+
+    @classmethod
+    def hget(cls, key: str, field: str):
+        """
+        Obtiene el valor de un campo de un Hash de Redis.
+        Devuelve None si la clave o el campo no existen.
+        """
+        client = cls._get_client()
+        return client.hget(key, field)
+
+    @classmethod
+    def hdel(cls, key: str, *fields):
+        """
+        Elimina uno o más campos de un Hash de Redis.
+        """
+        client = cls._get_client()
+        return client.hdel(key, *fields)
+
+    @classmethod
+    def pipeline(cls):
+        """
+        Inicia una transacción (pipeline) de Redis.
+        """
+        client = cls._get_client()
+        return client.pipeline()
+
+
+    @classmethod
+    def remove(cls, key: str):
+        client = cls._get_client()
+        result = client.delete(key)
+        return result
+
+    @classmethod
+    def exists(cls, key: str) -> bool:
+        """Verifica si una clave existe en Redis."""
+        client = cls._get_client()
+        # El comando EXISTS de Redis devuelve un entero (0 o 1). Lo convertimos a booleano.
+        return bool(client.exists(key))
+
+    @classmethod
+    def set_json(cls, key: str, value: dict, ex: int = None):
+        json_str = json.dumps(value)
+        return cls.set(key, json_str, ex=ex)
+
+    @classmethod
+    def get_json(cls, key: str, default: dict = None):
+        if default is None:
+            default = {}
+
+        json_str = cls.get(key, "")
+        if not json_str:
+            return default
+
+        try:
+            return json.loads(json_str)
+        except json.JSONDecodeError:
+            logging.warning(f"[RedisSessionManager] Invalid JSON in key '{key}': {json_str}")
+            return default