unique_orchestrator 2026.18.0.dev3__tar.gz → 2026.18.0.dev4__tar.gz

{unique_orchestrator-2026.18.0.dev3 → unique_orchestrator-2026.18.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-orchestrator
-Version: 2026.18.0.dev3
+Version: 2026.18.0.dev4
 Summary: 
 Author: Andreas Hauri
 Author-email: Andreas Hauri <andreas.hauri@unique.ai>
@@ -15,7 +15,9 @@ Requires-Dist: unique-internal-search>=2026.18.0.dev2
 Requires-Dist: unique-deep-research>=2026.18.0.dev2
 Requires-Dist: unique-web-search>=2026.18.0.dev2
 Requires-Dist: unique-swot>=2026.18.0.dev2
+Requires-Dist: unique-skill-tool>=2026.18.0.dev0
 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.18.0.dev3 → unique_orchestrator-2026.18.0.dev4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_orchestrator"
-version = "2026.18.0.dev3"
+version = "2026.18.0.dev4"
 description = ""
 readme = "README.md"
 license = { text = "Proprietary" }
@@ -19,7 +19,9 @@ dependencies = [
     "unique-deep-research>=2026.18.0.dev2",
     "unique-web-search>=2026.18.0.dev2",
     "unique-swot>=2026.18.0.dev2",
+    "unique-skill-tool>=2026.18.0.dev0",
     "openai>=1.109.1,<3",
+    "python-frontmatter>=1.1.0,<2",
 ]
 
 [build-system]
@@ -43,6 +45,7 @@ exclude-newer = "2 weeks"
 "unique-stock-ticker" = false
 "unique-swot" = false
 "unique-toolkit" = false
+"unique-skill-tool" = false
 "unique-web-search" = false
 
 [tool.uv.sources]
@@ -52,6 +55,7 @@ unique-stock-ticker = { workspace = true }
 unique-follow-up-questions = { workspace = true }
 unique-internal-search = { workspace = true }
 unique-swot = { workspace = true }
+unique-skill-tool = { workspace = true }
 unique-web-search = { workspace = true }
 unique-deep-research = { workspace = true }
 
@@ -82,12 +86,12 @@ filterwarnings = [
 ]
 
 [tool.deptry]
-known_first_party = ["unique_orchestrator", "unique_toolkit", "unique_stock_ticker", "unique_follow_up_questions", "unique_internal_search", "unique_deep_research", "unique_web_search", "unique_swot"]
+known_first_party = ["unique_orchestrator", "unique_toolkit", "unique_stock_ticker", "unique_follow_up_questions", "unique_internal_search", "unique_deep_research", "unique_web_search", "unique_swot", "unique_skill_tool"]
 extend_exclude = ["unique_orchestrator/tests"]
 
 [tool.deptry.per_rule_ignores]
-DEP002 = ["unique-toolkit", "unique-stock-ticker", "unique-follow-up-questions", "unique-internal-search", "unique-deep-research", "unique-web-search", "unique-swot"]
-DEP003 = ["unique_toolkit", "unique_stock_ticker", "unique_follow_up_questions", "unique_internal_search", "unique_deep_research", "unique_web_search", "unique_swot"]
+DEP002 = ["unique-toolkit", "unique-stock-ticker", "unique-follow-up-questions", "unique-internal-search", "unique-deep-research", "unique-web-search", "unique-swot", "unique-skill-tool"]
+DEP003 = ["unique_toolkit", "unique_stock_ticker", "unique_follow_up_questions", "unique_internal_search", "unique_deep_research", "unique_web_search", "unique_swot", "unique_skill_tool"]
 
 [tool.basedpyright]
 typeCheckingMode = "standard"

{unique_orchestrator-2026.18.0.dev3 → unique_orchestrator-2026.18.0.dev4}/unique_orchestrator/_builders/__init__.py

@@ -6,10 +6,14 @@ from unique_orchestrator._builders.open_file_setup import (
     configure_file_payload,
     handle_uploaded_file_tool_choices,
 )
+from unique_orchestrator._builders.skill_setup import (
+    configure_skill_tool,
+)
 
 __all__ = [
     "build_loop_iteration_runner",
     "configure_file_payload",
+    "configure_skill_tool",
     "handle_uploaded_file_tool_choices",
     "build_responses_loop_iteration_runner",
 ]

unique_orchestrator-2026.18.0.dev4/unique_orchestrator/_builders/inject_tool_reminders.py

@@ -0,0 +1,88 @@
+"""Inject per-turn tool reminders as standalone user content parts.
+
+Tools expose two per-turn hooks:
+
+- `Tool.tool_system_reminder_for_user_prompt` — a ``<system-reminder>`` block
+  describing the tool's current state (e.g. the Skill tool's listing
+  of currently-available skills). Regenerated every loop iteration.
+
+The orchestrator collects it, filters empties, and hands the list
+to this module. We surface each string as its own
+``{"type": "text"}`` entry on the latest user message, prepended
+before the residual query text::
+
+    {
+      "role": "user",
+      "content": [
+        {"type": "text", "text": "<system-reminder>...skills...</system-reminder>"},
+        {"type": "text", "text": "commit my staged changes"}
+      ]
+    }
+
+The user message may already be a multi-part list when this runs
+(the open-file tool injects file parts before this step), so both
+``str`` and ``list`` content shapes are supported. Non-text parts
+(e.g. ``image_url``, ``file``) are preserved.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from unique_toolkit.language_model.schemas import (
+    LanguageModelMessageRole,
+    LanguageModelMessages,
+    LanguageModelUserMessage,
+)
+
+
+def _find_last_user_index(messages: LanguageModelMessages) -> int | None:
+    for i in range(len(messages.root) - 1, -1, -1):
+        if messages.root[i].role == LanguageModelMessageRole.USER:
+            return i
+    return None
+
+
+def _content_as_parts(content: object) -> list[dict[str, Any]] | None:
+    """Normalise a user-message ``content`` value to a parts list.
+
+    Returns ``None`` when the content is neither a string nor a list
+    of part dicts (i.e. nothing for us to process).
+    """
+    if isinstance(content, str):
+        return [{"type": "text", "text": content}]
+    if isinstance(content, list):
+        return [p for p in content if isinstance(p, dict)]  # pyright: ignore[reportUnnecessaryIsInstance]
+    return None
+
+
+def inject_tool_reminders_into_user_message(
+    messages: LanguageModelMessages,
+    tool_reminders: list[str],
+) -> LanguageModelMessages:
+    """Prepend each non-empty ``tool_reminder`` as a text part.
+
+    The reminders are inserted at the head of the latest user-role
+    message's ``content`` array, in the order given, ahead of the
+    residual query text and any other existing parts. Empty strings
+    are skipped. Returns ``messages`` unchanged if there are no
+    non-empty reminders or no user message in the stream.
+    """
+    non_empty_reminders = [r for r in tool_reminders if r]
+    if not non_empty_reminders or not messages.root:
+        return messages
+
+    user_idx = _find_last_user_index(messages)
+    if user_idx is None:
+        return messages
+
+    existing_parts = _content_as_parts(messages.root[user_idx].content)
+    if existing_parts is None:
+        return messages
+
+    new_parts: list[dict[str, Any]] = [
+        {"type": "text", "text": reminder} for reminder in non_empty_reminders
+    ]
+    new_parts.extend(existing_parts)
+    messages.root[user_idx] = LanguageModelUserMessage(content=new_parts)
+    return messages

unique_orchestrator-2026.18.0.dev4/unique_orchestrator/_builders/skill_setup.py

@@ -0,0 +1,399 @@
+"""Helpers for the Skill tool.
+
+Loads skill definitions from the knowledge base and registers the
+SkillTool with the tool manager.
+
+Skill files are ``.md`` documents with optional YAML frontmatter::
+
+    ---
+    name: summarize-report
+    description: >-
+      Summarize a document into key findings.
+      Use when the user asks for a summary or overview.
+    ---
+
+    # Summarize Report
+    ...instructions...
+
+The frontmatter fields are used for the skill listing shown to the
+LLM.  The body (everything after the frontmatter) is the prompt
+content injected when the skill is invoked.
+
+TODO: Add a skill-path reconciliation module that supports both KB
+layouts and infers the skill name when frontmatter ``name:`` is
+missing. Today every ``.md`` is treated as an independent skill and
+is skipped unless the frontmatter carries both ``name`` and
+``description`` — a folder-based skill (``<scope>/draft-email/
+SKILL.md`` + assets) is indistinguishable from a flat-layout skill
+(``<scope>/draft-email.md``), and authors must repeat the name in
+frontmatter even though the filename or folder already implies it.
+
+Target layouts:
+  * flat:   ``<scope>/draft-email.md``
+            -> name inferred from filename stem
+  * folder: ``<scope>/draft-email/SKILL.md`` + sibling assets
+            -> name inferred from folder name; other ``.md`` files in
+               the folder are treated as assets, not separate skills
+"""
+
+from __future__ import annotations
+
+import asyncio
+from logging import Logger
+from typing import TYPE_CHECKING, Any
+
+import frontmatter
+from pydantic import ValidationError
+from unique_skill_tool.schemas import SkillDefinition
+from unique_skill_tool.service import SkillTool
+from unique_skill_tool.utils import extract_prefix_skills
+from unique_toolkit.agentic.tools.schemas import ToolCallResponse
+from unique_toolkit.content.schemas import Content, ContentInfo
+from unique_toolkit.content.smart_rules import (
+    AndStatement,
+    Operator,
+    OrStatement,
+    Statement,
+)
+from unique_toolkit.language_model.schemas import LanguageModelFunction
+from unique_toolkit.services.knowledge_base import KnowledgeBaseService
+
+if TYPE_CHECKING:
+    from unique_toolkit.agentic.history_manager.history_manager import HistoryManager
+    from unique_toolkit.agentic.tools.tool_manager import (
+        ResponsesApiToolManager,
+        ToolManager,
+    )
+    from unique_toolkit.app.schemas import ChatEvent
+    from unique_toolkit.content.service import ContentService
+
+    from unique_orchestrator.config import UniqueAIConfig
+
+
+_SUBTREE_PAGE_SIZE = 100
+_MAX_SUBTREE_ITEMS = 10_000
+
+
+def _is_markdown(*, content: Content | ContentInfo) -> bool:
+    return content.key.lower().endswith(".md")
+
+
+def _build_subtree_metadata_filter(*, scope_ids: list[str]) -> dict[str, Any]:
+    """Build a UniqueQL filter matching any file under the given scope IDs.
+
+    For each configured scope ID we add a ``folderIdPath CONTAINS
+    uniquepathid://<scope_id>`` predicate, then OR them together. The
+    backend's ACL is then applied to the matching set, so only files
+    the current user can access are returned.
+    """
+    statements: list[Statement | AndStatement | OrStatement] = [
+        Statement(
+            operator=Operator.CONTAINS,
+            value=f"uniquepathid://{scope_id}",
+            path=["folderIdPath"],
+        )
+        for scope_id in scope_ids
+    ]
+    if len(statements) == 1:
+        return statements[0].model_dump(mode="json")
+    return OrStatement(or_list=statements).model_dump(mode="json")
+
+
+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 _build_skill(
+    *,
+    content: Content | ContentInfo,
+    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.
+    """
+    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,
+        )
+    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_skills_from_knowledge_base(
+    *,
+    content_service: ContentService,
+    knowledge_base_service: KnowledgeBaseService,
+    scope_ids: list[str],
+    logger: Logger,
+) -> dict[str, SkillDefinition]:
+    """Load all ``.md`` files from *scope_ids* (recursively) into a skill registry.
+
+    Pages through ``/content/infos`` with a UniqueQL metadata filter that
+    OR's ``folderIdPath CONTAINS uniquepathid://<scope_id>`` for every
+    configured scope. The public API caps ``take`` at 100, so results are
+    accumulated across pages up to ``_MAX_SUBTREE_ITEMS``. This matches
+    any file whose folder path contains the configured scope at any
+    depth, so:
+
+    * Each configured scope ID acts as a subtree root — all files inside
+      it and any of its descendants are considered.
+    * The backend's ACL is applied to the matching set, so only files
+      the current user can access are returned.
+    * To expose skills to users who only have access to specific
+      sub-folders, configure those sub-folder scope IDs directly.
+
+    File downloads are fanned out concurrently via ``asyncio.gather`` so
+    per-request build latency stays ~O(1) in the number of skills rather
+    than O(N) synchronous HTTP round-trips.
+    """
+    if not scope_ids:
+        logger.info("SkillTool has no scope_ids configured.")
+        return {}
+
+    metadata_filter = _build_subtree_metadata_filter(scope_ids=scope_ids)
+
+    all_infos: list[ContentInfo] = []
+    skip = 0
+    try:
+        while skip < _MAX_SUBTREE_ITEMS:
+            paginated = knowledge_base_service.get_paginated_content_infos(
+                metadata_filter=metadata_filter,
+                skip=skip,
+                take=_SUBTREE_PAGE_SIZE,
+            )
+            all_infos.extend(paginated.content_infos)
+            skip += len(paginated.content_infos)
+            if (
+                len(paginated.content_infos) < _SUBTREE_PAGE_SIZE
+                or skip >= paginated.total_count
+            ):
+                break
+    except Exception:
+        logger.warning(
+            "Failed to list contents for scope_ids=%s — "
+            "SkillTool will have an empty skill registry.",
+            scope_ids,
+            exc_info=True,
+        )
+        return {}
+
+    md_infos = [ci for ci in all_infos if _is_markdown(content=ci)]
+    if not md_infos:
+        logger.info("No .md files found for scope_ids=%s.", scope_ids)
+        return {}
+
+    download_results = await asyncio.gather(
+        *(
+            content_service.download_content_to_bytes_async(content_id=info.id)
+            for info in md_infos
+        ),
+        return_exceptions=True,
+    )
+
+    skill_registry: dict[str, SkillDefinition] = {}
+    for info, result in zip(md_infos, download_results, strict=True):
+        if isinstance(result, BaseException):
+            logger.warning(
+                "Failed to download '%s' (%s) — skipping.",
+                info.key,
+                info.id,
+                exc_info=result,
+            )
+            continue
+
+        try:
+            file_text = result.decode("utf-8")
+        except UnicodeDecodeError:
+            logger.warning(
+                "Failed to decode '%s' (%s) as UTF-8 — skipping.",
+                info.key,
+                info.id,
+                exc_info=True,
+            )
+            continue
+
+        skill = _build_skill(content=info, file_text=file_text, logger=logger)
+        if skill is None:
+            logger.debug(
+                "Skipping '%s' (%s): empty file.",
+                info.key,
+                info.id,
+            )
+            continue
+
+        if skill.name in skill_registry:
+            logger.warning(
+                "Duplicate skill name '%s' — keeping the first occurrence.",
+                skill.name,
+            )
+            continue
+
+        skill_registry[skill.name] = skill
+
+    logger.info(
+        "Loaded %d skill(s) from knowledge base (scope_ids=%s).",
+        len(skill_registry),
+        scope_ids,
+    )
+    return skill_registry
+
+
+async def configure_skill_tool(
+    *,
+    config: UniqueAIConfig,
+    event: ChatEvent,
+    logger: Logger,
+    content_service: ContentService,
+    tool_manager: ToolManager | ResponsesApiToolManager,
+) -> None:
+    """Register the SkillTool if enabled in the config.
+
+    Lists all ``.md`` files in the configured ``scope_ids`` (and every
+    sub-folder reachable from them), downloads each one concurrently,
+    and registers the SkillTool with the parsed skills.
+    """
+    skill_config = config.agent.experimental.skill_tool_config
+    if not skill_config.enabled:
+        return
+
+    if not skill_config.scope_ids:
+        logger.warning(
+            "SkillTool is enabled but no scope_ids are configured — "
+            "no skills will be loaded."
+        )
+        return
+
+    knowledge_base_service = KnowledgeBaseService(
+        company_id=event.company_id,
+        user_id=event.user_id,
+    )
+
+    skill_registry = await load_skills_from_knowledge_base(
+        content_service=content_service,
+        knowledge_base_service=knowledge_base_service,
+        scope_ids=skill_config.scope_ids,
+        logger=logger,
+    )
+
+    if not skill_registry:
+        logger.info(
+            "SkillTool has an empty skill registry — tool will not be registered."
+        )
+        return
+
+    tool_manager.add_tool(
+        SkillTool(
+            event=event,
+            skill_registry=skill_registry,
+            config=skill_config,
+        )
+    )
+
+
+async def preload_invoked_skills(
+    *,
+    event: ChatEvent,
+    tool_manager: ToolManager | ResponsesApiToolManager,
+    history_manager: HistoryManager,
+    logger: Logger,
+) -> str | None:
+    """Preload skills invoked as ``/skill-name`` prefix(es) in the user message.
+
+    Mirrors the normal mid-loop activation path so preloaded skills are
+    indistinguishable from skills the model activates itself:
+
+    1. Parses consecutive ``/skill-name`` tokens from the start of the
+       user message.
+    2. For each matched skill, synthesizes a ``LanguageModelFunction``
+       and runs it through the already-registered ``SkillTool`` — the
+       exact same code path ``UniqueAI._handle_tool_calls`` uses.
+    3. Appends the synthetic assistant tool-call message plus the
+       resulting tool-result messages to history, so the first model
+       turn sees the skills as already-activated tool calls.
+    4. Strips the matched ``/skill-name`` tokens from the user message
+       so the rendered turn shows only the user's actual query.
+
+    No-ops when the SkillTool is not registered or no tokens match.
+    """
+    skill_tool = tool_manager.get_tool_by_name(SkillTool.name)
+    if not isinstance(skill_tool, SkillTool):
+        return None
+
+    original_text = event.payload.user_message.text or ""
+
+    skills, stripped_text = extract_prefix_skills(
+        original_text, skill_tool.skill_registry
+    )
+    if not skills:
+        return None
+
+    tool_calls: list[LanguageModelFunction] = []
+    responses: list[ToolCallResponse] = []
+    for skill in skills:
+        tool_call = LanguageModelFunction(
+            name=SkillTool.name,
+            arguments={"skill_name": skill.name},
+        )
+        response = await skill_tool.run(tool_call)
+        tool_calls.append(tool_call)
+        responses.append(response)
+        history_manager.add_tool_call(tool_call)
+
+    history_manager._append_tool_calls_to_history(tool_calls)
+    history_manager.add_tool_call_results(responses)
+
+    logger.info(
+        "Preloaded %d skill(s) from slash invocation: %s",
+        len(skills),
+        [s.name for s in skills],
+    )
+
+    return stripped_text

