unique_toolkit 0.8.29__tar.gz → 0.8.31__tar.gz

{unique_toolkit-0.8.29 → unique_toolkit-0.8.31}/CHANGELOG.md

@@ -4,6 +4,22 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), 
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+
+## [0.8.31] - 2025-08-29
+- Add various openai models to supported model list
+  - o1
+  - o3
+  - o3-deep-research
+  - o3-pro
+  - o4-mini
+  - o4-mini-deep-research
+  - gpt-4-1-mini
+  - gpt-4-1-nano
+
+## [0.8.30] - 2025-08-28
+- Added A2A manager
+
 ## [0.8.29] - 2025-08-27
 - Include `MessageExecution` and `MessageLog` in toolkit 
 
@@ -16,6 +32,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.8.26] - 2025-08-27
 - Optimized MCP manager
 
+## [0.8.26] - 2025-08-27
+- Optimized MCP manager
+
 ## [0.8.25] - 2025-08-27
 - Load environment variables automatically from plattform dirs or environment
 - General Endpoint definition utility

{unique_toolkit-0.8.29 → unique_toolkit-0.8.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unique_toolkit
-Version: 0.8.29
+Version: 0.8.31
 Summary: 
 License: Proprietary
 Author: Martin Fadler
@@ -114,6 +114,22 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), 
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+
+## [0.8.31] - 2025-08-29
+- Add various openai models to supported model list
+  - o1
+  - o3
+  - o3-deep-research
+  - o3-pro
+  - o4-mini
+  - o4-mini-deep-research
+  - gpt-4-1-mini
+  - gpt-4-1-nano
+
+## [0.8.30] - 2025-08-28
+- Added A2A manager
+
 ## [0.8.29] - 2025-08-27
 - Include `MessageExecution` and `MessageLog` in toolkit 
 
@@ -126,6 +142,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.8.26] - 2025-08-27
 - Optimized MCP manager
 
+## [0.8.26] - 2025-08-27
+- Optimized MCP manager
+
 ## [0.8.25] - 2025-08-27
 - Load environment variables automatically from plattform dirs or environment
 - General Endpoint definition utility

{unique_toolkit-0.8.29 → unique_toolkit-0.8.31}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "unique_toolkit"
-version = "0.8.29"
+version = "0.8.31"
 description = ""
 authors = [
     "Martin Fadler <martin.fadler@unique.ch>",

{unique_toolkit-0.8.29 → unique_toolkit-0.8.31}/unique_toolkit/language_model/infos.py

@@ -48,6 +48,14 @@ class LanguageModelName(StrEnum):
     LITELLM_OPENAI_GPT_5_MINI = "litellm:openai-gpt-5-mini"
     LITELLM_OPENAI_GPT_5_NANO = "litellm:openai-gpt-5-nano"
     LITELLM_OPENAI_GPT_5_CHAT = "litellm:openai-gpt-5-chat"
+    LITELLM_OPENAI_O1 = "litellm:openai-o1"
+    LITELLM_OPENAI_O3 = "litellm:openai-o3"
+    LITELLM_OPENAI_O3_DEEP_RESEARCH = "litellm:openai-o3-deep-research"
+    LITELLM_OPENAI_O3_PRO = "litellm:openai-o3-pro"
+    LITELLM_OPENAI_O4_MINI = "litellm:openai-o4-mini"
+    LITELLM_OPENAI_O4_MINI_DEEP_RESEARCH = "litellm:openai-o4-mini-deep-research"
+    LITELLM_OPENAI_GPT_4_1_MINI = "litellm:openai-gpt-4-1-mini"
+    LITELLM_OPENAI_GPT_4_1_NANO = "litellm:openai-gpt-4-1-nano"
     LITELLM_DEEPSEEK_R1 = "litellm:deepseek-r1"
     LITELLM_DEEPSEEK_V3 = "litellm:deepseek-v3-1"
     LITELLM_QWEN_3 = "litellm:qwen-3-235B-A22B"
@@ -83,6 +91,14 @@ def get_encoder_name(model_name: LanguageModelName) -> EncoderName:
             | LMN.LITELLM_OPENAI_GPT_5_MINI
             | LMN.LITELLM_OPENAI_GPT_5_NANO
             | LMN.LITELLM_OPENAI_GPT_5_CHAT
+            | LMN.LITELLM_OPENAI_O1
+            | LMN.LITELLM_OPENAI_O3
+            | LMN.LITELLM_OPENAI_O3_DEEP_RESEARCH
+            | LMN.LITELLM_OPENAI_O4_MINI
+            | LMN.LITELLM_OPENAI_O4_MINI_DEEP_RESEARCH
+            | LMN.LITELLM_OPENAI_GPT_4_1_MINI
+            | LMN.LITELLM_OPENAI_GPT_4_1_NANO
+            | LMN.LITELLM_OPENAI_O3_PRO
         ):
             return EncoderName.O200K_BASE
         case _:
