iatoolkit 2.51.3__tar.gz → 2.53.0__tar.gz

{iatoolkit-2.51.3/src/iatoolkit.egg-info → iatoolkit-2.53.0}/PKG-INFO

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

{iatoolkit-2.51.3 → iatoolkit-2.53.0}/src/iatoolkit/__init__.py

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

{iatoolkit-2.51.3 → iatoolkit-2.53.0}/src/iatoolkit/common/routes.py

@@ -299,7 +299,13 @@ def register_views(app):
                 return redirect(signed_url)
 
             # Fallback path: stream bytes from storage through Flask.
-            file_bytes = storage_service.get_document_content(company_short_name, storage_key)
+            try:
+                file_bytes = storage_service.get_document_content(company_short_name, storage_key)
+            except IAToolkitException as e:
+                if e.error_type != IAToolkitException.ErrorType.FILE_IO_ERROR:
+                    raise
+                # Generated downloads are deleted after the tenant's retention.
+                abort(404, "This file has expired or is no longer available.")
             guessed_mime, _ = mimetypes.guess_type(output_filename)
             return send_file(
                 BytesIO(file_bytes),

{iatoolkit-2.51.3 → iatoolkit-2.53.0}/src/iatoolkit/config/system_tools_pack.yaml

@@ -128,6 +128,9 @@ tools:
         - orientation
   - function_name: iat_send_email
     description: iatoolkit mail system. envia mails cuando un usuario lo solicita.
+    # Sends a real email: simulated, never sent, when an evaluation replays an agent.
+    execution_config:
+      side_effects: true
     routing_profile:
       tags:
         - email

{iatoolkit-2.51.3 → iatoolkit-2.53.0}/src/iatoolkit/locales/en.yaml

@@ -1425,6 +1425,7 @@ ui:
     definitions_filter_summary: "Showing {visible} of {total} pipelines"
     definition_last_run: "Last run"
     definition_no_runs: "No runs"
+    definition_column_id: "ID"
     definition_column_pipeline: "Pipeline"
     definition_column_input: "Input"
     definition_column_steps: "Steps"

{iatoolkit-2.51.3 → iatoolkit-2.53.0}/src/iatoolkit/locales/es.yaml

@@ -1440,6 +1440,7 @@ ui:
     definitions_filter_summary: "Mostrando {visible} de {total} pipelines"
     definition_last_run: "Última ejecución"
     definition_no_runs: "Sin ejecuciones"
+    definition_column_id: "ID"
     definition_column_pipeline: "Pipeline"
     definition_column_input: "Entrada"
     definition_column_steps: "Pasos"

{iatoolkit-2.51.3 → iatoolkit-2.53.0}/src/iatoolkit/repositories/models.py

@@ -9,7 +9,7 @@ from sqlalchemy import Column, Integer, BigInteger, String, DateTime, Enum, Text
 from sqlalchemy.orm import DeclarativeBase
 from sqlalchemy.orm import relationship, class_mapper
 from sqlalchemy.sql import func
-from sqlalchemy import UniqueConstraint
+from sqlalchemy import UniqueConstraint, Index
 from sqlalchemy.dialects.postgresql import JSONB
 from datetime import datetime
 from pgvector.sqlalchemy import Vector
@@ -385,6 +385,17 @@ class Tool(Base):
 
     company = relationship('Company', back_populates='tools')
 
+    @property
+    def has_side_effects(self) -> bool:
+        """Whether calling this tool changes something outside the conversation.
+
+        Declared explicitly with `execution_config.side_effects: true`; tools
+        are read-only unless they say otherwise. Model evaluations replay real
+        executions and simulate these tools instead of running them.
+        """
+        config = self.execution_config if isinstance(self.execution_config, dict) else {}
+        return config.get("side_effects") is True
+
     def to_dict(self):
         return {column.key: getattr(self, column.key) for column in class_mapper(self.__class__).columns}
 
@@ -598,6 +609,19 @@ class LLMQuery(Base):
     created_at = Column(DateTime, default=datetime.now)
     task_id = Column(Integer, default=None, nullable=True)
 
+    # Execution trace: enough to replay an agent execution later (model
+    # evaluations). prompt_inputs are the caller's raw inputs, before they are
+    # merged with the user profile; input_files hold storage references only,
+    # never file content.
+    prompt_name = Column(String, nullable=True)
+    prompt_inputs = Column(JSON, nullable=True)
+    input_files = Column(JSON, nullable=True)
+    input_files_purged_at = Column(DateTime, nullable=True)
+
+    __table_args__ = (
+        Index('ix_iat_queries_company_prompt_created', 'company_id', 'prompt_name', 'created_at'),
+    )
+
     company = relationship("Company", back_populates="llm_queries")
 
     def to_dict(self):

{iatoolkit-2.51.3 → iatoolkit-2.53.0}/src/iatoolkit/services/configuration_service.py

@@ -790,6 +790,12 @@ class ConfigurationService:
                 add_error(f"tools[{i}]", "Missing required key: 'description'")
             if not isinstance(tool.get("params"), dict):
                 add_error(f"tools[{i}]", "'params' key must be a dictionary.")
+            execution_config = tool.get("execution_config")
+            if execution_config is not None:
+                if not isinstance(execution_config, dict):
+                    add_error(f"tools[{i}].execution_config", "Must be a dictionary.")
+                elif "side_effects" in execution_config and not isinstance(execution_config["side_effects"], bool):
+                    add_error(f"tools[{i}].execution_config.side_effects", "Must be true or false.")
 
         # 6. Prompts
         prompt_list, categories_config = self._get_prompt_config(config)

{iatoolkit-2.51.3 → iatoolkit-2.53.0}/src/iatoolkit/services/dispatcher_service.py

@@ -14,6 +14,11 @@ from time import perf_counter
 from uuid import uuid4
 
 
+#: request_source of the executions a model evaluation replays. Tools that
+#: declare side effects are simulated for them instead of being run.
+EVALUATION_REQUEST_SOURCE = "evaluation"
+
+
 class Dispatcher:
     # System tools whose answer depends on who is asking, so the dispatcher
     # injects the identity server-side. The wiki tools are here because a page's
@@ -157,6 +162,22 @@ class Dispatcher:
             arguments=dict(kwargs),
         )
         started_at = perf_counter()
