unique_toolkit 1.59.0__tar.gz → 1.59.1__tar.gz

{unique_toolkit-1.59.0 → unique_toolkit-1.59.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-toolkit
-Version: 1.59.0
+Version: 1.59.1
 Summary: 
 Author: Cedric Klinkert, Martin Fadler, Sadique Sheik, Fabian Schläpfer, Pascal Hauri, Ejiroghene Oki-Peter, Rami Azouz, Ricardo Visini, Sanzio Monti
 Author-email: Cedric Klinkert <cedric.klinkert@unique.ch>, Martin Fadler <martin.fadler@unique.ch>, Sadique Sheik <sadique@unique.ch>, Fabian Schläpfer <fabian@unique.ch>, Pascal Hauri <pascal@unique.ch>, Ejiroghene Oki-Peter <oki-peter.ejiroghene@unique.ai>, Rami Azouz <rami.ext@unique.ch>, Ricardo Visini <ricardo.visini@unique.ch>, Sanzio Monti <sanzio.monti@unique.ai>

{unique_toolkit-1.59.0 → unique_toolkit-1.59.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_toolkit"
-version = "1.59.0"
+version = "1.59.1"
 description = ""
 readme = "README.md"
 requires-python = ">=3.12"

{unique_toolkit-1.59.0 → unique_toolkit-1.59.1}/unique_toolkit/agentic/history_manager/loop_token_reducer.py

@@ -14,7 +14,7 @@ from unique_toolkit.agentic.history_manager.history_construction_with_contents i
 )
 from unique_toolkit.agentic.reference_manager.reference_manager import ReferenceManager
 from unique_toolkit.app.schemas import ChatEvent
-from unique_toolkit.chat.service import ChatService
+from unique_toolkit.app.unique_settings import UniqueSettings
 from unique_toolkit.content.schemas import ContentChunk
 from unique_toolkit.content.service import ContentService
 from unique_toolkit.language_model.schemas import (
@@ -26,6 +26,7 @@ from unique_toolkit.language_model.schemas import (
     LanguageModelToolMessage,
     LanguageModelUserMessage,
 )
+from unique_toolkit.services.factory import UniqueServiceFactory
 
 MAX_INPUT_TOKENS_SAFETY_PERCENTAGE = (
     0.1  # 10% safety margin for input tokens we need 10% less does not work.
@@ -59,7 +60,9 @@ class LoopTokenReducer:
         self._reference_manager = reference_manager
         self._language_model = language_model
         self._encoder = self._get_encoder(language_model)
-        self._chat_service = ChatService(event)
+        self._chat_service = UniqueServiceFactory(
+            settings=UniqueSettings.from_chat_event(event)
+        ).chat_service()
         self._content_service = ContentService.from_event(event)
         self._user_message = event.payload.user_message
         self._chat_id = event.payload.chat_id

{unique_toolkit-1.59.0 → unique_toolkit-1.59.1}/unique_toolkit/agentic/tools/tool.py

@@ -1,6 +1,8 @@
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
 from logging import getLogger
-from typing import Any, Generic, TypeVar, cast
+from typing import TYPE_CHECKING, Any, Generic, TypeVar, cast
 
 from typing_extensions import deprecated
 
@@ -14,10 +16,12 @@ from unique_toolkit.agentic.tools.schemas import (
 )
 from unique_toolkit.agentic.tools.tool_progress_reporter import ToolProgressReporter
 from unique_toolkit.app.schemas import ChatEvent
-from unique_toolkit.chat.service import (
-    ChatService,
-)
+from unique_toolkit.app.unique_settings import UniqueSettings
 from unique_toolkit.language_model import LanguageModelToolDescription
+from unique_toolkit.services.factory import UniqueServiceFactory
+
+if TYPE_CHECKING:
+    from unique_toolkit.services.chat_service import ChatService
 from unique_toolkit.language_model.schemas import (
     LanguageModelFunction,
 )
@@ -180,7 +184,9 @@ class Tool(ABC, Generic[ConfigType]):
             tool_progress_reporter
         )
 
-        self._chat_service = ChatService(event)
+        self._chat_service = UniqueServiceFactory(
+            settings=UniqueSettings.from_chat_event(event)
+        ).chat_service()
         self._language_model_service = LanguageModelService(event)
         self._message_step_logger = MessageStepLogger(
             chat_service=self._chat_service,

{unique_toolkit-1.59.0 → unique_toolkit-1.59.1}/unique_toolkit/app/unique_settings.py

@@ -3,19 +3,26 @@ from __future__ import annotations
 import os
 from logging import getLogger
 from pathlib import Path
-from typing import TYPE_CHECKING, Self, TypeVar
+from typing import TYPE_CHECKING, Any, Self, TypeVar
 from urllib.parse import ParseResult, urlparse, urlunparse
 
 import unique_sdk
 from platformdirs import user_config_dir
-from pydantic import AliasChoices, BaseModel, Field, SecretStr, model_validator
+from pydantic import (
+    AliasChoices,
+    BaseModel,
+    Field,
+    PrivateAttr,
+    SecretStr,
+    model_validator,
+)
 from pydantic_settings import BaseSettings, SettingsConfigDict
 from typing_extensions import Protocol, deprecated
 
 from unique_toolkit._common.config_checker import register_config
 
 if TYPE_CHECKING:
-    from unique_toolkit.app.schemas import BaseEvent
+    from unique_toolkit.app.schemas import BaseEvent, ChatEvent
 
 
 logger = getLogger(__name__)
@@ -63,6 +70,13 @@ class AuthContext(BaseModel):
     def get_confidential_user_id(self) -> str:
         return self.user_id.get_secret_value()
 
+    @classmethod
+    def from_event(cls, event: BaseEvent) -> Self:
+        return cls(
+            company_id=SecretStr(event.company_id),
+            user_id=SecretStr(event.user_id),
+        )
+
 
 @register_config()
 class UniqueAuth(BaseSettings):
@@ -100,7 +114,7 @@ class UniqueAuth(BaseSettings):
         return warn_about_defaults(self)
 
     @classmethod
-    def from_event(cls, event: "BaseEvent") -> Self:
+    def from_event(cls, event: BaseEvent) -> Self:
         return cls(
             company_id=SecretStr(event.company_id),
             user_id=SecretStr(event.user_id),
@@ -114,19 +128,110 @@ class UniqueAuth(BaseSettings):
 
 
 # Chat
-# BaseModel only as only obtained from a request.
 class ChatContextProtocol(Protocol):
     chat_id: str
     assistant_id: str
-    last_assistant_message_id: str
+
+    @property
+    def last_assistant_message_id(self) -> str: ...
+    @property
+    def last_user_message_id(self) -> str: ...
+    @property
+    def last_user_message_text(self) -> str: ...
+
+    @property
+    def metadata_filter(self) -> dict[str, Any] | None: ...
+    @property
+    def parent_chat_id(self) -> str | None: ...
 
 
 class ChatContext(BaseModel):
     chat_id: str = Field(..., description="The chat ID.")
     assistant_id: str = Field(..., description="The assistant ID.")
-    last_assistant_message_id: str = Field(
-        ..., description="The last assistant message ID."
-    )
+
+    _last_assistant_message_id: str | None = PrivateAttr(default=None)
+    _last_user_message_id: str | None = PrivateAttr(default=None)
+    _last_user_message_text: str | None = PrivateAttr(default=None)
+    _metadata_filter: dict[str, Any] | None = PrivateAttr(default=None)
+    _parent_chat_id: str | None = PrivateAttr(default=None)
+
+    def __init__(
+        self,
+        *,
+        chat_id: str,
+        assistant_id: str,
+        last_assistant_message_id: str | None = None,
+        last_user_message_id: str | None = None,
+        last_user_message_text: str | None = None,
+        metadata_filter: dict[str, Any] | None = None,
+        parent_chat_id: str | None = None,
+        **data: Any,
+    ) -> None:
+        super().__init__(chat_id=chat_id, assistant_id=assistant_id, **data)
+        if last_assistant_message_id is not None:
+            self._last_assistant_message_id = last_assistant_message_id
+        if last_user_message_id is not None:
+            self._last_user_message_id = last_user_message_id
+        if last_user_message_text is not None:
+            self._last_user_message_text = last_user_message_text
+        if metadata_filter is not None:
+            self._metadata_filter = metadata_filter
+        if parent_chat_id is not None:
+            self._parent_chat_id = parent_chat_id
+
+    @property
+    def last_assistant_message_id(self) -> str:
+        if self._last_assistant_message_id is None:
+            raise ValueError("Last assistant message id is not set")
+        return self._last_assistant_message_id
+
+    @property
+    def last_user_message_id(self) -> str:
+        if self._last_user_message_id is None:
+            raise ValueError("User message id is not set")
+        return self._last_user_message_id
+
+    @property
+    def last_user_message_text(self) -> str:
+        if self._last_user_message_text is None:
+            raise ValueError("User message text is not set")
+        return self._last_user_message_text
+
+    @property
+    def metadata_filter(self) -> dict[str, Any] | None:
+        return self._metadata_filter
+
+    @metadata_filter.setter
+    def metadata_filter(self, value: dict[str, Any]) -> None:
+        self._metadata_filter = value
+
+    @property
+    def parent_chat_id(self) -> str | None:
+        return self._parent_chat_id
+
+    @parent_chat_id.setter
+    def parent_chat_id(self, value: str) -> None:
+        self._parent_chat_id = value
+
+    @classmethod
+    def from_chat_event(cls, event: ChatEvent) -> Self:
+        return cls(
+            chat_id=event.payload.chat_id,
+            assistant_id=event.payload.assistant_id,
+            last_assistant_message_id=event.payload.assistant_message.id,
+            last_user_message_id=event.payload.user_message.id
+            if event.payload.user_message
+            else None,
+            last_user_message_text=event.payload.user_message.text
+            if event.payload.user_message
+            else None,
+            metadata_filter=event.payload.metadata_filter
+            if event.payload.metadata_filter
+            else None,
+            parent_chat_id=event.payload.correlation.parent_chat_id
+            if event.payload.correlation
+            else None,
+        )
 
 
 # App
@@ -293,7 +398,7 @@ class UniqueEnvironment:
         return self._api
 
 
-class UniqueRequestContext:
+class UniqueContext:
     """
     Contains all settings/configuration that come from a request or an environment.
     """
@@ -320,11 +425,32 @@ class UniqueRequestContext:
         self._auth = value
 
     @property
-    def chat(self) -> ChatContextProtocol:
-        if self._chat is None:
-            raise ValueError("Chat context not set")
+    def chat(self) -> ChatContextProtocol | None:
         return self._chat
 
+    @classmethod
+    def from_chat_event(cls, event: ChatEvent) -> UniqueContext:
+        """Build a full (auth + chat) context from a ChatEvent."""
+
+        return cls(
+            auth=AuthContext.from_event(event),
+            chat=ChatContext.from_chat_event(event),
+        )
+
+    @classmethod
+    def from_event(cls, event: BaseEvent) -> Self:
+        """Build an auth-only context from any BaseEvent."""
+        return cls(
+            auth=AuthContext.from_event(event),
+        )
+
+    @classmethod
+    def from_settings(cls, settings: UniqueSettings | None = None) -> UniqueContext:
+        """Build an auth-only context from UniqueSettings (auto-loads from env if None)."""
+        if settings is None:
+            settings = UniqueSettings.from_env_auto_with_sdk_init()
+        return cls(auth=settings.authcontext)
+
 
 # Bundling: Build this object for every request.
 class UniqueSettings:
@@ -335,10 +461,11 @@ class UniqueSettings:
         api: UniqueApi,
         *,
         chat_event_filter_options: UniqueChatEventFilterOptions | None = None,
+        chat: ChatContextProtocol | None = None,
         env_file: Path | None = None,
     ):
         self._env = UniqueEnvironment(app=app, api=api)
-        self._request_context = UniqueRequestContext(auth=auth, chat=None)
+        self._context = UniqueContext(auth=auth, chat=chat)
         self._chat_event_filter_options = chat_event_filter_options
         self._env_file: Path | None = (
             env_file if (env_file and env_file.exists()) else None
@@ -471,8 +598,38 @@ class UniqueSettings:
         settings.init_sdk()
         return settings
 
+    @classmethod
+    def from_chat_event(cls, event: ChatEvent) -> UniqueSettings:
+        """Build a :class:`UniqueSettings` from a :class:`ChatEvent`.
+
+        Auth and chat context are extracted from the event.  App and API
+        settings are left at their default values; override them via the
+        returned instance's properties if needed.
+
+        Args:
+            event: The incoming chat event.
+
+        Returns:
+            UniqueSettings with auth + chat context populated from the event.
+        """
+        return cls(
+            auth=AuthContext.from_event(event),
+            app=UniqueApp(),
+            api=UniqueApi(),
+            chat=ChatContext.from_chat_event(event),
+        )
+
+    @property
+    def context(self) -> UniqueContext:
+        """The request-level context (auth + optional chat) for this settings object."""
+        return self._context
+
     def update_from_event(self, event: BaseEvent) -> None:
-        self._request_context.auth = UniqueAuth.from_event(event)
+        # Use UniqueAuth.from_event so the deprecated settings.auth property
+        # keeps working for callers that haven't migrated yet.
+        self._context = UniqueContext(
+            auth=UniqueAuth.from_event(event), chat=self._context.chat
+        )
 
     @property
     def api(self) -> UniqueApi:
@@ -485,18 +642,18 @@ class UniqueSettings:
     @property
     @deprecated("Use authcontext instead")
     def auth(self) -> UniqueAuth:
-        if not isinstance(self._request_context.auth, UniqueAuth):
+        if not isinstance(self._context.auth, UniqueAuth):
             raise ValueError("Auth context is not a UniqueAuth instance")
-        return self._request_context.auth
+        return self._context.auth
 
     @auth.setter
     @deprecated("Use authcontext instead")
     def auth(self, value: UniqueAuth) -> None:
-        self._request_context.auth = value
+        self._context.auth = value
 
     @property
     def authcontext(self) -> AuthContextProtocol:
-        return self._request_context.auth
+        return self._context.auth
 
     @property
     def chat_event_filter_options(self) -> UniqueChatEventFilterOptions | None:

unique_toolkit-1.59.1/unique_toolkit/services/__init__.py

@@ -0,0 +1,23 @@
+from unique_toolkit.app.unique_settings import (
+    AuthContext,
+    ChatContext,
+    UniqueContext,
+)
+from unique_toolkit.services.chat_service import ChatService
+from unique_toolkit.services.factory import (
+    ServiceNotRegisteredError,
+    UniqueServiceFactory,
+)
+from unique_toolkit.services.knowledge_base import KnowledgeBaseService
+
+UniqueServiceFactory.register_known_services()
+
+__all__ = [
+    "AuthContext",
+    "ChatContext",
+    "ChatService",
+    "KnowledgeBaseService",
+    "UniqueContext",
+    "UniqueServiceFactory",
+    "ServiceNotRegisteredError",
+]

{unique_toolkit-1.59.0 → unique_toolkit-1.59.1}/unique_toolkit/services/chat_service.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, Sequence, overload
+from typing import TYPE_CHECKING, Any, Sequence, overload
 
 import unique_sdk
 from openai.types.chat import ChatCompletionToolChoiceOptionParam
@@ -14,10 +14,11 @@ from openai.types.responses import (
 )
 from openai.types.shared_params import Metadata, Reasoning
 from pydantic import BaseModel
-from typing_extensions import deprecated
+from typing_extensions import Self, deprecated
 
 from unique_toolkit._common.utils.files import is_file_content, is_image_content
 from unique_toolkit.agentic.feature_flags import feature_flags
+from unique_toolkit.app.unique_settings import UniqueContext, UniqueSettings
 from unique_toolkit.chat.cancellation import CancellationWatcher
 from unique_toolkit.chat.constants import (
     DEFAULT_MAX_MESSAGES,
@@ -107,24 +108,77 @@ from unique_toolkit.short_term_memory.functions import (
 )
 from unique_toolkit.short_term_memory.schemas import ShortTermMemory
 
+if TYPE_CHECKING:
+    from unique_toolkit.app.schemas import ChatEvent
+
 logger = logging.getLogger(f"toolkit.{DOMAIN_NAME}.{__name__}")
 
 
 class ChatService(ChatServiceDeprecated):
     """Provides all functionalities to manage the chat session."""
 
-    def __init__(self, *args, **kwargs):
-        """Initialize ChatService with lazy-loaded service properties."""
-        super().__init__(*args, **kwargs)
+    @deprecated(
+        "Use UniqueContext.from_chat_event(event) with UniqueServiceFactory instead."
+    )
+    def __init__(
+        self,
+        event: "ChatEvent",
+        content_scope_chat_id: str | None = None,
+    ) -> None:
+        """Initialize ChatService from an event (deprecated). Use :meth:`from_context` instead."""
+        super().__init__(event, content_scope_chat_id)
         self._elicitation_service: ElicitationService | None = None
-
-        self._cancellation_watcher = CancellationWatcher(
+        self._elicitation_message_id: str | None = None
+        self._cancellation_watcher: CancellationWatcher = CancellationWatcher(
             user_id=self._user_id,
             company_id=self._company_id,
             chat_id=self._chat_id,
             assistant_message_id=self._assistant_message_id,
         )
 
+    @classmethod
+    def from_settings(cls, settings: UniqueSettings, **kwargs: Any) -> Self:
+        """Create a ChatService from a :class:`UniqueSettings` or :class:`UniqueContext`.
+
+        This is the preferred constructor when using the service factory pattern.
+
+        Args:
+            settings: Either a :class:`UniqueSettings` (whose ``context`` is used)
+                or a :class:`UniqueContext` carrying auth and chat information directly.
+
+        Raises:
+            ValueError: If the resolved context has no chat or ``last_user_message_id`` is missing.
+        """
+        return cls.from_context(context=settings.context)
+
+    @classmethod
+    def from_context(cls, context: UniqueContext) -> Self:
+        if context.chat is None:
+            raise ValueError(
+                "ChatService requires a chat context (context.chat is None)"
+            )
+        chat = context.chat
+        user_message_id = chat.last_user_message_id
+        instance: ChatService = cls.__new__(cls)
+        instance._event = None
+        instance._company_id = context.auth.get_confidential_company_id()
+        instance._user_id = context.auth.get_confidential_user_id()
+        instance._chat_id = chat.chat_id
+        instance._assistant_id = chat.assistant_id
+        instance._assistant_message_id = chat.last_assistant_message_id
+        instance._user_message_id = user_message_id
+        instance._user_message_text = chat.last_user_message_text
+        instance._content_scope_chat_id = chat.parent_chat_id or chat.chat_id
+        instance._elicitation_service = None
+        instance._elicitation_message_id = chat.last_assistant_message_id
+        instance._cancellation_watcher = CancellationWatcher(
+            user_id=instance._user_id,
+            company_id=instance._company_id,
+            chat_id=instance._chat_id,
+            assistant_message_id=instance._assistant_message_id,
+        )
+        return instance
+
     @property
     def cancellation(self) -> CancellationWatcher:
         """Cancellation watcher for this chat session."""
@@ -136,7 +190,15 @@ class ChatService(ChatServiceDeprecated):
         if self._elicitation_service is not None:
             return self._elicitation_service
 
-        self._elicitation_service = ElicitationService.from_chat_event(self._event)
+        if self._event is not None:
+            self._elicitation_service = ElicitationService.from_chat_event(self._event)
+        else:
+            self._elicitation_service = ElicitationService(
+                user_id=self._user_id,
+                company_id=self._company_id,
+                chat_id=self._content_scope_chat_id,
+                message_id=self._elicitation_message_id,
+            )
 
         return self._elicitation_service