iatoolkit 2.20.2__tar.gz → 2.20.4__tar.gz

{iatoolkit-2.20.2/src/iatoolkit.egg-info → iatoolkit-2.20.4}/PKG-INFO

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

{iatoolkit-2.20.2 → iatoolkit-2.20.4}/src/iatoolkit/__init__.py

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

{iatoolkit-2.20.2 → iatoolkit-2.20.4}/src/iatoolkit/infra/llm_proxy.py

@@ -414,6 +414,15 @@ class LLMProxy:
 
         with self._clients_cache_lock:
             if cache_key in self._clients_cache:
+                logging.debug(
+                    "Reusing LLM client provider='%s' base_url='%s' connect_timeout=%s read_timeout=%s max_retries=%s headers=%s",
+                    provider,
+                    base_url or "(default)",
+                    connect_timeout_seconds,
+                    read_timeout_seconds,
+                    max_retries,
+                    self._summarize_headers(default_headers),
+                )
                 return self._clients_cache[cache_key]
 
             client = self._create_client_for_provider(
@@ -425,6 +434,15 @@ class LLMProxy:
                 read_timeout_seconds=read_timeout_seconds,
                 max_retries=max_retries,
             )
+            logging.debug(
+                "Created LLM client provider='%s' base_url='%s' connect_timeout=%s read_timeout=%s max_retries=%s headers=%s",
+                provider,
+                base_url or "(default)",
+                connect_timeout_seconds,
+                read_timeout_seconds,
+                max_retries,
+                self._summarize_headers(default_headers),
+            )
             self._clients_cache[cache_key] = client
             return client
 
@@ -605,6 +623,17 @@ class LLMProxy:
             ),
         }
 
+    @staticmethod
+    def _summarize_headers(headers: Dict[str, str] | None) -> Dict[str, str]:
+        summarized = {}
+        for key, value in dict(headers or {}).items():
+            normalized_key = str(key or "").strip().lower()
+            if normalized_key in {"authorization", "cf-aig-authorization", "x-api-key"}:
+                summarized[str(key)] = "<redacted>"
+            else:
+                summarized[str(key)] = str(value)
+        return summarized
+
     @classmethod
     def _build_openai_timeout(
         cls,

{iatoolkit-2.20.2 → iatoolkit-2.20.4}/src/iatoolkit/services/dispatcher_service.py

@@ -8,6 +8,7 @@ from iatoolkit.repositories.llm_query_repo import LLMQueryRepo
 from iatoolkit.services.inference_service import InferenceService
 from iatoolkit.common.util import Utility
 from injector import inject
+import inspect
 import logging
 
 
@@ -38,6 +39,22 @@ class Dispatcher:
         except Exception as rollback_error:
             logging.warning(f"Dispatcher rollback failed: {rollback_error}")
 
+    @staticmethod
+    def _native_method_accepts_user_identifier(method) -> bool:
+        """Returns True when a native tool can safely receive user_identifier."""
+        try:
+            signature = inspect.signature(method)
+        except (TypeError, ValueError):
+            return False
+
+        if "user_identifier" in signature.parameters:
+            return True
+
+        return any(
+            parameter.kind == inspect.Parameter.VAR_KEYWORD
+            for parameter in signature.parameters.values()
+        )
+
     @property
     def tool_service(self):
         """Lazy-loads and returns the ToolService instance to avoid circular imports."""
@@ -145,7 +162,10 @@ class Dispatcher:
                     )
 
                 # Execute the method directly in the company class
-                return method(**kwargs)
+                native_kwargs = dict(kwargs)
+                if user_identifier and self._native_method_accepts_user_identifier(method):
+                    native_kwargs["user_identifier"] = user_identifier
+                return method(**native_kwargs)
 
             except IAToolkitException as e:
                 self._safe_rollback()

{iatoolkit-2.20.2 → iatoolkit-2.20.4}/src/iatoolkit/services/embedding_service.py

@@ -13,6 +13,7 @@ from iatoolkit.services.configuration_service import ConfigurationService
 from iatoolkit.services.i18n_service import I18nService
 from iatoolkit.repositories.profile_repo import ProfileRepo
 from iatoolkit.infra.call_service import CallServiceClient
+from iatoolkit.infra.llm_gateway_resolver import LLMGatewayResolver
 from iatoolkit.services.inference_service import InferenceService
 import logging
 import importlib
