iatoolkit 2.21.3__tar.gz → 2.22.0__tar.gz

{iatoolkit-2.21.3/src/iatoolkit.egg-info → iatoolkit-2.22.0}/PKG-INFO

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

{iatoolkit-2.21.3 → iatoolkit-2.22.0}/src/iatoolkit/__init__.py

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

{iatoolkit-2.21.3 → iatoolkit-2.22.0}/src/iatoolkit/locales/en.yaml

@@ -1594,7 +1594,7 @@ ui:
     execution_hint_native: "Native tools execute through toolkit runtime code, so there is no editable execution_config here."
     inference_execution_hint: "This tool type does not expose an editable execution_config in the GUI. Use the Output tab to document what the runtime returns."
     native_execution_hint: "This tool type executes through internal runtime code. There is no editable execution_config in this editor."
-    raw_hint: "Edit the full tool definition as YAML. This advanced mode includes parameters, execution_config, output_contract, and routing_profile."
+    raw_hint: "Edit the full tool definition as YAML. This advanced mode includes parameters, execution_config, execution_config.response.model_output, output_contract, and routing_profile."
     raw_footer_hint: "Saving from Raw uses this document as the source of truth for the tool definition."
 
     # Modal
@@ -1626,6 +1626,8 @@ ui:
     http_config_help_post_example: "POST example (Bearer from secrets_manager)"
     output_contract_title: "Output Contract"
     output_contract_hint: "Optional. Use YAML/JSON to describe the returned artifact, for example kind/image/file/audio/video plus transport and field names such as image_url or download_link."
+    model_output_title: "Model Output"
+    model_output_hint: "Define the final JSON returned to the model after the HTTP response is received. Default mode is raw."
     modal_output_contract_label: "Initial output_contract"
     modal_output_contract_placeholder: "kind: image\nmime_type: image/png\ntransport: signed_url\nurl_field: image_url"
     routing_profile_title: "Routing Profile"
@@ -2608,6 +2610,19 @@ js_messages:
   tool_http_response_codes_required: "response.success_status_codes must be a non-empty list"
   tool_http_response_codes_invalid: "response.success_status_codes must contain valid HTTP status codes (100..599)"
   tool_http_response_bytes_invalid: "response.max_response_bytes must be a positive integer"
+  tool_http_model_output_label: "model_output"
+  tool_http_model_output_object: "model_output must be an object"
+  tool_http_model_output_unknown_keys: "model_output has unsupported keys: {keys}"
+  tool_http_model_output_mode_invalid: "model_output.mode must be one of raw, extract, map"
+  tool_http_model_output_path_required: "model_output.path is required when mode=extract"
+  tool_http_model_output_root_invalid: "model_output.root must be a non-empty string"
+  tool_http_model_output_fields_required: "model_output.fields must be a non-empty object when mode=map"
+  tool_http_model_output_field_name_invalid: "model_output.fields must use non-empty field names"
+  tool_http_model_output_field_path_required: "model_output.fields.{field} must define a path"
+  tool_http_model_output_field_description_invalid: "model_output.fields.{field}.description must be a string"
+  tool_http_model_output_field_invalid: "model_output.fields.{field} must be a path string or object"
+  tool_http_model_output_exclude_nulls_invalid: "model_output.exclude_nulls must be a boolean"
+  tool_http_model_output_max_items_invalid: "model_output.max_items must be a positive integer"
   tool_error_loading_tools: "Error loading tools"
   tool_no_tools_found: "No tools found."
   tool_pack_read_only: "PACK tools are read-only. Use Clone to USER."

{iatoolkit-2.21.3 → iatoolkit-2.22.0}/src/iatoolkit/locales/es.yaml

@@ -1598,7 +1598,7 @@ ui:
     execution_hint_native: "Las tools nativas se ejecutan en código interno del runtime, por eso aquí no existe un execution_config editable."
     inference_execution_hint: "Este tipo de tool no expone un execution_config editable en la GUI. Usa el tab Output para documentar qué devuelve el runtime."
     native_execution_hint: "Este tipo de tool se ejecuta mediante código interno del runtime. No hay un execution_config editable en este editor."
