unique_orchestrator 1.7.3__tar.gz → 1.7.5__tar.gz

{unique_orchestrator-1.7.3 → unique_orchestrator-1.7.5}/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.7.5] - 2025-11-05
+- Adding functionality to include user metadata into user/system prompts of the orchestrator
+
+## [1.7.4] - 2025-11-04
+- Update and adapt to toolkit 1.23.0 (refactor sub agents implementation)
+
 ## [1.7.3] - 2025-11-03
 - Fixed an issue where new assistant messages were not properly generated during streaming outputs with tool calls; the orchestrator now correctly creates messages via `_create_new_assistant_message_if_loop_response_contains_content` when loop_response includes text and tool invocations.
 

{unique_orchestrator-1.7.3 → unique_orchestrator-1.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unique_orchestrator
-Version: 1.7.3
+Version: 1.7.5
 Summary: 
 License: Proprietary
 Author: Andreas Hauri
@@ -20,7 +20,7 @@ Requires-Dist: unique-internal-search (>=1.0.1,<2.0.0)
 Requires-Dist: unique-sdk (>=0.10.34,<0.11.0)
 Requires-Dist: unique-stock-ticker (>=1.0.2,<2.0.0)
 Requires-Dist: unique-swot (>=0.1.0,<0.2.0)
-Requires-Dist: unique-toolkit (>=1.22.2,<2.0.0)
+Requires-Dist: unique-toolkit (>=1.23.0,<2.0.0)
 Requires-Dist: unique-web-search (>=1.3.1,<2.0.0)
 Description-Content-Type: text/markdown
 
@@ -34,6 +34,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.7.5] - 2025-11-05
+- Adding functionality to include user metadata into user/system prompts of the orchestrator
+
+## [1.7.4] - 2025-11-04
+- Update and adapt to toolkit 1.23.0 (refactor sub agents implementation)
+
 ## [1.7.3] - 2025-11-03
 - Fixed an issue where new assistant messages were not properly generated during streaming outputs with tool calls; the orchestrator now correctly creates messages via `_create_new_assistant_message_if_loop_response_contains_content` when loop_response includes text and tool invocations.
 

{unique_orchestrator-1.7.3 → unique_orchestrator-1.7.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "unique_orchestrator"
-version = "1.7.3"
+version = "1.7.5"
 description = ""
 authors = ["Andreas Hauri <andreas.hauri@unique.ai>"]
 readme = ["README.md", "CHANGELOG.md"]
@@ -15,7 +15,7 @@ python-dotenv = "^1.0.1"
 pytest = "^8.4.1"
 unique-sdk = "^0.10.34"
 
-unique-toolkit = "^1.22.2"
+unique-toolkit = "^1.23.0"
 unique-stock-ticker = "^1.0.2"
 unique-follow-up-questions = "^1.1.2"
 unique-internal-search = "^1.0.1"

{unique_orchestrator-1.7.3 → unique_orchestrator-1.7.5}/unique_orchestrator/config.py

@@ -163,6 +163,12 @@ class UniqueAIPromptConfig(BaseModel):
         description="The user message prompt template as a Jinja2 template string.",
     )
 
