iatoolkit 2.5.0__tar.gz → 2.6.1__tar.gz

{iatoolkit-2.5.0/src/iatoolkit.egg-info → iatoolkit-2.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iatoolkit
-Version: 2.5.0
+Version: 2.6.1
 Summary: IAToolkit
 Author: Fernando Libedinsky
 License-Expression: MIT

{iatoolkit-2.5.0 → iatoolkit-2.6.1}/src/iatoolkit/__init__.py

@@ -3,7 +3,7 @@
 #
 # IAToolkit is open source software.
 
-__version__ = "2.5.0"
+__version__ = "2.6.1"
 
 # Expose main classes and functions at the top level of the package
 

{iatoolkit-2.5.0 → iatoolkit-2.6.1}/src/iatoolkit/common/model_registry.py

@@ -16,7 +16,7 @@ from typing import Literal
 
 
 HistoryType = Literal["server_side", "client_side"]
-ProviderType = Literal["openai", "gemini", "deepseek", "xai", "anthropic", "unknown"]
+ProviderType = Literal["openai", "gemini", "deepseek", "xai", "anthropic", "openrouter", "openai_compatible", "unknown"]
 
 
 @dataclass(frozen=True)
@@ -47,7 +47,10 @@ class ModelRegistry:
             "deepseek": ("deepseek",),
             "xai": ("grok", "grok-1", "grok-beta"),
             "anthropic": ("claude", "claude-3", "claude-2"),
+            "openrouter": ("openrouter/",),
         }
+        self._reasoning_effort_options = ("minimal", "low", "medium", "high", "xhigh")
+        self._text_verbosity_options = ("low", "medium", "high")
 
     # ------------------------------------------------------------------
     # Public API
@@ -60,7 +63,7 @@ class ModelRegistry:
         Examples:
             "gpt-4o"        -> "openai"
             "gemini-pro"    -> "gemini"
-            "deepseek-chat" -> "deepseek"
+            "deepseek-v4-pro" -> "deepseek"
         """
         if not model:
             return "unknown"
@@ -72,6 +75,42 @@ class ModelRegistry:
 
         return "unknown"
 
+    def normalize_provider(self, provider: str | None = None, model: str | None = None) -> ProviderType:
+        candidate = str(provider or "").strip().lower()
+        if candidate in {
+            "openai",
+            "gemini",
+            "deepseek",
+            "xai",
+            "anthropic",
+            "openrouter",
+            "openai_compatible",
+        }:
+            return candidate  # type: ignore[return-value]
+        return self.get_provider(model or "")
+
+    def get_capabilities(self, model: str, provider: str | None = None) -> dict:
+        normalized_provider = self.normalize_provider(provider=provider, model=model)
+        supports_reasoning_effort = normalized_provider in {
+            "openai",
+            "xai",
+            "openrouter",
+            "deepseek",
+            "openai_compatible",
+        }
+        supports_text_verbosity = normalized_provider in {"openai", "xai", "openrouter"}
+        supports_store = normalized_provider in {"openai", "xai"}
+
+        return {
+            "provider": normalized_provider,
+            "history_type": self.get_history_type(model),
+            "supports_reasoning_effort": supports_reasoning_effort,
+            "allowed_reasoning_efforts": list(self._reasoning_effort_options) if supports_reasoning_effort else [],
+            "supports_text_verbosity": supports_text_verbosity,
+            "allowed_text_verbosity": list(self._text_verbosity_options) if supports_text_verbosity else [],
+            "supports_store": supports_store,
+        }
+
     def get_request_defaults(self, model: str) -> dict:
         """
         Return per-model request defaults to keep model-specific policy centralized.

{iatoolkit-2.5.0 → iatoolkit-2.6.1}/src/iatoolkit/common/routes.py

@@ -184,10 +184,10 @@ def register_views(app):
     # --- RAG API Routes ---
     rag_view = RagApiView.as_view('rag_api')
 
-    # 1. List Files (POST for filters)
+    # 1. List Files (GET/POST for filters + pagination)
     app.add_url_rule('/api/rag/<company_short_name>/files',
                      view_func=rag_view,
-                     methods=['POST'],
+                     methods=['GET', 'POST'],
                      defaults={'action': 'list_files'})
 
     # 2. Delete File