{unique_orchestrator-2026.18.0.dev3 → unique_orchestrator-2026.18.0.dev4}/unique_orchestrator/config.py

@@ -9,6 +9,9 @@ from unique_deep_research.service import DeepResearchTool
 from unique_follow_up_questions.config import FollowUpQuestionsConfig
 from unique_internal_search.config import InternalSearchConfig
 from unique_internal_search.service import InternalSearchTool
+from unique_skill_tool.config import (
+    SkillToolConfig,
+)
 from unique_stock_ticker.config import StockTickerConfig
 from unique_swot import SwotAnalysisTool, SwotAnalysisToolConfig
 from unique_toolkit._common.validators import (
@@ -348,6 +351,8 @@ class ExperimentalConfig(BaseToolConfig):
 
     open_file_tool_config: OpenFileToolConfig = OpenFileToolConfig()
 
+    skill_tool_config: SkillToolConfig = SkillToolConfig()
+
     use_responses_api: bool = Field(
         default=False,
         description="If set, the main agent will use the Responses API from OpenAI",

{unique_orchestrator-2026.18.0.dev3 → unique_orchestrator-2026.18.0.dev4}/unique_orchestrator/tests/test_unique_ai_builder_uploaded_search.py

@@ -345,10 +345,6 @@ class TestConfigureUploadedSearchToolIngestionFilter:
         assert UploadedSearchTool.name not in tool_names
 
     def test_skip_excel_ingestion_mode_is_excluded(self):
-        # SKIP_EXCEL_INGESTION only excludes the doc when the mime type is
-        # actually Excel/CSV (see unique_toolkit.Content.is_ingested after
-        # #1454). A SKIP_EXCEL_INGESTION doc with a non-Excel or unknown
-        # mime type is still considered ingested.
         doc = self._make_doc(
             {"uniqueIngestionMode": "SKIP_EXCEL_INGESTION"},
             mime_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
@@ -381,7 +377,7 @@ class TestConfigureUploadedSearchToolIngestionFilter:
             self._make_doc({"uniqueIngestionMode": "SKIP_INGESTION"}),
             self._make_doc(
                 {"uniqueIngestionMode": "SKIP_EXCEL_INGESTION"},
-                mime_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                mime_type="text/csv",
             ),
         ]
         common = self._run(docs)

{unique_orchestrator-2026.18.0.dev3 → unique_orchestrator-2026.18.0.dev4}/unique_orchestrator/unique_ai.py

@@ -50,6 +50,10 @@ from unique_toolkit.protocols.support import (
     SupportCompleteWithReferences,
 )
 
+from unique_orchestrator._builders.inject_tool_reminders import (
+    inject_tool_reminders_into_user_message,
+)
+from unique_orchestrator._builders.skill_setup import preload_invoked_skills
 from unique_orchestrator.config import UniqueAIConfig
 from unique_orchestrator.utils import filter_uploaded_documents_by_selection
 
@@ -210,6 +214,16 @@ class UniqueAI:
         self._execution_times = []
         run_start = time.perf_counter()
 
+        if self._config.agent.experimental.skill_tool_config.enabled:
+            stripped_text = await preload_invoked_skills(
+                event=self._event,
+                tool_manager=self._tool_manager,
+                history_manager=self._history_manager,
+                logger=self._logger,
+            )
+            if stripped_text is not None:
+                self._event.payload.user_message.text = stripped_text
+
         sub = self._chat_service.cancellation.on_cancellation.subscribe(
             self._on_cancellation
         )
@@ -405,6 +419,12 @@ class UniqueAI:
                         messages
                     )
                 )
