iatoolkit 2.53.0__tar.gz → 2.54.0__tar.gz

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

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

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

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

{iatoolkit-2.53.0 → iatoolkit-2.54.0}/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.53.0 → iatoolkit-2.54.0}/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.53.0 → iatoolkit-2.54.0}/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.53.0 → iatoolkit-2.54.0}/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.53.0 → iatoolkit-2.54.0}/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.53.0 → iatoolkit-2.54.0}/src/iatoolkit/repositories/models.py

@@ -360,6 +360,7 @@ class Tool(Base):
     TYPE_NATIVE = 'NATIVE'       # executed by company class in Python
     TYPE_INFERENCE = 'INFERENCE' # executed by InferenceService
     TYPE_HTTP = 'HTTP'           # executed by HttpToolService
+    TYPE_MCP = 'MCP'             # executed by the handler an extension registers (Dispatcher.register_tool_type_handler)
 
     # source of the definition (Source of Truth)
     SOURCE_SYSTEM = 'SYSTEM'
@@ -367,6 +368,7 @@ class Tool(Base):
     SOURCE_YAML = 'YAML'         # defined in company.yaml
     SOURCE_USER = 'USER'         # defined via GUI/API
     SOURCE_PACK = 'PACK'         # materialized by enterprise control-plane
+    SOURCE_MCP = 'MCP'           # imported from an external MCP server
 
     id = Column(Integer, primary_key=True, autoincrement=True)
     company_id = Column(Integer,

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

@@ -31,6 +31,11 @@ class Dispatcher:
         "iat_wiki_get_page",
     }
     _tool_execution_hook = None
+    # Tool types this module executes itself; an extension cannot take them over.
+    BUILTIN_TOOL_TYPES = frozenset({"SYSTEM", "INFERENCE", "HTTP", "NATIVE"})
+    # Executors for tool types an extension owns (e.g. Enterprise's MCP client
+    # for tool_type='MCP'). This module knows nothing about what they do.
+    _tool_type_handlers: dict = {}
 
     @inject
     def __init__(self,
@@ -80,6 +85,33 @@ class Dispatcher:
     def clear_tool_execution_hook(cls):
         cls._tool_execution_hook = None
 
+    @classmethod
+    def register_tool_type_handler(cls, tool_type: str, handler):
+        """
+        Registers the executor for tools whose tool_type is not built in.
+        handler is called as:
+
+            handler(company_short_name=..., function_name=..., tool_def=...,
+                    user_identifier=..., runtime_source=..., arguments={...})
+
+        and returns the tool result, exactly like a native tool would.
+        """
+        normalized = str(tool_type or "").strip().upper()
+        if not normalized:
+            raise ValueError("tool_type is required")
+        if normalized in cls.BUILTIN_TOOL_TYPES:
+            raise ValueError(f"Tool type '{normalized}' is built in and cannot be overridden")
+        if not callable(handler):
+            raise ValueError("handler must be callable")
+        cls._tool_type_handlers = {**cls._tool_type_handlers, normalized: handler}
+
+    @classmethod
+    def clear_tool_type_handler(cls, tool_type: str):
+        normalized = str(tool_type or "").strip().upper()
+        cls._tool_type_handlers = {
+            key: value for key, value in cls._tool_type_handlers.items() if key != normalized
+        }
+
     def _notify_tool_execution_hook(self, event: str, **payload) -> None:
         hook = type(self)._tool_execution_hook
         if not callable(hook):
@@ -184,6 +216,7 @@ class Dispatcher:
                 function_name=function_name,
                 user_identifier=user_identifier,
                 tool_def=tool_def,
+                runtime_source=_iat_runtime_source,
                 **kwargs,
             )
             self._notify_tool_execution_hook(
@@ -241,6 +274,7 @@ class Dispatcher:
         function_name: str,
         user_identifier: str | None,
         tool_def,
+        runtime_source: str | None = None,
         **kwargs,
     ) -> dict:
         # 2. Dispatch based on Tool Type
@@ -320,6 +354,17 @@ class Dispatcher:
                                          f"Error executing native tool '{method_name}': {str(e)}") from e
 
         else:
