unique_toolkit 0.8.25__py3-none-any.whl → 0.8.26__py3-none-any.whl

unique_toolkit/history_manager/history_manager.py

@@ -158,6 +158,13 @@ class HistoryManager:
             f"Appending tool call result to history: {tool_response.name}"
         )
 
+        if tool_response.content != "":
+            return LanguageModelToolMessage(
+                content=tool_response.content,
+                tool_call_id=tool_response.id,  # type: ignore
+                name=tool_response.name,
+            )
+
         content_chunks = (
             tool_response.content_chunks or []
         )  # it can be that the tool response does not have content chunks

unique_toolkit/tools/mcp/__init__.py

@@ -1,4 +1,4 @@
-from .models import EnrichedMCPTool, MCPToolConfig
+from .models import MCPToolConfig
 from .tool_wrapper import MCPToolWrapper
 
-__all__ = ["MCPToolWrapper", "MCPToolConfig", "EnrichedMCPTool"]
+__all__ = ["MCPToolWrapper", "MCPToolConfig"]

unique_toolkit/tools/mcp/manager.py

@@ -1,7 +1,10 @@
 import logging
 
-from unique_toolkit.app.schemas import ChatEvent, McpServer, McpTool
-from unique_toolkit.tools.mcp.models import EnrichedMCPTool, MCPToolConfig
+from unique_toolkit.tools.config import ToolBuildConfig, ToolIcon, ToolSelectionPolicy
+from unique_toolkit.app.schemas import ChatEvent, McpServer
+from unique_toolkit.tools.schemas import BaseToolConfig
+from unique_toolkit.tools.tool import Tool
+from unique_toolkit.tools.mcp.models import MCPToolConfig
 from unique_toolkit.tools.mcp.tool_wrapper import MCPToolWrapper
 from unique_toolkit.tools.tool_progress_reporter import ToolProgressReporter
 
@@ -23,60 +26,42 @@ class MCPManager:
     def get_mcp_server_by_id(self, id: str):
         return next((server for server in self._mcp_servers if server.id == id), None)
 
-    def _enrich_tool_with_mcp_info(
-        self, mcp_tool: McpTool, server: McpServer
-    ) -> EnrichedMCPTool:
-        enriched_tool = type("EnrichedMcpTool", (), {})()
-
-        # Copy all attributes from the original tool
-        for attr in dir(mcp_tool):
-            if not attr.startswith("_"):
-                setattr(enriched_tool, attr, getattr(mcp_tool, attr))
-
-        # Add server-specific attributes
-        enriched_tool.server_id = server.id
-        enriched_tool.server_name = server.name
-        enriched_tool.server_system_prompt = getattr(server, "system_prompt", None)
-        enriched_tool.server_user_prompt = getattr(server, "user_prompt", None)
-        enriched_tool.mcp_source_id = server.id
-
-        return enriched_tool
-
-    def create_mcp_tool_wrapper(
-        self, mcp_tool: EnrichedMCPTool, tool_progress_reporter: ToolProgressReporter
-    ) -> MCPToolWrapper:
-        """Create MCP tool wrapper that behave like internal tools"""
-        try:
-            config = MCPToolConfig(
-                server_id=mcp_tool.server_id,
-                server_name=mcp_tool.server_name,
-                server_system_prompt=mcp_tool.server_system_prompt,
-                server_user_prompt=mcp_tool.server_user_prompt,
-                mcp_source_id=mcp_tool.mcp_source_id,
-            )
-            wrapper = MCPToolWrapper(
-                mcp_tool=mcp_tool,
-                config=config,
-                event=self._event,
-                tool_progress_reporter=tool_progress_reporter,
-            )
-            return wrapper
-        except Exception as e:
-            import traceback
-
-            logging.error(f"Error creating MCP tool wrapper for {mcp_tool.name}: {e}")
-            logging.error(f"Full traceback: {traceback.format_exc()}")
-            return None
-
-    def get_all_mcp_tools(self, selected_by_user: list[str]) -> list[MCPToolWrapper]:
+    def get_all_mcp_tools(self) -> list[Tool[BaseToolConfig]]:
         selected_tools = []
         for server in self._mcp_servers:
