iatoolkit 2.45.1__tar.gz → 2.45.3__tar.gz

{iatoolkit-2.45.1/src/iatoolkit.egg-info → iatoolkit-2.45.3}/PKG-INFO

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

{iatoolkit-2.45.1 → iatoolkit-2.45.3}/src/iatoolkit/__init__.py

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

{iatoolkit-2.45.1 → iatoolkit-2.45.3}/src/iatoolkit/infra/llm_providers/openai_compatible_chat_adapter.py

@@ -744,6 +744,7 @@ class OpenAICompatibleChatAdapter:
             reasoning_content=reasoning_content,
             reasoning_details=reasoning_details,
             content_parts=content_parts,
+            provider_metadata=self._extract_provider_metadata(response),
         )
 
     # Backward-compatible alias retained while the old DeepSeek-specific name
@@ -831,3 +832,7 @@ class OpenAICompatibleChatAdapter:
         if type(value).__module__.startswith("unittest.mock"):
             return ""
         return str(value or "").strip()
+
+    def _extract_provider_metadata(self, response: Any) -> Dict[str, Any]:
+        _ = response
+        return {}

iatoolkit-2.45.3/src/iatoolkit/infra/llm_providers/openrouter_adapter.py

@@ -0,0 +1,155 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from typing import Any, Dict
+
+from iatoolkit.infra.llm_providers.openai_compatible_chat_adapter import OpenAICompatibleChatAdapter
+
+
+class OpenRouterAdapter(OpenAICompatibleChatAdapter):
+    """OpenRouter-specific adapter built on top of the shared chat.completions core."""
+
+    supports_multimodal = True
+    supports_reasoning = False
+    supports_reasoning_content_messages = True
+    supports_reasoning_details_messages = True
+    reasoning_content_message_field = "reasoning"
+    supports_metadata = True
+    supports_parallel_tool_calls = True
+
+    def __init__(self, openrouter_client):
+        super().__init__(openai_compatible_client=openrouter_client, provider_label="OpenRouter")
+
+    def _extend_call_kwargs(self, call_kwargs: Dict[str, Any], kwargs: Dict[str, Any]) -> None:
+        text = kwargs.get("text") or {}
+        verbosity = text.get("verbosity") if isinstance(text, dict) else None
+        if verbosity:
+            call_kwargs["verbosity"] = verbosity
+
+        passthrough_keys = (
+            "service_tier",
+            "temperature",
+            "top_p",
+            "max_tokens",
+            "max_completion_tokens",
+            "seed",
+            "stop",
+            "stream",
+            "stream_options",
+            "modalities",
+            "user",
+        )
+        for key in passthrough_keys:
+            if kwargs.get(key) is not None:
+                call_kwargs[key] = kwargs.get(key)
+
+        extra_body = dict(call_kwargs.get("extra_body") or {})
+
+        reasoning_payload = self._build_reasoning_payload(kwargs.get("reasoning"), kwargs)
+        if reasoning_payload:
+            extra_body["reasoning"] = reasoning_payload
+
+        vendor_specific_keys = (
+            "models",
+            "provider",
+            "plugins",
+            "session_id",
+        )
+        for key in vendor_specific_keys:
+            if kwargs.get(key) is not None:
+                extra_body[key] = kwargs.get(key)
+
+        if extra_body:
+            call_kwargs["extra_body"] = extra_body
+
+    def _extract_provider_metadata(self, response: Any) -> Dict[str, Any]:
+        raw_metadata = self._get_message_value(response, "openrouter_metadata")
+        metadata = self._normalize_metadata_object(raw_metadata)
+
+        provider_name = self._extract_provider_name(metadata)
+        if not provider_name:
+            provider_name = self._coerce_optional_text(
+                self._get_message_value(response, "provider_name")
+            )
+
+        provider_metadata: Dict[str, Any] = {"provider": "openrouter"}
+        if provider_name:
+            provider_metadata["provider_name"] = provider_name
+        if metadata:
+            provider_metadata["openrouter"] = metadata
+
+        return provider_metadata
+
+    @classmethod
+    def _extract_provider_name(cls, metadata: Dict[str, Any]) -> str:
+        for key in ("provider_name", "provider", "upstream_provider", "selected_provider"):
+            value = metadata.get(key)
+            if isinstance(value, dict):
+                nested = cls._extract_provider_name(value)
+                if nested:
+                    return nested
+            normalized = cls._coerce_optional_text(value)
+            if normalized:
+                return normalized
+
+        for value in metadata.values():
+            if isinstance(value, dict):
+                nested = cls._extract_provider_name(value)
+                if nested:
+                    return nested
+
+        return ""
+
+    @classmethod
+    def _normalize_metadata_object(cls, value: Any) -> Dict[str, Any]:
+        if value is None or type(value).__module__.startswith("unittest.mock"):
+            return {}
+
+        if isinstance(value, dict):
+            return cls._sanitize_metadata_dict(value)
+
+        model_dump = getattr(value, "model_dump", None)
+        if callable(model_dump):
+            try:
+                dumped = model_dump()
+                if isinstance(dumped, dict):
+                    return cls._sanitize_metadata_dict(dumped)
+            except Exception:
+                return {}
+
+        raw_dict = getattr(value, "__dict__", None)
+        if isinstance(raw_dict, dict):
+            return cls._sanitize_metadata_dict({
+                key: item
+                for key, item in raw_dict.items()
+                if not key.startswith("_") and not callable(item)
+            })
+
+        return {}
+
+    @classmethod
+    def _sanitize_metadata_dict(cls, metadata: Dict[str, Any]) -> Dict[str, Any]:
+        sanitized: Dict[str, Any] = {}
+        for key, value in dict(metadata or {}).items():
+            normalized_key = cls._coerce_optional_text(key)
+            if not normalized_key:
+                continue
+
+            if isinstance(value, dict):
+                sanitized_value = cls._sanitize_metadata_dict(value)
+            elif isinstance(value, list):
+                sanitized_value = [
+                    cls._sanitize_metadata_dict(item) if isinstance(item, dict) else item
+                    for item in value
+                    if not type(item).__module__.startswith("unittest.mock")
+                ]
+            elif type(value).__module__.startswith("unittest.mock"):
+                continue
+            else:
+                sanitized_value = value
+
+            sanitized[normalized_key] = sanitized_value
+
+        return sanitized

