unique_toolkit 2026.28.0.dev6__py3-none-any.whl → 2026.28.0.dev8__py3-none-any.whl

unique_toolkit/_common/chunk_relevancy_sorter/service.py

@@ -71,7 +71,7 @@ class ChunkRelevancySorter:
         company_id: str | None = None,
         user_id: str | None = None,
     ):
-        if isinstance(event, (ChatEvent, BaseEvent)):
+        if isinstance(event, BaseEvent):
             self.chunk_relevancy_evaluator = ContextRelevancyEvaluator.from_event(event)
         else:
             [company_id, user_id] = validate_required_values([company_id, user_id])

unique_toolkit/agentic/evaluation/context_relevancy/service.py

@@ -81,7 +81,7 @@ class ContextRelevancyEvaluator:
         company_id: str | None = None,
         user_id: str | None = None,
     ):
-        if isinstance(event, (ChatEvent, BaseEvent)):
+        if isinstance(event, BaseEvent):
             self.language_model_service = LanguageModelService.from_event(event)
         else:
             [company_id, user_id] = validate_required_values([company_id, user_id])

unique_toolkit/agentic/tools/experimental/retrieve_search_scope_tool/tool.py

@@ -116,7 +116,7 @@ class RetrieveSearchScopeTool(Tool[RetrieveSearchScopeConfig]):
             )
 
         try:
-            settings = UniqueSettings.from_chat_event(self._event)
+            settings = UniqueSettings.from_chat_event(self.event)
             kb_service = UniqueServiceFactory(
                 settings=settings
             ).knowledge_base_service()

unique_toolkit/agentic/tools/run_context.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import Self
+
+from unique_toolkit.app.schemas import ChatEvent
+
+
+class ToolRunContext(BaseModel):
+    """Tool-manager runtime state decoupled from a raw :class:`ChatEvent`."""
+
+    model_config = ConfigDict(frozen=True, arbitrary_types_allowed=True)
+
+    tool_choices: list[str] = Field(default_factory=list)
+    disabled_tools: list[str] = Field(default_factory=list)
+    tool_init_event: ChatEvent | None = None
+
+    @classmethod
+    def from_chat_event(cls, event: ChatEvent) -> Self:
+        return cls(
+            tool_choices=list(event.payload.tool_choices),
+            disabled_tools=list(event.payload.disabled_tools),
+            tool_init_event=event,
+        )

unique_toolkit/agentic/tools/tool.py

@@ -18,7 +18,8 @@ from unique_toolkit.app.schemas import ChatEvent
 from unique_toolkit.language_model import LanguageModelToolDescription
 
 if TYPE_CHECKING:
-    pass
+    from unique_toolkit.language_model.service import LanguageModelService
+    from unique_toolkit.services.chat_service import ChatService
 from unique_toolkit.language_model.schemas import (
     LanguageModelFunction,
 )
@@ -169,6 +170,9 @@ class Tool(ABC, Generic[ConfigType]):
     def __init__(self, config: ConfigType) -> None: ...
 
     @overload
+    @deprecated(
+        "Passing event is deprecated. Use Tool(config) and inject context in run()."
+    )
     def __init__(
         self,
         config: ConfigType,
@@ -176,17 +180,32 @@ class Tool(ABC, Generic[ConfigType]):
         tool_progress_reporter: ToolProgressReporter | None = ...,
     ) -> None: ...
 
+    @overload
+    def __init__(
+        self,
+        config: ConfigType,
+        *,
+        chat_service: ChatService,
+        language_model_service: LanguageModelService,
+        tool_progress_reporter: ToolProgressReporter | None = ...,
+    ) -> None: ...
+
     def __init__(
         self,
         config: ConfigType,
         event: ChatEvent | None = None,
         tool_progress_reporter: ToolProgressReporter | None = None,
+        *,
+        chat_service: ChatService | None = None,
+        language_model_service: LanguageModelService | None = None,
     ) -> None:
         """Initialize the tool.
 
-        Preferred (decoupled): `Tool(config)` — configuration only.
+        Preferred (decoupled): ``Tool(config)`` — configuration only.
 
-        Backward compatible: `Tool(config, event, tool_progress_reporter)` — creates
+        Service injection: ``Tool(config, chat_service=..., language_model_service=...)``.
+
+        Backward compatible: ``Tool(config, event, tool_progress_reporter)`` — creates
         deprecated chat_service, language_model_service, message_step_logger for
         legacy subclasses.
         """
@@ -200,6 +219,25 @@ class Tool(ABC, Generic[ConfigType]):
         self.logger = getLogger(f"{module_name}.{__name__}")
         self.debug_info: dict[str, Any] = {}
 
+        if (chat_service is None) != (language_model_service is None):
+            raise ValueError(
+                "chat_service and language_model_service must be injected together; "
+                "supplying only one is not supported."
+            )
+
+        if chat_service is not None and language_model_service is not None:
+            from unique_toolkit.agentic.message_log_manager.service import (
+                MessageStepLogger,
+            )
+
+            self._tool_progress_reporter = tool_progress_reporter
+            self._chat_service = chat_service
+            self._language_model_service = language_model_service
+            self._message_step_logger = MessageStepLogger(
+                chat_service=self._chat_service,
+            )
+            return
+
         if event is not None:
             from unique_toolkit.agentic.message_log_manager.service import (
                 MessageStepLogger,
@@ -220,11 +258,12 @@ class Tool(ABC, Generic[ConfigType]):
         "Never reuse event. Dangerous. Prefer Tool(config) and inject context in run()."
     )
     def event(self) -> ChatEvent:
-        if not hasattr(self, "_event"):
+        chat_event = getattr(self, "_event", None)
+        if chat_event is None:
             raise AttributeError(
                 "event not available (tool was initialized with config only). "
             )
