unique_toolkit 1.46.9__tar.gz → 1.46.11__tar.gz

{unique_toolkit-1.46.9 → unique_toolkit-1.46.11}/CHANGELOG.md

@@ -5,6 +5,17 @@ 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.11] - 2026-02-20
+- Add OpenAI-proxy direct streaming with Python-side reference injection (UN-17264)
+- Add `stream_complete_with_references_openai()` using async OpenAI client and `chat.completions.stream()`
+- Add stream transformation pipeline: `StreamTransform` protocol, `TextTransformPipeline`, `ReferenceInjectionTransform` (reuses `add_references_to_message`), `NormalizationTransform` placeholder
+- Export `stream_complete_with_references_openai` and stream transform types from `unique_toolkit.language_model`
+
+## [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`
 

{unique_toolkit-1.46.9 → unique_toolkit-1.46.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unique_toolkit
-Version: 1.46.9
+Version: 1.46.11
 Summary: 
 License: Proprietary
 Author: Cedric Klinkert
@@ -127,6 +127,17 @@ 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.11] - 2026-02-20
+- Add OpenAI-proxy direct streaming with Python-side reference injection (UN-17264)
+- Add `stream_complete_with_references_openai()` using async OpenAI client and `chat.completions.stream()`
+- Add stream transformation pipeline: `StreamTransform` protocol, `TextTransformPipeline`, `ReferenceInjectionTransform` (reuses `add_references_to_message`), `NormalizationTransform` placeholder
+- Export `stream_complete_with_references_openai` and stream transform types from `unique_toolkit.language_model`
+
+## [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`
 

{unique_toolkit-1.46.9 → unique_toolkit-1.46.11}/pyproject.toml

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

unique_toolkit-1.46.11/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.9 → unique_toolkit-1.46.11}/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.9 → unique_toolkit-1.46.11}/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.9 → unique_toolkit-1.46.11}/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.11/unique_toolkit/chat/cancellation.py

