unique_toolkit 0.8.27__py3-none-any.whl → 0.8.29__py3-none-any.whl

unique_toolkit/app/schemas.py

@@ -196,6 +196,10 @@ class ChatEventPayload(BaseModel):
         default_factory=list,
         description="A list of MCP servers with tools available for the chat session.",
     )
+    message_execution_id: str | None = Field(
+        default=None,
+        description="The message execution id for triggering the chat event. Originates from the message execution service.",
+    )
 
     @field_validator("raw_scope_rules", mode="before")
     def validate_scope_rules(cls, value: dict[str, Any] | None) -> UniqueQL | None:

unique_toolkit/app/unique_settings.py

@@ -2,7 +2,7 @@ import os
 from logging import getLogger
 from pathlib import Path
 from typing import Self, TypeVar
-from urllib.parse import urlparse, urlunparse
+from urllib.parse import ParseResult, urlparse, urlunparse
 
 import unique_sdk
 from platformdirs import user_config_dir
@@ -99,22 +99,28 @@ class UniqueApi(BaseSettings):
             )
         )
 
-    def sdk_url(self) -> str:
+    def base_path(self) -> tuple[ParseResult, str]:
         parsed = urlparse(self.base_url)
+        base_path = "/public/chat/"
 
-        path = "/public/chat"
         if parsed.hostname and (
-            "qa.unique" in parsed.hostname or ".unique" in parsed.hostname
+            "gateway.qa.unique" in parsed.hostname
+            or "gateway.unique" in parsed.hostname
         ):
-            path = "/public/chat-gen2"
-        return urlunparse(parsed._replace(path=path, query=None, fragment=None))
+            base_path = "/public/chat-gen2/"
 
-    def openai_proxy_url(self) -> str:
-        parsed = urlparse(self.base_url)
-        path = "/public/chat/openai-proxy/"
-        if parsed.hostname and "qa.unique" in parsed.hostname:
-            path = "/public/chat-gen2/openai-proxy/"
+        if parsed.hostname and "localhost" in parsed.hostname:
+            base_path = "/public/"
 
+        return parsed, base_path
+
+    def sdk_url(self) -> str:
+        parsed, base_path = self.base_path()
+        return urlunparse(parsed._replace(path=base_path, query=None, fragment=None))
+
+    def openai_proxy_url(self) -> str:
+        parsed, base_path = self.base_path()
+        path = base_path + "openai-proxy/"
         return urlunparse(parsed._replace(path=path, query=None, fragment=None))
 
 

unique_toolkit/chat/functions.py

@@ -15,6 +15,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.content.utils import count_tokens
@@ -174,6 +181,26 @@ def map_references(references: list[ContentReference]) -> list[dict[str, Any]]:
     ]
 
 
