unique_toolkit 1.58.1__tar.gz → 1.59.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-toolkit
-Version: 1.58.1
+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.58.1 → unique_toolkit-1.59.1}/pyproject.toml

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

{unique_toolkit-1.58.1 → 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.58.1 → 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.58.1 → unique_toolkit-1.59.1}/unique_toolkit/app/unique_settings.py

@@ -1,18 +1,28 @@
+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, 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__)
@@ -37,6 +47,195 @@ def warn_about_defaults(instance: T) -> T:
     return instance
 
 
+# Auth
+# We have a BaseModel and a BaseSetting class here because the context can be
+# obtained from the environment and or a request. In the case of a request we
+# should be using the AuthContext.
+# Both classes implement the protocol that can be used for typing.
+class AuthContextProtocol(Protocol):
+    company_id: SecretStr
+    user_id: SecretStr
+
+    def get_confidential_company_id(self) -> str: ...
+    def get_confidential_user_id(self) -> str: ...
+
+
+class AuthContext(BaseModel):
+    company_id: SecretStr = Field(..., description="The company ID.")
+    user_id: SecretStr = Field(..., description="The user ID.")
+
+    def get_confidential_company_id(self) -> str:
+        return self.company_id.get_secret_value()
+
+    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):
+    company_id: SecretStr = Field(
+        default=SecretStr("dummy_company_id"),
+        validation_alias=AliasChoices(
+            "unique_auth_company_id",
+            "company_id",
+            "UNIQUE_AUTH_COMPANY_ID",
+            "COMPANY_ID",
+        ),
+    )
+    user_id: SecretStr = Field(
+        default=SecretStr("dummy_user_id"),
+        validation_alias=AliasChoices(
+            "unique_auth_user_id", "user_id", "UNIQUE_AUTH_USER_ID", "USER_ID"
+        ),
+    )
+
+    model_config = SettingsConfigDict(
+        env_prefix="unique_auth_",
+        env_file_encoding="utf-8",
+        case_sensitive=False,
+        extra="ignore",
+    )
+
+    def get_confidential_company_id(self) -> str:
+        return self.company_id.get_secret_value()
+
+    def get_confidential_user_id(self) -> str:
+        return self.user_id.get_secret_value()
+
+    @model_validator(mode="after")
+    def _warn_about_defaults(self) -> Self:
+        return warn_about_defaults(self)
+
+    @classmethod
+    def from_event(cls, event: BaseEvent) -> Self:
+        return cls(
+            company_id=SecretStr(event.company_id),
+            user_id=SecretStr(event.user_id),
+        )
+
+    def to_auth_context(self) -> AuthContext:
+        return AuthContext(
+            company_id=self.company_id,
+            user_id=self.user_id,
+        )
+
+
+# Chat
+class ChatContextProtocol(Protocol):
+    chat_id: str
+    assistant_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 | 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
+# Settings only as only obtained from the environment.
 @register_config()
 class UniqueApp(BaseSettings):
     id: SecretStr = Field(
@@ -79,6 +278,10 @@ class UniqueApp(BaseSettings):
     )
 
 
