unique_orchestrator 2026.30.0.dev4__tar.gz → 2026.30.0.dev6__tar.gz

{unique_orchestrator-2026.30.0.dev4 → unique_orchestrator-2026.30.0.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-orchestrator
-Version: 2026.30.0.dev4
+Version: 2026.30.0.dev6
 Summary: 
 Author: Andreas Hauri
 Author-email: Andreas Hauri <andreas.hauri@unique.ai>
@@ -9,7 +9,7 @@ Requires-Dist: pydantic>=2.8.2,<3
 Requires-Dist: pydantic-settings>=2.10.1,<3
 Requires-Dist: typing-extensions>=4.9.0,<5
 Requires-Dist: jinja2>=3.1.0,<4
-Requires-Dist: unique-toolkit>=2026.30.0.dev14,<2026.30.0rc0
+Requires-Dist: unique-toolkit>=2026.30.0.dev17,<2026.30.0rc0
 Requires-Dist: unique-stock-ticker>=2026.30.0.dev0,<2026.30.0rc0
 Requires-Dist: unique-follow-up-questions>=2026.30.0.dev0,<2026.30.0rc0
 Requires-Dist: unique-internal-search>=2026.30.0.dev0,<2026.30.0rc0

{unique_orchestrator-2026.30.0.dev4 → unique_orchestrator-2026.30.0.dev6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_orchestrator"
-version = "2026.30.0.dev4"
+version = "2026.30.0.dev6"
 description = ""
 readme = "README.md"
 license = { text = "Proprietary" }
@@ -13,7 +13,7 @@ dependencies = [
     "pydantic-settings>=2.10.1,<3",
     "typing-extensions>=4.9.0,<5",
     "jinja2>=3.1.0,<4",
-    "unique-toolkit>=2026.30.0.dev14,<2026.30.0rc0",
+    "unique-toolkit>=2026.30.0.dev17,<2026.30.0rc0",
     "unique-stock-ticker>=2026.30.0.dev0,<2026.30.0rc0",
     "unique-follow-up-questions>=2026.30.0.dev0,<2026.30.0rc0",
     "unique-internal-search>=2026.30.0.dev0,<2026.30.0rc0",

{unique_orchestrator-2026.30.0.dev4 → unique_orchestrator-2026.30.0.dev6}/unique_orchestrator/_builders/history_manager.py

@@ -14,6 +14,9 @@ from unique_toolkit.agentic.history_manager.history_manager import (
 )
 from unique_toolkit.agentic.reference_manager.reference_manager import ReferenceManager
 from unique_toolkit.agentic.tools.openai_builtin.base import OpenAIBuiltInToolName
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter import (
+    CodeInterpreterActivatorTool,
+)
 from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.postprocessors.artifacts import (
     load_code_execution_metadata,
 )
@@ -64,6 +67,8 @@ def _get_file_content_serializer(
         code_interpreter_available=(
             tool_manager.get_tool_by_name(OpenAIBuiltInToolName.CODE_INTERPRETER)
             is not None
+            or tool_manager.get_tool_by_name(CodeInterpreterActivatorTool.NAME)
+            is not None
         ),
     )
 

{unique_orchestrator-2026.30.0.dev4 → unique_orchestrator-2026.30.0.dev6}/unique_orchestrator/tests/test_unique_ai_execution_timing.py

@@ -1,4 +1,5 @@
 import time
+from datetime import datetime, timezone
 from unittest.mock import AsyncMock, MagicMock
 
 import pytest
@@ -735,6 +736,27 @@ class TestRunExecutionTimingIntegration:
         assert "loop_iterations" in payload
         assert "total_time" in payload
 
+    @pytest.mark.ai
+    @pytest.mark.asyncio
+    async def test_run__analytics__includes_total_time_to_answer_ms(
+        self, monkeypatch
+    ) -> None:
+        """
+        Purpose: Verify analytics measures from user creation through completion.
+        Why this matters: Internal loop timing excludes queueing and completion latency.
+        Setup summary: Return a known completion timestamp and assert the full delta.
+        """
+        ua = self._build_run_ua(monkeypatch)
+        ua._event.payload.user_message.created_at = "2026-07-13T20:00:00Z"
+        ua._chat_service.modify_assistant_message_async.return_value = MagicMock(
+            completed_at=datetime(2026, 7, 13, 20, 0, 2, 345000, tzinfo=timezone.utc)
+        )
+
+        await ua.run()
+
+        analytics_call = ua._debug_info_manager.add_analytics.call_args
+        assert analytics_call.kwargs["total_time_to_answer_ms"] == 2345
+
     @pytest.mark.ai
     @pytest.mark.asyncio
     async def test_run__execution_times__contains_one_entry_after_single_iteration(
@@ -836,10 +858,10 @@ class TestRunExecutionTimingIntegration:
     ) -> None:
         """
         Purpose: Verify that a failure in update_debug_info_async propagates to the caller.
-        Why this matters: After refactoring, debug info failures are no longer silently
-        swallowed; callers must handle them.
+        Why this matters: Debug failures remain visible without preventing answer
+        completion.
         Setup summary: Make update_debug_info_async raise; run; assert RuntimeError
-        propagates and modify_assistant_message_async is never reached.
+        propagates after modify_assistant_message_async completes the answer.
         """
         ua = self._build_run_ua(monkeypatch)
         ua._chat_service.update_debug_info_async.side_effect = RuntimeError("boom")
@@ -847,7 +869,9 @@ class TestRunExecutionTimingIntegration:
         with pytest.raises(RuntimeError, match="boom"):
             await ua.run()
 
-        ua._chat_service.modify_assistant_message_async.assert_not_called()
+        ua._chat_service.modify_assistant_message_async.assert_awaited_once_with(
+            set_completed_at=True
+        )
 
     @pytest.mark.ai
     @pytest.mark.asyncio

{unique_orchestrator-2026.30.0.dev4 → unique_orchestrator-2026.30.0.dev6}/unique_orchestrator/tests/test_unique_ai_loop_debug_params.py

@@ -76,6 +76,7 @@ def _make_loop_response() -> MagicMock:
     response.message = MagicMock()
     response.message.references = []
     response.message.text = "response text"
+    response.message.original_text = "original response text"
     response.is_empty.return_value = False
     return response
 
@@ -256,6 +257,9 @@ class TestRunLoopDebugParams:
         mock_chat_service.cancellation = mock_cancellation
         mock_chat_service.get_debug_info_async = AsyncMock(return_value={})
         mock_chat_service.update_debug_info_async = AsyncMock(return_value=None)
+        # Returns None by default → no completed_at, so total_time_to_answer_ms
+        # resolves to None. Tests that exercise timing override this return value
+        # with a MagicMock(completed_at=...).
         mock_chat_service.modify_assistant_message_async = AsyncMock(return_value=None)
         mock_chat_service.create_assistant_message_async = AsyncMock(
             return_value=MagicMock(id="assist_new")
@@ -279,6 +283,9 @@ class TestRunLoopDebugParams:
         mock_config = MagicMock()
         mock_config.effective_max_loop_iterations = 1
         mock_config.agent.prompt_config.user_metadata = []
+        mock_config.space.language_model.name = "AZURE_GPT_5_2025_0807"
+        mock_config.space.language_model.family = "openai"
+        mock_config.space.language_model.provider = "AZURE"
 
         mock_history_manager = MagicMock()
         mock_history_manager.get_history_for_model_call = AsyncMock(
@@ -345,6 +352,10 @@ class TestRunLoopDebugParams:
         as the first argument.
         """
         ua = self._build_run_ua(monkeypatch)
+        tool = MagicMock()
+        tool.name = "InternalSearch"
+        tool.display_name.return_value = "Knowledge Base Search"
+        ua._tool_manager.available_tools = [tool]
 
         await ua.run()
 
@@ -353,14 +364,119 @@ class TestRunLoopDebugParams:
         ]
         assert "loop_params" in keys_written
         assert "skills" in keys_written
+        # This test owns one contract: run() forwards the same skills value it
+        # wrote under "skills" as the first positional arg to add_analytics.
+        # Per-field kwargs (references / timing / lengths) are covered by the
+        # focused sibling tests below, so we don't re-pin the whole call here.
         skills_call = next(
             c
             for c in ua._debug_info_manager.add.call_args_list
             if c.args[0] == "skills"
         )
-        ua._debug_info_manager.add_analytics.assert_called_once_with(
-            skills_call.args[1]
-        )
+        ua._debug_info_manager.add_analytics.assert_called_once()
+        analytics_call = ua._debug_info_manager.add_analytics.call_args
+        assert analytics_call.args[0] == skills_call.args[1]
+        assert analytics_call.kwargs["tool_display_names"] == {
+            "InternalSearch": "Knowledge Base Search"
+        }
+
+    @pytest.mark.ai
+    @pytest.mark.asyncio
+    async def test_run__analytics__counts_unique_reference_sources(
+        self, monkeypatch
+    ) -> None:
+        ua = self._build_run_ua(monkeypatch)
+        references = [
+            MagicMock(url="source_1"),
+            MagicMock(url="source_1"),
+            MagicMock(url="source_2"),
+            MagicMock(url="source_3"),
+            MagicMock(url="source_3"),
+        ]
+        ua._loop_iteration_runner.return_value.message.references = references
+        ua._reference_manager.get_references.return_value = [references]
+
+        await ua.run()
+
+        analytics_call = ua._debug_info_manager.add_analytics.call_args
+        assert analytics_call.kwargs["references"] == 3
+
+    @pytest.mark.ai
+    @pytest.mark.asyncio
+    async def test_run__analytics__counts_references_across_iterations(
+        self, monkeypatch
+    ) -> None:
+        """
+        Purpose: Verify analytics includes reference sources from every loop iteration.
+        Why this matters: Earlier citations belong to the same run and must not be
+        omitted when a later iteration appends another reference batch.
+        Setup summary: Return two stored batches with one duplicate source and assert
+        that all three distinct sources are counted.
+        """
+        ua = self._build_run_ua(monkeypatch)
+        first_iteration_references = [
+            MagicMock(url="source_1"),
+            MagicMock(url="source_2"),
+        ]
+        latest_iteration_references = [
+            MagicMock(url="source_2"),
+            MagicMock(url="source_3"),
+        ]
+        ua._reference_manager.get_references.return_value = [
+            first_iteration_references,
+            latest_iteration_references,
+        ]
+
+        await ua.run()
+
+        analytics_call = ua._debug_info_manager.add_analytics.call_args
+        assert analytics_call.kwargs["references"] == 3
+
+    @pytest.mark.ai
+    @pytest.mark.asyncio
+    async def test_run__analytics__counts_distinct_references_without_urls(
+        self, monkeypatch
+    ) -> None:
+        """
+        Purpose: Verify URL-less references are identified by source and source ID.
+        Why this matters: MCP citations can omit URLs and must not collapse into one
+        analytics source.
+        Setup summary: Run with two distinct URL-less references and assert both count.
+        """
+        ua = self._build_run_ua(monkeypatch)
+        references = [
+            MagicMock(url=None, source="mcp", source_id="resource_1"),
+            MagicMock(url=None, source="mcp", source_id="resource_2"),
+        ]
+        ua._loop_iteration_runner.return_value.message.references = references
+        ua._reference_manager.get_references.return_value = [references]
+
+        await ua.run()
+
+        analytics_call = ua._debug_info_manager.add_analytics.call_args
+        assert analytics_call.kwargs["references"] == 2
+
+    @pytest.mark.ai
+    @pytest.mark.asyncio
+    async def test_run__analytics__total_time_to_answer_ms_none_without_completed_at(
+        self, monkeypatch
+    ) -> None:
+        """
+        Purpose: Verify total_time_to_answer_ms is None when the completed message
+        carries no completed_at.
+        Why this matters: Makes the None case deliberate — run() must degrade to
+        None (not crash) when completion time is unavailable, e.g. a tool took
+        control. Pairs with test_run__analytics__includes_total_time_to_answer_ms
+        (execution-timing suite) which covers the populated case.
+        Setup summary: modify_assistant_message_async returns None (fixture default);
+        assert the kwarg is present and None.
+        """
+        ua = self._build_run_ua(monkeypatch)
+
+        await ua.run()
+
+        analytics_call = ua._debug_info_manager.add_analytics.call_args
+        assert analytics_call.kwargs["total_time_to_answer_ms"] is None
 
     @pytest.mark.ai
     @pytest.mark.asyncio

unique_orchestrator-2026.30.0.dev6/unique_orchestrator/tests/test_unique_ai_plan_or_execute_include.py

@@ -0,0 +1,76 @@
+"""Tests for ResponsesStreamingHandler include injection (UN-17972).
+
+The handler always requests code_interpreter_call.outputs so UniqueAI stays
+generic (no isinstance checks) and code interpreter execution logs attach to
+tool calls whenever code interpreter runs.
+"""
+
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from unique_orchestrator.unique_ai_builder import (
+    ResponsesStreamingHandler,
+    _ChatServiceResponsesStreaming,
+)
+
+
+def _make_handler() -> ResponsesStreamingHandler:
+    inner = MagicMock()
+    inner.complete_with_references_async = AsyncMock(return_value=MagicMock())
+    inner.complete_with_references = MagicMock(return_value=MagicMock())
+    return ResponsesStreamingHandler(inner=inner)
+
+
+@pytest.mark.ai
+@pytest.mark.asyncio
+async def test_responses_streaming_handler__always_injects_include__async_path() -> (
+    None
+):
+    """complete_with_references_async always sets include=code_interpreter_call.outputs."""
+    handler = _make_handler()
+
+    await handler.complete_with_references_async(messages=[], model_name="model")
+
+    call_kwargs = handler._inner.complete_with_references_async.await_args.kwargs
+    assert call_kwargs["include"] == ["code_interpreter_call.outputs"]
+
+
+@pytest.mark.ai
+def test_responses_streaming_handler__always_injects_include__sync_path() -> None:
+    """The synchronous complete_with_references also always sets include."""
+    handler = _make_handler()
+
+    handler.complete_with_references(messages=[], model_name="model")
+
+    call_kwargs = handler._inner.complete_with_references.call_args.kwargs
+    assert call_kwargs["include"] == ["code_interpreter_call.outputs"]
+
+
+@pytest.mark.ai
+@pytest.mark.asyncio
+async def test_chat_service_responses_streaming__forwards_to_responses_methods() -> (
+    None
+):
+    """
+    Purpose: The legacy adapter must route the protocol's
+    `complete_with_references[_async]` to ChatService's Responses-specific
+    methods, not the Chat Completions ones.
+    Why this matters: ChatService exposes both; routing to the wrong method
+    would silently stream through the Chat Completions API.
+    """
+    chat_service = MagicMock()
+    chat_service.complete_responses_with_references = MagicMock(
+        return_value=MagicMock()
+    )
+    chat_service.complete_responses_with_references_async = AsyncMock(
+        return_value=MagicMock()
+    )
+    adapter = _ChatServiceResponsesStreaming(chat_service)
+
+    adapter.complete_with_references(messages=[], model_name="model")
+    await adapter.complete_with_references_async(messages=[], model_name="model")
+
+    chat_service.complete_responses_with_references.assert_called_once()
+    chat_service.complete_responses_with_references_async.assert_awaited_once()
+    chat_service.complete_with_references.assert_not_called()

{unique_orchestrator-2026.30.0.dev4 → unique_orchestrator-2026.30.0.dev6}/unique_orchestrator/unique_ai.py

@@ -1,6 +1,6 @@
 import asyncio
 import time
-from datetime import datetime
+from datetime import datetime, timezone
 from logging import Logger
 from typing import Any, cast, overload
 
@@ -8,6 +8,7 @@ import jinja2
 from typing_extensions import deprecated
 from unique_skill_tool.service import SkillTool
 from unique_toolkit.agentic.debug_info_manager.debug_info_manager import (
+    AnalyticsLanguageModel,
     DebugInfoManager,
 )
 from unique_toolkit.agentic.evaluation.evaluation_manager import EvaluationManager
@@ -261,9 +262,8 @@ class UniqueAI:
                     self._finalize_loop_timing(loop_start)
                     break
 
-                self._reference_manager.add_references(
-                    loop_response.message.references or []
-                )
+                references = loop_response.message.references or []
+                self._reference_manager.add_references(references)
                 self._last_assistant_text = (
                     loop_response.message.original_text or loop_response.message.text
                 )
@@ -318,12 +318,53 @@ class UniqueAI:
             self._debug_info_manager.add("loop_params", self._loop_debug_params)
             skills_debug_info = self._get_activated_skills_debug_info()
             self._debug_info_manager.add("skills", skills_debug_info)
-            self._debug_info_manager.add_analytics(skills_debug_info)
-
+            reference_sources = {
+                ("url", reference.url)
+                if reference.url is not None
+                else ("source", reference.source, reference.source_id)
+                for references in self._reference_manager.get_references()
+                for reference in references
+            }
+            language_model = self._config.space.language_model
+            tool_display_names = {
+                str(tool.name): tool.display_name() or str(tool.name)
+                for tool in self._tool_manager.available_tools
+            }
             tool_names = [
                 tool["name"] for tool in self._debug_info_manager.get()["tools"]
             ]
 
+            total_time_to_answer_ms: int | None = None
+            if not self._chat_service.cancellation.is_cancelled:
+                if self._config.agent.input_token_distribution.enable_tool_call_persistence:
+                    await self._persist_tool_calls()
+                completed_message = (
+                    await self._chat_service.modify_assistant_message_async(
+                        set_completed_at=not self._tool_took_control,
+                    )
+                )
+                total_time_to_answer_ms = self._calculate_total_time_to_answer_ms(
+                    user_message_created_at=self._event.payload.user_message.created_at,
+                    assistant_completed_at=getattr(
+                        completed_message, "completed_at", None
+                    ),
+                )
+
+            self._debug_info_manager.add_analytics(
+                skills_debug_info,
+                language_model=AnalyticsLanguageModel(
+                    name=str(language_model.name),
+                    family=str(language_model.family),
+                    provider=str(language_model.provider),
+                ),
+                tool_display_names=tool_display_names,
+                references=len(reference_sources),
+                user_prompt_length=len(self._event.payload.user_message.text),
+                answer_length=len(self._last_assistant_text or ""),
+                loop_iteration_count=len(self._execution_times),
+                total_time_to_answer_ms=total_time_to_answer_ms,
+            )
+
             # Get current debug info from chat service and add debug info from run. Do not update if DeepResearch is in the tool names.
             if "DeepResearch" not in tool_names:
                 debug_info = {
@@ -331,16 +372,30 @@ class UniqueAI:
                     **self._debug_info_manager.get(),
                 }
                 await self._chat_service.update_debug_info_async(debug_info=debug_info)
-
-            if not self._chat_service.cancellation.is_cancelled:
-                if self._config.agent.input_token_distribution.enable_tool_call_persistence:
-                    await self._persist_tool_calls()
-                await self._chat_service.modify_assistant_message_async(
-                    set_completed_at=not self._tool_took_control,
-                )
         finally:
             sub.cancel()
 
+    @staticmethod
+    def _calculate_total_time_to_answer_ms(
+        user_message_created_at: str,
+        assistant_completed_at: datetime | None,
+    ) -> int | None:
+        if assistant_completed_at is None:
+            return None
+
+        try:
+            user_created_at = datetime.fromisoformat(user_message_created_at)
+        except (ValueError, TypeError):
+            # ValueError: malformed timestamp; TypeError: created_at not a str.
+            return None
+
+        if user_created_at.tzinfo is None:
+            user_created_at = user_created_at.replace(tzinfo=timezone.utc)
+        if assistant_completed_at.tzinfo is None:
+            assistant_completed_at = assistant_completed_at.replace(tzinfo=timezone.utc)
+
+        return round((assistant_completed_at - user_created_at).total_seconds() * 1000)
+
     def _record_loop_debug_params(self, other_options: dict) -> None:
         reasoning = other_options.get("reasoning")
         thinking_level: str = (
@@ -700,7 +755,12 @@ class UniqueAI:
         # (see ``unique_skill_tool.SkillTool._log_skill_loaded``), so it is
         # redundant and noisy to also list it here.
 
-        tool_names_not_to_log: set[str] = {"DeepResearch", "Skill", "AskUser"}
+        tool_names_not_to_log: set[str] = {
+            "DeepResearch",
+            "Skill",
+            "AskUser",
+            "ActivatePython",
+        }
 
         used_tools: dict[str, int] = {}
         for tool_call in tool_calls:

{unique_orchestrator-2026.30.0.dev4 → unique_orchestrator-2026.30.0.dev6}/unique_orchestrator/unique_ai_builder.py

@@ -2,6 +2,7 @@ from logging import Logger
 from typing import Any, NamedTuple, cast
 
 from openai import AsyncOpenAI
+from openai.types.responses import ResponseIncludable
 from typing_extensions import override
 from unique_follow_up_questions.follow_up_postprocessor import (
     FollowUpPostprocessor,
@@ -115,37 +116,24 @@ def _configure_follow_up_questions(
 
 
 class ResponsesStreamingHandler(ResponsesSupportCompleteWithReferences):
-    """Streaming handler for Responses API runs.
+    """Streaming handler for Responses API runs."""
 
-    Injects `include` params from the tool manager on every call so the
-    orchestrator loop stays generic (no isinstance checks in UniqueAI).
-
-    Delegates the actual streaming to an injected
-    `ResponsesSupportCompleteWithReferences` (the event-routing
-    `ResponsesCompleteWithReferences` orchestrator), so this class only owns
-    the `include` injection.
-    """
+    _INCLUDE: list[ResponseIncludable] = ["code_interpreter_call.outputs"]
 
     def __init__(
         self,
         inner: ResponsesSupportCompleteWithReferences,
-        tool_manager: ResponsesApiToolManager,
     ) -> None:
         self._inner: ResponsesSupportCompleteWithReferences = inner
-        self._tool_manager: ResponsesApiToolManager = tool_manager
 
     @override
     def complete_with_references(self, *args: Any, **kwargs: Any) -> Any:
-        include = self._tool_manager.get_required_include_params()
-        if include:
-            kwargs["include"] = include
+        kwargs["include"] = self._INCLUDE
         return self._inner.complete_with_references(*args, **kwargs)
 
     @override
     async def complete_with_references_async(self, *args: Any, **kwargs: Any) -> Any:
-        include = self._tool_manager.get_required_include_params()
-        if include:
-            kwargs["include"] = include
+        kwargs["include"] = self._INCLUDE
         return await self._inner.complete_with_references_async(*args, **kwargs)
 
 
@@ -602,7 +590,6 @@ async def _build_responses(
 
     streaming_handler = ResponsesStreamingHandler(
         inner=inner,
-        tool_manager=tool_manager,
     )
 
     _add_sub_agents_postprocessor(

unique_orchestrator-2026.30.0.dev4/unique_orchestrator/tests/test_unique_ai_plan_or_execute_include.py

@@ -1,120 +0,0 @@
-"""Tests for ResponsesStreamingHandler include injection (UN-17972).
-
-The include forwarding logic lives in ResponsesStreamingHandler in
-unique_ai_builder.py so that UniqueAI stays generic (no isinstance checks).
-"""
-
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-from unique_toolkit.agentic.tools.tool_manager import ResponsesApiToolManager
-
-from unique_orchestrator.unique_ai_builder import (
-    ResponsesStreamingHandler,
-    _ChatServiceResponsesStreaming,
-)
-
-
-def _make_handler(
-    include_params: list[str],
-) -> ResponsesStreamingHandler:
-    tool_manager = MagicMock(spec=ResponsesApiToolManager)
-    tool_manager.get_required_include_params.return_value = include_params
-    inner = MagicMock()
-    inner.complete_with_references_async = AsyncMock(return_value=MagicMock())
-    inner.complete_with_references = MagicMock(return_value=MagicMock())
-    return ResponsesStreamingHandler(
-        inner=inner,
-        tool_manager=tool_manager,
-    )
-
-
-@pytest.mark.ai
-@pytest.mark.asyncio
-async def test_responses_streaming_handler__injects_include__when_tool_manager_returns_params() -> (
-    None
-):
-    """
-    Purpose: Verify complete_with_references_async injects include when the tool
-    manager returns a non-empty list.
-    Why this matters: UN-17972 requires code_interpreter_call.outputs on the
-    Responses API so execution logs attach to tool calls.
-    """
-    handler = _make_handler(include_params=["code_interpreter_call.outputs"])
-
-    await handler.complete_with_references_async(messages=[], model_name="model")
-
-    call_kwargs = handler._inner.complete_with_references_async.await_args.kwargs
-    assert call_kwargs["include"] == ["code_interpreter_call.outputs"]
-    handler._tool_manager.get_required_include_params.assert_called_once()
-
-
-@pytest.mark.ai
-@pytest.mark.asyncio
-async def test_responses_streaming_handler__omits_include__when_tool_manager_returns_empty() -> (
-    None
-):
-    """
-    Purpose: Verify include is not added when get_required_include_params returns [].
-    Why this matters: No extra include should reach the Responses API when no tool
-    requests it — preserving legacy behaviour exactly.
-    """
-    handler = _make_handler(include_params=[])
-
-    await handler.complete_with_references_async(messages=[], model_name="model")
-
-    call_kwargs = handler._inner.complete_with_references_async.await_args.kwargs
-    assert "include" not in call_kwargs
-
-
-@pytest.mark.ai
-def test_responses_streaming_handler__injects_include__sync_path() -> None:
-    """
-    Purpose: Verify the synchronous complete_with_references also injects include.
-    """
-    handler = _make_handler(include_params=["code_interpreter_call.outputs"])
-
-    handler.complete_with_references(messages=[], model_name="model")
-
-    call_kwargs = handler._inner.complete_with_references.call_args.kwargs
-    assert call_kwargs["include"] == ["code_interpreter_call.outputs"]
-
-
-@pytest.mark.ai
-def test_responses_streaming_handler__omits_include__sync_path_when_empty() -> None:
-    """Purpose: No include injected via sync path when tool manager returns []."""
-    handler = _make_handler(include_params=[])
-
-    handler.complete_with_references(messages=[], model_name="model")
-
-    call_kwargs = handler._inner.complete_with_references.call_args.kwargs
-    assert "include" not in call_kwargs
-
-
-@pytest.mark.ai
-@pytest.mark.asyncio
-async def test_chat_service_responses_streaming__forwards_to_responses_methods() -> (
-    None
-):
-    """
-    Purpose: The legacy adapter must route the protocol's
-    `complete_with_references[_async]` to ChatService's Responses-specific
-    methods, not the Chat Completions ones.
-    Why this matters: ChatService exposes both; routing to the wrong method
-    would silently stream through the Chat Completions API.
-    """
-    chat_service = MagicMock()
-    chat_service.complete_responses_with_references = MagicMock(
-        return_value=MagicMock()
-    )
-    chat_service.complete_responses_with_references_async = AsyncMock(
-        return_value=MagicMock()
-    )
-    adapter = _ChatServiceResponsesStreaming(chat_service)
-
-    adapter.complete_with_references(messages=[], model_name="model")
-    await adapter.complete_with_references_async(messages=[], model_name="model")
-
-    chat_service.complete_responses_with_references.assert_called_once()
-    chat_service.complete_responses_with_references_async.assert_awaited_once()
-    chat_service.complete_with_references.assert_not_called()