unique_orchestrator 2026.30.0.dev5__tar.gz → 2026.30.0.dev7__tar.gz

{unique_orchestrator-2026.30.0.dev5 → unique_orchestrator-2026.30.0.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-orchestrator
-Version: 2026.30.0.dev5
+Version: 2026.30.0.dev7
 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.dev15,<2026.30.0rc0
+Requires-Dist: unique-toolkit>=2026.30.0.dev19,<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.dev5 → unique_orchestrator-2026.30.0.dev7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_orchestrator"
-version = "2026.30.0.dev5"
+version = "2026.30.0.dev7"
 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.dev15,<2026.30.0rc0",
+    "unique-toolkit>=2026.30.0.dev19,<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.dev5 → unique_orchestrator-2026.30.0.dev7}/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.dev5 → unique_orchestrator-2026.30.0.dev7}/unique_orchestrator/tests/test_unique_ai_async_modify.py

@@ -3,6 +3,9 @@
 from unittest.mock import AsyncMock, MagicMock
 
 import pytest
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter import (
+    DisplayCodeInterpreterFilesPostProcessor,
+)
 
 from unique_orchestrator.unique_ai import UniqueAI
 
@@ -85,6 +88,7 @@ def _make_ua(monkeypatch, *, feature_flag_enabled: bool = False):
     ua._mcp_servers = []
     ua._execution_times = []
     ua._current_loop_timing = {}
+    ua._generated_files_info = None
     ua.current_iteration_index = 0
     ua._skill_choices = []
 
@@ -126,3 +130,23 @@ async def test_process_plan_calls_modify_async_on_empty_response(monkeypatch):
 
     assert result is True
     ua._chat_service.modify_assistant_message_async.assert_called()
+
+
+@pytest.mark.ai
+@pytest.mark.asyncio
+async def test_handle_no_tool_calls_stores_returned_artifacts_for_analytics(
+    monkeypatch,
+):
+    ua = _make_ua(monkeypatch)
+    artifacts = {"count": 1, "filetypes": ["csv"]}
+    ua._postprocessor_manager.run_postprocessors.return_value = {
+        DisplayCodeInterpreterFilesPostProcessor.__name__: artifacts
+    }
+    ua._current_loop_timing = {"post_processing": {}, "evaluation": {}}
+
+    response = MagicMock()
+    response.model_copy.return_value = response
+
+    await ua._handle_no_tool_calls(response)
+
+    assert ua._generated_files_info == artifacts

{unique_orchestrator-2026.30.0.dev5 → unique_orchestrator-2026.30.0.dev7}/unique_orchestrator/tests/test_unique_ai_loop_debug_params.py

@@ -478,6 +478,34 @@ class TestRunLoopDebugParams:
         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
+    async def test_run__generated_files_info__reset_at_start_prevents_stale_artifacts(
+        self, monkeypatch
+    ) -> None:
+        """
+        Purpose: Verify run() resets _generated_files_info at the start, so a rerun
+        that exits without reaching _handle_no_tool_calls does not report the previous
+        run's artifacts.
+        Why this matters: _generated_files_info persists on the UniqueAI instance;
+        without a reset it leaks a prior run's artifact count/filetypes into the
+        current answer's analytics (Cursor bot, UN-22110).
+        Setup summary: Seed a stale value, force an early loop exit via _process_plan
+        returning True (a tool took control — _handle_no_tool_calls never runs), and
+        assert add_analytics received artifacts=None.
+        """
+        ua = self._build_run_ua(monkeypatch)
+        # Leftover from a hypothetical previous run on the same instance.
+        ua._generated_files_info = {"count": 99, "filetypes": ["stale"]}
+        # Exit the loop as if a tool took control: _handle_no_tool_calls (which sets
+        # _generated_files_info) is skipped, but finalization still calls add_analytics.
+        ua._process_plan = AsyncMock(return_value=True)  # type: ignore[method-assign]
+
+        await ua.run()
+
+        analytics_call = ua._debug_info_manager.add_analytics.call_args
+        assert analytics_call.kwargs["artifacts"] is None
+
     @pytest.mark.ai
     @pytest.mark.asyncio
     async def test_run__loop_params__contains_one_entry_per_iteration(

unique_orchestrator-2026.30.0.dev7/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.dev5 → unique_orchestrator-2026.30.0.dev7}/unique_orchestrator/unique_ai.py

@@ -32,6 +32,12 @@ from unique_toolkit.agentic.tools.experimental.open_file_tool import (
     OpenFileToolRuntime,
     OpenFileToolRuntimeConfig,
 )
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter import (
+    DisplayCodeInterpreterFilesPostProcessor,
+)
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.postprocessors.generated_files import (
+    ArtifactsDebugInfo,
+)
 from unique_toolkit.agentic.tools.tool_manager import (
     ResponsesApiToolManager,
     SafeTaskExecutor,
@@ -197,6 +203,7 @@ class UniqueAI:
         self._execution_times: list[dict[str, Any]] = []
         self._current_loop_timing: dict[str, Any] = {}
         self._loop_debug_params: list[dict[str, Any]] = []
+        self._generated_files_info: ArtifactsDebugInfo | None = None
 
     async def _on_cancellation(self, _event: CancellationEvent) -> None:
         """Subscriber called by the cancellation event bus."""
@@ -222,6 +229,10 @@ class UniqueAI:
 
         self._execution_times = []
         self._loop_debug_params = []
+        # Reset per-run artifact analytics too: a later run that exits without
+        # reaching _handle_no_tool_calls (tool takes control / empty response /
+        # cancellation) must not report the previous run's artifacts.
+        self._generated_files_info = None
         run_start = time.perf_counter()
 
         await preload_invoked_skills(
@@ -363,6 +374,7 @@ class UniqueAI:
                 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,
+                artifacts=self._generated_files_info,
             )
 
             # Get current debug info from chat service and add debug info from run. Do not update if DeepResearch is in the tool names.
@@ -696,11 +708,19 @@ class UniqueAI:
             loop_response.model_copy(deep=True),
         )
 
-        _, evaluation_results = await asyncio.gather(
+        postprocessor_result, evaluation_results = await asyncio.gather(
             postprocessor_result,
             evaluation_results,
         )
-
+        postprocessor_outputs = postprocessor_result.unpack() or {}
+        # run_postprocessors erases each postprocessor's return type to
+        # `object | None` (generic channel), so re-narrow the one we own.
+        self._generated_files_info = cast(
+            "ArtifactsDebugInfo | None",
+            postprocessor_outputs.get(
+                DisplayCodeInterpreterFilesPostProcessor.__name__
+            ),
+        )
         self._current_loop_timing["post_processing"].update(
             self._postprocessor_manager.get_execution_times()
         )
@@ -755,7 +775,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.dev5 → unique_orchestrator-2026.30.0.dev7}/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.dev5/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()