iatoolkit 2.52.0__tar.gz → 2.53.1__tar.gz

{iatoolkit-2.52.0/src/iatoolkit.egg-info → iatoolkit-2.53.1}/PKG-INFO

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

{iatoolkit-2.52.0 → iatoolkit-2.53.1}/src/iatoolkit/__init__.py

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

{iatoolkit-2.52.0 → iatoolkit-2.53.1}/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.52.0 → iatoolkit-2.53.1}/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.52.0 → iatoolkit-2.53.1}/src/iatoolkit/core.py

@@ -175,6 +175,13 @@ class IAToolkit:
                     logging.info("🔥 Startup warm-up completed for endpoints=%s", woken_endpoints)
             except Exception:
                 logging.exception("⚠️ Startup warm-up failed.")
+            finally:
+                # The scoped session is per thread: whatever this thread read
+                # (the endpoint's credentials, from the secrets table) keeps its
+                # connection "idle in transaction" until the thread's own session
+                # is removed - and nothing else ever removes it.
+                if self.db_manager is not None:
+                    self.db_manager.remove_session()
 
         thread = threading.Thread(target=_run_warmup, name="iatoolkit-startup-warmup", daemon=True)
         thread.start()

{iatoolkit-2.52.0 → iatoolkit-2.53.1}/src/iatoolkit/infra/llm_proxy.py

@@ -89,6 +89,23 @@ class LLMProxy:
                 self._telemetry_service = NoopTelemetryService()
         return self._telemetry_service
 
+    @staticmethod
+    def _release_database_transaction() -> None:
+        """
+        Hands the request's database connection back to the pool before the
+        provider call. Resolved lazily, like telemetry: the proxy is also built
+        outside a running toolkit (tests, scripts), where there is nothing to
+        release.
+        """
+        try:
+            from iatoolkit import current_iatoolkit
+            from iatoolkit.repositories.database_manager import DatabaseManager
+
+            db_manager = current_iatoolkit().get_injector().get(DatabaseManager)
+        except Exception:
+            return
+        db_manager.release_idle_transaction()
+
     # -------------------------------------------------------------------------
     # Public API
     # -------------------------------------------------------------------------
@@ -146,6 +163,10 @@ class LLMProxy:
         if telemetry_execution is not None:
             request_kwargs["telemetry_execution"] = telemetry_execution
 
+        # Everything the call needs from the database is resolved by now; the
+        # model can take minutes, and the connection should not wait with it.
+        self._release_database_transaction()
+
         # Delegate to the adapter (OpenAI, Gemini, DeepSeek, xAI, Anthropic, etc.)
         return adapter.create_response(
             model=self._wire_model(model, model_config),

{iatoolkit-2.52.0 → iatoolkit-2.53.1}/src/iatoolkit/locales/en.yaml

@@ -1247,6 +1247,13 @@ ui:
     run_duration_seconds: "Duration (s)"
     run_duration_minutes: "Duration (min)"
     duration_minutes_suffix: "mins."
+    timing_duration: "Duration"
+    timing_rate: "Rate"
+    timing_eta: "ETA"
+    timing_eta_after_discovery: "ETA after discovery"
+    timing_eta_pending: "ETA pending"
+    timing_processed_rate_suffix: "processed"
+    timing_submitted_rate_suffix: "submitted"
     run_finished: "Finished"
     run_actions: "Actions"
     run_discovered: "Discovered"

{iatoolkit-2.52.0 → iatoolkit-2.53.1}/src/iatoolkit/locales/es.yaml

@@ -1262,6 +1262,13 @@ ui:
     run_duration_seconds: "Duración (s)"
     run_duration_minutes: "Duración (min)"
     duration_minutes_suffix: "mins."
+    timing_duration: "Duración"
+    timing_rate: "Ritmo"
+    timing_eta: "ETA"
+    timing_eta_after_discovery: "ETA después de discovery"
+    timing_eta_pending: "ETA pendiente"
+    timing_processed_rate_suffix: "procesados"
+    timing_submitted_rate_suffix: "enviados"
     run_finished: "Fin"
     run_actions: "Acciones"
     run_discovered: "Descubiertos"

{iatoolkit-2.52.0 → iatoolkit-2.53.1}/src/iatoolkit/repositories/database_manager.py

@@ -324,6 +324,37 @@ class DatabaseManager(DatabaseProvider):
     def remove_session(self):
         self.scoped_session.remove()
 
+    def release_idle_transaction(self) -> bool:
+        """
+        Ends the current session's transaction and returns its connection to the
+        pool, before a call that waits on something other than the database.
+
+        Any read opens a transaction that lasts until the next commit, so a
+        session that read config or secrets and then waited minutes on an LLM
+        held its connection "idle in transaction" the whole time. A web process
+        serves many requests from one small pool, and a few such waits were
+        enough to time out every other request.
+
+        Commits rather than rolls back: a rollback expires every loaded object
+        and would discard writes already flushed. The session factory keeps
+        objects on commit, so callers go on using what they loaded. Leaves the
+        session alone when it has pending changes - committing them here would
+        be the caller's decision, not ours.
+        """
+        try:
+            if not self.scoped_session.registry.has():
+                return False
+            session = self.scoped_session.registry()
+            if not session.in_transaction():
+                return False
+            if session.new or session.dirty or session.deleted:
+                return False
+            session.commit()
+            return True
+        except Exception as e:
+            logging.debug("Could not release the idle database transaction: %s", e)
+            return False
+
     # -- execution methods ----
 
     def execute_query(self, query: str, commit: bool = False, params: dict | None = None) -> list[dict] | dict:

{iatoolkit-2.52.0 → iatoolkit-2.53.1}/src/iatoolkit/repositories/models.py

@@ -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}
 

{iatoolkit-2.52.0 → iatoolkit-2.53.1}/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.52.0 → iatoolkit-2.53.1}/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.52.0 → iatoolkit-2.53.1}/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.52.0 → iatoolkit-2.53.1}/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.52.0 → iatoolkit-2.53.1/src/iatoolkit.egg-info}/PKG-INFO

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