+def map_references_with_original_index(
+    references: list[ContentReference],
+) -> list[dict[str, Any]]:
+    """Maps ContentReference objects to dict format for MessageLog API (complete format).
+
+    This function includes all fields including originalIndex for APIs that support it.
+    """
+    return [
+        {
+            "name": ref.name,
+            "url": ref.url,
+            "sequenceNumber": ref.sequence_number,
+            "sourceId": ref.source_id,
+            "source": ref.source,
+            "originalIndex": ref.original_index,
+        }
+        for ref in references
+    ]
+
+
 def _construct_message_modify_params(
     user_id: str,
     company_id: str,
@@ -887,3 +914,443 @@ async def stream_complete_with_references_async(
     except Exception as e:
         logger.error(f"Error streaming completion: {e}")
         raise e
+
+
+def create_message_log(
+    user_id: str,
+    company_id: str,
+    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 synchronously.
+
+    Args:
+        user_id (str): The user ID.
+        company_id (str): The company ID.
+        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.
+
+    """
+    try:
+        message_log = unique_sdk.MessageLog.create(
+            user_id=user_id,
+            company_id=company_id,
+            messageId=message_id,
+            text=text,
+            status=status.value,
+            order=order,
+            details=details.model_dump() if details else None,
+            uncitedReferences=uncited_references.model_dump()
+            if uncited_references
+            else None,
+            references=map_references_with_original_index(references)
+            if references
+            else [],  # type: ignore
+        )
+        return MessageLog(**message_log)
+    except Exception as e:
+        logger.error(f"Failed to create message log: {e}")
+        raise e
+
+
+async def create_message_log_async(
+    user_id: str,
+    company_id: str,
+    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 asynchronously.
+
+    Args:
+        user_id (str): The user ID.
+        company_id (str): The company ID.
+        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.
+
+    """
+    try:
+        message_log = await unique_sdk.MessageLog.create_async(
+            user_id=user_id,
+            company_id=company_id,
+            messageId=message_id,
+            text=text,
+            status=status.value,
+            order=order,
+            details=details.model_dump() if details else None,
+            uncitedReferences=uncited_references.model_dump()
+            if uncited_references
+            else None,
+            references=map_references_with_original_index(references)
+            if references
+            else [],  # type: ignore
+        )
+        return MessageLog(**message_log)
+    except Exception as e:
+        logger.error(f"Failed to create message log: {e}")
+        raise e
+
+
+def update_message_log(
+    user_id: str,
+    company_id: str,
+    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:
+        user_id (str): The user ID.
+        company_id (str): The company ID.
+        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.
+
+    """
+    try:
+        message_log = unique_sdk.MessageLog.update(
+            user_id=user_id,
+            company_id=company_id,
+            message_log_id=message_log_id,
+            text=text,
+            status=status.value if status else None,
+            order=order,
+            details=details.model_dump() if details else None,
+            uncitedReferences=uncited_references.model_dump()
+            if uncited_references
+            else None,
+            references=map_references_with_original_index(references)
+            if references
+            else [],  # type: ignore
+        )
+        return MessageLog(**message_log)
+    except Exception as e:
+        logger.error(f"Failed to update message log: {e}")
+        raise e
+
+
+async def update_message_log_async(
+    user_id: str,
+    company_id: str,
+    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:
+        user_id (str): The user ID.
+        company_id (str): The company ID.
+        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.
+
+    """
+    try:
+        message_log = await unique_sdk.MessageLog.update_async(
+            user_id=user_id,
+            company_id=company_id,
+            message_log_id=message_log_id,
+            text=text,
+            status=status.value if status else None,
+            order=order,
+            details=details.model_dump() if details else None,
+            uncitedReferences=uncited_references.model_dump()
+            if uncited_references
+            else None,
+            references=map_references_with_original_index(references)
+            if references
+            else [],  # type: ignore
+        )
+        return MessageLog(**message_log)
+    except Exception as e:
+        logger.error(f"Failed to update message log: {e}")
+        raise e
+
+
+def create_message_execution(
+    user_id: str,
+    company_id: str,
+    message_id: str,
+    chat_id: str,
+    type: MessageExecutionType = MessageExecutionType.DEEP_RESEARCH,
+    seconds_remaining: int | None = None,
+    percentage_completed: int | None = None,
+) -> MessageExecution:
+    """Creates a message execution synchronously.
+
+    Args:
+        user_id (str): The user ID.
+        company_id (str): The company ID.
+        message_id (str): The ID of the message this execution belongs to.
+        chat_id (str): The chat ID.
+        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.
+
+    """
+    try:
+        message_execution = unique_sdk.MessageExecution.create(
+            user_id=user_id,
+            company_id=company_id,
+            messageId=message_id,
+            chatId=chat_id,
+            type=type.value,
+            secondsRemaining=seconds_remaining,
+            percentageCompleted=percentage_completed,
+        )
+        return MessageExecution(**message_execution)
+    except Exception as e:
+        logger.error(f"Failed to create message execution: {e}")
+        raise e
+
+
+async def create_message_execution_async(
+    user_id: str,
+    company_id: str,
+    message_id: str,
+    chat_id: str,
+    type: MessageExecutionType = MessageExecutionType.DEEP_RESEARCH,
+    seconds_remaining: int | None = None,
+    percentage_completed: int | None = None,
+) -> MessageExecution:
+    """Creates a message execution asynchronously.
+
+    Args:
+        user_id (str): The user ID.
+        company_id (str): The company ID.
+        message_id (str): The ID of the message this execution belongs to.
+        chat_id (str): The chat ID.
+        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.
+
+    """
+    try:
+        message_execution = await unique_sdk.MessageExecution.create_async(
+            user_id=user_id,
+            company_id=company_id,
+            messageId=message_id,
+            chatId=chat_id,
+            type=type.value,
+            secondsRemaining=seconds_remaining,
+            percentageCompleted=percentage_completed,
+        )
+        return MessageExecution(**message_execution)
+    except Exception as e:
+        logger.error(f"Failed to create message execution: {e}")
+        raise e
+
+
+def get_message_execution(
+    user_id: str,
+    company_id: str,
+    message_id: str,
+) -> MessageExecution:
+    """Gets a message execution by message ID synchronously.
+
+    Args:
+        user_id (str): The user ID.
+        company_id (str): The company ID.
+        message_id (str): The ID of the message to get execution for.
+
+    Returns:
+        MessageExecution: The message execution.
+
+    Raises:
+        Exception: If the retrieval fails.
+
+    """
+    try:
+        message_execution = unique_sdk.MessageExecution.get(
+            user_id=user_id,
+            company_id=company_id,
+            messageId=message_id,
+        )
+        return MessageExecution(**message_execution)
+    except Exception as e:
+        logger.error(f"Failed to get message execution: {e}")
+        raise e
+
+
+async def get_message_execution_async(
+    user_id: str,
+    company_id: str,
+    message_id: str,
+) -> MessageExecution:
+    """Gets a message execution by message ID asynchronously.
+
+    Args:
+        user_id (str): The user ID.
+        company_id (str): The company ID.
+        message_id (str): The ID of the message to get execution for.
+
+    Returns:
+        MessageExecution: The message execution.
+
+    Raises:
+        Exception: If the retrieval fails.
+
+    """
+    try:
+        message_execution = await unique_sdk.MessageExecution.get_async(
+            user_id=user_id,
+            company_id=company_id,
+            messageId=message_id,
+        )
+        return MessageExecution(**message_execution)
+    except Exception as e:
+        logger.error(f"Failed to get message execution: {e}")
+        raise e
+
+
+def update_message_execution(
+    user_id: str,
+    company_id: str,
+    message_id: str,
+    status: MessageExecutionUpdateStatus,
+    seconds_remaining: int | None = None,
+    percentage_completed: int | None = None,
+) -> MessageExecution:
+    """Updates a message execution synchronously.
+
+    Args:
+        user_id (str): The user ID.
+        company_id (str): The company ID.
+        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.
+
+    """
+    try:
+        message_execution = unique_sdk.MessageExecution.update(
+            user_id=user_id,
+            company_id=company_id,
+            messageId=message_id,
+            status=status.value,
+            secondsRemaining=seconds_remaining,
+            percentageCompleted=percentage_completed,
+        )
+        return MessageExecution(**message_execution)
+    except Exception as e:
+        logger.error(f"Failed to update message execution: {e}")
+        raise e
+
+
+async def update_message_execution_async(
+    user_id: str,
+    company_id: str,
+    message_id: str,
+    status: MessageExecutionUpdateStatus,
+    seconds_remaining: int | None = None,
+    percentage_completed: int | None = None,
+) -> MessageExecution:
+    """Updates a message execution asynchronously.
+
+    Args:
+        user_id (str): The user ID.
+        company_id (str): The company ID.
+        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.
+
+    """
+    try:
+        message_execution = await unique_sdk.MessageExecution.update_async(
+            user_id=user_id,
+            company_id=company_id,
+            messageId=message_id,
+            status=status.value,
+            secondsRemaining=seconds_remaining,
+            percentageCompleted=percentage_completed,
+        )
+        return MessageExecution(**message_execution)
+    except Exception as e:
+        logger.error(f"Failed to update message execution: {e}")
+        raise e

unique_toolkit/chat/schemas.py

@@ -1,5 +1,6 @@
 from datetime import datetime
 from enum import StrEnum
+from typing import Literal
 
 from humps import camelize
 from openai.types.chat import (
@@ -161,3 +162,72 @@ class ChatMessageAssessment(BaseModel):
     is_visible: bool
     created_at: datetime | None = None
     updated_at: datetime | None = None
+
+
+class MessageLogStatus(StrEnum):
+    RUNNING = "RUNNING"
+    COMPLETED = "COMPLETED"
+    FAILED = "FAILED"
+
+
+class MessageExecutionStatus(StrEnum):
+    PENDING = "PENDING"
+    RUNNING = "RUNNING"
+    COMPLETED = "COMPLETED"
+    FAILED = "FAILED"
+
+
+class MessageExecutionType(StrEnum):
+    DEEP_RESEARCH = "DEEP_RESEARCH"
+
+
+class MessageExecutionUpdateStatus(StrEnum):
+    COMPLETED = "COMPLETED"
+    FAILED = "FAILED"
+
+
+class MessageLogUncitedReferences(BaseModel):
+    model_config = model_config
+    data: list[ContentReference]
+
+
+class MessageLogEvent(BaseModel):
+    model_config = model_config
+    type: Literal["WebSearch", "InternalSearch"]
+    text: str
+
+
+class MessageLogDetails(BaseModel):
+    model_config = model_config
+    data: list[MessageLogEvent] | None = None
+    status: str | None = Field(
+        default=None, description="Overarching status of the current message log"
+    )
+
+
+class MessageLog(BaseModel):
+    model_config = model_config
+
+    message_log_id: str | None = None
+    message_id: str | None = None
+    status: MessageLogStatus
+    text: str | None = None
+    details: MessageLogDetails | None = None
+    uncited_references: MessageLogUncitedReferences | None = None
+    order: int
+    references: list[ContentReference] | None = None
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+
+
+class MessageExecution(BaseModel):
+    model_config = model_config
+
+    message_execution_id: str | None = None
+    message_id: str | None = None
+    status: MessageExecutionStatus
+    type: MessageExecutionType = MessageExecutionType.DEEP_RESEARCH
+    seconds_remaining: int | None = None
+    percentage_completed: int | None = None
+    created_at: datetime | None = None
+    updated_at: datetime | None = None

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-0.8.27.dist-info → unique_toolkit-0.8.29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unique_toolkit
-Version: 0.8.27
+Version: 0.8.29
 Summary: 
 License: Proprietary
 Author: Martin Fadler
@@ -114,6 +114,11 @@ 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.29] - 2025-08-27
+- Include `MessageExecution` and `MessageLog` in toolkit 
+
+## [0.8.28] - 2025-08-28
+- Fix paths for `sdk_url` and `openai_proxy` for localhost
 
 ## [0.8.27] - 2025-08-28
 - Fixed function "create_async" in language_model.functions : "user_id" argument should be optional.

{unique_toolkit-0.8.27.dist-info → unique_toolkit-0.8.29.dist-info}/RECORD

@@ -14,14 +14,14 @@ unique_toolkit/app/init_logging.py,sha256=Sh26SRxOj8i8dzobKhYha2lLrkrMTHfB1V4jR3
 unique_toolkit/app/init_sdk.py,sha256=5_oDoETr6akwYyBCb0ivTdMNu3SVgPSkrXcDS6ELyY8,2269
 unique_toolkit/app/performance/async_tasks.py,sha256=H0l3OAcosLwNHZ8d2pd-Di4wHIXfclEvagi5kfqLFPA,1941
 unique_toolkit/app/performance/async_wrapper.py,sha256=yVVcRDkcdyfjsxro-N29SBvi-7773wnfDplef6-y8xw,1077
-unique_toolkit/app/schemas.py,sha256=uh7PR-YYXfdTnuO5V_eGrW96eJmP5tJ4jeePyU8tsNI,7888
-unique_toolkit/app/unique_settings.py,sha256=hsQ4ViOs-E5K_bq96PwDvuVpfMJ-vNPq01B2gCK5R5g,9802
+unique_toolkit/app/schemas.py,sha256=xHdzMyZ_cgCzxCqzCJYwOCAYWkaQ9zIyZsRhDgSQnEA,8088
+unique_toolkit/app/unique_settings.py,sha256=f9Ip1yBhIJqHpuHIo3ihCW2MGyQynBggEKDzlIOIlyg,9976
 unique_toolkit/app/verification.py,sha256=GxFFwcJMy25fCA_Xe89wKW7bgqOu8PAs5y8QpHF0GSc,3861
 unique_toolkit/chat/__init__.py,sha256=LRs2G-JTVuci4lbtHTkVUiNcZcSR6uqqfnAyo7af6nY,619
 unique_toolkit/chat/constants.py,sha256=05kq6zjqUVB2d6_P7s-90nbljpB3ryxwCI-CAz0r2O4,83
-unique_toolkit/chat/functions.py,sha256=I6r81PpWNu-j9DvHxNFKN3V6T5E5q42FhW9kF8pJJSY,29950
-unique_toolkit/chat/schemas.py,sha256=ekmDzxZRnO4pF-8DAnP4JqKmYuJnSC5RpYcO7j5T3aI,4927
-unique_toolkit/chat/service.py,sha256=-agXxkB_cl7Mcr3aFVHbBXhO-RioiouAfoHAHmlhQJs,37981
+unique_toolkit/chat/functions.py,sha256=qxBjxIFoko5vyQNJDYpIkMtBhEGGcSlWn6fkAY-dFVE,45213
+unique_toolkit/chat/schemas.py,sha256=u3WPdMkOlmwPGHUueQC-nk8k-QkM7ZSUcU0f-32g6Uc,6718
+unique_toolkit/chat/service.py,sha256=YT01Ol3czvopnvT1CxZUOYDxU85mxBaMt7C_lEcciDM,58162
 unique_toolkit/chat/state.py,sha256=Cjgwv_2vhDFbV69xxsn7SefhaoIAEqLx3ferdVFCnOg,1445
 unique_toolkit/chat/utils.py,sha256=ihm-wQykBWhB4liR3LnwPVPt_qGW6ETq21Mw4HY0THE,854
 unique_toolkit/content/__init__.py,sha256=EdJg_A_7loEtCQf4cah3QARQreJx6pdz89Rm96YbMVg,940
@@ -115,7 +115,7 @@ unique_toolkit/tools/utils/execution/execution.py,sha256=vjG2Y6awsGNtlvyQAGCTthQ
 unique_toolkit/tools/utils/source_handling/schema.py,sha256=vzAyf6ZWNexjMO0OrnB8y2glGkvAilmGGQXd6zcDaKw,870
 unique_toolkit/tools/utils/source_handling/source_formatting.py,sha256=C7uayNbdkNVJdEARA5CENnHtNY1SU6etlaqbgHNyxaQ,9152
 unique_toolkit/tools/utils/source_handling/tests/test_source_formatting.py,sha256=oM5ZxEgzROrnX1229KViCAFjRxl9wCTzWZoinYSHleM,6979
-unique_toolkit-0.8.27.dist-info/LICENSE,sha256=GlN8wHNdh53xwOPg44URnwag6TEolCjoq3YD_KrWgss,193
-unique_toolkit-0.8.27.dist-info/METADATA,sha256=8ZMPPZWswpjAPnSCMCm8t4DbGCeB4e0jvpF97fC4ayM,29077
-unique_toolkit-0.8.27.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-unique_toolkit-0.8.27.dist-info/RECORD,,
+unique_toolkit-0.8.29.dist-info/LICENSE,sha256=GlN8wHNdh53xwOPg44URnwag6TEolCjoq3YD_KrWgss,193
+unique_toolkit-0.8.29.dist-info/METADATA,sha256=14-dyP0BCriYbAGs3mQBbGUG-SfuOmJDX6lq1Puf2Gg,29245
+unique_toolkit-0.8.29.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+unique_toolkit-0.8.29.dist-info/RECORD,,