iatoolkit 2.28.2__tar.gz → 2.28.4__tar.gz

{iatoolkit-2.28.2/src/iatoolkit.egg-info → iatoolkit-2.28.4}/PKG-INFO

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

{iatoolkit-2.28.2 → iatoolkit-2.28.4}/src/iatoolkit/__init__.py

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

{iatoolkit-2.28.2 → iatoolkit-2.28.4}/src/iatoolkit/common/model_registry.py

@@ -100,9 +100,8 @@ class ModelRegistry:
         }
         supports_text_verbosity = normalized_provider in {"openai", "xai", "openrouter"}
         supports_store = normalized_provider in {"openai", "xai"}
-        supports_native_images = self._resolve_native_image_support(normalized_provider)
 
-        capabilities = {
+        return {
             "provider": normalized_provider,
             "history_type": self.get_history_type(model),
             "supports_reasoning_effort": supports_reasoning_effort,
@@ -111,9 +110,6 @@ class ModelRegistry:
             "allowed_text_verbosity": list(self._text_verbosity_options) if supports_text_verbosity else [],
             "supports_store": supports_store,
         }
-        if supports_native_images is not None:
-            capabilities["supports_native_images"] = supports_native_images
-        return capabilities
 
     def get_request_defaults(self, model: str) -> dict:
         """
@@ -195,12 +191,3 @@ class ModelRegistry:
 
     def is_anthropic_model(self, model: str) -> bool:
         return self.get_provider(model) == "anthropic"
-
-    @staticmethod
-    def _resolve_native_image_support(provider: ProviderType) -> bool | None:
-        # Keep this conservative and only publish a hint when we know the family behavior.
-        if provider in {"openai", "gemini", "anthropic"}:
-            return True
-        if provider == "deepseek":
-            return False
-        return None

{iatoolkit-2.28.2 → iatoolkit-2.28.4}/src/iatoolkit/infra/llm_providers/deepseek_adapter.py

@@ -31,6 +31,7 @@ class DeepseekAdapter(OpenAICompatibleChatAdapter):
 
     def create_response(self, model: str, input: list[dict], **kwargs):
         self._validate_model(model)
+        self._validate_multimodal_inputs(kwargs)
         return super().create_response(model=model, input=input, **kwargs)
 
     @classmethod
@@ -73,3 +74,19 @@ class DeepseekAdapter(OpenAICompatibleChatAdapter):
         # Keep the default deterministic: unless a prompt explicitly asks for
         # reasoning, use non-thinking mode.
         return {"type": "disabled"}
+
+    @staticmethod
+    def _validate_multimodal_inputs(kwargs: dict) -> None:
+        images = kwargs.get("images") or []
+        attachments = kwargs.get("attachments") or []
+        if not images and not attachments:
+            return
+
+        raise IAToolkitException(
+            IAToolkitException.ErrorType.LLM_ERROR,
+            (
+                "Este modelo/provider no expone visión ni archivos nativos por API en este endpoint: "
+                "DeepSeek API directa no acepta imagenes ni archivos nativos aqui. "
+                "Usa un modelo/provider que publique soporte API nativo de image/file input."
+            ),
+        )

{iatoolkit-2.28.2 → iatoolkit-2.28.4}/src/iatoolkit/services/attachment_policy_service.py

@@ -10,6 +10,10 @@ from typing import Any, Dict, List
 import base64
 import logging
 import mimetypes
+import threading
+import time
+
+import requests
 
 from injector import inject
 
@@ -26,12 +30,16 @@ class AttachmentPolicyService:
 
     DEFAULT_MODE = MODE_EXTRACTED_ONLY
     DEFAULT_FALLBACK = FALLBACK_EXTRACT
+    OPENROUTER_MODELS_CACHE_TTL_SECONDS = 300
+    OPENROUTER_MODELS_TIMEOUT_SECONDS = 8
 
     @inject
     def __init__(self, configuration_service: ConfigurationService, util: Utility):
         self.configuration_service = configuration_service
         self.util = util
         self._default_capabilities: dict | None = None
+        self._openrouter_models_cache: dict[str, dict[str, Any]] = {}
+        self._openrouter_models_cache_lock = threading.Lock()
         self._default_capabilities_path = (
             Path(__file__).resolve().parent.parent / "config" / "llm_capabilities.yaml"
         )
@@ -60,12 +68,11 @@ class AttachmentPolicyService:
         provider: str,
         files: list | None,
         policy: dict | None = None,
-        model_capabilities: dict | None = None,
+        model: str | None = None,
     ) -> dict:
         mode = self.normalize_mode((policy or {}).get("attachment_mode"))
         fallback = self.normalize_fallback((policy or {}).get("attachment_fallback"))
         capabilities = self.get_effective_provider_capabilities(company_short_name, provider)
-        capabilities = self._apply_model_capability_hints(capabilities, model_capabilities)
 
         if not files:
             return {
@@ -95,6 +102,8 @@ class AttachmentPolicyService:
             "fallback_to_extract": 0,
             "errors": 0,
         }
+        openrouter_native_image_error: str | None = None
+        openrouter_native_image_checked = False
 
         for file_obj in files:
             stats["total_files"] += 1
@@ -105,16 +114,33 @@ class AttachmentPolicyService:
                 wants_native = self._wants_native(mode, meta, capabilities)
                 wants_extract = self._wants_extract(mode, meta, capabilities)
                 native_ok = False
+                native_blocked_by_model_catalog = False
 
                 if wants_native:
-                    if bool(capabilities.get("supports_native_images")):
+                    if str(provider or "").strip().lower() == "openrouter":
+                        if not openrouter_native_image_checked:
+                            openrouter_native_image_error = self._get_openrouter_native_image_error(
+                                company_short_name=company_short_name,
+                                model=model,
+                            )
+                            openrouter_native_image_checked = True
+                        if openrouter_native_image_error:
+                            if fallback == self.FALLBACK_EXTRACT or wants_extract:
+                                stats["fallback_to_extract"] += 1
+                                wants_extract = True
+                                native_blocked_by_model_catalog = True
+                            else:
+                                if openrouter_native_image_error not in errors:
+                                    errors.append(openrouter_native_image_error)
+                                continue
+                    if (not native_blocked_by_model_catalog) and bool(capabilities.get("supports_native_images")):
                         files_for_context.append(dict(file_obj))
                         native_ok = True
                         stats["native_sent_count"] += 1
-                    elif fallback == self.FALLBACK_EXTRACT or wants_extract:
+                    elif (not native_blocked_by_model_catalog) and (fallback == self.FALLBACK_EXTRACT or wants_extract):
                         stats["fallback_to_extract"] += 1
                         wants_extract = True
-                    else:
+                    elif not native_blocked_by_model_catalog:
                         errors.append(
                             f"Image attachment '{filename}' cannot be sent as native image for provider '{provider}'."
                         )
@@ -244,17 +270,103 @@ class AttachmentPolicyService:
         merged.setdefault("max_files_per_request", 0)
         return merged
 
-    @staticmethod
-    def _apply_model_capability_hints(capabilities: dict, model_capabilities: dict | None) -> dict:
-        merged = dict(capabilities or {})
-        if not isinstance(model_capabilities, dict):
-            return merged
+    def _get_openrouter_native_image_error(self, company_short_name: str, model: str | None) -> str | None:
+        model_id = str(model or "").strip()
+        if not model_id:
+            return (
+                "Este modelo/provider no expone visión nativa por API: no se resolvio el modelo efectivo "
+                "para OpenRouter, por lo que no puedo confirmar soporte de imagenes nativas."
+            )
+
+        model_metadata, verified = self._lookup_openrouter_model_metadata(company_short_name, model_id)
+        if not verified:
+            return None
+        if not isinstance(model_metadata, dict):
+            return (
+                "Este modelo/provider no expone visión nativa por API verificable: "
+                f"OpenRouter no publica metadata para el modelo '{model_id}', por lo que no puedo confirmar "
+                "que acepte imagenes nativas."
+            )
+
+        architecture = model_metadata.get("architecture") or {}
+        raw_input_modalities = architecture.get("input_modalities") or []
+        input_modalities = [
+            str(modality or "").strip().lower()
+            for modality in raw_input_modalities
+            if str(modality or "").strip()
+        ]
+        if "image" in input_modalities:
+            return None
+
+        published_model_id = str(model_metadata.get("id") or model_id).strip() or model_id
+        published_modalities = ", ".join(input_modalities) if input_modalities else "(vacio)"
+        return (
+            "Este modelo/provider no expone visión nativa por API: "
+            f"OpenRouter publica el modelo '{published_model_id}' con input_modalities={published_modalities}, "
+            "sin 'image'. Para enviar imagenes nativas usa un modelo/provider que publique 'image' "
+            "como modalidad de entrada."
+        )
 
-        model_supports_native_images = model_capabilities.get("supports_native_images")
-        if isinstance(model_supports_native_images, bool):
-            merged["supports_native_images"] = bool(merged.get("supports_native_images")) and model_supports_native_images
+    def _lookup_openrouter_model_metadata(self, company_short_name: str, model: str) -> tuple[dict | None, bool]:
+        provider_config = self.configuration_service.get_llm_provider_config(company_short_name, "openrouter") or {}
+        base_url = str(provider_config.get("base_url") or "https://openrouter.ai/api/v1").strip()
+        models_url = f"{base_url.rstrip('/')}/models"
+        catalog = self._get_openrouter_models_catalog(models_url)
+        if catalog is None:
+            return None, False
+
+        model_key = str(model or "").strip().lower()
+        for item in catalog:
+            if not isinstance(item, dict):
+                continue
+            candidates = {
+                str(item.get("id") or "").strip().lower(),
+                str(item.get("canonical_slug") or "").strip().lower(),
+            }
+            candidates.update(
+                {
+                    candidate.split("/")[-1]
+                    for candidate in list(candidates)
+                    if candidate and "/" in candidate
+                }
+            )
+            if model_key and model_key in candidates:
+                return item, True
+
+        return None, True
+
+    def _get_openrouter_models_catalog(self, models_url: str) -> list[dict] | None:
+        current_time = time.time()
+        with self._openrouter_models_cache_lock:
+            cached_entry = self._openrouter_models_cache.get(models_url)
+            if cached_entry and (current_time - float(cached_entry.get("fetched_at") or 0)) < self.OPENROUTER_MODELS_CACHE_TTL_SECONDS:
+                cached_data = cached_entry.get("data")
+                if isinstance(cached_data, list):
+                    return cached_data
 
-        return merged
+        try:
+            response = requests.get(
+                models_url,
+                params={"output_modalities": "all"},
+                timeout=self.OPENROUTER_MODELS_TIMEOUT_SECONDS,
+                headers={"User-Agent": "IAToolkit AttachmentPolicy/1.0"},
+            )
+            response.raise_for_status()
+            payload = response.json()
+            catalog = payload.get("data") if isinstance(payload, dict) else None
+            if not isinstance(catalog, list):
+                logging.warning("OpenRouter models API returned an unexpected payload shape for '%s'.", models_url)
+                return None
+        except Exception as exc:
+            logging.warning("Could not fetch OpenRouter model metadata from '%s': %s", models_url, exc)
+            return None
+
+        with self._openrouter_models_cache_lock:
+            self._openrouter_models_cache[models_url] = {
+                "fetched_at": current_time,
+                "data": catalog,
+            }
+        return catalog
 
     def _normalize_file_meta(self, file_obj: dict) -> dict:
         if not isinstance(file_obj, dict):

{iatoolkit-2.28.2 → iatoolkit-2.28.4}/src/iatoolkit/services/query_service.py

@@ -201,14 +201,12 @@ class QueryService:
                        company_short_name: str,
                        model: Optional[str],
                        prompt_output_contract: dict | None = None) -> str:
-        # Priority: 1. Prompt model -> 2. Explicit model -> 3. Company config
-        effective_model = None
-        if isinstance(prompt_output_contract, dict):
+        # Priority: 1. Explicit model override -> 2. Prompt model -> 3. Company config
+        effective_model = str(model or "").strip() or None
+        if not effective_model and isinstance(prompt_output_contract, dict):
             prompt_model = str(prompt_output_contract.get("llm_model") or "").strip()
             if prompt_model:
                 effective_model = prompt_model
-        if not effective_model:
-            effective_model = model
         if not effective_model:
             llm_config = self.configuration_service.get_configuration(company_short_name, 'llm')
             if llm_config and llm_config.get('model'):
@@ -1422,18 +1420,12 @@ class QueryService:
                 },
             }
             if self.attachment_policy_service:
-                get_capabilities_fn = getattr(self.model_registry, "get_capabilities", None)
-                model_capabilities = (
-                    get_capabilities_fn(effective_model)
-                    if callable(get_capabilities_fn)
-                    else None
-                )
                 attachment_plan = self.attachment_policy_service.build_attachment_plan(
                     company_short_name=company_short_name,
                     provider=provider,
                     files=files or [],
                     policy=effective_attachment_policy,
-                    model_capabilities=model_capabilities,
+                    model=effective_model,
                 )
             log_stage("attachment_plan")
 

{iatoolkit-2.28.2 → iatoolkit-2.28.4/src/iatoolkit.egg-info}/PKG-INFO

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