unique_toolkit 1.63.1__tar.gz → 1.64.0__tar.gz

{unique_toolkit-1.63.1 → unique_toolkit-1.64.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-toolkit
-Version: 1.63.1
+Version: 1.64.0
 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-1.63.1 → unique_toolkit-1.64.0}/pyproject.toml

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

{unique_toolkit-1.63.1 → unique_toolkit-1.64.0}/unique_toolkit/agentic/tools/openai_builtin/base.py

@@ -2,6 +2,7 @@ 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
@@ -44,3 +45,12 @@ class OpenAIBuiltInTool(ABC, Generic[ToolType]):
     @abstractmethod
     def display_name(self) -> str:
         raise NotImplementedError()
+
+    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-1.63.1 → unique_toolkit-1.64.0}/unique_toolkit/agentic/tools/openai_builtin/code_interpreter/config.py

@@ -87,6 +87,17 @@ IMPORTANT: ALWAYS place a blank line before AND after each file reference link s
 - Only the following file types are allowed to be uploaded to the platform, anything else will FAIL: PDF, DOCX, XLSX, PPTX, CSV, HTML, MD, TXT, PNG, JPG, JPEG.
 - You MUST always use this syntax, otherwise the files will not be displayed in the chat.
 
+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.
+- HTML files MUST follow these best practices so they render correctly in the UI:
+  - Use a valid HTML5 document structure: `<!DOCTYPE html>`, `<html>`, `<head>` (with `<meta charset="UTF-8">` and `<meta name="viewport" content="width=device-width, initial-scale=1.0">`), and `<body>`.
+  - Make the layout self-contained: inline all CSS in a `<style>` block and all JavaScript in a `<script>` block. Do NOT rely on external CDN links that may be blocked.
+  - Use relative or fluid sizing (%, vw/vh, flexbox, CSS grid) rather than fixed pixel widths so the content fits any iframe size.
+  - Apply clean, readable typography: prefer system fonts (`-apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif`) and sufficient contrast (WCAG AA minimum).
+  - Use semantic HTML elements (`<table>` for tabular data, `<button>` for actions, `<h1>`–`<h6>` for headings, `alt` attributes on `<img>` tags). Avoid using `<div>` for everything.
+  - Do NOT use `window.parent`, `window.top`, or any attempt to access the parent frame.
+
 
 # Displaying Dataframes/Tables:
 - Whenever asked to display a dataframe/table, it is CRITICAL to represent it faithfully as a markdown table in your response.

{unique_toolkit-1.63.1 → unique_toolkit-1.64.0}/unique_toolkit/agentic/tools/openai_builtin/code_interpreter/postprocessors/code_display.py

@@ -6,6 +6,7 @@ from typing import override
 from pydantic import BaseModel, Field
 from pydantic.json_schema import SkipJsonSchema
 
+from unique_toolkit.agentic.feature_flags.feature_flags import feature_flags
 from unique_toolkit.agentic.postprocessor.postprocessor_manager import (
     ResponsesApiPostprocessor,
 )
@@ -24,22 +25,6 @@ _TEMPLATE = """
 
 """.lstrip()
 
-# Pattern matching the block emitted by _TEMPLATE (including trailing </br>).
-# Used when another postprocessor supersedes this content (e.g. fence injection).
-_EXECUTED_CODE_BLOCK_RE = re.compile(
-    r"\n*<details><summary>Code Interpreter Call</summary>.*?</details>[ \t]*\n*(?:[ \t]*</br>[ \t]*\n*)?",
-    re.DOTALL,
-)
-
-
-def strip_executed_code_blocks(text: str) -> str:
-    """Remove all executed-code <details> blocks emitted by this postprocessor.
-
-    Call this when the same content is represented elsewhere (e.g. imgWithSource
-    / fileWithSource fences) so the message does not contain duplicate code blocks.
-    """
-    return _EXECUTED_CODE_BLOCK_RE.sub("", text)
-
 
 logger = logging.getLogger(__name__)
 