@@ -879,6 +895,146 @@ class LanguageModelInfo(BaseModel):
                     deprecated_at=date(2026, 8, 7),
                     retirement_at=date(2026, 8, 7),
                 )
+            case LanguageModelName.LITELLM_OPENAI_O1:
+                return cls(
+                    name=model_name,
+                    provider=LanguageModelProvider.LITELLM,
+                    version="2024-12-17",
+                    encoder_name=EncoderName.O200K_BASE,
+                    capabilities=[
+                        ModelCapabilities.STRUCTURED_OUTPUT,
+                        ModelCapabilities.FUNCTION_CALLING,
+                        ModelCapabilities.STREAMING,
+                        ModelCapabilities.VISION,
+                        ModelCapabilities.REASONING,
+                    ],
+                    token_limits=LanguageModelTokenLimits(
+                        token_limit_input=200_000, token_limit_output=100_000
+                    ),
+                    info_cutoff_at=date(2023, 10, 1),
+                    published_at=date(2024, 12, 17),
+                    temperature_bounds=TemperatureBounds(
+                        min_temperature=1.0, max_temperature=1.0
+                    ),
+                )
+            case LanguageModelName.LITELLM_OPENAI_O3:
+                return cls(
+                    name=model_name,
+                    provider=LanguageModelProvider.LITELLM,
+                    version="2025-04-16",
+                    encoder_name=EncoderName.O200K_BASE,
+                    capabilities=[
+                        ModelCapabilities.FUNCTION_CALLING,
+                        ModelCapabilities.STRUCTURED_OUTPUT,
+                        ModelCapabilities.STREAMING,
+                        ModelCapabilities.REASONING,
+                    ],
+                    token_limits=LanguageModelTokenLimits(
+                        token_limit_input=200_000, token_limit_output=100_000
+                    ),
+                    temperature_bounds=TemperatureBounds(
+                        min_temperature=1.0, max_temperature=1.0
+                    ),
+                    published_at=date(2025, 4, 16),
+                    info_cutoff_at=date(2024, 6, 1),
+                )
+            case LanguageModelName.LITELLM_OPENAI_O3_DEEP_RESEARCH:
+                return cls(
+                    name=model_name,
+                    provider=LanguageModelProvider.LITELLM,
+                    version="2025-06-26",
+                    encoder_name=EncoderName.O200K_BASE,
+                    token_limits=LanguageModelTokenLimits(
+                        token_limit_input=200_000, token_limit_output=100_000
+                    ),
+                    published_at=date(2025, 4, 16),
+                    capabilities=[ModelCapabilities.STREAMING],
+                    info_cutoff_at=date(2024, 6, 1),
+                )
+            case LanguageModelName.LITELLM_OPENAI_O3_PRO:
+                return cls(
+                    name=model_name,
+                    provider=LanguageModelProvider.LITELLM,
+                    version="2025-06-10",
+                    encoder_name=EncoderName.O200K_BASE,
+                    capabilities=[
+                        ModelCapabilities.FUNCTION_CALLING,
+                        ModelCapabilities.REASONING,
+                        ModelCapabilities.STRUCTURED_OUTPUT,
+                    ],
+                    token_limits=LanguageModelTokenLimits(
+                        token_limit_input=200_000, token_limit_output=100_000
+                    ),
+                    published_at=date(2025, 6, 10),
+                    info_cutoff_at=date(2024, 6, 1),
+                )
+            case LanguageModelName.LITELLM_OPENAI_O4_MINI:
+                return cls(
+                    name=model_name,
+                    provider=LanguageModelProvider.LITELLM,
+                    version="2025-04-16",
+                    encoder_name=EncoderName.O200K_BASE,
+                    capabilities=[
+                        ModelCapabilities.FUNCTION_CALLING,
+                        ModelCapabilities.STREAMING,
+                        ModelCapabilities.STRUCTURED_OUTPUT,
+                    ],
+                    token_limits=LanguageModelTokenLimits(
+                        token_limit_input=200_000, token_limit_output=100_000
+                    ),
+                    published_at=date(2025, 4, 16),
+                    info_cutoff_at=date(2024, 6, 1),
+                    temperature_bounds=TemperatureBounds(
+                        min_temperature=1.0, max_temperature=1.0
+                    ),
+                )
+            case LanguageModelName.LITELLM_OPENAI_O4_MINI_DEEP_RESEARCH:
+                return cls(
+                    name=model_name,
+                    provider=LanguageModelProvider.LITELLM,
+                    version="2025-06-26",
+                    encoder_name=EncoderName.O200K_BASE,
+                    token_limits=LanguageModelTokenLimits(
+                        token_limit_input=200_000, token_limit_output=100_000
+                    ),
+                    published_at=date(2025, 4, 16),
+                    capabilities=[ModelCapabilities.STREAMING],
+                    info_cutoff_at=date(2024, 6, 1),
+                )
+            case LanguageModelName.LITELLM_OPENAI_GPT_4_1_MINI:
+                return cls(
+                    name=model_name,
+                    provider=LanguageModelProvider.LITELLM,
+                    version="2025-04-14",
+                    encoder_name=EncoderName.O200K_BASE,
+                    published_at=date(2025, 4, 14),
+                    info_cutoff_at=date(2024, 6, 1),
+                    token_limits=LanguageModelTokenLimits(
+                        token_limit_input=1_047_576, token_limit_output=32_768
+                    ),
+                    capabilities=[
+                        ModelCapabilities.STREAMING,
+                        ModelCapabilities.FUNCTION_CALLING,
+                        ModelCapabilities.STRUCTURED_OUTPUT,
+                    ],
+                )
+            case LanguageModelName.LITELLM_OPENAI_GPT_4_1_NANO:
+                return cls(
+                    name=model_name,
+                    provider=LanguageModelProvider.LITELLM,
+                    version="2025-04-14",
+                    encoder_name=EncoderName.O200K_BASE,
+                    published_at=date(2025, 4, 14),
+                    info_cutoff_at=date(2024, 6, 1),
+                    token_limits=LanguageModelTokenLimits(
+                        token_limit_input=1_047_576, token_limit_output=32_768
+                    ),
+                    capabilities=[
+                        ModelCapabilities.STREAMING,
+                        ModelCapabilities.FUNCTION_CALLING,
+                        ModelCapabilities.STRUCTURED_OUTPUT,
+                    ],
+                )
             case LanguageModelName.LITELLM_DEEPSEEK_R1:
                 return cls(
                     name=model_name,

unique_toolkit-0.8.31/unique_toolkit/tools/a2a/__init__.py

@@ -0,0 +1,4 @@
+from unique_toolkit.tools.a2a.config import SubAgentToolConfig
+from unique_toolkit.tools.a2a.service import SubAgentTool
+
+__all__ = ["SubAgentToolConfig", "SubAgentTool"]

unique_toolkit-0.8.31/unique_toolkit/tools/a2a/config.py

@@ -0,0 +1,27 @@
+from unique_toolkit.tools.config import get_configuration_dict
+from unique_toolkit.tools.schemas import BaseToolConfig
+
+DEFAULT_PARAM_DESCRIPTION_SUB_AGENT_USER_MESSAGE = """
+This is the message that will be sent to the sub-agent.
+""".strip()
+
+
+class SubAgentToolConfig(BaseToolConfig):
+    model_config = get_configuration_dict()
+
+    name: str = "default_name"
+    assistant_id: str = ""
+    chat_id: str | None = None
+    reuse_chat: bool = True
+    tool_description_for_system_prompt: str = ""
+    tool_description: str = ""
+    param_description_sub_agent_user_message: str = (
+        DEFAULT_PARAM_DESCRIPTION_SUB_AGENT_USER_MESSAGE
+    )
+    tool_format_information_for_system_prompt: str = ""
+
+    tool_description_for_user_prompt: str = ""
+    tool_format_information_for_user_prompt: str = ""
+
+    poll_interval: float = 1.0
+    max_wait: float = 120.0

unique_toolkit-0.8.31/unique_toolkit/tools/a2a/manager.py

@@ -0,0 +1,49 @@
+from logging import Logger
+
+from unique_toolkit.app.schemas import ChatEvent
+from unique_toolkit.tools.a2a.config import SubAgentToolConfig
+from unique_toolkit.tools.a2a.service import SubAgentTool, ToolProgressReporter
+from unique_toolkit.tools.config import ToolBuildConfig
+from unique_toolkit.tools.schemas import BaseToolConfig
+from unique_toolkit.tools.tool import Tool
+
+
+class A2AManager:
+    def __init__(
+        self,
+        logger: Logger,
+        tool_progress_reporter: ToolProgressReporter,
+    ):
+        self._logger = logger
+        self._tool_progress_reporter = tool_progress_reporter
+
+    def get_all_sub_agents(
+        self, tool_configs: list[ToolBuildConfig], event: ChatEvent
+    ) -> tuple[list[ToolBuildConfig], list[Tool[BaseToolConfig]]]:
+        sub_agents = []
+
+        for tool_config in tool_configs:
+            if not tool_config.is_sub_agent:
+                continue
+
+            if not isinstance(tool_config.configuration, SubAgentToolConfig):
+                self._logger.error(
+                    "tool_config.configuration must be of type SubAgentToolConfig"
+                )
+                continue
+
+            sub_agent_tool_config: SubAgentToolConfig = tool_config.configuration
+
+            sub_agents.append(
+                SubAgentTool(
+                    configuration=sub_agent_tool_config,
+                    event=event,
+                    tool_progress_reporter=self._tool_progress_reporter,
+                )
+            )
+
+        filtered_tool_config = [
+            tool_config for tool_config in tool_configs if not tool_config.is_sub_agent
+        ]
+
+        return filtered_tool_config, sub_agents

unique_toolkit-0.8.31/unique_toolkit/tools/a2a/memory.py

@@ -0,0 +1,26 @@
+from unique_toolkit import ShortTermMemoryService
+from unique_toolkit.short_term_memory.persistent_short_term_memory_manager import (
+    PersistentShortMemoryManager,
+)
+from unique_toolkit.tools.a2a.schema import SubAgentShortTermMemorySchema
+
+
+def _get_short_term_memory_name(assistant_id: str) -> str:
+    return f"sub_agent_chat_id_{assistant_id}"
+
+
+def get_sub_agent_short_term_memory_manager(
+    company_id: str, user_id: str, chat_id: str, assistant_id: str
+) -> PersistentShortMemoryManager[SubAgentShortTermMemorySchema]:
+    short_term_memory_service = ShortTermMemoryService(
+        company_id=company_id,
+        user_id=user_id,
+        chat_id=chat_id,
+        message_id=None,
+    )
+    short_term_memory_manager = PersistentShortMemoryManager(
+        short_term_memory_service=short_term_memory_service,
+        short_term_memory_schema=SubAgentShortTermMemorySchema,
+        short_term_memory_name=_get_short_term_memory_name(assistant_id),
+    )
+    return short_term_memory_manager

unique_toolkit-0.8.31/unique_toolkit/tools/a2a/schema.py

@@ -0,0 +1,15 @@
+from pydantic import BaseModel
+
+from unique_toolkit.tools.schemas import ToolCallResponse
+
+
+class SubAgentToolInput(BaseModel):
+    user_message: str
+
+
+class SubAgentToolCallResponse(ToolCallResponse):
+    assistant_message: str
+
+
+class SubAgentShortTermMemorySchema(BaseModel):
+    chat_id: str

unique_toolkit-0.8.31/unique_toolkit/tools/a2a/service.py

@@ -0,0 +1,152 @@
+from pydantic import Field, create_model
+from unique_sdk.utils.chat_in_space import send_message_and_wait_for_completion
+
+from unique_toolkit.app import ChatEvent
+from unique_toolkit.evaluators.schemas import EvaluationMetricName
+from unique_toolkit.language_model import (
+    LanguageModelFunction,
+    LanguageModelMessage,
+    LanguageModelToolDescription,
+)
+from unique_toolkit.tools.a2a.config import SubAgentToolConfig
+from unique_toolkit.tools.a2a.memory import (
+    get_sub_agent_short_term_memory_manager,
+)
+from unique_toolkit.tools.a2a.schema import (
+    SubAgentShortTermMemorySchema,
+    SubAgentToolInput,
+)
+from unique_toolkit.tools.schemas import ToolCallResponse
+from unique_toolkit.tools.tool import Tool
+from unique_toolkit.tools.tool_progress_reporter import (
+    ProgressState,
+    ToolProgressReporter,
+)
+
+
+class SubAgentTool(Tool[SubAgentToolConfig]):
+    name: str = "SubAgentTool"
+
+    def __init__(
+        self,
+        configuration: SubAgentToolConfig,
+        event: ChatEvent,
+        tool_progress_reporter: ToolProgressReporter | None = None,
+    ):
+        super().__init__(configuration, event, tool_progress_reporter)
+        self._user_id = event.user_id
+        self._company_id = event.company_id
+        self.name = configuration.name
+
+        self._short_term_memory_manager = get_sub_agent_short_term_memory_manager(
+            company_id=self._company_id,
+            user_id=self._user_id,
+            chat_id=event.payload.chat_id,
+            assistant_id=self.config.assistant_id,
+        )
+
+    def tool_description(self) -> LanguageModelToolDescription:
+        tool_input_model_with_description = create_model(
+            "SubAgentToolInput",
+            user_message=(
+                str,
+                Field(description=self.config.param_description_sub_agent_user_message),
+            ),
+        )
+
+        return LanguageModelToolDescription(
+            name=self.name,
+            description=self.config.tool_description,
+            parameters=tool_input_model_with_description,
+        )
+
+    def tool_description_for_system_prompt(self) -> str:
+        return self.config.tool_description_for_system_prompt
+
+    def tool_format_information_for_system_prompt(self) -> str:
+        return self.config.tool_format_information_for_system_prompt
+
+    def tool_description_for_user_prompt(self) -> str:
+        return self.config.tool_description_for_user_prompt
+
+    def tool_format_information_for_user_prompt(self) -> str:
+        return self.config.tool_format_information_for_user_prompt
+
+    def evaluation_check_list(self) -> list[EvaluationMetricName]:
+        return []
+
+    def get_evaluation_checks_based_on_tool_response(
+        self,
+        tool_response: ToolCallResponse,
+    ) -> list[EvaluationMetricName]:
+        return []
+
+    async def _get_chat_id(self) -> str | None:
+        if not self.config.reuse_chat:
+            return None
+
+        if self.config.chat_id is not None:
+            return self.config.chat_id
+
+        # Check if there is a saved chat id in short term memory
+        short_term_memory = await self._short_term_memory_manager.load_async()
+
+        if short_term_memory is not None:
+            return short_term_memory.chat_id
+
+        return None
+
+    async def _save_chat_id(self, chat_id: str) -> None:
+        if not self.config.reuse_chat:
+            return
+
+        await self._short_term_memory_manager.save_async(
+            SubAgentShortTermMemorySchema(chat_id=chat_id)
+        )
+
+    async def run(self, tool_call: LanguageModelFunction) -> ToolCallResponse:
+        tool_input = SubAgentToolInput.model_validate(tool_call.arguments)
+
+        if self.tool_progress_reporter:
+            await self.tool_progress_reporter.notify_from_tool_call(
+                tool_call=tool_call,
+                name=f"{self.name}",
+                message=f"{tool_input.user_message}",
+                state=ProgressState.RUNNING,
+            )
+
+        # Check if there is a saved chat id in short term memory
+        chat_id = await self._get_chat_id()
+
+        response = await send_message_and_wait_for_completion(
+            user_id=self._user_id,
+            assistant_id=self.config.assistant_id,
+            company_id=self._company_id,
+            text=tool_input.user_message,  # type: ignore
+            chat_id=chat_id,  # type: ignore
+            poll_interval=self.config.poll_interval,
+            max_wait=self.config.max_wait,
+        )
+
+        if chat_id is None:
+            await self._save_chat_id(response["chatId"])
+
+        if response["text"] is None:
+            raise ValueError("No response returned from sub agent")
+
+        self._text = response["text"]
+        return ToolCallResponse(
+            id=tool_call.id,  # type: ignore
+            name=tool_call.name,
+            content=response["text"],
+        )
+
+    def get_tool_call_result_for_loop_history(
+        self,
+        tool_response: ToolCallResponse,
+    ) -> LanguageModelMessage:
+        return ToolCallResponse(
+            id=tool_response.id,
+            name=tool_response.name,
+            content=tool_response["content"],
+        )

{unique_toolkit-0.8.29 → unique_toolkit-0.8.31}/unique_toolkit/tools/config.py

@@ -72,6 +72,7 @@ class ToolBuildConfig(BaseModel):
         default=False,
         description="This tool must be chosen by the user and no other tools are used for this iteration.",
     )