+            handler = type(self)._tool_type_handlers.get(str(tool_def.tool_type or "").strip().upper())
+            if handler:
+                logging.debug(f"Dispatching {tool_def.tool_type} tool: {function_name}")
+                return handler(
+                    company_short_name=company_short_name,
+                    function_name=function_name,
+                    tool_def=tool_def,
+                    user_identifier=user_identifier,
+                    runtime_source=runtime_source,
+                    arguments=dict(kwargs),
+                )
             raise IAToolkitException(
                 IAToolkitException.ErrorType.EXTERNAL_SOURCE_ERROR,
                 f"Unknown tool type '{tool_def.tool_type}'"

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

@@ -1191,6 +1191,11 @@ class ToolService:
             raise IAToolkitException(IAToolkitException.ErrorType.MISSING_PARAMETER, "Name and Description are required")
 
         tool_type = tool_data.get('tool_type', Tool.TYPE_NATIVE)
+        if str(tool_type or '').strip().upper() == Tool.TYPE_MCP:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.INVALID_OPERATION,
+                "MCP tools are imported from a registered MCP server, not created by hand",
+            )
         execution_config = tool_data.get('execution_config')
         output_contract = normalize_output_contract(tool_data.get('output_contract'))
         self._validate_tool_contract(tool_type, execution_config, output_contract, company=company)
@@ -1243,6 +1248,13 @@ class ToolService:
             raise IAToolkitException(IAToolkitException.ErrorType.INVALID_OPERATION, "Cannot modify System Tools")
         if tool.source == Tool.SOURCE_PACK:
             raise IAToolkitException(IAToolkitException.ErrorType.INVALID_OPERATION, "Cannot modify PACK tools")
+        if tool.source == Tool.SOURCE_MCP:
+            return self._update_mcp_tool(company_short_name, tool, tool_data, actor_identifier)
+        if str(tool_data.get('tool_type') or '').strip().upper() == Tool.TYPE_MCP:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.INVALID_OPERATION,
+                "A tool cannot be turned into an MCP tool; import it from its MCP server",
+            )
 
         normalized_name = None
         if 'name' in tool_data or 'key' in tool_data:
@@ -1286,6 +1298,43 @@ class ToolService:
         )
         return tool.to_dict()
 
+    MCP_TOOL_EDITABLE_FIELDS = ('description', 'is_active')
+
+    def _update_mcp_tool(self, company_short_name: str, tool, tool_data: dict,
+                         actor_identifier: str | None) -> dict:
+        """
+        An imported MCP tool mirrors a tool on its server: its name, schema and
+        execution config come from there (and agents reference the name), so
+        only what stays local can change here.
+        """
+        unsupported = sorted(
+            key for key in tool_data.keys()
+            if key not in self.MCP_TOOL_EDITABLE_FIELDS
+        )
+        if unsupported:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.INVALID_OPERATION,
+                f"MCP tools only allow editing {list(self.MCP_TOOL_EDITABLE_FIELDS)}; "
+                f"{unsupported} come from the MCP server",
+            )
+
+        if 'description' in tool_data:
+            description = str(tool_data.get('description') or '').strip()
+            if not description:
+                raise IAToolkitException(IAToolkitException.ErrorType.MISSING_PARAMETER, "Description is required")
+            tool.description = description
+        if 'is_active' in tool_data:
+            tool.is_active = bool(tool_data['is_active'])
+
+        self.llm_query_repo.commit()
+        self._notify_tool_lifecycle_hook(
+            event=self.TOOL_EVENT_UPDATED,
+            company_short_name=company_short_name,
+            tool_obj=tool,
+            actor_identifier=actor_identifier,
+        )
+        return tool.to_dict()
+
     def delete_tool(
         self,
         company_short_name: str,

{iatoolkit-2.53.0 → iatoolkit-2.54.0}/src/iatoolkit/static/js/chat_main.js

@@ -53,6 +53,10 @@ function sanitizeHtmlFragment(html) {
                 }
             });
             if (tag === 'a') {
+                // A link in an answer never replaces the chat: following it in
+                // the same tab loses the conversation on screen (e.g. the link to
+                // connect an external MCP account).
+                el.setAttribute('target', '_blank');
                 el.setAttribute('rel', 'noopener noreferrer');
             }
             walk(el);

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

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