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

unique_toolkit/__init__.py

@@ -2,7 +2,12 @@
 from unique_toolkit.chat import ChatService
 from unique_toolkit.content import ContentService
 from unique_toolkit.embedding import EmbeddingService
-from unique_toolkit.language_model import LanguageModelMessages, LanguageModelService
+from unique_toolkit.language_model import (
+    LanguageModelMessages,
+    LanguageModelName,
+    LanguageModelService,
+    LanguageModelToolDescription,
+)
 from unique_toolkit.short_term_memory import ShortTermMemoryService
 
 # You can add other classes you frequently use here as well
@@ -10,6 +15,8 @@ from unique_toolkit.short_term_memory import ShortTermMemoryService
 __all__ = [
     "LanguageModelService",
     "LanguageModelMessages",
+    "LanguageModelName",
+    "LanguageModelToolDescription",
     "ChatService",
     "ContentService",
     "EmbeddingService",

unique_toolkit/_common/endpoint_builder.py

@@ -0,0 +1,145 @@
+"""
+This module provides a minimal framework for building endpoint classes such that a client can use
+the endpoints without having to know the details of the endpoints.
+"""
+
+from collections.abc import Callable
+from string import Formatter, Template
+from typing import (
+    Any,
+    Generic,
+    ParamSpec,
+    Protocol,
+    TypeVar,
+)
+
+from pydantic import BaseModel
+
+# Type variables
+ResponseType = TypeVar("ResponseType", bound=BaseModel)
+PathParamsType = TypeVar("PathParamsType", bound=BaseModel)
+RequestBodyType = TypeVar("RequestBodyType", bound=BaseModel)
+
+# ParamSpecs for function signatures
+RequestConstructorSpec = ParamSpec("RequestConstructorSpec")
+PathParamsSpec = ParamSpec("PathParamsSpec")
+RequestBodySpec = ParamSpec("RequestBodySpec")
+
+
+# Necessary for typing of make_endpoint_class
+class EndpointClassProtocol(Protocol, Generic[PathParamsSpec, RequestBodySpec]):
+    @staticmethod
+    def create_url(
+        *args: PathParamsSpec.args, **kwargs: PathParamsSpec.kwargs
+    ) -> str: ...
+
+    @staticmethod
+    def create_payload(
+        *args: RequestBodySpec.args, **kwargs: RequestBodySpec.kwargs
+    ) -> dict[str, Any]: ...
+
+
+# Model for any client to implement
+class Client(Protocol):
+    def request(
+        self,
+        endpoint: EndpointClassProtocol,
+    ) -> dict[str, Any]: ...
+
+
+def build_endpoint_class(
+    *,
+    url_template: Template,
+    path_params_model: Callable[PathParamsSpec, PathParamsType],
+    payload_model: Callable[RequestBodySpec, RequestBodyType],
+    response_model: type[ResponseType],
+    dump_options: dict | None = None,
+) -> type[EndpointClassProtocol[PathParamsSpec, RequestBodySpec]]:
+    """Generate a class with static methods for endpoint handling.
+
+    Uses separate models for path parameters and request body for clean API design.
+
+    Returns a class with static methods:
+    - create_url: Creates URL from path parameters
+    - create_payload: Creates request body payload
+    """
+    if not dump_options:
+        dump_options = {
+            "exclude_unset": True,
+            "by_alias": True,
+            "exclude_defaults": True,
+        }
+
+    class EndpointClass(EndpointClassProtocol):
+        @staticmethod
+        def create_url(
+            *args: PathParamsSpec.args, **kwargs: PathParamsSpec.kwargs
+        ) -> str:
+            """Create URL from path parameters."""
+            path_model = path_params_model(*args, **kwargs)
+            path_dict = path_model.model_dump(**dump_options)
+
+            # Extract expected path parameters from template
+            template_params = [
+                fname
+                for _, fname, _, _ in Formatter().parse(url_template.template)
+                if fname is not None
+            ]
+
+            # Verify all required path parameters are present
+            missing_params = [
+                param for param in template_params if param not in path_dict
+            ]
+            if missing_params:
+                raise ValueError(f"Missing path parameters: {missing_params}")
+
+            return url_template.substitute(**path_dict)
+
+        @staticmethod
+        def create_payload(
+            *args: RequestBodySpec.args, **kwargs: RequestBodySpec.kwargs
+        ) -> dict[str, Any]:
+            """Create request body payload."""
+            request_model = payload_model(*args, **kwargs)
+            return request_model.model_dump(**dump_options)
+
+        @staticmethod
+        def handle_response(response: dict[str, Any]) -> ResponseType:
+            return response_model.model_validate(response)
+
+    return EndpointClass
+
+
+if __name__ == "__main__":
+    # Example models
+    class GetUserPathParams(BaseModel):
+        """Path parameters for the user endpoint."""
+
+        user_id: int
+
+    class GetUserRequestBody(BaseModel):
+        """Request body/query parameters for the user endpoint."""
+
+        include_profile: bool = False
+
+    class UserResponse(BaseModel):
+        """Response model for user data."""
+
+        id: int
+        name: str
+
+    # Example usage of make_endpoint_class
+    UserEndpoint = build_endpoint_class(
+        url_template=Template("/users/${user_id}"),
+        path_params_model=GetUserPathParams,
+        payload_model=GetUserRequestBody,
+        response_model=UserResponse,
+    )
+
+    # Create URL from path parameters
+    url = UserEndpoint.create_url(user_id=123)
+    print(f"URL: {url}")
+
+    # Create payload from request body parameters
+    payload = UserEndpoint.create_payload(include_profile=True)
+    print(f"Payload: {payload}")

unique_toolkit/app/schemas.py

@@ -227,6 +227,17 @@ class ChatEvent(BaseEvent):
             data = json.load(f)
         return cls.model_validate(data)
 
+    def get_initial_debug_info(self) -> dict[str, Any]:
+        """Get the debug information for the chat event"""
+
+        # TODO: Make sure this coincides with what is shown in the first user message
+        return {
+            "user_metadata": self.payload.user_metadata,
+            "tool_parameters": self.payload.tool_parameters,
+            "chosen_module": self.payload.name,
+            "assistant": {"id": self.payload.assistant_id},
+        }
+
 
 @deprecated(
     """Use the more specific `ChatEvent` instead that has the same properties. \

unique_toolkit/app/unique_settings.py

@@ -1,8 +1,11 @@
+import os
 from logging import getLogger
 from pathlib import Path
 from typing import Self, TypeVar
 from urllib.parse import urlparse, urlunparse
 
+import unique_sdk
+from platformdirs import user_config_dir
 from pydantic import AliasChoices, Field, SecretStr, model_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
@@ -100,7 +103,9 @@ class UniqueApi(BaseSettings):
         parsed = urlparse(self.base_url)
 
         path = "/public/chat"
-        if parsed.hostname and "qa.unique" in parsed.hostname:
+        if parsed.hostname and (
+            "qa.unique" in parsed.hostname or ".unique" in parsed.hostname
+        ):
             path = "/public/chat-gen2"
         return urlunparse(parsed._replace(path=path, query=None, fragment=None))
 
@@ -142,12 +147,57 @@ class UniqueAuth(BaseSettings):
         return warn_about_defaults(self)
 
 
+class EnvFileNotFoundError(FileNotFoundError):
+    """Raised when no environment file can be found in any of the expected locations."""
+
+
 class UniqueSettings:
     def __init__(self, auth: UniqueAuth, app: UniqueApp, api: UniqueApi):
         self.app = app
         self.auth = auth
         self.api = api
 
+    @classmethod
+    def _find_env_file(cls, filename: str = "unique.env") -> Path:
+        """Find environment file using cross-platform fallback locations.
+
+        Search order:
+        1. UNIQUE_ENV_FILE environment variable
+        2. Current working directory
+        3. User config directory (cross-platform via platformdirs)
+
+        Args:
+            filename: Name of the environment file (default: 'unique.env')
+
+        Returns:
+            Path to the environment file.
+
+        Raises:
+            EnvFileNotFoundError: If no environment file is found in any location.
+        """
+        locations = [
+            # 1. Explicit environment variable
+            Path(env_path) if (env_path := os.environ.get("UNIQUE_ENV_FILE")) else None,
+            # 2. Current working directory
+            Path.cwd() / filename,
+            # 3. User config directory (cross-platform)
+            Path(user_config_dir("unique", "unique-toolkit")) / filename,
+        ]
+
+        for location in locations:
+            if location and location.exists() and location.is_file():
+                return location
+
+        # If no file found, provide helpful error message
+        searched_locations = [str(loc) for loc in locations if loc is not None]
+        raise EnvFileNotFoundError(
+            f"Environment file '{filename}' not found. Searched locations:\n"
+            + "\n".join(f"  - {loc}" for loc in searched_locations)
+            + "\n\nTo fix this:\n"
+            + f"  1. Create {filename} in one of the above locations, or\n"
+            + f"  2. Set UNIQUE_ENV_FILE environment variable to point to your {filename} file"
+        )
+
     @classmethod
     def from_env(cls, env_file: Path | None = None) -> "UniqueSettings":
         """Initialize settings from environment variables and/or env file.
@@ -171,3 +221,54 @@ class UniqueSettings:
         app = UniqueApp(_env_file=env_file_str)  # type: ignore[call-arg]
         api = UniqueApi(_env_file=env_file_str)  # type: ignore[call-arg]
         return cls(auth=auth, app=app, api=api)
+
+    @classmethod
+    def from_env_auto(cls, filename: str = "unique.env") -> "UniqueSettings":
+        """Initialize settings by automatically finding environment file.
+
+        This method will automatically search for an environment file in standard locations
+        and fall back to environment variables only if no file is found.
+
+        Args:
+            filename: Name of the environment file to search for (default: '.env')
+
+        Returns:
+            UniqueSettings instance with values loaded from found env file or environment variables.
+        """
+        try:
+            env_file = cls._find_env_file(filename)
+            return cls.from_env(env_file=env_file)
+        except EnvFileNotFoundError:
+            logger.warning(
+                f"Environment file '{filename}' not found. Falling back to environment variables only."
+            )
+            # Fall back to environment variables only
+            return cls.from_env()
+
+    def init_sdk(self) -> None:
+        """Initialize the unique_sdk global configuration with these settings.
+
+        This method configures the global unique_sdk module with the API key,
+        app ID, and base URL from these settings.
+        """
+        unique_sdk.api_key = self.app.key.get_secret_value()
+        unique_sdk.app_id = self.app.id.get_secret_value()
+        unique_sdk.api_base = self.api.sdk_url()
+
+    @classmethod
+    def from_env_auto_with_sdk_init(
+        cls, filename: str = "unique.env"
+    ) -> "UniqueSettings":
+        """Initialize settings and SDK in one convenient call.
+
+        This method combines from_env_auto() and init_sdk() for the most common use case.
+
+        Args:
+            filename: Name of the environment file to search for (default: '.env')
+
+        Returns:
+            UniqueSettings instance with SDK already initialized.
+        """
+        settings = cls.from_env_auto(filename)
+        settings.init_sdk()
+        return settings

unique_toolkit/chat/service.py

@@ -479,6 +479,10 @@ class ChatService:
             set_completed_at=set_completed_at or False,
         )
 
+    def free_user_input(self) -> None:
+        """Unblocks the next user input"""
+        self.modify_assistant_message(set_completed_at=True)
+
     def get_full_history(self) -> list[ChatMessage]:
         """Loads the full chat history for the chat session synchronously.
 

unique_toolkit/framework_utilities/__init__.py

@@ -0,0 +1 @@
+"""Framework utilities for integrating with external frameworks."""

unique_toolkit/framework_utilities/langchain/client.py

@@ -23,7 +23,7 @@ else:
 
 
 def get_client(
-    unique_settings: UniqueSettings, model: str = "AZURE_GPT_4o_2024_0806"
+    unique_settings: UniqueSettings | None = None, model: str = "AZURE_GPT_4o_2024_0806"
 ) -> ChatOpenAI:
     """Get a Langchain ChatOpenAI client instance.
 
@@ -36,6 +36,8 @@ def get_client(
     Raises:
         LangchainNotInstalledError: If langchain-openai package is not installed
     """
+    if unique_settings is None:
+        unique_settings = UniqueSettings.from_env_auto()
 
     return ChatOpenAI(
         base_url=unique_settings.api.openai_proxy_url(),

unique_toolkit/framework_utilities/openai/__init__.py

@@ -0,0 +1,6 @@
+"""OpenAI framework utilities."""
+
+from .client import get_openai_client
+from .message_builder import OpenAIMessageBuilder
+
+__all__ = ["get_openai_client", "OpenAIMessageBuilder"]

unique_toolkit/framework_utilities/openai/client.py

@@ -22,7 +22,7 @@ else:
     raise OpenAINotInstalledError()
 
 
-def get_openai_client(unique_settings: UniqueSettings) -> OpenAI:
+def get_openai_client(unique_settings: UniqueSettings | None = None) -> OpenAI:
     """Get an OpenAI client instance.
 
     Args:
@@ -34,6 +34,9 @@ def get_openai_client(unique_settings: UniqueSettings) -> OpenAI:
     Raises:
         OpenAINotInstalledError: If OpenAI package is not installed
     """
+    if unique_settings is None:
+        unique_settings = UniqueSettings.from_env_auto()
+
     default_headers = get_default_headers(unique_settings.app, unique_settings.auth)
 
     return OpenAI(

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.24.dist-info → unique_toolkit-0.8.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unique_toolkit
-Version: 0.8.24
+Version: 0.8.26
 Summary: 
 License: Proprietary
 Author: Martin Fadler
@@ -12,6 +12,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: numpy (>=1.26.4,<2.0.0)
 Requires-Dist: openai (>=1.99.9,<2.0.0)
+Requires-Dist: platformdirs (>=4.0.0,<5.0.0)
 Requires-Dist: pydantic (>=2.8.2,<3.0.0)
 Requires-Dist: pydantic-settings (>=2.10.1,<3.0.0)
 Requires-Dist: pyhumps (>=3.8.0,<4.0.0)
@@ -114,6 +115,15 @@ 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
+- Expose `LanguageModelToolDescription` and `LanguageModelName` directly
+- Get initial debug information from chat payload  
+
 ## [0.8.24] - 2025-08-25
 - Optimized hallucination manager
 

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

@@ -1,7 +1,8 @@
-unique_toolkit/__init__.py,sha256=waK7W0EK3v2RJ26hawccwVz1i3yHGvHIIu5qgGjEGHQ,583
+unique_toolkit/__init__.py,sha256=nbOYPIKERt-ITsgifrnJhatn1YNR38Ntumw-dCn_tsA,714
 unique_toolkit/_common/_base_service.py,sha256=S8H0rAebx7GsOldA7xInLp3aQJt9yEPDQdsGSFRJsGg,276
 unique_toolkit/_common/_time_utils.py,sha256=ztmTovTvr-3w71Ns2VwXC65OKUUh-sQlzbHdKTQWm-w,135
 unique_toolkit/_common/default_language_model.py,sha256=tmHSqg6e8G7RmKqmdE_tmLxkSN0x-aGoyUdy6Pl2oAE,334
+unique_toolkit/_common/endpoint_builder.py,sha256=oM6uDmxUqTAJut6MuJQj3bIX4yOccyErWD5bJ1d1lcY,4526
 unique_toolkit/_common/exception.py,sha256=caQIE1btsQnpKCHqL2cgWUSbHup06enQu_Pt7uGUTTE,727
 unique_toolkit/_common/token/image_token_counting.py,sha256=VpFfZyY0GIH27q_Wy4YNjk2algqvbCtJyzuuROoFQPw,2189
 unique_toolkit/_common/token/token_counting.py,sha256=Jo5B11GLlnaZDi4u7xCzIboLl8zn5cY_dmrogHixVdk,6132
@@ -13,14 +14,14 @@ unique_toolkit/app/init_logging.py,sha256=Sh26SRxOj8i8dzobKhYha2lLrkrMTHfB1V4jR3
 unique_toolkit/app/init_sdk.py,sha256=5_oDoETr6akwYyBCb0ivTdMNu3SVgPSkrXcDS6ELyY8,2269
 unique_toolkit/app/performance/async_tasks.py,sha256=H0l3OAcosLwNHZ8d2pd-Di4wHIXfclEvagi5kfqLFPA,1941
 unique_toolkit/app/performance/async_wrapper.py,sha256=yVVcRDkcdyfjsxro-N29SBvi-7773wnfDplef6-y8xw,1077
-unique_toolkit/app/schemas.py,sha256=J584RzwzIVSsdZyq0uVLI6efxIpWiMPKNz_IjIoOrxo,7432
-unique_toolkit/app/unique_settings.py,sha256=Gn8qxy_hNraVTTlP4wfZJzgxPU8cU6s84Uw6FK6ixGg,5946
+unique_toolkit/app/schemas.py,sha256=uh7PR-YYXfdTnuO5V_eGrW96eJmP5tJ4jeePyU8tsNI,7888
+unique_toolkit/app/unique_settings.py,sha256=hsQ4ViOs-E5K_bq96PwDvuVpfMJ-vNPq01B2gCK5R5g,9802
 unique_toolkit/app/verification.py,sha256=GxFFwcJMy25fCA_Xe89wKW7bgqOu8PAs5y8QpHF0GSc,3861
 unique_toolkit/chat/__init__.py,sha256=LRs2G-JTVuci4lbtHTkVUiNcZcSR6uqqfnAyo7af6nY,619
 unique_toolkit/chat/constants.py,sha256=05kq6zjqUVB2d6_P7s-90nbljpB3ryxwCI-CAz0r2O4,83
 unique_toolkit/chat/functions.py,sha256=I6r81PpWNu-j9DvHxNFKN3V6T5E5q42FhW9kF8pJJSY,29950
 unique_toolkit/chat/schemas.py,sha256=ekmDzxZRnO4pF-8DAnP4JqKmYuJnSC5RpYcO7j5T3aI,4927
-unique_toolkit/chat/service.py,sha256=iyOSzbRxAnxxGw4VrcduVPjA6cPw_98SL70YgL7V9VI,37837
+unique_toolkit/chat/service.py,sha256=-agXxkB_cl7Mcr3aFVHbBXhO-RioiouAfoHAHmlhQJs,37981
 unique_toolkit/chat/state.py,sha256=Cjgwv_2vhDFbV69xxsn7SefhaoIAEqLx3ferdVFCnOg,1445
 unique_toolkit/chat/utils.py,sha256=ihm-wQykBWhB4liR3LnwPVPt_qGW6ETq21Mw4HY0THE,854
 unique_toolkit/content/__init__.py,sha256=EdJg_A_7loEtCQf4cah3QARQreJx6pdz89Rm96YbMVg,940
@@ -65,13 +66,15 @@ unique_toolkit/evaluators/hallucination/service.py,sha256=k8qro5Lw4Ak58m4HYp3G4H
 unique_toolkit/evaluators/hallucination/utils.py,sha256=gO2AOzDQwVTev2_5vDKgJ9A6A9e0himJyAta_wglVG8,8326
 unique_toolkit/evaluators/output_parser.py,sha256=eI72qkzK1dZyUvnfP2SOAQCGBj_-PwX5wy_aLPMsJMY,883
 unique_toolkit/evaluators/schemas.py,sha256=Jaue6Uhx75X1CyHKWj8sT3RE1JZXTqoLtfLt2xQNCX8,2507
-unique_toolkit/framework_utilities/langchain/client.py,sha256=Msfmr7uezwqagyRJ2zjWbQRFqzDExWYK0y5KLEnDNqM,1329
+unique_toolkit/framework_utilities/__init__.py,sha256=fvAn9y4MRL1JgoO14ufQtLVRPRHn4jP07XRqt-TItCA,68
+unique_toolkit/framework_utilities/langchain/client.py,sha256=9LDRS2l9XGxL0HoFLh0ZrFUXrlt8o_J-o-1rU8j-uMQ,1432
 unique_toolkit/framework_utilities/langchain/history.py,sha256=R9RuCeSFNaUO3OZ0G_LmIC4gmOCIANcl91MfyWLnZ1c,650
-unique_toolkit/framework_utilities/openai/client.py,sha256=IasxPXlVJHIsZdXHin7yq-5tO4RNLUu9cEuhrgb4ghE,1205
+unique_toolkit/framework_utilities/openai/__init__.py,sha256=UDigDBIXPAfGgnaopg8Yvcr1S8RDbXyv3RsJDclAIGw,180
+unique_toolkit/framework_utilities/openai/client.py,sha256=CiQjTq2erh8mPJ5gOSKUW4DUQqykB7Qhb9azjtOk1u8,1309
 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
@@ -98,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.24.dist-info/LICENSE,sha256=GlN8wHNdh53xwOPg44URnwag6TEolCjoq3YD_KrWgss,193
-unique_toolkit-0.8.24.dist-info/METADATA,sha256=0vvS5x-HsApDZlOrB7vnLQPal3u7Ucqxv7hZa35ebOo,28588
-unique_toolkit-0.8.24.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-unique_toolkit-0.8.24.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,,