unique_toolkit 1.29.4__py3-none-any.whl → 1.31.0__py3-none-any.whl

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/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/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/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/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"

unique_toolkit/app/fast_api_factory.py

@@ -0,0 +1,131 @@
+import json
+from logging import getLogger
+from typing import TYPE_CHECKING, Any, Callable, TypeVar
+
+from pydantic import ValidationError
+
+if TYPE_CHECKING:
+    from fastapi import BackgroundTasks, FastAPI, Request, status
+    from fastapi.responses import JSONResponse
+else:
+    try:
+        from fastapi import BackgroundTasks, FastAPI, Request, status
+        from fastapi.responses import JSONResponse
+    except ImportError:
+        FastAPI = None  # type: ignore[assignment, misc]
+        Request = None  # type: ignore[assignment, misc]
+        status = None  # type: ignore[assignment, misc]
+        JSONResponse = None  # type: ignore[assignment, misc]
+        BackgroundTasks = None  # type: ignore[assignment, misc]
+
+from unique_toolkit.app.schemas import BaseEvent, ChatEvent, EventName
+from unique_toolkit.app.unique_settings import UniqueSettings
+
+logger = getLogger(__name__)
+
+
+def default_event_handler(event: Any) -> int:
+    logger.info("Event received at event handler")
+    if status is not None:
+        return status.HTTP_200_OK
+    else:
+        # No fastapi installed
+        return 200
+
+
+T = TypeVar("T", bound=BaseEvent)
+
+
+def build_unique_custom_app(
+    *,
+    title: str = "Unique Chat App",
+    webhook_path: str = "/webhook",
+    settings: UniqueSettings,
+    event_handler: Callable[[T], int] = default_event_handler,
+    event_constructor: Callable[..., T] = ChatEvent,
+    subscribed_event_names: list[str] | None = None,
+) -> "FastAPI":
+    """Factory class for creating FastAPI apps with Unique webhook handling."""
+    if FastAPI is None:
+        raise ImportError(
+            "FastAPI is not installed. Install it with: poetry install --with fastapi"
+        )
+
+    app = FastAPI(title=title)
+
+    if subscribed_event_names is None:
+        subscribed_event_names = [EventName.EXTERNAL_MODULE_CHOSEN]
+
+    @app.get(path="/")
+    async def health_check() -> JSONResponse:
+        """Health check endpoint."""
+        return JSONResponse(content={"status": "healthy", "service": title})
+
+    @app.post(path=webhook_path)
+    async def webhook_handler(
+        request: Request, background_tasks: BackgroundTasks
+    ) -> JSONResponse:
+        """
+        Webhook endpoint for receiving events from Unique platform.
+
+        This endpoint:
+        1. Verifies the webhook signature
+        2. Constructs an event from the payload
+        3. Calls the configured event handler
+        """
+        # Get raw body and headers
+        body = await request.body()
+        headers = dict(request.headers)
+
+        from unique_toolkit.app.webhook import is_webhook_signature_valid
+
+        if not is_webhook_signature_valid(
+            headers=headers,
+            payload=body,
+            endpoint_secret=settings.app.endpoint_secret.get_secret_value(),
+        ):
+            return JSONResponse(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                content={"error": "Invalid webhook signature"},
+            )
+
+        try:
+            event_data = json.loads(body.decode(encoding="utf-8"))
+        except json.JSONDecodeError as e:
+            logger.error(f"Error parsing event: {e}", exc_info=True)
+            return JSONResponse(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                content={"error": f"Invalid event format: {str(e)}"},
+            )
+
+        if event_data["event"] not in subscribed_event_names:
+            return JSONResponse(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                content={"error": "Not subscribed event"},
+            )
+
+        try:
+            event = event_constructor(**event_data)
+            if event.filter_event(filter_options=settings.chat_event_filter_options):
+                return JSONResponse(
+                    status_code=status.HTTP_200_OK,
+                    content={"error": "Event filtered out"},
+                )
+        except ValidationError as e:
+            # pydantic errors https://docs.pydantic.dev/2.10/errors/errors/
+            logger.error(f"Validation error with model: {e.json()}", exc_info=True)
+            raise e
+        except ValueError as e:
+            logger.error(f"Error deserializing event: {e}", exc_info=True)
+            return JSONResponse(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                content={"error": "Invalid event"},
+            )
+
+        # Run the task in background so that we don't block for long running tasks
+        background_tasks.add_task(event_handler, event)
+        return JSONResponse(
+            status_code=status.HTTP_200_OK, content={"message": "Event received"}
+        )
+
+    return app