-            if hasattr(server, "tools") and server.tools:
-                for tool in server.tools:
-                    enriched_tool = self._enrich_tool_with_mcp_info(tool, server)
-                    wrapper = self.create_mcp_tool_wrapper(
-                        enriched_tool, self._tool_progress_reporter
+            if not hasattr(server, "tools"):
+                continue
+            if not server.tools:
+                continue
+
+            for tool in server.tools:
+                try:
+                    config = MCPToolConfig(
+                        server_id=server.id,
+                        server_name=server.name,
+                        server_system_prompt=server.system_prompt,
+                        server_user_prompt=server.user_prompt,
+                        mcp_source_id=server.id,
+                    )
+                    wrapper = MCPToolWrapper(
+                        mcp_server=server,
+                        mcp_tool=tool,
+                        config=config,
+                        event=self._event,
+                        tool_progress_reporter=self._tool_progress_reporter,
+                    )
+                    wrapper.settings = ToolBuildConfig(  # TODO: this must be refactored to behave like the other tools.
+                        name=tool.name,
+                        configuration=config,
+                        display_name=tool.title or tool.name,
+                        is_exclusive=False,
+                        is_enabled=True,
+                        icon=ToolIcon.BOOK,
+                        selection_policy=ToolSelectionPolicy.BY_USER,
+                    )
+                    selected_tools.append(wrapper)
+                except Exception as e:
+                    logging.error(
+                        f"Error creating MCP tool wrapper for {tool.name}: {e}"
                     )
-                    if wrapper is not None:
-                        selected_tools.append(wrapper)
         return selected_tools

unique_toolkit/tools/mcp/models.py

@@ -1,9 +1,8 @@
-from typing import Any, Dict, Optional, Protocol
-
+from typing import Any, Dict, Optional
 from unique_toolkit.tools.schemas import BaseToolConfig
 
 
-class MCPTool(Protocol):
+class MCPTool:
     """Protocol defining the expected structure of an MCP tool."""
 
     name: str
@@ -18,16 +17,6 @@ class MCPTool(Protocol):
     is_connected: bool
 
 
-class EnrichedMCPTool(MCPTool, Protocol):
-    """Protocol for MCP tools enriched with server information."""
-
-    server_id: str
-    server_name: str
-    server_system_prompt: Optional[str]
-    server_user_prompt: Optional[str]
-    mcp_source_id: str
-
-
 class MCPToolConfig(BaseToolConfig):
     """Configuration for MCP tools"""
 

unique_toolkit/tools/mcp/tool_wrapper.py

@@ -4,15 +4,14 @@ from typing import Any, Dict
 import unique_sdk
 from pydantic import BaseModel, Field, create_model
 
-from unique_toolkit.app.schemas import ChatEvent
+from unique_toolkit.app.schemas import ChatEvent, McpServer, McpTool
 from unique_toolkit.evals.schemas import EvaluationMetricName
 from unique_toolkit.language_model import LanguageModelMessage
 from unique_toolkit.language_model.schemas import (
     LanguageModelFunction,
     LanguageModelToolDescription,
-    LanguageModelToolMessage,
 )
-from unique_toolkit.tools.mcp.models import EnrichedMCPTool, MCPToolConfig
+from unique_toolkit.tools.mcp.models import MCPToolConfig
 from unique_toolkit.tools.schemas import ToolCallResponse
 from unique_toolkit.tools.tool import Tool
 from unique_toolkit.tools.tool_progress_reporter import (
@@ -26,24 +25,16 @@ class MCPToolWrapper(Tool[MCPToolConfig]):
 
     def __init__(
         self,
-        mcp_tool: EnrichedMCPTool,
+        mcp_server: McpServer,
+        mcp_tool: McpTool,
         config: MCPToolConfig,
         event: ChatEvent,
         tool_progress_reporter: ToolProgressReporter | None = None,
     ):
         self.name = mcp_tool.name
         super().__init__(config, event, tool_progress_reporter)
-        self.mcp_tool = mcp_tool
-        self._tool_description = mcp_tool.description or ""
-        self._parameters_schema = mcp_tool.input_schema
-
-        # Set the display name for user-facing messages
-        # Priority: title > annotations.title > name
-        self.display_name = (
-            getattr(mcp_tool, "title", None)
-            or (getattr(mcp_tool, "annotations", {}) or {}).get("title")
-            or mcp_tool.name
-        )
+        self._mcp_tool = mcp_tool
+        self._mcp_server = mcp_server
 
     def tool_description(self) -> LanguageModelToolDescription:
         """Convert MCP tool schema to LanguageModelToolDescription"""
@@ -52,14 +43,14 @@ class MCPToolWrapper(Tool[MCPToolConfig]):
 
         return LanguageModelToolDescription(
             name=self.name,
-            description=self._tool_description,
+            description=self._mcp_tool.description or "",
             parameters=parameters_model,
         )
 
     def _create_parameters_model(self) -> type[BaseModel]:
         """Create a Pydantic model from MCP tool's input schema"""
-        properties = self._parameters_schema.get("properties", {})
-        required_fields = self._parameters_schema.get("required", [])
+        properties = self._mcp_tool.input_schema.get("properties", {})
+        required_fields = self._mcp_tool.input_schema.get("required", [])
 
         # Convert JSON schema properties to Pydantic fields
         fields = {}
@@ -96,20 +87,30 @@ class MCPToolWrapper(Tool[MCPToolConfig]):
 
         return type_mapping.get(json_type, str)
 
-    def display_name(self) -> str:
-        """The display name of the tool."""
-        return self._display_name
-
     def tool_description_for_system_prompt(self) -> str:
         """Return tool description for system prompt"""
-        return self._tool_description
+        # Not using jinja here to keep it simple and not import new packages.
+        description = (
+            f"**MCP Server**: {self._mcp_server.name}\n"
+            f"**Tool Name**: {self.name}\n"
+            f"{self._mcp_tool.system_prompt}"
+        )
+
+        return description
+
+    def tool_description_for_user_prompt(self) -> str:
+        return self._mcp_tool.user_prompt or ""
+
+    def tool_format_information_for_user_prompt(self) -> str:
+        return ""
 
     def tool_format_information_for_system_prompt(self) -> str:
         """Return formatting information for system prompt"""
-        return f"Use this MCP tool to {self._tool_description.lower()}"
+        return ""  # this is empty for now as it requires to add this to the MCP model of the backend.
 
     def evaluation_check_list(self) -> list[EvaluationMetricName]:
         """Return evaluation check list - empty for MCP tools for now"""
+        # TODO: this is empty for now as it requires a setting in the backend for choosing a suitable validator.
         return []
 
     def get_evaluation_checks_based_on_tool_response(
@@ -123,35 +124,18 @@ class MCPToolWrapper(Tool[MCPToolConfig]):
         self,
         tool_response: ToolCallResponse,
     ) -> LanguageModelMessage:
-        """Convert tool response to message for loop history"""
-        # Convert the tool response to a message for the conversation history
-        content = (
-            tool_response.error_message
-            if tool_response.error_message
-            else "Tool executed successfully"
-        )
-
-        if hasattr(tool_response, "content") and tool_response.content:
-            content = str(tool_response.content)
-        elif tool_response.debug_info:
-            content = json.dumps(tool_response.debug_info)
-
-        return LanguageModelToolMessage(
-            content=content,
-            tool_call_id=tool_response.id,
-            name=tool_response.name,
-        )
+        raise NotImplementedError("function is not supported")
 
     async def run(self, tool_call: LanguageModelFunction) -> ToolCallResponse:
         """Execute the MCP tool using SDK to call public API"""
         self.logger.info(f"Running MCP tool: {self.name}")
 
         # Notify progress if reporter is available
-        if self.tool_progress_reporter:
-            await self.tool_progress_reporter.notify_from_tool_call(
+        if self._tool_progress_reporter:
+            await self._tool_progress_reporter.notify_from_tool_call(
                 tool_call=tool_call,
-                name=f"**{self.display_name}**",
-                message=f"Executing MCP tool: {self.display_name}",
+                name=f"**{self.display_name()}**",
+                message=f"Executing MCP tool: {self.display_name()}",
                 state=ProgressState.RUNNING,
             )
 
@@ -163,23 +147,23 @@ class MCPToolWrapper(Tool[MCPToolConfig]):
             result = await self._call_mcp_tool_via_sdk(arguments)
 
             # Create successful response
-            tool_response = ToolCallResponse(
+            tool_response = ToolCallResponse(  # TODO: Why result here not applied directly to the body of the tool_response? like so how does it know the results in the history?
                 id=tool_call.id or "",
                 name=self.name,
                 debug_info={
                     "mcp_tool": self.name,
                     "arguments": arguments,
-                    "result": result,
                 },
                 error_message="",
+                content=json.dumps(result),
             )
 
             # Notify completion
-            if self.tool_progress_reporter:
-                await self.tool_progress_reporter.notify_from_tool_call(
+            if self._tool_progress_reporter:
+                await self._tool_progress_reporter.notify_from_tool_call(
                     tool_call=tool_call,
-                    name=f"**{self.display_name}**",
-                    message=f"MCP tool completed: {self.display_name}",
+                    name=f"**{self.display_name()}**",
+                    message=f"MCP tool completed: {self.display_name()}",
                     state=ProgressState.FINISHED,
                 )
 
@@ -189,10 +173,10 @@ class MCPToolWrapper(Tool[MCPToolConfig]):
             self.logger.error(f"Error executing MCP tool {self.name}: {e}")
 
             # Notify failure
-            if self.tool_progress_reporter:
-                await self.tool_progress_reporter.notify_from_tool_call(
+            if self._tool_progress_reporter:
+                await self._tool_progress_reporter.notify_from_tool_call(
                     tool_call=tool_call,
-                    name=f"**{self.display_name}**",
+                    name=f"**{self.display_name()}**",
                     message=f"MCP tool failed: {str(e)}",
                     state=ProgressState.FAILED,
                 )

unique_toolkit/tools/schemas.py

@@ -14,6 +14,7 @@ from unique_toolkit.tools.utils.source_handling.schema import SourceFormatConfig
 class ToolCallResponse(BaseModel):
     id: str
     name: str
+    content: str = ""
     debug_info: Optional[dict] = None  # TODO: Make the default {}
     content_chunks: Optional[list[ContentChunk]] = None  # TODO: Make the default []
     reasoning_result: Optional[dict] = None  # TODO: Make the default {}
@@ -133,6 +134,8 @@ class ToolPrompts(BaseModel):
     name: str
     display_name: str
     tool_system_prompt: str
-    tool_description: str
     tool_format_information_for_system_prompt: str
+    tool_user_prompt: str
+    tool_format_information_for_user_prompt: str
+    tool_description: str
     input_model: dict[str, Any]

unique_toolkit/tools/tool.py

@@ -57,13 +57,17 @@ class Tool(ABC, Generic[ConfigType]):
         else:
             return cast("dict[str, Any]", parameters)
 
-    @abstractmethod
     def tool_description_for_system_prompt(self) -> str:
-        raise NotImplementedError
+        return ""
 
-    @abstractmethod
     def tool_format_information_for_system_prompt(self) -> str:
-        raise NotImplementedError
+        return ""
+
+    def tool_description_for_user_prompt(self) -> str:
+        return ""
+
+    def tool_format_information_for_user_prompt(self) -> str:
+        return ""
 
     def tool_format_reminder_for_user_prompt(self) -> str:
         """A short reminder for the user prompt for formatting rules for the tool.
@@ -112,6 +116,8 @@ class Tool(ABC, Generic[ConfigType]):
             tool_system_prompt=self.tool_description_for_system_prompt(),
             tool_format_information_for_system_prompt=self.tool_format_information_for_system_prompt(),
             input_model=self.tool_description_as_json(),
+            tool_user_prompt=self.tool_description_for_user_prompt(),
+            tool_format_information_for_user_prompt=self.tool_format_information_for_user_prompt(),
         )
 
     # Properties that we should soon deprecate

unique_toolkit/tools/tool_manager.py

@@ -103,7 +103,7 @@ class ToolManager:
         ]
 
         # Get MCP tools (these are already properly instantiated)
-        mcp_tools = self._mcp_manager.get_all_mcp_tools(tool_choices)
+        mcp_tools = self._mcp_manager.get_all_mcp_tools()
         # Combine both types of tools
         self.available_tools = internal_tools + mcp_tools
 
@@ -277,8 +277,6 @@ class ToolManager:
             )
         return unique_tool_calls
 
-    from typing import Any
-
     def _convert_to_forced_tool(self, tool_name: str) -> dict[str, Any]:
         return {
             "type": "function",

{unique_toolkit-0.8.25.dist-info → unique_toolkit-0.8.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unique_toolkit
-Version: 0.8.25
+Version: 0.8.26
 Summary: 
 License: Proprietary
 Author: Martin Fadler
@@ -115,6 +115,9 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), 
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.8.26] - 2025-08-27
+- Optimized MCP manager
+
 ## [0.8.25] - 2025-08-27
 - Load environment variables automatically from plattform dirs or environment
 - General Endpoint definition utility

{unique_toolkit-0.8.25.dist-info → unique_toolkit-0.8.26.dist-info}/RECORD

@@ -74,7 +74,7 @@ unique_toolkit/framework_utilities/openai/client.py,sha256=CiQjTq2erh8mPJ5gOSKUW
 unique_toolkit/framework_utilities/openai/message_builder.py,sha256=VU6mJm_upLcarJQKFft_t1RlLRncWDxDuLC5LIJ5lQQ,4339
 unique_toolkit/framework_utilities/utils.py,sha256=JK7g2yMfEx3eMprug26769xqNpS5WJcizf8n2zWMBng,789
 unique_toolkit/history_manager/history_construction_with_contents.py,sha256=c8Zy3erSbHGT8AdICRRlSK91T_FN6tNpTznvUzpLbWk,9023
-unique_toolkit/history_manager/history_manager.py,sha256=X0uIOXIYcZ2dzNUc0SkKFKKii3pu1hp3WWm1SeqsRcA,8099
+unique_toolkit/history_manager/history_manager.py,sha256=e18ldkof6ZRSzD8FefodazNFNHvmQIxP9cG0j6Yrl18,8350
 unique_toolkit/history_manager/loop_token_reducer.py,sha256=9kqJioUehfoYs5-XMoCv-b_5JpNRrhOz62QwhC3LF3E,17899
 unique_toolkit/history_manager/utils.py,sha256=iu4LsYOElx8HlZjcx3ZC75I-TmEYBiEP9q2J93Q63Mg,5606
 unique_toolkit/language_model/__init__.py,sha256=lRQyLlbwHbNFf4-0foBU13UGb09lwEeodbVsfsSgaCk,1971
@@ -101,21 +101,21 @@ unique_toolkit/smart_rules/compile.py,sha256=cxWjb2dxEI2HGsakKdVCkSNi7VK9mr08w5s
 unique_toolkit/thinking_manager/thinking_manager.py,sha256=AJfmrTXTr-DxBnJ2_zYYpYo57kr5deqT0LiZb8UdaDQ,4175
 unique_toolkit/tools/config.py,sha256=E4lFQA4gCi3_j4hcdnd5YUHhbaWTyIGWrgD18QardQw,3796
 unique_toolkit/tools/factory.py,sha256=w3uNHuYBIJ330Xi8PTdAkr8G3OMbQH2cBgvk5UT16oE,1253
-unique_toolkit/tools/mcp/__init__.py,sha256=_2_im3F4IgAwKyHysndhQSV1GbfoRviNOZlAS5vkF3Q,158
-unique_toolkit/tools/mcp/manager.py,sha256=7J9oE_4WxYcPDXx8RcWP67pt5oVMCUvxk_FDsu2J3YY,3218
-unique_toolkit/tools/mcp/models.py,sha256=4SFE12Y8xoJ0GBaXdz8oylhUBMHrrm66BRurCm3tCAI,987
-unique_toolkit/tools/mcp/tool_wrapper.py,sha256=lclzLZ9q4q6dLg7wUJq_aYjV0sTlQwk5abB9DeXJsr8,10287
-unique_toolkit/tools/schemas.py,sha256=PJBWN9NcEBSUmhrAMznbnw06ordrf4lfbhcxYZFmAOc,4720
+unique_toolkit/tools/mcp/__init__.py,sha256=RLF_p-LDRC7GhiB3fdCi4u3bh6V9PY_w26fg61BLyco,122
+unique_toolkit/tools/mcp/manager.py,sha256=KyPiCLgSfpGkkOhvJtwQCm_dQ1M7LkQlctkBzt0bMAM,2683
+unique_toolkit/tools/mcp/models.py,sha256=6-qFq3ip2OhqRC5H6YzhsC27w5CYrWln75dWmeIovRk,713
+unique_toolkit/tools/mcp/tool_wrapper.py,sha256=w7Fbo4FSMYvtgSq7Sqt1dmAPvqHjoBQS-TwnSp0p6j0,9927
+unique_toolkit/tools/schemas.py,sha256=rArQccbfIv7CWcozClAZ-BVlOwAsjpgL8KUab_WeO3k,4817
 unique_toolkit/tools/test/test_mcp_manager.py,sha256=jnVKxqJyeJBDb6LvI8bM9dd8XPxrbXV0VCOHMhCdlug,14398
 unique_toolkit/tools/test/test_tool_progress_reporter.py,sha256=GTtmBqOUo0-4fh_q0lRgxDhwKeankc3FHFD5ULZAm4Y,6299
-unique_toolkit/tools/tool.py,sha256=zreY6fGBAfOIPNujWkl4cV5fBojjzGzVyvYuNLDrbzQ,5626
-unique_toolkit/tools/tool_manager.py,sha256=-DTfX608iPSHo2_UlC_lVG8DGJfWhuzjAk_Wshc3YTQ,9988
+unique_toolkit/tools/tool.py,sha256=E0qORpQBrdksAylf_RuPaEbXKi_AlswVGv-67t3DNZI,5879
+unique_toolkit/tools/tool_manager.py,sha256=_Qt5fUGvA82YHn5LvqNJurLYW41jH9endNwsiSeyXyM,9948
 unique_toolkit/tools/tool_progress_reporter.py,sha256=ixud9VoHey1vlU1t86cW0-WTvyTwMxNSWBon8I11SUk,7955
 unique_toolkit/tools/utils/execution/execution.py,sha256=vjG2Y6awsGNtlvyQAGCTthQ5thWHYnn-vzZXaYLb3QE,7922
 unique_toolkit/tools/utils/source_handling/schema.py,sha256=vzAyf6ZWNexjMO0OrnB8y2glGkvAilmGGQXd6zcDaKw,870
 unique_toolkit/tools/utils/source_handling/source_formatting.py,sha256=C7uayNbdkNVJdEARA5CENnHtNY1SU6etlaqbgHNyxaQ,9152
 unique_toolkit/tools/utils/source_handling/tests/test_source_formatting.py,sha256=oM5ZxEgzROrnX1229KViCAFjRxl9wCTzWZoinYSHleM,6979
-unique_toolkit-0.8.25.dist-info/LICENSE,sha256=GlN8wHNdh53xwOPg44URnwag6TEolCjoq3YD_KrWgss,193
-unique_toolkit-0.8.25.dist-info/METADATA,sha256=VSgIOC7Zd7mtwd0Ay4azu35JH7TO-aKIqTusVDXX2cQ,28900
-unique_toolkit-0.8.25.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-unique_toolkit-0.8.25.dist-info/RECORD,,
+unique_toolkit-0.8.26.dist-info/LICENSE,sha256=GlN8wHNdh53xwOPg44URnwag6TEolCjoq3YD_KrWgss,193
+unique_toolkit-0.8.26.dist-info/METADATA,sha256=sTwRsRjcDR2QqTqbe8Oz5j5MHObkvMkOfND9EUyh7XE,28950
+unique_toolkit-0.8.26.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+unique_toolkit-0.8.26.dist-info/RECORD,,