+
+        tool_reminders: list[str] = []
+        for prompts in self._tool_manager.get_tool_prompts():
+            if prompts.tool_system_reminder_for_user_prompt:
+                tool_reminders.append(prompts.tool_system_reminder_for_user_prompt)
+        messages = inject_tool_reminders_into_user_message(messages, tool_reminders)
         return messages
 
     async def _render_user_prompt(self) -> str:
@@ -635,8 +655,11 @@ class UniqueAI:
             for tool in self._tool_manager.available_tools
         }
 
-        # Tool names that should not be logged in the message steps
-        tool_names_not_to_log = ["DeepResearch"]
+        # Tool names that should not be logged in the "Triggered Tool Calls"
+        # step. The Skill tool emits its own message log entry per invocation
+        # (see ``unique_skill_tool.SkillTool._log_skill_loaded``), so it is
+        # redundant and noisy to also list it here.
+        tool_names_not_to_log = ["DeepResearch", "Skill"]
 
         used_tools: dict[str, int] = {}
         for tool_call in tool_calls:

{unique_orchestrator-2026.18.0.dev3 → unique_orchestrator-2026.18.0.dev4}/unique_orchestrator/unique_ai_builder.py

@@ -83,6 +83,7 @@ from unique_orchestrator._builders.open_file_setup import (
     configure_file_payload,
     handle_uploaded_file_tool_choices,
 )