@@ -59,18 +44,32 @@ class ShowExecutedCodePostprocessorConfig(BaseModel):
 
 
 class ShowExecutedCodePostprocessor(ResponsesApiPostprocessor):
-    def __init__(self, config: ShowExecutedCodePostprocessorConfig):
+    def __init__(
+        self,
+        config: ShowExecutedCodePostprocessorConfig,
+        company_id: str | None = None,
+    ):
         super().__init__(self.__class__.__name__)
         self._config = config
+        self._company_id = company_id
 
     @override
     async def run(self, loop_response: ResponsesLanguageModelStreamResponse) -> None:
+        if feature_flags.enable_code_execution_fence_un_17972.is_enabled(
+            self._company_id
+        ):
+            return
         await asyncio.sleep(self._config.sleep_time_before_display)
 
     @override
     def apply_postprocessing_to_response(
         self, loop_response: ResponsesLanguageModelStreamResponse
     ) -> bool:
+        if feature_flags.enable_code_execution_fence_un_17972.is_enabled(
+            self._company_id
+        ):
+            return False
+
         prepended_text = ""
         for output in loop_response.code_interpreter_calls:
             prepended_text += _TEMPLATE.format(code=output.code)
@@ -83,6 +82,5 @@ class ShowExecutedCodePostprocessor(ResponsesApiPostprocessor):
     async def remove_from_text(self, text) -> str:
         if not self._config.remove_from_history:
             return text
-        # Remove code interpreter blocks using regex
         pattern = r"<details><summary>Code Interpreter Call</summary>.*?</details>"
         return re.sub(pattern, "", text, flags=re.DOTALL)

{unique_toolkit-1.63.1 → unique_toolkit-1.64.0}/unique_toolkit/agentic/tools/openai_builtin/code_interpreter/postprocessors/generated_files.py

@@ -6,6 +6,7 @@ from mimetypes import guess_type
 from typing import NamedTuple, override
 
 from openai import AsyncOpenAI
+from openai.types.responses import ResponseCodeInterpreterToolCall
 from openai.types.responses.response_output_text import AnnotationContainerFileCitation
 from pydantic import BaseModel, Field, RootModel
 from pydantic.json_schema import SkipJsonSchema
@@ -20,9 +21,6 @@ from unique_toolkit.agentic.short_term_memory_manager.persistent_short_term_memo
     PersistentShortMemoryManager,
 )
 from unique_toolkit.agentic.tools.config import get_configuration_dict
