unique_toolkit 0.8.24__tar.gz → 0.8.26__tar.gz

{unique_toolkit-0.8.24 → unique_toolkit-0.8.26}/CHANGELOG.md

@@ -5,6 +5,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 → unique_toolkit-0.8.26}/PKG-INFO

@@ -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 → unique_toolkit-0.8.26}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "unique_toolkit"
-version = "0.8.24"
+version = "0.8.26"
 description = ""
 authors = [
     "Martin Fadler <martin.fadler@unique.ch>",
@@ -24,6 +24,7 @@ unique-sdk = "^0.10.0"
 pydantic-settings = "^2.10.1"
 sseclient = "^0.0.27"
 openai = "^1.99.9"
+platformdirs = "^4.0.0"
 
 [tool.poetry.group.langchain]
 optional = true

{unique_toolkit-0.8.24 → unique_toolkit-0.8.26}/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-0.8.26/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-0.8.24 → unique_toolkit-0.8.26}/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-0.8.24 → unique_toolkit-0.8.26}/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-0.8.24 → unique_toolkit-0.8.26}/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-0.8.26/unique_toolkit/framework_utilities/__init__.py

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

{unique_toolkit-0.8.24 → unique_toolkit-0.8.26}/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-0.8.26/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-0.8.24 → unique_toolkit-0.8.26}/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-0.8.24 → unique_toolkit-0.8.26}/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.26/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.26/unique_toolkit/tools/mcp/manager.py

@@ -0,0 +1,67 @@
+import logging
+
+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
+
+
+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.24 → unique_toolkit-0.8.26}/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"""