-    raw_hint: "Edita la definición completa de la tool como YAML. Este modo avanzado incluye parameters, execution_config, output_contract y routing_profile."
+    raw_hint: "Edita la definición completa de la tool como YAML. Este modo avanzado incluye parameters, execution_config, execution_config.response.model_output, output_contract y routing_profile."
     raw_footer_hint: "Guardar desde Raw usa este documento como source of truth de la definición de la tool."
 
     # Modal
@@ -1630,6 +1630,8 @@ ui:
     http_config_help_post_example: "Ejemplo POST (Bearer desde secrets_manager)"
     output_contract_title: "Output Contract"
     output_contract_hint: "Opcional. Usa YAML/JSON para describir el artefacto devuelto, por ejemplo kind/image/file/audio/video más transport y nombres de campos como image_url o download_link."
+    model_output_title: "Model Output"
+    model_output_hint: "Define el JSON final que recibe el modelo después de ejecutar la tool HTTP. El modo por defecto es raw."
     modal_output_contract_label: "output_contract inicial"
     modal_output_contract_placeholder: "kind: image\nmime_type: image/png\ntransport: signed_url\nurl_field: image_url"
     routing_profile_title: "Routing Profile"
@@ -2611,6 +2613,19 @@ js_messages:
   tool_http_response_codes_required: "response.success_status_codes debe ser una lista no vacía"
   tool_http_response_codes_invalid: "response.success_status_codes debe contener códigos HTTP válidos (100..599)"
   tool_http_response_bytes_invalid: "response.max_response_bytes debe ser un entero positivo"
+  tool_http_model_output_label: "model_output"
+  tool_http_model_output_object: "model_output debe ser un objeto"
+  tool_http_model_output_unknown_keys: "model_output tiene claves no soportadas: {keys}"
+  tool_http_model_output_mode_invalid: "model_output.mode debe ser uno de raw, extract, map"
+  tool_http_model_output_path_required: "model_output.path es obligatorio cuando mode=extract"
+  tool_http_model_output_root_invalid: "model_output.root debe ser un string no vacío"
+  tool_http_model_output_fields_required: "model_output.fields debe ser un objeto no vacío cuando mode=map"
+  tool_http_model_output_field_name_invalid: "model_output.fields debe usar nombres de campo no vacíos"
+  tool_http_model_output_field_path_required: "model_output.fields.{field} debe definir un path"
+  tool_http_model_output_field_description_invalid: "model_output.fields.{field}.description debe ser un string"
+  tool_http_model_output_field_invalid: "model_output.fields.{field} debe ser un path string u objeto"
+  tool_http_model_output_exclude_nulls_invalid: "model_output.exclude_nulls debe ser booleano"
+  tool_http_model_output_max_items_invalid: "model_output.max_items debe ser un entero positivo"
   tool_error_loading_tools: "Error cargando herramientas"
   tool_no_tools_found: "No se encontraron herramientas."
   tool_pack_read_only: "Las herramientas PACK son de solo lectura. Usa Clonar a USER."

{iatoolkit-2.21.3 → iatoolkit-2.22.0}/src/iatoolkit/services/http_tool_service.py

@@ -512,6 +512,8 @@ class HttpToolService:
         if extract_path:
             value = self._extract_path(response_data, str(extract_path))
 
+        value = self._apply_model_output(value, response_cfg.get("model_output"))
+
         if mode == "text" and not isinstance(value, str):
             value = json.dumps(value, ensure_ascii=False, default=str)
 
@@ -553,3 +555,94 @@ class HttpToolService:
                 )
 
         return current
