unique_toolkit 1.46.8__tar.gz → 1.46.10__tar.gz

{unique_toolkit-1.46.8 → unique_toolkit-1.46.10}/CHANGELOG.md

@@ -5,6 +5,14 @@ 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).
 
+## [1.46.10] - 2026-02-19
+- Add flag-based cancellation support via `CancellationWatcher` and `TypedEventBus`
+- Expose `ChatService.cancellation` property for polling, event subscription, and `run_with_cancellation` helper
+- Add `CancellationEvent`, `cancelled_at` on `ChatMessage`, and `stopped_by_user` on `LanguageModelStreamResponse`
+
+## [1.46.9] - 2026-02-19
+- Add `litellm:anthropic-claude-sonnet-4-6` to `info.py`
+
 ## [1.46.8] - 2026-02-17
 - Add Configuration Check utility as class, CLI and CI workflow
 

{unique_toolkit-1.46.8 → unique_toolkit-1.46.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unique_toolkit
-Version: 1.46.8
+Version: 1.46.10
 Summary: 
 License: Proprietary
 Author: Cedric Klinkert
@@ -127,6 +127,14 @@ 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).
 
+## [1.46.10] - 2026-02-19
+- Add flag-based cancellation support via `CancellationWatcher` and `TypedEventBus`
+- Expose `ChatService.cancellation` property for polling, event subscription, and `run_with_cancellation` helper
+- Add `CancellationEvent`, `cancelled_at` on `ChatMessage`, and `stopped_by_user` on `LanguageModelStreamResponse`
+
+## [1.46.9] - 2026-02-19
+- Add `litellm:anthropic-claude-sonnet-4-6` to `info.py`
+
 ## [1.46.8] - 2026-02-17
 - Add Configuration Check utility as class, CLI and CI workflow
 