+    is_sub_agent: bool = False
 
     is_enabled: bool = Field(default=True)
 

{unique_toolkit-0.8.29 → unique_toolkit-0.8.31}/unique_toolkit/tools/test/test_mcp_manager.py

@@ -7,6 +7,7 @@ from pydantic import BaseModel
 from tests.test_obj_factory import get_event_obj
 from unique_toolkit.app.schemas import McpServer, McpTool
 from unique_toolkit.chat.service import ChatService
+from unique_toolkit.tools.a2a.manager import A2AManager
 from unique_toolkit.tools.config import ToolBuildConfig, ToolIcon, ToolSelectionPolicy
 from unique_toolkit.tools.factory import ToolFactory
 from unique_toolkit.tools.mcp.manager import MCPManager
@@ -162,25 +163,38 @@ class TestMCPManager:
             tool_progress_reporter=tool_progress_reporter,
         )
 
+    @pytest.fixture
+    def a2a_manager(self, tool_progress_reporter):
+        """Create MCP manager fixture"""
+        return A2AManager(
+            logger=self.logger,
+            tool_progress_reporter=tool_progress_reporter,
+        )
+
     @pytest.fixture
     def tool_manager_config(self, internal_tools):
         """Create tool manager configuration fixture"""
         return ToolManagerConfig(tools=internal_tools, max_tool_calls=10)
 
     @pytest.fixture