@@ -0,0 +1,176 @@
+"""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.9 → unique_toolkit-1.46.11}/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.9 → unique_toolkit-1.46.11}/unique_toolkit/language_model/__init__.py

@@ -5,6 +5,9 @@ from .default_language_model import (
 from .default_language_model import (
     DEFAULT_GPT_4o as DEFAULT_GPT_4o,
 )
+from .functions import (
+    stream_complete_with_references_openai as stream_complete_with_references_openai,
+)
 from .infos import LanguageModel as LanguageModel
 from .infos import LanguageModelName as LanguageModelName
 from .prompt import (
@@ -67,6 +70,18 @@ from .schemas import (
 from .service import (
     LanguageModelService as LanguageModelService,
 )
+from .stream_transform import (
+    NormalizationTransform as NormalizationTransform,
+)
+from .stream_transform import (
+    ReferenceInjectionTransform as ReferenceInjectionTransform,
+)
+from .stream_transform import (
+    StreamTransform as StreamTransform,
+)
+from .stream_transform import (
+    TextTransformPipeline as TextTransformPipeline,
+)
 from .utils import (
     convert_string_to_json as convert_string_to_json,
 )

{unique_toolkit-1.46.9 → unique_toolkit-1.46.11}/unique_toolkit/language_model/functions.py

@@ -2,7 +2,11 @@ import copy
 import logging
 import warnings
 from datetime import UTC, datetime
-from typing import Any, Sequence, cast
+from typing import TYPE_CHECKING, Any, Sequence, cast
+from uuid import uuid4
+
+if TYPE_CHECKING:
+    from unique_toolkit.app.unique_settings import UniqueSettings
 
 import humps
 import unique_sdk
@@ -12,15 +16,6 @@ from pydantic import BaseModel
 
 from unique_toolkit.chat.schemas import ChatMessage, ChatMessageRole
 from unique_toolkit.content.schemas import ContentChunk, ContentReference
-from unique_toolkit.language_model import (
-    LanguageModelMessageRole,
-    LanguageModelMessages,
-    LanguageModelResponse,
-    LanguageModelStreamResponse,
-    LanguageModelStreamResponseMessage,
-    LanguageModelTool,
-    LanguageModelToolDescription,
-)
 from unique_toolkit.language_model.infos import (
     LanguageModelInfo,
     LanguageModelName,
@@ -29,6 +24,16 @@ from unique_toolkit.language_model.infos import (
 from unique_toolkit.language_model.reference import (
     add_references_to_message,
 )
+from unique_toolkit.language_model.schemas import (
+    LanguageModelFunction,
+    LanguageModelMessageRole,
+    LanguageModelMessages,
+    LanguageModelResponse,
+    LanguageModelStreamResponse,
+    LanguageModelStreamResponseMessage,
+    LanguageModelTool,
+    LanguageModelToolDescription,
+)
 
 from .constants import (
     DEFAULT_COMPLETE_TEMPERATURE,
@@ -541,3 +546,127 @@ def _create_language_model_stream_response_with_references(
         message=stream_response_message,
         tool_calls=tool_calls,
     )
+
+
+async def stream_complete_with_references_openai(
+    messages: list[ChatCompletionMessageParam] | LanguageModelMessages,
+    model_name: LanguageModelName | str,
+    content_chunks: list[ContentChunk] | None = None,
+    temperature: float = DEFAULT_COMPLETE_TEMPERATURE,
+    start_text: str | None = None,
+    tools: Sequence[LanguageModelTool | LanguageModelToolDescription] | None = None,
+    tool_choice: ChatCompletionToolChoiceOptionParam | None = None,
+    unique_settings: "UniqueSettings | None" = None,  # noqa: F821
+    message_id: str | None = None,
+) -> LanguageModelStreamResponse:
+    """Stream a chat completion via the OpenAI proxy, apply reference injection, and return a LanguageModelStreamResponse."""
+    from unique_toolkit.framework_utilities.openai.client import (
+        get_async_openai_client,
+    )
+    from unique_toolkit.language_model.stream_transform import (
+        ReferenceInjectionTransform,
+        TextTransformPipeline,
+    )
+
+    # prepare variables
+    client = get_async_openai_client(unique_settings=unique_settings)
+    model_name_: str = (
+        model_name.value if isinstance(model_name, LanguageModelName) else model_name
+    )
+    messages_: list[ChatCompletionMessageParam] = (
+        messages.model_dump(
+            exclude_none=True,
+            by_alias=False,
+        )
+        if isinstance(messages, LanguageModelMessages)
+        else list(messages)
+    )
+    tools_ = (
+        []
+        if tools is None
+        else [
+            tool.to_openai(mode="completions")
+            if isinstance(tool, LanguageModelToolDescription)
+            else {"type": "function", "function": tool.model_dump(exclude_none=True)}
+            for tool in tools
+        ]
+    )
+
+    # pipeline
+    pipeline = TextTransformPipeline()
+    # pipeline.add(NormalizationTransform()) # no-op for now
+    pipeline.add(
+        ReferenceInjectionTransform(
+            content_chunks=content_chunks or [], model=model_name_
+        )
+    )
+
+    stream_kwargs: dict[str, Any] = {
+        "messages": messages_,
+        "model": model_name_,
+        "temperature": temperature,
+        "stream": True,
+    }
+    if tool_choice is not None:
+        stream_kwargs["tool_choice"] = tool_choice
+    if tools_:
+        stream_kwargs["tools"] = tools_
+
+    full_text: str = start_text or ""
+    tool_calls_fragments: dict[int, dict[str, Any]] = {}
+    try:
+        stream = await client.chat.completions.create(**stream_kwargs)
+        async with stream:
+            async for chunk in stream:
+                if not chunk.choices:
+                    continue
+                choice_ = chunk.choices[0]
+                # text
+                delta_ = choice_.delta
+                if delta_.content is not None:
+                    full_text += delta_.content
+                    pipeline.feed_delta(delta_.content)  # does nothing right now
+                # tools
+                for tool_call in delta_.tool_calls or []:
+                    idx_ = tool_call.index
+                    if idx_ not in tool_calls_fragments.keys():
+                        tool_calls_fragments[idx_] = {
+                            "id": tool_call.id or "",
+                            "name": "",
+                            "arguments": "",
+                        }
+                    if tool_call.function is not None:
+                        tool_calls_fragments[idx_]["name"] += (
+                            tool_call.function.name or ""
+                        )
+                        tool_calls_fragments[idx_]["arguments"] += (
+                            tool_call.function.arguments or ""
+                        )
+        # run on full text
+        text_, references_ = pipeline.run(full_text)
+        # construct tool calls
+        tool_calls_list = None
+        if len(tool_calls_fragments) > 0:
+            tool_calls_list = [
+                LanguageModelFunction(
+                    id=tool_call["id"],
+                    name=tool_call["name"],
+                    arguments=tool_call["arguments"] or None,
+                )
+                for tool_call in tool_calls_fragments.values()
+            ]
+
+        return LanguageModelStreamResponse(
+            message=LanguageModelStreamResponseMessage(
+                id=message_id or uuid4().hex,
+                previous_message_id=None,
+                role=LanguageModelMessageRole.ASSISTANT,
+                text=text_,
+                original_text=full_text,
+                references=references_,
+            ),
+            tool_calls=tool_calls_list,
+        )
+    except Exception as e:
+        logger.error("Error streaming completion (model=%s): %s", model_name_, e)
+        raise

{unique_toolkit-1.46.9 → unique_toolkit-1.46.11}/unique_toolkit/language_model/reference.py

@@ -53,7 +53,9 @@ def _add_references(
 
     # Gemini 2.5 models have tendency to add multiple references for the same fact
     # This is a workaround to limit the number of references to 5
-    if model and model.startswith("litellm:gemini-2-5"):
+    if model and model.startswith(
+        "litellm:gemini-2-5"
+    ):  # TODO - check if this holds also for other models
         reduced_text = _limit_consecutive_source_references(with_footnotes)
 
         # Get the references that remain after reduction

{unique_toolkit-1.46.9 → unique_toolkit-1.46.11}/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.11/unique_toolkit/language_model/stream_transform.py

@@ -0,0 +1,82 @@
+from datetime import UTC, datetime
+from typing import Protocol, runtime_checkable
+
+from unique_toolkit.chat.schemas import ChatMessage, ChatMessageRole
+from unique_toolkit.content.schemas import ContentChunk, ContentReference
+from unique_toolkit.language_model.reference import add_references_to_message
+
+
+@runtime_checkable
+class StreamTransform(Protocol):
+    def process_delta(self, delta: str) -> None: ...
+
+    def finalize(self, text: str) -> tuple[str, list[ContentReference]]: ...
+
+
+class ReferenceInjectionTransform:
+    """Transform to inject references into the text of a message."""
+
+    def __init__(self, content_chunks: list[ContentChunk], model: str | None = None):
+        self._content_chunks = content_chunks
+        self._model = (
+            model  # needed e.g. for gemini-2.5 models to limit the number of references
+        )
+
+    def process_delta(self, delta: str) -> None:
+        pass  # cannot manipulate delta right now, as it is a stream
+
+    def finalize(self, text: str) -> tuple[str, list[ContentReference]]:
+        message = ChatMessage(
+            id="irrelevant",
+            text=text,
+            role=ChatMessageRole.ASSISTANT,
+            created_at=datetime.now(UTC),
+            chat_id="irrelevant",
+        )
+
+        updated_message, __ = add_references_to_message(
+            message=message,
+            search_context=self._content_chunks,
+            model=self._model,
+        )
+
+        references: list[ContentReference] = [
+            ContentReference(**u.model_dump()) for u in updated_message.references or []
+        ]
+        return updated_message.content or "", references
+
+
+class NormalizationTransform:
+    """Transform to normalize the text of a message.
+    E.g. remove extra whitespace, convert to lowercase, etc.
+    For now, this is a no-op. Only trim trailing whitespace.
+    """
+
+    def process_delta(self, delta: str) -> None:
+        pass
+
+    def finalize(self, text: str) -> tuple[str, list[ContentReference]]:
+        return text.strip(), []
+
+
+class TextTransformPipeline:
+    """Pipeline of text transforms to be applied to a stream of text."""
+
+    def __init__(self):
+        self._transforms: list[StreamTransform] = []
+
+    def add(self, transform: StreamTransform) -> "TextTransformPipeline":
+        self._transforms.append(transform)
+        return self
+
+    def feed_delta(self, delta: str) -> None:
+        for transform in self._transforms:
+            transform.process_delta(delta)
+
+    def run(self, text: str) -> tuple[str, list[ContentReference]]:
+        refs_: list[ContentReference] = []
+        text_: str = text
+        for transform in self._transforms:
+            text_, new_refs = transform.finalize(text_)
+            refs_.extend(new_refs)
+        return text_, refs_