+        if self._is_simulated_call(tool_def, _iat_runtime_source):
+            result = self._simulated_result(function_name)
+            self._notify_tool_execution_hook(
+                "after_dispatch",
+                execution_id=execution_id,
+                company_short_name=company_short_name,
+                function_name=function_name,
+                user_identifier=user_identifier,
+                runtime_source=_iat_runtime_source,
+                tool_def=tool_def,
+                arguments=dict(kwargs),
+                status="simulated",
+                duration_ms=int(round((perf_counter() - started_at) * 1000)),
+                result=result,
+            )
+            return result
         try:
             result = self._dispatch_resolved_tool(
                 company_short_name=company_short_name,
@@ -195,6 +216,24 @@ class Dispatcher:
             )
             raise
 
+    @staticmethod
+    def _is_simulated_call(tool_def, runtime_source: str | None) -> bool:
+        if str(runtime_source or "").strip().lower() != EVALUATION_REQUEST_SOURCE:
+            return False
+        return bool(getattr(tool_def, "has_side_effects", False))
+
+    @staticmethod
+    def _simulated_result(function_name: str) -> dict:
+        # Returned to the model in place of the real call, so the agent can keep
+        # going: the evaluation measures its reasoning, not this action's outcome.
+        return {
+            "status": "simulated",
+            "message": (
+                f"Action '{function_name}' was not executed: this is a model evaluation "
+                "and the tool has side effects. Continue as if it had succeeded."
+            ),
+        }
+
     def _dispatch_resolved_tool(
         self,
         *,

{iatoolkit-2.51.3 → iatoolkit-2.53.0}/src/iatoolkit/services/llm_client_service.py

@@ -131,7 +131,8 @@ class llmClient:
                execution_metadata: Optional[Dict[str, Any]] = None,
                request_metadata: Optional[Dict[str, str]] = None,
                telemetry_request: Optional[Dict[str, Any]] = None,
-               response_contract: Optional[Dict[str, Any]] = None
+               response_contract: Optional[Dict[str, Any]] = None,
+               execution_trace: Optional[Dict[str, Any]] = None
                ) -> dict:
 
         self._assert_runtime_not_suspended(company)