+
+    def _apply_model_output(self, value, model_output):
+        if model_output in (None, {}, ""):
+            return value
+        if not isinstance(model_output, dict):
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.INVALID_PARAMETER,
+                "execution_config.response.model_output must be a JSON object"
+            )
+
+        mode = str(model_output.get("mode", "raw")).strip().lower()
+        if mode == "raw":
+            return value
+        if mode == "extract":
+            path = str(model_output.get("path") or "").strip()
+            if not path:
+                raise IAToolkitException(
+                    IAToolkitException.ErrorType.INVALID_PARAMETER,
+                    "execution_config.response.model_output.path is required when mode is 'extract'"
+                )
+            return self._extract_path(value, path)
+        if mode == "map":
+            return self._apply_mapped_model_output(value, model_output)
+
+        raise IAToolkitException(
+            IAToolkitException.ErrorType.INVALID_PARAMETER,
+            f"Unsupported execution_config.response.model_output.mode '{mode}'"
+        )
+
+    def _apply_mapped_model_output(self, value, model_output: dict):
+        root_path = str(model_output.get("root") or "").strip()
+        source = self._extract_path(value, root_path) if root_path else value
+        fields = model_output.get("fields") or {}
+        if not isinstance(fields, dict) or not fields:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.INVALID_PARAMETER,
+                "execution_config.response.model_output.fields must be a non-empty object when mode is 'map'"
+            )
+
+        exclude_nulls = model_output.get("exclude_nulls") is True
+        max_items = model_output.get("max_items")
+
+        if isinstance(source, list):
+            items = (
+                source[:max_items]
+                if isinstance(max_items, int) and not isinstance(max_items, bool) and max_items > 0
+                else source
+            )
+            return [
+                self._map_model_output_item(item, fields, exclude_nulls)
+                for item in items
+            ]
+        if isinstance(source, dict):
+            return self._map_model_output_item(source, fields, exclude_nulls)
+
+        raise IAToolkitException(
+            IAToolkitException.ErrorType.INVALID_PARAMETER,
+            f"Cannot map model_output over type '{type(source).__name__}'"
+        )
+
+    def _map_model_output_item(self, source: dict, fields: dict, exclude_nulls: bool) -> dict:
+        mapped = {}
+        for output_name, field_config in fields.items():
+            path = self._resolve_model_output_field_path(output_name, field_config)
+            found, field_value = self._try_extract_path(source, path)
+            if (not found or field_value is None) and exclude_nulls:
+                continue
+            mapped[output_name] = field_value if found else None
+        return mapped
+
+    @staticmethod
+    def _resolve_model_output_field_path(output_name: str, field_config) -> str:
+        if isinstance(field_config, str):
+            path = field_config.strip()
+        elif isinstance(field_config, dict):
+            path = str(field_config.get("path") or "").strip()
+        else:
+            path = ""
+
+        if not path:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.INVALID_PARAMETER,
+                f"execution_config.response.model_output.fields.{output_name} must define a path"
+            )
+        return path
+
+    def _try_extract_path(self, data, extract_path: str):
+        try:
+            return True, self._extract_path(data, extract_path)
+        except IAToolkitException:
+            return False, None

{iatoolkit-2.21.3 → iatoolkit-2.22.0}/src/iatoolkit/services/tool_service.py

@@ -35,6 +35,7 @@ class ToolService:
     HTTP_ALLOWED_BODY_MODES = {"none", "json_map", "full_args"}
     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"}
 
     TOOL_EVENT_CREATED = "created"
     TOOL_EVENT_UPDATED = "updated"
@@ -584,6 +585,103 @@ class ToolService:
                     "execution_config.response.max_response_bytes must be a positive integer"
                 )
 
