unique_toolkit 1.21.0__tar.gz → 1.21.2__tar.gz

{unique_toolkit-1.21.0 → unique_toolkit-1.21.2}/CHANGELOG.md

@@ -5,6 +5,11 @@ 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).
 
+## [1.21.2] - 2025-10-30
+- Fixing that system format info is only appended to system prompt if tool is called
+
+## [1.21.1] - 2025-10-30
+- Improve Spaces 2.0 display of tool progress reporter configuration.
 
 ## [1.21.0] - 2025-10-30
 - Add option to customize the display of tool progress statuses.

{unique_toolkit-1.21.0 → unique_toolkit-1.21.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unique_toolkit
-Version: 1.21.0
+Version: 1.21.2
 Summary: 
 License: Proprietary
 Author: Cedric Klinkert
@@ -118,6 +118,11 @@ 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).
 
+## [1.21.2] - 2025-10-30
+- Fixing that system format info is only appended to system prompt if tool is called
+
+## [1.21.1] - 2025-10-30
+- Improve Spaces 2.0 display of tool progress reporter configuration.
 
 ## [1.21.0] - 2025-10-30
 - Add option to customize the display of tool progress statuses.

{unique_toolkit-1.21.0 → unique_toolkit-1.21.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "unique_toolkit"
-version = "1.21.0"
+version = "1.21.2"
 description = ""
 authors = [
     "Cedric Klinkert <cedric.klinkert@unique.ch>",

{unique_toolkit-1.21.0 → unique_toolkit-1.21.2}/unique_toolkit/agentic/history_manager/history_manager.py

@@ -120,9 +120,16 @@ class HistoryManager:
             reference_manager=reference_manager,
         )
         self._tool_call_result_history: list[ToolCallResponse] = []
+        self._tool_calls: list[LanguageModelFunction] = []
         self._loop_history: list[LanguageModelMessage] = []
         self._source_enumerator = 0
 
+    def add_tool_call(self, tool_call: LanguageModelFunction) -> None:
+        self._tool_calls.append(tool_call)
+
+    def get_tool_calls(self) -> list[LanguageModelFunction]:
+        return self._tool_calls
+
     def has_no_loop_messages(self) -> bool:
         return len(self._loop_history) == 0
 

{unique_toolkit-1.21.0 → unique_toolkit-1.21.2}/unique_toolkit/agentic/tools/test/test_tool_progress_reporter.py

@@ -252,8 +252,10 @@ class TestToolProgressReporterConfig:
         # Arrange
         custom_config = ToolProgressReporterConfig(
             state_to_display_template={
-                ProgressState.RUNNING: "⏳ {tool_name}: {message}",
-                ProgressState.FINISHED: "✅ {tool_name}: {message}",
+                "started": "⚪ {tool_name}: {message}",
+                "running": "⏳ {tool_name}: {message}",
+                "finished": "✅ {tool_name}: {message}",
+                "failed": "❌ {tool_name}: {message}",
             }
         )
         reporter = ToolProgressReporter(chat_service, config=custom_config)
@@ -275,19 +277,21 @@ class TestToolProgressReporterConfig:
 
     @pytest.mark.ai
     @pytest.mark.asyncio
-    async def test_config__skips_states_not_in_template__when_state_excluded(
+    async def test_config__skips_states_with_empty_template__when_state_hidden(
         self, chat_service, tool_call
     ) -> None:
         """
-        Purpose: Verify that states not in the config mapping are not displayed.
+        Purpose: Verify that states with empty string templates are not displayed.
         Why this matters: Allows selective display of only certain states (e.g., hide STARTED).
-        Setup summary: Create config excluding RUNNING state, verify message is not displayed.
+        Setup summary: Create config with empty string for RUNNING state, verify message is not displayed.
         """
         # Arrange
         custom_config = ToolProgressReporterConfig(
             state_to_display_template={
-                ProgressState.FINISHED: "✅ {tool_name}: {message}",
-                # RUNNING state is intentionally excluded
+                "started": "",
+                "running": "",  # Empty string hides RUNNING state
+                "finished": "✅ {tool_name}: {message}",
+                "failed": "❌ {tool_name}: {message}",
             }
         )
         reporter = ToolProgressReporter(chat_service, config=custom_config)
@@ -304,7 +308,7 @@ class TestToolProgressReporterConfig:
         chat_service.modify_assistant_message_async.assert_called()
         call_args = chat_service.modify_assistant_message_async.call_args
         content = call_args.kwargs["content"]
-        # Content should not contain the message since RUNNING is excluded
+        # Content should not contain the message since RUNNING template is empty
         assert "Processing" not in content
         assert "Test Tool" not in content
 
@@ -321,8 +325,10 @@ class TestToolProgressReporterConfig:
         # Arrange
         custom_config = ToolProgressReporterConfig(
             state_to_display_template={
-                ProgressState.RUNNING: "▶️ {tool_name} - {message}",
-                ProgressState.FINISHED: "✓ {tool_name} - {message}",
+                "started": "○ {tool_name} - {message}",
+                "running": "▶️ {tool_name} - {message}",
+                "finished": "✓ {tool_name} - {message}",
+                "failed": "✗ {tool_name} - {message}",
             }
         )
         reporter = ToolProgressReporter(chat_service, config=custom_config)
@@ -355,14 +361,17 @@ class TestToolProgressReporterConfig:
         self, chat_service, tool_call
     ) -> None:
         """
-        Purpose: Verify selective state display shows only FINISHED when it's the only state configured.
+        Purpose: Verify selective state display shows only FINISHED when other states use empty templates.
         Why this matters: Use case where user only wants final results, not intermediate steps.
-        Setup summary: Configure only FINISHED state, send STARTED and FINISHED, verify only FINISHED appears.
+        Setup summary: Configure only FINISHED with content, send STARTED and FINISHED, verify only FINISHED appears.
         """
         # Arrange
         custom_config = ToolProgressReporterConfig(
             state_to_display_template={
-                ProgressState.FINISHED: "Done: {tool_name} - {message}",
+                "started": "",  # Empty template hides STARTED
+                "running": "",  # Empty template hides RUNNING
+                "finished": "Done: {tool_name} - {message}",
+                "failed": "Failed: {tool_name} - {message}",
             }
         )
         reporter = ToolProgressReporter(chat_service, config=custom_config)
@@ -399,16 +408,23 @@ class TestToolProgressReporterConfig:
 
     @pytest.mark.ai
     @pytest.mark.asyncio
-    async def test_config__handles_empty_template_dict__when_all_states_excluded(
+    async def test_config__handles_all_empty_templates__when_all_states_hidden(
         self, chat_service, tool_call
     ) -> None:
         """
-        Purpose: Verify that an empty template dict results in no messages being displayed.
+        Purpose: Verify that all empty string templates result in no messages being displayed.
         Why this matters: Edge case handling and allows disabling all progress display.
-        Setup summary: Create config with empty dict, verify no tool messages appear.
+        Setup summary: Create config with all empty templates, verify no tool messages appear.
         """
         # Arrange
-        custom_config = ToolProgressReporterConfig(state_to_display_template={})
+        custom_config = ToolProgressReporterConfig(
+            state_to_display_template={
+                "started": "",
+                "running": "",
+                "finished": "",
+                "failed": "",
+            }
+        )
         reporter = ToolProgressReporter(chat_service, config=custom_config)
 
         # Act

{unique_toolkit-1.21.0 → unique_toolkit-1.21.2}/unique_toolkit/agentic/tools/tool_manager.py

@@ -1,7 +1,7 @@
 import asyncio
 from abc import ABC, abstractmethod
 from logging import Logger, getLogger
-from typing import override
+from typing import Literal, override
 
 from openai.types.chat import (
     ChatCompletionNamedToolChoiceParam,
@@ -70,6 +70,24 @@ class BaseToolManager(ABC):
     def get_exclusive_tools(self) -> list[str]:
         raise NotImplementedError()
 
+    @abstractmethod
+    def filter_tool_calls(
+        self,
+        tool_calls: list[LanguageModelFunction],
+        tool_types: list[Literal["mcp", "internal", "subagent"]],
+    ) -> list[LanguageModelFunction]:
+        """
+        Filter tool calls by their types.
+
+        Args:
+            tool_calls: List of tool calls to filter
+            tool_types: List of tool types to include (e.g., ["mcp", "internal", "subagent"])
+
+        Returns:
+            Filtered list of tool calls matching the specified types
+        """
+        raise NotImplementedError()
+
     def does_a_tool_take_control(self, tool_calls: list[LanguageModelFunction]) -> bool:
         for tool_call in tool_calls:
             tool_instance = self.get_tool_by_name(tool_call.name)
@@ -266,7 +284,7 @@ class ToolManager(BaseToolManager):
         )
 
         # Build internal tools from configurations
-        internal_tools = [
+        self._internal_tools = [
             ToolFactory.build_tool_with_settings(
                 t.name,
                 t,
@@ -278,9 +296,9 @@ class ToolManager(BaseToolManager):
         ]
 
         # Get MCP tools (these are already properly instantiated)
-        mcp_tools = self._mcp_manager.get_all_mcp_tools()
+        self._mcp_tools = self._mcp_manager.get_all_mcp_tools()
         # Combine both types of tools
-        self.available_tools = internal_tools + mcp_tools + sub_agents
+        self.available_tools = self._internal_tools + self._mcp_tools + sub_agents
         self._sub_agents = sub_agents
 
         for t in self.available_tools:
@@ -301,6 +319,29 @@ class ToolManager(BaseToolManager):
 
             self._tools.append(t)
 
+    @override
+    def filter_tool_calls(
+        self,
+        tool_calls: list[LanguageModelFunction],
+        tool_types: list[Literal["mcp", "internal", "subagent"]],
+    ) -> list[LanguageModelFunction]:
+        filtered_calls = []
+
+        # Build sets for efficient lookup
+        internal_tool_names = {tool.name for tool in self._internal_tools}
+        mcp_tool_names = {tool.name for tool in self._mcp_tools}
+        sub_agent_names = {tool.name for tool in self._sub_agents}
+
+        for tool_call in tool_calls:
+            if "internal" in tool_types and tool_call.name in internal_tool_names:
+                filtered_calls.append(tool_call)
+            elif "mcp" in tool_types and tool_call.name in mcp_tool_names:
+                filtered_calls.append(tool_call)
+            elif "subagent" in tool_types and tool_call.name in sub_agent_names:
+                filtered_calls.append(tool_call)
+
+        return filtered_calls
+
     @property
     def sub_agents(self) -> list[SubAgentTool]:
         return self._sub_agents
@@ -416,6 +457,15 @@ class ResponsesApiToolManager(BaseToolManager):
             builtin_tools=builtin_tools,
         )
 
+    @override
+    def filter_tool_calls(
+        self,
+        tool_calls: list[LanguageModelFunction],
+        tool_types: list[Literal["mcp", "internal", "subagent"]],
+    ) -> list[LanguageModelFunction]:
+        """Delegate filtering to the underlying tool manager."""
+        return self._tool_manager.filter_tool_calls(tool_calls, tool_types)
+
     @override
     def get_tool_by_name(self, name: str) -> Tool | None:
         return self._tool_manager.get_tool_by_name(name)

{unique_toolkit-1.21.0 → unique_toolkit-1.21.2}/unique_toolkit/agentic/tools/tool_progress_reporter.py

@@ -2,7 +2,7 @@ import re
 from datetime import datetime
 from enum import StrEnum
 from functools import wraps
-from typing import Protocol
+from typing import Protocol, TypedDict
 
 from pydantic import BaseModel, Field
 
@@ -33,39 +33,37 @@ class ToolExecutionStatus(BaseModel):
     timestamp: datetime = Field(default_factory=datetime.now)
 
 
-_DEFAULT_STATE_TO_DISPLAY_TEMPLATE = {
-    ProgressState.FINISHED: "{arrow}**{{tool_name}}** 🟢: {{message}}".format(
-        arrow=ARROW
-    ),
-    ProgressState.RUNNING: "{arrow}**{{tool_name}}** 🟡: {{message}}".format(
-        arrow=ARROW
-    ),
-    ProgressState.FAILED: "{arrow}**{{tool_name}}** 🔴: {{message}}".format(
-        arrow=ARROW
-    ),
-    ProgressState.STARTED: "{arrow}**{{tool_name}}** ⚪: {{message}}".format(
-        arrow=ARROW
-    ),
+class StateToDisplayTemplate(TypedDict):
+    started: str
+    running: str
+    failed: str
+    finished: str
+
+
+_DEFAULT_STATE_TO_DISPLAY_TEMPLATE: StateToDisplayTemplate = {
+    "started": "{arrow}**{{tool_name}}** ⚪: {{message}}".format(arrow=ARROW),
+    "running": "{arrow}**{{tool_name}}** 🟡: {{message}}".format(arrow=ARROW),
+    "finished": "{arrow}**{{tool_name}}** 🟢: {{message}}".format(arrow=ARROW),
+    "failed": "{arrow}**{{tool_name}}** 🔴: {{message}}".format(arrow=ARROW),
 }
 
 
 state_to_display_template_description = """
-A mapping progress states to display templates.
-The display template is a string that will be used to display the progress status.
-The template can contain the following placeholders:
+Display templates for the different progress states.
+The template is a string that will be used to display the progress status.
+It can contain the following placeholders:
 - `{tool_name}`: The name of the tool
 - `{message}`: The message to display (sent by the tool)
-
-If a state is not present in the mapping, then updates for that state will not be displayed.
 """.strip()
 
 
 class ToolProgressReporterConfig(BaseModel):
     model_config = get_configuration_dict()
 
-    state_to_display_template: dict[ProgressState, str] = Field(
+    state_to_display_template: StateToDisplayTemplate = Field(
         default=_DEFAULT_STATE_TO_DISPLAY_TEMPLATE,
         description=state_to_display_template_description,
+        title="Display Templates",
     )
 
 
@@ -188,12 +186,15 @@ class ToolProgressReporter:
     def _get_tool_status_display_message(
         self, name: str, message: str, state: ProgressState
     ) -> str | None:
-        if state in self._config.state_to_display_template:
-            return self._config.state_to_display_template[state].format(
-                tool_name=name,
-                message=message,
-            )
-        return None
+        display_message = self._config.state_to_display_template[state.value].format(
+            tool_name=name,
+            message=message,
+        )
+        # Don't display empty messages
+        if display_message.strip() == "":
+            return None
+
+        return display_message
 
 
 class ToolWithToolProgressReporter(Protocol):