@@ -426,7 +427,8 @@ class llmClient:
                              response=self.serialize_response(response, decoded_response),
                              function_calls=f_calls,
                              stats=combined_stats,
-                             answer_time=stats['response_time']
+                             answer_time=stats['response_time'],
+                             **self._execution_trace_columns(execution_trace)
                              )
             self.llmquery_repo.add_query(query)
             telemetry_execution.finalize(
@@ -503,6 +505,7 @@ class llmClient:
                              response={},
                              valid_response=False,
                              function_calls=f_calls,
+                             **self._execution_trace_columns(execution_trace)
                              )
             self.llmquery_repo.add_query(query)
             telemetry_execution.finalize(
@@ -1324,6 +1327,24 @@ class llmClient:
             stats_dict["provider_calls"] = provider_calls
         return stats_dict
 
+    @staticmethod
+    def _execution_trace_columns(execution_trace: Optional[Dict[str, Any]]) -> dict:
+        """Maps the caller's execution trace onto the LLMQuery trace columns."""
+        if not isinstance(execution_trace, dict):
+            return {}
+
+        columns = {}
+        prompt_name = str(execution_trace.get("prompt_name") or "").strip()
+        if prompt_name:
+            columns["prompt_name"] = prompt_name
+        prompt_inputs = execution_trace.get("prompt_inputs")
+        if isinstance(prompt_inputs, dict):
+            columns["prompt_inputs"] = prompt_inputs
+        input_files = execution_trace.get("input_files")
+        if isinstance(input_files, list) and input_files:
+            columns["input_files"] = input_files
+        return columns
+
     @classmethod
     def _compact_execution_metadata_for_stats(cls, key: str, value):
         if key == "tool_router":

{iatoolkit-2.51.3 → iatoolkit-2.53.0}/src/iatoolkit/services/query_service.py

@@ -963,6 +963,30 @@ class QueryService:
             return False
         return any(marker in error_text for marker in cls._PREVIOUS_RESPONSE_NOT_FOUND_MARKERS)
 
+    @staticmethod
+    def build_execution_trace(*,
+                               prompt_name: str | None,
+                               client_data: dict | None,
+                               input_files: list | None) -> dict:
+        """
+        What an agent execution needs to be replayed later. Inputs are taken
+        as the caller sent them, before build_user_turn_prompt merges them with
+        the user profile; keys starting with "_" are internal plumbing.
+        """
+        trace = {}
+        normalized_prompt_name = str(prompt_name or "").strip()
+        if normalized_prompt_name:
+            trace["prompt_name"] = normalized_prompt_name
+            safe_client_data = client_data if isinstance(client_data, dict) else {}
+            trace["prompt_inputs"] = {
+                key: value
+                for key, value in safe_client_data.items()
+                if not str(key or "").startswith("_")
+            }
+        if isinstance(input_files, list) and input_files:
+            trace["input_files"] = [dict(item) for item in input_files if isinstance(item, dict)]
+        return trace
+
     def _invoke_with_history_recovery(self,
                                       *,
                                       company,
@@ -984,7 +1008,8 @@ class QueryService:
                                       telemetry_request: dict | None,
                                       prompt_output_contract: dict,
                                       history_handle: HistoryHandle,
-                                      ignore_history: bool) -> tuple[dict, HistoryHandle]:
+                                      ignore_history: bool,
+                                      execution_trace: dict | None = None) -> tuple[dict, HistoryHandle]:
         previous_response_id = history_handle.request_params.get('previous_response_id')
         context_history = history_handle.request_params.get('context_history')
 
@@ -1009,6 +1034,7 @@ class QueryService:
                 request_metadata=request_metadata,
                 telemetry_request=telemetry_request,
                 response_contract=prompt_output_contract if prompt_output_contract.get("schema") else None,
+                execution_trace=execution_trace,
             )
             return response, history_handle
         except Exception as invoke_error:
@@ -1067,6 +1093,7 @@ class QueryService:
                 request_metadata=request_metadata,
                 telemetry_request=telemetry_request,
                 response_contract=prompt_output_contract if prompt_output_contract.get("schema") else None,
+                execution_trace=execution_trace,
             )
             return response, retry_history_handle
 
@@ -1377,10 +1404,16 @@ class QueryService:
                   client_data: dict = {},
                   task_id: Optional[int] = None,
                   ignore_history: bool = False,
-                  files: list = []
+                  files: list = [],
+                  input_files: list | None = None
                   ) -> dict:
         try:
             stage_started_at = time.time()
+            execution_trace = self.build_execution_trace(
+                prompt_name=prompt_name,
+                client_data=client_data,
+                input_files=input_files,
+            )
             request_source = None
 
             logging.debug(
@@ -1742,6 +1775,7 @@ class QueryService:
                 prompt_output_contract=prompt_output_contract,
                 history_handle=history_handle,
                 ignore_history=ignore_history,
+                execution_trace=execution_trace,
             )
             log_stage("invoke_with_history_recovery")
 

{iatoolkit-2.51.3 → iatoolkit-2.53.0}/src/iatoolkit/services/system_tools.py

@@ -56,6 +56,13 @@ def _validate_system_tool_entry(entry: dict, index: int) -> dict:
     routing_profile = entry.get("routing_profile")
     normalized_routing_profile = _validate_routing_profile(routing_profile, index)
 
+    execution_config = entry.get("execution_config")
+    if execution_config is not None:
+        if not isinstance(execution_config, dict):
+            raise ValueError(f"tools[{index}].execution_config must be an object")
+        if "side_effects" in execution_config and not isinstance(execution_config["side_effects"], bool):
+            raise ValueError(f"tools[{index}].execution_config.side_effects must be a boolean")
+
     normalized = {
         "function_name": function_name,
         "description": description,
@@ -67,6 +74,8 @@ def _validate_system_tool_entry(entry: dict, index: int) -> dict:
         normalized["routing"] = normalized_routing
     if normalized_routing_profile is not None:
         normalized["routing_profile"] = normalized_routing_profile
+    if execution_config is not None:
+        normalized["execution_config"] = copy.deepcopy(execution_config)
     return normalized
 
 

{iatoolkit-2.51.3 → iatoolkit-2.53.0}/src/iatoolkit/services/tool_service.py

@@ -4,6 +4,7 @@
 # IAToolkit is open source software.
 
 from injector import inject
+import copy
 import os
 import json
 import logging
@@ -930,6 +931,7 @@ class ToolService:
                     name=function['function_name'],
                     description=function['description'],
                     parameters=function['parameters'],
+                    execution_config=copy.deepcopy(function.get("execution_config")),
                     output_contract=clone_output_contract(function.get("output_contract")),
                     tool_type=Tool.TYPE_SYSTEM,
                     source=Tool.SOURCE_SYSTEM,
@@ -972,6 +974,7 @@ class ToolService:
             and tool.description == definition.get("description")
             and (tool.parameters or {}) == (definition.get("parameters") or {})
             and (tool.output_contract or {}) == (definition.get("output_contract") or {})
+            and (tool.execution_config or {}) == (definition.get("execution_config") or {})
         )
 
     def _system_tools_catalog_has_drift(
@@ -1032,6 +1035,7 @@ class ToolService:
                     name=function_name,
                     description=function.get("description"),
                     parameters=function.get("parameters") or {},
+                    execution_config=copy.deepcopy(function.get("execution_config")),
                     output_contract=clone_output_contract(function.get("output_contract")),
                     tool_type=Tool.TYPE_SYSTEM,
                     source=Tool.SOURCE_SYSTEM,
@@ -1128,6 +1132,7 @@ class ToolService:
                     name=name,
                     description=tool_data['description'],
                     parameters=tool_data['params'],
+                    execution_config=copy.deepcopy(tool_data.get('execution_config')),
                     output_contract=clone_output_contract(tool_data.get('output_contract')),
 
                     tool_type=Tool.TYPE_NATIVE,

{iatoolkit-2.51.3 → iatoolkit-2.53.0/src/iatoolkit.egg-info}/PKG-INFO

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