unique_toolkit/app/webhook.py

@@ -0,0 +1,77 @@
+"""
+Webhook signature verification for Unique platform.
+
+Extracted from unique_sdk to provide standalone verification without event construction.
+"""
+
+import hashlib
+import hmac
+import logging
+import time
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def is_webhook_signature_valid(
+    headers: dict[str, str],
+    payload: bytes,
+    endpoint_secret: str,
+    tolerance: int = 300,
+) -> bool:
+    """
+    Verify webhook signature from Unique platform.
+
+    Args:
+        headers: Request headers with X-Unique-Signature and X-Unique-Created-At
+        payload: Raw request body bytes
+        endpoint_secret: App endpoint secret from Unique platform
+        tolerance: Max seconds between timestamp and now (default: 300)
+
+    Returns:
+        True if signature is valid, False otherwise
+    """
+    # Extract headers
+    signature = headers.get("X-Unique-Signature") or headers.get("x-unique-signature")
+    timestamp_str = headers.get("X-Unique-Created-At") or headers.get(
+        "x-unique-created-at"
+    )
+
+    if not signature:
+        _LOGGER.error("Missing X-Unique-Signature header")
+        return False
+
+    if not timestamp_str:
+        _LOGGER.error("Missing X-Unique-Created-At header")
+        return False
+
+    # Convert timestamp to int
+    try:
+        timestamp = int(timestamp_str)
+    except ValueError:
+        _LOGGER.error(f"Invalid timestamp: {timestamp_str}")
+        return False
+
+    # Decode payload if bytes
+    message = payload.decode("utf-8") if isinstance(payload, bytes) else payload
+
+    # Compute expected signature: HMAC-SHA256(message, secret)
+    expected_signature = hmac.new(
+        endpoint_secret.encode("utf-8"),
+        msg=message.encode("utf-8"),
+        digestmod=hashlib.sha256,
+    ).hexdigest()
+
+    # Compare signatures (constant-time to prevent timing attacks)
+    if not hmac.compare_digest(expected_signature, signature):
+        _LOGGER.error("Signature mismatch. Ensure you're using the raw request body.")
+        return False
+
+    # Check timestamp tolerance (prevent replay attacks)
+    if tolerance and timestamp < time.time() - tolerance:
+        _LOGGER.error(
+            f"Timestamp outside tolerance ({tolerance}s). Possible replay attack."
+        )
+        return False
+
+    _LOGGER.debug("✅ Webhook signature verified successfully")
+    return True

unique_toolkit/language_model/infos.py

@@ -47,6 +47,7 @@ class LanguageModelName(StrEnum):
     ANTHROPIC_CLAUDE_SONNET_4_5 = "litellm:anthropic-claude-sonnet-4-5"
     ANTHROPIC_CLAUDE_OPUS_4 = "litellm:anthropic-claude-opus-4"
     ANTHROPIC_CLAUDE_OPUS_4_1 = "litellm:anthropic-claude-opus-4-1"
+    ANTHROPIC_CLAUDE_OPUS_4_5 = "litellm:anthropic-claude-opus-4-5"
     GEMINI_2_0_FLASH = "litellm:gemini-2-0-flash"
     GEMINI_2_5_FLASH = "litellm:gemini-2-5-flash"
     GEMINI_2_5_FLASH_LITE = "litellm:gemini-2-5-flash-lite"
