unique-toolkit 2026.42.0.dev7__tar.gz → 2026.42.0.dev9__tar.gz

{unique_toolkit-2026.42.0.dev7 → unique_toolkit-2026.42.0.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-toolkit
-Version: 2026.42.0.dev7
+Version: 2026.42.0.dev9
 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.42.0.dev1,<2026.42.0rc0
+Requires-Dist: unique-sdk>=2026.42.0.dev3,<2026.42.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.42.0.dev7 → unique_toolkit-2026.42.0.dev9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_toolkit"
-version = "2026.42.0.dev7"
+version = "2026.42.0.dev9"
 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.42.0.dev1,<2026.42.0rc0",
+    "unique-sdk>=2026.42.0.dev3,<2026.42.0rc0",
     "jambo>=0.1.2,<0.2",
     "jinja2>=3.1.6,<4",
     "docxtpl>=0.20.1,<0.21",

{unique_toolkit-2026.42.0.dev7 → unique_toolkit-2026.42.0.dev9}/unique_toolkit/agentic/loop_runner/_responses_iteration_handler_utils.py

@@ -1,9 +1,6 @@
 import logging
-from collections.abc import Sequence
 from typing import Unpack
 
-from openai.types.responses import ToolParam, response_create_params
-
 from unique_toolkit.agentic.loop_runner._responses_stream_handler_utils import (
     responses_stream_response,
 )
@@ -12,44 +9,12 @@ from unique_toolkit.agentic.loop_runner.base import (
 )
 from unique_toolkit.language_model.schemas import (
     LanguageModelTokenUsage,
-    LanguageModelToolDescription,
     ResponsesLanguageModelStreamResponse,
 )
 
 _LOGGER = logging.getLogger(__name__)
 
 
-def _is_forced_function_choice(
-    tool_choice: response_create_params.ToolChoice,
-) -> bool:
-    return isinstance(tool_choice, dict) and tool_choice.get("type") == "function"
-
-
-def _is_hosted_tool(tool: LanguageModelToolDescription | ToolParam) -> bool:
-    """Return whether OpenAI executes the tool."""
-    if isinstance(tool, LanguageModelToolDescription):
-        return False
-    return tool.get("type") != "function"
-
-
-def _tools_for_forced_choice(
-    tools: Sequence[LanguageModelToolDescription | ToolParam] | None,
-    tool_choice: response_create_params.ToolChoice,
-) -> list[LanguageModelToolDescription | ToolParam] | None:
-    """Drop hosted tools from requests that force a function tool."""
-    if tools is None or not _is_forced_function_choice(tool_choice):
-        return list(tools) if tools is not None else None
-
-    remaining = [tool for tool in tools if not _is_hosted_tool(tool)]
-    dropped = len(tools) - len(remaining)
-    if dropped > 0:
-        _LOGGER.info(
-            "Dropped %d hosted tool(s) from the forced function request.",
-            dropped,
-        )
-    return remaining
-
-
 async def handle_responses_last_iteration(
     **kwargs: Unpack[_ResponsesLoopIterationRunnerKwargs],
 ) -> ResponsesLanguageModelStreamResponse:
@@ -82,16 +47,9 @@ async def handle_responses_forced_tools_iteration(
     responses: list[ResponsesLanguageModelStreamResponse] = []
 
     for opt in tool_choices:
-        tools = _tools_for_forced_choice(kwargs.get("tools"), opt)
-        if tools is None:
-            response = await responses_stream_response(
-                loop_runner_kwargs=kwargs, tool_choice=opt
-            )
-        else:
-            response = await responses_stream_response(
-                loop_runner_kwargs=kwargs, tool_choice=opt, tools=tools
-            )
-        responses.append(response)
+        responses.append(
+            await responses_stream_response(loop_runner_kwargs=kwargs, tool_choice=opt)
+        )
 
     # Merge responses and refs:
     tool_calls = []

{unique_toolkit-2026.42.0.dev7 → unique_toolkit-2026.42.0.dev9}/unique_toolkit/agentic_table/service.py

@@ -1,6 +1,7 @@
 import asyncio
 import logging
 import time
+from collections.abc import Collection
 from datetime import datetime
 from typing import Any, NamedTuple, cast
 
@@ -252,7 +253,11 @@ class AgenticTableService:
         return MagicTableCell.model_validate(cell_data)
 
     async def set_multiple_cells(
-        self, cells: list[MagicTableCell], batch_size: int = 4000
+        self,
+        cells: list[MagicTableCell],
+        batch_size: int = 4000,
+        *,
+        overwrite_library_rows: bool | None = None,
     ):
         """
         Sets the values of multiple cells in the Agentic Table.
@@ -260,6 +265,14 @@ class AgenticTableService:
         Args:
             cells (list[MagicTableCell]): The cells to set sorted by row and column.
             batch_size (int): Number of cells to set in a single request.
+            overwrite_library_rows (bool | None): When set, forwarded as
+                ``overwriteLibraryRows``. ``True`` lets updates to existing cells on
+                library-sheet rows go through instead of being dropped; the server
+                only honors it on library sheets, for rows where the caller can read
+                every sheet named in the row's ``sourceSheetId`` metadata. Locked rows still
+                need unlocking first (``update_row_verification_status`` with
+                ``locked=False``). ``None`` omits the field; servers that predate
+                it reject it with a 400.
         """
         for i in range(0, len(cells), batch_size):
             batch = cells[i : i + batch_size]
@@ -275,6 +288,7 @@ class AgenticTableService:
                     )
                     for cell in batch
                 ],
