unique-toolkit 2026.30.0.dev16__tar.gz → 2026.30.0.dev18__tar.gz

{unique_toolkit-2026.30.0.dev16 → unique_toolkit-2026.30.0.dev18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-toolkit
-Version: 2026.30.0.dev16
+Version: 2026.30.0.dev18
 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>

{unique_toolkit-2026.30.0.dev16 → unique_toolkit-2026.30.0.dev18}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_toolkit"
-version = "2026.30.0.dev16"
+version = "2026.30.0.dev18"
 description = ""
 readme = "README.md"
 requires-python = ">=3.12"

{unique_toolkit-2026.30.0.dev16 → unique_toolkit-2026.30.0.dev18}/unique_toolkit/agentic/tools/openai_builtin/base.py

@@ -2,7 +2,6 @@ from abc import ABC, abstractmethod
 from enum import StrEnum
 from typing import Generic, TypeVar
 
-from openai.types.responses import ResponseIncludable
 from openai.types.responses.tool_param import CodeInterpreter
 
 from unique_toolkit.agentic.tools.schemas import ToolPrompts
@@ -52,12 +51,3 @@ class OpenAIBuiltInTool(ABC, Generic[ToolType]):
         Default: False.
         """
         return False
-
-    def get_required_include_params(self) -> list[ResponseIncludable]:
-        """Return Responses API `include` values required by this tool.
-
-        Subclasses override this when they need additional data attached to the
-        response (e.g. code interpreter execution logs).  The default is an
-        empty list, meaning no extra includes are needed.
-        """
-        return []

{unique_toolkit-2026.30.0.dev16 → unique_toolkit-2026.30.0.dev18}/unique_toolkit/agentic/tools/openai_builtin/code_interpreter/__init__.py

@@ -1,5 +1,9 @@
-from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.config import (
-    OpenAICodeInterpreterConfig,
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.activator import (
+    CodeInterpreterActivatorConfig,
+    CodeInterpreterActivatorTool,
+)
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.builder import (
+    CodeInterpreterBuilder,
 )
 from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.postprocessors import (
     DisplayCodeInterpreterFilesPostProcessor,
@@ -7,11 +11,15 @@ from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.postprocessors
     ShowExecutedCodePostprocessor,
     ShowExecutedCodePostprocessorConfig,
 )
-from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.service import (
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.tool import (
+    OpenAICodeInterpreterConfig,
     OpenAICodeInterpreterTool,
 )
 
 __all__ = [
+    "CodeInterpreterActivatorConfig",
+    "CodeInterpreterActivatorTool",
+    "CodeInterpreterBuilder",
     "OpenAICodeInterpreterConfig",
     "OpenAICodeInterpreterTool",
     "ShowExecutedCodePostprocessor",

unique_toolkit-2026.30.0.dev18/unique_toolkit/agentic/tools/openai_builtin/code_interpreter/activator/__init__.py

@@ -0,0 +1,11 @@
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.activator.config import (
+    CodeInterpreterActivatorConfig,
+)
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.activator.service import (
+    CodeInterpreterActivatorTool,
+)
+
+__all__ = [
+    "CodeInterpreterActivatorConfig",
+    "CodeInterpreterActivatorTool",
+]

unique_toolkit-2026.30.0.dev18/unique_toolkit/agentic/tools/openai_builtin/code_interpreter/activator/config.py

@@ -0,0 +1,23 @@
+from pydantic import Field
+
+from unique_toolkit.agentic.tools.schemas import (
+    BaseToolConfig,
+)
+
+_DEFAULT_TOOL_DESCRIPTION = """
+Activate the code interpreter to run Python in a secure environment for
+calculations, data analysis, processing uploaded files (including spreadsheets),
+plotting and data visualization, and generating downloadable files. 
+
+CRITICAL: Act as though these capabilities are already available: whenever they are useful, call this tool
+silently and proceed. Never mention this tool, its activation, or its setup to the user.
+""".strip()
+
+_DEFAULT_TOOL_DESCRIPTION_FOR_SYSTEM_PROMPT = _DEFAULT_TOOL_DESCRIPTION
+
+
+class CodeInterpreterActivatorConfig(BaseToolConfig):
+    tool_description: str = Field(default=_DEFAULT_TOOL_DESCRIPTION)
+    tool_description_for_system_prompt: str = (
+        _DEFAULT_TOOL_DESCRIPTION_FOR_SYSTEM_PROMPT
+    )

unique_toolkit-2026.30.0.dev18/unique_toolkit/agentic/tools/openai_builtin/code_interpreter/activator/service.py

@@ -0,0 +1,110 @@
+import asyncio
+import logging
+from typing import override
+
+from pydantic import BaseModel, Field
+
+from unique_toolkit.agentic.evaluation.schemas import EvaluationMetricName
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.activator.config import (
+    CodeInterpreterActivatorConfig,
+)
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.builder import (
+    CodeInterpreterBuilder,
+)
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.tool import (
+    OpenAICodeInterpreterTool,
+)
+from unique_toolkit.agentic.tools.schemas import (
+    ToolCallResponse,
+)
+from unique_toolkit.agentic.tools.tool import Tool
+from unique_toolkit.language_model.schemas import (
+    LanguageModelFunction,
+    LanguageModelToolDescription,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class _CodeParams(BaseModel):
+    arg: bool = Field(True, description="Ignored Argument.")
+
+
+class CodeInterpreterActivatorTool(Tool[CodeInterpreterActivatorConfig]):
+    NAME = "ActivatePython"
+    DISPLAY_NAME = "Activate Python"
+
+    name = NAME
+
+    def __init__(
+        self,
+        config: CodeInterpreterActivatorConfig,
+        builder: CodeInterpreterBuilder,
+    ) -> None:
+        super().__init__(config=config)
+        self._builder = builder
+        self._built_tool: OpenAICodeInterpreterTool | None = None
+        self._activation_lock = asyncio.Lock()
+
+    @property
+    def is_activated(self) -> bool:
+        return self._built_tool is not None
+
+    def get_activated_tool(self) -> OpenAICodeInterpreterTool:
+        if self._built_tool is None:
+            raise RuntimeError(
+                "Code interpreter tool is not activated yet; call `run` first."
+            )
+        return self._built_tool
+
+    @override
+    def display_name(self) -> str:
+        return self.DISPLAY_NAME
+
+    @override
+    def is_enabled(self) -> bool:
+        return True
+
+    @override
+    def is_exclusive(self) -> bool:
+        return False
+
+    @override
+    def is_capability(self) -> bool:
+        return True
+
+    @override
+    def tool_description(self) -> LanguageModelToolDescription:
+        return LanguageModelToolDescription(
+            name=self.name,
+            description=self.config.tool_description,
+            parameters=_CodeParams,
+        )
+
+    @override
+    def tool_description_for_system_prompt(self) -> str:
+        return self.config.tool_description_for_system_prompt
+
+    @override
+    def evaluation_check_list(self) -> list[EvaluationMetricName]:
+        return []
+
+    @override
+    def get_evaluation_checks_based_on_tool_response(
+        self,
+        tool_response: ToolCallResponse,
+    ) -> list[EvaluationMetricName]:
+        return []
+
+    @override
+    async def run(self, tool_call: LanguageModelFunction) -> ToolCallResponse:
+        async with self._activation_lock:
+            if self._built_tool is None:
+                logger.info("Building code interpreter tool")
+                self._built_tool = await self._builder.build()
+
+        return ToolCallResponse(
+            id=tool_call.id,
+            name=self.name,
+            content="The python tool is now active. You may execute python code.",
+        )

unique_toolkit-2026.30.0.dev18/unique_toolkit/agentic/tools/openai_builtin/code_interpreter/builder/__init__.py

@@ -0,0 +1,5 @@
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.builder.builder import (
+    CodeInterpreterBuilder,
+)
+
+__all__ = ["CodeInterpreterBuilder"]

unique_toolkit-2026.30.0.dev18/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.30.0.dev18/unique_toolkit/agentic/tools/openai_builtin/code_interpreter/builder/_files.py

@@ -0,0 +1,152 @@
+import asyncio
+import logging
+
+from openai import AsyncOpenAI
+from tenacity import (
+    AsyncRetrying,
+    before_sleep_log,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+from unique_toolkit import ContentService
+from unique_toolkit._common.execution import (
+    SafeTaskExecutor,
+)
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.builder._memory import (
+    CodeExecutionShortTermMemorySchema,
+)
+from unique_toolkit.content.schemas import (
+    Content,
+)
+
+logger = logging.getLogger(__name__)
+
+UPLOAD_MAX_RETRIES = 2
+UPLOAD_RETRY_BASE_DELAY = 0.5
+
+
+def build_upload_retry() -> AsyncRetrying:
+    """Exponential-backoff retry policy for transient upload/download failures.
+
+    Matches the pattern used in the ``DisplayCodeInterpreterFilesPostProcessor``
+    so that every outbound I/O call gets the same behaviour: up to
+    ``UPLOAD_MAX_RETRIES`` extra attempts, doubling the wait each time,
+    with a WARNING log before each sleep.
+    """
+    return AsyncRetrying(
+        stop=stop_after_attempt(1 + UPLOAD_MAX_RETRIES),
+        wait=wait_exponential(multiplier=UPLOAD_RETRY_BASE_DELAY),
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+        reraise=True,
+    )
+
+
+def check_file_already_uploaded(
+    content_id: str,
+    memory: CodeExecutionShortTermMemorySchema,
+) -> bool:
+    if content_id not in memory.file_paths:
+        logger.info("File with id %s not in short term memory", content_id)
+        return False
+
+    return True
+
+
+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.path
+
+
+async def upload_files_to_container(
+    client: AsyncOpenAI,
+    uploaded_files: list[Content],
+    memory: CodeExecutionShortTermMemorySchema,
+    content_service: ContentService,
+) -> tuple[CodeExecutionShortTermMemorySchema, bool]:
+    async def _check_and_upload(content: Content) -> str | None:
+        if check_file_already_uploaded(content_id=content.id, memory=memory):
+            return None
+
+        return await upload_file_to_container(
+            client=client,
+            content_id=content.id,
+            filename=content.key,
+            content_service=content_service,
+            container_id=memory.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 (filepath := result.unpack()) is not None:
+            memory.file_paths[content.id] = filepath
+            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 contents

unique_toolkit-2026.30.0.dev18/unique_toolkit/agentic/tools/openai_builtin/code_interpreter/builder/_memory.py

@@ -0,0 +1,35 @@
+from openai import BaseModel
+
+from unique_toolkit import ShortTermMemoryService
+from unique_toolkit.agentic.short_term_memory_manager.persistent_short_term_memory_manager import (
+    PersistentShortMemoryManager,
+)
+
+SHORT_TERM_MEMORY_NAME = "container_code_execution"
+
+
+class CodeExecutionShortTermMemorySchema(BaseModel):
+    container_id: str
+    file_paths: dict[str, str] = {}
+
+
+CodeExecutionMemoryManager = PersistentShortMemoryManager[
+    CodeExecutionShortTermMemorySchema
+]
+
+
+def get_container_code_execution_short_term_memory_manager(
+    company_id: str, user_id: str, chat_id: str
+) -> CodeExecutionMemoryManager:
+    short_term_memory_service = ShortTermMemoryService(
+        company_id=company_id,
+        user_id=user_id,
+        chat_id=chat_id,
+        message_id=None,
+    )
+    short_term_memory_manager = PersistentShortMemoryManager(
+        short_term_memory_service=short_term_memory_service,
+        short_term_memory_schema=CodeExecutionShortTermMemorySchema,
+        short_term_memory_name=SHORT_TERM_MEMORY_NAME,
+    )
+    return short_term_memory_manager

unique_toolkit-2026.30.0.dev18/unique_toolkit/agentic/tools/openai_builtin/code_interpreter/builder/builder.py

@@ -0,0 +1,166 @@
+import logging
+
+from openai import AsyncOpenAI
+from pydantic import ValidationError
+
+from unique_toolkit import ContentService
+from unique_toolkit._common.execution import (
+    failsafe_async,
+)
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.builder._container import (
+    check_container_exists,
+    create_container,
+)
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.builder._files import (
+    resolve_kb_contents,
+    upload_files_to_container,
+)
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.builder._memory import (
+    CodeExecutionShortTermMemorySchema,
+    get_container_code_execution_short_term_memory_manager,
+)
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.postprocessors.artifacts import (
+    load_code_execution_metadata,
+)
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.tool import (
+    OpenAICodeInterpreterConfig,
+    OpenAICodeInterpreterTool,
+)
+from unique_toolkit.content.schemas import (
+    Content,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class CodeInterpreterBuilder:
+    """Provisions an ``OpenAICodeInterpreterTool``.
+
+    Owns the construction side of the code interpreter: warm-container reuse
+    via short-term memory, container creation, chat/KB file uploads, and the
+    final tool instantiation. The tool class itself stays a pure runtime
+    representation.
+    """
+
+    def __init__(
+        self,
+        config: OpenAICodeInterpreterConfig,
+        uploaded_files: list[Content],
+        client: AsyncOpenAI,
+        content_service: ContentService,
+        company_id: str,
+        user_id: str,
+        chat_id: str,
+        is_exclusive: bool = False,
+        force_auto_container: bool = False,
+    ) -> None:
+        self._config = config
+        self._uploaded_files = uploaded_files
+        self._client = client
+        self._content_service = content_service
+        self._company_id = company_id
+        self._user_id = user_id
+        self._chat_id = chat_id
+        self._is_exclusive = is_exclusive
+        self._force_auto_container = force_auto_container
+
+    async def build(self) -> OpenAICodeInterpreterTool:
+        is_exclusive = self._is_exclusive
+        force_auto_container = self._force_auto_container
+        config = self._config
+        uploaded_files = self._uploaded_files
+        client = self._client
+        content_service = self._content_service
+        company_id = self._company_id
+        user_id = self._user_id
+        chat_id = self._chat_id
+
+        if force_auto_container:
+            config = config.model_copy(update={"use_auto_container": True})
+
+        if config.use_auto_container:
+            logger.info("Using `auto` container setting")
+            return OpenAICodeInterpreterTool(
+                config=config,
+                container_id=None,
+                company_id=company_id,
+                is_exclusive=is_exclusive,
+            )
+
+        memory_manager = get_container_code_execution_short_term_memory_manager(
+            company_id=company_id,
+            user_id=user_id,
+            chat_id=chat_id,
+        )
+
+        # Ignore old memory schema
+        memory = await failsafe_async(
+            failure_return_value=None, exceptions=(ValidationError,), log_exc_info=False
+        )(memory_manager.load_async)()
+
+        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
+
+        code_execution_files = []
+        user_uploaded_files = []
+        for content in uploaded_files:
+            if (metadata := load_code_execution_metadata(content)) is not None:
+                code_execution_files.append(content)
+                if metadata.container_id == memory.container_id:
+                    # Already available in container
+                    memory.file_paths[content.id] = metadata.filepath
+            else:
+                user_uploaded_files.append(content)
+
+        files_to_upload: list[Content] = []
+
+        if config.upload_files_in_chat_to_container:
+            files_to_upload.extend(uploaded_files)
+
+        kb_files = []
+        if config.additional_uploaded_documents:
+            kb_files = await resolve_kb_contents(
+                content_service=content_service,
+                content_ids=config.additional_uploaded_documents,
+            )
+            files_to_upload.extend(kb_files)
+
+        files_updated = False
+        if files_to_upload:
+            memory, files_updated = await upload_files_to_container(
+                client=client,
+                uploaded_files=files_to_upload,
+                content_service=content_service,
+                memory=memory,
+            )
+
+        if container_updated or files_updated:
+            await memory_manager.save_async(memory)
+
+        def _extract_paths(contents: list[Content]) -> list[str]:
+            return [
+                memory.file_paths[content.id]
+                for content in contents
+                if content.id in memory.file_paths
+            ]
+
+        return OpenAICodeInterpreterTool(
+            config=config,
+            container_id=memory.container_id,
+            company_id=company_id,
+            is_exclusive=is_exclusive,
+            user_uploaded_files=_extract_paths(user_uploaded_files),
+            kb_uploaded_files=_extract_paths(kb_files),
+            code_execution_files=_extract_paths(code_execution_files),
+        )

unique_toolkit-2026.30.0.dev18/unique_toolkit/agentic/tools/openai_builtin/code_interpreter/config.py

@@ -0,0 +1,67 @@
+from typing import Annotated
+
+from pydantic import Field, field_validator
+
+from unique_toolkit._common.config_checker import register_config
+from unique_toolkit.agentic.tools.factory import ToolFactory
+from unique_toolkit.agentic.tools.openai_builtin.base import (
+    OpenAIBuiltInToolName,
+)
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.activator import (
+    CodeInterpreterActivatorConfig,
+)
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.postprocessors.code_display import (
+    ShowExecutedCodePostprocessorConfig,
+)
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.postprocessors.generated_files import (
+    DisplayCodeInterpreterFilesPostProcessorConfig,
+)
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.tool import (
+    OpenAICodeInterpreterConfig,
+)
+from unique_toolkit.agentic.tools.schemas import BaseToolConfig
+
+
+@register_config()
+class CodeInterpreterExtendedConfig(BaseToolConfig):
+    generated_files_config: DisplayCodeInterpreterFilesPostProcessorConfig = Field(
+        default=DisplayCodeInterpreterFilesPostProcessorConfig(),
+        title="Generated files",
+    )
+
+    executed_code_display_config: ShowExecutedCodePostprocessorConfig = Field(
+        default=ShowExecutedCodePostprocessorConfig(),
+        title="Code display",
+    )
+
+    activator_config: (
+        Annotated[
+            CodeInterpreterActivatorConfig,
+            Field(
+                title="Active",
+                description="Configuration for the tool allowing the model to request code execution.",
+            ),
+        ]
+        | Annotated[None, Field(title="Deactivated")]
+    ) = Field(
+        default=None,
+        title="Deferred Resource Provisioning",
+        description="If active, the resources for code execution are not provisioned eagerly but only when the model indicates that it needs the tool.",
+    )
+
+    @field_validator("executed_code_display_config", mode="before")
+    @classmethod
+    def _default_executed_code_display_config(cls, v):
+        if v is None:
+            return ShowExecutedCodePostprocessorConfig()
+        return v
+
+    tool_config: OpenAICodeInterpreterConfig = Field(
+        default=OpenAICodeInterpreterConfig(),
+        title="Tool",
+    )
+
+
+ToolFactory.register_tool_config(
+    OpenAIBuiltInToolName.CODE_INTERPRETER, CodeInterpreterExtendedConfig
+)