+# Api
+# Settings only as only obtained from the environment.
+
+
 @register_config()
 class UniqueApi(BaseSettings):
     base_url: str = Field(
@@ -147,43 +350,8 @@ class UniqueApi(BaseSettings):
         return urlunparse(parsed._replace(path=path, query=None, fragment=None))
 
 
-@register_config()
-class UniqueAuth(BaseSettings):
-    company_id: SecretStr = Field(
-        default=SecretStr("dummy_company_id"),
-        validation_alias=AliasChoices(
-            "unique_auth_company_id",
-            "company_id",
-            "UNIQUE_AUTH_COMPANY_ID",
-            "COMPANY_ID",
-        ),
-    )
-    user_id: SecretStr = Field(
-        default=SecretStr("dummy_user_id"),
-        validation_alias=AliasChoices(
-            "unique_auth_user_id", "user_id", "UNIQUE_AUTH_USER_ID", "USER_ID"
-        ),
-    )
-
-    model_config = SettingsConfigDict(
-        env_prefix="unique_auth_",
-        env_file_encoding="utf-8",
-        case_sensitive=False,
-        extra="ignore",
-    )
-
-    @model_validator(mode="after")
-    def _warn_about_defaults(self) -> Self:
-        return warn_about_defaults(self)
-
-    @classmethod
-    def from_event(cls, event: "BaseEvent") -> Self:
-        return cls(
-            company_id=SecretStr(event.company_id),
-            user_id=SecretStr(event.user_id),
-        )
-
-
+# EventFilterOptions
+# Settings only as only obtained from the environment.
 class UniqueChatEventFilterOptions(BaseSettings):
     # Empty string evals to False
     assistant_ids: list[str] = Field(
@@ -211,19 +379,93 @@ class EnvFileNotFoundError(FileNotFoundError):
     """Raised when no environment file can be found in any of the expected locations."""
 
 
+class UniqueEnvironment:
+    """
+    Contains all settings that come exclusively from the environment.
+    This means if a setting can be intialized from either request or the environment, this class will not contain it.
+    """
+
+    def __init__(self, app: UniqueApp, api: UniqueApi) -> None:
+        self._app = app
+        self._api = api
+
+    @property
+    def app(self) -> UniqueApp:
+        return self._app
+
+    @property
+    def api(self) -> UniqueApi:
+        return self._api
+
+
+class UniqueContext:
+    """
+    Contains all settings/configuration that come from a request or an environment.
+    """
+
+    def __init__(
+        self,
+        auth: AuthContextProtocol | None = None,
+        chat: ChatContextProtocol | None = None,
+    ) -> None:
+        self._auth = auth
+        self._chat = chat
+
+    @property
+    def auth(self) -> AuthContextProtocol:
+        if self._auth is None:
+            raise ValueError("Auth context not set")
+        return self._auth
+
+    @auth.setter
+    @deprecated(
+        "Avoid this, rather create a new request context with the new auth context. Kept for backwards compatibility."
+    )
+    def auth(self, value: AuthContextProtocol) -> None:
+        self._auth = value
+
+    @property
+    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:
     def __init__(
         self,
-        auth: UniqueAuth,
+        auth: AuthContextProtocol,
         app: UniqueApp,
         api: UniqueApi,
         *,
         chat_event_filter_options: UniqueChatEventFilterOptions | None = None,
+        chat: ChatContextProtocol | None = None,
         env_file: Path | None = None,
     ):
-        self._app = app
-        self._auth = auth
-        self._api = api
+        self._env = UniqueEnvironment(app=app, api=api)
+        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
@@ -274,7 +516,7 @@ class UniqueSettings:
     def from_env(
         cls,
         env_file: Path | None = None,
-    ) -> "UniqueSettings":
+    ) -> UniqueSettings:
         """Initialize settings from environment variables and/or env file.
 
         Args:
@@ -305,7 +547,7 @@ class UniqueSettings:
         )
 
     @classmethod
-    def from_env_auto(cls, filename: str = "unique.env") -> "UniqueSettings":
+    def from_env_auto(cls, filename: str = "unique.env") -> UniqueSettings:
         """Initialize settings by automatically finding environment file.
 
         This method will automatically search for an environment file in standard locations
@@ -334,14 +576,14 @@ class UniqueSettings:
         This method configures the global unique_sdk module with the API key,
         app ID, and base URL from these settings.
         """
-        unique_sdk.api_key = self._app.key.get_secret_value()
-        unique_sdk.app_id = self._app.id.get_secret_value()
-        unique_sdk.api_base = self._api.sdk_url()
+        unique_sdk.api_key = self.app.key.get_secret_value()
+        unique_sdk.app_id = self.app.id.get_secret_value()
+        unique_sdk.api_base = self.api.sdk_url()
 
     @classmethod
     def from_env_auto_with_sdk_init(
         cls, filename: str = "unique.env"
-    ) -> "UniqueSettings":
+    ) -> UniqueSettings:
         """Initialize settings and SDK in one convenient call.
 
         This method combines from_env_auto() and init_sdk() for the most common use case.
@@ -356,24 +598,62 @@ class UniqueSettings:
         settings.init_sdk()
         return settings
 
-    def update_from_event(self, event: "BaseEvent") -> None:
-        self._auth = UniqueAuth.from_event(event)
+    @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:
+        # 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:
-        return self._api
+        return self._env.api
 
     @property
     def app(self) -> UniqueApp:
-        return self._app
+        return self._env.app
 
     @property
+    @deprecated("Use authcontext instead")
     def auth(self) -> UniqueAuth:
-        return self._auth
+        if not isinstance(self._context.auth, UniqueAuth):
+            raise ValueError("Auth context is not a UniqueAuth instance")
+        return self._context.auth
 
     @auth.setter
+    @deprecated("Use authcontext instead")
     def auth(self, value: UniqueAuth) -> None:
-        self._auth = value
+        self._context.auth = value
+
+    @property
+    def authcontext(self) -> AuthContextProtocol:
+        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",
+]