unique_toolkit 1.74.2__tar.gz → 1.75.1__tar.gz

{unique_toolkit-1.74.2 → unique_toolkit-1.75.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-toolkit
-Version: 1.74.2
+Version: 1.75.1
 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-1.74.2 → unique_toolkit-1.75.1}/pyproject.toml

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

{unique_toolkit-1.74.2 → unique_toolkit-1.75.1}/unique_toolkit/agentic/loop_runner/middleware/planning/planning.py

@@ -7,6 +7,7 @@ from openai.types.responses import (
     Response,
     ResponseFormatTextJSONSchemaConfigParam,
     ResponseInputItemParam,
+    ResponseOutputMessage,
     ResponseTextConfigParam,
 )
 from pydantic import BaseModel, Field
@@ -39,6 +40,26 @@ from unique_toolkit.language_model.schemas import (
 _LOGGER = logging.getLogger(__name__)
 
 
+def _get_first_output_text(response: Response) -> str | None:
+    """
+    The Responses API can return multiple output items when doing structured output
+    (https://community.openai.com/t/multiple-outputs-from-responses-api/1291026),
+    We should tell the model not to do this in the schema, as well as extract only the first one
+    """
+    if len(response.output) > 1:
+        _LOGGER.warning(
+            "Model returned %i outputs, keeping only the first one",
+            len(response.output),
+        )
+
+    for item in response.output:
+        if isinstance(item, ResponseOutputMessage):
+            for content in item.content:
+                if content.type == "output_text" and content.text:
+                    return content.text
+    return None
+
+
 class PlanningConfig(BaseModel):
     model_config = get_configuration_dict()
 
@@ -128,7 +149,7 @@ class ResponsesPlanningMiddleware(ResponsesLoopIterationRunner):
         self,
         openai_messages: str | list[ResponseInputItemParam],
         model_name: str,
-    ) -> Response | None:
+    ) -> str | None:
         planning_schema = get_planning_schema(self._config.planning_schema_config)
 
         response = await self._openai_client.responses.create(
@@ -148,29 +169,30 @@ class ResponsesPlanningMiddleware(ResponsesLoopIterationRunner):
             ),
         )
 
-        if not response.output_text:
+        output_text = _get_first_output_text(response)
+        if not output_text:
             _LOGGER.info("Empty planning response")
             return None
 
-        return response
+        return output_text
 
     async def __call__(
         self, **kwargs: Unpack[_ResponsesLoopIterationRunnerKwargs]
     ) -> ResponsesLanguageModelStreamResponse:
         openai_messages = convert_messages_to_openai(kwargs["messages"])
 