{iatoolkit-2.45.1 → iatoolkit-2.45.3}/src/iatoolkit/infra/llm_response.py

@@ -38,6 +38,7 @@ class LLMResponse:
     # ordered list of content blocks (text and image mixed)
     # Example: [{"type": "text", "text": "..."}, {"type": "image", "source": {"type": "base64", "data": "..."}}]
     content_parts: List[Dict] = None
+    provider_metadata: Dict[str, Any] = None
 
     def __post_init__(self):
         """Asegura que output sea una lista"""
@@ -56,3 +57,6 @@ class LLMResponse:
                     "type": "text",
                     "text": self.output_text
                 })
+
+        if self.provider_metadata is None:
+            self.provider_metadata = {}

{iatoolkit-2.45.1 → iatoolkit-2.45.3}/src/iatoolkit/services/llm_client_service.py

@@ -404,7 +404,7 @@ class llmClient:
                     if key == "request_source":
                         continue
                     if value is not None:
-                        combined_stats[key] = value
+                        combined_stats[key] = self._compact_execution_metadata_for_stats(key, value)
 
             # decode the LLM response
             decoded_response = self.decode_response(response)
@@ -1255,17 +1255,111 @@ class llmClient:
             "output_tokens": response.usage.output_tokens,
             "total_tokens": response.usage.total_tokens
         }
+        provider_stats = self._build_provider_stats(getattr(response, "provider_metadata", None))
+        if provider_stats:
+            stats_dict.update(provider_stats)
         return stats_dict
 