-        return self._event
+        return chat_event
 
     @property
     @deprecated(

unique_toolkit/agentic/tools/tool_manager.py

@@ -12,6 +12,7 @@ from openai.types.responses import (
     response_create_params,
 )
 from pydantic import BaseModel, Field
+from typing_extensions import Self
 
 from unique_toolkit._common.execution import (
     Result,
@@ -31,6 +32,7 @@ from unique_toolkit.agentic.tools.openai_builtin.base import (
     OpenAIBuiltInToolName,
 )
 from unique_toolkit.agentic.tools.openai_builtin.manager import OpenAIBuiltInToolManager
+from unique_toolkit.agentic.tools.run_context import ToolRunContext
 from unique_toolkit.agentic.tools.schemas import ToolCallResponse, ToolPrompts
 from unique_toolkit.agentic.tools.tool import Tool
 from unique_toolkit.agentic.tools.tool_progress_reporter import ToolProgressReporter
@@ -88,13 +90,62 @@ class _ToolManager(Generic[_ApiMode]):
         a2a_manager: A2AManager,
         api_mode: _ApiMode,
         builtin_tool_manager: OpenAIBuiltInToolManager | None = None,
+    ) -> None:
+        self._setup(
+            logger=logger,
+            config=config,
+            run_context=ToolRunContext.from_chat_event(event),
+            tool_progress_reporter=tool_progress_reporter,
+            mcp_manager=mcp_manager,
+            a2a_manager=a2a_manager,
+            api_mode=api_mode,
+            builtin_tool_manager=builtin_tool_manager,
+        )
+
+    @classmethod
+    def from_run_context(
+        cls,
+        logger: Logger,
+        config: ToolManagerConfig,
+        *,
+        run_context: ToolRunContext,
+        tool_progress_reporter: ToolProgressReporter,
+        mcp_manager: MCPManager,
+        a2a_manager: A2AManager,
+        api_mode: _ApiMode,
+        builtin_tool_manager: OpenAIBuiltInToolManager | None = None,
+    ) -> Self:
+        instance = cls.__new__(cls)
+        instance._setup(
+            logger=logger,
+            config=config,
+            run_context=run_context,
+            tool_progress_reporter=tool_progress_reporter,
+            mcp_manager=mcp_manager,
+            a2a_manager=a2a_manager,
+            api_mode=api_mode,
+            builtin_tool_manager=builtin_tool_manager,
+        )
+        return instance
+
+    def _setup(
+        self,
+        *,
+        logger: Logger,
+        config: ToolManagerConfig,
+        run_context: ToolRunContext,
+        tool_progress_reporter: ToolProgressReporter,
+        mcp_manager: MCPManager,
+        a2a_manager: A2AManager,
+        api_mode: _ApiMode,
+        builtin_tool_manager: OpenAIBuiltInToolManager | None,
     ) -> None:
         self._logger = logger
         self._config = config
         self._tool_progress_reporter = tool_progress_reporter
         self._tools: list[Tool[Any] | OpenAIBuiltInTool[Any]] = []
-        self._tool_choices = event.payload.tool_choices
-        self._disabled_tools = event.payload.disabled_tools
+        self._tool_choices = run_context.tool_choices
+        self._disabled_tools = run_context.disabled_tools
         self._exclusive_tools = [
             tool.name for tool in self._config.tools if tool.is_exclusive
         ]
@@ -104,17 +155,33 @@ class _ToolManager(Generic[_ApiMode]):
         self._a2a_manager = a2a_manager
         self._builtin_tool_manager = builtin_tool_manager
         self._api_mode = api_mode
-        self._init__tools(event)
-
-    def _init__tools(self, event: ChatEvent) -> None:
+        self._sub_agents: list[SubAgentTool] = []
+        self._builtin_tools: list[OpenAIBuiltInTool[Any]] = []
+        self._mcp_tools: list[Tool[Any]] = []
+        self._internal_tools: list[Tool[Any]] = []
+        self.available_tools: list[
+            Tool[Any] | OpenAIBuiltInTool[Any] | SubAgentTool
+        ] = []
+        self._init__tools(run_context.tool_init_event)
+
+    def _init__tools(self, tool_init_event: ChatEvent | None) -> None:
         tool_choices = self._tool_choices
         tool_configs = self._config.tools
         self._logger.info("Initializing tool definitions...")
         self._logger.info(f"Tool choices: {tool_choices}")
 
-        tool_configs, sub_agents = self._a2a_manager.get_all_sub_agents(
-            tool_configs, event
-        )
+        if tool_init_event is not None:
+            tool_configs, sub_agents = self._a2a_manager.get_all_sub_agents(
+                tool_configs,
+                tool_init_event,
+            )
+        else:
+            tool_configs = [
+                tool_config
+                for tool_config in tool_configs
+                if not tool_config.is_sub_agent
+            ]
+            sub_agents = []
         self._sub_agents = sub_agents
 
         registered_tool_names = set(t.name for t in self._sub_agents)
@@ -133,18 +200,27 @@ class _ToolManager(Generic[_ApiMode]):
         registered_tool_names.update(t.name for t in self._mcp_tools)
 
         # Build internal tools from configurations
-        self._internal_tools = [
-            ToolFactory.build_tool_with_settings(
-                t.name,
-                t,
-                t.configuration,
-                event,
-                tool_progress_reporter=self._tool_progress_reporter,
-            )
-            for t in tool_configs
-            if t.name not in registered_tool_names  # Skip already handled tools
-            and t.name not in OpenAIBuiltInToolName  # Safeguard
-        ]
+        self._internal_tools.clear()
+        for t in tool_configs:
+            if t.name in registered_tool_names:
+                continue
+            if t.name in OpenAIBuiltInToolName:
+                continue
+            if tool_init_event is not None:
+                built_tool = ToolFactory.build_tool_with_settings(
+                    t.name,
+                    t,
+                    t.configuration,
+                    tool_init_event,
+                    tool_progress_reporter=self._tool_progress_reporter,
+                )
+            else:
+                self._logger.info(
+                    "Skipping internal tool '%s' (requires chat event for initialization)",
+                    t.name,
+                )
+                continue
+            self._internal_tools.append(built_tool)
 
         # Combine all types of tools
         self.available_tools = (
@@ -607,6 +683,30 @@ class ToolManager(_ToolManager[Literal["completions"]]):
             builtin_tool_manager=None,
         )
 
+    @classmethod
+    def from_run_context(
+        cls,
+        logger: Logger,
+        config: ToolManagerConfig,
+        *,
+        run_context: ToolRunContext,
+        tool_progress_reporter: ToolProgressReporter,
+        mcp_manager: MCPManager,
+        a2a_manager: A2AManager,
+        api_mode: Literal["completions"] = "completions",
+        builtin_tool_manager: OpenAIBuiltInToolManager | None = None,
+    ) -> Self:
+        return super().from_run_context(
+            logger=logger,
+            config=config,
+            run_context=run_context,
+            tool_progress_reporter=tool_progress_reporter,
+            mcp_manager=mcp_manager,
+            a2a_manager=a2a_manager,
+            api_mode=api_mode,
+            builtin_tool_manager=builtin_tool_manager,
+        )
+
 
 class ResponsesApiToolManager(_ToolManager[Literal["responses"]]):
     def __init__(
@@ -631,6 +731,33 @@ class ResponsesApiToolManager(_ToolManager[Literal["responses"]]):
             builtin_tool_manager=builtin_tool_manager,
         )
 
+    @classmethod
+    def from_run_context(
+        cls,
+        logger: Logger,
+        config: ToolManagerConfig,
+        *,
+        run_context: ToolRunContext,
+        tool_progress_reporter: ToolProgressReporter,
+        mcp_manager: MCPManager,
+        a2a_manager: A2AManager,
+        api_mode: Literal["responses"] = "responses",
+        builtin_tool_manager: OpenAIBuiltInToolManager | None = None,
+    ) -> Self:
+        if builtin_tool_manager is None:
+            msg = "builtin_tool_manager is required for ResponsesApiToolManager"
+            raise ValueError(msg)
+        return super().from_run_context(
+            logger=logger,
+            config=config,
+            run_context=run_context,
+            tool_progress_reporter=tool_progress_reporter,
+            mcp_manager=mcp_manager,
+            a2a_manager=a2a_manager,
+            api_mode=api_mode,
+            builtin_tool_manager=builtin_tool_manager,
+        )
+
     def get_required_include_params(self) -> list[ResponseIncludable]:
         """Return Responses API include params required by all active built-in tools."""
         return self._builtin_tool_manager.get_required_include_params()

unique_toolkit/agentic_table/schemas.py

@@ -1,5 +1,5 @@
 from enum import StrEnum
-from typing import Annotated, Any, Generic, Literal, TypeVar
+from typing import Annotated, Any, Generic, Literal, TypeVar, override
 
 from pydantic import (
     AliasChoices,
@@ -20,13 +20,13 @@ from unique_sdk.api_resources._agentic_table import (
     SheetType,
 )
 
+from unique_toolkit._common.exception import ConfigurationException
 from unique_toolkit._common.pydantic_helpers import get_configuration_dict
 from unique_toolkit.app.schemas import (
-    ChatEvent,
-    ChatEventAssistantMessage,
-    ChatEventUserMessage,
-    Correlation,
+    AssistantWebhookEvent,
+    BaseEventPayload,
 )
+from unique_toolkit.app.unique_settings import UniqueChatEventFilterOptions
 from unique_toolkit.language_model.schemas import (
     LanguageModelMessageRole,
     LanguageModelMessages,
@@ -112,27 +112,27 @@ A = TypeVar("A", bound=MagicTableAction)
 T = TypeVar("T", bound=BaseMetadata)
 
 
-class MagicTableBasePayload(BaseModel, Generic[A, T]):
+class MagicTableBasePayload(BaseEventPayload, Generic[A, T]):
+    """Magic-table-specific payload.
+
+    Inherits the common envelope fields (``name``, ``chat_id``, ``assistant_id``,
+    ``configuration``, ``metadata_filter``, ``correlation``) from
+    :class:`BaseEventPayload` and adds magic-table-only fields.
+
+    Note: previously this carried stub-empty ``user_message`` /
+    ``assistant_message`` defaults so that ``MagicTableEvent`` could pose as
+    a ``ChatEvent``. That coupling is gone; magic-table flows that need a
+    chat context should construct a :class:`UniqueContext` explicitly.
+    """
+
     model_config = get_configuration_dict()
-    name: str = Field(description="The name of the module")
-    sheet_name: str
 
+    # Optional on magic-table (BaseEventPayload requires it for chat).
+    configuration: dict[str, Any] = Field(default_factory=dict)
+    sheet_name: str
     action: A
-    chat_id: str
-    assistant_id: str
     table_id: str
-    user_message: ChatEventUserMessage = Field(
-        default=ChatEventUserMessage(
-            id="", text="", original_text="", created_at="", language=""
-        )
-    )
-    assistant_message: ChatEventAssistantMessage = Field(
-        default=ChatEventAssistantMessage(id="", created_at="")
-    )
-    configuration: dict[str, Any] = {}
     metadata: T
-    metadata_filter: dict[str, Any] | None = None
-    correlation: Correlation | None = None
 
 
 ########### Specialized Payload definitions ###########
@@ -263,10 +263,48 @@ PayloadTypes = (
 MagicTablePayloadTypes = Annotated[PayloadTypes, Field(discriminator="action")]
 
 
-class MagicTableEvent(ChatEvent):
-    # TODO(UN-19532): investigate making ChatEvent generic to avoid these overrides
+class MagicTableEvent(
+    AssistantWebhookEvent[UniqueChatEventFilterOptions, MagicTablePayloadTypes]
+):
+    """Magic-table webhook event, sibling of :class:`ChatEvent`.
+
+    No longer extends ``ChatEvent``; both events are siblings under
+    :class:`AssistantWebhookEvent`. This makes ``isinstance(magic_table_event,
+    ChatEvent)`` correctly return ``False`` and prevents silently passing a
+    magic-table event to services that require chat-only fields.
+    """
+
     event: MagicTableEventTypes  # pyright: ignore[reportIncompatibleVariableOverride]
-    payload: MagicTablePayloadTypes  # pyright: ignore[reportIncompatibleVariableOverride]
+
+    @override
+    def filter_event(
+        self, *, filter_options: UniqueChatEventFilterOptions | None = None
+    ) -> bool:
+        if filter_options is None:
+            return False
+
+        if not filter_options.assistant_ids and not filter_options.references_in_code:
+            raise ConfigurationException(
+                "No filter options provided, all events will be filtered! \n"
+                "Please define: \n"
+                " - 'UNIQUE_CHAT_EVENT_FILTER_OPTIONS_ASSISTANT_IDS' \n"
+                " - 'UNIQUE_CHAT_EVENT_FILTER_OPTIONS_REFERENCES_IN_CODE' \n"
+                "in your environment variables."
+            )
+
+        if (
+            filter_options.assistant_ids
+            and self.payload.assistant_id not in filter_options.assistant_ids
+        ):
+            return True
+
+        if (
+            filter_options.references_in_code
+            and self.payload.name not in filter_options.references_in_code
+        ):
+            return True
+
+        return super().filter_event(filter_options=filter_options)
 
 
 class LogDetail(BaseModel):

unique_toolkit/agentic_table/synthetic_chat_event.py

@@ -0,0 +1,67 @@
+"""Synthetic :class:`ChatEvent` for magic-table runs with chat-typed toolkit APIs."""
+
+from unique_toolkit.agentic_table.schemas import MagicTableEvent
+from unique_toolkit.app.schemas import (
+    ChatEvent,
+    ChatEventAssistantMessage,
+    ChatEventPayload,
+    ChatEventUserMessage,
+    EventName,
+)
+from unique_toolkit.app.unique_settings import (
+    MAGIC_TABLE_STREAMING_ASSISTANT_MESSAGE_ID,
+    MAGIC_TABLE_STREAMING_USER_MESSAGE_ID,
+)
+
+_MAGIC_TABLE_STREAMING_MESSAGE_CREATED_AT = "1970-01-01T00:00:00Z"
+
+
+def build_synthetic_chat_event(
+    event: MagicTableEvent,
+    *,
+    event_id: str | None = None,
+    description: str = "magic-table",
+) -> ChatEvent:
+    """Build a :class:`ChatEvent` for evaluators/tools that still require chat typing.
+
+    Discouraged for new code: prefer :meth:`UniqueContext.from_magic_table_event`
+    and ``Service.from_context(...)`` / :meth:`ToolManager.from_run_context`
+    so callers do not depend on a fabricated chat envelope.
+
+    Magic-table runs create messages dynamically; placeholder message ids are
+    sufficient for search tooling and hallucination evaluation scoping.
+    """
+    payload = event.payload
+    chat_id = payload.chat_id
+    if not chat_id:
+        msg = (
+            "Magic-table event is missing chat_id; "
+            "chat-scoped services cannot be built."
+        )
+        raise ValueError(msg)
+    return ChatEvent(
+        id=event_id or event.id,
+        event=EventName.EXTERNAL_MODULE_CHOSEN,
+        user_id=event.user_id,
+        company_id=event.company_id,
+        payload=ChatEventPayload(
+            name=payload.name,
+            chat_id=chat_id,
+            assistant_id=payload.assistant_id,
+            description=description,
+            configuration=payload.configuration,
+            metadata_filter=payload.metadata_filter,
+            correlation=payload.correlation,
+            user_message=ChatEventUserMessage(
+                id=MAGIC_TABLE_STREAMING_USER_MESSAGE_ID,
+                text="",
+                original_text="",
+                created_at=_MAGIC_TABLE_STREAMING_MESSAGE_CREATED_AT,
+                language="EN",
+            ),
+            assistant_message=ChatEventAssistantMessage(
+                id=MAGIC_TABLE_STREAMING_ASSISTANT_MESSAGE_ID,
+                created_at=_MAGIC_TABLE_STREAMING_MESSAGE_CREATED_AT,
+            ),
+        ),
+    )

unique_toolkit/app/schemas.py

@@ -250,14 +250,36 @@ class ChatEventSkill(BaseModel):
 SkillReference = ChatEventSkill
 
 
-class ChatEventPayload(BaseModel):
+class BaseEventPayload(BaseModel):
+    """Common payload fields shared by all assistant-context webhook events.
+
+    Both :class:`ChatEventPayload` and :class:`MagicTableBasePayload` extend
+    this. Services that only need the common envelope (``chat_id``,
+    ``assistant_id``, ``metadata_filter``, ``correlation``, ...) should
+    accept :class:`AssistantWebhookEvent` and read the payload off this
+    shared shape; services that need chat-only fields (``user_message``,
+    ``assistant_message``) must accept :class:`ChatEvent` explicitly.
+    """
+
     model_config = model_config
 
-    name: str
-    description: str
-    configuration: dict[str, Any]
+    name: str = Field(description="The module / action name driving the event.")
     chat_id: str
     assistant_id: str
+    configuration: dict[str, Any]
+    # Default is None as empty dict triggers error in `backend-ingestion`
+    metadata_filter: dict[str, Any] | None = Field(
+        default=None,
+        description="Metadata filter compiled after module selection function calling and scope rules.",
+    )
+    correlation: Correlation | None = Field(
+        default=None,
+        description="The correlation to parent message in another chat.",
+    )
+
+
+class ChatEventPayload(BaseEventPayload):
+    description: str
     user_message: ChatEventUserMessage
     assistant_message: ChatEventAssistantMessage
     text: str | None = None
@@ -296,11 +318,6 @@ class ChatEventPayload(BaseModel):
         default_factory=dict,
         description="Parameters extracted from module selection function calling the tool.",
     )
-    # Default is None as empty dict triggers error in `backend-ingestion`
-    metadata_filter: dict[str, Any] | None = Field(
-        default=None,
-        description="Metadata filter compiled after module selection function calling and scope rules.",
-    )
     raw_scope_rules: UniqueQL | None = Field(
         default=None,
         description="Raw UniqueQL rule that can be compiled to a metadata filter.",
@@ -317,10 +334,6 @@ class ChatEventPayload(BaseModel):
         default=None,
         description="The session configuration for the chat session.",
     )
-    correlation: Correlation | None = Field(
-        default=None,
-        description="The correlation to parent message in another chat.",
-    )
 
     @field_validator("raw_scope_rules", mode="before")
     def validate_scope_rules(cls, value: dict[str, Any] | None) -> UniqueQL | None:
@@ -341,13 +354,39 @@ class EventPayload(ChatEventPayload):
     # additional_parameters: Optional[EventAdditionalParameters] = None
 
 
-class ChatEvent(BaseEvent[UniqueChatEventFilterOptions]):
+PayloadT_co = TypeVar("PayloadT_co", bound=BaseEventPayload, covariant=True)
+
+
+class AssistantWebhookEvent(
+    BaseEvent[FilterOptionsT], Generic[FilterOptionsT, PayloadT_co]
+):
+    """Umbrella envelope for webhook events that carry assistant/chat context.
+
+    The payload is constrained to :class:`BaseEventPayload`, giving consumers
+    a typed view of the shared envelope fields (``chat_id``, ``assistant_id``,
+    ``metadata_filter``, ``correlation``, ...). Concrete events specialize
+    the payload type:
+
+    * :class:`ChatEvent` → :class:`ChatEventPayload`
+    * ``MagicTableEvent`` → ``MagicTablePayloadTypes`` (discriminated union)
+
+    ``PayloadT_co`` is covariant so that ``AssistantWebhookEvent[..., ChildPayload]``
+    is a subtype of ``AssistantWebhookEvent[..., ParentPayload]``. This lets a
+    service signature accept *any* assistant-context event while still
+    accessing the common ``BaseEventPayload`` shape in a type-checked way.
+    """
+
     model_config = model_config
 
-    payload: ChatEventPayload
+    # Covariant payload must stay read-only; reassignment through a widened type is unsound.
+    payload: PayloadT_co = Field(frozen=True)
     created_at: Optional[int] = None
     version: Optional[str] = None
 
+
+class ChatEvent(AssistantWebhookEvent[UniqueChatEventFilterOptions, ChatEventPayload]):
+    model_config = model_config
+
     class FilterOptions(BaseSettings):
         assistant_ids: list[str] = Field(
             default=[],

unique_toolkit/app/unique_settings.py

@@ -26,8 +26,13 @@ from unique_toolkit.app.feature_flags import UNIQUE_TOOLKIT_FEATURE_FLAGS
 from unique_toolkit.app.find_env_file import EnvFileNotFoundError, find_env_file
 
 if TYPE_CHECKING:
+    from unique_toolkit.agentic_table.schemas import MagicTableEvent
     from unique_toolkit.app.schemas import BaseEvent, ChatEvent
 
+# Placeholder message ids for magic-table runs that create messages dynamically.
+MAGIC_TABLE_STREAMING_ASSISTANT_MESSAGE_ID = "magic-table-streaming-assistant"
+MAGIC_TABLE_STREAMING_USER_MESSAGE_ID = "magic-table-streaming-user"
+
 
 logger = getLogger(__name__)
 
@@ -485,6 +490,39 @@ class UniqueContext:
             chat=ChatContext.from_chat_event(event),
         )
 
+    @classmethod
+    def from_magic_table_event(cls, event: MagicTableEvent) -> Self:
+        """Build auth + chat context from a magic-table webhook event.
+
+        Magic-table payloads carry ``chat_id`` and ``assistant_id`` but no live
+        user/assistant message objects. Placeholder message ids are used so
+        chat-scoped services (e.g. :class:`ChatService`) can be constructed via
+        :meth:`from_context`; do not use this context for short-term memory
+        writes that require a real message id.
+        """
+        payload = event.payload
+        if not payload.chat_id:
+            msg = (
+                "Magic-table event is missing chat_id; "
+                "chat-scoped services cannot be built."
+            )
+            raise ValueError(msg)
+        parent_chat_id = (
+            payload.correlation.parent_chat_id if payload.correlation else None
+        )
+        return cls(
+            auth=AuthContext.from_event(event),
+            chat=ChatContext(
+                chat_id=payload.chat_id,
+                assistant_id=payload.assistant_id,
+                last_assistant_message_id=MAGIC_TABLE_STREAMING_ASSISTANT_MESSAGE_ID,
+                last_user_message_id=MAGIC_TABLE_STREAMING_USER_MESSAGE_ID,
+                last_user_message_text="",
+                metadata_filter=payload.metadata_filter,
+                parent_chat_id=parent_chat_id,
+            ),
+        )
+
     @classmethod
     def from_event(cls, event: BaseEvent[Any]) -> Self:
         """Build an auth-only context from any BaseEvent."""

unique_toolkit/chat/functions.py

@@ -180,6 +180,7 @@ def map_references(references: list[ContentReference]) -> list[dict[str, Any]]:
     return [
         {
             "name": ref.name,
+            "description": ref.description,
             "url": ref.url,
             "sequenceNumber": ref.sequence_number,
             "sourceId": ref.source_id,
@@ -199,6 +200,7 @@ def map_references_with_original_index(
     return [
         {
             "name": ref.name,
+            "description": ref.description,
             "url": ref.url,
             "sequenceNumber": ref.sequence_number,
             "sourceId": ref.source_id,

unique_toolkit/content/schemas.py

@@ -215,6 +215,17 @@ class ContentReference(BaseModel):
     sequence_number: int
     source: str
     source_id: str
+    description: str | None = Field(
+        default=None,
+        description=(
+            "Optional free-text/structured description carried alongside the "
+            "reference. Used by MCP tool references (UN-22310) to carry an "
+            'enriched ``{"mcp": {connectorName, title, details?, mcpServerId?}}`` '
+            "JSON payload the chat frontend renders as a card. Nullable "
+            "end-to-end (node-chat persists it as a nullable column; empty "
+            "values are dropped before sending)."
+        ),
+    )
     url: str | None = Field(
         default=None,
         description=(
@@ -241,6 +252,8 @@ class ContentReference(BaseModel):
             "source": reference["source"],
             "source_id": reference["sourceId"],
         }
+        if "description" in reference:
+            kwargs["description"] = reference["description"]
         if "originalIndex" in reference:
             kwargs["original_index"] = reference["originalIndex"]
 

unique_toolkit/content/service.py

@@ -4,12 +4,12 @@ from typing import Any, overload
 
 import unique_sdk
 from requests import Response
-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._common.validate_required_values import validate_required_values
-from unique_toolkit.app.schemas import BaseEvent, ChatEvent, Correlation, Event
-from unique_toolkit.app.unique_settings import UniqueSettings
+from unique_toolkit.app.schemas import AssistantWebhookEvent, BaseEvent, Correlation
+from unique_toolkit.app.unique_settings import UniqueContext, UniqueSettings
 from unique_toolkit.content import DOMAIN_NAME
 from unique_toolkit.content.constants import DEFAULT_SEARCH_LANGUAGE
 from unique_toolkit.content.functions import (
@@ -46,7 +46,7 @@ class ContentService:
         "Use __init__ with company_id, user_id and chat_id instead or use the classmethod `from_event`"
     )
     @overload
-    def __init__(self, event: Event | ChatEvent | BaseEvent[Any]): ...
+    def __init__(self, event: BaseEvent[Any]): ...
 
     """
         Initialize the ContentService with an event (deprecated)
@@ -68,7 +68,7 @@ class ContentService:
 
     def __init__(
         self,
-        event: Event | BaseEvent[Any] | None = None,
+        event: BaseEvent[Any] | None = None,
         company_id: str | None = None,
         user_id: str | None = None,
         chat_id: str | None = None,
@@ -78,23 +78,32 @@ class ContentService:
         Initialize the ContentService with a company_id, user_id and chat_id.
         """
 
-        self._event = event  # Changed to protected attribute
+        if event is not None:
+            if isinstance(event, AssistantWebhookEvent):
+                delegated = type(self).from_event(event)
+                self._event = event
+                self._company_id = delegated._company_id
+                self._user_id = delegated._user_id
+                self._chat_id = delegated._chat_id
+                self._metadata_filter = delegated._metadata_filter
+                return
+
+            self._event = event
+            self._metadata_filter = None
+            self._company_id = event.company_id
+            self._user_id = event.user_id
+            return
+
+        self._event = None
         self._metadata_filter = None
-        if event:
-            self._company_id: str = event.company_id
-            self._user_id: str = event.user_id
-            if isinstance(event, (ChatEvent, Event)):
-                self._metadata_filter = event.payload.metadata_filter
-                self._chat_id: str | None = event.payload.chat_id
-        else:
-            [company_id, user_id] = validate_required_values([company_id, user_id])
-            self._company_id = company_id
-            self._user_id = user_id
-            self._chat_id = chat_id
-            self._metadata_filter = metadata_filter
+        [company_id, user_id] = validate_required_values([company_id, user_id])
+        self._company_id = company_id
+        self._user_id = user_id
+        self._chat_id = chat_id
+        self._metadata_filter = metadata_filter
 
     @classmethod
-    def from_event(cls, event: Event | ChatEvent | BaseEvent[Any]):
+    def from_event(cls, event: BaseEvent[Any]):
         """Initialize the ContentService with an event.
 
         When the event has a correlation (e.g. subagent run), delegates to
@@ -109,32 +118,26 @@ class ContentService:
             ContentService: Instance scoped to the event's chat or, when
                 correlation is present, the parent chat.
         """
-        if (
-            isinstance(event, (ChatEvent, Event))
-            and getattr(event.payload, "correlation", None) is not None
-        ):
-            if event.payload.correlation is None:
-                raise ValueError(
-                    "correlation attribute is not defined in the event payload"
+        if isinstance(event, AssistantWebhookEvent):
+            payload = event.payload
+            if payload.correlation is not None:
+                return cls.from_correlation(
+                    event.company_id,
+                    event.user_id,
+                    payload.correlation,
+                    metadata_filter=payload.metadata_filter,
                 )
-            return cls.from_correlation(
-                event.company_id,
-                event.user_id,
-                event.payload.correlation,
-                metadata_filter=getattr(event.payload, "metadata_filter", None),
-            )
-        chat_id = None
-        metadata_filter = None
 
-        if isinstance(event, (ChatEvent | Event)):
-            chat_id = event.payload.chat_id
-            metadata_filter = event.payload.metadata_filter
+            return cls(
+                company_id=event.company_id,
+                user_id=event.user_id,
+                chat_id=payload.chat_id,
+                metadata_filter=payload.metadata_filter,
+            )
 
         return cls(
             company_id=event.company_id,
             user_id=event.user_id,
-            chat_id=chat_id,
-            metadata_filter=metadata_filter,
         )
 
     @classmethod
@@ -167,11 +170,41 @@ class ContentService:
             metadata_filter=metadata_filter,
         )
 
+    @classmethod
+    def from_context(
+        cls,
+        context: UniqueContext,
+        *,
+        metadata_filter: dict[str, Any] | None = None,
+    ) -> Self:
+        """Create a ContentService from a :class:`UniqueContext`.
+
+        When ``context.chat.parent_chat_id`` is set (subagent correlation),
+        content operations are scoped to the parent chat.
+        """
+        if context.chat is None:
+            msg = "ContentService requires chat context (context.chat is None)"
+            raise ValueError(msg)
+        chat = context.chat
+        effective_filter = (
+            metadata_filter if metadata_filter is not None else chat.metadata_filter
+        )
+        chat_id = (
+            chat.parent_chat_id if chat.parent_chat_id is not None else chat.chat_id
+        )
+        return cls(
+            company_id=context.auth.get_confidential_company_id(),
+            user_id=context.auth.get_confidential_user_id(),
+            chat_id=chat_id,
+            metadata_filter=effective_filter,
+        )
+
     @classmethod
     def from_settings(
         cls,
         settings: UniqueSettings | str | None = None,
         metadata_filter: dict[str, Any] | None = None,
+        **kwargs: Any,
     ):
         """
         Initialize the ContentService with a settings object and metadata filter.
@@ -182,6 +215,12 @@ class ContentService:
         elif isinstance(settings, str):
             settings = UniqueSettings.from_env_auto_with_sdk_init(filename=settings)
 
+        if settings.context.chat is not None:
+            return cls.from_context(
+                settings.context,
+                metadata_filter=metadata_filter,
+            )
+
         return cls(
             company_id=settings.auth.company_id.get_secret_value(),
             user_id=settings.auth.user_id.get_secret_value(),
@@ -192,7 +231,7 @@ class ContentService:
     @deprecated(
         "The event property is deprecated and will be removed in a future version."
     )
-    def event(self) -> Event | BaseEvent[Any] | None:
+    def event(self) -> BaseEvent[Any] | None:
         """
         Get the event object (deprecated).
 

unique_toolkit/language_model/service.py

@@ -5,7 +5,7 @@ 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.schemas import AssistantWebhookEvent, BaseEvent
 from unique_toolkit.app.unique_settings import UniqueSettings
 from unique_toolkit.content.schemas import ContentChunk
 from unique_toolkit.language_model.constants import (
@@ -40,7 +40,7 @@ class LanguageModelService:
         "Use __init__ with company_id and user_id instead or use the classmethod `from_event`"
     )
     @overload
-    def __init__(self, event: Event | ChatEvent | BaseEvent[Any]): ...
+    def __init__(self, event: BaseEvent[Any]): ...
 
     """
         Initialize the LanguageModelService with an event (deprecated)
@@ -55,30 +55,30 @@ class LanguageModelService:
 
     def __init__(
         self,
-        event: Event | ChatEvent | BaseEvent[Any] | None = None,
+        event: BaseEvent[Any] | None = None,
         company_id: str | None = None,
         user_id: str | None = None,
         **kwargs: dict[str, Any],  # only here for backward compatibility
     ):
-        if isinstance(event, (ChatEvent, Event)):
+        if event is not None:
+            auth_scoped = type(self).from_event(event)
+            self._company_id = auth_scoped._company_id
+            self._user_id = auth_scoped._user_id
             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
+            if isinstance(event, AssistantWebhookEvent):
+                payload = event.payload
+                self._chat_id = payload.chat_id
+                self._assistant_id = payload.assistant_id
+            return
+
+        [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[Any]):
@@ -88,7 +88,7 @@ class LanguageModelService:
         return cls(company_id=event.company_id, user_id=event.user_id)
 
     @classmethod
-    def from_settings(cls, settings: UniqueSettings | str | None = None):
+    def from_settings(cls, settings: UniqueSettings | str | None = None, **kwargs: Any):
         """
         Initialize the LanguageModelService with a settings object.
         """
@@ -106,7 +106,7 @@ class LanguageModelService:
     @deprecated(
         "The event property is deprecated and will be removed in a future version."
     )
-    def event(self) -> Event | BaseEvent[Any] | None:
+    def event(self) -> BaseEvent[Any] | None:
         """
         Get the event object (deprecated).
 

unique_toolkit/services/factory.py

@@ -138,7 +138,8 @@ class UniqueServiceFactory:
     def register_known_services(cls) -> None:
         """Register the stable toolkit services with the factory.
 
-        Currently registers :class:`KnowledgeBaseService` and :class:`ChatService`.
+        Currently registers :class:`KnowledgeBaseService`, :class:`ChatService`,
+        :class:`ContentService`, and :class:`LanguageModelService`.
         :class:`ChunkRelevancySorter` is intentionally excluded to avoid circular
         imports at package init time — use the ``chunk_relevancy_sorter()``
         convenience method instead.
@@ -149,10 +150,17 @@ class UniqueServiceFactory:
         example, :meth:`Identity.from_settings`) so that the experimental
         dependency is visible at every call site.
         """
+        from unique_toolkit.content.service import ContentService
+        from unique_toolkit.language_model.service import LanguageModelService
         from unique_toolkit.services.chat_service import ChatService
         from unique_toolkit.services.knowledge_base import KnowledgeBaseService
 
-        for service_class in [KnowledgeBaseService, ChatService]:
+        for service_class in [
+            KnowledgeBaseService,
+            ChatService,
+            ContentService,
+            LanguageModelService,
+        ]:
             if service_class.__name__ not in cls._registry:
                 cls.register(service_class=service_class)
 

unique_toolkit/services/knowledge_base.py

@@ -16,7 +16,7 @@ from unique_toolkit._common.metadata_filter_scope import (
     merge_scope_clause_into_metadata_filter,
 )
 from unique_toolkit._common.validate_required_values import validate_required_values
-from unique_toolkit.app.schemas import BaseEvent, ChatEvent, Event
+from unique_toolkit.app.schemas import AssistantWebhookEvent, BaseEvent
 from unique_toolkit.app.unique_settings import UniqueSettings
 from unique_toolkit.content.constants import (
     DEFAULT_SEARCH_LANGUAGE,
@@ -93,7 +93,7 @@ class KnowledgeBaseService:
         """
         metadata_filter = None
 
-        if isinstance(event, (ChatEvent | Event)):
+        if isinstance(event, AssistantWebhookEvent):
             metadata_filter = event.payload.metadata_filter
 
         return cls(

unique_toolkit/short_term_memory/service.py

@@ -52,23 +52,33 @@ class ShortTermMemoryService:
         chat_id: str | None = None,
         message_id: str | None = None,
     ):
-        self._event = event
-        if event:
-            self._company_id: str = event.company_id
-            self._user_id: str = event.user_id
-            if isinstance(event, (ChatEvent, Event)):
-                self._chat_id = event.payload.chat_id
-                self._message_id = event.payload.user_message.id
-        else:
-            [company_id, user_id] = validate_required_values([company_id, user_id])
-
-            if not (chat_id or message_id):
-                raise ValueError("Chat_id or message_id must be provided")
-
-            self._company_id = company_id
-            self._user_id = user_id
-            self._chat_id = chat_id
-            self._message_id = message_id
+        if event is not None:
+            if isinstance(event, ChatEvent):
+                delegated = type(self).from_event(event)
+                self._event = event
+                self._company_id = delegated._company_id
+                self._user_id = delegated._user_id
+                self._chat_id = delegated._chat_id
+                self._message_id = delegated._message_id
+                return
+
+            self._event = event
+            self._company_id = event.company_id
+            self._user_id = event.user_id
+            self._chat_id = None
+            self._message_id = None
+            return
+
+        self._event = None
+        [company_id, user_id] = validate_required_values([company_id, user_id])
+
+        if not (chat_id or message_id):
+            raise ValueError("Chat_id or message_id must be provided")
+
+        self._company_id = company_id
+        self._user_id = user_id
+        self._chat_id = chat_id
+        self._message_id = message_id
 
     @classmethod
     def from_event(cls, event: ChatEvent):

{unique_toolkit-2026.28.0.dev6.dist-info → unique_toolkit-2026.28.0.dev8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-toolkit
-Version: 2026.28.0.dev6
+Version: 2026.28.0.dev8
 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>
@@ -16,7 +16,7 @@ Requires-Dist: sseclient>=0.0.27,<0.0.28
 Requires-Dist: openai>=1.105.0,<3
 Requires-Dist: platformdirs>=4.0.0,<5
 Requires-Dist: pillow>=12.1.1
-Requires-Dist: unique-sdk>=2026.28.0.dev8,<2026.28.0rc0
+Requires-Dist: unique-sdk>=2026.28.0.dev11,<2026.28.0rc0
 Requires-Dist: jambo>=0.1.2,<0.2
 Requires-Dist: jinja2>=3.1.6,<4
 Requires-Dist: docxtpl>=0.20.1,<0.21

{unique_toolkit-2026.28.0.dev6.dist-info → unique_toolkit-2026.28.0.dev8.dist-info}/RECORD

@@ -7,7 +7,7 @@ unique_toolkit/_common/base_model_type_attribute.py,sha256=3t2InDT3nxG9YMEg0M90_
 unique_toolkit/_common/chunk_relevancy_sorter/config.py,sha256=_9ACfqI-69DzN2azdt9dUhBRvS6NbTjqqNfm77Qn_5M,1889
 unique_toolkit/_common/chunk_relevancy_sorter/exception.py,sha256=1mY4zjbvnXsd5oIxwiVsma09bS2XRnHrxW8KJBGtgCM,126
 unique_toolkit/_common/chunk_relevancy_sorter/schemas.py,sha256=Cg9vNDPmkn5V_j6ssV58ADcEaDURNP5TeUa1UmRtdHw,1343
-unique_toolkit/_common/chunk_relevancy_sorter/service.py,sha256=AmowH3VA3PC1MmSto6x5HO3GUlM8deT2BNFnkPQcB_M,14770
+unique_toolkit/_common/chunk_relevancy_sorter/service.py,sha256=pCwRJRdCqXK_2a7kAm3K9VZRCjaLntek8OtoCyRpHQE,14757
 unique_toolkit/_common/chunk_relevancy_sorter/tests/test_service.py,sha256=giD9b5W8A0xP18dZCcrLUruoGi38BeBvPnO1phY7Sp0,8892
 unique_toolkit/_common/config_checker/README.md,sha256=4WXBP5DIyEwklSi8RkVpKYYUPo_qOvm_8zEAz9WsdcU,11564
 unique_toolkit/_common/config_checker/__init__.py,sha256=iGtDFILDQrjSpxC_hNut_H6hQxQ_exDp6GQrgMSdn0U,1204
@@ -90,7 +90,7 @@ unique_toolkit/agentic/evaluation/context_relevancy/prompts/__init__.py,sha256=I
 unique_toolkit/agentic/evaluation/context_relevancy/prompts/system_prompt.j2,sha256=PFT9Y7QQ85h-ronwK8sq6zJJrxfrZhvZkYHXspMdDHU,985
 unique_toolkit/agentic/evaluation/context_relevancy/prompts/user_prompt.j2,sha256=9HXm0Qg0xAPIE5mnaUiHrscolD_qO7f83qlIjXiP1n4,150
 unique_toolkit/agentic/evaluation/context_relevancy/schema.py,sha256=lZd0TPzH43ifgWWGg3WO6b1AQX8aK2R9y51yH0d1DHM,2919
-unique_toolkit/agentic/evaluation/context_relevancy/service.py,sha256=i6WA_BwHyhHDfnvK59UC0z1FgZ8EPW5OJyYLbSxNRic,8760
+unique_toolkit/agentic/evaluation/context_relevancy/service.py,sha256=OYr5_uQmovFtvsXVItqDw1VUW5rP-LED9XElx-kh5MM,8747
 unique_toolkit/agentic/evaluation/evaluation_manager.py,sha256=4HeKsDg6tLkJXNw3kzjmVLbD-86IRzKLQSuPwYtfYBk,7992
 unique_toolkit/agentic/evaluation/exception.py,sha256=7lcVbCyoN4Md1chNJDFxpUYyWbVrcr9dcc3TxWykJTc,115
 unique_toolkit/agentic/evaluation/hallucination/constants.py,sha256=uEQR-CNKmeXizDaLOLHhwTZ0iYUmFwoKeMLHPm4M0sY,3208
@@ -187,7 +187,7 @@ unique_toolkit/agentic/tools/experimental/open_file_tool/runtime.py,sha256=SOIFV
 unique_toolkit/agentic/tools/experimental/open_file_tool/tool.py,sha256=BXsEeyJ1Njswl_PChfO-vVz2MzFzmDcN2Few9WBWdXU,3774
 unique_toolkit/agentic/tools/experimental/retrieve_search_scope_tool/__init__.py,sha256=kD6BaQWgOWk8fPYVBuCUnfHWcJNuH4KjWAreORAkfWI,357
 unique_toolkit/agentic/tools/experimental/retrieve_search_scope_tool/config.py,sha256=NI-dk1Sai-t32PD5AUIyeGguPeV-qZhn4F8-nIHXAhA,4271
-unique_toolkit/agentic/tools/experimental/retrieve_search_scope_tool/tool.py,sha256=Egxrq_9TVNOaCvBtEuLsaolOdeGyxaJxYU6ibOMfC2A,7514
+unique_toolkit/agentic/tools/experimental/retrieve_search_scope_tool/tool.py,sha256=4r9nX6iFvmYtnV1VnsWaINcnTLvU665ha3pgQSquh8U,7513
 unique_toolkit/agentic/tools/experimental/todo/__init__.py,sha256=QzaC8tqBFrjfZbYSxvWJkWyFYel1ejrbx8IN63d0YCo,583
 unique_toolkit/agentic/tools/experimental/todo/config.py,sha256=52GamaMU6VrCd__JgyRoJfEL_Dp0y8CPf3jwYCkXVBg,3506
 unique_toolkit/agentic/tools/experimental/todo/prompts/__init__.py,sha256=DlBk0Ex5w41XtcmnLdGFK9r4mVfBHweFwc8dZB5tXVI,379
@@ -214,11 +214,12 @@ unique_toolkit/agentic/tools/openai_builtin/code_interpreter/postprocessors/gene
 unique_toolkit/agentic/tools/openai_builtin/code_interpreter/schemas.py,sha256=W7egCmYrPrzic0aXsu9wY5fvQ8y_cl4Tzq_cjVs0mZs,542
 unique_toolkit/agentic/tools/openai_builtin/code_interpreter/service.py,sha256=k10VBHL2vVlEylNF3EWGvm8_wZ_44K1pJ5ngGirUzOA,14275
 unique_toolkit/agentic/tools/openai_builtin/manager.py,sha256=CkfMRsjrRDv_X-zfJHZnxxOdpCK1qzf6RGGxKtUHp9k,3519
+unique_toolkit/agentic/tools/run_context.py,sha256=lk9tS1wn97NcSByNZpJWunnnZTos9H2SsxUkKKAvW_A,783
 unique_toolkit/agentic/tools/schemas.py,sha256=4BTJ0q7fiAVQ2Uy9kVJnS0rcKeKKaYTkOFq8XGZwMJ0,5291
 unique_toolkit/agentic/tools/test/test_mcp_manager.py,sha256=uWrTmnenQ70s5hrTfMYVah2vDT-jZq4nQmvhutypEK8,19195
 unique_toolkit/agentic/tools/test/test_tool_progress_reporter.py,sha256=XHNezB8itj9KzpQgD0cwRtp2AgRUfUkQsHc3bTyPj6c,15801
-unique_toolkit/agentic/tools/tool.py,sha256=l92-yE8zgwYoaZGm3VmgKCw6CfyFeMiiWxPHqgRjNB4,9176
-unique_toolkit/agentic/tools/tool_manager.py,sha256=lsFfKPVJgJwlDc1YE80o0z6Ktfo13us4OhO2m9EZikc,23355
+unique_toolkit/agentic/tools/tool.py,sha256=jDGXRD9H0aagibLARWjJaX8DGMFjICeCojgONs40ghY,10721
+unique_toolkit/agentic/tools/tool_manager.py,sha256=FNf_Yfi-Nt8YfGA3A_ZHUStzSuIJiY_rSdRJLVGu6z8,27719
 unique_toolkit/agentic/tools/tool_progress_reporter.py,sha256=GaR0oqDUJZvBB9WCUVYYh0Zvs6U-LMygJCCrqPlitgA,10296
 unique_toolkit/agentic/tools/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 unique_toolkit/agentic/tools/utils/source_handling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -226,8 +227,9 @@ unique_toolkit/agentic/tools/utils/source_handling/schema.py,sha256=iHBKuks6tUy8
 unique_toolkit/agentic/tools/utils/source_handling/source_formatting.py,sha256=uZ0QXqrPWgId3ZA67dvjHQ6xrW491LK1xxx_sVJmFHg,9160
 unique_toolkit/agentic/tools/utils/source_handling/tests/test_source_formatting.py,sha256=EA8iVvb3L91OFk2XMbGcFuhe2etqm3Sx9QCYDGiOSOM,6995
 unique_toolkit/agentic_table/__init__.py,sha256=bTMTBUomZysXhMtP9Rnzk6hVa2lZ7Xmrn-THZzE8uWo,1737
-unique_toolkit/agentic_table/schemas.py,sha256=CClyrQnI847iVBbhz1LDzTyiR39Qq2jP7z-FR4qjCU8,10988
+unique_toolkit/agentic_table/schemas.py,sha256=IhVVSWZyDVIeyVoiP-FWp26MWwXv8oL4KFPTzeQquCc,12568
 unique_toolkit/agentic_table/service.py,sha256=26hblR33Vp8FWWMgtaQCJ0IQT8hmGzGCQy86BDi2wOo,19670
+unique_toolkit/agentic_table/synthetic_chat_event.py,sha256=MylvYuhx5CVt2DbPetzV0sR8GlkL218DmNFi7A6RYVs,2373
 unique_toolkit/app/__init__.py,sha256=VnyvvCugDYZzEK93vVpSL1zHGduuev6yOvLJOGzpmMc,1568
 unique_toolkit/app/chat_event_filter_options_settings.py,sha256=W0Ydio1UeED5_xqaTzbcGzK2tH4EpA1WHUzdF-iWpqI,364
 unique_toolkit/app/dev_util.py,sha256=cHDuC6jtaptdVISbtMmOCqRTTWBPeCoIUQvUQvcmVyY,5517
@@ -238,15 +240,15 @@ unique_toolkit/app/init_logging.py,sha256=Lv0FuEiUmxvtV2yovjD0gWNIvLdsi2xdMFeEiN
 unique_toolkit/app/init_sdk.py,sha256=5_oDoETr6akwYyBCb0ivTdMNu3SVgPSkrXcDS6ELyY8,2269
 unique_toolkit/app/performance/async_tasks.py,sha256=8Xv5kEmmFDJO7YyyBxv4e7bcNgq-3z_E2_4z1Yn9EqU,1970
 unique_toolkit/app/performance/async_wrapper.py,sha256=yVVcRDkcdyfjsxro-N29SBvi-7773wnfDplef6-y8xw,1077
-unique_toolkit/app/schemas.py,sha256=f5h9BqCuqHvrXUAB7tjrx0PSLmuJJKlZ89othqOsuSY,14762
-unique_toolkit/app/unique_settings.py,sha256=XrRcKobm0DHFIFJvScEeRVBDmRotBZTz9qctg34FbY8,23364
+unique_toolkit/app/schemas.py,sha256=NWaj7cpNiXaxU6W-U-bw911cdpXjqsbSUGeVoN4Q3Js,16534
+unique_toolkit/app/unique_settings.py,sha256=nN_5PxBepHXUSd3yL2r7Ex1cVUf8r79uvRk2qa9exh0,25079
 unique_toolkit/app/verification.py,sha256=GxFFwcJMy25fCA_Xe89wKW7bgqOu8PAs5y8QpHF0GSc,3861
 unique_toolkit/app/webhook.py,sha256=evpxLDnvz7P3D7-TV1XBkl8WcoldXpjOkw3tvFRxHr0,2368
 unique_toolkit/chat/__init__.py,sha256=N9RubtxWN7UF0DlxP7YgeNTgjjk6p7AwkbGaVvuZCv0,938
 unique_toolkit/chat/cancellation.py,sha256=HvGZK-daCMSr0M0AnvMY3EBPH1N_UqQPfrbTjwr8owk,5645
 unique_toolkit/chat/constants.py,sha256=05kq6zjqUVB2d6_P7s-90nbljpB3ryxwCI-CAz0r2O4,83
 unique_toolkit/chat/deprecated/service.py,sha256=8_XoopUWHT396Z_5gwMmsI6v4NGVgQirSJCYUW4Gx8c,9339
-unique_toolkit/chat/functions.py,sha256=vj0sdeBVm-vsrZOwsHAfCUtpdTwQNgr-aVayvRhUCp4,52360
+unique_toolkit/chat/functions.py,sha256=8PXqo4X2BJhsbHkD9X5Ykqz-iVqbRJ1UlWuCNl1XSX8,52448
 unique_toolkit/chat/rendering.py,sha256=c8YiV9oADRrJQ5A_QBJ4_UFc0NZ-2vVaa7tupoMusso,880
 unique_toolkit/chat/responses_api.py,sha256=QtCOe3TI242N1JChhoFikxUCvGY6xfTvSmaE9Ta8HSM,19811
 unique_toolkit/chat/schemas.py,sha256=l-Epugu27RoajiX5OkFO-BrVNey-wfTmaXiEmNNmG7s,7396
@@ -256,8 +258,8 @@ unique_toolkit/chat/utils.py,sha256=CsD9IER2gA1IOV0fmUOl-N0LmKvA7JP9dGrOqeOY0Gg,
 unique_toolkit/content/__init__.py,sha256=nnQDfnNTEvI8-3dgWvIojoFDYU7edwd8Kloi6lMDG0M,1586
 unique_toolkit/content/constants.py,sha256=1iy4Y67xobl5VTnJB6SxSyuoBWbdLl9244xfVMUZi5o,60
 unique_toolkit/content/functions.py,sha256=avnlEQ1FkVz2NTbXUkafU04jzygqOJtUMQL605rEL4c,34019
-unique_toolkit/content/schemas.py,sha256=00qbe-DlUjqlf-n3QVOotZjpsj0LZNnUoPmdwyMjVHY,10667
-unique_toolkit/content/service.py,sha256=fR93_76aPczx2voxR7cvYDs_-pxD-Mc9WP6-5IqA8ko,28301
+unique_toolkit/content/schemas.py,sha256=AmnlqMpA_JgbgsaZF6Xdy8kt9lcY0YCqlfqpG1tYWeE,11306
+unique_toolkit/content/service.py,sha256=S_sFtG1hJd-zz7XyP-6Gu-B8_Xx-r5v46qZLWdRRyRs,29477
 unique_toolkit/content/smart_rules.py,sha256=9GlHXm63POTi4jy5hW0qUjeqy-JSeL1wIbURM1GKhc4,11481
 unique_toolkit/content/utils.py,sha256=keDkqu_ZzQY0y_g7g_XLOza3p4XsvfqVVDI9ylM91KY,10115
 unique_toolkit/data_extraction/README.md,sha256=5KxzqPHC29wxBiWJ-87wBQisSgRBkuSnPTb38pGH1wA,3138
@@ -383,7 +385,7 @@ unique_toolkit/language_model/infos.py,sha256=V3gKj4DyZwapbLAzDBPjw2D8LlWY9UaSAP
 unique_toolkit/language_model/prompt.py,sha256=JSawaLjQg3VR-E2fK8engFyJnNdk21zaO8pPIodzN4Q,3991
 unique_toolkit/language_model/reference.py,sha256=T3wr2jP_uRg5wKVIbKqLbxJlcgxfbZQGq3XdjbQ2kSo,6984
 unique_toolkit/language_model/schemas.py,sha256=JZbIT3w1cj5fKrYaQ55X7sjXmCo6i_GqgJ198V3RXSg,29474
-unique_toolkit/language_model/service.py,sha256=mzHYppmbFxXRHzsmQ4i_z9N4fheIEjomJeuGaEOFs9Y,12025
+unique_toolkit/language_model/service.py,sha256=hDoJBBgG_wWs8WuC_c8tnmK8cNu8o5EhJJXRvgwhkFQ,11956
 unique_toolkit/language_model/settings.py,sha256=xkoMv3ATb2ft5V3MA8JvqW-EO8AnZ5t-6rvdbTx6lFU,1490
 unique_toolkit/language_model/stream_transform.py,sha256=iNNGpLY_7G6Bpp9Y4KtbIkQm3WB4yZt75BXcqx0DVkI,2775
 unique_toolkit/language_model/utils.py,sha256=bPQ4l6_YO71w-zaIPanUUmtbXC1_hCvLK0tAFc3VCRc,1902
@@ -394,16 +396,16 @@ unique_toolkit/monitoring/registry.py,sha256=8r9jqaQoRHZveGRZe_GQvBzvQpmUV4cpw8E
 unique_toolkit/protocols/support.py,sha256=x5edzbBmKAUuvm3oLFh52gkgQsqR5LU7M0t8RHK0DZk,5161
 unique_toolkit/services/__init__.py,sha256=b9Wl7Wvz1JmZDbDexIZzBoXZ0wscXuczGAH8LoL-Qak,572
 unique_toolkit/services/chat_service.py,sha256=mh9lZr_AiNR0JSdiEU4kh2vkh5YQG4tASlQIRpeeEQI,95567
-unique_toolkit/services/factory.py,sha256=tZo49glnXyW0wc76PXG_c95p9SE2DL9V1UwrcaVXFPo,9525
-unique_toolkit/services/knowledge_base.py,sha256=wuH0KYLHpvpyq-ZCYleAe19AobMSYgd5I60jLNq-mwo,43439
+unique_toolkit/services/factory.py,sha256=7gNeanyHkgX23Iz7RMCQTCkE9gI5asCI11nXxM0jjx4,9832
+unique_toolkit/services/knowledge_base.py,sha256=a9itNRxIrGDIuXkLiTLBsA-m2ncy8F8DwCLCXtWm_GY,43446
 unique_toolkit/short_term_memory/__init__.py,sha256=2mI3AUrffgH7Yt-xS57EGqnHf7jnn6xquoKEhJqk3Wg,185
 unique_toolkit/short_term_memory/constants.py,sha256=698CL6-wjup2MvU19RxSmQk3gX7aqW_OOpZB7sbz_Xg,34
 unique_toolkit/short_term_memory/functions.py,sha256=mbEeWkJ5Jr0cvg1_m6l9aS1L6nWE5ZhviNzpKlCs-a8,7907
 unique_toolkit/short_term_memory/schemas.py,sha256=C6gopsnuIgWJBG7XF87gxMwzLJtqbSGmsKXUf2h1sn4,1666
-unique_toolkit/short_term_memory/service.py,sha256=Qo-c9yxzC1ZEEHJyIG_vnRs_ef0SKbjCAm-iH_JeJCk,8979
+unique_toolkit/short_term_memory/service.py,sha256=2JMBEBn6GoyK-a0xvdcWpPft-3C74xZ1hckAzj97n4M,9264
 unique_toolkit/smart_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 unique_toolkit/smart_rules/compile.py,sha256=vRe0aMJWuVIK-VsqomgxQImzke7MDmwgSxxJfYCa7zw,1386
 unique_toolkit/test_utilities/events.py,sha256=FLrhMh0A_mQutAUjoD0FdMcVQ4Gq31r35OVGzRjvLro,6760
-unique_toolkit-2026.28.0.dev6.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-unique_toolkit-2026.28.0.dev6.dist-info/METADATA,sha256=hoO0ZUgIV4theG_01eSZ0nk_8iU5vBqbxVk5St6xIW0,7426
-unique_toolkit-2026.28.0.dev6.dist-info/RECORD,,
+unique_toolkit-2026.28.0.dev8.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+unique_toolkit-2026.28.0.dev8.dist-info/METADATA,sha256=v9-siqdK8nGyMVGx7bXMB2dX4Z3RTGeS7KZZd4v069U,7427
+unique_toolkit-2026.28.0.dev8.dist-info/RECORD,,