iatoolkit 2.53.1__tar.gz → 2.54.0__tar.gz

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

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

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

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

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

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