unique_toolkit 2026.42.0.dev10__tar.gz → 2026.42.0.dev12__tar.gz

{unique_toolkit-2026.42.0.dev10 → unique_toolkit-2026.42.0.dev12}/PKG-INFO

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

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

@@ -3,6 +3,7 @@ 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
@@ -104,12 +105,15 @@ 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(
@@ -139,12 +143,15 @@ 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(
@@ -223,6 +230,38 @@ 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,
@@ -234,18 +273,11 @@ def _append_element_to_builder(
     selected_content_ids: set[str] | None = None,
 ) -> None:
     if len(c.contents) > 0:
-        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
-            ]
+        split = _split_contents(c.contents, selected_content_ids)
+        image_contents = split.images
         content = _serialize_file_contents(
             text,
-            file_contents,
+            split.serializable,
             file_content_serializer,
         )
         if include_images and image_contents:
@@ -282,18 +314,11 @@ async def _append_element_to_builder_async(
     selected_content_ids: set[str] | None = None,
 ) -> None:
     if len(c.contents) > 0:
-        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
-            ]
+        split = _split_contents(c.contents, selected_content_ids)
+        image_contents = split.images
         content = _serialize_file_contents(
             text,
-            file_contents,
+            split.serializable,
             file_content_serializer,
         )
         if include_images and image_contents:

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

@@ -0,0 +1,121 @@
+import asyncio
+import logging
+import time
+
+from openai import AsyncOpenAI
+
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.builder._memory import (
+    CodeExecutionShortTermMemorySchema,
+)
+
+logger = logging.getLogger(__name__)
+
+# Statuses in which a container accepts file uploads and code execution.
+LIVE_CONTAINER_STATUSES = frozenset({"active", "running"})
+
+# Best-effort wait for a live status before the first upload; on deadline we
+# proceed anyway and rely on the upload retry.
+CONTAINER_READY_TIMEOUT_SECONDS = 10.0
+CONTAINER_READY_POLL_INTERVAL_SECONDS = 0.5
+
+
+def is_container_live(status: str | None) -> bool:
+    return status in LIVE_CONTAINER_STATUSES
+
+
+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 not is_container_live(container.status):
+        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 wait_until_container_live(
+    client: AsyncOpenAI,
+    container_id: str,
+    initial_status: str | None,
+    *,
+    timeout_seconds: float = CONTAINER_READY_TIMEOUT_SECONDS,
+    poll_interval_seconds: float = CONTAINER_READY_POLL_INTERVAL_SECONDS,
+) -> None:
+    """Poll ``containers.retrieve`` until the container reports a live status.
+
+    Returns immediately (no API call) when ``initial_status`` is already live.
+    Never raises: on deadline or retrieve errors it logs and returns so the
+    caller can still attempt the upload.
+    """
+    if is_container_live(initial_status):
+        return
+
+    logger.info(
+        "Container %s created with status `%s`, waiting up to %.0fs for it to become live",
+        container_id,
+        initial_status,
+        timeout_seconds,
+    )
+    deadline = time.monotonic() + timeout_seconds
+    status = initial_status
+    while time.monotonic() < deadline:
+        await asyncio.sleep(poll_interval_seconds)
+        try:
+            container = await client.containers.retrieve(container_id)
+        except Exception:
+            logger.warning(
+                "Failed to retrieve status of container %s while waiting for it to become live",
+                container_id,
+                exc_info=True,
+            )
+            return
+        status = container.status
+        if is_container_live(status):
+            logger.info("Container %s is now `%s`", container_id, status)
+            return
+        logger.info("Container %s still has status `%s`", container_id, status)
+
+    logger.warning(
+        "Container %s did not become live within %.0fs (last status `%s`); proceeding with upload anyway",
+        container_id,
+        timeout_seconds,
+        status,
+    )
+
+
+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 with status `%s`", container.id, container.status
+    )
+    await wait_until_container_live(
+        client=client,
+        container_id=container.id,
+        initial_status=container.status,
+    )
+    return container.id

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

@@ -1,7 +1,9 @@
 import asyncio
 import logging
+import time
 from dataclasses import dataclass
 
+import httpx
 from openai import APIStatusError, AsyncOpenAI
 from tenacity import (
     AsyncRetrying,
@@ -26,6 +28,11 @@ 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
@@ -81,6 +88,24 @@ 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,
@@ -117,16 +142,18 @@ async def upload_file_to_container(
         container_id,
     )
 
+    upload_started = time.monotonic()
     openai_file = await build_upload_retry()(
-        client.containers.files.create,
+        build_upload_client(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",
+        "File %s successfully uploaded as OpenAI file %s in container %s in %.1fs",
         content_id,
         openai_file.id,
         container_id,
+        time.monotonic() - upload_started,
     )
 
     return openai_file.path

{unique_toolkit-2026.42.0.dev10 → unique_toolkit-2026.42.0.dev12}/unique_toolkit/content/schemas.py

@@ -200,6 +200,35 @@ 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.dev10 → unique_toolkit-2026.42.0.dev12}/unique_toolkit/content/service.py

@@ -480,6 +480,7 @@ 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)
@@ -487,6 +488,8 @@ 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.
@@ -498,18 +501,22 @@ 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.
@@ -521,6 +528,7 @@ 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]:

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

@@ -1,50 +0,0 @@
-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