-    def add_stats(self, stats1: dict, stats2: dict) -> dict:
+    @staticmethod
+    def _build_provider_stats(provider_metadata: dict | None) -> dict:
+        if not isinstance(provider_metadata, dict) or not provider_metadata:
+            return {}
+
+        provider = str(provider_metadata.get("provider") or "").strip()
+        routed_provider = str(provider_metadata.get("provider_name") or "").strip()
+
+        stats: dict = {}
+        if provider:
+            stats["provider"] = provider
+        if routed_provider:
+            stats["routed_provider"] = routed_provider
+
+        openrouter_metadata = provider_metadata.get("openrouter")
+        if isinstance(openrouter_metadata, dict) and openrouter_metadata:
+            stats["openrouter"] = openrouter_metadata
+
+        provider_call = {}
+        if provider:
+            provider_call["provider"] = provider
+        if routed_provider:
+            provider_call["routed_provider"] = routed_provider
+        if provider_call:
+            stats["provider_calls"] = [provider_call]
+
+        return stats
+
+    @staticmethod
+    def add_stats(stats1: dict, stats2: dict) -> dict:
+        stats1 = dict(stats1 or {})
+        stats2 = dict(stats2 or {})
         stats_dict = {
-            "model": stats1.get('model', ''),
+            **stats1,
+            **stats2,
+            "model": stats2.get('model') or stats1.get('model', ''),
             "input_tokens": (stats1.get('input_tokens') or 0) + (stats2.get('input_tokens') or 0),
             "output_tokens": (stats1.get('output_tokens') or 0) + (stats2.get('output_tokens') or 0),
             "total_tokens": (stats1.get('total_tokens') or 0) + (stats2.get('total_tokens') or 0),
         }
+        provider_calls = []
+        for stats in (stats1, stats2):
+            for provider_call in stats.get("provider_calls") or []:
+                if isinstance(provider_call, dict) and provider_call not in provider_calls:
+                    provider_calls.append(provider_call)
+        if provider_calls:
+            stats_dict["provider_calls"] = provider_calls
         return stats_dict
 
+    @classmethod
+    def _compact_execution_metadata_for_stats(cls, key: str, value):
+        if key == "tool_router":
+            return cls._compact_tool_router_stats(value)
+        return value
+
+    @staticmethod
+    def _compact_tool_router_stats(metrics):
+        if not isinstance(metrics, dict):
+            return metrics
+
+        compact = {}
+        scalar_keys = (
+            "candidate_count",
+            "selected_count",
+            "selection_mode",
+            "fallback_reason",
+            "selector_latency_ms",
+            "router_skipped",
+            "hard_disable_tools",
+        )
+        for key in scalar_keys:
+            if key in metrics:
+                compact[key] = metrics.get(key)
+
+        list_count_keys = {
+            "configured_tool_names": "configured_count",
+            "matched_tool_names": "matched_count",
+            "missing_tool_names": "missing_count",
+            "forced_tool_names": "forced_count",
+            "selected_system_prompt_keys": "selected_system_prompt_count",
+        }
+        for source_key, target_key in list_count_keys.items():
+            value = metrics.get(source_key)
+            if isinstance(value, list):
+                compact[target_key] = len(value)
+
+        hook_metadata = metrics.get("hook_metadata")
+        if isinstance(hook_metadata, dict):
+            for key in ("top_k", "top_n", "min_confidence", "shadow_mode"):
+                if key in hook_metadata:
+                    compact[key] = hook_metadata.get(key)
+            selected_tool_names = hook_metadata.get("selected_tool_names")
+            if isinstance(selected_tool_names, list):
+                compact["hook_selected_count"] = len(selected_tool_names)
+            ranked_tools_preview = hook_metadata.get("ranked_tools_preview")
+            if isinstance(ranked_tools_preview, list):
+                compact["ranked_preview_count"] = len(ranked_tools_preview)
+
+        return compact
+
 
     def _create_sql_retry_prompt(self, function_name: str, sql_query: str, db_error: str) -> str:
         return f"""

{iatoolkit-2.45.1 → iatoolkit-2.45.3}/src/iatoolkit/services/operator_identity_service.py

@@ -39,6 +39,17 @@ class OperatorIdentityService:
     SETTING_NAMES = ("IAT_OPERATOR_COMPANY", "IAT_BILLING_COMPANY_SHORT_NAME")
     SETTING_NAME = SETTING_NAMES[0]
 
+    #: Held on the class, not the instance. Callers that have a repository at hand
+    #: build their own instance rather than asking the injector, so an instance
+    #: cache resolved — and logged, and queried the database — once per request
+    #: instead of once per process.
+    _resolved: str | None = None
+
+    @classmethod
+    def reset_cache(cls) -> None:
+        """Forget the resolved name. For tests: it cannot change at runtime."""
+        OperatorIdentityService._resolved = None
+
     @classmethod
     def stated_name(cls) -> str:
         """What this deployment calls its operator, without checking it exists.
