unique-toolkit 2026.20.0.dev0__tar.gz → 2026.20.0.dev2__tar.gz

{unique_toolkit-2026.20.0.dev0 → unique_toolkit-2026.20.0.dev2}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "unique_toolkit"
-version = "2026.20.0.dev0"
+version = "2026.20.0.dev2"
 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.20.0.dev0",
+    "unique-sdk>=2026.20.0.dev1",
     "jambo>=0.1.2,<0.2",
     "jinja2>=3.1.6,<4",
     "docxtpl>=0.20.1,<0.21",

{unique_toolkit-2026.20.0.dev0 → unique_toolkit-2026.20.0.dev2}/unique_toolkit/agentic/tools/openai_builtin/code_interpreter/config.py

@@ -181,6 +181,10 @@ class OpenAICodeInterpreterConfig(BaseToolConfig):
         default=False,
         description="If set, use the `auto` container setting from OpenAI. Note that this will recreate the container on each call.",
     )
+    additional_uploaded_documents: list[str] = Field(
+        default=[],
+        description="Documents (content_ids) to always upload to the container from the Knowledge Base. Useful for example for templates.",
+    )
 
 
 @register_config()

{unique_toolkit-2026.20.0.dev0 → unique_toolkit-2026.20.0.dev2}/unique_toolkit/agentic/tools/openai_builtin/code_interpreter/service.py

@@ -1,9 +1,15 @@
 from __future__ import annotations
 
+import asyncio
 import logging
 from typing import Any, override
 
