unique_toolkit 2026.42.0__tar.gz → 2026.42.0.dev0__tar.gz

{unique_toolkit-2026.42.0 → unique_toolkit-2026.42.0.dev0}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "unique_toolkit"
-version = "2026.42.0"
+version = "2026.42.0.dev0"
 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",
+    "unique-sdk>=2026.42.0.dev0,<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 → unique_toolkit-2026.42.0.dev0}/unique_toolkit/agentic/history_manager/history_construction_with_contents.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import base64
 import logging
 import mimetypes
-from dataclasses import dataclass
 from datetime import datetime
 from enum import StrEnum
 from itertools import groupby
@@ -105,15 +104,12 @@ def get_chat_history_with_contents(
     else:
         chat_history.append(last_user_message)
 
-    # Failed uploads are included on purpose so the model is told about every
-    # file the user attached, including those that could not be ingested.
     chat_contents = content_service.search_contents(
         where={
             "ownerId": {
                 "equals": chat_id,
             },
         },
-        include_failed_content=True,
     )
 
     return ChatHistoryWithContent.from_chat_history_and_contents(
@@ -143,15 +139,12 @@ async def get_chat_history_with_contents_async(
     else:
         chat_history.append(last_user_message)
 
-    # Failed uploads are included on purpose so the model is told about every
-    # file the user attached, including those that could not be ingested.
     chat_contents = await content_service.search_contents_async(
         where={
             "ownerId": {
                 "equals": chat_id,
             },
         },
-        include_failed_content=True,
     )
 
     return ChatHistoryWithContent.from_chat_history_and_contents(
@@ -230,38 +223,6 @@ def _serialize_file_contents(
     return (text + "\n\n" + "\n".join(serialized_files)).strip()
 
 
-@dataclass(frozen=True)
-class _SplitContents:
-    """Uploads of one chat message, grouped by how they reach the model.
-
-    ``serializable`` holds documents *and* images in upload order so the
-    ``FileContentSerializer`` can describe every upload as text, while
-    ``images`` only holds the images that will be attached as base64.
-    """
-
-    serializable: list[Content]
-    images: list[Content]
-
-
-def _split_contents(
-    contents: list[Content],
-    selected_content_ids: set[str] | None,
-) -> _SplitContents:
-    serializable: list[Content] = []
-    images: list[Content] = []
-    for content in contents:
-        if selected_content_ids is not None and content.id not in selected_content_ids:
-            continue
-        is_image = FileUtils.is_image_content(content.key)
-        if is_image or FileUtils.is_file_content(content.key):
-            serializable.append(content)
-        # Failed or expired uploads cannot be downloaded; they are still listed
-        # via the serializer but never attached as an image.
-        if is_image and not content.has_ingestion_failed() and not content.is_expired():
-            images.append(content)
-    return _SplitContents(serializable=serializable, images=images)
-
-
 def _append_element_to_builder(
     builder: MessagesBuilder,
     c: ChatMessageWithContents,
@@ -273,11 +234,18 @@ def _append_element_to_builder(
     selected_content_ids: set[str] | None = None,
 ) -> None:
     if len(c.contents) > 0:
-        split = _split_contents(c.contents, selected_content_ids)
-        image_contents = split.images
+        file_contents = [co for co in c.contents if FileUtils.is_file_content(co.key)]
+        image_contents = [co for co in c.contents if FileUtils.is_image_content(co.key)]
+        if selected_content_ids is not None:
+            file_contents = [
+                co for co in file_contents if co.id in selected_content_ids
+            ]
+            image_contents = [
+                co for co in image_contents if co.id in selected_content_ids
+            ]
         content = _serialize_file_contents(
             text,
-            split.serializable,
+            file_contents,
             file_content_serializer,
         )
         if include_images and image_contents:
@@ -314,11 +282,18 @@ async def _append_element_to_builder_async(
     selected_content_ids: set[str] | None = None,
 ) -> None:
     if len(c.contents) > 0:
-        split = _split_contents(c.contents, selected_content_ids)
-        image_contents = split.images
+        file_contents = [co for co in c.contents if FileUtils.is_file_content(co.key)]
+        image_contents = [co for co in c.contents if FileUtils.is_image_content(co.key)]
+        if selected_content_ids is not None:
+            file_contents = [
+                co for co in file_contents if co.id in selected_content_ids
+            ]
+            image_contents = [
+                co for co in image_contents if co.id in selected_content_ids
+            ]
         content = _serialize_file_contents(
             text,
-            split.serializable,
+            file_contents,
             file_content_serializer,
         )
         if include_images and image_contents:

unique_toolkit-2026.42.0.dev0/unique_toolkit/agentic/tools/openai_builtin/code_interpreter/builder/_container.py

@@ -0,0 +1,50 @@
+import logging
+
+from openai import AsyncOpenAI
+
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.builder._memory import (
+    CodeExecutionShortTermMemorySchema,
+)
+
+logger = logging.getLogger(__name__)
+
+
+async def check_container_exists(
+    client: AsyncOpenAI,
+    memory: CodeExecutionShortTermMemorySchema,
+) -> bool:
+    try:
+        container = await client.containers.retrieve(memory.container_id)
+    # The error here is sometimes InternalServerError, and sometimes a NotFoundError. We catch everything and re-create on exception
+    except Exception:
+        logger.exception("Container %s not found", memory.container_id)
+        return False
+
+    if container.status not in ["active", "running"]:
+        logger.info(
+            "Container %s has status `%s`, recreating a new one",
+            memory.container_id,
+            container.status,
+        )
+        return False
+
+    logger.info("Container %s found in short term memory", memory.container_id)
+    return True
+
+
+async def create_container(
+    client: AsyncOpenAI,
+    chat_id: str,
+    user_id: str,
+    company_id: str,
+    expires_after_minutes: int,
+) -> str:
+    container = await client.containers.create(
+        name=f"code_execution_{company_id}_{user_id}_{chat_id}",
+        expires_after={
+            "anchor": "last_active_at",
+            "minutes": expires_after_minutes,
+        },
+    )
+    logger.info("Created new container %s", container.id)
+    return container.id

{unique_toolkit-2026.42.0 → unique_toolkit-2026.42.0.dev0}/unique_toolkit/agentic/tools/openai_builtin/code_interpreter/builder/_files.py

@@ -1,9 +1,7 @@
 import asyncio
 import logging
-import time
 from dataclasses import dataclass
 
-import httpx
 from openai import APIStatusError, AsyncOpenAI
 from tenacity import (
     AsyncRetrying,
@@ -28,11 +26,6 @@ logger = logging.getLogger(__name__)
 UPLOAD_MAX_RETRIES = 2
 UPLOAD_RETRY_BASE_DELAY = 0.5
 
-# Read timeout must stay above node-chat's own upload retry window (~95s) so we
-# never abandon a request the proxy is still retrying, which would double-upload.
-UPLOAD_CONNECT_TIMEOUT_SECONDS = 5.0
-UPLOAD_READ_TIMEOUT_SECONDS = 120.0
-
 # The `/public/openai-proxy/containers/*/files` route enforces a request-body
 # size cap (see UN-23109); Azure OpenAI/node-chat surfaces this as an
 # `APIStatusError` with this status code. Anything else is treated as a
@@ -88,24 +81,6 @@ def build_upload_retry() -> AsyncRetrying:
     )
 
 
-def build_upload_client(client: AsyncOpenAI) -> AsyncOpenAI:
-    """Return a client variant tuned for container-file uploads.
-
-    SDK-level retries are disabled (``max_retries=0``) so that
-    ``build_upload_retry`` is the single retry owner with full visibility in
-    logs, and the read timeout is capped so a hung upstream costs
-    ``UPLOAD_READ_TIMEOUT_SECONDS`` instead of the SDK's 600s default.
-    """
-    return client.with_options(
-        max_retries=0,
-        timeout=httpx.Timeout(
-            UPLOAD_CONNECT_TIMEOUT_SECONDS,
-            read=UPLOAD_READ_TIMEOUT_SECONDS,
-            write=UPLOAD_READ_TIMEOUT_SECONDS,
-        ),
-    )
-
-
 def check_file_already_uploaded(
     content_id: str,
     memory: CodeExecutionShortTermMemorySchema,
@@ -142,18 +117,16 @@ async def upload_file_to_container(
         container_id,
     )
 
-    upload_started = time.monotonic()
     openai_file = await build_upload_retry()(
-        build_upload_client(client).containers.files.create,
+        client.containers.files.create,
         container_id=container_id,
         file=(filename, file_content),
     )
     logger.info(
-        "File %s successfully uploaded as OpenAI file %s in container %s in %.1fs",
+        "File %s successfully uploaded as OpenAI file %s in container %s",
         content_id,
         openai_file.id,
         container_id,
-        time.monotonic() - upload_started,
     )
 
     return openai_file.path

{unique_toolkit-2026.42.0 → unique_toolkit-2026.42.0.dev0}/unique_toolkit/agentic/tools/openai_builtin/code_interpreter/tool/config.py

@@ -115,7 +115,7 @@ Instructions:
 Uploaded and generated files:
 - All files uploaded to the chat are available at the path `/mnt/data/<filename>`.
 - All files generated through code MUST be saved in the `/mnt/data` folder.
-- CRITICAL: When generating any plot, chart or other data visualization as a PNG, use **matplotlib** and call `plt.savefig('/mnt/data/<filename>.png', bbox_inches='tight')` and `plt.close()` to save the file. Never rely on `plt.show()` alone — a file that is not saved to `/mnt/data/` cannot be displayed.
+- CRITICAL: When generating any plot or visualization as a PNG, use **matplotlib** and call `plt.savefig('/mnt/data/<filename>.png', bbox_inches='tight')` and `plt.close()` to save the file. Never rely on `plt.show()` alone — a file that is not saved to `/mnt/data/` cannot be displayed.
 
 CRUCIAL Instructions for displaying images and files in the chat:
 - Once files are generated in the `/mnt/data` folder you MUST reference them in the chat using markdown syntax in order to display them in the chat.
@@ -134,17 +134,10 @@ IMPORTANT: ALWAYS place a blank line before AND after each file reference link s
 - You MUST always use this syntax, otherwise the files will not be displayed in the chat.
 
 Visualization library choice — CRITICAL:
-- For static charts and plots (PNG): ALWAYS use **matplotlib**. NEVER use plotly to produce a PNG — `fig.write_image()` requires the `kaleido` package which is NOT installed in this environment and will always raise an error.
-- For static page, poster, card or mockup images made of text blocks and boxes (not data charts): use **PIL** (`ImageDraw`) or **matplotlib** and follow "Page and layout images" below.
+- For static image outputs (PNG): ALWAYS use **matplotlib**. NEVER use plotly to produce a PNG — `fig.write_image()` requires the `kaleido` package which is NOT installed in this environment and will always raise an error.
 - For interactive visualizations (HTML): ALWAYS use **plotly**. Save with `fig.write_html(path, full_html=True, include_plotlyjs="cdn", default_height="600px")`. Do NOT use matplotlib for HTML artifacts.
 - If a user explicitly asks for a plotly chart as an image, produce an equivalent **matplotlib** PNG and briefly explain that static plotly export is not supported here.
 
-Page and layout images — CRITICAL (text MUST NOT overlap or overflow):
-- Applies to images built from text blocks, boxes and cards (pages, posters, slides, mockups), not data charts.
-- NEVER hardcode positions or sizes by eye. Place elements top to bottom with a running `y` cursor and advance it by each element's MEASURED height plus padding. Size boxes and cards from their measured content.
-- Measure text before placing it (PIL: `draw.textbbox((0, 0), text, font=font)`; matplotlib: `text.get_window_extent(fig.canvas.get_renderer())`) and wrap it to its container's width with `textwrap.wrap`. In a row of cards, give each card `(available_width - gaps) / n` width.
-- Before saving, assert in code that no two text bounding boxes intersect and that each lies inside its container.
-
 HTML files — CRITICAL rules:
 - NEVER write raw HTML markup directly in your text response. HTML content MUST only ever appear as a saved `.html` file in `/mnt/data/`.
 - Whenever you create HTML (dashboards, charts, tables, reports, interactive widgets), you MUST save it as a `.html` file and reference it using the sandbox link format above.
@@ -169,7 +162,7 @@ HTML files — CRITICAL rules:
 
 Handling User Queries:
 - Whenever the user query requires using the python tool, you must always think first about the steps required.
-- CRITICAL: If any step generates a plot, chart or other data visualization as a PNG, use **matplotlib** — that code block MUST include `plt.savefig('/mnt/data/<filename>.png', bbox_inches='tight')` and `plt.close()` as the final lines. Code that only calls `plt.show()` without saving will NOT display the image to the user.
+- CRITICAL: If any step generates a plot or visualization as a PNG, use **matplotlib** — that code block MUST include `plt.savefig('/mnt/data/<filename>.png', bbox_inches='tight')` and `plt.close()` as the final lines. Code that only calls `plt.show()` without saving will NOT display the image to the user.
 - CRITICAL: NEVER reference a `sandbox:/mnt/data/<filename>` link unless you have already executed code in this response that saved that exact file. Referencing a file that was not created by executed code will result in a broken link.
   - Self-check before writing any sandbox link: look back at the code blocks you executed in this response. Is there a block that explicitly saves this exact filename to `/mnt/data/`? If not, execute the code first — then reference the file.
 - CRITICAL: The sandbox has NO internet access. NEVER use `requests`, `httpx`, `urllib`, or any other HTTP library to fetch data from the web — these calls will always fail. If the user's query requires live web data (e.g. market prices, news, APIs), you MUST retrieve it using the web search tool first and then pass the result into the code interpreter.

{unique_toolkit-2026.42.0 → unique_toolkit-2026.42.0.dev0}/unique_toolkit/agentic_table/service.py

@@ -1,7 +1,6 @@
 import asyncio
 import logging
 import time
-from collections.abc import Collection
 from datetime import datetime
 from typing import Any, NamedTuple, cast
 
@@ -253,11 +252,7 @@ class AgenticTableService:
         return MagicTableCell.model_validate(cell_data)
 
     async def set_multiple_cells(
-        self,
-        cells: list[MagicTableCell],
-        batch_size: int = 4000,
-        *,
-        overwrite_library_rows: bool | None = None,
+        self, cells: list[MagicTableCell], batch_size: int = 4000
     ):
         """
         Sets the values of multiple cells in the Agentic Table.
@@ -265,14 +260,6 @@ 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]
@@ -288,7 +275,6 @@ class AgenticTableService:
                     )
                     for cell in batch
                 ],
-                overwriteLibraryRows=overwrite_library_rows,
             )
 
     async def set_activity(
@@ -889,133 +875,6 @@ 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.
 

{unique_toolkit-2026.42.0 → unique_toolkit-2026.42.0.dev0}/unique_toolkit/app/schemas.py

@@ -334,13 +334,6 @@ class ChatEventPayload(BaseEventPayload):
         default_factory=lambda: LanguageModelInfo.from_name(DEFAULT_LANGUAGE_MODEL),
         description="The model choice the user has chosen to be used.",
     )
-    thinking_level: str = Field(
-        default="",
-        description=(
-            "Thinking or reasoning level chosen for this turn. "
-            "Empty when the client did not send one."
-        ),
-    )
     tool_choices: list[str] = Field(
         default_factory=list,
         description="A list containing the tool names the user has chosen to be activated.",
@@ -394,10 +387,6 @@ class ChatEventPayload(BaseEventPayload):
     def has_model_choice_override(self) -> bool:
         return "model_choice" in self.model_fields_set
 
-    @property
-    def has_thinking_level_override(self) -> bool:
-        return "thinking_level" in self.model_fields_set and bool(self.thinking_level)
-
 
 @deprecated("""Use `ChatEventPayload` instead.
             This class will be removed in the next major version.""")

{unique_toolkit-2026.42.0 → unique_toolkit-2026.42.0.dev0}/unique_toolkit/content/schemas.py

@@ -200,35 +200,6 @@ class Content(BaseModel):
             timezone.utc
         )
 
-    def has_ingestion_failed(self) -> bool:
-        """Whether the platform reported a failed ingestion for this content.
-
-        All failure states of the platform's ``IngestionState`` enum share the
-        ``FAILED`` prefix (e.g. ``FAILED_PARSING``, ``FAILED_MALWARE_FOUND``).
-        """
-        return self.ingestion_state is not None and self.ingestion_state.startswith(
-            "FAILED"
-        )
-
-    def is_ingestion_in_progress(self) -> bool:
-        """Whether the content is still being ingested and is not yet searchable."""
-        return self.ingestion_state in _INGESTION_IN_PROGRESS_STATES
-
-
-_INGESTION_IN_PROGRESS_STATES: frozenset[str] = frozenset(
-    {
-        "QUEUED",
-        "MALWARE_SCANNING",
-        "METADATA_VALIDATION",
-        "EXTRACTING_METADATA",
-        "INGESTION_READING",
-        "INGESTION_CHUNKING",
-        "INGESTION_EMBEDDING",
-        "RE_INGESTING",
-        "RETRYING",
-    }
-)
-
 
 class ContentReference(BaseModel):
     model_config = model_config

{unique_toolkit-2026.42.0 → unique_toolkit-2026.42.0.dev0}/unique_toolkit/content/service.py

@@ -480,7 +480,6 @@ class ContentService:
         self,
         where: dict[str, Any],
         chat_id: str | None = None,
-        include_failed_content: bool = False,
     ) -> list[Content]:
         """
         Performs a search in the knowledge base by filter (and not a smilarity search)
@@ -488,8 +487,6 @@ class ContentService:
 
         Args:
             where (dict): The search criteria.
-            chat_id (str | None): Chat to scope the search to; defaults to the service's chat.
-            include_failed_content (bool): Also return content whose ingestion failed.
 
         Returns:
             list[Content]: The search results.
@@ -501,22 +498,18 @@ class ContentService:
             company_id=self._company_id,
             chat_id=chat_id,
             where=where,
-            include_failed_content=include_failed_content,
         )
 
     async def search_contents_async(
         self,
         where: dict[str, Any],
         chat_id: str | None = None,
-        include_failed_content: bool = False,
     ) -> list[Content]:
         """
         Performs an asynchronous search for content files in the knowledge base by filter.
 
         Args:
             where (dict): The search criteria.
-            chat_id (str | None): Chat to scope the search to; defaults to the service's chat.
-            include_failed_content (bool): Also return content whose ingestion failed.
 
         Returns:
             list[Content]: The search results.
@@ -528,7 +521,6 @@ class ContentService:
             company_id=self._company_id,
             chat_id=chat_id,
             where=where,
-            include_failed_content=include_failed_content,
         )
 
     def search_content_on_chat(self, chat_id: str) -> list[Content]: