unique_toolkit 0.8.28__py3-none-any.whl → 0.8.30__py3-none-any.whl

unique_toolkit/chat/service.py

@@ -14,13 +14,23 @@ from unique_toolkit.chat.functions import (
     create_message_assessment,
     create_message_assessment_async,
     create_message_async,
+    create_message_execution,
+    create_message_execution_async,
+    create_message_log,
+    create_message_log_async,
     get_full_history,
     get_full_history_async,
+    get_message_execution,
+    get_message_execution_async,
     get_selection_from_history,
     modify_message,
     modify_message_assessment,
     modify_message_assessment_async,
     modify_message_async,
+    update_message_execution,
+    update_message_execution_async,
+    update_message_log,
+    update_message_log_async,
 )
 from unique_toolkit.chat.schemas import (
     ChatMessage,
@@ -29,6 +39,13 @@ from unique_toolkit.chat.schemas import (
     ChatMessageAssessmentStatus,
     ChatMessageAssessmentType,
     ChatMessageRole,
+    MessageExecution,
+    MessageExecutionType,
+    MessageExecutionUpdateStatus,
+    MessageLog,
+    MessageLogDetails,
+    MessageLogStatus,
+    MessageLogUncitedReferences,
 )
 from unique_toolkit.content.schemas import ContentChunk, ContentReference
 from unique_toolkit.language_model.constants import (
@@ -896,6 +913,558 @@ class ChatService:
             label=label,
         )
 
+    def create_message_log(
+        self,
+        message_id: str,
+        text: str,
+        status: MessageLogStatus,
+        order: int,
+        details: MessageLogDetails | None = None,
+        uncited_references: MessageLogUncitedReferences | None = None,
+        references: list[ContentReference] | None = None,
+    ) -> MessageLog:
+        """Creates a message log for tracking execution steps synchronously.
+
+        Args:
+            message_id (str): The ID of the message this log belongs to
+            text (str): The log text content
+            status (MessageLogStatus): The status of this log entry
+            order (int): The order/sequence number of this log entry
+            details (MessageLogDetails | None): Additional details about this log entry
+            uncited_references (MessageLogUncitedReferences | None): References that are not cited
+            references (list[ContentReference] | None): List of references for this log
+
+        Returns:
+            MessageLog: The created message log
+
+        Raises:
+            Exception: If the creation fails
+
+        """
+        return create_message_log(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            message_id=message_id,
+            text=text,
+            status=status,
+            order=order,
+            details=details,
+            uncited_references=uncited_references,
+            references=references,
+        )
+
+    async def create_message_log_async(
+        self,
+        message_id: str,
+        text: str,
+        status: MessageLogStatus,
+        order: int,
+        details: MessageLogDetails | None = None,
+        uncited_references: MessageLogUncitedReferences | None = None,
+        references: list[ContentReference] | None = None,
+    ) -> MessageLog:
+        """Creates a message log for tracking execution steps asynchronously.
+
+        Args:
+            message_id (str): The ID of the message this log belongs to
+            text (str): The log text content
+            status (MessageLogStatus): The status of this log entry
+            order (int): The order/sequence number of this log entry
+            details (MessageLogDetails | None): Additional details about this log entry
+            uncited_references (MessageLogUncitedReferences | None): References that are not cited
+            references (list[ContentReference] | None): List of references for this log
+
+        Returns:
+            MessageLog: The created message log
+
+        Raises:
+            Exception: If the creation fails
+
+        """
+        return await create_message_log_async(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            message_id=message_id,
+            text=text,
+            status=status,
+            order=order,
+            details=details,
+            uncited_references=uncited_references,
+            references=references,
+        )
+
+    def update_message_log(
+        self,
+        message_log_id: str,
+        order: int,
+        text: str | None = None,
+        status: MessageLogStatus | None = None,
+        details: MessageLogDetails | None = None,
+        uncited_references: MessageLogUncitedReferences | None = None,
+        references: list[ContentReference] | None = None,
+    ) -> MessageLog:
+        """Updates a message log synchronously.
+
+        Args:
+            message_log_id (str): The ID of the message log to update
+            order (int): The order/sequence number (required)
+            text (str | None): The updated log text content
+            status (MessageLogStatus | None): The updated status
+            details (MessageLogDetails | None): Updated additional details
+            uncited_references (MessageLogUncitedReferences | None): Updated uncited references
+            references (list[ContentReference] | None): Updated list of references
+
+        Returns:
+            MessageLog: The updated message log
+
+        Raises:
+            Exception: If the update fails
+
+        """
+        return update_message_log(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            message_log_id=message_log_id,
+            order=order,
+            text=text,
+            status=status,
+            details=details,
+            uncited_references=uncited_references,
+            references=references,
+        )
+
+    async def update_message_log_async(
+        self,
+        message_log_id: str,
+        order: int,
+        text: str | None = None,
+        status: MessageLogStatus | None = None,
+        details: MessageLogDetails | None = None,
+        uncited_references: MessageLogUncitedReferences | None = None,
+        references: list[ContentReference] | None = None,
+    ) -> MessageLog:
+        """Updates a message log asynchronously.
+
+        Args:
+            message_log_id (str): The ID of the message log to update
+            order (int): The order/sequence number (required)
+            text (str | None): The updated log text content
+            status (MessageLogStatus | None): The updated status
+            details (MessageLogDetails | None): Updated additional details
+            uncited_references (MessageLogUncitedReferences | None): Updated uncited references
+            references (list[ContentReference] | None): Updated list of references
+
+        Returns:
+            MessageLog: The updated message log
+
+        Raises:
+            Exception: If the update fails
+
+        """
+        return await update_message_log_async(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            message_log_id=message_log_id,
+            order=order,
+            text=text,
+            status=status,
+            details=details,
+            uncited_references=uncited_references,
+            references=references,
+        )
+
+    def create_assistant_message_log(
+        self,
+        text: str,
+        status: MessageLogStatus,
+        order: int,
+        details: MessageLogDetails | None = None,
+        uncited_references: MessageLogUncitedReferences | None = None,
+        references: list[ContentReference] | None = None,
+    ) -> MessageLog:
+        """Creates a message log for the current assistant message synchronously.
+
+        This is a convenience method that uses the current assistant message ID.
+
+        Args:
+            text (str): The log text content
+            status (MessageLogStatus): The status of this log entry
+            order (int): The order/sequence number of this log entry
+            details (MessageLogDetails | None): Additional details about this log entry
+            uncited_references (MessageLogUncitedReferences | None): References that are not cited
+            references (list[ContentReference] | None): List of references for this log
+
+        Returns:
+            MessageLog: The created message log
+
+        Raises:
+            Exception: If the creation fails
+
+        """
+        return self.create_message_log(
+            message_id=self._assistant_message_id,
+            text=text,
+            status=status,
+            order=order,
+            details=details,
+            uncited_references=uncited_references,
+            references=references,
+        )
+
+    async def create_assistant_message_log_async(
+        self,
+        text: str,
+        status: MessageLogStatus,
+        order: int,
+        details: MessageLogDetails | None = None,
+        uncited_references: MessageLogUncitedReferences | None = None,
+        references: list[ContentReference] | None = None,
+    ) -> MessageLog:
+        """Creates a message log for the current assistant message asynchronously.
+
+        This is a convenience method that uses the current assistant message ID.
+
+        Args:
+            text (str): The log text content
+            status (MessageLogStatus): The status of this log entry
+            order (int): The order/sequence number of this log entry
+            details (MessageLogDetails | None): Additional details about this log entry
+            uncited_references (MessageLogUncitedReferences | None): References that are not cited
+            references (list[ContentReference] | None): List of references for this log
+
+        Returns:
+            MessageLog: The created message log
+
+        Raises:
+            Exception: If the creation fails
+
+        """
+        return await self.create_message_log_async(
+            message_id=self._assistant_message_id,
+            text=text,
+            status=status,
+            order=order,
+            details=details,
+            uncited_references=uncited_references,
+            references=references,
+        )
+
+    def create_message_execution(
+        self,
+        message_id: str,
+        type: MessageExecutionType = MessageExecutionType.DEEP_RESEARCH,
+        seconds_remaining: int | None = None,
+        percentage_completed: int | None = None,
+    ) -> MessageExecution:
+        """Creates a message execution for tracking long-running operations synchronously.
+
+        Args:
+            message_id (str): The ID of the message this execution belongs to
+            type (MessageExecutionType): The type of execution. Defaults to DEEP_RESEARCH.
+            seconds_remaining (int | None): Estimated seconds remaining for completion
+            percentage_completed (int | None): Percentage of completion (0-100)
+
+        Returns:
+            MessageExecution: The created message execution
+
+        Raises:
+            Exception: If the creation fails
+
+        """
+        return create_message_execution(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            message_id=message_id,
+            chat_id=self._chat_id,
+            type=type,
+            seconds_remaining=seconds_remaining,
+            percentage_completed=percentage_completed,
+        )
+
+    async def create_message_execution_async(
+        self,
+        message_id: str,
+        type: MessageExecutionType = MessageExecutionType.DEEP_RESEARCH,
+        seconds_remaining: int | None = None,
+        percentage_completed: int | None = None,
+    ) -> MessageExecution:
+        """Creates a message execution for tracking long-running operations asynchronously.
+
+        Args:
+            message_id (str): The ID of the message this execution belongs to
+            type (MessageExecutionType): The type of execution. Defaults to DEEP_RESEARCH.
+            seconds_remaining (int | None): Estimated seconds remaining for completion
+            percentage_completed (int | None): Percentage of completion (0-100)
+
+        Returns:
+            MessageExecution: The created message execution
+
+        Raises:
+            Exception: If the creation fails
+
+        """
+        return await create_message_execution_async(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            message_id=message_id,
+            chat_id=self._chat_id,
+            type=type,
+            seconds_remaining=seconds_remaining,
+            percentage_completed=percentage_completed,
+        )
+
+    def get_message_execution(
+        self,
+        message_id: str,
+    ) -> MessageExecution:
+        """Gets a message execution by message ID synchronously.
+
+        Args:
+            message_id (str): The ID of the message to get execution for
+
+        Returns:
+            MessageExecution: The message execution
+
+        Raises:
+            Exception: If the retrieval fails
+
+        """
+        return get_message_execution(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            message_id=message_id,
+        )
+
+    async def get_message_execution_async(
+        self,
+        message_id: str,
+    ) -> MessageExecution:
+        """Gets a message execution by message ID asynchronously.
+
+        Args:
+            message_id (str): The ID of the message to get execution for
+
+        Returns:
+            MessageExecution: The message execution
+
+        Raises:
+            Exception: If the retrieval fails
+
+        """
+        return await get_message_execution_async(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            message_id=message_id,
+        )
+
+    def update_message_execution(
+        self,
+        message_id: str,
+        status: MessageExecutionUpdateStatus,
+        seconds_remaining: int | None = None,
+        percentage_completed: int | None = None,
+    ) -> MessageExecution:
+        """Updates a message execution synchronously.
+
+        Args:
+            message_id (str): The ID of the message to update execution for
+            status (MessageExecutionUpdateStatus): The updated status (COMPLETED or FAILED)
+            seconds_remaining (int | None): Updated estimated seconds remaining
+            percentage_completed (int | None): Updated percentage of completion (0-100)
+
+        Returns:
+            MessageExecution: The updated message execution
+
+        Raises:
+            Exception: If the update fails
+
+        """
+        return update_message_execution(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            message_id=message_id,
+            status=status,
+            seconds_remaining=seconds_remaining,
+            percentage_completed=percentage_completed,
+        )
+
+    async def update_message_execution_async(
+        self,
+        message_id: str,
+        status: MessageExecutionUpdateStatus,
+        seconds_remaining: int | None = None,
+        percentage_completed: int | None = None,
+    ) -> MessageExecution:
+        """Updates a message execution asynchronously.
+
+        Args:
+            message_id (str): The ID of the message to update execution for
+            status (MessageExecutionUpdateStatus): The updated status (COMPLETED or FAILED)
+            seconds_remaining (int | None): Updated estimated seconds remaining
+            percentage_completed (int | None): Updated percentage of completion (0-100)
+
+        Returns:
+            MessageExecution: The updated message execution
+
+        Raises:
+            Exception: If the update fails
+
+        """
+        return await update_message_execution_async(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            message_id=message_id,
+            status=status,
+            seconds_remaining=seconds_remaining,
+            percentage_completed=percentage_completed,
+        )
+
+    def create_assistant_message_execution(
+        self,
+        type: MessageExecutionType = MessageExecutionType.DEEP_RESEARCH,
+        seconds_remaining: int | None = None,
+        percentage_completed: int | None = None,
+    ) -> MessageExecution:
+        """Creates a message execution for the current assistant message synchronously.
+
+        This is a convenience method that uses the current assistant message ID.
+
+        Args:
+            type (MessageExecutionType): The type of execution. Defaults to DEEP_RESEARCH.
+            seconds_remaining (int | None): Estimated seconds remaining for completion
+            percentage_completed (int | None): Percentage of completion (0-100)
+
+        Returns:
+            MessageExecution: The created message execution
+
+        Raises:
+            Exception: If the creation fails
+
+        """
+        return self.create_message_execution(
+            message_id=self._assistant_message_id,
+            type=type,
+            seconds_remaining=seconds_remaining,
+            percentage_completed=percentage_completed,
+        )
+
+    async def create_assistant_message_execution_async(
+        self,
+        type: MessageExecutionType = MessageExecutionType.DEEP_RESEARCH,
+        seconds_remaining: int | None = None,
+        percentage_completed: int | None = None,
+    ) -> MessageExecution:
+        """Creates a message execution for the current assistant message asynchronously.
+
+        This is a convenience method that uses the current assistant message ID.
+
+        Args:
+            type (MessageExecutionType): The type of execution. Defaults to DEEP_RESEARCH.
+            seconds_remaining (int | None): Estimated seconds remaining for completion
+            percentage_completed (int | None): Percentage of completion (0-100)
+
+        Returns:
+            MessageExecution: The created message execution
+
+        Raises:
+            Exception: If the creation fails
+
+        """
+        return await self.create_message_execution_async(
+            message_id=self._assistant_message_id,
+            type=type,
+            seconds_remaining=seconds_remaining,
+            percentage_completed=percentage_completed,
+        )
+
+    def get_assistant_message_execution(self) -> MessageExecution:
+        """Gets the message execution for the current assistant message synchronously.
+
+        This is a convenience method that uses the current assistant message ID.
+
+        Returns:
+            MessageExecution: The message execution
+
+        Raises:
+            Exception: If the retrieval fails
+
+        """
+        return self.get_message_execution(message_id=self._assistant_message_id)
+
+    async def get_assistant_message_execution_async(self) -> MessageExecution:
+        """Gets the message execution for the current assistant message asynchronously.
+
+        This is a convenience method that uses the current assistant message ID.
+
+        Returns:
+            MessageExecution: The message execution
+
+        Raises:
+            Exception: If the retrieval fails
+
+        """
+        return await self.get_message_execution_async(
+            message_id=self._assistant_message_id
+        )
+
+    def update_assistant_message_execution(
+        self,
+        status: MessageExecutionUpdateStatus,
+        seconds_remaining: int | None = None,
+        percentage_completed: int | None = None,
+    ) -> MessageExecution:
+        """Updates the message execution for the current assistant message synchronously.
+
+        This is a convenience method that uses the current assistant message ID.
+
+        Args:
+            status (MessageExecutionUpdateStatus): The updated status (COMPLETED or FAILED)
+            seconds_remaining (int | None): Updated estimated seconds remaining
+            percentage_completed (int | None): Updated percentage of completion (0-100)
+
+        Returns:
+            MessageExecution: The updated message execution
+
+        Raises:
+            Exception: If the update fails
+
+        """
+        return self.update_message_execution(
+            message_id=self._assistant_message_id,
+            status=status,
+            seconds_remaining=seconds_remaining,
+            percentage_completed=percentage_completed,
+        )
+
+    async def update_assistant_message_execution_async(
+        self,
+        status: MessageExecutionUpdateStatus,
+        seconds_remaining: int | None = None,
+        percentage_completed: int | None = None,
+    ) -> MessageExecution:
+        """Updates the message execution for the current assistant message asynchronously.
+
+        This is a convenience method that uses the current assistant message ID.
+
+        Args:
+            status (MessageExecutionUpdateStatus): The updated status (COMPLETED or FAILED)
+            seconds_remaining (int | None): Updated estimated seconds remaining
+            percentage_completed (int | None): Updated percentage of completion (0-100)
+
+        Returns:
+            MessageExecution: The updated message execution
+
+        Raises:
+            Exception: If the update fails
+
+        """
+        return await self.update_message_execution_async(
+            message_id=self._assistant_message_id,
+            status=status,
+            seconds_remaining=seconds_remaining,
+            percentage_completed=percentage_completed,
+        )
+
     @deprecated("Use complete_with_references instead")
     def stream_complete(
         self,

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/tools/a2a/config.py

@@ -0,0 +1,29 @@
+from unique_toolkit.tools.schemas import BaseToolConfig
+
+from unique_toolkit.tools.config import get_configuration_dict
+
+
+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/tools/a2a/manager.py

@@ -0,0 +1,50 @@
+from logging import Logger
+
+from unique_toolkit.app.schemas import ChatEvent
+from unique_toolkit.tools.a2a.service import SubAgentTool, ToolProgressReporter
+
+from unique_toolkit.tools.a2a.config import SubAgentToolConfig
+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