unique_toolkit 1.70.4__tar.gz → 1.70.6__tar.gz

{unique_toolkit-1.70.4 → unique_toolkit-1.70.6}/PKG-INFO

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

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

{unique_toolkit-1.70.4 → unique_toolkit-1.70.6}/unique_toolkit/agentic/tools/openai_builtin/code_interpreter/postprocessors/generated_files.py

@@ -9,7 +9,6 @@ from typing import NamedTuple, override
 
 import httpx
 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
@@ -587,7 +586,12 @@ class DisplayCodeInterpreterFilesPostProcessor(
                 missed_files.append(filename)
 
             is_html_rendered = is_html
-            if replaced and not (is_image or is_html_rendered or fence_ff_on):
+            has_superscript = f"<sup>{ref_number}</sup>" in loop_response.message.text
+            if (
+                replaced
+                and has_superscript
+                and not (is_image or is_html_rendered or fence_ff_on)
+            ):
                 loop_response.message.references.append(
                     ContentReference(
                         sequence_number=ref_number,
@@ -613,7 +617,16 @@ class DisplayCodeInterpreterFilesPostProcessor(
                 len(code_blocks),
                 [f.filename for b in code_blocks for f in b.files],
             )
-            _warn_unmatched_code_blocks(self._content_map, code_blocks)
+            unmatched_blocks = _warn_unmatched_code_blocks(
+                self._content_map, code_blocks
+            )
+            if unmatched_blocks:
+                self._log.info(
+                    "Fence path: %d file(s) have no code-block match and will appear "
+                    "as plain download links: %s",
+                    len(unmatched_blocks),
+                    list(unmatched_blocks),
+                )
             text_before = loop_response.message.text
             loop_response.message.text = _inject_code_execution_fences(
                 loop_response.message.text,
@@ -625,19 +638,27 @@ class DisplayCodeInterpreterFilesPostProcessor(
                 self._log.info("Fence injection modified the message text")
 
             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
-                )
+                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
                 self._log.info(
-                    "Appended %d orphan fence(s)", len(self._orphan_code_blocks)
+                    "Added %d orphan code block(s) to message references",
+                    len(self._orphan_code_blocks),
                 )
 
         _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
+            loop_response.message.text
         )
         changed |= dangling_replaced
         if dangling_replaced:
@@ -949,13 +970,12 @@ class DisplayCodeInterpreterFilesPostProcessor(
     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.
+        """Upload source **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.
+        converts those "orphan" calls into downloadable .txt files (the executed
+        code, not stdout) so the postprocessor can attach a reference for download.
 
         Called only when the fence feature flag is enabled.  Skipped entirely if
         any container files were produced (normal fencing handles those).
@@ -976,13 +996,9 @@ class DisplayCodeInterpreterFilesPostProcessor(
             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
+            # Always persist the executed source as the downloadable .txt (not stdout),
+            # so the attachment matches what ran in the sandbox.
+            txt_content = call.code
             filename = f"code_{i + 1}.txt" if use_numeric_suffix else "code.txt"
 
             try:
@@ -1020,38 +1036,6 @@ class DisplayCodeInterpreterFilesPostProcessor(
         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 ""
     if mime.startswith("image/"):
@@ -1383,33 +1367,41 @@ def _warn_missing_content_ids(text: str, content_map: dict[str, str | None]) ->
 # so the entire `[label](sandbox://...)` token can be replaced rather than just the URL.
 _SANDBOX_MARKDOWN_LINK_RE = re.compile(r"!?\[.*?\]\(sandbox:/mnt/data/\S+?\)")
 
+# Extracts the bare filename from a sandbox URL like `sandbox:/mnt/data/foo.csv`.
+_SANDBOX_FILENAME_RE = re.compile(r"sandbox:/mnt/data/([^)\s]+)")
+
 
-def _replace_dangling_sandbox_links(text: str, error_message: str) -> tuple[str, bool]:
-    """Replace any remaining sandbox:/mnt/data/ markdown links with an error message.
+def _replace_dangling_sandbox_links(text: str) -> tuple[str, bool]:
+    """Replace any remaining sandbox:/mnt/data/ markdown links with a per-file notice.
 
     A dangling link means either the LLM hallucinated a file reference (the sandbox
     link appears in the text but no matching container file annotation was emitted by
     OpenAI), or the link format did not match the expected regex in stage-1.  In both
     cases the user would see a broken link; this function replaces each such link with
-    the configured error message and logs a warning so the incident is visible in logs.
+    an actionable message that names the specific file, and logs a warning so the
+    incident is visible in production logs.
     """
-    matches = _SANDBOX_MARKDOWN_LINK_RE.findall(text)
-    if not matches:
+    if not _SANDBOX_MARKDOWN_LINK_RE.search(text):
         return text, False
-    for match in matches:
+
+    def _replacement(m: re.Match[str]) -> str:
+        filename_match = _SANDBOX_FILENAME_RE.search(m.group())
+        filename = filename_match.group(1) if filename_match else "the file"
         logger.warning(
             "Dangling sandbox link found in final text: '%s'. "
             "The file was either never uploaded or the link format did not match "
-            "the expected pattern — replacing with error message.",
-            match,
+            "the expected pattern — replacing with per-file notice.",
+            m.group(),
         )
-    return _SANDBOX_MARKDOWN_LINK_RE.sub(error_message, text), True
+        return f"⚠️ The file *{filename}* could not be retrieved. You can ask me to regenerate it."
+
+    return _SANDBOX_MARKDOWN_LINK_RE.sub(_replacement, text), True
 
 
 def _warn_unmatched_code_blocks(
     content_map: dict[str, str | None],
     code_blocks: list[CodeInterpreterBlock],
-) -> None:
+) -> dict[str, str]:
     """Warn for files that were uploaded but could not be matched to any code block.
 
     When the fence feature flag is on, every uploaded file should map to a code block
@@ -1417,8 +1409,13 @@ def _warn_unmatched_code_blocks(
     matched (e.g. the LLM used a variable for the output path rather than a literal
     string) it falls back to a plain unique://content/ link with no code context.
     The user can still download it, but the frontend artifact UI will not be shown.
+
+    Returns:
+        Mapping of filename → content_id for every file that could not be matched
+        to a code block.  Callers may use this to inject additional fallback links.
     """
     fenced_filenames = {f.filename for block in code_blocks for f in block.files}
+    unmatched: dict[str, str] = {}
     for filename, content_id in content_map.items():
         if content_id is None:
             continue
@@ -1434,6 +1431,8 @@ def _warn_unmatched_code_blocks(
                 content_id,
                 filename,
             )
+            unmatched[filename] = content_id
+    return unmatched
 
 
 def _get_next_ref_number(references: list[ContentReference] | None) -> int:
@@ -1474,11 +1473,12 @@ def _replace_container_image_citation(
     if not re.search(image_markdown, text):
         logger.warning(
             "No sandbox link found for image '%s' (content_id=%s); "
-            "file was uploaded but the LLM did not reference it — it will not be displayed.",
+            "file was uploaded but the LLM did not reference it — appending fallback link.",
             filename,
             content_id,
         )
-        return text, False
+        fallback = f"\n\n📎 [{filename}](unique://content/{content_id})"
+        return text + fallback, True
 
     logger.info("Inserting image citation for '%s'", filename)
     return re.sub(
@@ -1497,11 +1497,12 @@ def _replace_container_html_citation(
     if not re.search(html_markdown, text):
         logger.warning(
             "No sandbox link found for HTML file '%s' (content_id=%s); "
-            "file was uploaded but the LLM did not reference it — it will not be displayed.",
+            "file was uploaded but the LLM did not reference it — appending fallback link.",
             filename,
             content_id,
         )
-        return text, False
+        fallback = f"\n\n📎 [{filename}](unique://content/{content_id})"
+        return text + fallback, True
 
     logger.info("Inserting HTML rendering block for '%s'", filename)
     block = f"```HtmlRendering\n800px\n600px\n\nunique://content/{content_id}\n\n```"
@@ -1554,11 +1555,12 @@ def _replace_container_file_citation(
     if not re.search(file_markdown, text):
         logger.warning(
             "No sandbox link found for file '%s' (content_id=%s); "
-            "file was uploaded but the LLM did not reference it — it will not be displayed.",
+            "file was uploaded but the LLM did not reference it — appending fallback link.",
             filename,
             content_id,
         )
-        return text, False
+        fallback = f"\n\n📎 [{filename}](unique://content/{content_id})"
+        return text + fallback, True
 
     logger.info("Displaying file %s", filename)
     replacement = (