-    def tool_manager(self, tool_manager_config, mcp_manager, tool_progress_reporter):
+    def tool_manager(
+        self, tool_manager_config, mcp_manager, a2a_manager, tool_progress_reporter
+    ):
         """Create tool manager fixture"""
+
         return ToolManager(
             logger=self.logger,
             config=tool_manager_config,
             event=self.event,
             tool_progress_reporter=tool_progress_reporter,
             mcp_manager=mcp_manager,
+            a2a_manager=a2a_manager,
         )
 
     def test_tool_manager_initialization(self, tool_manager):
         """Test tool manager is initialized correctly"""
         assert tool_manager is not None
+
         assert (
             len(tool_manager.get_tools()) >= 2
         )  # Should have both internal and MCP tools
@@ -255,12 +269,19 @@ class TestMCPManager:
         """Test the _init__tools method behavior with different scenarios"""
 
         # Test 1: Normal initialization with both tool types
+
+        a2a_manager = A2AManager(
+            logger=self.logger,
+            tool_progress_reporter=tool_progress_reporter,
+        )
+
         tool_manager = ToolManager(
             logger=self.logger,
             config=tool_manager_config,
             event=self.event,
             tool_progress_reporter=tool_progress_reporter,
             mcp_manager=mcp_manager,
+            a2a_manager=a2a_manager,
         )
 
         # Verify both tools are loaded