@@ -946,7 +947,7 @@ class LanguageModelInfo(BaseModel):
                         ModelCapabilities.REASONING,
                     ],
                     provider=LanguageModelProvider.LITELLM,
-                    version="claude-opus-4",
+                    version="claude-opus-4-1",
                     encoder_name=EncoderName.O200K_BASE,  # TODO: Update encoder with litellm
                     token_limits=LanguageModelTokenLimits(
                         # Input limit is 200_000, we leave 20_000 tokens as buffer due to tokenizer mismatch
@@ -956,6 +957,26 @@ class LanguageModelInfo(BaseModel):
                     info_cutoff_at=date(2025, 3, 1),
                     published_at=date(2025, 5, 1),
                 )
+            case LanguageModelName.ANTHROPIC_CLAUDE_OPUS_4_5:
+                return cls(
+                    name=model_name,
+                    capabilities=[
+                        ModelCapabilities.FUNCTION_CALLING,
+                        ModelCapabilities.STREAMING,
+                        ModelCapabilities.VISION,
+                        ModelCapabilities.REASONING,
+                    ],
+                    provider=LanguageModelProvider.LITELLM,
+                    version="claude-opus-4-5",
+                    encoder_name=EncoderName.O200K_BASE,  # TODO: Update encoder with litellm
+                    token_limits=LanguageModelTokenLimits(
+                        # Input limit is 200_000, we leave 20_000 tokens as buffer due to tokenizer mismatch
+                        token_limit_input=180_000,
+                        token_limit_output=64_000,
+                    ),
+                    info_cutoff_at=date(2025, 8, 1),
+                    published_at=date(2025, 11, 13),
+                )
             case LanguageModelName.GEMINI_2_0_FLASH:
                 return cls(
                     name=model_name,

{unique_toolkit-1.29.4.dist-info → unique_toolkit-1.31.0.dist-info}/METADATA

@@ -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.dist-info → unique_toolkit-1.31.0.dist-info}/RECORD

@@ -82,12 +82,12 @@ unique_toolkit/agentic/tools/a2a/evaluation/evaluator.py,sha256=AJvXu0UJKHe72nRm
 unique_toolkit/agentic/tools/a2a/evaluation/summarization_user_message.j2,sha256=acP1YqD_sCy6DT0V2EIfhQTmaUKeqpeWNJ7RGgceo8I,271
 unique_toolkit/agentic/tools/a2a/manager.py,sha256=pk06UUXKQdIUY-PyykYiItubBjmIydOaqWvBBDwhMN4,1939
 unique_toolkit/agentic/tools/a2a/postprocessing/__init__.py,sha256=aVtUBPN7kDrqA6Bze34AbqQpcBBqpvfyJG-xF65w7R0,659
-unique_toolkit/agentic/tools/a2a/postprocessing/_display_utils.py,sha256=iIuddL5qJlPiPHLcMXVXzZfBtYsZTzMfaSk1et5LWUY,5461
+unique_toolkit/agentic/tools/a2a/postprocessing/_display_utils.py,sha256=lpcyCTm3KKhaYMF4Wh7DHrkP_WAOkbXha5QJc7zy2nc,6539
 unique_toolkit/agentic/tools/a2a/postprocessing/_ref_utils.py,sha256=E3KybH9SX5oOkh14sSaIaLnht4DhKVrHAiUkoACNBsg,2430
-unique_toolkit/agentic/tools/a2a/postprocessing/config.py,sha256=XVzZru7T-lULRsFKMJsBPY30XNSTj_MxEyGRCgBUnEk,1818
-unique_toolkit/agentic/tools/a2a/postprocessing/display.py,sha256=WbT4fXo3aPiUoHGkPon_rdB86wLTmxavhfQ6AzmNexU,6398
+unique_toolkit/agentic/tools/a2a/postprocessing/config.py,sha256=U5N2y6ok14daNf_u-E1SXnV9v9DwpW4jL_U_3o8oJ7Q,2633
+unique_toolkit/agentic/tools/a2a/postprocessing/display.py,sha256=9t6zsVAYCyGXMHkxyH_XHdIbU0w0WBY1O08wjJvjoig,7850
 unique_toolkit/agentic/tools/a2a/postprocessing/references.py,sha256=DGiv8WXMjIwumI7tlpWRgV8wSxnE282ryxEf03fgck8,3465
