PyPI - unique_toolkit - Versions diffs - 2026.42.0.dev10__tar.gz → 2026.42.0.dev11__tar.gz - Mend

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-toolkit
-Version: 2026.42.0.dev10
+Version: 2026.42.0.dev11
 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>

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

@@ -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

@@ -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

@@ -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

unique_toolkit 2026.42.0.dev10__tar.gz → 2026.42.0.dev11__tar.gz

unique_toolkit 2026.42.0.dev10tar.gz → 2026.42.0.dev11tar.gz