@@ -285,12 +306,18 @@ class TestMCPManager:
         event_with_disabled.payload.tool_choices = ["internal_search", "mcp_test_tool"]
         event_with_disabled.payload.disabled_tools = ["internal_search"]
 
+        a2a_manager = A2AManager(
+            logger=self.logger,
+            tool_progress_reporter=tool_progress_reporter,
+        )
+
         tool_manager = ToolManager(
             logger=self.logger,
             config=tool_manager_config,
             event=event_with_disabled,
             tool_progress_reporter=tool_progress_reporter,
             mcp_manager=mcp_manager,
+            a2a_manager=a2a_manager,
         )
 
         # Should only have MCP tool, internal tool should be filtered out
@@ -315,12 +342,18 @@ class TestMCPManager:
         event_with_limited_choices.payload.tool_choices = ["internal_search"]
         event_with_limited_choices.payload.disabled_tools = []
 
+        a2a_manager = A2AManager(
+            logger=self.logger,
+            tool_progress_reporter=tool_progress_reporter,
+        )
+
         tool_manager = ToolManager(
             logger=self.logger,
             config=tool_manager_config,
             event=event_with_limited_choices,
             tool_progress_reporter=tool_progress_reporter,
             mcp_manager=mcp_manager,
+            a2a_manager=a2a_manager,
         )
 
         # Should only have internal search tool
