unique_toolkit 0.7.9__py3-none-any.whl → 1.33.3__py3-none-any.whl

unique_toolkit/language_model/service.py

@@ -1,11 +1,13 @@
 import logging
-from typing import Optional, Type
+from typing import Any, Optional, Type, overload
 
 from pydantic import BaseModel
 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.app.unique_settings import UniqueSettings
+from unique_toolkit.content.schemas import ContentChunk
 from unique_toolkit.language_model.constants import (
     DEFAULT_COMPLETE_TEMPERATURE,
     DEFAULT_COMPLETE_TIMEOUT,
@@ -14,12 +16,16 @@ from unique_toolkit.language_model.constants import (
 from unique_toolkit.language_model.functions import (
     complete,
     complete_async,
+    complete_with_references,
+    complete_with_references_async,
 )
 from unique_toolkit.language_model.infos import LanguageModelName
 from unique_toolkit.language_model.schemas import (
     LanguageModelMessages,
     LanguageModelResponse,
+    LanguageModelStreamResponse,
     LanguageModelTool,
+    LanguageModelToolDescription,
 )
 
 logger = logging.getLogger(f"toolkit.{DOMAIN_NAME}.{__name__}")
@@ -28,34 +34,73 @@ logger = logging.getLogger(f"toolkit.{DOMAIN_NAME}.{__name__}")
 class LanguageModelService:
     """
     Provides methods to interact with the Language Model by generating responses.
+    """
+
+    @deprecated(
+        "Use __init__ with company_id and user_id instead or use the classmethod `from_event`"
+    )
+    @overload
+    def __init__(self, event: Event | ChatEvent | BaseEvent): ...
 
-    Args:
-        company_id (str | None, optional): The company identifier. Defaults to None.
-        user_id (str | None, optional): The user 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.
+    """
+        Initialize the LanguageModelService with an event (deprecated)
+    """
+
+    @overload
+    def __init__(self, *, company_id: str, user_id: str): ...
+
+    """
+        Initialize the LanguageModelService with a company_id and user_id.
     """
 
     def __init__(
         self,
-        event: Event | BaseEvent | None = None,
+        event: Event | ChatEvent | BaseEvent | None = None,
         company_id: str | None = None,
         user_id: str | None = None,
-        chat_id: str | None = None,
-        assistant_id: str | None = None,
+        **kwargs: dict[str, Any],  # only here for backward compatibility
     ):
-        self._event = event
-        self.company_id = company_id
-        self.user_id = user_id
-        self.chat_id = chat_id
-        self.assistant_id = assistant_id
-
-        if event:
-            self.company_id = event.company_id
-            self.user_id = event.user_id
-            if isinstance(event, (ChatEvent, Event)):
-                self.chat_id = event.payload.chat_id
-                self.assistant_id = event.payload.assistant_id
+        if isinstance(event, (ChatEvent, Event)):
+            self._event = event
+            self._chat_id = event.payload.chat_id
+            self._assistant_id = event.payload.assistant_id
+            self._company_id = event.company_id
+            self._user_id = event.user_id
+        elif isinstance(event, BaseEvent):
+            self._event = event
+            self._company_id = event.company_id
+            self._user_id = event.user_id
+            self._chat_id = None
+            self._assistant_id = None
+        else:
+            [company_id, user_id] = validate_required_values([company_id, user_id])
+            self._event = None
+            self._company_id: str = company_id
+            self._user_id: str = user_id
+            self._chat_id: str | None = None
+            self._assistant_id: str | None = None
+
+    @classmethod
+    def from_event(cls, event: BaseEvent):
+        """
+        Initialize the LanguageModelService with an event.
+        """
+        return cls(company_id=event.company_id, user_id=event.user_id)
+
+    @classmethod
+    def from_settings(cls, settings: UniqueSettings | str | None = None):
+        """
+        Initialize the LanguageModelService with a settings object.
+        """
+        if settings is None:
+            settings = UniqueSettings.from_env_auto_with_sdk_init()
+        elif isinstance(settings, str):
+            settings = UniqueSettings.from_env_auto_with_sdk_init(filename=settings)
+
+        return cls(
+            company_id=settings.auth.company_id.get_secret_value(),
+            user_id=settings.auth.user_id.get_secret_value(),
+        )
 
     @property
     @deprecated(
@@ -70,13 +115,117 @@ class LanguageModelService:
         """
         return self._event
 
+    @property
+    @deprecated(
+        "The company_id property is deprecated and will be removed in a future version."
+    )
+    def company_id(self) -> str | None:
+        """
+        Get the company identifier (deprecated).
+
+        Returns:
+            str | None: The company identifier.
+        """
+        return self._company_id
+
+    @company_id.setter
+    @deprecated(
+        "The company_id setter is deprecated and will be removed in a future version."
+    )
+    def company_id(self, value: str) -> None:
+        """
+        Set the company identifier (deprecated).
+
+        Args:
+            value (str | None): The company identifier.
+        """
+        self._company_id = value
+
+    @property
+    @deprecated(
+        "The user_id property is deprecated and will be removed in a future version."
+    )
+    def user_id(self) -> str | None:
+        """
+        Get the user identifier (deprecated).
+
+        Returns:
+            str | None: The user identifier.
+        """
+        return self._user_id
+
+    @user_id.setter
+    @deprecated(
+        "The user_id setter is deprecated and will be removed in a future version."
+    )
+    def user_id(self, value: str) -> None:
+        """
+        Set the user identifier (deprecated).
+
+        Args:
+            value (str | None): The user identifier.
+        """
+        self._user_id = value
+
+    @property
+    @deprecated(
+        "The chat_id property is deprecated and will be removed in a future version."
+    )
+    def chat_id(self) -> str | None:
+        """
+        Get the chat identifier (deprecated).
+
+        Returns:
+            str | None: The chat identifier.
+        """
+        return self._chat_id
+
+    @chat_id.setter
+    @deprecated(
+        "The chat_id setter is deprecated and will be removed in a future version."
+    )
+    def chat_id(self, value: str | None) -> None:
+        """
+        Set the chat identifier (deprecated).
+
+        Args:
+            value (str | None): The chat identifier.
+        """
+        self._chat_id = value
+
+    @property
+    @deprecated(
+        "The assistant_id property is deprecated and will be removed in a future version."
+    )
+    def assistant_id(self) -> str | None:
+        """
+        Get the assistant identifier (deprecated).
+
+        Returns:
+            str | None: The assistant identifier.
+        """
+        return self._assistant_id
+
+    @assistant_id.setter
+    @deprecated(
+        "The assistant_id setter is deprecated and will be removed in a future version."
+    )
+    def assistant_id(self, value: str | None) -> None:
+        """
+        Set the assistant identifier (deprecated).
+
+        Args:
+            value (str | None): The assistant identifier.
+        """
+        self._assistant_id = value
+
     def complete(
         self,
         messages: LanguageModelMessages,
         model_name: LanguageModelName | str,
         temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
         timeout: int = DEFAULT_COMPLETE_TIMEOUT,
-        tools: Optional[list[LanguageModelTool]] = None,
+        tools: Optional[list[LanguageModelTool | LanguageModelToolDescription]] = None,
         structured_output_model: Optional[Type[BaseModel]] = None,
         structured_output_enforce_schema: bool = False,
         other_options: Optional[dict] = None,
@@ -84,10 +233,10 @@ class LanguageModelService:
         """
         Calls the completion endpoint synchronously without streaming the response.
         """
-        [company_id] = validate_required_values([self.company_id])
 
         return complete(
-            company_id=company_id,
+            company_id=self._company_id,
+            user_id=self._user_id,
             messages=messages,
             model_name=model_name,
             temperature=temperature,
@@ -104,7 +253,7 @@ class LanguageModelService:
         model_name: LanguageModelName | str,
         temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
         timeout: int = DEFAULT_COMPLETE_TIMEOUT,
-        tools: Optional[list[LanguageModelTool]] = None,
+        tools: Optional[list[LanguageModelTool | LanguageModelToolDescription]] = None,
         structured_output_model: Optional[Type[BaseModel]] = None,
         structured_output_enforce_schema: bool = False,
         other_options: Optional[dict] = None,
@@ -112,10 +261,10 @@ class LanguageModelService:
         """
         Calls the completion endpoint asynchronously without streaming the response.
         """
-        [company_id] = validate_required_values([self.company_id])
 
         return await complete_async(
-            company_id=company_id,
+            company_id=self._company_id,
+            user_id=self._user_id,
             messages=messages,
             model_name=model_name,
             temperature=temperature,
@@ -133,9 +282,10 @@ class LanguageModelService:
         company_id: str,
         messages: LanguageModelMessages,
         model_name: LanguageModelName | str,
+        user_id: str | None = None,
         temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
         timeout: int = DEFAULT_COMPLETE_TIMEOUT,
-        tools: Optional[list[LanguageModelTool]] = None,
+        tools: Optional[list[LanguageModelTool | LanguageModelToolDescription]] = None,
         structured_output_model: Optional[Type[BaseModel]] = None,
         structured_output_enforce_schema: bool = False,
         other_options: Optional[dict] = None,
@@ -146,6 +296,7 @@ class LanguageModelService:
 
         return await complete_async(
             company_id=company_id,
+            user_id=user_id,
             messages=messages,
             model_name=model_name,
             temperature=temperature,
@@ -155,3 +306,53 @@ class LanguageModelService:
             structured_output_model=structured_output_model,
             structured_output_enforce_schema=structured_output_enforce_schema,
         )
+
+    def complete_with_references(
+        self,
+        messages: LanguageModelMessages,
+        model_name: LanguageModelName | str,
+        content_chunks: list[ContentChunk] | None = None,
+        debug_info: dict = {},
+        temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
+        timeout: int = DEFAULT_COMPLETE_TIMEOUT,
+        tools: list[LanguageModelTool | LanguageModelToolDescription] | None = None,
+        start_text: str | None = None,
+        other_options: dict[str, Any] | None = None,
+    ) -> LanguageModelStreamResponse:
+        return complete_with_references(
+            company_id=self._company_id,
+            user_id=self._user_id,
+            messages=messages,
+            model_name=model_name,
+            content_chunks=content_chunks,
+            temperature=temperature,
+            timeout=timeout,
+            other_options=other_options,
+            tools=tools,
+            start_text=start_text,
+        )
+
+    async def complete_with_references_async(
+        self,
+        messages: LanguageModelMessages,
+        model_name: LanguageModelName | str,
+        content_chunks: list[ContentChunk] | None = None,
+        debug_info: dict = {},
+        temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
+        timeout: int = DEFAULT_COMPLETE_TIMEOUT,
+        tools: list[LanguageModelTool | LanguageModelToolDescription] | None = None,
+        start_text: str | None = None,
+        other_options: dict[str, Any] | None = None,
+    ) -> LanguageModelStreamResponse:
+        return await complete_with_references_async(
+            company_id=self._company_id,
+            user_id=self._user_id,
+            messages=messages,
+            model_name=model_name,
+            content_chunks=content_chunks,
+            temperature=temperature,
+            timeout=timeout,
+            other_options=other_options,
+            tools=tools,
+            start_text=start_text,
+        )

unique_toolkit/protocols/support.py

@@ -0,0 +1,145 @@
+from typing import Awaitable, Protocol, Sequence
+
+from openai.types.chat import (
+    ChatCompletionMessageParam,
+    ChatCompletionToolChoiceOptionParam,
+)
+from openai.types.responses import (
+    ResponseIncludable,
+    ResponseInputItemParam,
+    ResponseOutputItem,
+    ResponseTextConfigParam,
+    ToolParam,
+    response_create_params,
+)
+from openai.types.shared_params import Metadata, Reasoning
+
+from unique_toolkit.content import ContentChunk
+from unique_toolkit.language_model import (
+    LanguageModelMessages,
+    LanguageModelName,
+    LanguageModelResponse,
+    LanguageModelStreamResponse,
+    LanguageModelTool,
+    LanguageModelToolDescription,
+)
+from unique_toolkit.language_model.constants import (
+    DEFAULT_COMPLETE_TEMPERATURE,
+    DEFAULT_COMPLETE_TIMEOUT,
+)
+from unique_toolkit.language_model.schemas import (
+    LanguageModelMessageOptions,
+    ResponsesLanguageModelStreamResponse,
+)
+
+# As soon as we have multiple, remember
+# https://pypi.org/project/typing-protocol-intersection/
+# to generate combinations of protocols without inheritance
+
+
+class SupportsComplete(Protocol):
+    def complete(
+        self,
+        messages: LanguageModelMessages,
+        model_name: LanguageModelName | str,
+        temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
+        timeout: int = DEFAULT_COMPLETE_TIMEOUT,
+        tools: list[LanguageModelTool | LanguageModelToolDescription] | None = None,
+    ) -> LanguageModelResponse: ...
+
+    async def complete_async(
+        self,
+        messages: LanguageModelMessages,
+        model_name: LanguageModelName | str,
+        temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
+        timeout: int = DEFAULT_COMPLETE_TIMEOUT,
+        tools: Sequence[LanguageModelTool | LanguageModelToolDescription] | None = None,
+    ) -> Awaitable[LanguageModelResponse]: ...
+
+
+class SupportCompleteWithReferences(Protocol):
+    def complete_with_references(
+        self,
+        messages: LanguageModelMessages,
+        model_name: LanguageModelName | str,
+        content_chunks: list[ContentChunk] | None = None,
+        debug_info: dict | None = None,
+        temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
+        timeout: int = DEFAULT_COMPLETE_TIMEOUT,
+        tools: Sequence[LanguageModelTool | LanguageModelToolDescription] | None = None,
+        start_text: str | None = None,
+        tool_choice: ChatCompletionToolChoiceOptionParam | None = None,
+        other_options: dict | None = None,
+    ) -> LanguageModelStreamResponse: ...
+
+    async def complete_with_references_async(
+        self,
+        messages: LanguageModelMessages | list[ChatCompletionMessageParam],
+        model_name: LanguageModelName | str,
+        content_chunks: list[ContentChunk] | None = None,
+        debug_info: dict | None = None,
+        temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
+        timeout: int = DEFAULT_COMPLETE_TIMEOUT,
+        tools: Sequence[LanguageModelTool | LanguageModelToolDescription] | None = None,
+        tool_choice: ChatCompletionToolChoiceOptionParam | None = None,
+        start_text: str | None = None,
+        other_options: dict | None = None,
+    ) -> LanguageModelStreamResponse: ...
+
+
+class ResponsesSupportCompleteWithReferences(Protocol):
+    def complete_with_references(
+        self,
+        *,
+        model_name: LanguageModelName | str,
+        messages: str
+        | LanguageModelMessages
+        | Sequence[
+            ResponseInputItemParam
+            | LanguageModelMessageOptions
+            | ResponseOutputItem  # History is automatically convertible
+        ],
+        content_chunks: list[ContentChunk] | None = None,
+        tools: Sequence[LanguageModelToolDescription | ToolParam] | None = None,
+        temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
+        debug_info: dict | None = None,
+        start_text: str | None = None,
+        include: list[ResponseIncludable] | None = None,
+        instructions: str | None = None,
+        max_output_tokens: int | None = None,
+        metadata: Metadata | None = None,
+        parallel_tool_calls: bool | None = None,
+        text: ResponseTextConfigParam | None = None,
+        tool_choice: response_create_params.ToolChoice | None = None,
+        top_p: float | None = None,
+        reasoning: Reasoning | None = None,
+        other_options: dict | None = None,
+    ) -> ResponsesLanguageModelStreamResponse: ...
+
+    async def complete_with_references_async(
+        self,
+        *,
+        model_name: LanguageModelName | str,
+        messages: str
+        | LanguageModelMessages
+        | Sequence[
+            ResponseInputItemParam
+            | LanguageModelMessageOptions
+            | ResponseOutputItem  # History is automatically convertible
+        ],
+        content_chunks: list[ContentChunk] | None = None,
+        tools: Sequence[LanguageModelToolDescription | ToolParam] | None = None,
+        temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
+        debug_info: dict | None = None,
+        start_text: str | None = None,
+        include: list[ResponseIncludable] | None = None,
+        instructions: str | None = None,
+        max_output_tokens: int | None = None,
+        metadata: Metadata | None = None,
+        parallel_tool_calls: bool | None = None,
+        text: ResponseTextConfigParam | None = None,
+        tool_choice: response_create_params.ToolChoice | None = None,
+        top_p: float | None = None,
+        reasoning: Reasoning | None = None,
+        other_options: dict | None = None,
+    ) -> ResponsesLanguageModelStreamResponse: ...

unique_toolkit/services/__init__.py

@@ -0,0 +1,7 @@
+from unique_toolkit.services.chat_service import ChatService
+from unique_toolkit.services.knowledge_base import KnowledgeBaseService
+
+__all__ = [
+    "ChatService",
+    "KnowledgeBaseService",
+]