unique_toolkit 1.29.4__tar.gz → 1.31.0__tar.gz

{unique_toolkit-1.29.4 → unique_toolkit-1.31.0}/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).
 
+## [1.31.0] - 2025-11-20
+- Adding model `litellm:anthropic-claude-opus-4-5` to `language_model/info.py`
+
+## [1.30.0] - 2025-11-26
+- Add option to only display parts of sub agent responses.
+
 ## [1.29.4] - 2025-11-25
 - Add display name to openai builtin tools
 

{unique_toolkit-1.29.4 → unique_toolkit-1.31.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unique_toolkit
-Version: 1.29.4
+Version: 1.31.0
 Summary: 
 License: Proprietary
 Author: Cedric Klinkert
@@ -121,6 +121,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).
 
+## [1.31.0] - 2025-11-20
+- Adding model `litellm:anthropic-claude-opus-4-5` to `language_model/info.py`
+
+## [1.30.0] - 2025-11-26
+- Add option to only display parts of sub agent responses.
+
 ## [1.29.4] - 2025-11-25
 - Add display name to openai builtin tools
 

{unique_toolkit-1.29.4 → unique_toolkit-1.31.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "unique_toolkit"
-version = "1.29.4"
+version = "1.31.0"
 description = ""
 authors = [
     "Cedric Klinkert <cedric.klinkert@unique.ch>",
@@ -45,6 +45,13 @@ openai = "^1.97.0"
 langchain = "^0.3.27"
 langchain-openai = "^0.3.28"
 
+[tool.poetry.group.fastapi]
+optional = true
+
+[tool.poetry.group.fastapi.dependencies]
+fastapi = "^0.119.0"
+uvicorn = "^0.37.0"
+
 [tool.poetry.group.dev.dependencies]
 ruff = "0.12.10"
 pytest = "^7.4.3"

{unique_toolkit-1.29.4 → unique_toolkit-1.31.0}/unique_toolkit/agentic/tools/a2a/postprocessing/_display_utils.py

@@ -1,5 +1,5 @@
 import re
-from typing import Literal
+from typing import Literal, NamedTuple
 
 from unique_toolkit.agentic.tools.a2a.postprocessing.config import (
     SubAgentDisplayConfig,
@@ -126,7 +126,7 @@ def _get_display_template(
     if add_block_border:
         template = _wrap_with_block_border(template)
 
-    return template
+    return template.strip()
 
 
 def _get_display_removal_re(
@@ -150,10 +150,40 @@ def _get_display_removal_re(
     return re.compile(pattern, flags=re.DOTALL)
 
 
+class SubAgentAnswerPart(NamedTuple):
+    matching_text: str  # Matching text as found in the answer
+    formatted_text: str  # Formatted text to be displayed
+
+
+def get_sub_agent_answer_parts(
+    answer: str,
+    display_config: SubAgentDisplayConfig,
+) -> list[SubAgentAnswerPart]:
+    if display_config.mode == SubAgentResponseDisplayMode.HIDDEN:
+        return []
+
+    if len(display_config.answer_substrings_config) == 0:
+        return [SubAgentAnswerPart(matching_text=answer, formatted_text=answer)]
+
+    substrings = []
+    for config in display_config.answer_substrings_config:
+        match = re.search(config.regexp, answer)
+        if match is not None:
+            text = match.group(0)
+            substrings.append(
+                SubAgentAnswerPart(
+                    matching_text=text,
+                    formatted_text=config.display_template.format(text),
+                )
+            )
+
+    return substrings
+
+
 def get_sub_agent_answer_display(
     display_name: str,
     display_config: SubAgentDisplayConfig,
-    answer: str,
+    answer: str | list[str],
     assistant_id: str,
 ) -> str:
     template = _get_display_template(
@@ -162,6 +192,10 @@ def get_sub_agent_answer_display(
         add_block_border=display_config.add_block_border,
         display_title_template=display_config.display_title_template,
     )
+
+    if isinstance(answer, list):
+        answer = display_config.answer_substrings_separator.join(answer)
+
     return template.format(
         display_name=display_name, answer=answer, assistant_id=assistant_id
     )

{unique_toolkit-1.29.4 → unique_toolkit-1.31.0}/unique_toolkit/agentic/tools/a2a/postprocessing/config.py

@@ -13,6 +13,18 @@ class SubAgentResponseDisplayMode(StrEnum):
     PLAIN = "plain"
 
 
+class SubAgentAnswerSubstringConfig(BaseModel):
+    model_config = get_configuration_dict()
+
+    regexp: str = Field(
+        description="The regular expression to use to extract the substring. The first capture group will always be used.",
+    )
+    display_template: str = Field(
+        default="{}",
+        description="The template to use to display the substring. It should contain exactly one empty placeholder '{}' for the substring.",
+    )
+
+
 class SubAgentDisplayConfig(BaseModel):
     model_config = get_configuration_dict()
 
@@ -47,3 +59,12 @@ class SubAgentDisplayConfig(BaseModel):
         default=False,
         description="If set, the sub agent references will be added to the main agent response references even in not mentioned in the main agent response text.",
     )
+
+    answer_substrings_config: list[SubAgentAnswerSubstringConfig] = Field(
+        default=[],
+        description="If set, only parts of the answer matching the provided regular expressions will be displayed.",
+    )
+    answer_substrings_separator: str = Field(
+        default="\n",
+        description="The separator to use between the substrings.",
+    )

{unique_toolkit-1.29.4 → unique_toolkit-1.31.0}/unique_toolkit/agentic/tools/a2a/postprocessing/display.py

@@ -10,6 +10,7 @@ from unique_toolkit._common.pydantic_helpers import get_configuration_dict
 from unique_toolkit.agentic.postprocessor.postprocessor_manager import Postprocessor
 from unique_toolkit.agentic.tools.a2a.postprocessing._display_utils import (
     get_sub_agent_answer_display,
+    get_sub_agent_answer_parts,
     remove_sub_agent_answer_from_text,
 )
 from unique_toolkit.agentic.tools.a2a.postprocessing._ref_utils import (
@@ -44,6 +45,15 @@ class SubAgentResponsesPostprocessorConfig(BaseModel):
         default=1, description="Time to sleep before updating the main agent message."
     )
 
+    remove_duplicate_answers: bool = Field(
+        default=False,
+        description="If set, duplicate answers will only be displayed once. If sub agent is configured to display only substrings, this will remove duplicate substrings across different responses.",
+    )
+    answer_separator: str = Field(
+        default="",
+        description="The separator to use between the different sub agent answers.",
+    )
+
 
 class SubAgentResponsesDisplayPostprocessor(Postprocessor):
     def __init__(
@@ -96,6 +106,8 @@ class SubAgentResponsesDisplayPostprocessor(Postprocessor):
         answers_displayed_before = []
         answers_displayed_after = []
 
+        all_answers_displayed = set()
+
         for assistant_id, responses in displayed_sub_agent_responses.items():
             for response in responses:
                 message = response.message
@@ -105,6 +117,9 @@ class SubAgentResponsesDisplayPostprocessor(Postprocessor):
                     loop_response=loop_response, response=message
                 )
 
+                if tool_info.display_config.mode == SubAgentResponseDisplayMode.HIDDEN:
+                    continue
+
                 display_name = tool_info.display_name
                 if len(responses) > 1:
                     display_name += f" {response.sequence_number}"
@@ -116,13 +131,33 @@ class SubAgentResponsesDisplayPostprocessor(Postprocessor):
                         response.sequence_number,
                     )
 
-                if tool_info.display_config.mode == SubAgentResponseDisplayMode.HIDDEN:
+                message_text = message["text"] or ""
+
+                answer_parts = get_sub_agent_answer_parts(
+                    answer=message_text,
+                    display_config=tool_info.display_config,
+                )
+
+                if len(answer_parts) == 0:
                     continue
 
+                answer_display_texts = []
+                if self._config.remove_duplicate_answers:
+                    for answer_part in answer_parts:
+                        if answer_part.matching_text in all_answers_displayed:
+                            continue
+
+                        all_answers_displayed.add(answer_part.matching_text)
+                        answer_display_texts.append(answer_part.formatted_text)
+                else:
+                    answer_display_texts = [
+                        answer_part.formatted_text for answer_part in answer_parts
+                    ]
+
                 answer = get_sub_agent_answer_display(
                     display_name=display_name,
                     display_config=tool_info.display_config,
-                    answer=message["text"] or "",
+                    answer=answer_display_texts,
                     assistant_id=assistant_id,
                 )
 
@@ -135,6 +170,7 @@ class SubAgentResponsesDisplayPostprocessor(Postprocessor):
             text=loop_response.message.text,
             answers_before=answers_displayed_before,
             answers_after=answers_displayed_after,
+            sep=self._config.answer_separator,
         )
 
         return True
@@ -182,4 +218,5 @@ def _get_final_answer_display(
 
     if len(answers_after) > 0:
         text = text + sep + sep.join(answers_after)
-    return text
+
+    return text.strip()

{unique_toolkit-1.29.4 → unique_toolkit-1.31.0}/unique_toolkit/agentic/tools/a2a/postprocessing/test/test_display_utils.py

@@ -16,9 +16,11 @@ from unique_toolkit.agentic.tools.a2a.postprocessing._display_utils import (
     _wrap_with_details_tag,
     _wrap_with_quote_border,
     get_sub_agent_answer_display,
+    get_sub_agent_answer_parts,
     remove_sub_agent_answer_from_text,
 )
 from unique_toolkit.agentic.tools.a2a.postprocessing.config import (
+    SubAgentAnswerSubstringConfig,
     SubAgentDisplayConfig,
     SubAgentResponseDisplayMode,
 )
@@ -1333,3 +1335,389 @@ def test_remove_sub_agent_answer__no_op_when_assistant_not_found() -> None:
     assert result == original_text
     assert "Present answer" in result
     assert "Present Agent" in result
+
+
+# Test get_sub_agent_answer_parts
+
+
+@pytest.mark.ai
+def test_get_sub_agent_answer_parts__returns_empty__when_hidden_mode() -> None:
+    """
+    Purpose: Verify empty list returned for HIDDEN display mode.
+    Why this matters: Hidden mode should not extract any answer parts.
+    Setup summary: Set mode to HIDDEN, assert empty list.
+    """
+    # Arrange
+    answer = "Some answer text"
+    config = SubAgentDisplayConfig(
+        mode=SubAgentResponseDisplayMode.HIDDEN,
+    )
+
+    # Act
+    result = get_sub_agent_answer_parts(answer=answer, display_config=config)
+
+    # Assert
+    assert result == []
+
+
+@pytest.mark.ai
+def test_get_sub_agent_answer_parts__returns_full_answer__when_no_config() -> None:
+    """
+    Purpose: Verify full answer returned when no substring config provided.
+    Why this matters: Default behavior should return entire answer.
+    Setup summary: Provide answer without substring config, assert full answer.
+    """
+    # Arrange
+    answer = "This is the complete answer"
+    config = SubAgentDisplayConfig(
+        mode=SubAgentResponseDisplayMode.PLAIN,
+        answer_substrings_config=[],
+    )
+
+    # Act
+    result = get_sub_agent_answer_parts(answer=answer, display_config=config)
+
+    # Assert
+    assert len(result) == 1
+    assert result[0].matching_text == answer
+    assert result[0].formatted_text == answer
+
+
+@pytest.mark.ai
+def test_get_sub_agent_answer_parts__extracts_single_match__with_one_regexp() -> None:
+    """
+    Purpose: Verify single substring extracted with one regexp config.
+    Why this matters: Core functionality for extracting specific answer parts.
+    Setup summary: Provide answer with single regexp config, assert match extracted.
+    """
+    # Arrange
+    answer = "The price is $42.99 for the item"
+    config = SubAgentDisplayConfig(
+        mode=SubAgentResponseDisplayMode.PLAIN,
+        answer_substrings_config=[
+            SubAgentAnswerSubstringConfig(regexp=r"\$\d+\.\d+"),
+        ],
+    )
+
+    # Act
+    result = get_sub_agent_answer_parts(answer=answer, display_config=config)
+
+    # Assert
+    assert len(result) == 1
+    assert result[0].matching_text == "$42.99"
+    assert result[0].formatted_text == "$42.99"
+
+
+@pytest.mark.ai
+def test_get_sub_agent_answer_parts__extracts_multiple_matches__with_multiple_regexps() -> (
+    None
+):
+    """
+    Purpose: Verify multiple substrings extracted with multiple regexp configs.
+    Why this matters: Supports extracting different types of information.
+    Setup summary: Provide answer with multiple regexp configs, assert all matches.
+    """
+    # Arrange
+    answer = "Contact John at john@example.com or call 555-1234"
+    config = SubAgentDisplayConfig(
+        mode=SubAgentResponseDisplayMode.PLAIN,
+        answer_substrings_config=[
+            SubAgentAnswerSubstringConfig(
+                regexp=r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"
+            ),
+            SubAgentAnswerSubstringConfig(regexp=r"\d{3}-\d{4}"),
+        ],
+    )
+
+    # Act
+    result = get_sub_agent_answer_parts(answer=answer, display_config=config)
+
+    # Assert
+    assert len(result) == 2
+    assert result[0].matching_text == "john@example.com"
+    assert result[1].matching_text == "555-1234"
+
+
+@pytest.mark.ai
+def test_get_sub_agent_answer_parts__applies_display_template__to_matched_text() -> (
+    None
+):
+    """
+    Purpose: Verify display template is applied to format matched text.
+    Why this matters: Allows customization of how extracted parts are displayed.
+    Setup summary: Provide template with placeholder, assert formatted output.
+    """
+    # Arrange
+    answer = "The temperature is 72 degrees"
+    config = SubAgentDisplayConfig(
+        mode=SubAgentResponseDisplayMode.PLAIN,
+        answer_substrings_config=[
+            SubAgentAnswerSubstringConfig(
+                regexp=r"\d+",
+                display_template="Temperature: {}°F",
+            ),
+        ],
+    )
+
+    # Act
+    result = get_sub_agent_answer_parts(answer=answer, display_config=config)
+
+    # Assert
+    assert len(result) == 1
+    assert result[0].matching_text == "72"
+    assert result[0].formatted_text == "Temperature: 72°F"
+
+
+@pytest.mark.ai
+def test_get_sub_agent_answer_parts__returns_empty_list__when_no_matches() -> None:
+    """
+    Purpose: Verify empty list returned when regexp doesn't match answer.
+    Why this matters: Handles cases where expected pattern not present.
+    Setup summary: Provide regexp that doesn't match, assert empty list.
+    """
+    # Arrange
+    answer = "This is plain text without numbers"
+    config = SubAgentDisplayConfig(
+        mode=SubAgentResponseDisplayMode.PLAIN,
+        answer_substrings_config=[
+            SubAgentAnswerSubstringConfig(regexp=r"\d+"),
+        ],
+    )
+
+    # Act
+    result = get_sub_agent_answer_parts(answer=answer, display_config=config)
+
+    # Assert
+    assert result == []
+
+
+@pytest.mark.ai
+def test_get_sub_agent_answer_parts__extracts_first_match_only__for_each_regexp() -> (
+    None
+):
+    """
+    Purpose: Verify only first match per regexp is extracted.
+    Why this matters: Function uses re.search which finds first occurrence.
+    Setup summary: Provide answer with multiple numbers, assert only first extracted.
+    """
+    # Arrange
+    answer = "First number is 42 and second is 99"
+    config = SubAgentDisplayConfig(
+        mode=SubAgentResponseDisplayMode.PLAIN,
+        answer_substrings_config=[
+            SubAgentAnswerSubstringConfig(regexp=r"\d+"),
+        ],
+    )
+
+    # Act
+    result = get_sub_agent_answer_parts(answer=answer, display_config=config)
+
+    # Assert
+    assert len(result) == 1
+    assert result[0].matching_text == "42"
+
+
+@pytest.mark.ai
+def test_get_sub_agent_answer_parts__handles_empty_answer__with_no_config() -> None:
+    """
+    Purpose: Verify empty answer returned as single part when no config.
+    Why this matters: Edge case handling for empty content.
+    Setup summary: Provide empty answer, assert single empty part.
+    """
+    # Arrange
+    answer = ""
+    config = SubAgentDisplayConfig(
+        mode=SubAgentResponseDisplayMode.PLAIN,
+        answer_substrings_config=[],
+    )
+
+    # Act
+    result = get_sub_agent_answer_parts(answer=answer, display_config=config)
+
+    # Assert
+    assert len(result) == 1
+    assert result[0].matching_text == ""
+    assert result[0].formatted_text == ""
+
+
+@pytest.mark.ai
+def test_get_sub_agent_answer_parts__handles_empty_answer__with_regexp_config() -> None:
+    """
+    Purpose: Verify empty list returned for empty answer with regexp config.
+    Why this matters: No matches possible in empty string.
+    Setup summary: Provide empty answer with regexp, assert empty list.
+    """
+    # Arrange
+    answer = ""
+    config = SubAgentDisplayConfig(
+        mode=SubAgentResponseDisplayMode.PLAIN,
+        answer_substrings_config=[
+            SubAgentAnswerSubstringConfig(regexp=r"\d+"),
+        ],
+    )
+
+    # Act
+    result = get_sub_agent_answer_parts(answer=answer, display_config=config)
+
+    # Assert
+    assert result == []
+
+
+@pytest.mark.ai
+def test_get_sub_agent_answer_parts__handles_multiline_answer__with_regexp() -> None:
+    """
+    Purpose: Verify regexp matching works across multiple lines.
+    Why this matters: Answers can span multiple lines.
+    Setup summary: Provide multiline answer with pattern, assert match found.
+    """
+    # Arrange
+    answer = "Line 1\nThe code is ABC123\nLine 3"
+    config = SubAgentDisplayConfig(
+        mode=SubAgentResponseDisplayMode.PLAIN,
+        answer_substrings_config=[
+            SubAgentAnswerSubstringConfig(regexp=r"[A-Z]{3}\d{3}"),
+        ],
+    )
+
+    # Act
+    result = get_sub_agent_answer_parts(answer=answer, display_config=config)
+
+    # Assert
+    assert len(result) == 1
+    assert result[0].matching_text == "ABC123"
+
+
+@pytest.mark.ai
+def test_get_sub_agent_answer_parts__handles_special_regex_chars__in_answer() -> None:
+    """
+    Purpose: Verify regexp can match content with special regex characters.
+    Why this matters: Answers may contain special characters.
+    Setup summary: Provide answer with special chars, use proper escaping in regexp.
+    """
+    # Arrange
+    answer = "The expression is: [test] (value)"
+    config = SubAgentDisplayConfig(
+        mode=SubAgentResponseDisplayMode.PLAIN,
+        answer_substrings_config=[
+            SubAgentAnswerSubstringConfig(regexp=r"\[test\]"),
+        ],
+    )
+
+    # Act
+    result = get_sub_agent_answer_parts(answer=answer, display_config=config)
+
+    # Assert
+    assert len(result) == 1
+    assert result[0].matching_text == "[test]"
+
+
+@pytest.mark.ai
+def test_get_sub_agent_answer_parts__skips_non_matching_configs__returns_matches_only() -> (
+    None
+):
+    """
+    Purpose: Verify only matching regexp configs produce results.
+    Why this matters: Should not fail on partial matches, only return what matches.
+    Setup summary: Provide multiple configs where only some match, assert partial results.
+    """
+    # Arrange
+    answer = "Value is 42"
+    config = SubAgentDisplayConfig(
+        mode=SubAgentResponseDisplayMode.PLAIN,
+        answer_substrings_config=[
+            SubAgentAnswerSubstringConfig(regexp=r"\d+"),  # Matches
+            SubAgentAnswerSubstringConfig(regexp=r"[A-Z]{3}"),  # Doesn't match
+            SubAgentAnswerSubstringConfig(regexp=r"Value"),  # Matches
+        ],
+    )
+
+    # Act
+    result = get_sub_agent_answer_parts(answer=answer, display_config=config)
+
+    # Assert
+    assert len(result) == 2
+    assert result[0].matching_text == "42"
+    assert result[1].matching_text == "Value"
+
+
+@pytest.mark.ai
+def test_get_sub_agent_answer_parts__preserves_order__of_configs_not_matches() -> None:
+    """
+    Purpose: Verify results follow config order, not match order in text.
+    Why this matters: Predictable output order based on configuration.
+    Setup summary: Provide configs in specific order, assert results match config order.
+    """
+    # Arrange
+    answer = "first 123 then abc"
+    config = SubAgentDisplayConfig(
+        mode=SubAgentResponseDisplayMode.PLAIN,
+        answer_substrings_config=[
+            SubAgentAnswerSubstringConfig(regexp=r"[a-z]{3,}"),  # Matches "first"
+            SubAgentAnswerSubstringConfig(regexp=r"\d+"),  # Matches "123"
+        ],
+    )
+
+    # Act
+    result = get_sub_agent_answer_parts(answer=answer, display_config=config)
+
+    # Assert
+    assert len(result) == 2
+    # Results follow config order, not text order
+    assert result[0].matching_text == "first"
+    assert result[1].matching_text == "123"
+
+
+@pytest.mark.ai
+def test_get_sub_agent_answer_parts__handles_complex_template__with_multiple_placeholders() -> (
+    None
+):
+    """
+    Purpose: Verify complex display templates with formatting work correctly.
+    Why this matters: Supports rich formatting of extracted content.
+    Setup summary: Provide template with additional text, assert formatted correctly.
+    """
+    # Arrange
+    answer = "User score: 95"
+    config = SubAgentDisplayConfig(
+        mode=SubAgentResponseDisplayMode.PLAIN,
+        answer_substrings_config=[
+            SubAgentAnswerSubstringConfig(
+                regexp=r"\d+",
+                display_template="**Score: {}%**",
+            ),
+        ],
+    )
+
+    # Act
+    result = get_sub_agent_answer_parts(answer=answer, display_config=config)
+
+    # Assert
+    assert len(result) == 1
+    assert result[0].matching_text == "95"
+    assert result[0].formatted_text == "**Score: 95%**"
+
+
+@pytest.mark.ai
+def test_get_sub_agent_answer_parts__works_with_details_modes__extracts_normally() -> (
+    None
+):
+    """
+    Purpose: Verify extraction works regardless of display mode (except HIDDEN).
+    Why this matters: Substring extraction independent of display mode.
+    Setup summary: Use DETAILS modes, assert extraction still works.
+    """
+    # Arrange
+    answer = "Result: SUCCESS"
+    config = SubAgentDisplayConfig(
+        mode=SubAgentResponseDisplayMode.DETAILS_CLOSED,
+        answer_substrings_config=[
+            SubAgentAnswerSubstringConfig(regexp=r"SUCCESS"),
+        ],
+    )
+
+    # Act
+    result = get_sub_agent_answer_parts(answer=answer, display_config=config)
+
+    # Assert
+    assert len(result) == 1
+    assert result[0].matching_text == "SUCCESS"

{unique_toolkit-1.29.4 → unique_toolkit-1.31.0}/unique_toolkit/app/__init__.py

@@ -47,5 +47,8 @@ from .schemas import (
 from .verification import (
     verify_signature_and_construct_event as verify_signature_and_construct_event,
 )
+from .webhook import (
+    is_webhook_signature_valid as is_webhook_signature_valid,
+)
 
 DOMAIN_NAME = "app"