iatoolkit 2.20.1__tar.gz → 2.20.3__tar.gz

{iatoolkit-2.20.1/src/iatoolkit.egg-info → iatoolkit-2.20.3}/PKG-INFO

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

{iatoolkit-2.20.1 → iatoolkit-2.20.3}/src/iatoolkit/__init__.py

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

{iatoolkit-2.20.1 → iatoolkit-2.20.3}/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.1 → iatoolkit-2.20.3}/src/iatoolkit/services/http_tool_service.py

@@ -50,7 +50,11 @@ class HttpToolService:
         url = self._render_path_params(url, request_cfg, input_data)
         self._validate_target_url(company_short_name, execution_config, url)
 
-        headers = dict(request_cfg.get("headers") or {})
+        headers = self._resolve_request_headers(
+            company_short_name=company_short_name,
+            request_cfg=request_cfg,
+            url=url,
+        )
         self._apply_auth(company_short_name, execution_config, headers, params)
 
         json_payload = self._build_json_payload(request_cfg, input_data)
@@ -89,6 +93,93 @@ class HttpToolService:
             f"HTTP method '{method}' is not supported"
         )
 
+    def _resolve_request_headers(self,
+                                 company_short_name: str,
+                                 request_cfg: dict,
+                                 url: str) -> dict:
+        company_params = self.config_service.get_configuration(company_short_name, "parameters") or {}
+        http_tools_cfg = company_params.get("http_tools") or {}
+        host = (urlparse(url).hostname or "").strip().lower()
+
+        merged_headers = {}
+        self._merge_headers_case_insensitive(
+            merged_headers,
+            self._build_builtin_default_headers(company_short_name),
+            field_name="builtin_default_headers",
+        )
+        self._merge_headers_case_insensitive(
+            merged_headers,
+            http_tools_cfg.get("default_headers"),
+            field_name="parameters.http_tools.default_headers",
+        )
+
+        host_headers_cfg = http_tools_cfg.get("host_headers")
+        if host_headers_cfg is not None:
+            if not isinstance(host_headers_cfg, dict):
+                raise IAToolkitException(
+                    IAToolkitException.ErrorType.INVALID_PARAMETER,
+                    "parameters.http_tools.host_headers must be a JSON object"
+                )
+            for host_pattern, headers in host_headers_cfg.items():
+                if not isinstance(host_pattern, str) or not host_pattern.strip():
+                    raise IAToolkitException(
+                        IAToolkitException.ErrorType.INVALID_PARAMETER,
+                        "parameters.http_tools.host_headers keys must be non-empty strings"
+                    )
+                if self._host_matches_pattern(host, host_pattern.strip().lower()):
+                    self._merge_headers_case_insensitive(
+                        merged_headers,
+                        headers,
+                        field_name=f"parameters.http_tools.host_headers.{host_pattern}",
+                    )
+
+        self._merge_headers_case_insensitive(
+            merged_headers,
+            request_cfg.get("headers"),
+            field_name="execution_config.request.headers",
+        )
+        return merged_headers
+
+    @staticmethod
+    def _build_builtin_default_headers(company_short_name: str) -> dict:
+        return {
+            "User-Agent": f"IAToolkit-HTTPTool/1.0 (company={company_short_name})",
+        }
+
+    def _merge_headers_case_insensitive(self,
+                                        target: dict,
+                                        headers: dict | None,
+                                        field_name: str) -> None:
+        if headers is None:
+            return
+        if not isinstance(headers, dict):
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.INVALID_PARAMETER,
+                f"{field_name} must be a JSON object"
+            )
+
+        existing_keys = {str(key).lower(): key for key in target.keys()}
+        for raw_key, raw_value in headers.items():
+            if not isinstance(raw_key, str) or not raw_key.strip():
+                raise IAToolkitException(
+                    IAToolkitException.ErrorType.INVALID_PARAMETER,
+                    f"{field_name} must contain non-empty string header names"
+                )
+            if raw_value is None:
+                continue
+            if not isinstance(raw_value, str):
+                raise IAToolkitException(
+                    IAToolkitException.ErrorType.INVALID_PARAMETER,
+                    f"{field_name} must contain string header values"
+                )
+            normalized_key = raw_key.strip()
+            lookup_key = normalized_key.lower()
+            existing_key = existing_keys.get(lookup_key)
+            if existing_key and existing_key != normalized_key:
+                target.pop(existing_key, None)
+            target[normalized_key] = raw_value
+            existing_keys[lookup_key] = normalized_key
+
     def _validate_target_url(self, company_short_name: str, execution_config: dict, url: str):
         parsed = urlparse(url)
         host = (parsed.hostname or "").strip().lower()

{iatoolkit-2.20.1 → iatoolkit-2.20.3/src/iatoolkit.egg-info}/PKG-INFO

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