+                overwriteLibraryRows=overwrite_library_rows,
             )
 
     async def set_activity(
@@ -875,6 +889,133 @@ class AgenticTableService:
         if not result.get("status"):
             raise Exception(result.get("message") or "Failed to create row metadata")
 
+    async def update_row_metadata(
+        self,
+        metadata_id: str,
+        entry: RowMetadataEntryInput,
+    ) -> None:
+        """Update a single row metadata entry, addressed by its id.
+
+        Args:
+            metadata_id (str): The ``id`` of the row metadata entry to update.
+            entry (RowMetadataEntryInput): The new key, value and filter flag.
+
+        Raises:
+            Exception: If the API reports a non-success status.
+        """
+        result = await AgenticTable.update_row_metadata(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            tableId=self.table_id,
+            metadataId=metadata_id,
+            key=entry.key,
+            value=entry.value,
+            exactFilter=entry.exact_filter,
+        )
+        if not result.get("status"):
+            raise Exception(result.get("message") or "Failed to update row metadata")
+
+    async def delete_row_metadata(self, metadata_id: str) -> None:
+        """Delete a single row metadata entry, addressed by its id.
+
+        Raises:
+            Exception: If the API reports a non-success status.
+        """
+        result = await AgenticTable.delete_row_metadata(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            tableId=self.table_id,
+            metadataId=metadata_id,
+        )
+        if not result.get("status"):
+            raise Exception(result.get("message") or "Failed to delete row metadata")
+
+    async def set_row_metadata_by_key(
+        self,
+        row: int,
+        entries: list[RowMetadataEntryInput],
+        row_id: str | None = None,
+        existing: list[RowMetadataEntry] | None = None,
+        managed_keys: Collection[str] | None = None,
+    ) -> None:
+        """Merge row metadata by key, and optionally remove keys the caller owns.
+
+        For each entry: a key the row lacks is created; a key the row holds with
+        a different value or filter flag is updated in place; a key that already
+        matches is left alone. If the row holds the key more than once, one entry
+        is kept and the others are deleted, so the key ends up with exactly the
+        given value.
+
+        Keys not in ``entries`` are only removed when listed in ``managed_keys``.
+        This is not a full replace: rows also carry metadata the caller does not
+        own (e.g. the ``sourceSheetId`` stamp that library overwrites are checked
+        against), which must survive.
+
+        Args:
+            row (int): The row index (row order).
+            entries (list[RowMetadataEntryInput]): Key/value entries to set. Keys
+                must be unique.
+            row_id (str | None): The backend row id, used when creating keys.
+            existing (list[RowMetadataEntry] | None): The row's current metadata,
+                when the caller already read it (e.g. ``get_sheet`` with
+                ``include_row_metadata=True``). When ``None``, the row's metadata
+                and id are read with ``get_cell``.
+            managed_keys (Collection[str] | None): Keys the caller owns. Every
+                entry key must be in it. Any of these keys missing from
+                ``entries`` is deleted from the row, duplicates included. ``None``
+                deletes nothing beyond duplicates of keys in ``entries``.
+
+        Raises:
+            ValueError: If ``entries`` repeats a key, an entry key is not in
+                ``managed_keys``, or a key must be created and the row id cannot
+                be resolved.
+            Exception: If the API reports a non-success status.
+        """
+        keys = [entry.key for entry in entries]
+        if len(set(keys)) != len(keys):
+            raise ValueError(f"Duplicate row metadata keys in {keys}")
+        if managed_keys is not None:
+            unmanaged = sorted(set(keys) - set(managed_keys))
+            if unmanaged:
+                raise ValueError(f"Row metadata keys {unmanaged} not in managed_keys")
+        if not entries and not managed_keys:
+            return
+        if existing is None:
+            cell = await self.get_cell(row, 0, include_row_metadata=True)
+            existing = cell.row_metadata
+            row_id = row_id or cell.row_id
+
+        existing_by_key: dict[str, list[RowMetadataEntry]] = {}
+        for current in existing:
+            existing_by_key.setdefault(current.key, []).append(current)
+
+        to_create: list[RowMetadataEntryInput] = []
+        for entry in entries:
+            matches = existing_by_key.get(entry.key)
+            if not matches:
+                to_create.append(entry)
+                continue
+            keep = next(
+                (
+                    m
+                    for m in matches
+                    if m.value == entry.value and m.exact_filter == entry.exact_filter
+                ),
+                None,
+            )
+            if keep is None:
+                keep = matches[0]
+                await self.update_row_metadata(keep.id, entry)
+            for duplicate in matches:
+                if duplicate.id != keep.id:
+                    await self.delete_row_metadata(duplicate.id)
+
+        for key in set(managed_keys or ()) - set(keys):
+            for stale in existing_by_key.get(key, []):
+                await self.delete_row_metadata(stale.id)
+
+        await self.create_row_metadata(row, to_create, row_id=row_id)
+
     async def delete_sheet_metadata(self, metadata_id: str) -> None:
         """Delete a sheet metadata entry by its id.