@@ -348,12 +381,18 @@ class TestMCPManager:
             tools=[exclusive_tool_config], max_tool_calls=10
         )
 
+        a2a_manager = A2AManager(
+            logger=self.logger,
+            tool_progress_reporter=tool_progress_reporter,
+        )
+
         tool_manager = ToolManager(
             logger=self.logger,
             config=config_with_exclusive,
             event=self.event,
             tool_progress_reporter=tool_progress_reporter,
             mcp_manager=mcp_manager,
+            a2a_manager=a2a_manager,
         )
 
         # Should only have the exclusive tool, MCP tools should be ignored
@@ -383,12 +422,18 @@ class TestMCPManager:
             tools=[disabled_tool_config], max_tool_calls=10
         )
 
+        a2a_manager = A2AManager(
+            logger=self.logger,
+            tool_progress_reporter=tool_progress_reporter,
+        )
+
         tool_manager = ToolManager(
             logger=self.logger,
             config=config_with_disabled,
             event=self.event,
             tool_progress_reporter=tool_progress_reporter,
             mcp_manager=mcp_manager,
+            a2a_manager=a2a_manager,
         )
 
         # Should only have MCP tool, disabled internal tool should be filtered out

{unique_toolkit-0.8.29 → unique_toolkit-0.8.31}/unique_toolkit/tools/tool_manager.py

