unique_toolkit 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

unique_toolkit/chat/functions.py

@@ -1,6 +1,6 @@
 import logging
 import re
-from typing import Any, Dict, List
+from typing import Any, Dict, List, cast
 
 import unique_sdk
 from unique_sdk._list_object import ListObject
@@ -15,8 +15,19 @@ from unique_toolkit.chat.schemas import (
     ChatMessageAssessmentType,
     ChatMessageRole,
 )
-from unique_toolkit.content.schemas import ContentReference
+from unique_toolkit.content.schemas import ContentChunk, ContentReference
 from unique_toolkit.content.utils import count_tokens
+from unique_toolkit.language_model.constants import (
+    DEFAULT_COMPLETE_TEMPERATURE,
+    DEFAULT_COMPLETE_TIMEOUT,
+)
+from unique_toolkit.language_model.functions import _prepare_completion_params_util
+from unique_toolkit.language_model.infos import LanguageModelName
+from unique_toolkit.language_model.schemas import (
+    LanguageModelMessages,
+    LanguageModelStreamResponse,
+    LanguageModelTool,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -659,3 +670,136 @@ async def modify_message_assessment_async(
     except Exception as e:
         logger.error(f"Failed to modify message assessment: {e}")
         raise e
+
+
+def stream_complete_to_chat(
+    company_id: str,
+    user_id: str,
+    assistant_message_id: str,
+    user_message_id: str,
+    chat_id: str,
+    assistant_id: str,
+    messages: LanguageModelMessages,
+    model_name: LanguageModelName | str,
+    content_chunks: list[ContentChunk] = [],
+    debug_info: dict = {},
+    temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
+    timeout: int = DEFAULT_COMPLETE_TIMEOUT,
+    tools: list[LanguageModelTool] | None = None,
+    start_text: str | None = None,
+    other_options: dict | None = None,
+) -> LanguageModelStreamResponse:
+    """
+    Streams a completion synchronously.
+
+    Args:
+        company_id (str): The company ID associated with the request.
+        user_id (str): The user ID for the request.
+        assistant_message_id (str): The assistant message ID.
+        user_message_id (str): The user message ID.
+        chat_id (str): The chat ID.
+        assistant_id (str): The assistant ID.
+        messages (LanguageModelMessages): The messages to complete.
+        model_name (LanguageModelName | str): The model name.
+        content_chunks (list[ContentChunk]): Content chunks for context.
+        debug_info (dict): Debug information.
+        temperature (float): Temperature setting.
+        timeout (int): Timeout in milliseconds.
+        tools (Optional[list[LanguageModelTool]]): Optional tools.
+        start_text (Optional[str]): Starting text.
+        other_options (Optional[dict]): Additional options.
+
+    Returns:
+        LanguageModelStreamResponse: The streaming response object.
+    """
+    options, model, messages_dict, search_context = _prepare_completion_params_util(
+        messages=messages,
+        model_name=model_name,
+        temperature=temperature,
+        tools=tools,
+        other_options=other_options,
+        content_chunks=content_chunks,
+    )
+
+    try:
+        response = unique_sdk.Integrated.chat_stream_completion(
+            user_id=user_id,
+            company_id=company_id,
+            assistantMessageId=assistant_message_id,
+            userMessageId=user_message_id,
+            messages=cast(
+                list[unique_sdk.Integrated.ChatCompletionRequestMessage],
+                messages_dict,
+            ),
+            chatId=chat_id,
+            searchContext=search_context,
+            model=model,
+            timeout=timeout,
+            assistantId=assistant_id,
+            debugInfo=debug_info,
+            options=options,  # type: ignore
+            startText=start_text,
+        )
+        return LanguageModelStreamResponse(**response)
+    except Exception as e:
+        logger.error(f"Error streaming completion: {e}")
+        raise e
+
+
+async def stream_complete_to_chat_async(
+    company_id: str,
+    user_id: str,
+    assistant_message_id: str,
+    user_message_id: str,
+    chat_id: str,
+    assistant_id: str,
+    messages: LanguageModelMessages,
+    model_name: LanguageModelName | str,
+    content_chunks: list[ContentChunk] = [],
+    debug_info: dict = {},
+    temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
+    timeout: int = DEFAULT_COMPLETE_TIMEOUT,
+    tools: list[LanguageModelTool] | None = None,
+    start_text: str | None = None,
+    other_options: dict | None = None,
+) -> LanguageModelStreamResponse:
+    """
+    Streams a completion asynchronously.
+
+    Args: [same as stream_complete]
+
+    Returns:
+        LanguageModelStreamResponse: The streaming response object.
+    """
+    options, model, messages_dict, search_context = _prepare_completion_params_util(
+        messages=messages,
+        model_name=model_name,
+        temperature=temperature,
+        tools=tools,
+        other_options=other_options,
+        content_chunks=content_chunks,
+    )
+
+    try:
+        response = await unique_sdk.Integrated.chat_stream_completion_async(
+            user_id=user_id,
+            company_id=company_id,
+            assistantMessageId=assistant_message_id,
+            userMessageId=user_message_id,
+            messages=cast(
+                list[unique_sdk.Integrated.ChatCompletionRequestMessage],
+                messages_dict,
+            ),
+            chatId=chat_id,
+            searchContext=search_context,
+            model=model,
+            timeout=timeout,
+            assistantId=assistant_id,
+            debugInfo=debug_info,
+            options=options,  # type: ignore
+            startText=start_text,
+        )
+        return LanguageModelStreamResponse(**response)
+    except Exception as e:
+        logger.error(f"Error streaming completion: {e}")
+        raise e

unique_toolkit/chat/service.py

@@ -3,6 +3,7 @@ from typing import Optional
 
 from typing_extensions import deprecated
 
+from unique_toolkit._common.validate_required_values import validate_required_values
 from unique_toolkit.app.schemas import ChatEvent, Event
 from unique_toolkit.chat.constants import (
     DEFAULT_MAX_MESSAGES,
@@ -30,7 +31,24 @@ from unique_toolkit.chat.schemas import (
     ChatMessageAssessmentType,
     ChatMessageRole,
 )
-from unique_toolkit.content.schemas import ContentReference
+from unique_toolkit.content.schemas import ContentChunk, ContentReference
+from unique_toolkit.language_model.constants import (
+    DEFAULT_COMPLETE_TEMPERATURE,
+    DEFAULT_COMPLETE_TIMEOUT,
+)
+from unique_toolkit.language_model.infos import (
+    LanguageModelName,
+)
+from unique_toolkit.language_model.schemas import (
+    LanguageModelMessages,
+    LanguageModelStreamResponse,
+    LanguageModelTool,
+)
+
+from .functions import (
+    stream_complete_to_chat,
+    stream_complete_to_chat_async,
+)
 
 logger = logging.getLogger(f"toolkit.{DOMAIN_NAME}.{__name__}")
 
@@ -377,8 +395,8 @@ class ChatService:
         original_content: str | None = None,
         references: list[ContentReference] = [],
         debug_info: dict = {},
-        set_completed_at: Optional[bool] = False,
-    ):
+        set_completed_at: bool | None = False,
+    ) -> ChatMessage:
         """
         Creates a message in the chat session synchronously.
 
@@ -395,7 +413,7 @@ class ChatService:
         Raises:
             Exception: If the creation fails.
         """
-        return create_message(
+        chat_message = create_message(
             user_id=self.user_id,
             company_id=self.company_id,
             chat_id=self.chat_id,
@@ -407,6 +425,9 @@ class ChatService:
             debug_info=debug_info,
             set_completed_at=set_completed_at,
         )
+        # Update the assistant message id
+        self.assistant_message_id = chat_message.id
+        return chat_message
 
     async def create_assistant_message_async(
         self,
@@ -414,8 +435,8 @@ class ChatService:
         original_content: str | None = None,
         references: list[ContentReference] = [],
         debug_info: dict = {},
-        set_completed_at: Optional[bool] = False,
-    ):
+        set_completed_at: bool | None = False,
+    ) -> ChatMessage:
         """
         Creates a message in the chat session asynchronously.
 
@@ -433,7 +454,7 @@ class ChatService:
             Exception: If the creation fails.
         """
 
-        return await create_message_async(
+        chat_message = await create_message_async(
             user_id=self.user_id,
             company_id=self.company_id,
             chat_id=self.chat_id,
@@ -445,6 +466,90 @@ class ChatService:
             debug_info=debug_info,
             set_completed_at=set_completed_at,
         )
+        # Update the assistant message id
+        self.assistant_message_id = chat_message.id
+        return chat_message
+
+    def create_user_message(
+        self,
+        content: str,
+        original_content: str | None = None,
+        references: list[ContentReference] = [],
+        debug_info: dict = {},
+        set_completed_at: bool | None = False,
+    ) -> ChatMessage:
+        """
+        Creates a user message in the chat session synchronously.
+
+        Args:
+            content (str): The content for the message.
+            original_content (str, optional): The original content for the message.
+            references (list[ContentReference]): list of ContentReference objects. Defaults to None.
+            debug_info (dict[str, Any]]): Debug information. Defaults to None.
+            set_completed_at (Optional[bool]): Whether to set the completedAt field with the current date time. Defaults to False.
+
+        Returns:
+            ChatMessage: The created message.
+
+        Raises:
+            Exception: If the creation fails.
+        """
+        chat_message = create_message(
+            user_id=self.user_id,
+            company_id=self.company_id,
+            chat_id=self.chat_id,
+            assistant_id=self.assistant_id,
+            role=ChatMessageRole.USER,
+            content=content,
+            original_content=original_content,
+            references=references,
+            debug_info=debug_info,
+            set_completed_at=set_completed_at,
+        )
+        # Update the user message id
+        self.user_message_id = chat_message.id
+        return chat_message
+
+    async def create_user_message_async(
+        self,
+        content: str,
+        original_content: str | None = None,
+        references: list[ContentReference] = [],
+        debug_info: dict = {},
+        set_completed_at: bool | None = False,
+    ) -> ChatMessage:
+        """
+        Creates a user message in the chat session asynchronously.
+
+        Args:
+            content (str): The content for the message.
+            original_content (str, optional): The original content for the message.
+            references (list[ContentReference]): list of references. Defaults to None.
+            debug_info (dict[str, Any]]): Debug information. Defaults to None.
+            set_completed_at (Optional[bool]): Whether to set the completedAt field with the current date time. Defaults to False.
+
+        Returns:
+            ChatMessage: The created message.
+
+        Raises:
+            Exception: If the creation fails.
+        """
+
+        chat_message = await create_message_async(
+            user_id=self.user_id,
+            company_id=self.company_id,
+            chat_id=self.chat_id,
+            assistant_id=self.assistant_id,
+            role=ChatMessageRole.USER,
+            content=content,
+            original_content=original_content,
+            references=references,
+            debug_info=debug_info,
+            set_completed_at=set_completed_at,
+        )
+        # Update the user message id
+        self.user_message_id = chat_message.id
+        return chat_message
 
     def create_message_assessment(
         self,
@@ -599,3 +704,106 @@ class ChatService:
             explanation=explanation,
             label=label,
         )
+
+    def stream_complete(
+        self,
+        messages: LanguageModelMessages,
+        model_name: LanguageModelName | str,
+        content_chunks: list[ContentChunk] = [],
+        debug_info: dict = {},
+        temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
+        timeout: int = DEFAULT_COMPLETE_TIMEOUT,
+        tools: Optional[list[LanguageModelTool]] = None,
+        start_text: Optional[str] = None,
+        other_options: Optional[dict] = None,
+    ) -> LanguageModelStreamResponse:
+        """
+        Streams a completion in the chat session synchronously.
+        """
+        [
+            company_id,
+            user_id,
+            assistant_message_id,
+            user_message_id,
+            chat_id,
+            assistant_id,
+        ] = validate_required_values(
+            [
+                self.company_id,
+                self.user_id,
+                self.assistant_message_id,
+                self.user_message_id,
+                self.chat_id,
+                self.assistant_id,
+            ]
+        )
+
+        return stream_complete_to_chat(
+            company_id=company_id,
+            user_id=user_id,
+            assistant_message_id=assistant_message_id,
+            user_message_id=user_message_id,
+            chat_id=chat_id,
+            assistant_id=assistant_id,
+            messages=messages,
+            model_name=model_name,
+            content_chunks=content_chunks,
+            debug_info=debug_info,
+            temperature=temperature,
+            timeout=timeout,
+            tools=tools,
+            start_text=start_text,
+            other_options=other_options,
+        )
+
+    async def stream_complete_async(
+        self,
+        messages: LanguageModelMessages,
+        model_name: LanguageModelName | str,
+        content_chunks: list[ContentChunk] = [],
+        debug_info: dict = {},
+        temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
+        timeout: int = DEFAULT_COMPLETE_TIMEOUT,
+        tools: Optional[list[LanguageModelTool]] = None,
+        start_text: Optional[str] = None,
+        other_options: Optional[dict] = None,
+    ) -> LanguageModelStreamResponse:
+        """
+        Streams a completion in the chat session asynchronously.
+        """
+
+        [
+            company_id,
+            user_id,
+            assistant_message_id,
+            user_message_id,
+            chat_id,
+            assistant_id,
+        ] = validate_required_values(
+            [
+                self.company_id,
+                self.user_id,
+                self.assistant_message_id,
+                self.user_message_id,
+                self.chat_id,
+                self.assistant_id,
+            ]
+        )
+
+        return await stream_complete_to_chat_async(
+            company_id=company_id,
+            user_id=user_id,
+            assistant_message_id=assistant_message_id,
+            user_message_id=user_message_id,
+            chat_id=chat_id,
+            assistant_id=assistant_id,
+            messages=messages,
+            model_name=model_name,
+            content_chunks=content_chunks,
+            debug_info=debug_info,
+            temperature=temperature,
+            timeout=timeout,
+            tools=tools,
+            start_text=start_text,
+            other_options=other_options,
+        )

unique_toolkit/language_model/functions.py

@@ -1,20 +1,20 @@
 import logging
-from typing import Optional, Type, cast
+from typing import Type, cast
 
 import unique_sdk
 from pydantic import BaseModel
 
 from unique_toolkit.content.schemas import ContentChunk
 from unique_toolkit.evaluators import DOMAIN_NAME
-from unique_toolkit.language_model.constants import (
+
+from .constants import (
     DEFAULT_COMPLETE_TEMPERATURE,
     DEFAULT_COMPLETE_TIMEOUT,
 )
-from unique_toolkit.language_model.infos import LanguageModelName
-from unique_toolkit.language_model.schemas import (
+from .infos import LanguageModelName
+from .schemas import (
     LanguageModelMessages,
     LanguageModelResponse,
-    LanguageModelStreamResponse,
     LanguageModelTool,
 )
 
@@ -27,9 +27,9 @@ def complete(
     model_name: LanguageModelName | str,
     temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
     timeout: int = DEFAULT_COMPLETE_TIMEOUT,
-    tools: Optional[list[LanguageModelTool]] = None,
-    other_options: Optional[dict] = None,
-    structured_output_model: Optional[Type[BaseModel]] = None,
+    tools: list[LanguageModelTool] | None = None,
+    other_options: dict | None = None,
+    structured_output_model: Type[BaseModel] | None = None,
     structured_output_enforce_schema: bool = False,
 ) -> LanguageModelResponse:
     """
@@ -80,9 +80,9 @@ async def complete_async(
     model_name: LanguageModelName | str,
     temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
     timeout: int = DEFAULT_COMPLETE_TIMEOUT,
-    tools: Optional[list[LanguageModelTool]] = None,
-    other_options: Optional[dict] = None,
-    structured_output_model: Optional[Type[BaseModel]] = None,
+    tools: list[LanguageModelTool] | None = None,
+    other_options: dict | None = None,
+    structured_output_model: Type[BaseModel] | None = None,
     structured_output_enforce_schema: bool = False,
 ) -> LanguageModelResponse:
     """
@@ -134,142 +134,9 @@ async def complete_async(
         raise e
 
 
-def stream_complete_to_chat(
-    company_id: str,
-    user_id: str,
-    assistant_message_id: str,
-    user_message_id: str,
-    chat_id: str,
-    assistant_id: str,
-    messages: LanguageModelMessages,
-    model_name: LanguageModelName | str,
-    content_chunks: list[ContentChunk] = [],
-    debug_info: dict = {},
-    temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
-    timeout: int = DEFAULT_COMPLETE_TIMEOUT,
-    tools: Optional[list[LanguageModelTool]] = None,
-    start_text: Optional[str] = None,
-    other_options: Optional[dict] = None,
-) -> LanguageModelStreamResponse:
-    """
-    Streams a completion synchronously.
-
-    Args:
-        company_id (str): The company ID associated with the request.
-        user_id (str): The user ID for the request.
-        assistant_message_id (str): The assistant message ID.
-        user_message_id (str): The user message ID.
-        chat_id (str): The chat ID.
-        assistant_id (str): The assistant ID.
-        messages (LanguageModelMessages): The messages to complete.
-        model_name (LanguageModelName | str): The model name.
-        content_chunks (list[ContentChunk]): Content chunks for context.
-        debug_info (dict): Debug information.
-        temperature (float): Temperature setting.
-        timeout (int): Timeout in milliseconds.
-        tools (Optional[list[LanguageModelTool]]): Optional tools.
-        start_text (Optional[str]): Starting text.
-        other_options (Optional[dict]): Additional options.
-
-    Returns:
-        LanguageModelStreamResponse: The streaming response object.
-    """
-    options, model, messages_dict, search_context = _prepare_completion_params_util(
-        messages=messages,
-        model_name=model_name,
-        temperature=temperature,
-        tools=tools,
-        other_options=other_options,
-        content_chunks=content_chunks,
-    )
-
-    try:
-        response = unique_sdk.Integrated.chat_stream_completion(
-            user_id=user_id,
-            company_id=company_id,
-            assistantMessageId=assistant_message_id,
-            userMessageId=user_message_id,
-            messages=cast(
-                list[unique_sdk.Integrated.ChatCompletionRequestMessage],
-                messages_dict,
-            ),
-            chatId=chat_id,
-            searchContext=search_context,
-            model=model,
-            timeout=timeout,
-            assistantId=assistant_id,
-            debugInfo=debug_info,
-            options=options,  # type: ignore
-            startText=start_text,
-        )
-        return LanguageModelStreamResponse(**response)
-    except Exception as e:
-        logger.error(f"Error streaming completion: {e}")
-        raise e
-
-
-async def stream_complete_to_chat_async(
-    company_id: str,
-    user_id: str,
-    assistant_message_id: str,
-    user_message_id: str,
-    chat_id: str,
-    assistant_id: str,
-    messages: LanguageModelMessages,
-    model_name: LanguageModelName | str,
-    content_chunks: list[ContentChunk] = [],
-    debug_info: dict = {},
-    temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
-    timeout: int = DEFAULT_COMPLETE_TIMEOUT,
-    tools: Optional[list[LanguageModelTool]] = None,
-    start_text: Optional[str] = None,
-    other_options: Optional[dict] = None,
-) -> LanguageModelStreamResponse:
-    """
-    Streams a completion asynchronously.
-
-    Args: [same as stream_complete]
-
-    Returns:
-        LanguageModelStreamResponse: The streaming response object.
-    """
-    options, model, messages_dict, search_context = _prepare_completion_params_util(
-        messages=messages,
-        model_name=model_name,
-        temperature=temperature,
-        tools=tools,
-        other_options=other_options,
-        content_chunks=content_chunks,
-    )
-
-    try:
-        response = await unique_sdk.Integrated.chat_stream_completion_async(
-            user_id=user_id,
-            company_id=company_id,
-            assistantMessageId=assistant_message_id,
-            userMessageId=user_message_id,
-            messages=cast(
-                list[unique_sdk.Integrated.ChatCompletionRequestMessage],
-                messages_dict,
-            ),
-            chatId=chat_id,
-            searchContext=search_context,
-            model=model,
-            timeout=timeout,
-            assistantId=assistant_id,
-            debugInfo=debug_info,
-            options=options,  # type: ignore
-            startText=start_text,
-        )
-        return LanguageModelStreamResponse(**response)
-    except Exception as e:
-        logger.error(f"Error streaming completion: {e}")
-        raise e
-
-
 def _add_tools_to_options(
     options: dict,
-    tools: Optional[list[LanguageModelTool]],
+    tools: list[LanguageModelTool] | None,
 ) -> dict:
     if tools:
         options["tools"] = [
@@ -321,12 +188,12 @@ def _prepare_completion_params_util(
     messages: LanguageModelMessages,
     model_name: LanguageModelName | str,
     temperature: float,
-    tools: Optional[list[LanguageModelTool]] = None,
-    other_options: Optional[dict] = None,
-    content_chunks: Optional[list[ContentChunk]] = None,
-    structured_output_model: Optional[Type[BaseModel]] = None,
+    tools: list[LanguageModelTool] | None = None,
+    other_options: dict | None = None,
+    content_chunks: list[ContentChunk] | None = None,
+    structured_output_model: Type[BaseModel] | None = None,
     structured_output_enforce_schema: bool = False,
-) -> tuple[dict, str, dict, Optional[dict]]:
+) -> tuple[dict, str, dict, dict | None]:
     """
     Prepares common parameters for completion requests.
 
@@ -335,7 +202,7 @@ def _prepare_completion_params_util(
         - options (dict): Combined options including tools and temperature
         - model (str): Resolved model name
         - messages_dict (dict): Processed messages
-        - search_context (Optional[dict]): Processed content chunks if provided
+        - search_context (dict | None): Processed content chunks if provided
     """
 
     options = _add_tools_to_options({}, tools)

unique_toolkit/language_model/service.py

@@ -6,7 +6,6 @@ from typing_extensions import deprecated
 
 from unique_toolkit._common.validate_required_values import validate_required_values
 from unique_toolkit.app.schemas import BaseEvent, ChatEvent, Event
-from unique_toolkit.content.schemas import ContentChunk
 from unique_toolkit.language_model.constants import (
     DEFAULT_COMPLETE_TEMPERATURE,
     DEFAULT_COMPLETE_TIMEOUT,
@@ -15,14 +14,11 @@ from unique_toolkit.language_model.constants import (
 from unique_toolkit.language_model.functions import (
     complete,
     complete_async,
-    stream_complete_to_chat,
-    stream_complete_to_chat_async,
 )
 from unique_toolkit.language_model.infos import LanguageModelName
 from unique_toolkit.language_model.schemas import (
     LanguageModelMessages,
     LanguageModelResponse,
-    LanguageModelStreamResponse,
     LanguageModelTool,
 )
 
@@ -36,10 +32,8 @@ class LanguageModelService:
     Args:
         company_id (str | None, optional): The company identifier. Defaults to None.
         user_id (str | None, optional): The user identifier. Defaults to None.
-        assistant_message_id (str | None, optional): The assistant message identifier. Defaults to None.
         chat_id (str | None, optional): The chat identifier. Defaults to None.
         assistant_id (str | None, optional): The assistant identifier. Defaults to None.
-        user_message_id (str | None, optional): The user message identifier. Defaults to None.
     """
 
     def __init__(
@@ -47,16 +41,12 @@ class LanguageModelService:
         event: Event | BaseEvent | None = None,
         company_id: str | None = None,
         user_id: str | None = None,
-        assistant_message_id: str | None = None,
         chat_id: str | None = None,
         assistant_id: str | None = None,
-        user_message_id: str | None = None,
     ):
         self._event = event
         self.company_id = company_id
         self.user_id = user_id
-        self.assistant_message_id = assistant_message_id
-        self.user_message_id = user_message_id
         self.chat_id = chat_id
         self.assistant_id = assistant_id
 
@@ -64,8 +54,6 @@ class LanguageModelService:
             self.company_id = event.company_id
             self.user_id = event.user_id
             if isinstance(event, (ChatEvent, Event)):
-                self.assistant_message_id = event.payload.assistant_message.id
-                self.user_message_id = event.payload.user_message.id
                 self.chat_id = event.payload.chat_id
                 self.assistant_id = event.payload.assistant_id
 
@@ -167,211 +155,3 @@ class LanguageModelService:
             structured_output_model=structured_output_model,
             structured_output_enforce_schema=structured_output_enforce_schema,
         )
-
-    @deprecated("Use stream_complete_to_chat instead")
-    def stream_complete(
-        self,
-        messages: LanguageModelMessages,
-        model_name: LanguageModelName | str,
-        content_chunks: list[ContentChunk] = [],
-        debug_info: dict = {},
-        temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
-        timeout: int = DEFAULT_COMPLETE_TIMEOUT,
-        tools: Optional[list[LanguageModelTool]] = None,
-        start_text: Optional[str] = None,
-        other_options: Optional[dict] = None,
-    ) -> LanguageModelStreamResponse:
-        """
-        Streams a completion in the chat session synchronously.
-        """
-        [
-            company_id,
-            user_id,
-            assistant_message_id,
-            user_message_id,
-            chat_id,
-            assistant_id,
-        ] = validate_required_values(
-            [
-                self.company_id,
-                self.user_id,
-                self.assistant_message_id,
-                self.user_message_id,
-                self.chat_id,
-                self.assistant_id,
-            ]
-        )
-
-        return stream_complete_to_chat(
-            company_id=company_id,
-            user_id=user_id,
-            assistant_message_id=assistant_message_id,
-            user_message_id=user_message_id,
-            chat_id=chat_id,
-            assistant_id=assistant_id,
-            messages=messages,
-            model_name=model_name,
-            content_chunks=content_chunks,
-            debug_info=debug_info,
-            temperature=temperature,
-            timeout=timeout,
-            tools=tools,
-            start_text=start_text,
-            other_options=other_options,
-        )
-
-    def stream_complete_to_chat(
-        self,
-        messages: LanguageModelMessages,
-        model_name: LanguageModelName | str,
-        content_chunks: list[ContentChunk] = [],
-        debug_info: dict = {},
-        temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
-        timeout: int = DEFAULT_COMPLETE_TIMEOUT,
-        tools: Optional[list[LanguageModelTool]] = None,
-        start_text: Optional[str] = None,
-        other_options: Optional[dict] = None,
-    ) -> LanguageModelStreamResponse:
-        """
-        Streams a completion in the chat session synchronously.
-        """
-        [
-            company_id,
-            user_id,
-            assistant_message_id,
-            user_message_id,
-            chat_id,
-            assistant_id,
-        ] = validate_required_values(
-            [
-                self.company_id,
-                self.user_id,
-                self.assistant_message_id,
-                self.user_message_id,
-                self.chat_id,
-                self.assistant_id,
-            ]
-        )
-
-        return stream_complete_to_chat(
-            company_id=company_id,
-            user_id=user_id,
-            assistant_message_id=assistant_message_id,
-            user_message_id=user_message_id,
-            chat_id=chat_id,
-            assistant_id=assistant_id,
-            messages=messages,
-            model_name=model_name,
-            content_chunks=content_chunks,
-            debug_info=debug_info,
-            temperature=temperature,
-            timeout=timeout,
-            tools=tools,
-            start_text=start_text,
-            other_options=other_options,
-        )
-
-    @deprecated("Use stream_complete_to_chat_async instead")
-    async def stream_complete_async(
-        self,
-        messages: LanguageModelMessages,
-        model_name: LanguageModelName | str,
-        content_chunks: list[ContentChunk] = [],
-        debug_info: dict = {},
-        temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
-        timeout: int = DEFAULT_COMPLETE_TIMEOUT,
-        tools: Optional[list[LanguageModelTool]] = None,
-        start_text: Optional[str] = None,
-        other_options: Optional[dict] = None,
-    ) -> LanguageModelStreamResponse:
-        """
-        Streams a completion in the chat session asynchronously.
-        """
-
-        [
-            company_id,
-            user_id,
-            assistant_message_id,
-            user_message_id,
-            chat_id,
-            assistant_id,
-        ] = validate_required_values(
-            [
-                self.company_id,
-                self.user_id,
-                self.assistant_message_id,
-                self.user_message_id,
-                self.chat_id,
-                self.assistant_id,
-            ]
-        )
-
-        return await stream_complete_to_chat_async(
-            company_id=company_id,
-            user_id=user_id,
-            assistant_message_id=assistant_message_id,
-            user_message_id=user_message_id,
-            chat_id=chat_id,
-            assistant_id=assistant_id,
-            messages=messages,
-            model_name=model_name,
-            content_chunks=content_chunks,
-            debug_info=debug_info,
-            temperature=temperature,
-            timeout=timeout,
-            tools=tools,
-            start_text=start_text,
-            other_options=other_options,
-        )
-
-    async def stream_complete_to_chat_async(
-        self,
-        messages: LanguageModelMessages,
-        model_name: LanguageModelName | str,
-        content_chunks: list[ContentChunk] = [],
-        debug_info: dict = {},
-        temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
-        timeout: int = DEFAULT_COMPLETE_TIMEOUT,
-        tools: Optional[list[LanguageModelTool]] = None,
-        start_text: Optional[str] = None,
-        other_options: Optional[dict] = None,
-    ) -> LanguageModelStreamResponse:
-        """
-        Streams a completion in the chat session asynchronously.
-        """
-
-        [
-            company_id,
-            user_id,
-            assistant_message_id,
-            user_message_id,
-            chat_id,
-            assistant_id,
-        ] = validate_required_values(
-            [
-                self.company_id,
-                self.user_id,
-                self.assistant_message_id,
-                self.user_message_id,
-                self.chat_id,
-                self.assistant_id,
-            ]
-        )
-
-        return await stream_complete_to_chat_async(
-            company_id=company_id,
-            user_id=user_id,
-            assistant_message_id=assistant_message_id,
-            user_message_id=user_message_id,
-            chat_id=chat_id,
-            assistant_id=assistant_id,
-            messages=messages,
-            model_name=model_name,
-            content_chunks=content_chunks,
-            debug_info=debug_info,
-            temperature=temperature,
-            timeout=timeout,
-            tools=tools,
-            start_text=start_text,
-            other_options=other_options,
-        )

{unique_toolkit-0.6.0.dist-info → unique_toolkit-0.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unique_toolkit
-Version: 0.6.0
+Version: 0.6.1
 Summary: 
 License: Proprietary
 Author: Martin Fadler
@@ -55,7 +55,7 @@ The `unique_toolkit.app` module encompasses functions for initializing and secur
 The `unique_toolkit.chat` module encompasses all chat related functionality.
 
 - `functions.py` comprises the functions to manage and load the chat history and interact with the chat ui, e.g., creating a new assistant message.
-- `service.py` comprises the ChatService and provides an interface to manage and load the chat history and interact with the chat ui, e.g., creating a new assistant message.
+- `service.py` comprises the ChatService and provides an interface to manage and load the chat history and interact with the chat ui, e.g., creating a new assistant message and stream complete.
 - `schemas.py` comprises all relevant schemas, e.g., ChatMessage, used in the ChatService.
 - `utils.py` comprises utility functions to use and convert ChatMessage objects in assistants, e.g., convert_chat_history_to_injectable_string converts the chat history to a string that can be injected into a prompt. 
 
@@ -83,7 +83,7 @@ Unique platform.
 
 - `infos.py` comprises the information on all language models deployed through the Unique platform. We recommend to use the LanguageModel class, initialized with the LanguageModelName, e.g., LanguageModel(LanguageModelName.AZURE_GPT_35_TURBO_0125) to get the information on the specific language model like the name, version, token limits or retirement date.
 - `functions.py` comprises the functions to complete and stream complete to chat.
-- `service.py` comprises the LanguageModelService and provides an interface to interact with the language models, e.g., complete or stream_complete. 
+- `service.py` comprises the LanguageModelService and provides an interface to interact with the language models, e.g., complete. 
 - `schemas.py` comprises all relevant schemas, e.g., LanguageModelResponse, used in the LanguageModelService.
 - `utils.py` comprises utility functions to parse the output of the language model, e.g., convert_string_to_json finds and parses the last json object in a string.
 
@@ -111,6 +111,10 @@ 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.6.1] - 2025-02-25
+- [BREAKING] `LanguageModelService.stream_complete` and `LanguageModelService.stream_complete_async` are now moved to `ChatService.stream_complete` and `ChatService.stream_complete_async`. Correspondingly `assistant_message_id` and `user_message_id` are removed from `LanguageModelService`.
+- Add `create_user_message` and `create_user_message_async` to `ChatService` (similar to `create_assistant_message` and `create_assistant_message_async`)
+
 ## [0.6.0] - 2025-02-21
 - make for each domain, its base functionality accessible from `functions.py`
 - make it possible to instantiate the domain services directly from different event types, inhereted from common `BaseEvent`

{unique_toolkit-0.6.0.dist-info → unique_toolkit-0.6.1.dist-info}/RECORD

@@ -13,9 +13,9 @@ unique_toolkit/app/schemas.py,sha256=hPOh5xLNNWgWVIkdrj6ZHYaGz0cTV-5Kv7OQHOaUgV8
 unique_toolkit/app/verification.py,sha256=mffa6wm0i4hJbwzofePrkaia46xumMzECwQ0T3eKAx0,1929
 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=CtlvrwYWUQ7_wSQyAXf8jnARv0P-Ffh1gx2JJzISvvI,22231
+unique_toolkit/chat/functions.py,sha256=J9Cmgkhj9bBxZja3ggkSp48af_LPU4Dfi9Sbc_WhhNY,27204
 unique_toolkit/chat/schemas.py,sha256=MNcGAXjK1K8zOODeMFz3FHVQL5sIBQXRwkr_2hFkG8k,2672
-unique_toolkit/chat/service.py,sha256=abBHpPonQYA408c_Z-WNmnROzMmYNUL55D6ek3iDubI,22048
+unique_toolkit/chat/service.py,sha256=SoFeaOi0BTexhiyX6busui_7JjhlRu30YNiKdgwV3JQ,29127
 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
@@ -47,18 +47,18 @@ unique_toolkit/evaluators/schemas.py,sha256=Jaue6Uhx75X1CyHKWj8sT3RE1JZXTqoLtfLt
 unique_toolkit/language_model/__init__.py,sha256=jWko_vQj48wjnpTtlkg8iNdef0SMI3FN2kGywXRTMzg,1880
 unique_toolkit/language_model/builder.py,sha256=nsRqWO_2dgFehK5CgtqR5aqXgYUU0QL6mR0lALPrQXM,1898
 unique_toolkit/language_model/constants.py,sha256=B-topqW0r83dkC_25DeQfnPk3n53qzIHUCBS7YJ0-1U,119
-unique_toolkit/language_model/functions.py,sha256=Gvf7nYwfNvkER59KVGursOvvZj5uYBFgxQyG9fHRBJQ,12677
+unique_toolkit/language_model/functions.py,sha256=I5jHhHsKoq7GwEQyTrM8LXB2n_6dvMAk7UklenjuHSY,7945
 unique_toolkit/language_model/infos.py,sha256=NgoV05ausVWMqrYqgH6i3s7tYG7mejupROIF_bwEGZo,13050
 unique_toolkit/language_model/prompt.py,sha256=JSawaLjQg3VR-E2fK8engFyJnNdk21zaO8pPIodzN4Q,3991
 unique_toolkit/language_model/schemas.py,sha256=87511yupvea-U6sfKWfelETevNMVPevhj7mEqX5FszU,7461
-unique_toolkit/language_model/service.py,sha256=IQamCLVL-k4-YifgGpwhvlPwZ81EQRpBI6eMK176ciU,12967
+unique_toolkit/language_model/service.py,sha256=GupYD4uDZjy1TfVQW3jichmgQwiSgQCj350FtL4O0W4,5569
 unique_toolkit/language_model/utils.py,sha256=bPQ4l6_YO71w-zaIPanUUmtbXC1_hCvLK0tAFc3VCRc,1902
 unique_toolkit/short_term_memory/__init__.py,sha256=2mI3AUrffgH7Yt-xS57EGqnHf7jnn6xquoKEhJqk3Wg,185
 unique_toolkit/short_term_memory/constants.py,sha256=698CL6-wjup2MvU19RxSmQk3gX7aqW_OOpZB7sbz_Xg,34
 unique_toolkit/short_term_memory/functions.py,sha256=3WiK-xatY5nh4Dr5zlDUye1k3E6kr41RiscwtTplw5k,4484
 unique_toolkit/short_term_memory/schemas.py,sha256=OhfcXyF6ACdwIXW45sKzjtZX_gkcJs8FEZXcgQTNenw,1406
 unique_toolkit/short_term_memory/service.py,sha256=gdsVzoNqTXmLoBR_-p_lJlZDBo8L7Cr5EKchTNVJg1Q,5233
-unique_toolkit-0.6.0.dist-info/LICENSE,sha256=GlN8wHNdh53xwOPg44URnwag6TEolCjoq3YD_KrWgss,193
-unique_toolkit-0.6.0.dist-info/METADATA,sha256=glSKhyn4h1sfvzWEDmJ1WBYYtXVwCs823B5HACP_ZJY,18600
-unique_toolkit-0.6.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-unique_toolkit-0.6.0.dist-info/RECORD,,
+unique_toolkit-0.6.1.dist-info/LICENSE,sha256=GlN8wHNdh53xwOPg44URnwag6TEolCjoq3YD_KrWgss,193
+unique_toolkit-0.6.1.dist-info/METADATA,sha256=HE5Tg7WWNCSsaU4O0VirvkILqvxRdHtNnfsbbu_S3Z8,19071
+unique_toolkit-0.6.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+unique_toolkit-0.6.1.dist-info/RECORD,,