iatoolkit 2.35.0__tar.gz → 2.36.0__tar.gz

{iatoolkit-2.35.0/src/iatoolkit.egg-info → iatoolkit-2.36.0}/PKG-INFO

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

{iatoolkit-2.35.0 → iatoolkit-2.36.0}/src/iatoolkit/__init__.py

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

{iatoolkit-2.35.0 → iatoolkit-2.36.0}/src/iatoolkit/locales/en.yaml

@@ -91,6 +91,8 @@ ui:
       telemetry_not_recorded: "Not recorded"
       telemetry_disabled: "Disabled"
       telemetry_unknown_provider: "unknown provider"
+      attached_files: "Attached Files"
+      open_attachment: "Open {filename}"
 
   communications:
     title: "Communications"

{iatoolkit-2.35.0 → iatoolkit-2.36.0}/src/iatoolkit/locales/es.yaml

@@ -92,6 +92,8 @@ ui:
       telemetry_not_recorded: "No registrada"
       telemetry_disabled: "Deshabilitada"
       telemetry_unknown_provider: "provider desconocido"
+      attached_files: "Archivos adjuntos"
+      open_attachment: "Abrir {filename}"
 
   communications:
     title: "Communications"

{iatoolkit-2.35.0 → iatoolkit-2.36.0}/src/iatoolkit/services/http_tool_service.py

@@ -7,6 +7,7 @@ import base64
 import ipaddress
 import json
 import socket
+from typing import Callable
 from urllib.parse import urlparse
 from injector import inject
 from iatoolkit.common.exceptions import IAToolkitException
@@ -27,6 +28,25 @@ class HttpToolService:
         self.secret_provider = secret_provider
         self.config_service = config_service
 
+        # Registry of alternate transports for execution_config.transport
+        # values other than the built-in "direct". Populated by plugins
+        # (e.g. Enterprise's bridge integration) via register_transport() —
+        # this module has no knowledge of what a "bridge" is.
+        self._transports: dict[str, Callable] = {}
+
+    def register_transport(self, name: str, handler: Callable):
+        """
+        Registers a handler for execution_config.transport == name (other
+        than "direct", which is built in). handler is called as:
+
+            handler(company_short_name=..., tool_name=..., execution_config=...,
+                     bridge_id=..., target=..., method=..., path=...,
+                     query_params=..., headers=..., body=..., timeout_ms=...)
+
+        and must return (response_data, status_code).
+        """
+        self._transports[name] = handler
+
     def execute(self,
                 company_short_name: str,
                 tool_name: str,
@@ -38,6 +58,18 @@ class HttpToolService:
                 f"Invalid execution_config for HTTP tool '{tool_name}'"
             )
 
+        transport = str(execution_config.get("transport") or "direct").lower()
+        if transport != "direct":
+            return self._execute_via_transport(
+                transport, company_short_name, tool_name, execution_config, input_data)
+
+        return self._execute_direct(company_short_name, tool_name, execution_config, input_data)
+
+    def _execute_direct(self,
+                         company_short_name: str,
+                         tool_name: str,
+                         execution_config: dict,
+                         input_data: dict) -> dict:
         request_cfg = execution_config.get("request") or {}
         method = str(request_cfg.get("method", "")).upper()
         url = str(request_cfg.get("url", ""))
@@ -72,6 +104,56 @@ class HttpToolService:
             status_code=status_code,
         )
 
+    def _execute_via_transport(self,
+                                transport: str,
+                                company_short_name: str,
+                                tool_name: str,
+                                execution_config: dict,
+                                input_data: dict) -> dict:
+        handler = self._transports.get(transport)
+        if not handler:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.INVALID_PARAMETER,
+                f"HTTP tool '{tool_name}' uses transport '{transport}', which is not registered"
+            )
+
+        request_cfg = execution_config.get("request") or {}
+        method = str(request_cfg.get("method", "")).upper()
+        target = str(request_cfg.get("target", ""))
+        bridge_id = str(execution_config.get("bridge_id", ""))
+
+        if not method or not target:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.INVALID_PARAMETER,
+                f"Invalid request config for HTTP tool '{tool_name}'"
+            )
+
+        params = self._build_query_params(request_cfg, input_data)
+        path = self._render_path_params(request_cfg.get("path") or "", request_cfg, input_data)
+        json_payload = self._build_json_payload(request_cfg, input_data)
+        timeout_ms = request_cfg.get("timeout_ms") or 30000
+
+        response_data, status_code = handler(
+            company_short_name=company_short_name,
+            tool_name=tool_name,
+            execution_config=execution_config,
+            bridge_id=bridge_id,
+            target=target,
+            method=method,
+            path=path,
+            query_params=params,
+            headers=request_cfg.get("headers") or {},
+            body=json_payload,
+            timeout_ms=timeout_ms,
+        )
+
+        return self._build_response(
+            tool_name=tool_name,
+            execution_config=execution_config,
+            response_data=response_data,
+            status_code=status_code,
+        )
+
     def _call(self,
               method: str,
               url: str,

{iatoolkit-2.35.0 → iatoolkit-2.36.0}/src/iatoolkit/services/tool_service.py

@@ -36,6 +36,7 @@ class ToolService:
     HTTP_ALLOWED_AUTH_TYPES = {"none", "bearer", "api_key_header", "api_key_query", "basic"}
     HTTP_ALLOWED_RESPONSE_MODES = {"json", "text", "raw"}
     HTTP_ALLOWED_MODEL_OUTPUT_MODES = {"raw", "extract", "map"}
+    HTTP_ALLOWED_TRANSPORTS = {"direct", "bridge"}
 
     TOOL_EVENT_CREATED = "created"
     TOOL_EVENT_UPDATED = "updated"
@@ -457,6 +458,18 @@ class ToolService:
                 "execution_config.version must be 1"
             )
 
