unique_orchestrator 2026.22.0.dev6__tar.gz → 2026.22.0.dev7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-orchestrator
-Version: 2026.22.0.dev6
+Version: 2026.22.0.dev7
 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.dev7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_orchestrator"
-version = "2026.22.0.dev6"
+version = "2026.22.0.dev7"
 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.dev7}/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.dev7/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.dev7}/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:
@@ -345,7 +346,9 @@ 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=resolve_other_options(
+                self._config, self._tool_manager, self._logger
+            ),
         )
 
         # Experimental Feature UN-17905

unique_orchestrator-2026.22.0.dev7/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]