@@ -11,6 +11,7 @@ from unique_toolkit.language_model.schemas import (
     LanguageModelTool,
     LanguageModelToolDescription,
 )
+from unique_toolkit.tools.a2a.manager import A2AManager
 from unique_toolkit.tools.config import ToolBuildConfig, _rebuild_config_model
 from unique_toolkit.tools.factory import ToolFactory
 from unique_toolkit.tools.mcp.manager import MCPManager
@@ -71,6 +72,7 @@ class ToolManager:
         event: ChatEvent,
         tool_progress_reporter: ToolProgressReporter,
         mcp_manager: MCPManager,
+        a2a_manager: A2AManager,
     ):
         self._logger = logger
         self._config = config
@@ -81,6 +83,7 @@ class ToolManager:
         # this needs to be a set of strings to avoid duplicates
         self._tool_evaluation_check_list: set[EvaluationMetricName] = set()
         self._mcp_manager = mcp_manager
+        self._a2a_manager = a2a_manager
         self._init__tools(event)
 
     def _init__tools(self, event: ChatEvent) -> None:
@@ -90,6 +93,10 @@ class ToolManager:
         self._logger.info(f"Tool choices: {tool_choices}")
         self._logger.info(f"Tool configs: {tool_configs}")
 
+        tool_configs, sub_agents = self._a2a_manager.get_all_sub_agents(
+            tool_configs, event
+        )
+
         # Build internal tools from configurations
         internal_tools = [
             ToolFactory.build_tool_with_settings(
@@ -105,7 +112,7 @@ class ToolManager:
         # Get MCP tools (these are already properly instantiated)
         mcp_tools = self._mcp_manager.get_all_mcp_tools()
         # Combine both types of tools
-        self.available_tools = internal_tools + mcp_tools
+        self.available_tools = internal_tools + mcp_tools + sub_agents
 
         for t in self.available_tools:
             if t.is_exclusive():