+            self._validate_http_model_output_config(response_cfg.get("model_output"))
+
+    def _validate_http_model_output_config(self, model_output):
+        if model_output is None:
+            return
+        if not isinstance(model_output, dict):
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.INVALID_PARAMETER,
+                "execution_config.response.model_output must be a JSON object"
+            )
+
+        allowed_keys = {"mode", "path", "root", "fields", "exclude_nulls", "max_items"}
+        unknown_keys = sorted(key for key in model_output.keys() if key not in allowed_keys)
+        if unknown_keys:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.INVALID_PARAMETER,
+                f"execution_config.response.model_output has unsupported keys: {unknown_keys}"
+            )
+
+        mode = str(model_output.get("mode", "raw")).strip().lower()
+        if mode not in self.HTTP_ALLOWED_MODEL_OUTPUT_MODES:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.INVALID_PARAMETER,
+                f"execution_config.response.model_output.mode must be one of {sorted(self.HTTP_ALLOWED_MODEL_OUTPUT_MODES)}"
+            )
+
+        if mode == "extract":
+            path = model_output.get("path")
+            if not isinstance(path, str) or not path.strip():
+                raise IAToolkitException(
+                    IAToolkitException.ErrorType.INVALID_PARAMETER,
+                    "execution_config.response.model_output.path is required when mode is 'extract'"
+                )
+
+        if mode == "map":
+            root = model_output.get("root")
+            if root is not None and (not isinstance(root, str) or not root.strip()):
+                raise IAToolkitException(
+                    IAToolkitException.ErrorType.INVALID_PARAMETER,
+                    "execution_config.response.model_output.root must be a non-empty string"
+                )
+
+            fields = model_output.get("fields")
+            if not isinstance(fields, dict) or not fields:
+                raise IAToolkitException(
+                    IAToolkitException.ErrorType.INVALID_PARAMETER,
+                    "execution_config.response.model_output.fields must be a non-empty object when mode is 'map'"
+                )
+            for field_name, field_config in fields.items():
+                if not isinstance(field_name, str) or not field_name.strip():
+                    raise IAToolkitException(
+                        IAToolkitException.ErrorType.INVALID_PARAMETER,
+                        "execution_config.response.model_output.fields must use non-empty string field names"
+                    )
+                if isinstance(field_config, str):
+                    if not field_config.strip():
+                        raise IAToolkitException(
+                            IAToolkitException.ErrorType.INVALID_PARAMETER,
+                            f"execution_config.response.model_output.fields.{field_name} must be a non-empty path"
+                        )
+                    continue
+                if isinstance(field_config, dict):
+                    path = field_config.get("path")
+                    if not isinstance(path, str) or not path.strip():
+                        raise IAToolkitException(
+                            IAToolkitException.ErrorType.INVALID_PARAMETER,
+                            f"execution_config.response.model_output.fields.{field_name}.path must be a non-empty string"
+                        )
+                    description = field_config.get("description")
+                    if description is not None and not isinstance(description, str):
+                        raise IAToolkitException(
+                            IAToolkitException.ErrorType.INVALID_PARAMETER,
+                            f"execution_config.response.model_output.fields.{field_name}.description must be a string"
+                        )
+                    continue
+                raise IAToolkitException(
+                    IAToolkitException.ErrorType.INVALID_PARAMETER,
+                    f"execution_config.response.model_output.fields.{field_name} must be a path string or object"
+                )
+
+            exclude_nulls = model_output.get("exclude_nulls")
+            if exclude_nulls is not None and not isinstance(exclude_nulls, bool):
+                raise IAToolkitException(
+                    IAToolkitException.ErrorType.INVALID_PARAMETER,
+                    "execution_config.response.model_output.exclude_nulls must be a boolean"
+                )
+
+            max_items = model_output.get("max_items")
+            if (
+                max_items is not None
+                and (isinstance(max_items, bool) or not isinstance(max_items, int) or max_items <= 0)
+            ):
+                raise IAToolkitException(
+                    IAToolkitException.ErrorType.INVALID_PARAMETER,
+                    "execution_config.response.model_output.max_items must be a positive integer"
+                )
+
     @staticmethod
     def _build_tool_snapshot(tool_obj) -> dict:
         if tool_obj is None:

{iatoolkit-2.21.3 → iatoolkit-2.22.0/src/iatoolkit.egg-info}/PKG-INFO

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