unique-toolkit 2026.28.0.dev9__tar.gz → 2026.28.0.dev10__tar.gz

{unique_toolkit-2026.28.0.dev9 → unique_toolkit-2026.28.0.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-toolkit
-Version: 2026.28.0.dev9
+Version: 2026.28.0.dev10
 Summary: 
 Author: Cedric Klinkert, Martin Fadler, Sadique Sheik, Fabian Schläpfer, Pascal Hauri, Ejiroghene Oki-Peter, Rami Azouz, Ricardo Visini, Sanzio Monti
 Author-email: Cedric Klinkert <cedric.klinkert@unique.ch>, Martin Fadler <martin.fadler@unique.ch>, Sadique Sheik <sadique@unique.ch>, Fabian Schläpfer <fabian@unique.ch>, Pascal Hauri <pascal@unique.ch>, Ejiroghene Oki-Peter <oki-peter.ejiroghene@unique.ai>, Rami Azouz <rami.ext@unique.ch>, Ricardo Visini <ricardo.visini@unique.ch>, Sanzio Monti <sanzio.monti@unique.ai>

{unique_toolkit-2026.28.0.dev9 → unique_toolkit-2026.28.0.dev10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_toolkit"
-version = "2026.28.0.dev9"
+version = "2026.28.0.dev10"
 description = ""
 readme = "README.md"
 requires-python = ">=3.12"

{unique_toolkit-2026.28.0.dev9 → unique_toolkit-2026.28.0.dev10}/unique_toolkit/agentic/tools/a2a/manager.py

@@ -29,6 +29,13 @@ class A2AManager:
             if not tool_config.is_sub_agent:
                 continue
 
+            if not tool_config.is_enabled:
+                self._logger.info(
+                    "Skipping disabled sub-agent '%s'",
+                    tool_config.name,
+                )
+                continue
+
             if not isinstance(tool_config.configuration, SubAgentToolConfig):
                 self._logger.error(
                     "tool_config.configuration must be of type SubAgentToolConfig"
@@ -37,16 +44,23 @@ class A2AManager:
 
             sub_agent_tool_config = tool_config.configuration
 
-            sub_agents.append(
-                SubAgentTool(
-                    configuration=sub_agent_tool_config,
-                    event=event,
-                    tool_progress_reporter=self._tool_progress_reporter,
-                    name=tool_config.name,
-                    display_name=tool_config.display_name,
-                    response_watcher=self._response_watcher,
+            try:
+                sub_agents.append(
+                    SubAgentTool(
+                        configuration=sub_agent_tool_config,
+                        event=event,
+                        tool_progress_reporter=self._tool_progress_reporter,
+                        name=tool_config.name,
+                        display_name=tool_config.display_name,
+                        response_watcher=self._response_watcher,
+                    )
+                )
+            except Exception:
+                self._logger.warning(
+                    "Skipping sub-agent '%s' due to initialization failure.",
+                    tool_config.name,
+                    exc_info=True,
                 )
-            )
 
         filtered_tool_config = [
             tool_config for tool_config in tool_configs if not tool_config.is_sub_agent

{unique_toolkit-2026.28.0.dev9 → unique_toolkit-2026.28.0.dev10}/unique_toolkit/agentic/tools/config.py

@@ -1,3 +1,4 @@
+import logging
 from enum import StrEnum
 from typing import Annotated, Any, Generic
 
@@ -14,9 +15,36 @@ from typing_extensions import TypeVar
 from unique_toolkit._common.pydantic_helpers import get_configuration_dict
 from unique_toolkit.agentic.tools.schemas import BaseToolConfig
 
+logger = logging.getLogger(__name__)
+
 T = TypeVar("T", bound=BaseToolConfig, default=BaseToolConfig)
 
 
+def _ensure_base_tool_config(value: dict[str, Any]) -> None:
+    """Make configuration parseable; disabled/demoted tools are never built at runtime."""
+    configuration = value.get("configuration")
+    if not isinstance(configuration, BaseToolConfig):
+        value["configuration"] = BaseToolConfig()
+
+
+def _non_empty_str(value: dict[str, Any], snake_key: str, camel_key: str) -> str:
+    raw = value.get(snake_key, value.get(camel_key, ""))
+    if raw is None:
+        return ""
+    return str(raw)
+
+
+def _is_mcp_tool_payload(value: dict[str, Any]) -> bool:
+    if _non_empty_str(value, "mcp_source_id", "mcpSourceId"):
+        return True
+
+    configuration = value.get("configuration", {})
+    if isinstance(configuration, dict):
+        if _non_empty_str(configuration, "mcp_source_id", "mcpSourceId"):
+            return True
+    return False
+
+
 class ToolIcon(StrEnum):
     ANALYTICS = "IconAnalytics"
     BOOK = "IconBook"
@@ -76,11 +104,26 @@ class ToolBuildConfig(BaseModel, Generic[T]):
         value: Any,
         info: ValidationInfo,
     ) -> Any:
-        """Check the given values for."""
+        """Validate and resolve tool configuration based on tool type and name.
+
+        Disabled tools skip validation entirely.
+        Enabled tools that fail validation are demoted to disabled.
+        """
         if not isinstance(value, dict):
             return value
 
-        is_mcp_tool = value.get("mcp_source_id", "") != ""
+        if "isEnabled" in value:
+            is_enabled = bool(value["isEnabled"])
+        elif "is_enabled" in value:
+            is_enabled = bool(value["is_enabled"])
+        else:
+            is_enabled = True
+
+        if not is_enabled:
+            _ensure_base_tool_config(value)
+            return value
+
+        is_mcp_tool = _is_mcp_tool_payload(value)
         mcp_configuration = value.get("configuration", {})
 
         # Import at runtime to avoid circular imports
@@ -102,26 +145,39 @@ class ToolBuildConfig(BaseModel, Generic[T]):
 
         configuration = value.get("configuration", {})
 
-        if is_sub_agent_tool:
-            from unique_toolkit.agentic.tools.a2a import ExtendedSubAgentToolConfig
-
-            config = ExtendedSubAgentToolConfig.model_validate(configuration)
-        elif isinstance(configuration, dict):
-            # Local import to avoid circular import at module import time
-            from unique_toolkit.agentic.tools.factory import ToolFactory
-
-            config = ToolFactory.build_tool_config(
-                value["name"],
-                **configuration,
+        try:
+            if is_sub_agent_tool:
+                from unique_toolkit.agentic.tools.a2a import ExtendedSubAgentToolConfig
+
+                config = ExtendedSubAgentToolConfig.model_validate(configuration)
+            elif isinstance(configuration, dict):
+                # Local import to avoid circular import at module import time
+                from unique_toolkit.agentic.tools.factory import ToolFactory
+
+                config = ToolFactory.build_tool_config(
+                    value["name"],
+                    **configuration,
+                )
+            else:
+                # Check that the type of config matches the tool name
+                from unique_toolkit.agentic.tools.factory import ToolFactory
+
+                assert isinstance(
+                    configuration,
+                    ToolFactory.tool_config_map[value["name"]],  # pyright: ignore[reportArgumentType]
+                )
+                config = configuration
+        except Exception:
+            tool_name = value.get("name", "<unknown>")
+            logger.warning(
+                "Tool '%s' has invalid configuration and will be disabled.",
+                tool_name,
+                exc_info=True,
             )
-        else:
-            # Check that the type of config matches the tool name
-            from unique_toolkit.agentic.tools.factory import ToolFactory
+            value["is_enabled"] = False
+            value["isEnabled"] = False
+            _ensure_base_tool_config(value)
+            return value
 
-            assert isinstance(
-                configuration,
-                ToolFactory.tool_config_map[value["name"]],  # pyright: ignore[reportArgumentType]
-            )
-            config = configuration
         value["configuration"] = config
         return value

{unique_toolkit-2026.28.0.dev9 → unique_toolkit-2026.28.0.dev10}/unique_toolkit/agentic/tools/tool_manager.py

@@ -147,7 +147,9 @@ class _ToolManager(Generic[_ApiMode]):
         self._tool_choices = run_context.tool_choices
         self._disabled_tools = run_context.disabled_tools
         self._exclusive_tools = [
-            tool.name for tool in self._config.tools if tool.is_exclusive
+            tool.name
+            for tool in self._config.tools
+            if tool.is_exclusive and tool.is_enabled
         ]
         # this needs to be a set of strings to avoid duplicates
         self._tool_evaluation_check_list: set[EvaluationMetricName] = set()
@@ -199,28 +201,39 @@ class _ToolManager(Generic[_ApiMode]):
 
         registered_tool_names.update(t.name for t in self._mcp_tools)
 
-        # Build internal tools from configurations
+        # Build internal tools from configurations, skipping disabled and failing tools
         self._internal_tools.clear()
+        safe_executor = SafeTaskExecutor(logger=self._logger, log_exceptions=False)
         for t in tool_configs:
             if t.name in registered_tool_names:
                 continue
             if t.name in OpenAIBuiltInToolName:
                 continue
-            if tool_init_event is not None:
-                built_tool = ToolFactory.build_tool_with_settings(
-                    t.name,
-                    t,
-                    t.configuration,
-                    tool_init_event,
-                    tool_progress_reporter=self._tool_progress_reporter,
-                )
-            else:
+            if not t.is_enabled:
+                self._logger.info("Skipping disabled tool '%s'", t.name)
+                continue
+            if tool_init_event is None:
                 self._logger.info(
                     "Skipping internal tool '%s' (requires chat event for initialization)",
                     t.name,
                 )
                 continue
-            self._internal_tools.append(built_tool)
+            result = safe_executor.execute(
+                ToolFactory.build_tool_with_settings,
+                t.name,
+                t,
+                t.configuration,
+                tool_init_event,
+                tool_progress_reporter=self._tool_progress_reporter,
+            )
+            if result.success:
+                self._internal_tools.append(result.unpack())
+            else:
+                self._logger.warning(
+                    "Skipping tool '%s' due to initialization failure.",
+                    t.name,
+                    exc_info=result.exception,
+                )
 
         # Combine all types of tools
         self.available_tools = (