{iatoolkit-2.5.0 → iatoolkit-2.6.1}/src/iatoolkit/config/system_prompts/html_structures.prompt

@@ -1,7 +1,7 @@
 ### HTML estructurado
 
 #### Tablas
-- Usa como base `table table-striped table-hover` de Bootstrap como mínimo.
+- Siempre utiliza tablas con estilos de bootstrap, ejemplo:  `table table-striped table-hover`.
 - Si una columna contiene RUT, fecha, id certificado o valores similares, usa
   clase `nowrap` en el `<th>` y en el `<td>` correspondiente cuando aplique.
 - Si una columna debe ir centrada o alineada a la derecha, agrega

iatoolkit-2.6.1/src/iatoolkit/config/system_prompts/sql_casting.prompt

@@ -0,0 +1,23 @@
+### SQL: casting y tipos
+
+- Si un numero puede venir con decimales, usa `NUMERIC`, no `INTEGER`.
+- Para numeros extraidos desde JSONB que pueden venir vacios, usa
+  `COALESCE(NULLIF(jsonb_col->>'campo', '')::NUMERIC, 0)`.
+- Si agregas numeros extraidos desde JSONB, aplica ese cast dentro de la
+  agregacion, no despues.
+- No uses `NULLIF(..., '')` sobre resultados ya agregados ni sobre columnas que
+  ya son numericas.
+- Usa `TO_DATE(...)` solo cuando la fecha viene como texto o desde `jsonb->>'campo'`.
+  No lo uses sobre columnas que ya son `DATE` o `TIMESTAMP`.
+- Antes de comparar fechas de texto con `CURRENT_DATE`, castealas explicitamente.
+- Los booleanos dentro de JSONB llegan como texto: evalualos con cast explicito,
+  por ejemplo `(jsonb_col->>'flag')::BOOLEAN IS TRUE`.
+- La función ROUND(double precision, integer) NO EXISTE en PostgreSQL.
+Todo ROUND() que lleve segundo argumento (cantidad de decimales) debe aplicarsesobre NUMERIC, no sobre DOUBLE PRECISION.
+
+Si la expresión a redondear viene de AVG(), MIN(), MAX(), SUM() sobre unacolumna de tipo float/double precision, casteala siempre antes del ROUND:
+ ROUND(AVG(columna)::NUMERIC, decimales)ROUND(MIN(columna)::NUMERIC, decimales)ROUND(MAX(columna)::NUMERIC, decimales)ROUND(SUM(columna)::NUMERIC, decimales)
+Esto aplica incluso si la subexpresión ya fue casteada antes: el cast debeestar dentro del ROUND, no afuera.
+Si usás ROUND sin segundo argumento, no hace falta el cast:
+ROUND(AVG(columna)) -- esto sí funciona, devuelve double precision redondeado a entero
+Antes de entregar la consulta SQL final, revisá cada ocurrencia de ROUND(..., N)y verificá que su primer argumento sea NUMERIC. Si no lo es, agregale ::NUMERIC.```

{iatoolkit-2.5.0 → iatoolkit-2.6.1}/src/iatoolkit/core.py

@@ -152,6 +152,16 @@ class IAToolkit:
         # get a value from the config dict or the environment variable
         return self.config.get(key, os.getenv(key, default))
 
+    def _get_redis_max_connections(self) -> int:
+        raw_value = self._get_config_value("REDIS_MAX_CONNECTIONS", "30")
+        try:
+            parsed = int(raw_value)
+            if parsed > 0:
+                return parsed
+        except (TypeError, ValueError):
+            pass
+        return 30
+
     def _setup_request_globals(self):
         """
         Configures functions to run before each request to set up
@@ -271,7 +281,8 @@ class IAToolkit:
                 port=url.port,
                 password=url.password,
                 ssl=(url.scheme == "rediss"),
-                ssl_cert_reqs=None
+                ssl_cert_reqs=None,
+                max_connections=self._get_redis_max_connections(),
             )
 
             self.app.config.update({

{iatoolkit-2.5.0 → iatoolkit-2.6.1}/src/iatoolkit/infra/llm_providers/anthropic_adapter.py

@@ -33,7 +33,8 @@ class AnthropicAdapter:
                         images: Optional[List[Dict]] = None,
                         attachments: Optional[List[Dict]] = None,
                         store: Optional[bool] = None,
-                        metadata: Optional[Dict[str, str]] = None) -> LLMResponse:
+                        metadata: Optional[Dict[str, str]] = None,
+                        telemetry_execution: Any = None) -> LLMResponse:
         """
         Calls Anthropic Messages API and maps the response to common LLMResponse.
 
@@ -76,6 +77,8 @@ class AnthropicAdapter:
                 if tool_choice_payload:
                     params["tool_choice"] = tool_choice_payload
 
+            self._record_telemetry_input(telemetry_execution, params)
+
             anthropic_response = self.client.messages.create(**params)
             return self._map_anthropic_response(anthropic_response, model)
 
@@ -87,6 +90,12 @@ class AnthropicAdapter:
                 error_message
             ) from e
 
+    @staticmethod
+    def _record_telemetry_input(telemetry_execution: Any, payload: Dict[str, Any]) -> None:
+        record_input = getattr(telemetry_execution, "record_input", None)
+        if callable(record_input):
+            record_input(payload)
+
     def _prepare_messages(self, input_items: List[Dict], images: List[Dict]) -> tuple[Optional[str], List[Dict]]:
         system_parts: List[str] = []
         messages: List[Dict] = []

iatoolkit-2.6.1/src/iatoolkit/infra/llm_providers/deepseek_adapter.py

@@ -0,0 +1,75 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from iatoolkit.common.exceptions import IAToolkitException
+from iatoolkit.infra.llm_providers.openai_compatible_chat_adapter import OpenAICompatibleChatAdapter
+
+
+class DeepseekAdapter(OpenAICompatibleChatAdapter):
+    """DeepSeek V4 adapter."""
+
+    supports_reasoning = False
+    supports_reasoning_effort = True
+    supports_reasoning_content_messages = True
+    supports_thinking = True
+    model_capabilities = {
+        "deepseek-v4-flash": {
+            "supports_thinking": True,
+            "supports_tool_choice_required": True,
+        },
+        "deepseek-v4-pro": {
+            "supports_thinking": True,
+            "supports_tool_choice_required": True,
+        },
+    }
+    supported_models = frozenset(model_capabilities)
+
+    def __init__(self, deepseek_client):
+        super().__init__(openai_compatible_client=deepseek_client, provider_label="DeepSeek")
+
+    def create_response(self, model: str, input: list[dict], **kwargs):
+        self._validate_model(model)
+        return super().create_response(model=model, input=input, **kwargs)
+
+    @classmethod
+    def _validate_model(cls, model: str) -> None:
+        normalized_model = str(model or "").strip().lower()
+        if normalized_model in cls.supported_models:
+            return
+
+        raise IAToolkitException(
+            IAToolkitException.ErrorType.MODEL,
+            (
+                f"Unsupported DeepSeek model '{model}'. "
+                f"Supported models: {sorted(cls.supported_models)}"
+            ),
+        )
+
+    def _map_reasoning_effort(self, model: str, effort: str, kwargs: dict) -> str | None:
+        _ = model
+        _ = kwargs
+
+        candidate = str(effort or "").strip().lower()
+        if candidate in {"low", "medium", "high"}:
+            return "high"
+        if candidate in {"xhigh", "max"}:
+            return "max"
+        return None
+
+    def _build_thinking_payload(self, model: str, reasoning: dict | None, kwargs: dict) -> dict | None:
+        explicit_thinking = self._normalize_thinking_payload(kwargs.get("thinking"))
+        if explicit_thinking is not None:
+            return explicit_thinking
+
+        reasoning_effort = self._extract_reasoning_effort(reasoning, kwargs)
+
+        if reasoning_effort == "minimal":
+            return {"type": "disabled"}
+        if reasoning_effort:
+            return {"type": "enabled"}
+
+        # Keep the default deterministic: unless a prompt explicitly asks for
+        # reasoning, use non-thinking mode.
+        return {"type": "disabled"}

{iatoolkit-2.5.0 → iatoolkit-2.6.1}/src/iatoolkit/infra/llm_providers/gemini_adapter.py

@@ -53,6 +53,7 @@ class GeminiAdapter:
                         attachments: Optional[List[Dict]] = None,
                         store: Optional[bool] = None,
                         metadata: Optional[Dict[str, str]] = None,
+                        telemetry_execution: Any = None,
                         ) -> LLMResponse:
         try:
             _ = store
@@ -81,6 +82,10 @@ class GeminiAdapter:
                 # "response_modalities": ['TEXT', 'IMAGE']
             }
 
+            tool_config = self._prepare_gemini_tool_config(tool_choice, tools)
+            if tool_config is not None:
+                config_kwargs["tool_config"] = tool_config
+
             if isinstance(text, dict):
                 response_schema = text.get("response_schema")
                 if response_schema is not None:
@@ -93,9 +98,12 @@ class GeminiAdapter:
                 config = types.GenerateContentConfig(**config_kwargs)
             except TypeError as e:
                 # Backward compatibility with older google-genai SDK versions.
-                if "response_schema" in config_kwargs or "response_mime_type" in config_kwargs:
+                if (
+                    "response_schema" in config_kwargs
+                    or "response_mime_type" in config_kwargs
+                ):
                     logging.warning(
-                        "Gemini SDK doesn't support response_schema fields in GenerateContentConfig. "
+                        "Gemini SDK doesn't support one or more advanced GenerateContentConfig fields. "
                         "Falling back to prompt-instruction-only mode: %s",
                         e
                     )
@@ -105,6 +113,15 @@ class GeminiAdapter:
                 else:
                     raise
 
+            self._record_telemetry_input(
+                telemetry_execution,
+                {
+                    "model": model,
+                    "contents": contents,
+                    "config": dict(config_kwargs),
+                },
+            )
+
             # call the new SDK
             response = self.client.models.generate_content(
                 model=model,
@@ -144,6 +161,12 @@ class GeminiAdapter:
 
             raise IAToolkitException(IAToolkitException.ErrorType.LLM_ERROR, error_message)
 
+    @staticmethod
+    def _record_telemetry_input(telemetry_execution: Any, payload: Dict[str, Any]) -> None:
+        record_input = getattr(telemetry_execution, "record_input", None)
+        if callable(record_input):
+            record_input(payload)
+
     def _extract_system_and_filter_input(self, input_list: List[Dict]) -> tuple[Optional[str], List[Dict]]:
         """Extrae el mensaje de sistema para usarlo en system_instruction."""
         system_parts = []
@@ -219,10 +242,10 @@ class GeminiAdapter:
                 # Reconstruir llamadas a herramientas si existen
                 if "tool_calls" in message:
                     for tc in message["tool_calls"]:
-                        args = tc["arguments"]
-                        if isinstance(args, str):
-                            args = json.loads(args)
-                        parts.append(types.Part.from_function_call(name=tc["name"], args=args))
+                        function_name, args = self._extract_history_tool_call(tc)
+                        if not function_name:
+                            continue
+                        parts.append(types.Part.from_function_call(name=function_name, args=args))
 
                 content = message.get("context") or message.get("content", "")
                 if content:
@@ -294,6 +317,34 @@ class GeminiAdapter:
 
         return None
 
+    def _prepare_gemini_tool_config(self, tool_choice: str, tools: List[Dict] | None) -> Optional[Any]:
+        tool_names = [
+            str(tool.get("name") or "").strip()
+            for tool in (tools or [])
+            if isinstance(tool, dict) and str(tool.get("name") or "").strip()
+        ]
+        if not tool_names:
+            return None
+
+        normalized_choice = str(tool_choice or "auto").strip().lower() or "auto"
+        function_calling_kwargs: Dict[str, Any] = {}
+
+        if normalized_choice == "auto":
+            function_calling_kwargs["mode"] = "AUTO"
+        elif normalized_choice == "none":
+            function_calling_kwargs["mode"] = "NONE"
+        elif normalized_choice == "required":
+            function_calling_kwargs["mode"] = "ANY"
+        elif normalized_choice in set(tool_names):
+            function_calling_kwargs["mode"] = "ANY"
+            function_calling_kwargs["allowed_function_names"] = [normalized_choice]
+        else:
+            function_calling_kwargs["mode"] = "AUTO"
+
+        return types.ToolConfig(
+            function_calling_config=types.FunctionCallingConfig(**function_calling_kwargs)
+        )
+
     def _prepare_response_schema(self, schema: Any) -> Any:
         """Normalize OpenAI-style JSON schema into a Gemini-compatible schema subset."""
         if isinstance(schema, dict):
@@ -680,3 +731,30 @@ class GeminiAdapter:
             output_tokens=output_tokens,
             total_tokens=total_tokens
         )
+
+    @staticmethod
+    def _extract_history_tool_call(tool_call: Dict[str, Any]) -> tuple[str, Dict[str, Any]]:
+        if not isinstance(tool_call, dict):
+            return "", {}
+
+        function_payload = tool_call.get("function")
+        if isinstance(function_payload, dict):
+            function_name = str(function_payload.get("name") or "").strip()
+            arguments = function_payload.get("arguments", {})
+        else:
+            function_name = str(tool_call.get("name") or "").strip()
+            arguments = tool_call.get("arguments", {})
+
+        if isinstance(arguments, str):
+            try:
+                parsed_arguments = json.loads(arguments)
+                if isinstance(parsed_arguments, dict):
+                    arguments = parsed_arguments
+                else:
+                    arguments = {"value": parsed_arguments}
+            except Exception:
+                arguments = {"value": arguments}
+        elif not isinstance(arguments, dict):
+            arguments = {}
+
+        return function_name, arguments

{iatoolkit-2.5.0 → iatoolkit-2.6.1}/src/iatoolkit/infra/llm_providers/openai_adapter.py

@@ -4,10 +4,9 @@
 # IAToolkit is open source software.
 
 import logging
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from iatoolkit.infra.llm_response import LLMResponse, ToolCall, Usage
 from iatoolkit.common.exceptions import IAToolkitException
-from typing import List
 import mimetypes
 import re
 import base64
@@ -31,7 +30,8 @@ class OpenAIAdapter:
                         images: Optional[List[Dict]] = None,
                         attachments: Optional[List[Dict]] = None,
                         store: Optional[bool] = None,
-                        metadata: Optional[Dict[str, str]] = None) -> LLMResponse:
+                        metadata: Optional[Dict[str, str]] = None,
+                        telemetry_execution: Any = None) -> LLMResponse:
         """Llamada a la API de OpenAI y mapeo a estructura común"""
         try:
             # Handle multimodal input if images are present
@@ -44,10 +44,6 @@ class OpenAIAdapter:
                 'input': input
             }
 
-            # add image generation tool
-            if tools:
-                tools.append({"type": "image_generation"})
-
             if previous_response_id:
                 params['previous_response_id'] = previous_response_id
             if tools:
@@ -64,6 +60,8 @@ class OpenAIAdapter:
             if tool_choice_payload is not None:
                 params['tool_choice'] = tool_choice_payload
 
+            self._record_telemetry_input(telemetry_execution, params)
+
             # Llamar a la API de OpenAI
             openai_response = self.client.responses.create(**params)
 
@@ -76,6 +74,12 @@ class OpenAIAdapter:
 
             raise IAToolkitException(IAToolkitException.ErrorType.LLM_ERROR, error_message)
 
+    @staticmethod
+    def _record_telemetry_input(telemetry_execution: Any, payload: Dict[str, Any]) -> None:
+        record_input = getattr(telemetry_execution, "record_input", None)
+        if callable(record_input):
+            record_input(payload)
+
     @staticmethod
     def _map_tool_choice(tool_choice: str, tools_payload: List[Dict]) -> Optional[Dict | str]:
         if tool_choice in ("", None, "auto"):