@@ -57,7 +68,6 @@ class OperatorIdentityService:
     @inject
     def __init__(self, profile_repo: ProfileRepo):
         self.profile_repo = profile_repo
-        self._resolved: str | None = None
 
     def company_short_name(self) -> str:
         """The operator company, resolved once per process.
@@ -65,24 +75,24 @@ class OperatorIdentityService:
         Cached because the answer cannot change without a deployment, and this is
         read on paths that run per request and per invoice.
         """
-        if self._resolved:
-            return self._resolved
+        if OperatorIdentityService._resolved:
+            return OperatorIdentityService._resolved
 
         for setting in self.SETTING_NAMES:
             configured = (os.getenv(setting) or "").strip().lower()
             if configured:
-                self._resolved = configured
+                OperatorIdentityService._resolved = configured
                 logging.info("Operator company: '%s' (from %s).", configured, setting)
-                return self._resolved
+                return configured
 
         if self._company_exists(self.LEGACY_COMPANY_SHORT_NAME):
-            self._resolved = self.LEGACY_COMPANY_SHORT_NAME
+            OperatorIdentityService._resolved = self.LEGACY_COMPANY_SHORT_NAME
             logging.info(
                 "Operator company: '%s' (default). Set %s to name it explicitly.",
-                self._resolved,
+                OperatorIdentityService._resolved,
                 self.SETTING_NAME,
             )
-            return self._resolved
+            return OperatorIdentityService._resolved
 
         # Deliberately loud. The alternative is what used to happen: a name from
         # another deployment travels down to the payment configuration and the

{iatoolkit-2.45.1 → iatoolkit-2.45.3/src/iatoolkit.egg-info}/PKG-INFO

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

iatoolkit-2.45.1/src/iatoolkit/infra/llm_providers/openrouter_adapter.py

@@ -1,65 +0,0 @@
-# Copyright (c) 2024 Fernando Libedinsky
-# Product: IAToolkit
-#
-# IAToolkit is open source software.
-
-from typing import Any, Dict
-
-from iatoolkit.infra.llm_providers.openai_compatible_chat_adapter import OpenAICompatibleChatAdapter
-
-
-class OpenRouterAdapter(OpenAICompatibleChatAdapter):
-    """OpenRouter-specific adapter built on top of the shared chat.completions core."""
-
-    supports_multimodal = True
-    supports_reasoning = False
-    supports_reasoning_content_messages = True
-    supports_reasoning_details_messages = True
-    reasoning_content_message_field = "reasoning"
-    supports_metadata = True
-    supports_parallel_tool_calls = True
-
-    def __init__(self, openrouter_client):
-        super().__init__(openai_compatible_client=openrouter_client, provider_label="OpenRouter")
-
-    def _extend_call_kwargs(self, call_kwargs: Dict[str, Any], kwargs: Dict[str, Any]) -> None:
-        text = kwargs.get("text") or {}
-        verbosity = text.get("verbosity") if isinstance(text, dict) else None
-        if verbosity:
-            call_kwargs["verbosity"] = verbosity
-
-        passthrough_keys = (
-            "service_tier",
-            "temperature",
-            "top_p",
-            "max_tokens",
-            "max_completion_tokens",
-            "seed",
-            "stop",
-            "stream",
-            "stream_options",
-            "modalities",
-            "user",
-        )
-        for key in passthrough_keys:
-            if kwargs.get(key) is not None:
-                call_kwargs[key] = kwargs.get(key)
-
-        extra_body = dict(call_kwargs.get("extra_body") or {})
-
-        reasoning_payload = self._build_reasoning_payload(kwargs.get("reasoning"), kwargs)
-        if reasoning_payload:
-            extra_body["reasoning"] = reasoning_payload
-
-        vendor_specific_keys = (
-            "models",
-            "provider",
-            "plugins",
-            "session_id",
-        )
-        for key in vendor_specific_keys:
-            if kwargs.get(key) is not None:
-                extra_body[key] = kwargs.get(key)
-
-        if extra_body:
-            call_kwargs["extra_body"] = extra_body