-from openai import AsyncOpenAI, BaseModel, NotFoundError
+from openai import (
+    AsyncOpenAI,
+    BaseModel,
+    NotFoundError,
+    OpenAIError,
+)
 from openai.types.responses import ResponseCodeInterpreterToolCall, ResponseIncludable
 from openai.types.responses.tool_param import CodeInterpreter
 from tenacity import (
@@ -14,6 +20,7 @@ from tenacity import (
 )
 
 from unique_toolkit import ContentService, ShortTermMemoryService
+from unique_toolkit._common.execution import SafeTaskExecutor
 from unique_toolkit.agentic.feature_flags.feature_flags import feature_flags
 from unique_toolkit.agentic.short_term_memory_manager.persistent_short_term_memory_manager import (
     PersistentShortMemoryManager,
@@ -56,7 +63,7 @@ _SHORT_TERM_MEMORY_NAME = "container_code_execution"
 
 
 class CodeExecutionShortTermMemorySchema(BaseModel):
-    container_id: str | None = None
+    container_id: str
     file_ids: dict[str, str] = {}  # Mapping of unique file id to openai file id
 
 
@@ -82,47 +89,107 @@ def _get_container_code_execution_short_term_memory_manager(
     return short_term_memory_manager
 
 
-async def _create_container_if_not_exists(
+async def _check_container_exists(
+    client: AsyncOpenAI,
+    memory: CodeExecutionShortTermMemorySchema,
+) -> bool:
+    try:
+        container = await client.containers.retrieve(memory.container_id)
+    except NotFoundError:
+        logger.info("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,
-    memory: CodeExecutionShortTermMemorySchema | None = None,
-) -> CodeExecutionShortTermMemorySchema:
-    if memory is not None:
-        logger.info("Container found in short term memory")
-    else:
-        logger.info("No Container in short term memory, creating a new container")
-        memory = CodeExecutionShortTermMemorySchema()
+) -> 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
+
 
+async def _check_file_already_uploaded(
+    client: AsyncOpenAI,
+    content_id: str,
+    memory: CodeExecutionShortTermMemorySchema,
+) -> bool:
     container_id = memory.container_id
 
-    if container_id is not None:
-        try:
-            container = await client.containers.retrieve(container_id)
-            if container.status not in ["active", "running"]:
-                logger.info(
-                    "Container has status `%s`, recreating a new one", container.status
-                )
-                container_id = None
-        except NotFoundError:
-            container_id = None
-
-    if container_id is None:
-        memory = CodeExecutionShortTermMemorySchema()
-
-        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,
-            },
+    if content_id not in memory.file_ids:
+        logger.info("File with id %s not in short term memory", content_id)
+        return False
+
+    file_id = memory.file_ids[content_id]
+    try:
+        await client.containers.files.retrieve(
+            container_id=container_id, file_id=file_id
         )
+        logger.info("File with id %s already uploaded to container", content_id)
+        return True
+    except OpenAIError:  # Azure API Errors are not stable
+        logger.exception("Error while retrieving file %s", file_id)
+        return False
 
-        memory.container_id = container.id
 
-    return memory
+async def _upload_file_to_container(
+    client: AsyncOpenAI,
+    content_id: str,
+    filename: str,
+    content_service: ContentService,
+    container_id: str,
+) -> str:
+    logger.info(
+        "Uploading file %s (%s) to container %s",
+        content_id,
+        filename,
+        container_id,
+    )
+
+    file_content = await _build_upload_retry()(
+        content_service.download_content_to_bytes_async,
+        content_id=content_id,
+    )
+    logger.info(
+        "Downloaded %d bytes for file %s; uploading to container %s",
+        len(file_content),
+        content_id,
+        container_id,
+    )
+
+    openai_file = await _build_upload_retry()(
+        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",
+        content_id,
+        openai_file.id,
+        container_id,
+    )
+
+    return openai_file.id
 
 
 async def _upload_files_to_container(
@@ -130,58 +197,61 @@ async def _upload_files_to_container(
     uploaded_files: list[Content],
     memory: CodeExecutionShortTermMemorySchema,
     content_service: ContentService,
-    chat_id: str,
-) -> CodeExecutionShortTermMemorySchema:
-    container_id = memory.container_id
+) -> tuple[CodeExecutionShortTermMemorySchema, bool]:
 
-    assert container_id is not None
+    async def _check_and_upload(content: Content) -> str | None:
+        if await _check_file_already_uploaded(
+            client=client, content_id=content.id, memory=memory
+        ):
+            return None
 
-    memory = memory.model_copy(deep=True)
+        return await _upload_file_to_container(
+            client=client,
+            content_id=content.id,
+            filename=content.key,
+            content_service=content_service,
+            container_id=memory.container_id,
+        )
 
-    for file in uploaded_files:
-        upload = True
-        if file.id in memory.file_ids:
-            try:
-                _ = await client.containers.files.retrieve(
-                    container_id=container_id, file_id=memory.file_ids[file.id]
-                )
-                logger.info("File with id %s already uploaded to container", file.id)
-                upload = False
-            except NotFoundError:
-                upload = True
-
-        if upload:
-            logger.info(
-                "Uploading file %s (%s) to container %s",
-                file.id,
-                file.key,
-                memory.container_id,
-            )
-            file_content = await _build_upload_retry()(
-                content_service.download_content_to_bytes_async,
-                content_id=file.id,
-                chat_id=chat_id,
-            )
-            logger.info(
-                "Downloaded %d bytes for file %s; uploading to container %s",
-                len(file_content),
-                file.id,
-                container_id,
-            )
-            openai_file = await _build_upload_retry()(
-                client.containers.files.create,
-                container_id=container_id,
-                file=(file.key, file_content),
-            )
-            memory.file_ids[file.id] = openai_file.id
-            logger.info(
-                "File %s successfully uploaded as OpenAI file %s in container %s",
-                file.id,
-                openai_file.id,
-                container_id,
-            )
+    # Deduplicate
+    unique_contents = {content.id: content for content in uploaded_files}.values()
+
+    executor = SafeTaskExecutor(logger=logger)
+
+    results = await asyncio.gather(
+        *(
+            executor.execute_async(_check_and_upload, content)
+            for content in unique_contents
+        ),
+    )
+
+    updated = False
+    for content, result in zip(unique_contents, results):
+        if result.success and (file_id := result.unpack()) is not None:
+            memory.file_ids[content.id] = file_id
+            updated = True
+
+    return memory, updated
+
+
+async def _resolve_kb_contents(
+    content_service: ContentService,
+    content_ids: list[str],
+) -> list[Content]:
+    contents = await content_service.search_contents_async(
+        where={"id": {"in": content_ids}},
+    )
+
+    found_ids = {c.id for c in contents}
+    missing = [content_id for content_id in content_ids if content_id not in found_ids]
+    if missing:
+        logger.warning(
+            "additional_uploaded_documents: %d content ids not found or not accessible in KB: %s",
+            len(missing),
+            missing,
+        )
 
-    return memory
+    return contents
 
 
 class OpenAICodeInterpreterTool(OpenAIBuiltInTool[CodeInterpreter]):
@@ -266,27 +336,43 @@ class OpenAICodeInterpreterTool(OpenAIBuiltInTool[CodeInterpreter]):
 
         memory = await memory_manager.load_async()
 
-        memory = await _create_container_if_not_exists(
-            client=client,
-            memory=memory,
-            chat_id=chat_id,
-            user_id=user_id,
-            company_id=company_id,
-            expires_after_minutes=config.expires_after_minutes,
-        )
+        container_updated = False
+        if memory is None or not await _check_container_exists(
+            client=client, memory=memory
+        ):
+            container_id = await _create_container(
+                client=client,
+                chat_id=chat_id,
+                user_id=user_id,
+                company_id=company_id,
+                expires_after_minutes=config.expires_after_minutes,
+            )
+            memory = CodeExecutionShortTermMemorySchema(container_id=container_id)
+            container_updated = True
 
+        files_to_upload: list[Content] = []
         if config.upload_files_in_chat_to_container:
-            memory = await _upload_files_to_container(
+            files_to_upload.extend(uploaded_files)
+
+        if config.additional_uploaded_documents:
+            files_to_upload.extend(
+                await _resolve_kb_contents(
+                    content_service=content_service,
+                    content_ids=config.additional_uploaded_documents,
+                )
+            )
+
+        files_updated = False
+        if files_to_upload:
+            memory, files_updated = await _upload_files_to_container(
                 client=client,
-                uploaded_files=uploaded_files,
+                uploaded_files=files_to_upload,
                 content_service=content_service,
-                chat_id=chat_id,
                 memory=memory,
             )
 
-        await memory_manager.save_async(memory)
-
-        assert memory.container_id is not None
+        if container_updated or files_updated:
+            await memory_manager.save_async(memory)
 
         return OpenAICodeInterpreterTool(
             config=config,