{unique_toolkit-1.46.8 → unique_toolkit-1.46.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "unique_toolkit"
-version = "1.46.8"
+version = "1.46.10"
 description = ""
 authors = [
     "Cedric Klinkert <cedric.klinkert@unique.ch>",

unique_toolkit-1.46.10/unique_toolkit/_common/event_bus.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import dataclass
+from typing import Any, Awaitable, Callable, Generic, Protocol, TypeVar, Union
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T")
+
+AsyncHandler = Callable[[T], Awaitable[None]]
+SyncHandler = Callable[[T], None]
+Handler = Union[AsyncHandler[T], SyncHandler[T]]
+
+
+class Subscription(Protocol):
+    """Handle returned by ``subscribe`` that allows unsubscribing."""
+
+    def cancel(self) -> None: ...
+
+
+@dataclass(slots=True)
+class _ListSubscription:
+    _cancel: Callable[[], None]
+    _active: bool = True
+
+    def cancel(self) -> None:
+        if not self._active:
+            return
+        self._active = False
+        self._cancel()
+
+
+class TypedEventBus(Generic[T]):
+    """In-process, asyncio-friendly, typed pub/sub.
+
+    * ``subscribe(handler)`` — returns a :class:`Subscription`
+    * ``publish_and_wait(event)`` — synchronous: calls handlers directly,
+      schedules async handlers as tasks when a loop is running
+    * ``publish_and_forget_async(event)`` — fire-and-forget (schedules tasks)
+    * ``publish_and_wait_async(event)`` — awaits all handlers
+    """
+
+    __slots__ = ("_handlers",)
+
+    def __init__(self) -> None:
+        self._handlers: list[Handler[T]] = []
+
+    def subscribe(self, handler: Handler[T]) -> Subscription:
+        self._handlers.append(handler)
+
+        def _remove() -> None:
+            try:
+                self._handlers.remove(handler)
+            except ValueError:
+                pass
+
+        return _ListSubscription(_cancel=_remove)
+
+    async def _invoke(self, handler: Handler[T], event: T) -> None:
+        result: Any = handler(event)
+        if asyncio.iscoroutine(result):
+            await result
+
+    def publish_and_wait(self, event: T) -> None:
+        """Synchronous publish: call each handler directly.
+
+        Sync handlers are invoked inline.  Async handlers are scheduled
+        as fire-and-forget tasks when a running event loop is detected;
+        otherwise they are skipped with a warning.
+        """
+        loop: asyncio.AbstractEventLoop | None = None
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            pass
+
+        for handler in list(self._handlers):
+            result: Any = handler(event)
+            if asyncio.iscoroutine(result):
+                if loop is not None:
+                    loop.create_task(result)
+                else:
+                    result.close()
+                    logger.warning(
+                        "Skipping async handler %r — no running event loop",
+                        handler,
+                    )
+
+    def publish_and_forget_async(self, event: T) -> list[asyncio.Task[None]]:
+        """Fire-and-forget: schedule each handler as a background task."""
+        loop = asyncio.get_running_loop()
+        return [loop.create_task(self._invoke(h, event)) for h in list(self._handlers)]
+
+    async def publish_and_wait_async(
+        self, event: T, *, return_exceptions: bool = False
+    ) -> None:
+        """Invoke every handler and await completion."""
+        coros = [self._invoke(h, event) for h in list(self._handlers)]
+        if coros:
+            await asyncio.gather(*coros, return_exceptions=return_exceptions)

{unique_toolkit-1.46.8 → unique_toolkit-1.46.10}/unique_toolkit/agentic/tools/tool.py

@@ -52,7 +52,7 @@ class Tool(ABC, Generic[ConfigType]):
         """Whether the tool is enabled or not."""
         return self.settings.is_enabled
 
-    def takes_control(self):
+    def takes_control(self) -> bool:
         """
         Some tools require to take control of the conversation with the user and do not want the orchestrator to intervene.
         this function indicates whether the tool takes control or not. It yanks the control away from the orchestrator.

{unique_toolkit-1.46.8 → unique_toolkit-1.46.10}/unique_toolkit/agentic/tools/tool_manager.py

@@ -255,6 +255,7 @@ class _ToolManager(Generic[_ApiMode]):
 
         # Wait until all tasks are finished
         tool_call_results = await asyncio.gather(*tasks)
+
         tool_call_results_unpacked: list[ToolCallResponse] = []
         for i, result in enumerate(tool_call_results):
             unpacked_tool_call_result = self._create_tool_call_response(

{unique_toolkit-1.46.8 → unique_toolkit-1.46.10}/unique_toolkit/chat/__init__.py

@@ -1,5 +1,7 @@
 import warnings
 
+from .cancellation import CancellationEvent as CancellationEvent
+from .cancellation import CancellationWatcher as CancellationWatcher
 from .constants import DOMAIN_NAME as DOMAIN_NAME
 from .schemas import ChatMessage as ChatMessage
 from .schemas import ChatMessageAssessment as ChatMessageAssessment

unique_toolkit-1.46.10/unique_toolkit/chat/cancellation.py

@@ -0,0 +1,175 @@
+"""Cancellation detection and notification for chat agent executions."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import dataclass
+from typing import Any, Coroutine, TypeVar, overload
+
+import unique_sdk
+
+from unique_toolkit._common.event_bus import TypedEventBus
+
+
+@dataclass(frozen=True, slots=True)
+class CancellationEvent:
+    """Published on the cancellation event bus when a user abort is detected."""
+
+    message_id: str
+
+T = TypeVar("T")
+
+logger = logging.getLogger(__name__)
+
+
+class CancellationWatcher:
+    """Polls the database for ``cancelledAt`` and publishes to an event bus.
+
+    The watcher never raises exceptions for cancellation. Instead it:
+    - publishes a :class:`CancellationEvent` on the bus
+    - sets :attr:`is_cancelled` to ``True``
+
+    Callers inspect :attr:`is_cancelled` to decide whether to stop.
+    """
+
+    def __init__(
+        self,
+        *,
+        user_id: str,
+        company_id: str,
+        chat_id: str,
+        assistant_message_id: str,
+    ) -> None:
+        self._bus: TypedEventBus[CancellationEvent] = TypedEventBus()
+        self._user_id = user_id
+        self._company_id = company_id
+        self._chat_id = chat_id
+        self._assistant_message_id = assistant_message_id
+        self._cancelled = False
+
+    @property
+    def is_cancelled(self) -> bool:
+        return self._cancelled
+
+    @property
+    def on_cancellation(self) -> TypedEventBus[CancellationEvent]:
+        return self._bus
+
+    async def check_cancellation_async(self) -> bool:
+        """Poll the DB once.  Returns ``True`` if the message was cancelled.
+
+        When cancellation is detected for the first time, all subscribers
+        on the bus are notified (awaited) before this method returns.
+        """
+        if self._cancelled:
+            return True
+        try:
+            raw_msg = await unique_sdk.Message.retrieve_async(
+                user_id=self._user_id,
+                company_id=self._company_id,
+                id=self._assistant_message_id,
+                chatId=self._chat_id,
+            )
+            cancelled_at = getattr(raw_msg, "cancelledAt", None)
+            if cancelled_at is not None:
+                self._cancelled = True
+                event = CancellationEvent(message_id=self._assistant_message_id)
+                await self._bus.publish_and_wait_async(event)
+                return True
+        except Exception as exc:
+            logger.warning(
+                "Failed to check cancellation: %s: %s", type(exc).__name__, exc
+            )
+        return False
+
+    def check_cancellation(self) -> bool:
+        """Synchronous single-shot check.
+
+        Returns ``True`` if the message was cancelled.  Subscribers are
+        notified via :meth:`TypedEventBus.publish_and_wait` (sync handlers
+        are called inline; async handlers are scheduled as tasks when a
+        running event loop is detected).
+        """
+        if self._cancelled:
+            return True
+        try:
+            raw_msg = unique_sdk.Message.retrieve(
+                user_id=self._user_id,
+                company_id=self._company_id,
+                id=self._assistant_message_id,
+                chatId=self._chat_id,
+            )
+            cancelled_at = getattr(raw_msg, "cancelledAt", None)
+            if cancelled_at is not None:
+                self._cancelled = True
+                event = CancellationEvent(message_id=self._assistant_message_id)
+                self._bus.publish_and_wait(event)
+                return True
+        except Exception as exc:
+            logger.warning(
+                "Failed to check cancellation: %s: %s", type(exc).__name__, exc
+            )
+        return False
+
+    @overload
+    async def run_with_cancellation(
+        self,
+        coroutine: Coroutine[Any, Any, T],
+        *,
+        poll_interval: float = ...,
+        cancel_result: T,
+    ) -> T: ...
+
+    @overload
+    async def run_with_cancellation(
+        self,
+        coroutine: Coroutine[Any, Any, T],
+        *,
+        poll_interval: float = ...,
+    ) -> T | None: ...
+
+    async def run_with_cancellation(
+        self,
+        coroutine: Coroutine[Any, Any, Any],
+        *,
+        poll_interval: float = 2.0,
+        cancel_result: Any = None,
+    ) -> Any:
+        """Run *coroutine* while polling for cancellation in the background.
+
+        When cancelled, subscribers are notified via the bus and
+        :attr:`is_cancelled` is set to ``True``.
+
+        Args:
+            coroutine: The async coroutine to execute.
+            poll_interval: How often (in seconds) to poll for cancellation.
+            cancel_result: Value to return when cancelled.  When provided
+                the return type matches the coroutine's return type so
+                callers don't need a ``None`` check.
+
+        Returns:
+            The coroutine's result on success, or *cancel_result* if
+            cancelled (defaults to ``None``).
+        """
+        task = asyncio.create_task(coroutine)
+
+        async def _watcher() -> None:
+            while not task.done():
+                cancelled = await self.check_cancellation_async()
+                if cancelled:
+                    task.cancel()
+                    return
+                await asyncio.sleep(poll_interval)
+
+        watcher = asyncio.create_task(_watcher())
+        try:
+            return await task
+        except asyncio.CancelledError:
+            return cancel_result
+        finally:
+            watcher.cancel()
+            try:
+                await watcher
+            except asyncio.CancelledError:
+                pass

{unique_toolkit-1.46.8 → unique_toolkit-1.46.10}/unique_toolkit/chat/schemas.py

@@ -83,6 +83,7 @@ class ChatMessage(BaseModel):
     debug_info: dict | None = {}
     created_at: datetime | None = None
     completed_at: datetime | None = None
+    cancelled_at: datetime | None = None
     updated_at: datetime | None = None
     references: list[ContentReference] | None = None
 

{unique_toolkit-1.46.8 → unique_toolkit-1.46.10}/unique_toolkit/language_model/infos.py

@@ -57,6 +57,7 @@ class LanguageModelName(StrEnum):
     ANTHROPIC_CLAUDE_HAIKU_4_5 = "litellm:anthropic-claude-haiku-4-5"
     ANTHROPIC_CLAUDE_SONNET_4 = "litellm:anthropic-claude-sonnet-4"
     ANTHROPIC_CLAUDE_SONNET_4_5 = "litellm:anthropic-claude-sonnet-4-5"
+    ANTHROPIC_CLAUDE_SONNET_4_6 = "litellm:anthropic-claude-sonnet-4-6"
     ANTHROPIC_CLAUDE_OPUS_4 = "litellm:anthropic-claude-opus-4"
     ANTHROPIC_CLAUDE_OPUS_4_1 = "litellm:anthropic-claude-opus-4-1"
     ANTHROPIC_CLAUDE_OPUS_4_5 = "litellm:anthropic-claude-opus-4-5"
@@ -1139,6 +1140,26 @@ class LanguageModelInfo(BaseModel):
                     info_cutoff_at=date(2025, 7, 1),
                     published_at=date(2025, 9, 29),
                 )
+            case LanguageModelName.ANTHROPIC_CLAUDE_SONNET_4_6:
+                return cls(
+                    name=model_name,
+                    capabilities=[
+                        ModelCapabilities.FUNCTION_CALLING,
+                        ModelCapabilities.STREAMING,
+                        ModelCapabilities.VISION,
+                        ModelCapabilities.REASONING,
+                    ],
+                    provider=LanguageModelProvider.LITELLM,
+                    version="claude-sonnet-4-6",
+                    encoder_name=EncoderName.O200K_BASE,  # TODO: Update encoder with litellm
+                    token_limits=LanguageModelTokenLimits(
+                        # Input limit is 200_000, we leave 20_000 tokens as buffer due to tokenizer mismatch
+                        token_limit_input=180_000,
+                        token_limit_output=64_000,
+                    ),
+                    info_cutoff_at=date(2026, 1, 1),
+                    published_at=date(2026, 2, 17),
+                )
             case LanguageModelName.ANTHROPIC_CLAUDE_OPUS_4:
                 return cls(
                     name=model_name,

{unique_toolkit-1.46.8 → unique_toolkit-1.46.10}/unique_toolkit/language_model/schemas.py

@@ -168,6 +168,7 @@ class LanguageModelStreamResponse(BaseModel):
 
     message: LanguageModelStreamResponseMessage
     tool_calls: list[LanguageModelFunction] | None = None
+    stopped_by_user: bool = False
 
     def is_empty(self) -> bool:
         """

{unique_toolkit-1.46.8 → unique_toolkit-1.46.10}/unique_toolkit/services/chat_service.py

@@ -17,6 +17,7 @@ from pydantic import BaseModel
 from typing_extensions import deprecated
 
 from unique_toolkit._common.utils.files import is_file_content, is_image_content
+from unique_toolkit.chat.cancellation import CancellationWatcher
 from unique_toolkit.chat.constants import (
     DEFAULT_MAX_MESSAGES,
     DEFAULT_PERCENT_OF_MAX_TOKENS,
@@ -114,13 +115,24 @@ class ChatService(ChatServiceDeprecated):
         super().__init__(*args, **kwargs)
         self._elicitation_service: ElicitationService | None = None
 
+        self._cancellation_watcher = CancellationWatcher(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            chat_id=self._chat_id,
+            assistant_message_id=self._assistant_message_id,
+        )
+
+    @property
+    def cancellation(self) -> CancellationWatcher:
+        """Cancellation watcher for this chat session."""
+        return self._cancellation_watcher
+
     @property
     def elicitation(self) -> ElicitationService:
         """Get the ElicitationService for this chat session."""
         if self._elicitation_service is not None:
             return self._elicitation_service
 
-        # Create the ElicitationService from the chat event (dynamically selects correlation or chat and message)
         self._elicitation_service = ElicitationService.from_chat_event(self._event)
 
         return self._elicitation_service