unique-toolkit 2026.30.0.dev2__tar.gz → 2026.30.0.dev4__tar.gz

{unique_toolkit-2026.30.0.dev2 → unique_toolkit-2026.30.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-toolkit
-Version: 2026.30.0.dev2
+Version: 2026.30.0.dev4
 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>

{unique_toolkit-2026.30.0.dev2 → unique_toolkit-2026.30.0.dev4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_toolkit"
-version = "2026.30.0.dev2"
+version = "2026.30.0.dev4"
 description = ""
 readme = "README.md"
 requires-python = ">=3.12"

{unique_toolkit-2026.30.0.dev2 → unique_toolkit-2026.30.0.dev4}/unique_toolkit/agentic/tools/config.py

@@ -1,4 +1,5 @@
 import logging
+from collections.abc import Sequence
 from enum import StrEnum
 from typing import Annotated, Any, Generic
 
@@ -98,6 +99,16 @@ class ToolBuildConfig(BaseModel, Generic[T]):
 
     is_enabled: bool = Field(default=True)
 
+    config_error: str | None = Field(
+        default=None,
+        exclude=True,
+        description=(
+            "Set when this tool's stored configuration failed to resolve and was "
+            "demoted to a disabled BaseToolConfig fallback. None for tools that are "
+            "valid, including tools that are deliberately disabled."
+        ),
+    )
+
     @model_validator(mode="before")
     def initialize_config_based_on_tool_name(
         cls,
@@ -115,6 +126,16 @@ class ToolBuildConfig(BaseModel, Generic[T]):
         if not isinstance(value, dict):
             return value
 
+        # config_error must only ever be set by this validator's own demotion
+        # path below. Since this is a plain field on a model with
+        # populate_by_name + a camelCase alias generator, an externally
+        # supplied config_error/configError (e.g. a stray key on a stored
+        # payload) would otherwise pass straight through untouched on every
+        # non-demotion return path and make a perfectly healthy tool look
+        # misconfigured to collect_tool_configuration_errors.
+        value.pop("config_error", None)
+        value.pop("configError", None)
+
         is_mcp_tool = _is_mcp_tool_payload(value)
         mcp_configuration = value.get("configuration", {})
 
@@ -168,8 +189,23 @@ class ToolBuildConfig(BaseModel, Generic[T]):
             )
             value["is_enabled"] = False
             value["isEnabled"] = False
+            value["config_error"] = f"Tool '{tool_name}' has invalid configuration."
             _ensure_base_tool_config(value)
             return value
 
         value["configuration"] = config
         return value
+
+
+def collect_tool_configuration_errors(
+    tools: Sequence["ToolBuildConfig[Any]"],
+) -> list[str]:
+    """Return the config_error message for every tool demoted due to an invalid config.
+
+    `initialize_config_based_on_tool_name` never raises: a tool whose stored
+    configuration is invalid is silently disabled with a BaseToolConfig fallback so
+    that one broken tool cannot take down the whole space. Callers that need to
+    surface these failures instead of ignoring them (e.g. to fail a chat request the
+    way an invalid configuration used to) can use this helper to recover the list.
+    """
+    return [tool.config_error for tool in tools if tool.config_error]

{unique_toolkit-2026.30.0.dev2 → unique_toolkit-2026.30.0.dev4}/unique_toolkit/experimental/integrations/openai/streaming/event_routing/responses/code_interpreter_event_handler.py

@@ -1,10 +1,16 @@
 """EventHandler for code interpreter call events — pure state accumulator.
 
-The event handler consumes OpenAI Responses code-interpreter events and keeps a
-per-``item_id`` ``(status, text)`` fingerprint to suppress duplicate
-progress updates; each genuine transition is published as an
-:class:`ActivityProgressUpdate` on the event-handler-owned
-:class:`TypedEventBus` (:attr:`activity_bus`).
+The event handler consumes OpenAI Responses code-interpreter lifecycle events
+(``in_progress`` / ``interpreting`` / ``completed``; ``delta`` and ``code.done``
+carry no displayed progress and are ignored) and keeps a per-``correlation_id``
+``(status, text)`` fingerprint to suppress duplicate progress updates; each
+genuine transition is published as an :class:`ActivityProgressUpdate` on the
+event-handler-owned :class:`TypedEventBus` (:attr:`activity_bus`).
+
+Each call surfaces as two correlation ids, mirroring the orchestrator's normal
+tool-call display: a one-shot "Triggered Tool Calls" summary published under
+``{item_id}-triggered`` on the ``in_progress`` event, and the "Code Execution"
+detail published under ``item_id`` on every lifecycle transition.
 
 All SDK I/O (``MessageLog`` create/update, ``Message`` modify) lives in
 subscribers reacting to the outer-bus :class:`ActivityProgress` event
@@ -56,8 +62,12 @@ class ResponsesCodeInterpreterEventHandler:
 
     Publishes :class:`ActivityProgressUpdate` on its own
     :class:`TypedEventBus` (accessible via :attr:`activity_bus`) for
-    every genuine state transition, deduplicated by a per-``item_id``
-    ``(status, text)`` fingerprint.
+    every genuine state transition, deduplicated by a per-``correlation_id``
+    ``(status, text)`` fingerprint. Lifecycle events (``in_progress`` /
+    ``interpreting`` / ``completed``) drive the ``item_id`` detail update;
+    the ``in_progress`` event additionally emits a one-shot "Triggered Tool
+    Calls" summary under ``{item_id}-triggered``. ``delta`` and ``code.done``
+    events are ignored.
     """
 
     def __init__(self) -> None:
@@ -70,35 +80,49 @@ class ResponsesCodeInterpreterEventHandler:
         return self._activity_bus
 
     async def on_code_interpreter_event(self, event: CodeInterpreterCallEvent) -> None:
-        """Map one OpenAI CI event to an optional progress update publish."""
-        status: ActivityStatus
-        if isinstance(event, ResponseCodeInterpreterCallCodeDoneEvent):
-            text_update = "Code interpreter call completed"
-            status = "COMPLETED"
-        elif isinstance(event, ResponseCodeInterpreterCallCompletedEvent):
-            text_update = "Code interpreter call completed"
-            status = "COMPLETED"
-        elif isinstance(event, ResponseCodeInterpreterCallCodeDeltaEvent):
-            text_update = "Code interpreter call in progress"
-            status = "RUNNING"
-        elif isinstance(event, ResponseCodeInterpreterCallInProgressEvent):
-            text_update = "Code interpreter call in progress"
-            status = "RUNNING"
-        else:  # ResponseCodeInterpreterCallInterpretingEvent
-            text_update = "Code interpreter call interpreting"
-            status = "RUNNING"
-
-        item_id = event.item_id
-        fingerprint = (status, text_update)
-        if self._last_by_item.get(item_id) == fingerprint:
+        """Map one OpenAI CI event to its progress update publishes."""
+        progress = self._progress_for_event(event)
+        if progress is None:
             return
-        self._last_by_item[item_id] = fingerprint
+        status, text_update = progress
 
+        if event.type == "response.code_interpreter_call.in_progress":
+            await self._publish_if_changed(
+                f"{event.item_id}-triggered",
+                "COMPLETED",
+                "**Triggered Tool Calls:**\n - Code Execution",
+            )
+        await self._publish_if_changed(event.item_id, status, text_update)
+
+    @staticmethod
+    def _build_code_execution_message(message: str) -> str:
+        return f"**Code Execution**\n {message}".strip()
+
+    def _progress_for_event(
+        self, event: CodeInterpreterCallEvent
+    ) -> tuple[ActivityStatus, str] | None:
+        """Decode a CI event into its ``(status, text)``, or ``None`` to ignore it."""
+        if event.type == "response.code_interpreter_call.completed":
+            return "COMPLETED", self._build_code_execution_message("")
+        if event.type == "response.code_interpreter_call.in_progress":
+            return "RUNNING", self._build_code_execution_message("Writing Code")
+        if event.type == "response.code_interpreter_call.interpreting":
+            return "RUNNING", self._build_code_execution_message("Executing Code")
+        return None
+
+    async def _publish_if_changed(
+        self, correlation_id: str, status: ActivityStatus, text: str
+    ) -> None:
+        """Publish a progress update unless its ``(status, text)`` is unchanged."""
+        fingerprint = (status, text)
+        if self._last_by_item.get(correlation_id) == fingerprint:
+            return
+        self._last_by_item[correlation_id] = fingerprint
         await self._activity_bus.publish_and_wait_async(
             ActivityProgressUpdate(
-                correlation_id=item_id,
+                correlation_id=correlation_id,
                 status=status,
-                text=text_update,
+                text=text,
             )
         )