unique-toolkit 2026.26.0.dev12__tar.gz → 2026.28.0__tar.gz

{unique_toolkit-2026.26.0.dev12 → unique_toolkit-2026.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-toolkit
-Version: 2026.26.0.dev12
+Version: 2026.28.0
 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.26.0.dev17,<2026.26.0rc0
+Requires-Dist: unique-sdk>=2026.28.0
 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.26.0.dev12 → unique_toolkit-2026.28.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_toolkit"
-version = "2026.26.0.dev12"
+version = "2026.28.0"
 description = ""
 readme = "README.md"
 requires-python = ">=3.12"
@@ -28,7 +28,7 @@ dependencies = [
     "openai>=1.105.0,<3",
     "platformdirs>=4.0.0,<5",
     "pillow>=12.1.1",
-    "unique-sdk>=2026.26.0.dev17,<2026.26.0rc0",
+    "unique-sdk>=2026.28.0",
     "jambo>=0.1.2,<0.2",
     "jinja2>=3.1.6,<4",
     "docxtpl>=0.20.1,<0.21",

{unique_toolkit-2026.26.0.dev12 → unique_toolkit-2026.28.0}/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-2026.26.0.dev12 → unique_toolkit-2026.28.0}/unique_toolkit/_common/pydantic/rjsf_tags.py

@@ -928,6 +928,7 @@ def ui_schema_for_model(
     ui: dict[str, Any] = {}
 
     for fname in model_cls.model_fields:
+        field_info = model_cls.model_fields[fname]
         ann = hints[fname]
         node: dict[str, Any] = {}
 
@@ -1019,13 +1020,21 @@ def ui_schema_for_model(
                 _maybe_set_string_empty_value(branch, alt_b, default_string_empty_value)
                 branches.append(branch)
             if branches:
-                # Check if the metadata already has an anyOf structure (from Union composer)
-                if "anyOf" in node:
-                    # Use the anyOf from the metadata (from Union composer)
-                    pass  # Keep the existing anyOf from the Union composer
-                else:
-                    # Create anyOf structure for Union types
-                    node["anyOf"] = branches
+                # RJSF v6 selects the per-branch uiSchema using the SAME keyword
+                # the JSON schema uses for the union: ``schema.oneOf`` reads
+                # ``uiSchema.oneOf`` and ``schema.anyOf`` reads ``uiSchema.anyOf``
+                # (see @rjsf/core ``AnyOfField``). Pydantic emits ``oneOf`` for a
+                # *discriminated* union and ``anyOf`` otherwise, so the uiSchema
+                # branch key MUST match the schema keyword — a ``oneOf`` schema
+                # paired with an ``anyOf`` uiSchema makes RJSF silently drop every
+                # per-branch widget and fall back to default widgets.
+                branch_key = (
+                    "oneOf" if field_info.discriminator is not None else "anyOf"
+                )
+                # Keep any branch structure already supplied by a composer
+                # (Optional/Union write their own ``anyOf`` into ``meta``).
+                if "anyOf" not in node and "oneOf" not in node:
+                    node[branch_key] = branches
 
         # Scalars: node already has metadata if any
         _maybe_set_string_empty_value(node, base, default_string_empty_value)

{unique_toolkit-2026.26.0.dev12 → unique_toolkit-2026.28.0}/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-2026.26.0.dev12 → unique_toolkit-2026.28.0}/unique_toolkit/agentic/evaluation/hallucination/constants.py

@@ -52,6 +52,18 @@ class HallucinationConfig(EvaluationMetricConfig):
         default={},
         description="Additional options to pass to the language model.",
     )
+    max_external_context_chars_per_source: SkipJsonSchema[int] = Field(
+        default=20_000,
+        ge=0,
+        description=(
+            "Per-source character cap applied to external (non-chunk) "
+            "context texts, e.g. MCP tool output. Raw/large tool results "
+            "inflate the judge prompt and the eval-LLM call; each external "
+            "text is truncated to this many characters before being added "
+            "to the context. 0 disables truncation. Does not affect "
+            "chunk-derived context."
+        ),
+    )
     score_to_label: dict[str, str] = {
         "LOW": "GREEN",
         "MEDIUM": "YELLOW",

{unique_toolkit-2026.26.0.dev12 → unique_toolkit-2026.28.0}/unique_toolkit/agentic/evaluation/hallucination/hallucination_evaluation.py

@@ -54,6 +54,17 @@ class HallucinationEvaluation(Evaluation):
             reference_pattern=self.config.reference_pattern,
         )
 
+        # Append non-chunk groundedness context (e.g. MCP tool output). These
+        # are added in full ("all retrieved output as context") rather than via
+        # source-marker selection, since they carry no [sourceN] markers.
+        external_context_texts = self._reference_manager.get_external_context_texts()
+        max_chars = self.config.max_external_context_chars_per_source
+        if max_chars > 0:
+            external_context_texts = [
+                text[:max_chars] for text in external_context_texts
+            ]
+        context_texts = context_texts + external_context_texts
+
         evaluation_result: EvaluationMetricResult = await check_hallucination(
             company_id=self._company_id,
             user_id=self._user_id,

{unique_toolkit-2026.26.0.dev12 → unique_toolkit-2026.28.0}/unique_toolkit/agentic/evaluation/hallucination/utils.py

@@ -16,6 +16,8 @@ from unique_toolkit.agentic.evaluation.schemas import (
 )
 from unique_toolkit.content import ContentReference
 from unique_toolkit.content.schemas import ContentChunk
+from unique_toolkit.language_model.builder import MessagesBuilder
+from unique_toolkit.language_model.infos import ModelCapabilities
 from unique_toolkit.language_model.schemas import (
     LanguageModelMessages,
     LanguageModelStreamResponse,
@@ -104,19 +106,28 @@ def _get_msgs(
     """
     Composes the messages for hallucination analysis based on the provided input and configuration.
 
-    This method composes messages with or without context based on the availability of context texts
-    and history message texts in the input.
+    This method composes messages with or without context based on the availability of context texts,
+    history message texts, and (for vision-capable models) context images in the input.
 
     Args:
-        input (EvaluationMetricInput): The input data that includes context texts and history message texts
-                                      for the analysis.
+        input (EvaluationMetricInput): The input data that includes context texts, history message texts,
+                                      and context images for the analysis.
         config (EvaluationMetricConfig): The configuration settings for composing messages.
         logger (Optional[logging.Logger], optional): The logger used for logging debug information.
 
     Returns:
         The composed messages as per the provided input and configuration.
     """
-    has_context = bool(input.context_texts or input.history_messages)
+    # Context images only count as grounding when the model can actually consume
+    # them; otherwise _compose_msgs drops them and the message would be text-only.
+    model_supports_vision = (
+        ModelCapabilities.VISION in config.language_model.capabilities
+    )
+    has_context = bool(
+        input.context_texts
+        or input.history_messages
+        or (input.context_images and model_supports_vision)
+    )
 
     if has_context:
         _LOGGER.debug("Using context / history for hallucination evaluation.")
@@ -165,6 +176,36 @@ def _compose_msgs(
         else None,
         output_text=input.output_text,
     )
+
+    # When images are provided AND the configured model is vision-capable, build
+    # a multimodal user message (rendered user text + one image part per data
+    # URL) so the model can ground the check against the rendered pages. If the
+    # model lacks VISION we drop the images and fall back to the text-only
+    # message: attaching images to a non-vision model would make the LLM call
+    # fail. Without images the message stays the exact text-only form, so
+    # existing callers are unaffected.
+    context_images = input.context_images or []
+    model_supports_vision = (
+        ModelCapabilities.VISION in config.language_model.capabilities
+    )
+    # When has_context is True for an images-only input, the caller already
+    # confirmed the model is vision-capable, so this branch stays unreachable in
+    # that case and only logs for a genuine non-vision misconfiguration.
+    if context_images and not model_supports_vision:
+        _LOGGER.warning(
+            "Hallucination model %s lacks VISION capability; ignoring "
+            "%d context image(s) and grounding on text only.",
+            config.language_model.name,
+            len(context_images),
+        )
+    if context_images and model_supports_vision:
+        return (
+            MessagesBuilder()
+            .append(system_msg)
+            .image_message_append(content=user_msg_content, images=context_images)
+            .build()
+        )
+
     user_msg = LanguageModelUserMessage(content=user_msg_content)
 
     return LanguageModelMessages([system_msg, user_msg])

{unique_toolkit-2026.26.0.dev12 → unique_toolkit-2026.28.0}/unique_toolkit/agentic/evaluation/schemas.py

@@ -34,6 +34,16 @@ class EvaluationMetricInput(BaseModel):
     context_texts: Optional[list[str]] = None
     history_messages: Optional[list[ChatMessage]] = None
     output_text: Optional[str] = None
+    context_images: Optional[list[str]] = Field(
+        default=None,
+        description=(
+            "Optional base64 data URLs (e.g. 'data:image/png;base64,...') of "
+            "context the metric should evaluate against visually, in addition "
+            "to context_texts. Used by metrics that support a multimodal "
+            "(vision) check; ignored by metrics that do not. Defaults to None "
+            "so existing text-only callers are unaffected."
+        ),
+    )
 
     def get_joined_context_texts(self, tag_name: str = "reference") -> str:
         """

unique_toolkit-2026.28.0/unique_toolkit/agentic/evaluation/tests/test_hallucination_external_context.py

@@ -0,0 +1,122 @@
+"""Tests that HallucinationEvaluation grounds against non-chunk context.
+
+UN-21951: external context texts (e.g. MCP tool output) registered on the
+ReferenceManager must be appended to the evaluation context — in addition to
+chunk-derived context, capped by ``max_external_context_chars_per_source`` —
+without being converted to ContentChunks.
+"""
+
+from types import SimpleNamespace
+
+import pytest
+
+from unique_toolkit.agentic.evaluation.hallucination import (
+    hallucination_evaluation as he,
+)
+from unique_toolkit.agentic.evaluation.hallucination.constants import (
+    HallucinationConfig,
+    SourceSelectionMode,
+)
+from unique_toolkit.agentic.evaluation.schemas import (
+    EvaluationMetricName,
+    EvaluationMetricResult,
+)
+from unique_toolkit.agentic.reference_manager.reference_manager import (
+    ReferenceManager,
+)
+from unique_toolkit.chat.schemas import ChatMessageRole
+from unique_toolkit.language_model.schemas import (
+    LanguageModelStreamResponse,
+    LanguageModelStreamResponseMessage,
+)
+
+
+def _make_event() -> SimpleNamespace:
+    return SimpleNamespace(
+        company_id="company_1",
+        user_id="user_1",
+        payload=SimpleNamespace(
+            user_message=SimpleNamespace(text="what is ACME revenue?"),
+        ),
+    )
+
+
+def _make_response(text: str = "ACME revenue is 1M.") -> LanguageModelStreamResponse:
+    return LanguageModelStreamResponse(
+        message=LanguageModelStreamResponseMessage(
+            id="msg_1",
+            previous_message_id=None,
+            role=ChatMessageRole.ASSISTANT,
+            text=text,
+            chat_id="chat_1",
+            original_text=text,
+            references=None,
+        ),
+        tool_calls=None,
+    )
+
+
+@pytest.fixture
+def captured_context(monkeypatch: pytest.MonkeyPatch) -> dict:
+    """Patch check_hallucination to capture the context_texts it receives."""
+    captured: dict = {}
+
+    async def _fake_check_hallucination(*, company_id, user_id, input, config):
+        captured["context_texts"] = list(input.context_texts or [])
+        return EvaluationMetricResult(
+            name=EvaluationMetricName.HALLUCINATION,
+            value="LOW",
+            reason="grounded",
+        )
+
+    monkeypatch.setattr(he, "check_hallucination", _fake_check_hallucination)
+    return captured
+
+
+async def test_external_context_is_appended(captured_context: dict) -> None:
+    manager = ReferenceManager()
+    manager.add_external_context_texts(["ACME revenue: 1M"])
+    evaluation = he.HallucinationEvaluation(
+        HallucinationConfig(source_selection_mode=SourceSelectionMode.FROM_IDS),
+        _make_event(),  # type: ignore[arg-type]
+        manager,
+    )
+
+    result = await evaluation.run(_make_response())
+
+    # No chunks → context comes solely from the external (MCP) source.
+    assert captured_context["context_texts"] == ["ACME revenue: 1M"]
+    assert result.value == "LOW"
+    assert result.is_positive is True
+
+
+async def test_external_context_is_truncated(captured_context: dict) -> None:
+    manager = ReferenceManager()
+    manager.add_external_context_texts(["x" * 100])
+    evaluation = he.HallucinationEvaluation(
+        HallucinationConfig(
+            source_selection_mode=SourceSelectionMode.FROM_IDS,
+            max_external_context_chars_per_source=10,
+        ),
+        _make_event(),  # type: ignore[arg-type]
+        manager,
+    )
+
+    await evaluation.run(_make_response())
+
+    assert captured_context["context_texts"] == ["x" * 10]
+
+
+async def test_no_external_context_preserves_chunk_only_behaviour(
+    captured_context: dict,
+) -> None:
+    manager = ReferenceManager()  # no chunks, no external context
+    evaluation = he.HallucinationEvaluation(
+        HallucinationConfig(source_selection_mode=SourceSelectionMode.FROM_IDS),
+        _make_event(),  # type: ignore[arg-type]
+        manager,
+    )
+
+    await evaluation.run(_make_response())
+
+    assert captured_context["context_texts"] == []

{unique_toolkit-2026.26.0.dev12 → unique_toolkit-2026.28.0}/unique_toolkit/agentic/evaluation/tests/test_hallucination_utils.py

@@ -20,6 +20,10 @@ from unique_toolkit.agentic.evaluation.schemas import EvaluationMetricInput
 from unique_toolkit.chat.schemas import ChatMessage
 from unique_toolkit.content import ContentReference
 from unique_toolkit.content.schemas import ContentChunk
+from unique_toolkit.language_model.infos import (
+    LanguageModelName,
+    ModelCapabilities,
+)
 from unique_toolkit.language_model.schemas import (
     LanguageModelMessageRole,
     LanguageModelMessages,
@@ -1013,3 +1017,162 @@ def test_compose_msgs__generates_non_empty_messages__from_config_prompts(
     # Assert
     assert len(result.root[0].content) > 0
     assert len(result.root[1].content) > 0
+
+
+_IMAGE_DATA_URL = "data:image/png;base64,QQ=="
+
+
+@pytest.mark.ai
+def test_compose_msgs__builds_multimodal_user_message__with_context_images(
+    hallucination_config: HallucinationConfig,
+) -> None:
+    """
+    Purpose: Verify that context_images produce a multimodal user message.
+    Why this matters: Vision faithfulness needs the rendered pages as image parts.
+    Setup summary: Provide context_images, assert the user message carries text +
+    one image part per data URL.
+    """
+    # Arrange
+    input_data: EvaluationMetricInput = EvaluationMetricInput(
+        input_text="Question",
+        output_text="Output",
+        context_images=[_IMAGE_DATA_URL],
+    )
+
+    # Act
+    result: LanguageModelMessages = _compose_msgs(
+        input_data, hallucination_config, has_context=True
+    )
+
+    # Assert
+    assert len(result.root) == 2
+    user_content = result.root[1].content
+    assert isinstance(user_content, list)
+    text_parts = [p for p in user_content if p.get("type") == "text"]
+    image_parts = [p for p in user_content if p.get("type") == "image_url"]
+    assert len(text_parts) == 1
+    assert len(image_parts) == 1
+    assert image_parts[0]["imageUrl"]["url"] == _IMAGE_DATA_URL
+
+
+@pytest.mark.ai
+def test_compose_msgs__stays_text_only__without_context_images(
+    hallucination_config: HallucinationConfig,
+) -> None:
+    """
+    Purpose: Verify that omitting context_images keeps the exact text-only message.
+    Why this matters: Backward compatibility for all existing (non-vision) callers.
+    Setup summary: No context_images -> user message content is a plain string.
+    """
+    # Arrange
+    input_data: EvaluationMetricInput = EvaluationMetricInput(
+        input_text="Question",
+        context_texts=["Context 1"],
+        output_text="Output",
+    )
+
+    # Act
+    result: LanguageModelMessages = _compose_msgs(
+        input_data, hallucination_config, has_context=True
+    )
+
+    # Assert
+    assert isinstance(result.root[1].content, str)
+
+
+@pytest.mark.ai
+def test_compose_msgs__drops_images__when_model_lacks_vision() -> None:
+    """
+    Purpose: Verify images are dropped when the configured model is not vision-capable.
+    Why this matters: Attaching images to a non-vision model makes the LLM call fail;
+    we must degrade gracefully to a text-only message instead.
+    Setup summary: Configure a text-only model (no VISION capability) with
+    context_images, assert the user message content stays a plain string.
+    """
+    # Arrange
+    text_only_config = HallucinationConfig(
+        enabled=True,
+        language_model=LanguageModelName.AZURE_GPT_4_0613,
+    )
+    assert ModelCapabilities.VISION not in (
+        text_only_config.language_model.capabilities
+    )
+    input_data: EvaluationMetricInput = EvaluationMetricInput(
+        input_text="Question",
+        output_text="Output",
+        context_images=[_IMAGE_DATA_URL],
+    )
+
+    # Act
+    result: LanguageModelMessages = _compose_msgs(
+        input_data, text_only_config, has_context=True
+    )
+
+    # Assert
+    assert isinstance(result.root[1].content, str)
+
+
+@pytest.mark.ai
+def test_get_msgs__treats_context_images_as_context(
+    hallucination_config: HallucinationConfig,
+) -> None:
+    """
+    Purpose: Verify that context_images alone count as context in _get_msgs.
+    Why this matters: A vision-only turn must use the grounded (has_context) prompt
+    and build the multimodal message.
+    Setup summary: Provide only context_images; assert the system prompt matches the
+    has_context variant and the user message is multimodal.
+    """
+    # Arrange
+    image_only: EvaluationMetricInput = EvaluationMetricInput(
+        input_text="Question",
+        output_text="Output",
+        context_images=[_IMAGE_DATA_URL],
+    )
+    grounded: EvaluationMetricInput = EvaluationMetricInput(
+        input_text="Question",
+        context_texts=["Context 1"],
+        output_text="Output",
+    )
+
+    # Act
+    result: LanguageModelMessages = _get_msgs(image_only, hallucination_config)
+    grounded_result: LanguageModelMessages = _get_msgs(grounded, hallucination_config)
+
+    # Assert
+    assert result.root[0].content == grounded_result.root[0].content
+    assert isinstance(result.root[1].content, list)
+
+
+@pytest.mark.ai
+def test_get_msgs__ignores_context_images__when_model_lacks_vision() -> None:
+    """
+    Purpose: Verify image-only input is not treated as context for a non-vision model.
+    Why this matters: _compose_msgs drops the images for a non-vision model, so the
+    grounded prompt would otherwise claim references that are never sent. has_context
+    must reflect the message actually delivered.
+    Setup summary: Configure a text-only model with only context_images; assert the
+    system prompt matches the ungrounded variant and the user message is text-only.
+    """
+    # Arrange
+    text_only_config = HallucinationConfig(
+        enabled=True,
+        language_model=LanguageModelName.AZURE_GPT_4_0613,
+    )
+    image_only: EvaluationMetricInput = EvaluationMetricInput(
+        input_text="Question",
+        output_text="Output",
+        context_images=[_IMAGE_DATA_URL],
+    )
+    no_context: EvaluationMetricInput = EvaluationMetricInput(
+        input_text="Question",
+        output_text="Output",
+    )
+
+    # Act
+    result: LanguageModelMessages = _get_msgs(image_only, text_only_config)
+    no_context_result: LanguageModelMessages = _get_msgs(no_context, text_only_config)
+
+    # Assert
+    assert result.root[0].content == no_context_result.root[0].content
+    assert isinstance(result.root[1].content, str)

{unique_toolkit-2026.26.0.dev12 → unique_toolkit-2026.28.0}/unique_toolkit/agentic/reference_manager/reference_manager.py

@@ -32,6 +32,7 @@ class ReferenceManager:
         self._tool_chunks: dict[str, tool_chunks] = {}
         self._chunks: list[ContentChunk] = []
         self._references: list[list[ContentReference]] = []
+        self._external_context_texts: list[str] = []
 
     def extract_referenceable_chunks(
         self, tool_responses: list[ToolCallResponse]
@@ -47,6 +48,21 @@ class ReferenceManager:
     def get_chunks(self) -> list[ContentChunk]:
         return self._chunks
 
+    def add_external_context_texts(self, texts: list[str]) -> None:
+        """Register groundedness context that is not backed by ContentChunks.
+
+        Some retrieval sources (e.g. MCP tool output) provide text the answer
+        is built on but are deliberately *not* modelled as ContentChunks — they
+        are a different entity from ingested document chunks and must not flow
+        through the chunk/reference pipeline. They still need to ground the
+        hallucination check, so they are stored here and appended to the
+        evaluation context alongside the chunk-derived texts.
+        """
+        self._external_context_texts.extend(text for text in texts if text)
+
+    def get_external_context_texts(self) -> list[str]:
+        return self._external_context_texts
+
     def get_tool_chunks(self) -> dict[str, tool_chunks]:
         return self._tool_chunks
 

unique_toolkit-2026.28.0/unique_toolkit/agentic/reference_manager/tests/test_external_context.py

@@ -0,0 +1,35 @@
+"""Tests for non-chunk groundedness context on the ReferenceManager.
+
+External context texts (e.g. MCP tool output, UN-21951) ground the
+hallucination check without being modelled as ContentChunks.
+"""
+
+from unique_toolkit.agentic.reference_manager.reference_manager import (
+    ReferenceManager,
+)
+
+
+def test_external_context_starts_empty() -> None:
+    manager = ReferenceManager()
+    assert manager.get_external_context_texts() == []
+
+
+def test_add_external_context_texts_accumulates() -> None:
+    manager = ReferenceManager()
+    manager.add_external_context_texts(["a", "b"])
+    manager.add_external_context_texts(["c"])
+    assert manager.get_external_context_texts() == ["a", "b", "c"]
+
+
+def test_add_external_context_texts_drops_empty_strings() -> None:
+    manager = ReferenceManager()
+    manager.add_external_context_texts(["keep", "", "also"])
+    assert manager.get_external_context_texts() == ["keep", "also"]
+
+
+def test_external_context_is_independent_of_chunks() -> None:
+    manager = ReferenceManager()
+    manager.add_external_context_texts(["mcp output"])
+    # External context must not leak into the chunk pipeline.
+    assert manager.get_chunks() == []
+    assert manager.get_external_context_texts() == ["mcp output"]