unique_toolkit 0.8.25__tar.gz → 0.8.27__tar.gz

{unique_toolkit-0.8.25 → unique_toolkit-0.8.27}/CHANGELOG.md

@@ -5,6 +5,12 @@ 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.27] - 2025-08-28
+- Fixed function "create_async" in language_model.functions : "user_id" argument should be optional.
+
+## [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 → unique_toolkit-0.8.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unique_toolkit
-Version: 0.8.25
+Version: 0.8.27
 Summary: 
 License: Proprietary
 Author: Martin Fadler
@@ -115,6 +115,12 @@ 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.27] - 2025-08-28
+- Fixed function "create_async" in language_model.functions : "user_id" argument should be optional.
+
+## [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 → unique_toolkit-0.8.27}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "unique_toolkit"
-version = "0.8.25"
+version = "0.8.27"
 description = ""
 authors = [
     "Martin Fadler <martin.fadler@unique.ch>",

{unique_toolkit-0.8.25 → unique_toolkit-0.8.27}/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-0.8.25 → unique_toolkit-0.8.27}/unique_toolkit/language_model/functions.py

@@ -94,9 +94,9 @@ def complete(
 
 async def complete_async(
     company_id: str,
-    user_id: str,
     messages: LanguageModelMessages | list[ChatCompletionMessageParam],
     model_name: LanguageModelName | str,
+    user_id: str | None = None,
     temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
     timeout: int = DEFAULT_COMPLETE_TIMEOUT,
     tools: list[LanguageModelTool | LanguageModelToolDescription] | None = None,

{unique_toolkit-0.8.25 → unique_toolkit-0.8.27}/unique_toolkit/language_model/service.py

@@ -277,9 +277,9 @@ class LanguageModelService:
     async def complete_async_util(
         cls,
         company_id: str,
-        user_id: str,
         messages: LanguageModelMessages,
         model_name: LanguageModelName | str,
+        user_id: str | None = None,
         temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
         timeout: int = DEFAULT_COMPLETE_TIMEOUT,
         tools: Optional[list[LanguageModelTool | LanguageModelToolDescription]] = None,

unique_toolkit-0.8.27/unique_toolkit/tools/mcp/__init__.py

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

unique_toolkit-0.8.27/unique_toolkit/tools/mcp/manager.py

@@ -0,0 +1,67 @@
+import logging
+
+from unique_toolkit.app.schemas import ChatEvent, McpServer
+from unique_toolkit.tools.config import ToolBuildConfig, ToolIcon, ToolSelectionPolicy
+from unique_toolkit.tools.mcp.models import MCPToolConfig
+from unique_toolkit.tools.mcp.tool_wrapper import MCPToolWrapper
+from unique_toolkit.tools.schemas import BaseToolConfig
+from unique_toolkit.tools.tool import Tool
+from unique_toolkit.tools.tool_progress_reporter import ToolProgressReporter
+
+
+class MCPManager:
+    def __init__(
+        self,
+        mcp_servers: list[McpServer],
+        event: ChatEvent,
+        tool_progress_reporter: ToolProgressReporter,
+    ):
+        self._mcp_servers = mcp_servers
+        self._event = event
+        self._tool_progress_reporter = tool_progress_reporter
+
+    def get_mcp_servers(self):
+        return self._mcp_servers
+
+    def get_mcp_server_by_id(self, id: str):
+        return next((server for server in self._mcp_servers if server.id == id), None)
+
+    def get_all_mcp_tools(self) -> list[Tool[BaseToolConfig]]:
+        selected_tools = []
+        for server in self._mcp_servers:
+            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}"
+                    )
+        return selected_tools

{unique_toolkit-0.8.25 → unique_toolkit-0.8.27}/unique_toolkit/tools/mcp/models.py

@@ -1,9 +1,9 @@
-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 +18,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-0.8.25 → unique_toolkit-0.8.27}/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-0.8.25 → unique_toolkit-0.8.27}/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-0.8.25 → unique_toolkit-0.8.27}/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-0.8.25 → unique_toolkit-0.8.27}/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/unique_toolkit/tools/mcp/__init__.py

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

unique_toolkit-0.8.25/unique_toolkit/tools/mcp/manager.py

@@ -1,82 +0,0 @@
-import logging
-
-from unique_toolkit.app.schemas import ChatEvent, McpServer, McpTool
-from unique_toolkit.tools.mcp.models import EnrichedMCPTool, MCPToolConfig
-from unique_toolkit.tools.mcp.tool_wrapper import MCPToolWrapper
-from unique_toolkit.tools.tool_progress_reporter import ToolProgressReporter
-
-
-class MCPManager:
-    def __init__(
-        self,
-        mcp_servers: list[McpServer],
-        event: ChatEvent,
-        tool_progress_reporter: ToolProgressReporter,
-    ):
-        self._mcp_servers = mcp_servers
-        self._event = event
-        self._tool_progress_reporter = tool_progress_reporter
-
-    def get_mcp_servers(self):
-        return self._mcp_servers
-
-    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]:
-        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 wrapper is not None:
-                        selected_tools.append(wrapper)
-        return selected_tools