-unique_toolkit/agentic/tools/a2a/postprocessing/test/test_display_utils.py,sha256=5fIwvSQI6J_YIHyQgME5WfxgfJOg_ad6JHcsV43jOgY,39642
+unique_toolkit/agentic/tools/a2a/postprocessing/test/test_display_utils.py,sha256=mj2kR96ZzVIcgW3x-70oAjOLgYl5QreCIWBum1eQE_I,51989
 unique_toolkit/agentic/tools/a2a/postprocessing/test/test_ref_utils.py,sha256=u-eNrHjsRFcu4TmzkD5XfFrxvaIToB42YGyXZ-RpsR0,17830
 unique_toolkit/agentic/tools/a2a/prompts.py,sha256=0ILHL_RAcT04gFm2d470j4Gho7PoJXdCJy-bkZgf_wk,2401
 unique_toolkit/agentic/tools/a2a/response_watcher/__init__.py,sha256=fS8Lq49DZo5spMcP8QGTMWwSg80rYSr2pTfYDbssGYs,184
@@ -124,8 +124,9 @@ unique_toolkit/agentic/tools/utils/source_handling/__init__.py,sha256=47DEQpj8HB
 unique_toolkit/agentic/tools/utils/source_handling/schema.py,sha256=iHBKuks6tUy8tvian4Pd0B6_-8__SehVVNcxIUAUjEA,882
 unique_toolkit/agentic/tools/utils/source_handling/source_formatting.py,sha256=uZ0QXqrPWgId3ZA67dvjHQ6xrW491LK1xxx_sVJmFHg,9160
 unique_toolkit/agentic/tools/utils/source_handling/tests/test_source_formatting.py,sha256=EA8iVvb3L91OFk2XMbGcFuhe2etqm3Sx9QCYDGiOSOM,6995
-unique_toolkit/app/__init__.py,sha256=ETxYDpEizg_PKmi4JPX_P76ySq-us-xypfAIdKQ1QZU,1284
+unique_toolkit/app/__init__.py,sha256=OaylhLwxeRlsHlcFGSlR5R7oREFsjv9wRdxuVZBYM_8,1371
 unique_toolkit/app/dev_util.py,sha256=J20peCvrSQKfMGdYPYwCirs3Yq2v_e33GzNBzNKbWN4,5531
+unique_toolkit/app/fast_api_factory.py,sha256=l6AZoR8RAh4IJxAHZR_ajAL5ojcGdVh7Z8pfSpDSEKM,4634
 unique_toolkit/app/init_logging.py,sha256=Sh26SRxOj8i8dzobKhYha2lLrkrMTHfB1V4jR3h23gQ,678
 unique_toolkit/app/init_sdk.py,sha256=5_oDoETr6akwYyBCb0ivTdMNu3SVgPSkrXcDS6ELyY8,2269
 unique_toolkit/app/performance/async_tasks.py,sha256=H0l3OAcosLwNHZ8d2pd-Di4wHIXfclEvagi5kfqLFPA,1941
@@ -133,6 +134,7 @@ unique_toolkit/app/performance/async_wrapper.py,sha256=yVVcRDkcdyfjsxro-N29SBvi-
 unique_toolkit/app/schemas.py,sha256=1KziC9FzPtjOJ1R2ZoeJqVV9PNjGuKJ9uIMvPpA2yus,10159
 unique_toolkit/app/unique_settings.py,sha256=NTfa3a8wWzBDx4_4Irqyhy4mpXyPU6Munqs41ozPFnE,12366
 unique_toolkit/app/verification.py,sha256=GxFFwcJMy25fCA_Xe89wKW7bgqOu8PAs5y8QpHF0GSc,3861