-        response = await self._run_plan_step(
+        output_text = await self._run_plan_step(
             openai_messages=openai_messages,
             model_name=kwargs["model"].name,
         )
 
-        if response is None:
+        if output_text is None:
             _LOGGER.info(
                 "Error executing planning step, proceeding without planning step"
             )
             return await self._loop_runner(**kwargs)
 
-        assistant_message = LanguageModelAssistantMessage(content=response.output_text)
+        assistant_message = LanguageModelAssistantMessage(content=output_text)
 
         if self._history_manager is not None:
             self._history_manager.add_assistant_message(assistant_message)

{unique_toolkit-1.74.2 → unique_toolkit-1.75.1}/unique_toolkit/content/schemas.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+import re
 from datetime import datetime
 from enum import StrEnum
 from typing import Any, Optional
@@ -72,6 +75,56 @@ class ContentChunk(BaseModel):
     created_at: datetime | None = None
     updated_at: datetime | None = None
 
+    def to_reference(
+        self,
+        sequence_number: int,
+        original_index: list[int] | None = None,
+        *,
+        message_id: str = "",
+    ) -> ContentReference:
+        """Convert this chunk into a ``ContentReference`` with page-number info.
+
+        When using ``modify_assistant_message`` (the message-update path) instead of
+        streaming via ``complete_with_references``, the backend does **not**
+        automatically create references from ``searchContext``. This method replicates
+        the reference format the backend streaming path produces so page numbers
+        appear in the frontend reference chips.
+
+        Args:
+            sequence_number: The 1-based sequence number shown in the ``<sup>``
+                tag in the message text.
+            original_index: Optional list of bracket indices (``[N]``) in the
+                message text that this reference corresponds to.
+            message_id: The chat message id this reference belongs to, if any.
+
+        Returns:
+            A ``ContentReference`` ready to pass to ``modify_assistant_message``.
+        """
+        from unique_toolkit.content.utils import _generate_pages_postfix
+
+        name = self.title or self.key or f"Content {self.id}"
+        pages_postfix = _generate_pages_postfix([self])
+        if pages_postfix and not re.search(r" : [\d,]+$", name):
+            name = f"{name}{pages_postfix}"
+
+        source_id = f"{self.id}_{self.chunk_id}" if self.chunk_id else self.id
+        url = (
+            self.url
+            if self.url and not self.internally_stored_at
+            else f"unique://content/{self.id}"
+        )
+
+        return ContentReference(
+            id=self.id,
+            message_id=message_id,
+            name=name,
+            sequence_number=sequence_number,
+            source_id=source_id,
+            source="node-ingestion-chunks",
+            url=url,
+            original_index=original_index or [],
+        )
+
 
 class Content(BaseModel):
     model_config = model_config

{unique_toolkit-1.74.2 → unique_toolkit-1.75.1}/unique_toolkit/content/utils.py

@@ -121,40 +121,33 @@ def merge_content_chunks(content_chunks: list[ContentChunk]):
 
 
 def _generate_pages_postfix(chunks: list[ContentChunk]) -> str:
-    """
-    Generates a postfix string of page numbers from a list of source objects.
-    Each source object contains startPage and endPage numbers. The function
-    compiles a list of all unique page numbers greater than 0 from all chunks,
-    and then returns them as a string prefixed with " : " if there are any.
+    """Build a human-readable page suffix for one or more chunks (e.g. ``" : 1,2,3"``).
 
-    Parameters:
-    - chunks (list): A list of objects with 'startPage' and 'endPage' keys.
+    Collects all page numbers greater than zero from each chunk's ``start_page`` and
+    ``end_page``, deduplicates and sorts them, then formats them as ``" : n,n,..."`` or
+    returns the empty string when there are no valid pages.
+
+    **Usage:** Called from ``sort_content_chunks``, ``merge_content_chunks``, and
+    ``ContentChunk.to_reference`` so list presentation and reference names stay
+    consistent with the backend's page postfix convention.
+
+    **Why pages may be missing:** ``ContentChunk.start_page`` and ``end_page`` are
+    optional (``None`` from the API). This path must not call ``range`` with ``None``,
+    or callers would raise ``TypeError`` when building references from real chunks.
+
+    Args:
+        chunks: Chunks whose ``start_page`` / ``end_page`` may be ``None`` or ``-1``
+            (sentinel for unknown).
 
     Returns:
-    - string: A string of page numbers separated by commas, prefixed with " : ".
+        Postfix string such as ``" : 3,4,5"``, or ``""`` when no positive pages apply.
     """
 
-    def gen_all_numbers_in_between(start, end) -> list[int]:
-        """
-        Generates a list of all numbers between start and end, inclusive.
-        If start or end is -1, it behaves as follows:
-        - If both start and end are -1, it returns an empty list.
-        - If only end is -1, it returns a list containing only the start.
-        - If start is -1, it returns an empty list.
-
-        Parameters:
-        - start (int): The starting page number.
-        - end (int): The ending page number.
-
-        Returns:
-        - list: A list of numbers from start to end, inclusive.
-        """
-        if start == -1 and end == -1:
+    def gen_all_numbers_in_between(start: int | None, end: int | None) -> list[int]:
+        if start is None or start == -1:
             return []
-        if end == -1:
+        if end is None or end == -1:
             return [start]
-        if start == -1:
-            return []
         return list(range(start, end + 1))
 
     page_numbers_array = [