+from unique_orchestrator._builders.skill_setup import configure_skill_tool
 from unique_orchestrator.config import UniqueAIConfig
 from unique_orchestrator.unique_ai import UniqueAI
 from unique_orchestrator.utils import filter_uploaded_documents_by_selection
@@ -140,7 +141,7 @@ async def build_unique_ai(
             common_components=common_components,
         )
     else:
-        return _build_completions(
+        return await _build_completions(
             event=event,
             logger=logger,
             config=config,
@@ -432,6 +433,14 @@ async def _build_responses(
             history_manager=history_manager,
         )
 
+    await configure_skill_tool(
+        config=config,
+        event=event,
+        logger=logger,
+        content_service=common_components.content_service,
+        tool_manager=tool_manager,
+    )
+
     loop_iteration_runner = build_responses_loop_iteration_runner(
         config=config,
         history_manager=common_components.history_manager,
@@ -478,7 +487,7 @@ async def _build_responses(
     )
 
 
-def _build_completions(
+async def _build_completions(
     event: ChatEvent,
     logger: Logger,
     config: UniqueAIConfig,
@@ -502,6 +511,14 @@ def _build_completions(
     if not has_tool_choices and has_valid_uploaded_documents:
         tool_manager.add_forced_tool(UploadedSearchTool.name)
 
+    await configure_skill_tool(
+        config=config,
+        event=event,
+        logger=logger,
+        content_service=common_components.content_service,
+        tool_manager=tool_manager,
+    )
+
     postprocessor_manager = common_components.postprocessor_manager
 
     _add_sub_agents_postprocessor(