-from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.postprocessors.code_display import (
-    strip_executed_code_blocks,
-)
 from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.schemas import (
     CodeInterpreterBlock,
     CodeInterpreterFile,
@@ -110,6 +108,7 @@ class DisplayCodeInterpreterFilesPostProcessor(
         if self._chat_service is None:
             raise ValueError("ChatService is required if uploadToChat is True")
 
+        self._orphan_code_blocks: list[CodeInterpreterBlock] = []
         self._short_term_memory_manager = None
         if chat_id is not None and user_id is not None and company_id is not None:
             self._short_term_memory_manager = _init_short_term_memory_manager(
@@ -150,10 +149,23 @@ class DisplayCodeInterpreterFilesPostProcessor(
             ]
         )
 
+        if feature_flags.enable_code_execution_fence_un_17972.is_enabled(
+            self._company_id
+        ):
+            self._orphan_code_blocks = await self._upload_orphan_code_as_txt(
+                loop_response
+            )
+        else:
+            self._orphan_code_blocks = []
+
     @override
     def apply_postprocessing_to_response(
         self, loop_response: ResponsesLanguageModelStreamResponse
     ) -> bool:
+        if loop_response.message.references is None:
+            loop_response.message.references = []
+        if loop_response.message.text is None:
+            loop_response.message.text = ""
         ref_number = _get_next_ref_number(loop_response.message.references)
         changed = False
 
@@ -169,6 +181,9 @@ class DisplayCodeInterpreterFilesPostProcessor(
 
             is_image = (guess_type(filename)[0] or "").startswith("image/")
             is_html = (guess_type(filename)[0] or "") == "text/html"
+            fence_ff_on = feature_flags.enable_code_execution_fence_un_17972.is_enabled(
+                self._company_id
+            )
 
             # Images
             if is_image:
@@ -181,9 +196,13 @@ class DisplayCodeInterpreterFilesPostProcessor(
                 )
                 changed |= replaced
 
-            # HTML (behind feature flag)
-            elif is_html and feature_flags.enable_html_rendering_un_15131.is_enabled(
-                self._company_id
+            # HTML rendered as legacy HtmlRendering block — only when fence FF is off
+            elif (
+                is_html
+                and not fence_ff_on
+                and feature_flags.enable_html_rendering_un_15131.is_enabled(
+                    self._company_id
+                )
             ):
                 loop_response.message.text, replaced = _replace_container_html_citation(
                     text=loop_response.message.text,
@@ -192,13 +211,8 @@ class DisplayCodeInterpreterFilesPostProcessor(
                 )
                 changed |= replaced
 
-            # Files (including HTML when feature flag is disabled)
+            # Files and HTML (fence FF on: HTML → htmlWithSource; others → fileWithSource)
             else:
-                fence_ff_on = (
-                    feature_flags.enable_code_execution_fence_un_17972.is_enabled(
-                        self._company_id
-                    )
-                )
                 loop_response.message.text, replaced = _replace_container_file_citation(
                     text=loop_response.message.text,
                     filename=filename,
@@ -210,11 +224,19 @@ class DisplayCodeInterpreterFilesPostProcessor(
 
             is_html_rendered = (
                 is_html
+                and not fence_ff_on
                 and feature_flags.enable_html_rendering_un_15131.is_enabled(
                     self._company_id
                 )
             )
-            if replaced and not is_image and not is_html_rendered:
+            # htmlWithSource fences carry contentId directly — no separate reference needed
+            is_html_fenced = is_html and fence_ff_on
+            if (
+                replaced
+                and not is_image
+                and not is_html_rendered
+                and not is_html_fenced
+            ):
                 loop_response.message.references.append(
                     ContentReference(
                         sequence_number=ref_number,
@@ -238,6 +260,27 @@ class DisplayCodeInterpreterFilesPostProcessor(
             )
             changed |= loop_response.message.text != text_before
 
+            if self._orphan_code_blocks:
+                fence_id = _get_next_fence_id(loop_response.message.text)
+                orphan_fences = _build_orphan_fences(self._orphan_code_blocks, fence_id)
+                loop_response.message.text = (
+                    loop_response.message.text.rstrip() + "\n\n" + orphan_fences
+                )
+                ref_number = _get_next_ref_number(loop_response.message.references)
+                for block in self._orphan_code_blocks:
+                    for file in block.files:
+                        loop_response.message.references.append(
+                            ContentReference(
+                                sequence_number=ref_number,
+                                source_id=file.content_id,
+                                source="node-ingestion-chunks",
+                                url=f"unique://content/{file.content_id}",
+                                name=file.filename,
+                            )
+                        )
+                        ref_number += 1
+                changed = True
+
         _warn_missing_content_ids(loop_response.message.text, self._content_map)
         loop_response.message.text, dangling_replaced = _replace_dangling_sandbox_links(
             loop_response.message.text, self._config.file_download_failed_message
@@ -307,6 +350,110 @@ class DisplayCodeInterpreterFilesPostProcessor(
             _DisplayedFilesShortTermMemorySchema(root=content_infos)
         )
 
+    async def _upload_orphan_code_as_txt(
+        self, loop_response: ResponsesLanguageModelStreamResponse
+    ) -> list[CodeInterpreterBlock]:
+        """Upload stdout (or code) from calls that produced no container files as .txt artifacts.
+
+        When code interpreter runs but generates no files or images, the response
+        text has no sandbox links for fence injection to hook onto.  This method
+        converts those "orphan" calls into downloadable .txt files so the fence
+        postprocessor can attach a fileWithSource component and the new Code
+        Execution UI is shown instead of the legacy <details> block.
+
+        Called only when the fence feature flag is enabled.  Skipped entirely if
+        any container files were produced (normal fencing handles those).
+        """
+        if loop_response.container_files:
+            return []
+
+        calls = loop_response.code_interpreter_calls
+        if not calls:
+            return []
+
+        assert self._chat_service is not None  # Checked in __init__
+
+        use_numeric_suffix = len(calls) > 1
+        orphan_blocks: list[CodeInterpreterBlock] = []
+
+        for i, call in enumerate(calls):
+            if not call.code:
+                continue
+
+            # Code interpreter logs are only present on each code_interpreter_call when
+            # the create/retrieve request sets include=["code_interpreter_call.outputs"]
+            # (see OpenAI Responses API `include` and manual examples in
+            # docs/manual_examples_for_docs/code_execution_openai_client.py).  If
+            # `outputs` is omitted, call.outputs is null and we fall back to the
+            # source code as the downloadable txt.
+            txt_content = _collect_stdout(call) or call.code
+            filename = f"code_{i + 1}.txt" if use_numeric_suffix else "code.txt"
+
+            try:
+                content = await self._chat_service.upload_to_chat_from_bytes_async(
+                    content=txt_content.encode("utf-8"),
+                    content_name=filename,
+                    mime_type="text/plain",
+                    skip_ingestion=True,
+                    hide_in_chat=True,
+                )
+            except Exception:
+                logger.exception(
+                    "Failed to upload orphan code block as txt for call %d ('%s'); "
+                    "falling back to legacy code block display.",
+                    i,
+                    filename,
+                )
+                continue
+
+            orphan_file = CodeInterpreterFile(
+                filename=filename,
+                content_id=content.id,
+                type="document",
+            )
+            orphan_blocks.append(
+                CodeInterpreterBlock(code=call.code, files=[orphan_file])
+            )
+            logger.info(
+                "Uploaded orphan code block as '%s' (content_id=%s)",
+                filename,
+                content.id,
+            )
+
+        return orphan_blocks
+
+
+def _collect_stdout(call: ResponseCodeInterpreterToolCall) -> str:
+    """Collect all stdout logs from a code interpreter call's outputs."""
+    if not call.outputs:
+        return ""
+    return "\n".join(output.logs for output in call.outputs if output.type == "logs")
+
+
+def _get_next_fence_id(text: str) -> int:
+    """Return the next available fence id by scanning existing fences in the text."""
+    existing = re.findall(r"````(?:imgWithSource|fileWithSource)\(id='(\d+)'", text)
+    if not existing:
+        return 1
+    return max(int(fid) for fid in existing) + 1
+
+
+def _build_orphan_fences(
+    blocks: list[CodeInterpreterBlock], start_fence_id: int
+) -> str:
+    """Build concatenated fence text for orphan code blocks.
+
+    Orphan blocks have no inline ref in the message text, so their fences are
+    appended directly rather than injected via pattern replacement.
+    """
+    fence_id = start_fence_id
+    parts: list[str] = []
+    for block in blocks:
+        for file in block.files:
+            parts.append(_build_file_fence(file, block.code, fence_id))
+            fence_id += 1
+    return "\n".join(parts)
+
 
 def _get_file_type(filename: str) -> CodeInterpreterFileType:
     mime = guess_type(filename)[0] or ""
@@ -382,6 +529,8 @@ def _build_file_fence(file: CodeInterpreterFile, code: str, fence_id: int) -> st
     outer = "````"
     if file.type == "image":
         tag = f"imgWithSource(id='{fence_id}', contentId='{file.content_id}', title=\"{title}\", code=\"{escaped}\")"
+    elif file.type == "html":
+        tag = f"htmlWithSource(id='{fence_id}', contentId='{file.content_id}', title=\"{title}\", code=\"{escaped}\")"
     else:
         ftype = _file_frontend_type(file.filename)
         tag = f'fileWithSource(id=\'{fence_id}\', contentId=\'{file.content_id}\', title="{title}", type="{ftype}", code="{escaped}")'
@@ -394,23 +543,18 @@ def _inline_ref_pattern(file: CodeInterpreterFile) -> re.Pattern[str]:
     After apply_postprocessing_to_response replaces sandbox paths, each file type
     has a distinct inline form in the text:
       image    → ![image](unique://content/{content_id})
+      html     → [{filename}](unique://content/{content_id})
       document → [{filename}](unique://content/{content_id})
-      html     → ```HtmlRendering\\n100%\\n500px\\n\\nunique://content/{content_id}\\n\\n```
     """
     cid = re.escape(file.content_id)
     fname = re.escape(file.filename)
     if file.type == "image":
         return re.compile(rf"!\[image\]\(unique://content/{cid}\)")
-    if file.type == "html":
-        return re.compile(
-            rf"```HtmlRendering\n100%\n500px\n\nunique://content/{cid}\n\n```",
-            re.DOTALL,
-        )
     return re.compile(rf"\[{fname}\]\(unique://content/{cid}\)")
 
 
 _FENCE_BLOCK_START = re.compile(
-    r"^[^\n`]+?(````(?:imgWithSource|fileWithSource)\()",
+    r"^[^\n`]+?(````(?:imgWithSource|fileWithSource|htmlWithSource)\()",
     re.MULTILINE,
 )
 
@@ -420,9 +564,9 @@ _FENCE_BLOCK_START = re.compile(
 #   - cross-line: 1 or 2 newlines optionally surrounded by horizontal whitespace
 #     (list-item linebreak, or blank-line paragraph gap)
 _CONSECUTIVE_FENCES_RE = re.compile(
-    r"(````(?:imgWithSource|fileWithSource)\([^\n]*\)````)"
+    r"(````(?:imgWithSource|fileWithSource|htmlWithSource)\([^\n]*\)````)"
     r"(?:[^\n`]*|[ \t]*\n{1,2}[ \t]*)"
-    r"(?=````(?:imgWithSource|fileWithSource)\()"
+    r"(?=````(?:imgWithSource|fileWithSource|htmlWithSource)\()"
 )
 
 
@@ -453,8 +597,6 @@ def _inject_code_execution_fences(
 
     Each file gets its own fence placed at the position of its inline ref. Duplicate
     refs for the same file (overwrite case) are removed after the first is replaced.
-    When at least one fence was injected, executed-code <details> blocks are
-    stripped via strip_executed_code_blocks() from the code_display postprocessor.
 
     fence_id is a message-level counter so each fence has a unique id.
     """
@@ -480,7 +622,6 @@ def _inject_code_execution_fences(
             # Remove duplicate refs (overwrite case)
             text = re.sub(pattern, "", text)
     if any_fence_injected:
-        text = strip_executed_code_blocks(text)
         text = _ensure_fences_are_standalone(text)
         text = _CONSECUTIVE_FENCES_RE.sub(r"\1\n", text)
     return text
@@ -687,7 +828,9 @@ def _warn_unmatched_code_blocks(
             )
 
 
-def _get_next_ref_number(references: list[ContentReference]) -> int:
+def _get_next_ref_number(references: list[ContentReference] | None) -> int:
+    if not references:
+        return 1
     max_ref_number = 0
     for ref in references:
         max_ref_number = max(max_ref_number, ref.sequence_number)

{unique_toolkit-1.63.1 → unique_toolkit-1.64.0}/unique_toolkit/agentic/tools/openai_builtin/code_interpreter/service.py

@@ -2,7 +2,7 @@ import logging
 from typing import Any, override
 
 from openai import AsyncOpenAI, BaseModel, NotFoundError
-from openai.types.responses import ResponseCodeInterpreterToolCall
+from openai.types.responses import ResponseCodeInterpreterToolCall, ResponseIncludable
 from openai.types.responses.tool_param import CodeInterpreter
 
 from unique_toolkit import ContentService, ShortTermMemoryService
@@ -251,14 +251,19 @@ class OpenAICodeInterpreterTool(OpenAIBuiltInTool[CodeInterpreter]):
         fence_ff_on = feature_flags.enable_code_execution_fence_un_17972.is_enabled(
             self._company_id
         )
-        operator_customised = (
-            self._config.tool_description_for_system_prompt
-            != DEFAULT_TOOL_DESCRIPTION_FOR_SYSTEM_PROMPT
-        )
+        # A prompt is considered operator-customised only when it differs from every
+        # known default variant. Comparing against both defaults ensures spaces whose
+        # stored value was written by an earlier deployment (which may have used the
+        # non-fence default) are still treated as uncustomised once the fence FF is on.
+        stored = self._config.tool_description_for_system_prompt
+        operator_customised = stored not in {
+            DEFAULT_TOOL_DESCRIPTION_FOR_SYSTEM_PROMPT,
+            DEFAULT_TOOL_DESCRIPTION_FOR_SYSTEM_PROMPT_FENCE,
+        }
         if fence_ff_on and not operator_customised:
             system_prompt = DEFAULT_TOOL_DESCRIPTION_FOR_SYSTEM_PROMPT_FENCE
         else:
-            system_prompt = self._config.tool_description_for_system_prompt
+            system_prompt = stored
 
         return ToolPrompts(
             name="python",  # https://platform.openai.com/docs/guides/tools-code-interpreter
@@ -275,6 +280,14 @@ class OpenAICodeInterpreterTool(OpenAIBuiltInTool[CodeInterpreter]):
     def display_name(self) -> str:
         return self.DISPLAY_NAME
 
+    @override
+    def get_required_include_params(self) -> list[ResponseIncludable]:
+        if feature_flags.enable_code_execution_fence_un_17972.is_enabled(
+            self._company_id
+        ):
+            return ["code_interpreter_call.outputs"]
+        return []
+
     @classmethod
     def get_debug_info(cls, call: ResponseCodeInterpreterToolCall) -> dict[str, Any]:
         return {

{unique_toolkit-1.63.1 → unique_toolkit-1.64.0}/unique_toolkit/agentic/tools/openai_builtin/manager.py

@@ -1,4 +1,5 @@
 from openai import AsyncOpenAI
+from openai.types.responses import ResponseIncludable
 
 from unique_toolkit.agentic.tools.config import ToolBuildConfig
 from unique_toolkit.agentic.tools.openai_builtin.base import (
@@ -79,3 +80,14 @@ class OpenAIBuiltInToolManager:
 
     def get_all_openai_builtin_tools(self) -> list[OpenAIBuiltInTool]:
         return self._builtin_tools.copy()
+
+    def get_required_include_params(self) -> list[ResponseIncludable]:
+        """Aggregate include params required by all active built-in tools."""
+        seen: set[str] = set()
+        result: list[ResponseIncludable] = []
+        for tool in self._builtin_tools:
+            for param in tool.get_required_include_params():
+                if param not in seen:
+                    seen.add(param)
+                    result.append(param)
+        return result

{unique_toolkit-1.63.1 → unique_toolkit-1.64.0}/unique_toolkit/agentic/tools/tool_manager.py

@@ -7,6 +7,7 @@ from openai.types.chat import (
     ChatCompletionNamedToolChoiceParam,
 )
 from openai.types.responses import (
+    ResponseIncludable,
     ToolParam,
     response_create_params,
 )
@@ -490,6 +491,7 @@ class ResponsesApiToolManager(_ToolManager[Literal["responses"]]):
         a2a_manager: A2AManager,
         builtin_tool_manager: OpenAIBuiltInToolManager,
     ) -> None:
+        self._builtin_tool_manager = builtin_tool_manager
         super().__init__(
             logger=logger,
             config=config,
@@ -500,3 +502,7 @@ class ResponsesApiToolManager(_ToolManager[Literal["responses"]]):
             api_mode="responses",
             builtin_tool_manager=builtin_tool_manager,
         )
+
+    def get_required_include_params(self) -> list[ResponseIncludable]:
+        """Return Responses API include params required by all active built-in tools."""
+        return self._builtin_tool_manager.get_required_include_params()