unique-toolkit 2026.30.0.dev14__tar.gz → 2026.30.0.dev16__tar.gz

{unique_toolkit-2026.30.0.dev14 → unique_toolkit-2026.30.0.dev16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-toolkit
-Version: 2026.30.0.dev14
+Version: 2026.30.0.dev16
 Summary: 
 Author: Cedric Klinkert, Martin Fadler, Sadique Sheik, Fabian Schläpfer, Pascal Hauri, Ejiroghene Oki-Peter, Rami Azouz, Ricardo Visini, Sanzio Monti
 Author-email: Cedric Klinkert <cedric.klinkert@unique.ch>, Martin Fadler <martin.fadler@unique.ch>, Sadique Sheik <sadique@unique.ch>, Fabian Schläpfer <fabian@unique.ch>, Pascal Hauri <pascal@unique.ch>, Ejiroghene Oki-Peter <oki-peter.ejiroghene@unique.ai>, Rami Azouz <rami.ext@unique.ch>, Ricardo Visini <ricardo.visini@unique.ch>, Sanzio Monti <sanzio.monti@unique.ai>
@@ -16,7 +16,7 @@ Requires-Dist: sseclient>=0.0.27,<0.0.28
 Requires-Dist: openai>=1.105.0,<3
 Requires-Dist: platformdirs>=4.0.0,<5
 Requires-Dist: pillow>=12.1.1
-Requires-Dist: unique-sdk>=2026.30.0.dev5,<2026.30.0rc0
+Requires-Dist: unique-sdk>=2026.30.0.dev8,<2026.30.0rc0
 Requires-Dist: jambo>=0.1.2,<0.2
 Requires-Dist: jinja2>=3.1.6,<4
 Requires-Dist: docxtpl>=0.20.1,<0.21

{unique_toolkit-2026.30.0.dev14 → unique_toolkit-2026.30.0.dev16}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_toolkit"
-version = "2026.30.0.dev14"
+version = "2026.30.0.dev16"
 description = ""
 readme = "README.md"
 requires-python = ">=3.12"
@@ -28,7 +28,7 @@ dependencies = [
     "openai>=1.105.0,<3",
     "platformdirs>=4.0.0,<5",
     "pillow>=12.1.1",
-    "unique-sdk>=2026.30.0.dev5,<2026.30.0rc0",
+    "unique-sdk>=2026.30.0.dev8,<2026.30.0rc0",
     "jambo>=0.1.2,<0.2",
     "jinja2>=3.1.6,<4",
     "docxtpl>=0.20.1,<0.21",

{unique_toolkit-2026.30.0.dev14 → unique_toolkit-2026.30.0.dev16}/unique_toolkit/agentic/debug_info_manager/debug_info_manager.py

@@ -12,8 +12,11 @@ from unique_toolkit.language_model.schemas import (
 
 class AnalyticsTool(TypedDict, total=False):
     name: Required[str]
+    display_name: Required[str]
     is_forced: bool
     is_exclusive: bool
+    is_sub_agent: bool
+    is_mcp: bool
     loop_iteration: int
 
 
@@ -23,9 +26,31 @@ class AnalyticsSkill(TypedDict):
     is_forced: bool
 
 
+class AnalyticsLanguageModel(TypedDict):
+    name: str
+    family: str
+    provider: str
+
+
+class AnalyticsToolName(TypedDict):
+    name: str
+    display_name: str
+
+
 class Analytics(TypedDict):
-    tools: list[AnalyticsTool]
-    skills: list[AnalyticsSkill]
+    answer_length: int
+    artifacts_created_count: int | None
+    artifacts_created_filetype: list[str] | None
+    language_model: AnalyticsLanguageModel
+    loop_iteration_count: int
+    mcp_tool_names_used: list[AnalyticsToolName]
+    references_count: int
+    skills_used: list[AnalyticsSkill]
+    subagent_names_used: list[AnalyticsToolName]
+    tool_call_count: int
+    tools_used: list[AnalyticsTool]
+    total_time_to_answer_ms: int | None
+    user_prompt_length: int
 
 
 class DebugInfoManager:
@@ -71,46 +96,97 @@ class DebugInfoManager:
     def get(self) -> dict[str, Any]:
         return self.debug_info
 
-    def add_analytics(self, skills: list[dict[str, Any]]) -> None:
+    def add_analytics(
+        self,
+        skills: list[dict[str, Any]],
+        language_model: AnalyticsLanguageModel,
+        tool_display_names: dict[str, str],
+        references: int = 0,
+        user_prompt_length: int = 0,
+        answer_length: int = 0,
+        loop_iteration_count: int = 0,
+        total_time_to_answer_ms: int | None = None,
+    ) -> None:
         """Add a stable 'analytics' snapshot for downstream ROI/usage reporting.
 
         Copies the current `tools` list (with each tool's info reduced to
-        attribution fields only) plus the given `skills` list into a new
-        `analytics` key, so later appends to `debug_info["tools"]` (e.g. from
+        attribution fields only), the given `skills` list, usage counts, prompt
+        and answer lengths, and language-model attribution into a new
+        `analytics` key. Later appends to `debug_info["tools"]` (e.g. from
         extract_tool_debug_info) can't leak into the frozen snapshot. Existing
         top-level keys (`tools`, `skills`, ...) are left untouched, so this is
-        additive for any consumer already reading the old shape.
+        additive for consumers reading the old shape.
         """
-        self.add(
-            "analytics",
-            Analytics(
-                tools=[
-                    _to_analytics_tool_entry(tool)
-                    for tool in self.debug_info.get("tools", [])
-                ],
-                skills=[
-                    AnalyticsSkill(
-                        name=skill["name"],
-                        content_id=skill["content_id"],
-                        is_forced=skill["is_forced"],
-                    )
-                    for skill in skills
-                ],
-            ),
+        analytics_tools = [
+            _to_analytics_tool_entry(tool, tool_display_names)
+            for tool in self.debug_info.get("tools", [])
+        ]
+        analytics = Analytics(
+            tools_used=analytics_tools,
+            tool_call_count=len(analytics_tools),
+            skills_used=[
+                AnalyticsSkill(
+                    name=skill["name"],
+                    content_id=skill["content_id"],
+                    is_forced=skill["is_forced"],
+                )
+                for skill in skills
+            ],
+            references_count=references,
+            user_prompt_length=user_prompt_length,
+            answer_length=answer_length,
+            language_model=language_model.copy(),
+            loop_iteration_count=loop_iteration_count,
+            subagent_names_used=_unique_tool_names(analytics_tools, "is_sub_agent"),
+            mcp_tool_names_used=_unique_tool_names(analytics_tools, "is_mcp"),
+            total_time_to_answer_ms=total_time_to_answer_ms,
+            # Reserved placeholders — schema present so consumers can rely on the
+            # keys, populated in a follow-up step (artifacts instrumentation).
+            artifacts_created_count=None,
+            artifacts_created_filetype=None,
         )
+        self.add("analytics", analytics)
+
+
+def _unique_tool_names(
+    analytics_tools: list[AnalyticsTool], flag: str
+) -> list[AnalyticsToolName]:
+    """Dedupe the tools carrying `flag` into `{name, display_name}` entries.
+
+    Keyed on the stable `name` so downstream reporting can join on a stable
+    identifier while still carrying the user-facing `display_name` for labels.
+    """
+    unique: dict[str, AnalyticsToolName] = {}
+    for tool in analytics_tools:
+        if tool.get(flag) and tool["name"] not in unique:
+            unique[tool["name"]] = AnalyticsToolName(
+                name=tool["name"],
+                display_name=tool["display_name"],
+            )
+    return list(unique.values())
 
 
-def _to_analytics_tool_entry(tool: dict[str, Any]) -> AnalyticsTool:
+def _to_analytics_tool_entry(
+    tool: dict[str, Any], tool_display_names: dict[str, str]
+) -> AnalyticsTool:
     """Return an analytics-safe copy of a tool debug-info entry.
 
-    Keeps only name plus is_forced / is_exclusive / loop_iteration.
+    Keeps only tool attribution fields.
     """
     info = tool.get("info") or {}
-    analytics_tool = AnalyticsTool(name=tool["name"])
+    name = tool["name"]
+    analytics_tool = AnalyticsTool(
+        name=name,
+        display_name=tool_display_names.get(name) or name,
+    )
     if "is_forced" in info:
         analytics_tool["is_forced"] = info["is_forced"]
     if "is_exclusive" in info:
         analytics_tool["is_exclusive"] = info["is_exclusive"]
+    if info.get("is_sub_agent"):
+        analytics_tool["is_sub_agent"] = True
+    if info.get("is_mcp") or tool.get("mcp_server"):
+        analytics_tool["is_mcp"] = True
     if "loop_iteration" in info:
         analytics_tool["loop_iteration"] = info["loop_iteration"]
     return analytics_tool

{unique_toolkit-2026.30.0.dev14 → unique_toolkit-2026.30.0.dev16}/unique_toolkit/agentic/history_manager/loop_token_reducer.py

@@ -37,6 +37,37 @@ from unique_toolkit.services.factory import UniqueServiceFactory
 MAX_INPUT_TOKENS_SAFETY_PERCENTAGE = env_settings.input_correction_reduction_factor
 SAFETY_MARGIN_FOR_AGGRESSIVE_REDUCTION = env_settings.input_aggressive_reduction_factor
 
+PLAIN_TEXT_TRUNCATION_MARKER = "\n\n[... tool response too long and was truncated]"
+# TODO: Make this configurable
+MIN_PLAIN_TEXT_CHARS_TO_KEEP = 1000
+
+
+def _truncate_plain_text(text: str, overshoot_factor: float) -> str:
+    """Truncate plain text so it helps a tool response fit the token budget.
+
+    Keeps the head and appends a marker. The amount kept scales with the
+    overshoot (mirroring the source-reduction math) and never drops below
+    ``MIN_PLAIN_TEXT_CHARS_TO_KEEP``. Truncation is on characters rather than
+    tokens because the encoder is encode-only; on prose the character ratio is a
+    good proxy for the token ratio, and the outer loop re-counts and re-enters
+    until the payload fits or no further progress is possible. Any prior marker
+    is stripped first so repeated rounds neither stack markers nor re-flag an
+    already-floored string. Returns *text* unchanged when no truncation applies.
+    """
+    base = text.removesuffix(PLAIN_TEXT_TRUNCATION_MARKER)
+
+    # Copied as for the case where the tool returns chunks (below)
+    aggressive_divisor = overshoot_factor * SAFETY_MARGIN_FOR_AGGRESSIVE_REDUCTION
+    divisor = max(
+        aggressive_divisor if aggressive_divisor >= 1.2 else overshoot_factor, 1.0
+    )
+    chars_to_keep = max(MIN_PLAIN_TEXT_CHARS_TO_KEEP, int(len(base) // divisor))
+
+    if chars_to_keep >= len(base):
+        return text
+
+    return base[:chars_to_keep] + PLAIN_TEXT_TRUNCATION_MARKER
+
 
 class SourceReductionResult(BaseModel):
     message: LanguageModelToolMessage
@@ -118,7 +149,9 @@ class LoopTokenReducer:
         token_count = self._count_message_tokens(messages)
         self._log_token_usage(token_count)
 
-        while self._exceeds_token_limit(token_count):
+        while self._exceeds_token_limit(token_count) and self._can_reduce_history(
+            loop_history
+        ):
             token_count_before_reduction = token_count
             loop_history[:] = self._handle_token_limit_exceeded(
                 loop_history, token_count
@@ -141,18 +174,30 @@ class LoopTokenReducer:
         return messages
 
     def _exceeds_token_limit(self, token_count: int) -> bool:
-        """Check if token count exceeds the maximum allowed limit and if at least one tool call has more than one source."""
-        # At least one tool call should have more than one chunk as answer
+        """Whether the payload is over the effective input-token limit.
+
+        This is purely a size check. Whether anything can actually be reduced to
+        get back under the limit is a separate concern (:meth:`_can_reduce_history`).
+        """
+        # TODO: This is not fully correct at the moment as the token_count
+        # include system_prompt and user question already
+        return token_count > self._effective_token_limit
+
+    def _can_reduce_history(self, loop_history: list[LanguageModelMessage]) -> bool:
+        """Whether there is any tool response left to reduce.
+
+        Two independent reduction levers exist:
+          * a tool call with more than one chunk can shed sources, and
+          * a chunk-less plain-text tool response can be truncated.
+        When neither applies the reduction loop cannot make progress and stops.
+        """
         has_multiple_chunks_for_a_tool_call = any(
             len(chunks) > 1
             for chunks in self._reference_manager.get_chunks_of_all_tools()
         )
-        # TODO: This is not fully correct at the moment as the token_count
-        # include system_prompt and user question already
-        # TODO: There is a problem if we exceed but only have one chunk per tool call
-        exceeds_limit = token_count > self._effective_token_limit
-
-        return has_multiple_chunks_for_a_tool_call and exceeds_limit
+        return has_multiple_chunks_for_a_tool_call or any(
+            self._can_truncate_message(message) for message in loop_history
+        )
 
     def _count_message_tokens(self, messages: LanguageModelMessages) -> int:
         """Count tokens in messages using the configured encoding model."""
@@ -211,7 +256,7 @@ class LoopTokenReducer:
             f"(overshoot factor: {overshoot_factor:.2f}x). Reducing number of sources per tool call.",
         )
 
-        return self._reduce_message_length_by_reducing_sources_in_tool_response(
+        return self._reduce_message_length_by_reducing_tool_responses_content(
             loop_history, overshoot_factor
         )
 
@@ -451,7 +496,7 @@ class LoopTokenReducer:
 
         return limited_history_messages[idx:]
 
-    def _reduce_message_length_by_reducing_sources_in_tool_response(
+    def _reduce_message_length_by_reducing_tool_responses_content(
         self,
         history: list[LanguageModelMessage],
         overshoot_factor: float,
@@ -473,21 +518,41 @@ class LoopTokenReducer:
         source_offset = max(0, self._max_db_source_number + 1)
 
         for message in history:
-            if self._should_reduce_message(message):
-                result = self._reduce_sources_in_tool_message(
+            if not self._should_reduce_message(message):
+                result = message
+            elif self._has_sources(message):
+                source_result = self._reduce_sources_in_tool_message(
                     message,
                     chunk_offset,
                     source_offset,
                     overshoot_factor,
                 )
-                content_chunks_reduced.extend(result.reduced_chunks)
-                history_reduced.append(result.message)
-                chunk_offset = result.chunk_offset
-                source_offset = result.source_offset
+                content_chunks_reduced.extend(source_result.reduced_chunks)
+                chunk_offset = source_result.chunk_offset
+                source_offset = source_result.source_offset
+                result = source_result.message
+            elif self._can_truncate_message(message):
+                assert isinstance(message.content, str)
+                truncated = _truncate_plain_text(message.content, overshoot_factor)
+                if truncated != message.content:
+                    self._logger.warning(
+                        f"Truncated plain-text tool response '{message.name}' to "
+                        f"{len(truncated)} chars "
+                        f"(overshoot factor: {overshoot_factor:.2f}x)."
+                    )
+                result = LanguageModelToolMessage(
+                    content=truncated,
+                    tool_call_id=message.tool_call_id,
+                    name=message.name,
+                )
             else:
-                history_reduced.append(message)
+                result = message
+
+            history_reduced.append(result)
+
+        if len(content_chunks_reduced) > 0:
+            self._reference_manager.replace(chunks=content_chunks_reduced)
 
-        self._reference_manager.replace(chunks=content_chunks_reduced)
         return history_reduced
 
     def _should_reduce_message(
@@ -498,6 +563,19 @@ class LoopTokenReducer:
             message, LanguageModelToolMessage
         )
 
+    def _has_sources(self, message: LanguageModelToolMessage) -> bool:
+        return len(self._reference_manager.get_chunks_of_tool(message.tool_call_id)) > 0
+
+    def _can_truncate_message(self, message: LanguageModelMessage) -> bool:
+        if not self._should_reduce_message(message) or message.name == "TableSearch":
+            return False
+        if not isinstance(message.content, str):
+            return False
+        if self._has_sources(message):
+            return False
+        base = message.content.removesuffix(PLAIN_TEXT_TRUNCATION_MARKER)
+        return len(base) > MIN_PLAIN_TEXT_CHARS_TO_KEEP
+
     def _reduce_sources_in_tool_message(
         self,
         message: LanguageModelToolMessage,

{unique_toolkit-2026.30.0.dev14 → unique_toolkit-2026.30.0.dev16}/unique_toolkit/agentic/tools/tool_manager.py

@@ -525,6 +525,10 @@ class _ToolManager(Generic[_ApiMode]):
             unpacked_tool_call_result.debug_info["is_forced"] = (
                 tool_calls[i].name in self.get_tool_choices()
             )
+            if any(tool.name == tool_calls[i].name for tool in self._sub_agents):
+                unpacked_tool_call_result.debug_info["is_sub_agent"] = True
+            if any(tool.name == tool_calls[i].name for tool in self._mcp_tools):
+                unpacked_tool_call_result.debug_info["is_mcp"] = True
             tool_call_results_unpacked.append(unpacked_tool_call_result)
 
         return tool_call_results_unpacked