+    user_metadata: list[str] = Field(
+        default=[],
+        title="User Metadata",
+        description="User metadata fields to be ingested in the system prompt.",
+    )
+
 
 class UniqueAIServices(BaseModel):
     """Determine the services the agent is using

unique_orchestrator-1.7.5/unique_orchestrator/tests/test_unique_ai_get_filtered_user_metadata.py

@@ -0,0 +1,257 @@
+from unittest.mock import MagicMock
+
+import pytest
+
+
+class TestGetFilteredUserMetadata:
+    """Test suite for UniqueAI._get_filtered_user_metadata method"""
+
+    @pytest.fixture
+    def mock_unique_ai(self):
+        """Create a minimal UniqueAI instance with mocked dependencies"""
+        # Lazy import to avoid heavy dependencies at module import time
+        from unique_orchestrator.unique_ai import UniqueAI
+
+        mock_logger = MagicMock()
+
+        # Create minimal event structure
+        dummy_event = MagicMock()
+        dummy_event.payload.assistant_message.id = "assist_1"
+        dummy_event.payload.user_message.text = "query"
+
+        # Create minimal config structure
+        mock_config = MagicMock()
+        mock_config.agent.prompt_config.user_metadata = []
+
+        # Create minimal required dependencies
+        mock_chat_service = MagicMock()
+        mock_content_service = MagicMock()
+        mock_debug_info_manager = MagicMock()
+        mock_reference_manager = MagicMock()
+        mock_thinking_manager = MagicMock()
+        mock_tool_manager = MagicMock()
+        mock_history_manager = MagicMock()
+        mock_evaluation_manager = MagicMock()
+        mock_postprocessor_manager = MagicMock()
+        mock_streaming_handler = MagicMock()
+
+        # Instantiate UniqueAI
+        ua = UniqueAI(
+            logger=mock_logger,
+            event=dummy_event,
+            config=mock_config,
+            chat_service=mock_chat_service,
+            content_service=mock_content_service,
+            debug_info_manager=mock_debug_info_manager,
+            streaming_handler=mock_streaming_handler,
+            reference_manager=mock_reference_manager,
+            thinking_manager=mock_thinking_manager,
+            tool_manager=mock_tool_manager,
+            history_manager=mock_history_manager,
+            evaluation_manager=mock_evaluation_manager,
+            postprocessor_manager=mock_postprocessor_manager,
+            mcp_servers=[],
+        )
+
+        return ua
+
+    def test_returns_empty_dict_when_config_is_empty_list(self, mock_unique_ai):
+        """Test that empty dict is returned when config.user_metadata is an empty list"""
+        mock_unique_ai._config.agent.prompt_config.user_metadata = []
+        mock_unique_ai._event.payload.user_metadata = {
+            "department": "Engineering",
+            "role": "Developer",
+        }
+
+        result = mock_unique_ai._get_filtered_user_metadata()
+
+        assert result == {}
+        assert isinstance(result, dict)
+
+    def test_returns_empty_dict_when_user_metadata_is_none(self, mock_unique_ai):
+        """Test that empty dict is returned when user_metadata is None"""
+        mock_unique_ai._config.agent.prompt_config.user_metadata = [
+            "department",
+            "role",
+        ]
+        mock_unique_ai._event.payload.user_metadata = None
+
+        result = mock_unique_ai._get_filtered_user_metadata()
+
+        assert result == {}
+        assert isinstance(result, dict)
+
+    def test_returns_empty_dict_when_both_config_and_metadata_are_empty(
+        self, mock_unique_ai
+    ):
+        """Test that empty dict is returned when both config and user_metadata are empty/None"""
+        mock_unique_ai._config.agent.prompt_config.user_metadata = []
+        mock_unique_ai._event.payload.user_metadata = None
+
+        result = mock_unique_ai._get_filtered_user_metadata()
+
+        assert result == {}
+        assert isinstance(result, dict)
+
+    def test_filters_metadata_to_include_only_configured_keys(self, mock_unique_ai):
+        """Test that only keys specified in config are included in the result"""
+        mock_unique_ai._config.agent.prompt_config.user_metadata = [
+            "department",
+            "role",
+        ]
+        mock_unique_ai._event.payload.user_metadata = {
+            "department": "Engineering",
+            "role": "Developer",
+            "location": "San Francisco",
+            "salary": "100000",
+        }
+
+        result = mock_unique_ai._get_filtered_user_metadata()
+
+        assert result == {"department": "Engineering", "role": "Developer"}
+        assert "location" not in result
+        assert "salary" not in result
+        # Verify all values are strings
+        assert all(isinstance(v, str) for v in result.values())
+
+    def test_returns_only_existing_keys_from_user_metadata(self, mock_unique_ai):
+        """Test that keys in config but not in user_metadata are not included"""
+        mock_unique_ai._config.agent.prompt_config.user_metadata = [
+            "department",
+            "role",
+            "team",
+            "manager",
+        ]
+        mock_unique_ai._event.payload.user_metadata = {
+            "department": "Engineering",
+            "role": "Developer",
+        }
+
+        result = mock_unique_ai._get_filtered_user_metadata()
+
+        assert result == {"department": "Engineering", "role": "Developer"}
+        assert "team" not in result
+        assert "manager" not in result
+
+    def test_handles_single_key_in_config(self, mock_unique_ai):
+        """Test filtering with a single key in config"""
+        mock_unique_ai._config.agent.prompt_config.user_metadata = ["department"]
+        mock_unique_ai._event.payload.user_metadata = {
+            "department": "Engineering",
+            "role": "Developer",
+        }
+
+        result = mock_unique_ai._get_filtered_user_metadata()
+
+        assert result == {"department": "Engineering"}
+        assert isinstance(result["department"], str)
+
+    def test_handles_string_values(self, mock_unique_ai):
+        """Test that string values in user_metadata are preserved"""
+        mock_unique_ai._config.agent.prompt_config.user_metadata = [
+            "name",
+            "email",
+            "department",
+            "title",
+        ]
+        mock_unique_ai._event.payload.user_metadata = {
+            "name": "John Doe",
+            "email": "john.doe@example.com",
+            "department": "Engineering",
+            "title": "Senior Developer",
+            "ignored": "This should not appear",
+        }
+
+        result = mock_unique_ai._get_filtered_user_metadata()
+
+        assert result == {
+            "name": "John Doe",
+            "email": "john.doe@example.com",
+            "department": "Engineering",
+            "title": "Senior Developer",
+        }
+        assert "ignored" not in result
+        # Verify all values are strings
+        assert all(isinstance(v, str) for v in result.values())
+
+    def test_handles_empty_dict_user_metadata(self, mock_unique_ai):
+        """Test behavior when user_metadata is an empty dict"""
+        mock_unique_ai._config.agent.prompt_config.user_metadata = ["department"]
+        mock_unique_ai._event.payload.user_metadata = {}
+
+        result = mock_unique_ai._get_filtered_user_metadata()
+
+        assert result == {}
+
+    def test_handles_empty_string_values(self, mock_unique_ai):
+        """Test that empty string values in user_metadata are preserved if key is in config"""
+        mock_unique_ai._config.agent.prompt_config.user_metadata = [
+            "department",
+            "role",
+        ]
+        mock_unique_ai._event.payload.user_metadata = {
+            "department": "Engineering",
+            "role": "",
+        }
+
+        result = mock_unique_ai._get_filtered_user_metadata()
+
+        assert result == {"department": "Engineering", "role": ""}
+        assert isinstance(result["role"], str)
+
+    def test_preserves_original_metadata_unchanged(self, mock_unique_ai):
+        """Test that the original user_metadata dict is not modified"""
+        original_metadata = {
+            "department": "Engineering",
+            "role": "Developer",
+            "location": "San Francisco",
+        }
+        mock_unique_ai._config.agent.prompt_config.user_metadata = ["department"]
+        mock_unique_ai._event.payload.user_metadata = original_metadata.copy()
+
+        result = mock_unique_ai._get_filtered_user_metadata()
+
+        # Original should still have all keys
+        assert mock_unique_ai._event.payload.user_metadata == original_metadata
+        # Result should only have filtered key
+        assert result == {"department": "Engineering"}
+
+    def test_handles_special_characters_in_values(self, mock_unique_ai):
+        """Test that special characters in string values are preserved"""
+        mock_unique_ai._config.agent.prompt_config.user_metadata = [
+            "description",
+            "notes",
+        ]
+        mock_unique_ai._event.payload.user_metadata = {
+            "description": "User with special chars: @#$%^&*()",
+            "notes": "Multi-line\ntext\twith\ttabs",
+            "other": "excluded",
+        }
+
+        result = mock_unique_ai._get_filtered_user_metadata()
+
+        assert result == {
+            "description": "User with special chars: @#$%^&*()",
+            "notes": "Multi-line\ntext\twith\ttabs",
+        }
+        assert all(isinstance(v, str) for v in result.values())
+
+    def test_return_type_is_dict_str_str(self, mock_unique_ai):
+        """Test that return type is dict[str, str]"""
+        mock_unique_ai._config.agent.prompt_config.user_metadata = [
+            "department",
+            "role",
+        ]
+        mock_unique_ai._event.payload.user_metadata = {
+            "department": "Engineering",
+            "role": "Developer",
+        }
+
+        result = mock_unique_ai._get_filtered_user_metadata()
+
+        # Check it's a dict
+        assert isinstance(result, dict)
+        # Check all keys are strings
+        assert all(isinstance(k, str) for k in result.keys())
+        # Check all values are strings
+        assert all(isinstance(v, str) for v in result.values())

{unique_orchestrator-1.7.3 → unique_orchestrator-1.7.5}/unique_orchestrator/unique_ai.py

@@ -228,7 +228,9 @@ class UniqueAI:
             self._logger.debug(
                 "Tools were called we process them and do not exit the loop"
             )
-            await self._create_new_assistant_message_if_loop_response_contains_content(loop_response)
+            await self._create_new_assistant_message_if_loop_response_contains_content(
+                loop_response
+            )
 
             return await self._handle_tool_calls(loop_response)
 
@@ -268,6 +270,8 @@ class UniqueAI:
             mcp_server.user_prompt for mcp_server in self._mcp_servers
         ]
 
+        user_metadata = self._get_filtered_user_metadata()
+
         tool_descriptions = self._tool_manager.get_tool_prompts()
 
         query = self._event.payload.user_message.text
@@ -291,12 +295,11 @@ class UniqueAI:
             tool_descriptions_with_user_prompts=tool_descriptions_with_user_prompts,
             use_sub_agent_references=use_sub_agent_references,
             sub_agent_referencing_instructions=sub_agent_referencing_instructions,
+            user_metadata=user_metadata,
         )
         return user_msg
 
-    async def _render_system_prompt(
-        self,
-    ) -> str:
+    async def _render_system_prompt(self) -> str:
         # TODO: Collect tool information here and adapt to system prompt
         tool_descriptions = self._tool_manager.get_tool_prompts()
 
@@ -311,6 +314,8 @@ class UniqueAI:
 
         date_string = datetime.now().strftime("%A %B %d, %Y")
 
+        user_metadata = self._get_filtered_user_metadata()
+
         mcp_server_system_prompts = [
             mcp_server.system_prompt for mcp_server in self._mcp_servers
         ]
@@ -339,6 +344,7 @@ class UniqueAI:
             mcp_server_system_prompts=mcp_server_system_prompts,
             use_sub_agent_references=use_sub_agent_references,
             sub_agent_referencing_instructions=sub_agent_referencing_instructions,
+            user_metadata=user_metadata,
         )
         return system_message
 
@@ -444,6 +450,26 @@ class UniqueAI:
             )
         )
 
+    def _get_filtered_user_metadata(self) -> dict[str, str]:
+        """
+        Filter user metadata to only include keys specified in the agent's prompt config.
+
+        Returns:
+            Dictionary containing only the metadata keys that are configured to be included.
+        """
+        user_metadata = {}
+        if (
+            self._config.agent.prompt_config.user_metadata
+            and self._event.payload.user_metadata is not None
+        ):
+            # Filter metadata to only include selected keys
+            user_metadata = {
+                k: str(v)
+                for k, v in self._event.payload.user_metadata.items()
+                if k in self._config.agent.prompt_config.user_metadata
+            }
+        return user_metadata
+
 
 class UniqueAIResponsesApi(UniqueAI):
     def __init__(

{unique_orchestrator-1.7.3 → unique_orchestrator-1.7.5}/unique_orchestrator/unique_ai_builder.py

@@ -1,6 +1,6 @@
 import os
 from logging import Logger
-from typing import NamedTuple
+from typing import NamedTuple, cast
 
 from openai import AsyncOpenAI
 from unique_follow_up_questions.follow_up_postprocessor import (
@@ -46,11 +46,13 @@ from unique_toolkit.agentic.thinking_manager.thinking_manager import (
 from unique_toolkit.agentic.tools.a2a import (
     A2AManager,
     ExtendedSubAgentToolConfig,
+    SubAgentDisplaySpec,
     SubAgentEvaluationService,
-    SubAgentResponsesPostprocessor,
-)
-from unique_toolkit.agentic.tools.a2a.postprocessing.postprocessor import (
+    SubAgentEvaluationSpec,
+    SubAgentReferencesPostprocessor,
+    SubAgentResponsesDisplayPostprocessor,
     SubAgentResponsesPostprocessorConfig,
+    SubAgentResponseWatcher,
 )
 from unique_toolkit.agentic.tools.config import ToolBuildConfig
 from unique_toolkit.agentic.tools.mcp.manager import MCPManager
@@ -107,6 +109,7 @@ class _CommonComponents(NamedTuple):
     history_manager: HistoryManager
     evaluation_manager: EvaluationManager
     postprocessor_manager: PostprocessorManager
+    response_watcher: SubAgentResponseWatcher
     # Tool Manager Components
     tool_progress_reporter: ToolProgressReporter
     tool_manager_config: ToolManagerConfig
@@ -126,6 +129,8 @@ def _build_common(
 
     uploaded_documents = content_service.get_documents_uploaded_to_chat()
 
+    response_watcher = SubAgentResponseWatcher()
+
     tool_progress_reporter = ToolProgressReporter(
         chat_service=chat_service,
         config=config.agent.services.tool_progress_reporter_config,
@@ -174,7 +179,9 @@ def _build_common(
     a2a_manager = A2AManager(
         logger=logger,
         tool_progress_reporter=tool_progress_reporter,
+        response_watcher=response_watcher,
     )
+
     tool_manager_config = ToolManagerConfig(
         tools=config.space.tools,
         max_tool_calls=config.agent.experimental.loop_configuration.max_tool_calls_per_iteration,
@@ -222,6 +229,7 @@ def _build_common(
         tool_manager_config=tool_manager_config,
         mcp_servers=event.payload.mcp_servers,
         postprocessor_manager=postprocessor_manager,
+        response_watcher=response_watcher,
     )
 
 
@@ -341,16 +349,15 @@ async def _build_responses(
     _add_sub_agents_postprocessor(
         postprocessor_manager=postprocessor_manager,
         tool_manager=tool_manager,
-        user_id=event.user_id,
-        company_id=event.company_id,
-        chat_id=event.payload.chat_id,
-        sleep_time_before_update=config.agent.experimental.sub_agents_config.sleep_time_before_update,
+        config=config,
+        response_watcher=common_components.response_watcher,
     )
     _add_sub_agents_evaluation(
         evaluation_manager=common_components.evaluation_manager,
         tool_manager=tool_manager,
         config=config,
         event=event,
+        response_watcher=common_components.response_watcher,
     )
 
     return UniqueAIResponsesApi(
@@ -414,16 +421,15 @@ def _build_completions(
     _add_sub_agents_postprocessor(
         postprocessor_manager=postprocessor_manager,
         tool_manager=tool_manager,
-        user_id=event.user_id,
-        company_id=event.company_id,
-        chat_id=event.payload.chat_id,
-        sleep_time_before_update=config.agent.experimental.sub_agents_config.sleep_time_before_update,
+        config=config,
+        response_watcher=common_components.response_watcher,
     )
     _add_sub_agents_evaluation(
         evaluation_manager=common_components.evaluation_manager,
         tool_manager=tool_manager,
         config=config,
         event=event,
+        response_watcher=common_components.response_watcher,
     )
 
     return UniqueAI(
@@ -447,28 +453,37 @@ def _build_completions(
 def _add_sub_agents_postprocessor(
     postprocessor_manager: PostprocessorManager,
     tool_manager: ToolManager | ResponsesApiToolManager,
-    user_id: str,
-    company_id: str,
-    chat_id: str,
-    sleep_time_before_update: float,
+    config: UniqueAIConfig,
+    response_watcher: SubAgentResponseWatcher,
 ) -> None:
     sub_agents = tool_manager.sub_agents
     if len(sub_agents) > 0:
-        sub_agent_responses_postprocessor = SubAgentResponsesPostprocessor(
-            user_id=user_id,
-            main_agent_chat_id=chat_id,
-            company_id=company_id,
-            config=SubAgentResponsesPostprocessorConfig(
-                sleep_time_before_update=sleep_time_before_update,
-            ),
+        display_config = SubAgentResponsesPostprocessorConfig(
+            sleep_time_before_update=config.agent.experimental.sub_agents_config.sleep_time_before_update,
         )
-        postprocessor_manager.add_postprocessor(sub_agent_responses_postprocessor)
-
-        for tool in tool_manager.sub_agents:
-            assert isinstance(tool.config, ExtendedSubAgentToolConfig)
-            sub_agent_responses_postprocessor.register_sub_agent_tool(
-                tool, tool.config.response_display_config
+        display_specs = []
+        for tool in sub_agents:
+            tool_config = cast(
+                ExtendedSubAgentToolConfig, tool.settings.configuration
+            )  # (BeforeValidator of ToolBuildConfig)
+
+            display_specs.append(
+                SubAgentDisplaySpec(
+                    assistant_id=tool_config.assistant_id,
+                    display_name=tool.display_name(),
+                    display_config=tool_config.response_display_config,
+                )
             )
+        reference_postprocessor = SubAgentReferencesPostprocessor(
+            response_watcher=response_watcher,
+        )
+        sub_agent_responses_postprocessor = SubAgentResponsesDisplayPostprocessor(
+            config=display_config,
+            response_watcher=response_watcher,
+            display_specs=display_specs,
+        )
+        postprocessor_manager.add_postprocessor(reference_postprocessor)
+        postprocessor_manager.add_postprocessor(sub_agent_responses_postprocessor)
 
 
 def _add_sub_agents_evaluation(
@@ -476,18 +491,31 @@ def _add_sub_agents_evaluation(
     tool_manager: ToolManager | ResponsesApiToolManager,
     config: UniqueAIConfig,
     event: ChatEvent,
+    response_watcher: SubAgentResponseWatcher,
 ) -> None:
     sub_agents = tool_manager.sub_agents
-    if len(sub_agents) > 0:
-        sub_agent_evaluation = None
-        if config.agent.experimental.sub_agents_config.evaluation_config is not None:
-            sub_agent_evaluation = SubAgentEvaluationService(
-                config=config.agent.experimental.sub_agents_config.evaluation_config,
-                language_model_service=LanguageModelService.from_event(event),
-            )
-            evaluation_manager.add_evaluation(sub_agent_evaluation)
-            for tool in tool_manager.sub_agents:
-                assert isinstance(tool.config, ExtendedSubAgentToolConfig)
-                sub_agent_evaluation.register_sub_agent_tool(
-                    tool, tool.config.evaluation_config
+    if (
+        len(sub_agents) > 0
+        and config.agent.experimental.sub_agents_config.evaluation_config is not None
+    ):
+        evaluation_specs = []
+        for tool in sub_agents:
+            tool_config = cast(
+                ExtendedSubAgentToolConfig, tool.settings.configuration
+            )  # (BeforeValidator of ToolBuildConfig)
+
+            evaluation_specs.append(
+                SubAgentEvaluationSpec(
+                    assistant_id=tool_config.assistant_id,
+                    display_name=tool.display_name(),
+                    config=tool_config.evaluation_config,
                 )
+            )
+
+        sub_agent_evaluation = SubAgentEvaluationService(
+            config=config.agent.experimental.sub_agents_config.evaluation_config,
+            language_model_service=LanguageModelService.from_event(event),
+            evaluation_specs=evaluation_specs,
+            response_watcher=response_watcher,
+        )
+        evaluation_manager.add_evaluation(sub_agent_evaluation)