unique_toolkit 0.6.0__py3-none-any.whl → 0.6.2__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/evaluators/config.py

@@ -25,7 +25,7 @@ class EvaluationMetricConfig(BaseModel):
     enabled: bool = False
     name: EvaluationMetricName
     language_model: LanguageModel = LanguageModel(
-        LanguageModelName.AZURE_GPT_35_TURBO_0613
+        LanguageModelName.AZURE_GPT_35_TURBO_0125
     )
     custom_prompts: dict[str, str] = {}
     score_to_emoji: dict[str, str] = {}

unique_toolkit/evaluators/context_relevancy/constants.py

@@ -23,7 +23,7 @@ context_relevancy_required_input_fields = [
 default_config = EvaluationMetricConfig(
     enabled=False,
     name=EvaluationMetricName.CONTEXT_RELEVANCY,
-    language_model=LanguageModel(LanguageModelName.AZURE_GPT_35_TURBO_0613),
+    language_model=LanguageModel(LanguageModelName.AZURE_GPT_35_TURBO_0125),
     score_to_emoji={"LOW": "🟢", "MEDIUM": "🟡", "HIGH": "🔴"},
     custom_prompts={
         SYSTEM_MSG_KEY: CONTEXT_RELEVANCY_METRIC_SYSTEM_MSG,

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)