@@ -168,11 +169,16 @@ class EmbeddingClientFactory:
                  config_service: ConfigurationService,
                  call_service: CallServiceClient,
                  inference_service: InferenceService,
-                 secret_provider: SecretProvider):
+                 secret_provider: SecretProvider,
+                 gateway_resolver: LLMGatewayResolver | None = None):
         self.config_service = config_service
         self.call_service = call_service
         self.inference_service = inference_service
         self.secret_provider = secret_provider
+        self.gateway_resolver = gateway_resolver or LLMGatewayResolver(
+            configuration_service=config_service,
+            secret_provider=secret_provider,
+        )
         self._clients = {}  # Cache for storing initialized client wrappers
 
     def get_client(self, company_short_name: str, model_type: str = 'text') -> EmbeddingClientWrapper:
@@ -270,9 +276,12 @@ class EmbeddingClientFactory:
             )
 
         elif provider == 'openai':
-            api_key = self._get_api_key_from_config(company_short_name, embedding_config)
-
-            client = OpenAI(api_key=api_key)
+            client_config = self._get_openai_client_config(company_short_name, embedding_config)
+            client = OpenAI(
+                api_key=client_config["api_key"],
+                base_url=client_config["base_url"] or None,
+                default_headers=client_config["default_headers"] or None,
+            )
             if not model:
                 model='text-embedding-ada-002'
             wrapper = OpenAIClientWrapper(client, model, dimensions)
@@ -292,17 +301,70 @@ class EmbeddingClientFactory:
         for key in keys_to_clear:
             self._clients.pop(key, None)
 
-    def _get_api_key_from_config(self, company_short_name: str, embedding_config: dict):
+    def _get_openai_client_config(self, company_short_name: str, embedding_config: dict) -> dict:
+        provider_api_key = self._get_api_key_from_config(
+            company_short_name,
+            embedding_config,
+            required=False,
+        )
+        gateway_transport = self.gateway_resolver.resolve(
+            company_short_name=company_short_name,
+            provider="openai",
+            provider_api_key=provider_api_key,
+        )
+        if gateway_transport.get("enabled"):
+            logging.debug(
+                "Embedding gateway enabled for company='%s' provider='openai' vendor='%s' mode='%s' credential_mode='%s' base_url='%s' headers=%s",
+                company_short_name,
+                gateway_transport.get("vendor"),
+                gateway_transport.get("mode"),
+                gateway_transport.get("credential_mode"),
+                gateway_transport.get("base_url"),
+                self._summarize_headers(gateway_transport.get("default_headers")),
+            )
+            return {
+                "api_key": gateway_transport.get("api_key", provider_api_key) or "",
+                "base_url": gateway_transport.get("base_url") or "",
+                "default_headers": dict(gateway_transport.get("default_headers") or {}),
+            }
+
+        resolved_api_key = provider_api_key or self._get_api_key_from_config(
+            company_short_name,
+            embedding_config,
+            required=True,
+        )
+        return {
+            "api_key": resolved_api_key,
+            "base_url": "",
+            "default_headers": {},
+        }
+
+    def _get_api_key_from_config(self, company_short_name: str, embedding_config: dict, *, required: bool = True):
         api_key_ref = embedding_config.get('api_key_secret_ref') or embedding_config.get('api_key_name')
         if not api_key_ref:
-            raise ValueError("Missing configuration for embedding api_key_secret_ref (or legacy api_key_name).")
+            if required:
+                raise ValueError("Missing configuration for embedding api_key_secret_ref (or legacy api_key_name).")
+            return ""
 
         api_key = resolve_secret(self.secret_provider, company_short_name, api_key_ref)
         if not api_key:
-            raise ValueError(f"Secret reference '{api_key_ref}' is not set.")
+            if required:
+                raise ValueError(f"Secret reference '{api_key_ref}' is not set.")
+            return ""
 
         return api_key
 
+    @staticmethod
+    def _summarize_headers(headers: dict | None) -> dict:
+        summarized = {}
+        for key, value in dict(headers or {}).items():
+            normalized_key = str(key or "").strip().lower()
+            if normalized_key in {"authorization", "cf-aig-authorization", "x-api-key"}:
+                summarized[str(key)] = "<redacted>"
+            else:
+                summarized[str(key)] = str(value)
+        return summarized
+
 
 class EmbeddingService:
     """

{iatoolkit-2.20.2 → iatoolkit-2.20.4/src/iatoolkit.egg-info}/PKG-INFO

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