unique_orchestrator 2026.22.0.dev6__tar.gz → 2026.22.0.dev8__tar.gz

{unique_orchestrator-2026.22.0.dev6 → unique_orchestrator-2026.22.0.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-orchestrator
-Version: 2026.22.0.dev6
+Version: 2026.22.0.dev8
 Summary: 
 Author: Andreas Hauri
 Author-email: Andreas Hauri <andreas.hauri@unique.ai>
@@ -9,16 +9,15 @@ 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.22.0.dev7,<2026.22.0rc0
+Requires-Dist: unique-toolkit>=2026.22.0.dev11,<2026.22.0rc0
 Requires-Dist: unique-stock-ticker>=2026.22.0.dev2,<2026.22.0rc0
 Requires-Dist: unique-follow-up-questions>=2026.22.0.dev2,<2026.22.0rc0
 Requires-Dist: unique-internal-search>=2026.22.0.dev3,<2026.22.0rc0
 Requires-Dist: unique-deep-research>=2026.22.0.dev2,<2026.22.0rc0
 Requires-Dist: unique-web-search>=2026.22.0.dev4,<2026.22.0rc0
 Requires-Dist: unique-swot>=2026.22.0.dev2,<2026.22.0rc0
-Requires-Dist: unique-skill-tool>=2026.22.0.dev4,<2026.22.0rc0
+Requires-Dist: unique-skill-tool>=2026.22.0.dev6,<2026.22.0rc0
 Requires-Dist: openai>=1.109.1,<3
-Requires-Dist: python-frontmatter>=1.1.0,<2
 Requires-Python: >=3.12, <4
 Description-Content-Type: text/markdown
 

{unique_orchestrator-2026.22.0.dev6 → unique_orchestrator-2026.22.0.dev8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_orchestrator"
-version = "2026.22.0.dev6"
+version = "2026.22.0.dev8"
 description = ""
 readme = "README.md"
 license = { text = "Proprietary" }
@@ -13,16 +13,15 @@ dependencies = [
     "pydantic-settings>=2.10.1,<3",
     "typing-extensions>=4.9.0,<5",
     "jinja2>=3.1.0,<4",
-    "unique-toolkit>=2026.22.0.dev7,<2026.22.0rc0",
+    "unique-toolkit>=2026.22.0.dev11,<2026.22.0rc0",
     "unique-stock-ticker>=2026.22.0.dev2,<2026.22.0rc0",
     "unique-follow-up-questions>=2026.22.0.dev2,<2026.22.0rc0",
     "unique-internal-search>=2026.22.0.dev3,<2026.22.0rc0",
     "unique-deep-research>=2026.22.0.dev2,<2026.22.0rc0",
     "unique-web-search>=2026.22.0.dev4,<2026.22.0rc0",
     "unique-swot>=2026.22.0.dev2,<2026.22.0rc0",
-    "unique-skill-tool>=2026.22.0.dev4,<2026.22.0rc0",
+    "unique-skill-tool>=2026.22.0.dev6,<2026.22.0rc0",
     "openai>=1.109.1,<3",
-    "python-frontmatter>=1.1.0,<2",
 ]
 
 [build-system]

{unique_orchestrator-2026.22.0.dev6 → unique_orchestrator-2026.22.0.dev8}/unique_orchestrator/_builders/skill_setup.py

@@ -43,11 +43,10 @@ from __future__ import annotations
 
 import asyncio
 from logging import Logger
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
-import frontmatter
-from pydantic import ValidationError
 from unique_skill_tool.config import SkillToolConfig
+from unique_skill_tool.loader import parse_skill_file
 from unique_skill_tool.schemas import SkillDefinition
 from unique_skill_tool.service import SkillTool
 from unique_toolkit.agentic.tools.config import ToolBuildConfig
@@ -76,29 +75,6 @@ def _find_skill_tool_build_config(
     return None
 
 
-def _parse_frontmatter(*, text: str) -> tuple[dict[str, Any], str]:
-    """Split YAML frontmatter from the markdown body.
-
-    Thin wrapper around ``python-frontmatter``. On a YAML parse error,
-    or when the frontmatter parses to a non-mapping (e.g. a top-level
-    YAML list), we fall back to ``({}, <stripped body>)`` so a broken
-    skill file never leaks its raw ``---\\nname: ...\\n---`` block into
-    the LLM prompt, but also never crashes ``_build_skill`` with an
-    unhandled ``TypeError``/``ValueError`` from ``dict(...)``.
-    """
-    try:
-        post = frontmatter.loads(text)
-        metadata = post.metadata
-        body = post.content
-    except Exception:
-        return {}, text
-
-    if not isinstance(metadata, dict):
-        return {}, body
-
-    return dict(metadata), body
-
-
 def normalize_available_skills_for_tool(
     available_skills: list[SkillReference],
 ) -> list[SkillReference]:
@@ -125,56 +101,6 @@ def normalize_available_skills_for_tool(
     return out
 
 
-def _build_skill(
-    *,
-    content_id: str,
-    content_key: str,
-    file_text: str,
-    logger: Logger,
-) -> SkillDefinition | None:
-    """Build a ``SkillDefinition`` from the raw file text of a KB document.
-
-    Parses YAML frontmatter for ``name`` and ``description``. A malformed
-    ``name`` (non-kebab-case, contains whitespace/punctuation, too long)
-    is rejected by ``SkillDefinition`` rather than silently flowing into
-    the OpenAI tool enum where the model could never emit it verbatim.
-
-    ``content_id`` is stored on the returned definition so it can be used
-    as a lookup key to load the SKILL.md.
-    """
-    if not file_text.strip():
-        return None
-
-    metadata, body = _parse_frontmatter(text=file_text)
-
-    name = metadata.get("name")
-    description = metadata.get("description")
-
-    if not name or not description:
-        logger.warning(
-            "Skipping '%s' (%s): wrong skill format.",
-            content_key,
-            content_id,
-        )
-        return None
-
-    try:
-        return SkillDefinition(
-            name=name,
-            description=description,
-            content=body,
-            content_id=content_id,
-        )
-    except ValidationError as exc:
-        logger.warning(
-            "Skipping '%s' (%s): invalid skill definition: %s",
-            content_key,
-            content_id,
-            exc.errors(include_url=False),
-        )
-        return None
-
-
 async def load_selectable_skills(
     *,
     content_service: ContentService,
@@ -224,12 +150,22 @@ async def load_selectable_skills(
             )
             continue
 
-        skill = _build_skill(
-            content_id=entry.content_id,
-            content_key=label,
-            file_text=file_text,
-            logger=logger,
-        )
+        try:
+            skill = parse_skill_file(
+                file_text=file_text,
+                content_id=entry.content_id,
+                source_label=label,
+                logger=logger,
+            )
+        except Exception:
+            logger.warning(
+                "Unexpected error building selectable skill '%s' (%s) — skipping.",
+                label,
+                entry.content_id,
+                exc_info=True,
+            )
+            continue
+
         if skill is None:
             logger.debug(
                 "Skipping selectable skill '%s' (%s): empty or invalid file.",

{unique_orchestrator-2026.22.0.dev6 → unique_orchestrator-2026.22.0.dev8}/unique_orchestrator/tests/test_unique_ai_execution_timing.py

@@ -727,9 +727,11 @@ class TestRunExecutionTimingIntegration:
 
         await ua.run()
 
-        call_args = ua._debug_info_manager.add.call_args
-        assert call_args[0][0] == "execution_time"
-        payload = call_args[0][1]
+        calls_by_key = {
+            args[0][0]: args[0][1] for args in ua._debug_info_manager.add.call_args_list
+        }
+        assert "execution_time" in calls_by_key
+        payload = calls_by_key["execution_time"]
         assert "loop_iterations" in payload
         assert "total_time" in payload
 

unique_orchestrator-2026.22.0.dev8/unique_orchestrator/tests/test_unique_ai_loop_debug_params.py

@@ -0,0 +1,424 @@
+"""Tests for _loop_debug_params — per-iteration debug info tracking.
+
+Covers initialisation, per-call accumulation in _plan_or_execute (both
+completions-API and responses-API thinking-level extraction), and the final
+write of ``loop_params`` to the debug info manager in run().
+"""
+
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+# ---------------------------------------------------------------------------
+# Shared helpers
+# ---------------------------------------------------------------------------
+
+
+def _build_unique_ai(**overrides):
+    """Return a minimal UniqueAI with all external dependencies mocked."""
+    from unique_orchestrator.unique_ai import UniqueAI
+
+    mock_tool_manager = MagicMock()
+    mock_tool_manager.available_tools = []
+    mock_tool_manager.get_forced_tools.return_value = []
+    mock_tool_manager.get_tool_definitions.return_value = []
+    mock_tool_manager.filter_duplicate_tool_calls.side_effect = lambda x: x
+    mock_tool_manager.filter_tool_calls_by_max_tool_calls_allowed.side_effect = (
+        lambda x: x
+    )
+    mock_tool_manager.does_a_tool_take_control.return_value = False
+    mock_tool_manager.should_stop_after_tool_calls.return_value = False
+    mock_tool_manager.get_evaluation_check_list.return_value = []
+
+    mock_chat_service = MagicMock()
+    mock_chat_service.update_debug_info_async = AsyncMock(return_value=None)
+    mock_chat_service.get_debug_info_async = AsyncMock(return_value={})
+
+    dummy_event = MagicMock()
+    dummy_event.payload.assistant_message.id = "assist_1"
+    dummy_event.payload.user_message.text = "query"
+    dummy_event.payload.assistant_id = "assistant_123"
+    dummy_event.payload.name = "TestAssistant"
+    dummy_event.payload.user_metadata = {}
+    dummy_event.payload.tool_parameters = {}
+
+    mock_config = MagicMock()
+    mock_config.agent.prompt_config.user_metadata = []
+
+    mock_debug_info_manager = MagicMock()
+    mock_debug_info_manager.get.return_value = {}
+
+    defaults = dict(
+        logger=MagicMock(),
+        event=dummy_event,
+        config=mock_config,
+        chat_service=mock_chat_service,
+        content_service=MagicMock(),
+        debug_info_manager=mock_debug_info_manager,
+        streaming_handler=MagicMock(),
+        reference_manager=MagicMock(),
+        thinking_manager=MagicMock(),
+        tool_manager=mock_tool_manager,
+        history_manager=MagicMock(),
+        evaluation_manager=MagicMock(),
+        postprocessor_manager=MagicMock(),
+        message_step_logger=MagicMock(),
+        mcp_servers=[],
+        loop_iteration_runner=MagicMock(),
+    )
+    defaults.update(overrides)
+    return UniqueAI(**defaults)
+
+
+def _make_loop_response() -> MagicMock:
+    response = MagicMock()
+    response.tool_calls = None
+    response.message = MagicMock()
+    response.message.references = []
+    response.message.text = "response text"
+    response.is_empty.return_value = False
+    return response
+
+
+async def _call_plan_or_execute(ua, monkeypatch, other_options: dict) -> None:
+    """Call _plan_or_execute with a patched resolve_other_options."""
+    monkeypatch.setattr(
+        "unique_orchestrator.unique_ai.resolve_other_options",
+        lambda *_args, **_kwargs: other_options,
+    )
+    ua._compose_message_plan_execution = AsyncMock(return_value=[])  # type: ignore[method-assign]
+    ua._loop_iteration_runner = AsyncMock(return_value=_make_loop_response())
+    await ua._plan_or_execute()
+
+
+# ---------------------------------------------------------------------------
+# Initialisation
+# ---------------------------------------------------------------------------
+
+
+class TestLoopDebugParamsInit:
+    @pytest.mark.ai
+    def test_init__loop_debug_params__is_empty_list(self) -> None:
+        """
+        Purpose: Verify that _loop_debug_params is initialised as an empty list.
+        Why this matters: An uninitialised attribute causes AttributeError on the
+        first append inside _plan_or_execute.
+        Setup summary: Freshly constructed UniqueAI; assert _loop_debug_params == [].
+        """
+        ua = _build_unique_ai()
+        assert ua._loop_debug_params == []
+
+
+# ---------------------------------------------------------------------------
+# _plan_or_execute — thinking-level extraction
+# ---------------------------------------------------------------------------
+
+
+class TestPlanOrExecuteLoopDebugParams:
+    @pytest.mark.ai
+    @pytest.mark.asyncio
+    async def test_plan_or_execute__completions_api__reasoning_effort_stored(
+        self, monkeypatch
+    ) -> None:
+        """
+        Purpose: Verify that a ``reasoning_effort`` value from the completions API
+        is stored as ``thinking_level`` in the appended entry.
+        Why this matters: The completions API uses a flat ``reasoning_effort`` key;
+        the extractor must read from there, not from ``reasoning.effort``.
+        Setup summary: Patch resolve_other_options to return
+        ``{'reasoning_effort': 'high'}``; call _plan_or_execute; assert
+        _loop_debug_params[0]['thinking_level'] == 'high'.
+        """
+        ua = _build_unique_ai()
+        await _call_plan_or_execute(ua, monkeypatch, {"reasoning_effort": "high"})
+
+        assert len(ua._loop_debug_params) == 1
+        assert ua._loop_debug_params[0]["thinking_level"] == "high"
+
+    @pytest.mark.ai
+    @pytest.mark.asyncio
+    async def test_plan_or_execute__responses_api__reasoning_effort_stored(
+        self, monkeypatch
+    ) -> None:
+        """
+        Purpose: Verify that ``reasoning.effort`` from the responses API is stored
+        as ``thinking_level``.
+        Why this matters: The responses API nests the effort inside a ``reasoning``
+        dict; failing to look there would always produce None for responses-API calls.
+        Setup summary: Patch resolve_other_options to return
+        ``{'reasoning': {'effort': 'low'}}``; assert thinking_level == 'low'.
+        """
+        ua = _build_unique_ai()
+        await _call_plan_or_execute(ua, monkeypatch, {"reasoning": {"effort": "low"}})
+
+        assert len(ua._loop_debug_params) == 1
+        assert ua._loop_debug_params[0]["thinking_level"] == "low"
+
+    @pytest.mark.ai
+    @pytest.mark.asyncio
+    async def test_plan_or_execute__no_thinking_level__none_string_stored(
+        self, monkeypatch
+    ) -> None:
+        """
+        Purpose: Verify that when resolve_other_options returns no reasoning-related
+        keys, thinking_level is stored as the string "None".
+        Why this matters: Using the string "None" instead of Python None keeps the
+        debug payload consistently typed as str, which serialises cleanly to JSON
+        and is unambiguous in log output.
+        Setup summary: Patch resolve_other_options to return {}; assert
+        thinking_level == "None".
+        """
+        ua = _build_unique_ai()
+        await _call_plan_or_execute(ua, monkeypatch, {})
+
+        assert len(ua._loop_debug_params) == 1
+        assert ua._loop_debug_params[0]["thinking_level"] == "None"
+
+    @pytest.mark.ai
+    @pytest.mark.asyncio
+    async def test_plan_or_execute__loop_number__matches_current_iteration_index(
+        self, monkeypatch
+    ) -> None:
+        """
+        Purpose: Verify that loop_number in the appended entry equals
+        current_iteration_index at call time.
+        Why this matters: Consumers use loop_number to correlate debug params with
+        execution timing entries; a wrong value breaks that correlation.
+        Setup summary: Set current_iteration_index to 3; call _plan_or_execute;
+        assert loop_number == 3.
+        """
+        ua = _build_unique_ai()
+        ua.current_iteration_index = 3
+        await _call_plan_or_execute(ua, monkeypatch, {"reasoning_effort": "medium"})
+
+        assert ua._loop_debug_params[0]["loop_number"] == 3
+
+    @pytest.mark.ai
+    @pytest.mark.asyncio
+    async def test_plan_or_execute__multiple_calls__accumulates_entries_in_order(
+        self, monkeypatch
+    ) -> None:
+        """
+        Purpose: Verify that repeated calls across iterations append independent
+        entries in the correct order.
+        Why this matters: A multi-iteration run must produce one entry per iteration
+        with no overwrites or entry merges.
+        Setup summary: Call _plan_or_execute twice with different iteration indices
+        and thinking levels; assert len == 2 and each entry has the correct values.
+        """
+        ua = _build_unique_ai()
+
+        monkeypatch.setattr(
+            "unique_orchestrator.unique_ai.resolve_other_options",
+            lambda *_args, **_kwargs: {"reasoning_effort": "high"},
+        )
+        ua._compose_message_plan_execution = AsyncMock(return_value=[])  # type: ignore[method-assign]
+        ua._loop_iteration_runner = AsyncMock(return_value=_make_loop_response())
+        ua.current_iteration_index = 0
+        await ua._plan_or_execute()
+
+        monkeypatch.setattr(
+            "unique_orchestrator.unique_ai.resolve_other_options",
+            lambda *_args, **_kwargs: {"reasoning": {"effort": "low"}},
+        )
+        ua.current_iteration_index = 1
+        await ua._plan_or_execute()
+
+        assert len(ua._loop_debug_params) == 2
+        assert ua._loop_debug_params[0] == {"loop_number": 0, "thinking_level": "high"}
+        assert ua._loop_debug_params[1] == {"loop_number": 1, "thinking_level": "low"}
+
+
+# ---------------------------------------------------------------------------
+# run() integration — loop_params written to debug info manager
+# ---------------------------------------------------------------------------
+
+
+class TestRunLoopDebugParams:
+    def _build_run_ua(self, monkeypatch):
+        mock_feature_flags = MagicMock()
+        monkeypatch.setattr(
+            "unique_orchestrator.unique_ai.feature_flags", mock_feature_flags
+        )
+        monkeypatch.setattr(
+            "unique_orchestrator.unique_ai.resolve_other_options",
+            lambda *_args, **_kwargs: {"reasoning_effort": "high"},
+        )
+
+        mock_cancellation = MagicMock()
+        mock_cancellation.is_cancelled = False
+        mock_cancellation.on_cancellation.subscribe = MagicMock(
+            return_value=MagicMock()
+        )
+        mock_cancellation.check_cancellation_async = AsyncMock(return_value=False)
+
+        mock_chat_service = MagicMock()
+        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)
+        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")
+        )
+
+        mock_tool_manager = MagicMock()
+        mock_tool_manager.available_tools = []
+        mock_tool_manager.get_forced_tools.return_value = []
+        mock_tool_manager.get_tool_definitions.return_value = []
+        mock_tool_manager.filter_duplicate_tool_calls.side_effect = lambda x: x
+        mock_tool_manager.filter_tool_calls_by_max_tool_calls_allowed.side_effect = (
+            lambda x: x
+        )
+        mock_tool_manager.does_a_tool_take_control.return_value = False
+        mock_tool_manager.should_stop_after_tool_calls.return_value = False
+        mock_tool_manager.get_evaluation_check_list.return_value = []
+
+        mock_debug_info_manager = MagicMock()
+        mock_debug_info_manager.get.return_value = {"tools": []}
+
+        mock_config = MagicMock()
+        mock_config.effective_max_loop_iterations = 1
+        mock_config.agent.prompt_config.user_metadata = []
+
+        mock_history_manager = MagicMock()
+        mock_history_manager.get_history_for_model_call = AsyncMock(
+            return_value=MagicMock()
+        )
+        mock_history_manager.add_tool_call_results = MagicMock()
+        mock_history_manager.extract_message_tools.return_value = []
+
+        mock_postprocessor_manager = MagicMock()
+        mock_postprocessor_manager.run_postprocessors = AsyncMock(return_value=None)
+        mock_postprocessor_manager.get_execution_times.return_value = {}
+
+        mock_evaluation_manager = MagicMock()
+        mock_evaluation_manager.run_evaluations = AsyncMock(return_value=[])
+        mock_evaluation_manager.get_execution_times.return_value = {}
+
+        dummy_event = MagicMock()
+        dummy_event.payload.assistant_message.id = "assist_1"
+        dummy_event.payload.user_message.text = "query"
+        dummy_event.payload.assistant_id = "assistant_123"
+        dummy_event.payload.name = "TestAssistant"
+        dummy_event.payload.user_metadata = {}
+        dummy_event.payload.tool_parameters = {}
+        dummy_event.company_id = "company_1"
+
+        loop_response = _make_loop_response()
+
+        from unique_orchestrator.unique_ai import UniqueAI
+
+        ua = UniqueAI(
+            logger=MagicMock(),
+            event=dummy_event,
+            config=mock_config,
+            chat_service=mock_chat_service,
+            content_service=MagicMock(),
+            debug_info_manager=mock_debug_info_manager,
+            streaming_handler=MagicMock(),
+            reference_manager=MagicMock(),
+            thinking_manager=MagicMock(),
+            tool_manager=mock_tool_manager,
+            history_manager=mock_history_manager,
+            evaluation_manager=mock_evaluation_manager,
+            postprocessor_manager=mock_postprocessor_manager,
+            message_step_logger=MagicMock(),
+            mcp_servers=[],
+            loop_iteration_runner=AsyncMock(return_value=loop_response),
+        )
+        ua._render_user_prompt = AsyncMock(return_value="user")  # type: ignore[method-assign]
+        ua._render_system_prompt = AsyncMock(return_value="system")  # type: ignore[method-assign]
+        ua._thinking_manager.thinking_is_displayed = MagicMock(return_value=True)
+        return ua
+
+    @pytest.mark.ai
+    @pytest.mark.asyncio
+    async def test_run__debug_info_manager__receives_loop_params_key(
+        self, monkeypatch
+    ) -> None:
+        """
+        Purpose: Verify that run() calls debug_info_manager.add with 'loop_params'
+        after the agentic loop completes.
+        Why this matters: Without this call, loop-level debug params are never
+        persisted and the feature has no observable effect.
+        Setup summary: Run one iteration; assert add was called with 'loop_params'
+        as the first argument.
+        """
+        ua = self._build_run_ua(monkeypatch)
+
+        await ua.run()
+
+        keys_written = [
+            call.args[0] for call in ua._debug_info_manager.add.call_args_list
+        ]
+        assert "loop_params" in keys_written
+
+    @pytest.mark.ai
+    @pytest.mark.asyncio
+    async def test_run__loop_params__contains_one_entry_per_iteration(
+        self, monkeypatch
+    ) -> None:
+        """
+        Purpose: Verify that the loop_params value written to the debug info manager
+        contains exactly one entry for a single-iteration run.
+        Why this matters: The entry count must match the iteration count so that
+        loop_params and execution_time.loop_iterations stay in sync.
+        Setup summary: Run with effective_max_loop_iterations=1; find the loop_params
+        add call; assert the value is a list of length 1.
+        """
+        ua = self._build_run_ua(monkeypatch)
+
+        await ua.run()
+
+        loop_params_call = next(
+            call
+            for call in ua._debug_info_manager.add.call_args_list
+            if call.args[0] == "loop_params"
+        )
+        payload = loop_params_call.args[1]
+        assert isinstance(payload, list)
+        assert len(payload) == 1
+
+    @pytest.mark.ai
+    @pytest.mark.asyncio
+    async def test_run__loop_params_entry__contains_loop_number_and_thinking_level(
+        self, monkeypatch
+    ) -> None:
+        """
+        Purpose: Verify that each entry in loop_params has the expected keys.
+        Why this matters: Consumers read these keys by name; missing keys cause
+        KeyErrors or require defensive coding across all consumers.
+        Setup summary: Run one iteration; assert the single entry has both
+        'loop_number' and 'thinking_level'.
+        """
+        ua = self._build_run_ua(monkeypatch)
+
+        await ua.run()
+
+        loop_params_call = next(
+            call
+            for call in ua._debug_info_manager.add.call_args_list
+            if call.args[0] == "loop_params"
+        )
+        entry = loop_params_call.args[1][0]
+        assert "loop_number" in entry
+        assert "thinking_level" in entry
+
+    @pytest.mark.ai
+    @pytest.mark.asyncio
+    async def test_run__loop_debug_params__reset_on_each_run(self, monkeypatch) -> None:
+        """
+        Purpose: Verify that _loop_debug_params is cleared at the start of each
+        run() call.
+        Why this matters: Without a reset, consecutive run() calls on the same
+        instance accumulate stale entries from previous runs, inflating the
+        loop_params list.
+        Setup summary: Run twice; assert _loop_debug_params has exactly one entry
+        after the second run (not two).
+        """
+        ua = self._build_run_ua(monkeypatch)
+
+        await ua.run()
+        await ua.run()
+
+        assert len(ua._loop_debug_params) == 1

unique_orchestrator-2026.22.0.dev8/unique_orchestrator/tests/test_utils_resolve_other_options.py

@@ -0,0 +1,261 @@
+"""Tests for utils.resolve_other_options().
+
+Verifies that the highest effort level is selected across
+``additional_llm_options`` from config and the ``thinking_level`` hints
+declared on skills activated in the current run, and that the effort is
+written in the format required by the active API.
+"""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+from unique_skill_tool.service import SkillTool
+
+from unique_orchestrator.utils import resolve_other_options
+
+
+def _make_config(
+    additional_llm_options: dict,
+    use_responses_api: bool = False,
+    supported_reasoning_efforts: list[str] | None = None,
+) -> MagicMock:
+    config = MagicMock()
+    config.agent.experimental.additional_llm_options = additional_llm_options
+    config.agent.experimental.responses_api_config.use_responses_api = use_responses_api
+    config.agent.experimental.use_responses_api = use_responses_api
+    config.space.language_model.supported_reasoning_efforts = (
+        supported_reasoning_efforts
+    )
+    return config
+
+
+def _make_tool_manager(skill_tool: SkillTool | None = None) -> MagicMock:
+    tool_manager = MagicMock()
+    tool_manager.get_tool_by_name.return_value = skill_tool
+    return tool_manager
+
+
+def _make_skill_tool_with_max(max_level: str | None) -> SkillTool:
+    tool = MagicMock(spec=SkillTool)
+    tool.max_thinking_level = max_level
+    return tool
+
+
+def _call(
+    additional_llm_options: dict,
+    skill_tool: SkillTool | None = None,
+    use_responses_api: bool = False,
+    supported_reasoning_efforts: list[str] | None = None,
+) -> dict:
+    return resolve_other_options(
+        config=_make_config(
+            additional_llm_options, use_responses_api, supported_reasoning_efforts
+        ),
+        tool_manager=_make_tool_manager(skill_tool),
+        logger=MagicMock(),
+    )
+
+
+class TestResolveOtherOptions:
+    def test_returns_config_options_unchanged_when_no_skill_tool(self) -> None:
+        result = _call({"temperature": 0.5})
+        assert result == {"temperature": 0.5}
+
+    def test_returns_config_options_unchanged_when_skill_tool_has_no_hint(self) -> None:
+        skill_tool = _make_skill_tool_with_max(None)
+        result = _call({"temperature": 0.5}, skill_tool=skill_tool)
+        assert result == {"temperature": 0.5}
+
+    def test_injects_skill_hint_when_config_has_no_reasoning_effort(self) -> None:
+        skill_tool = _make_skill_tool_with_max("high")
+        result = _call({}, skill_tool=skill_tool)
+        assert result["reasoning_effort"] == "high"
+
+    def test_config_effort_wins_when_higher_than_skill(self) -> None:
+        skill_tool = _make_skill_tool_with_max("low")
+        result = _call({"reasoning_effort": "high"}, skill_tool=skill_tool)
+        assert result["reasoning_effort"] == "high"
+
+    def test_skill_hint_wins_when_higher_than_config(self) -> None:
+        skill_tool = _make_skill_tool_with_max("high")
+        result = _call({"reasoning_effort": "low"}, skill_tool=skill_tool)
+        assert result["reasoning_effort"] == "high"
+
+    def test_equal_levels_preserved(self) -> None:
+        skill_tool = _make_skill_tool_with_max("medium")
+        result = _call({"reasoning_effort": "medium"}, skill_tool=skill_tool)
+        assert result["reasoning_effort"] == "medium"
+
+    def test_other_options_keys_passed_through_unchanged(self) -> None:
+        skill_tool = _make_skill_tool_with_max("high")
+        result = _call(
+            {"reasoning_effort": "low", "responseFormat": {"type": "json_object"}},
+            skill_tool=skill_tool,
+        )
+        assert result["reasoning_effort"] == "high"
+        assert result["responseFormat"] == {"type": "json_object"}
+
+    def test_does_not_mutate_config_dict(self) -> None:
+        original = {"reasoning_effort": "low"}
+        skill_tool = _make_skill_tool_with_max("high")
+        _call(original, skill_tool=skill_tool)
+        assert original == {"reasoning_effort": "low"}
+
+    # ── Responses API ─────────────────────────────────────────────────────────
+
+    def test_reads_effort_from_nested_reasoning_dict_for_responses_api(self) -> None:
+        skill_tool = _make_skill_tool_with_max("high")
+        result = _call(
+            {"reasoning": {"effort": "low"}},
+            skill_tool=skill_tool,
+            use_responses_api=True,
+        )
+        assert result["reasoning"] == {"effort": "high"}
+        assert "reasoning_effort" not in result
+
+    def test_nested_effort_config_wins_when_higher_than_skill(self) -> None:
+        skill_tool = _make_skill_tool_with_max("low")
+        result = _call(
+            {"reasoning": {"effort": "high"}},
+            skill_tool=skill_tool,
+            use_responses_api=True,
+        )
+        assert result["reasoning"] == {"effort": "high"}
+
+    def test_skill_hint_injected_when_no_nested_effort_config(self) -> None:
+        skill_tool = _make_skill_tool_with_max("high")
+        result = _call({}, skill_tool=skill_tool, use_responses_api=True)
+        assert result["reasoning"] == {"effort": "high"}
+        assert "reasoning_effort" not in result
+
+    def test_flat_reasoning_effort_ignored_when_responses_api_active(self) -> None:
+        """``reasoning_effort`` (flat) is in the wrong format for the responses API
+        and must not be picked up as the config effort value."""
+        skill_tool = _make_skill_tool_with_max("high")
+        result = _call(
+            {"reasoning_effort": "low"},
+            skill_tool=skill_tool,
+            use_responses_api=True,
+        )
+        assert result["reasoning"] == {"effort": "high"}
+        assert result.get("reasoning_effort") == "low"
+
+    def test_extra_reasoning_subkeys_preserved_for_responses_api(self) -> None:
+        """Other keys inside ``reasoning`` (e.g. ``summary``) must survive."""
+        skill_tool = _make_skill_tool_with_max("high")
+        result = _call(
+            {"reasoning": {"effort": "low", "summary": "auto"}},
+            skill_tool=skill_tool,
+            use_responses_api=True,
+        )
+        assert result["reasoning"] == {"effort": "high", "summary": "auto"}
+
+    def test_json_string_reasoning_is_parsed_for_responses_api(self) -> None:
+        """``reasoning`` stored as a JSON string must be parsed before use."""
+        skill_tool = _make_skill_tool_with_max("high")
+        result = _call(
+            {"reasoning": '{"effort": "low"}'},
+            skill_tool=skill_tool,
+            use_responses_api=True,
+        )
+        assert result["reasoning"] == {"effort": "high"}
+
+    def test_invalid_json_string_reasoning_treated_as_empty_for_responses_api(
+        self,
+    ) -> None:
+        """An unparseable string must not crash; skill max is used as effort."""
+        skill_tool = _make_skill_tool_with_max("medium")
+        result = _call(
+            {"reasoning": "not-json"},
+            skill_tool=skill_tool,
+            use_responses_api=True,
+        )
+        assert result["reasoning"] == {"effort": "medium"}
+
+    # ── Completions API ───────────────────────────────────────────────────────
+
+    def test_nested_reasoning_effort_ignored_when_completions_api_active(self) -> None:
+        """``reasoning: {effort: ...}`` is in the wrong format for the completions API
+        and must not be picked up as the config effort value."""
+        skill_tool = _make_skill_tool_with_max("high")
+        result = _call(
+            {"reasoning": {"effort": "low"}},
+            skill_tool=skill_tool,
+            use_responses_api=False,
+        )
+        assert result["reasoning_effort"] == "high"
+        assert result.get("reasoning") == {"effort": "low"}
+
+    # ── Invalid config effort ─────────────────────────────────────────────────
+
+    def test_unrecognised_config_effort_falls_back_to_skill_max(self) -> None:
+        """An unrecognised effort string must not crash; skill max is used instead."""
+        skill_tool = _make_skill_tool_with_max("high")
+        result = _call({"reasoning_effort": "very_high"}, skill_tool=skill_tool)
+        assert result["reasoning_effort"] == "high"
+
+    def test_unrecognised_config_effort_passes_through_when_no_skill_max(self) -> None:
+        """When no skill thinking_level is active the invalid value passes through unchanged."""
+        skill_tool = _make_skill_tool_with_max(None)
+        result = _call({"reasoning_effort": "very_high"}, skill_tool=skill_tool)
+        assert result["reasoning_effort"] == "very_high"
+
+    def test_unrecognised_nested_effort_falls_back_to_skill_max_responses_api(
+        self,
+    ) -> None:
+        """Same guard for the responses-API nested path."""
+        skill_tool = _make_skill_tool_with_max("medium")
+        result = _call(
+            {"reasoning": {"effort": "very_high"}},
+            skill_tool=skill_tool,
+            use_responses_api=True,
+        )
+        assert result["reasoning"] == {"effort": "medium"}
+
+    # ── Supported reasoning efforts ───────────────────────────────────────────
+
+    def test_effort_written_when_within_supported_list(self) -> None:
+        """Resolved effort is written when it appears in the supported list."""
+        skill_tool = _make_skill_tool_with_max("high")
+        result = _call(
+            {},
+            skill_tool=skill_tool,
+            supported_reasoning_efforts=["low", "medium", "high"],
+        )
+        assert result["reasoning_effort"] == "high"
+
+    def test_effort_skipped_when_model_does_not_support_reasoning(self) -> None:
+        """Empty supported list means the model does not support reasoning_effort at all."""
+        skill_tool = _make_skill_tool_with_max("high")
+        result = _call({}, skill_tool=skill_tool, supported_reasoning_efforts=[])
+        assert "reasoning_effort" not in result
+
+    def test_effort_skipped_when_resolved_effort_not_in_supported_list(self) -> None:
+        """Resolved effort outside the supported list is not written."""
+        skill_tool = _make_skill_tool_with_max("high")
+        result = _call(
+            {},
+            skill_tool=skill_tool,
+            supported_reasoning_efforts=["low"],
+        )
+        assert "reasoning_effort" not in result
+
+    def test_original_options_preserved_when_effort_skipped(self) -> None:
+        """Other options survive when the effort is skipped due to model constraints."""
+        skill_tool = _make_skill_tool_with_max("high")
+        result = _call(
+            {"temperature": 0.5},
+            skill_tool=skill_tool,
+            supported_reasoning_efforts=[],
+        )
+        assert result == {"temperature": 0.5}
+
+    # ── No effort resolved ────────────────────────────────────────────────────
+
+    def test_no_effort_resolved_leaves_options_unchanged(self) -> None:
+        """When neither config nor skill provides an effort, options pass through."""
+        result = _call({"responseFormat": {"type": "json_object"}})
+        assert result == {"responseFormat": {"type": "json_object"}}
+        assert "reasoning_effort" not in result
+        assert "reasoning" not in result

{unique_orchestrator-2026.22.0.dev6 → unique_orchestrator-2026.22.0.dev8}/unique_orchestrator/unique_ai.py

@@ -57,6 +57,7 @@ from unique_orchestrator._builders.inject_tool_reminders import (
 from unique_orchestrator._builders.skill_setup import preload_invoked_skills
 from unique_orchestrator.config import UniqueAIConfig
 from unique_orchestrator.settings import env_settings
+from unique_orchestrator.utils import resolve_other_options
 
 
 class UniqueAI:
@@ -187,6 +188,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]] = []
 
     async def _on_cancellation(self, _event: CancellationEvent) -> None:
         """Subscriber called by the cancellation event bus."""
@@ -211,6 +213,7 @@ class UniqueAI:
             )
 
         self._execution_times = []
+        self._loop_debug_params = []
         run_start = time.perf_counter()
 
         await preload_invoked_skills(
@@ -305,6 +308,7 @@ class UniqueAI:
                     "total_time": round(time.perf_counter() - run_start, 3),
                 },
             )
+            self._debug_info_manager.add("loop_params", self._loop_debug_params)
 
             tool_names = [
                 tool["name"] for tool in self._debug_info_manager.get()["tools"]
@@ -327,6 +331,20 @@ class UniqueAI:
         finally:
             sub.cancel()
 
+    def _record_loop_debug_params(self, other_options: dict) -> None:
+        reasoning = other_options.get("reasoning")
+        thinking_level: str = (
+            other_options.get("reasoning_effort")
+            if not isinstance(reasoning, dict)
+            else reasoning.get("effort")
+        ) or "None"
+        self._loop_debug_params.append(
+            {
+                "loop_number": self.current_iteration_index,
+                "thinking_level": thinking_level,
+            }
+        )
+
     # @track()
     async def _plan_or_execute(self) -> LanguageModelStreamResponse:
         self._logger.info("Planning or executing the loop.")
@@ -334,6 +352,11 @@ class UniqueAI:
 
         self._logger.info("Done composing message plan execution.")
 
+        other_options = resolve_other_options(
+            self._config, self._tool_manager, self._logger
+        )
+        self._record_loop_debug_params(other_options)
+
         kwargs: dict = dict(
             messages=messages,
             iteration_index=self.current_iteration_index,
@@ -345,7 +368,7 @@ class UniqueAI:
             debug_info=self._debug_info_manager.get(),
             temperature=self._config.agent.experimental.temperature,
             tool_choices=self._tool_manager.get_forced_tools(),  # type: ignore (as above)
-            other_options=self._config.agent.experimental.additional_llm_options,
+            other_options=other_options,
         )
 
         # Experimental Feature UN-17905

unique_orchestrator-2026.22.0.dev8/unique_orchestrator/utils.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import json
+from logging import Logger
+
+from unique_skill_tool.service import SkillTool
+from unique_toolkit.agentic.feature_flags import feature_flags
+from unique_toolkit.agentic.tools.tool_manager import (
+    ResponsesApiToolManager,
+    ToolManager,
+)
+from unique_toolkit.app.schemas import ChatEventAdditionalParameters
+from unique_toolkit.content import Content
+from unique_toolkit.language_model.schemas import (
+    REASONING_EFFORT_ORDER,
+    to_reasoning_effort,
+)
+
+from unique_orchestrator.config import UniqueAIConfig
+
+
+def resolve_other_options(
+    config: UniqueAIConfig,
+    tool_manager: ToolManager | ResponsesApiToolManager,
+    logger: Logger,
+) -> dict:
+    """Build ``other_options`` for the LLM call.
+
+    Merges ``additional_llm_options`` from config with the highest
+    ``thinking_level`` declared across all skills activated in this run.
+    The final effort level is the highest value among the config setting
+    (if any) and the skill hint (if any).
+
+    Determines the active API first, then reads the effort from the
+    matching format and writes the resolved value back in that same format:
+    - completions API: ``reasoning_effort: "high"``
+    - responses API: ``reasoning: {"effort": "high"}``
+    """
+
+    options: dict = dict(config.agent.experimental.additional_llm_options)
+
+    skill_tool = tool_manager.get_tool_by_name(SkillTool.name)
+    if not isinstance(skill_tool, SkillTool) or skill_tool.max_thinking_level is None:
+        return options
+
+    skill_max: str = skill_tool.max_thinking_level
+
+    use_responses_api: bool = (
+        config.agent.experimental.responses_api_config.use_responses_api
+        or config.agent.experimental.use_responses_api
+    )
+
+    if use_responses_api:
+        reasoning_raw = options.get("reasoning")
+        if isinstance(reasoning_raw, str):
+            try:
+                reasoning_dict: dict = json.loads(reasoning_raw)
+            except (json.JSONDecodeError, ValueError):
+                reasoning_dict = {}
+        elif isinstance(reasoning_raw, dict):
+            reasoning_dict = reasoning_raw
+        else:
+            reasoning_dict = {}
+        config_effort: str | None = reasoning_dict.get("effort")
+    else:
+        config_effort = options.get("reasoning_effort")
+
+    valid_config_effort: str | None = None
+    if config_effort is not None:
+        try:
+            valid_config_effort = to_reasoning_effort(config_effort)
+        except ValueError:
+            logger.warning(
+                "additional_llm_options contains an unrecognised "
+                "reasoning_effort value %r — cannot compare it with "
+                "the skill's thinking_level; using skill maximum %r instead.",
+                config_effort,
+                skill_max,
+            )
+
+    resolved_effort: str = (
+        skill_max
+        if valid_config_effort is None
+        else max([valid_config_effort, skill_max], key=REASONING_EFFORT_ORDER.index)
+    )
+
+    supported_efforts = config.space.language_model.supported_reasoning_efforts
+    if supported_efforts is not None:
+        if len(supported_efforts) == 0:
+            logger.warning(
+                "Skipping reasoning_effort %r: model %s does not support reasoning_effort.",
+                resolved_effort,
+                config.space.language_model.name,
+            )
+            return options
+        if resolved_effort not in supported_efforts:
+            logger.warning(
+                "Skipping reasoning_effort %r: model %s only supports %s.",
+                resolved_effort,
+                config.space.language_model.name,
+                supported_efforts,
+            )
+            return options
+
+    if use_responses_api:
+        existing_reasoning: dict = dict(reasoning_dict)
+        existing_reasoning["effort"] = resolved_effort
+        options["reasoning"] = existing_reasoning
+    else:
+        options["reasoning_effort"] = resolved_effort
+
+    return options
+
+
+def filter_uploaded_documents_by_selection(
+    documents: list[Content],
+    additional_parameters: ChatEventAdditionalParameters | None,
+    company_id: str,
+) -> list[Content]:
+    """Return only the documents the user has actively selected.
+
+    Returns *all* documents unchanged when:
+    - the feature flag is disabled for ``company_id``,
+    - ``additional_parameters`` is ``None``.
+    """
+    if not feature_flags.enable_selected_uploaded_files_un_18215.is_enabled(company_id):
+        return documents
+
+    if additional_parameters is None:
+        return documents
+
+    selected_ids = additional_parameters.selected_uploaded_file_ids
+    return [doc for doc in documents if doc.id in selected_ids]

unique_orchestrator-2026.22.0.dev6/unique_orchestrator/utils.py

@@ -1,26 +0,0 @@
-from __future__ import annotations
-
-from unique_toolkit.agentic.feature_flags import feature_flags
-from unique_toolkit.app.schemas import ChatEventAdditionalParameters
-from unique_toolkit.content import Content
-
-
-def filter_uploaded_documents_by_selection(
-    documents: list[Content],
-    additional_parameters: ChatEventAdditionalParameters | None,
-    company_id: str,
-) -> list[Content]:
-    """Return only the documents the user has actively selected.
-
-    Returns *all* documents unchanged when:
-    - the feature flag is disabled for ``company_id``,
-    - ``additional_parameters`` is ``None``.
-    """
-    if not feature_flags.enable_selected_uploaded_files_un_18215.is_enabled(company_id):
-        return documents
-
-    if additional_parameters is None:
-        return documents
-
-    selected_ids = additional_parameters.selected_uploaded_file_ids
-    return [doc for doc in documents if doc.id in selected_ids]