+unique_toolkit/app/webhook.py,sha256=k7DP1UTR3p7D4qzuKPKVmGMAkDVHfALrnMIzTZqj_OI,2320
 unique_toolkit/chat/__init__.py,sha256=uP7P6YPeOjEOvpX3bhcU6ND_m0QLr4wMklcrnAKK0q4,804
 unique_toolkit/chat/constants.py,sha256=05kq6zjqUVB2d6_P7s-90nbljpB3ryxwCI-CAz0r2O4,83
 unique_toolkit/chat/deprecated/service.py,sha256=CYwzXi7OB0RjHd73CO2jq8SlpdBmDYLatzPFkb5sA0k,6529
@@ -169,7 +171,7 @@ unique_toolkit/language_model/builder.py,sha256=4OKfwJfj3TrgO1ezc_ewIue6W7BCQ2ZY
 unique_toolkit/language_model/constants.py,sha256=B-topqW0r83dkC_25DeQfnPk3n53qzIHUCBS7YJ0-1U,119
 unique_toolkit/language_model/default_language_model.py,sha256=-_DBsJhLCsFdaU4ynAkyW0jYIl2lhrPybZm1K-GgVJs,125
 unique_toolkit/language_model/functions.py,sha256=nGxlV4OO70jdH_7AgRWDMpbzmmKLZ-5Tk4gu5nxB2ko,17735
-unique_toolkit/language_model/infos.py,sha256=fPUTwDJk30V_uqrlc5EXXysqYOCI7nAXTYWEOJggfxc,78788
+unique_toolkit/language_model/infos.py,sha256=sZJOOij-dfReDxJWfd7ZwP3qx4KcN1LVqNchRafKmrY,79877
 unique_toolkit/language_model/prompt.py,sha256=JSawaLjQg3VR-E2fK8engFyJnNdk21zaO8pPIodzN4Q,3991
 unique_toolkit/language_model/reference.py,sha256=nkX2VFz-IrUz8yqyc3G5jUMNwrNpxITBrMEKkbqqYoI,8583
 unique_toolkit/language_model/schemas.py,sha256=ATiHjhfGxoubS332XuhL9PKSoFewcWvPTUVBaNGWlJo,23994
@@ -187,7 +189,7 @@ unique_toolkit/short_term_memory/service.py,sha256=5PeVBu1ZCAfyDb2HLVvlmqSbyzBBu
 unique_toolkit/smart_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 unique_toolkit/smart_rules/compile.py,sha256=Ozhh70qCn2yOzRWr9d8WmJeTo7AQurwd3tStgBMPFLA,1246
 unique_toolkit/test_utilities/events.py,sha256=_mwV2bs5iLjxS1ynDCjaIq-gjjKhXYCK-iy3dRfvO3g,6410
-unique_toolkit-1.29.4.dist-info/LICENSE,sha256=GlN8wHNdh53xwOPg44URnwag6TEolCjoq3YD_KrWgss,193
-unique_toolkit-1.29.4.dist-info/METADATA,sha256=WeO7rETdLnEj6Gapt5HFrJbYSg_0TXGNNKcMn2VPtZ0,44462
-unique_toolkit-1.29.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-unique_toolkit-1.29.4.dist-info/RECORD,,
+unique_toolkit-1.31.0.dist-info/LICENSE,sha256=GlN8wHNdh53xwOPg44URnwag6TEolCjoq3YD_KrWgss,193
+unique_toolkit-1.31.0.dist-info/METADATA,sha256=fCVcgrZkBcRqyYl21qWou_M1kuGb7qngixPIdR9sjAo,44652
+unique_toolkit-1.31.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+unique_toolkit-1.31.0.dist-info/RECORD,,