+        transport = str(execution_config.get("transport", "direct")).lower()
+        if transport not in self.HTTP_ALLOWED_TRANSPORTS:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.INVALID_PARAMETER,
+                f"execution_config.transport must be one of {sorted(self.HTTP_ALLOWED_TRANSPORTS)}"
+            )
+        if transport == "bridge" and not str(execution_config.get("bridge_id") or "").strip():
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.INVALID_PARAMETER,
+                "execution_config.bridge_id is required when transport is 'bridge'"
+            )
+
         request_cfg = execution_config.get("request")
         if not isinstance(request_cfg, dict):
             raise IAToolkitException(
@@ -471,58 +484,70 @@ class ToolService:
                 f"execution_config.request.method must be one of {sorted(self.HTTP_ALLOWED_METHODS)}"
             )
 
-        url = request_cfg.get("url")
-        if not isinstance(url, str) or not url.strip():
-            raise IAToolkitException(
-                IAToolkitException.ErrorType.INVALID_PARAMETER,
-                "execution_config.request.url is required and must be a non-empty string"
-            )
-
-        security_cfg = execution_config.get("security")
-        allow_private_network = False
-        if security_cfg is not None:
-            if not isinstance(security_cfg, dict):
+        # For transport='bridge', the hosted side never names a host/URL — it names a
+        # `target` that the bridge itself resolves against its own allowlist. There is
+        # no URL here to apply the direct-transport SSRF/scheme checks against.
+        if transport == "bridge":
+            target = request_cfg.get("target")
+            if not isinstance(target, str) or not target.strip():
                 raise IAToolkitException(
                     IAToolkitException.ErrorType.INVALID_PARAMETER,
-                    "execution_config.security must be a JSON object"
+                    "execution_config.request.target is required and must be a non-empty string "
+                    "when transport is 'bridge'"
+                )
+        else:
+            url = request_cfg.get("url")
+            if not isinstance(url, str) or not url.strip():
+                raise IAToolkitException(
+                    IAToolkitException.ErrorType.INVALID_PARAMETER,
+                    "execution_config.request.url is required and must be a non-empty string"
                 )
 
-            allowed_hosts = security_cfg.get("allowed_hosts")
-            if allowed_hosts is not None:
-                if not isinstance(allowed_hosts, list):
+            security_cfg = execution_config.get("security")
+            allow_private_network = False
+            if security_cfg is not None:
+                if not isinstance(security_cfg, dict):
                     raise IAToolkitException(
                         IAToolkitException.ErrorType.INVALID_PARAMETER,
-                        "execution_config.security.allowed_hosts must be a list"
+                        "execution_config.security must be a JSON object"
                     )
-                for host in allowed_hosts:
-                    if not isinstance(host, str) or not host.strip():
+
+                allowed_hosts = security_cfg.get("allowed_hosts")
+                if allowed_hosts is not None:
+                    if not isinstance(allowed_hosts, list):
                         raise IAToolkitException(
                             IAToolkitException.ErrorType.INVALID_PARAMETER,
-                            "execution_config.security.allowed_hosts must contain non-empty strings"
+                            "execution_config.security.allowed_hosts must be a list"
                         )
+                    for host in allowed_hosts:
+                        if not isinstance(host, str) or not host.strip():
+                            raise IAToolkitException(
+                                IAToolkitException.ErrorType.INVALID_PARAMETER,
+                                "execution_config.security.allowed_hosts must contain non-empty strings"
+                            )
 
-            allow_private_network_value = security_cfg.get("allow_private_network", False)
-            if not isinstance(allow_private_network_value, bool):
+                allow_private_network_value = security_cfg.get("allow_private_network", False)
+                if not isinstance(allow_private_network_value, bool):
+                    raise IAToolkitException(
+                        IAToolkitException.ErrorType.INVALID_PARAMETER,
+                        "execution_config.security.allow_private_network must be a boolean"
+                    )
+                allow_private_network = allow_private_network_value
+
+            parsed = urlparse(url)
+            scheme = parsed.scheme.lower()
+            allowed_schemes = {"https", "http"} if allow_private_network else {"https"}
+            if scheme not in allowed_schemes or not parsed.netloc:
+                message = "execution_config.request.url must be an absolute HTTPS URL"
+                if allow_private_network:
+                    message = (
+                        "execution_config.request.url must be an absolute HTTP or HTTPS URL "
+                        "when allow_private_network=true"
+                    )
                 raise IAToolkitException(
                     IAToolkitException.ErrorType.INVALID_PARAMETER,
-                    "execution_config.security.allow_private_network must be a boolean"
-                )
-            allow_private_network = allow_private_network_value
-
-        parsed = urlparse(url)
-        scheme = parsed.scheme.lower()
-        allowed_schemes = {"https", "http"} if allow_private_network else {"https"}
-        if scheme not in allowed_schemes or not parsed.netloc:
-            message = "execution_config.request.url must be an absolute HTTPS URL"
-            if allow_private_network:
-                message = (
-                    "execution_config.request.url must be an absolute HTTP or HTTPS URL "
-                    "when allow_private_network=true"
+                    message
                 )
-            raise IAToolkitException(
-                IAToolkitException.ErrorType.INVALID_PARAMETER,
-                message
-            )
 
         timeout_ms = request_cfg.get("timeout_ms")
         if timeout_ms is not None:

{iatoolkit-2.35.0 → iatoolkit-2.36.0/src/iatoolkit.egg-info}/PKG-INFO

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