unique-toolkit 2026.36.0.dev2__tar.gz → 2026.36.0.dev4__tar.gz

{unique_toolkit-2026.36.0.dev2 → unique_toolkit-2026.36.0.dev4}/PKG-INFO

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

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

{unique_toolkit-2026.36.0.dev2 → unique_toolkit-2026.36.0.dev4}/unique_toolkit/agentic/feature_flags/feature_flags.py

@@ -30,7 +30,6 @@ class FeatureFlagNames(StrEnum):
     enable_web_search_argument_screening_un_18741 = (
         "FEATURE_FLAG_ENABLE_WEB_SEARCH_ARGUMENT_SCREENING_UN_18741"
     )
-    enable_new_answers_ui_un_14411 = "FEATURE_FLAG_ENABLE_NEW_ANSWERS_UI_UN_14411"
 
 
 @deprecated(
@@ -83,20 +82,25 @@ class FeatureFlags(BaseSettings):
     """Feature flags loaded from environment variables.
 
     Environment variables are automatically loaded based on field names.
-    For example, `enable_new_answers_ui_un_14411` will be loaded from
-    `FEATURE_FLAG_ENABLE_NEW_ANSWERS_UI_UN_14411` (with the env_prefix).
+    For example, `enable_html_rendering_un_15131` will be loaded from
+    `FEATURE_FLAG_ENABLE_HTML_RENDERING_UN_15131` (with the env_prefix).
 
     Usage:
         >>> flags = FeatureFlags()
         >>> # Check if feature is enabled for a company
-        >>> flags.enable_new_answers_ui_un_14411.is_enabled("company123")
+        >>> flags.enable_html_rendering_un_15131.is_enabled("company123")
         >>> # Check global enablement
         >>> bool(flags.enable_elicitation_un_15809)
     """
 
     enable_new_answers_ui_un_14411: FeatureFlag = Field(
         default=FeatureFlag([]),
-        description="Enable new answers UI (UN-14411)",
+        description=(
+            "Retired (UN-24507): the new answers UI is always on now, no code "
+            "reads this field. Kept only so removing it doesn't trip the "
+            "config-checker's breaking-change gate on this settings model; "
+            "delete once that checker allows field removal."
+        ),
     )
 
     enable_html_rendering_un_15131: FeatureFlag = Field(

{unique_toolkit-2026.36.0.dev2 → unique_toolkit-2026.36.0.dev4}/unique_toolkit/agentic/tools/a2a/tool/service.py

@@ -22,7 +22,6 @@ from unique_toolkit._common.referencing import (
 )
 from unique_toolkit._common.utils.jinja.render import render_template
 from unique_toolkit.agentic.evaluation.schemas import EvaluationMetricName
-from unique_toolkit.agentic.feature_flags import FeatureFlagNames
 from unique_toolkit.agentic.tools.a2a.response_watcher import SubAgentResponseWatcher
 from unique_toolkit.agentic.tools.a2a.tool._memory import (
     get_sub_agent_short_term_memory_manager,
@@ -39,10 +38,7 @@ from unique_toolkit.agentic.tools.a2a.tool.config import (
 from unique_toolkit.agentic.tools.factory import ToolFactory
 from unique_toolkit.agentic.tools.schemas import ToolCallResponse
 from unique_toolkit.agentic.tools.tool import Tool
-from unique_toolkit.agentic.tools.tool_progress_reporter import (
-    ProgressState,
-    ToolProgressReporter,
-)
+from unique_toolkit.agentic.tools.tool_progress_reporter import ToolProgressReporter
 from unique_toolkit.app import ChatEvent
 from unique_toolkit.chat.schemas import (
     ChatMessageAssessmentLabel,
@@ -53,7 +49,6 @@ from unique_toolkit.chat.schemas import (
 )
 from unique_toolkit.chat.service import ChatService
 from unique_toolkit.content import ContentChunk, ContentReference
-from unique_toolkit.experimental.resources.feature_flags import is_flag_enabled
 from unique_toolkit.language_model import (
     LanguageModelFunction,
     LanguageModelService,
@@ -196,12 +191,6 @@ class SubAgentTool(Tool[SubAgentToolConfig]):
             timestamp = datetime.now()
 
             if self._lock.locked():
-                await self._notify_progress(
-                    tool_call=tool_call,
-                    message=f"Waiting for another run of `{self.display_name()}` to finish",
-                    state=ProgressState.STARTED,
-                )
-
                 active_message_log = self._create_or_update_message_log(
                     progress_message="_Waiting for another run of this sub agent to finish_",
                     active_message_log=active_message_log,
@@ -215,12 +204,6 @@ class SubAgentTool(Tool[SubAgentToolConfig]):
                 sequence_number = self._sequence_number
                 self._sequence_number += 1
 
-                await self._notify_progress(
-                    tool_call=tool_call,
-                    message=tool_input,
-                    state=ProgressState.RUNNING,
-                )
-
                 active_message_log = self._create_or_update_message_log(
                     progress_message=f"<em>Executing sub agent with input: {tool_input}</em>",
                     active_message_log=active_message_log,
@@ -285,12 +268,6 @@ class SubAgentTool(Tool[SubAgentToolConfig]):
                         has_refs=has_refs,
                     )
 
-                await self._notify_progress(
-                    tool_call=tool_call,
-                    message=tool_input,
-                    state=ProgressState.FINISHED,
-                )
-
                 # Update message log entry to completed
                 active_message_log = self._create_or_update_message_log(
                     progress_message=f"<em>Completed sub agent with input: {tool_input}</em>",
@@ -329,11 +306,6 @@ class SubAgentTool(Tool[SubAgentToolConfig]):
         except TimeoutError as e:
             raise e
         except Exception as e:
-            await self._notify_progress(
-                tool_call=tool_call,
-                message="Error while running sub agent",
-                state=ProgressState.FAILED,
-            )
             active_message_log = self._create_or_update_message_log(
                 progress_message="_Error while running sub agent_",
                 status=MessageLogStatus.FAILED,
@@ -426,23 +398,6 @@ class SubAgentTool(Tool[SubAgentToolConfig]):
             SubAgentShortTermMemorySchema(chat_id=chat_id)
         )
 
-    async def _notify_progress(
-        self,
-        tool_call: LanguageModelFunction,
-        message: str,
-        state: ProgressState,
-    ) -> None:
-        if self._tool_progress_reporter is not None and not await is_flag_enabled(
-            FeatureFlagNames.enable_new_answers_ui_un_14411,
-            company_id=self._company_id or "",
-        ):
-            await self._tool_progress_reporter.notify_from_tool_call(
-                tool_call=tool_call,
-                name=self._display_name,
-                message=message,
-                state=state,
-            )
-
     def _create_or_update_message_log(
         self,
         *,
@@ -511,11 +466,6 @@ class SubAgentTool(Tool[SubAgentToolConfig]):
                 wait_for_invocations=True,
             )
         except TimeoutError as e:
-            await self._notify_progress(
-                tool_call=tool_call,
-                message="Timeout while waiting for response from sub agent.",
-                state=ProgressState.FAILED,
-            )
             active_message_log = self._create_or_update_message_log(
                 progress_message="_Timeout while waiting for response from sub agent_",
                 status=MessageLogStatus.FAILED,

{unique_toolkit-2026.36.0.dev2 → unique_toolkit-2026.36.0.dev4}/unique_toolkit/agentic/tools/mcp/tool_wrapper.py

@@ -10,20 +10,15 @@ import unique_sdk
 from pydantic import ValidationError
 
 from unique_toolkit.agentic.evaluation.schemas import EvaluationMetricName
-from unique_toolkit.agentic.feature_flags import FeatureFlagNames
 from unique_toolkit.agentic.tools.mcp.models import MCPToolConfig
 from unique_toolkit.agentic.tools.schemas import ToolCallResponse
 from unique_toolkit.agentic.tools.tool import Tool
-from unique_toolkit.agentic.tools.tool_progress_reporter import (
-    ProgressState,
-    ToolProgressReporter,
-)
+from unique_toolkit.agentic.tools.tool_progress_reporter import ToolProgressReporter
 from unique_toolkit.app.schemas import ChatEvent, McpServer, McpTool
 from unique_toolkit.chat.schemas import MessageLog, MessageLogStatus
 from unique_toolkit.chat.service import ChatService
 from unique_toolkit.content.functions import upload_content_from_bytes
 from unique_toolkit.content.schemas import ContentChunk, ContentReference
-from unique_toolkit.experimental.resources.feature_flags import is_flag_enabled
 from unique_toolkit.language_model import LanguageModelService
 from unique_toolkit.language_model.schemas import (
     LanguageModelFunction,
@@ -137,18 +132,6 @@ class MCPToolWrapper(Tool[MCPToolConfig]):
             active_message_log=active_message_log,
         )
 
-        # Notify progress if reporter is available
-        if self._tool_progress_reporter and not await is_flag_enabled(
-            FeatureFlagNames.enable_new_answers_ui_un_14411,
-            company_id=self._event.company_id,
-        ):
-            await self._tool_progress_reporter.notify_from_tool_call(
-                tool_call=tool_call,
-                name=f"**{self.display_name()}**",
-                message=f"Executing MCP tool: {self.display_name()}",
-                state=ProgressState.RUNNING,
-            )
-
         try:
             # Robust argument extraction and validation
             arguments = self._extract_and_validate_arguments(tool_call)
@@ -180,18 +163,6 @@ class MCPToolWrapper(Tool[MCPToolConfig]):
                 image_data_urls=image_data_urls,
             )
 
-            # Notify completion
-            if self._tool_progress_reporter and not await is_flag_enabled(
-                FeatureFlagNames.enable_new_answers_ui_un_14411,
-                company_id=self._event.company_id,
-            ):
-                await self._tool_progress_reporter.notify_from_tool_call(
-                    tool_call=tool_call,
-                    name=f"**{self.display_name()}**",
-                    message=f"MCP tool completed: {self.display_name()}",
-                    state=ProgressState.FINISHED,
-                )
-
             # Update message log entry to completed
             active_message_log = self._create_or_update_message_log(
                 progress_message="_Completed MCP tool_",
@@ -205,18 +176,6 @@ class MCPToolWrapper(Tool[MCPToolConfig]):
         except Exception as e:
             self.logger.error(f"Error executing MCP tool {self.name}: {e}")
 
-            # Notify failure
-            if self._tool_progress_reporter and not await is_flag_enabled(
-                FeatureFlagNames.enable_new_answers_ui_un_14411,
-                company_id=self._event.company_id,
-            ):
-                await self._tool_progress_reporter.notify_from_tool_call(
-                    tool_call=tool_call,
-                    name=f"**{self.display_name()}**",
-                    message=f"MCP tool failed: {str(e)}",
-                    state=ProgressState.FAILED,
-                )
-
             # Update message log entry to failed
             active_message_log = self._create_or_update_message_log(
                 progress_message="_Failed executing MCP tool_",

unique_toolkit-2026.36.0.dev4/unique_toolkit/agentic/tools/openai_builtin/code_interpreter/postprocessors/artifacts.py

@@ -0,0 +1,213 @@
+import asyncio
+import logging
+import tempfile
+from mimetypes import guess_type
+from pathlib import Path
+from typing import Any
+
+import unique_sdk.utils.file_io as file_io
+from openai.types.responses.response_output_text import AnnotationContainerFileCitation
+from pydantic import BaseModel
+
+from unique_toolkit import ChatService
+from unique_toolkit._common.utils.files import FileMimeType, ImageMimeType
+from unique_toolkit.agentic.tools.openai_builtin.code_interpreter.postprocessors.office_preview import (
+    OFFICE_PREVIEW_MIME_TYPES,
+    convert_office_bytes_to_preview_pdf,
+    office_extension,
+)
+from unique_toolkit.content.schemas import Content
+
+_CODE_EXECUTION_ARTIFACT_METADATA_KEY: str = "codeExecutionArtifactMetadata"
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class CodeExecutionArtifactMetadata(BaseModel):
+    container_id: str
+    file_id: str
+    filepath: str
+
+
+def _kb_safe_mime(mime: str) -> str:
+    """Return a MIME type the Unique KB will accept.
+
+    Membership is defined by ``FileMimeType`` and ``ImageMimeType`` in
+    ``unique_toolkit._common.utils.files`` (same catalog as path-based helpers
+    like ``FileMimeType.is_valid_mime``, but here we already have a resolved
+    MIME string from ``mimetypes.guess_type``, so we use StrEnum value lookup
+    instead of re-parsing a path).
+
+    The KB GraphQL API rejects many code-file MIME types (e.g. ``text/x-python``
+    for ``.py`` files).  Anything not in those enums is coerced to
+    ``text/plain`` so the file can be stored and downloaded without changing
+    its bytes.
+
+    Other ``image/*`` subtypes (e.g. ``image/jpg``) still pass through unchanged.
+    """
+    try:
+        FileMimeType(mime)
+        return mime
+    except ValueError:
+        pass
+    try:
+        ImageMimeType(mime)
+        return mime
+    except ValueError:
+        pass
+    if mime.startswith("image/"):
+        return mime
+    return "text/plain"
+
+
+def _artifact_metadata(
+    file: AnnotationContainerFileCitation,
+) -> dict[str, Any]:
+    return {
+        _CODE_EXECUTION_ARTIFACT_METADATA_KEY: CodeExecutionArtifactMetadata(
+            container_id=file.container_id,
+            file_id=file.file_id,
+            filepath=f"/mnt/data/{file.filename}",
+        ).model_dump()
+    }
+
+
+async def _upload_artifact_bytes(
+    chat_service: ChatService,
+    file: AnnotationContainerFileCitation,
+    file_bytes: bytes,
+    mime: str,
+) -> Content:
+    _LOGGER.info(
+        "Uploading '%s' to knowledge base (%d bytes, mime type %s)",
+        file.filename,
+        len(file_bytes),
+        mime,
+    )
+
+    return await chat_service.upload_to_chat_from_bytes_async(
+        content=file_bytes,
+        content_name=file.filename,
+        mime_type=mime,
+        skip_ingestion=True,
+        hide_in_chat=True,
+        metadata=_artifact_metadata(file),
+    )
+
+
+async def _upload_office_artifact_with_preview(
+    chat_service: ChatService,
+    file: AnnotationContainerFileCitation,
+    file_bytes: bytes,
+    mime: str,
+) -> Content | None:
+    """Upload an Office artifact with a PDF preview, or ``None`` to fall back."""
+    with tempfile.TemporaryDirectory(prefix="code-interpreter-preview-") as tmp:
+        output_dir = Path(tmp)
+        preview_path = await convert_office_bytes_to_preview_pdf(
+            filename=file.filename,
+            file_bytes=file_bytes,
+            tmp_dir=output_dir,
+            logger=_LOGGER,
+        )
+        if preview_path is None:
+            _LOGGER.warning(
+                "Code interpreter Office artifact '%s' could not be converted "
+                "to PDF; uploading without preview.",
+                file.filename,
+            )
+            return None
+
+        source_path = output_dir / Path(file.filename).name
+        _LOGGER.info(
+            "Uploading code interpreter Office artifact '%s' with PDF preview '%s'",
+            file.filename,
+            preview_path.name,
+        )
+
+        uploaded = await asyncio.to_thread(
+            file_io.upload_file,
+            chat_service._user_id,
+            chat_service._company_id,
+            str(source_path),
+            file.filename,
+            mime,
+            chat_id=chat_service._chat_id,
+            ingestion_config={
+                "uniqueIngestionMode": "SKIP_INGESTION",
+                "hideInChat": True,
+            },
+            metadata=_artifact_metadata(file),
+            preview_pdf_path=str(preview_path),
+        )
+
+    return Content.model_validate(uploaded, by_alias=True, by_name=True)
+
+
+async def save_code_execution_artifact(
+    chat_service: ChatService,
+    file: AnnotationContainerFileCitation,
+    file_bytes: bytes,
+    *,
+    attach_office_preview: bool = False,
+) -> Content:
+    """Upload a code-interpreter artifact to the chat knowledge base.
+
+    ``attach_office_preview`` is opt-in (default ``False``) so existing
+    Unique AI callers keep the historical bytes-only upload. When ``True``,
+    Word / PowerPoint / Excel files are converted to a sibling PDF and
+    uploaded with ``preview_pdf_path``. Conversion is best-effort: if
+    LibreOffice is missing or conversion fails, the original bytes are
+    uploaded instead. Upload failures are not retried via the bytes path,
+    because ``file_io.upload_file`` may already have created a content row.
+    """
+    if attach_office_preview:
+        extension = office_extension(file.filename)
+        if extension is not None:
+            mime = _kb_safe_mime(OFFICE_PREVIEW_MIME_TYPES[extension])
+            content = await _upload_office_artifact_with_preview(
+                chat_service=chat_service,
+                file=file,
+                file_bytes=file_bytes,
+                mime=mime,
+            )
+            if content is not None:
+                return content
+            return await _upload_artifact_bytes(
+                chat_service=chat_service,
+                file=file,
+                file_bytes=file_bytes,
+                mime=mime,
+            )
+
+    raw_mime = guess_type(file.filename)[0] or "text/plain"
+    mime = _kb_safe_mime(raw_mime)
+
+    if mime != raw_mime:
+        _LOGGER.info(
+            "MIME type '%s' is not supported by the Unique KB; "
+            "uploading '%s' as 'text/plain' so the file can be stored and downloaded.",
+            raw_mime,
+            file.filename,
+        )
+
+    return await _upload_artifact_bytes(
+        chat_service=chat_service,
+        file=file,
+        file_bytes=file_bytes,
+        mime=mime,
+    )
+
+
+def load_code_execution_metadata(
+    content: Content,
+) -> CodeExecutionArtifactMetadata | None:
+    if (
+        content.metadata is None
+        or _CODE_EXECUTION_ARTIFACT_METADATA_KEY not in content.metadata
+    ):
+        return None
+
+    return CodeExecutionArtifactMetadata.model_validate(
+        content.metadata[_CODE_EXECUTION_ARTIFACT_METADATA_KEY]
+    )

{unique_toolkit-2026.36.0.dev2 → unique_toolkit-2026.36.0.dev4}/unique_toolkit/agentic/tools/openai_builtin/code_interpreter/postprocessors/generated_files.py

@@ -117,6 +117,15 @@ class DisplayCodeInterpreterFilesPostProcessorConfig(BaseModel):
         "Applies per SDK attempt. The OpenAI SDK default of 600s is too generous "
         "for small generated files; a shorter timeout lets us retry sooner.",
     )
+    attach_office_preview: SkipJsonSchema[bool] = Field(
+        default=False,
+        description=(
+            "When True, convert Word/PowerPoint/Excel artifacts to a sibling "
+            "PDF and attach it as the chat side-panel preview. Default False "
+            "keeps the historical bytes-only upload. Conversion is best-effort "
+            "and falls back to the original file."
+        ),
+    )
 
 
 class _ContentInfo(NamedTuple):
@@ -762,6 +771,7 @@ class DisplayCodeInterpreterFilesPostProcessor(
                 chat_service=self._chat_service,
                 file=container_file,
                 file_bytes=file_bytes,
+                attach_office_preview=self._config.attach_office_preview,
             )
             upload_ms = (time.monotonic() - upload_t0) * 1000
             if upload_ms > 2000:

unique_toolkit-2026.36.0.dev4/unique_toolkit/agentic/tools/openai_builtin/code_interpreter/postprocessors/office_preview.py

@@ -0,0 +1,154 @@
+"""LibreOffice PDF previews for code-interpreter Office artifacts.
+
+When the OpenAI code interpreter emits a Word, PowerPoint, or Excel file,
+the chat UI can render a sibling PDF in the side panel far more reliably
+than the Office binary. Conversion is best-effort: if ``soffice`` is
+missing, times out, or rejects the file, callers upload the original
+without a preview.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+_SOFFICE_TIMEOUT_SECONDS = 180
+
+# Canonical MIME types so slim containers without ``/etc/mime.types`` still
+# upload Office files with a KB-accepted type instead of falling back to
+# ``text/plain`` via ``mimetypes.guess_type``.
+OFFICE_PREVIEW_MIME_TYPES: dict[str, str] = {
+    ".doc": "application/msword",
+    ".docx": (
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+    ),
+    ".ppt": "application/vnd.ms-powerpoint",
+    ".pptx": (
+        "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+    ),
+    ".xls": "application/vnd.ms-excel",
+    ".xlsx": ("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"),
+}
+
+
+def office_extension(filename: str) -> str | None:
+    """Return the lowercased Office suffix, or ``None`` if not previewable."""
+    suffix = Path(filename).suffix.lower()
+    return suffix if suffix in OFFICE_PREVIEW_MIME_TYPES else None
+
+
+def _resolve_soffice_binary() -> str | None:
+    return shutil.which("soffice") or shutil.which("libreoffice")
+
+
+def _run_soffice(
+    soffice: str,
+    source: Path,
+    output_dir: Path,
+    logger: logging.Logger,
+) -> None:
+    """Invoke headless ``soffice`` to convert *source* into *output_dir*.
+
+    Uses an isolated ``UserInstallation`` profile so concurrent LibreOffice
+    invocations do not collide on ``$HOME/.config/libreoffice``.
+    """
+    with tempfile.TemporaryDirectory(
+        prefix=".libreoffice-profile-",
+        dir=output_dir,
+    ) as profile_dir:
+        proc = subprocess.run(
+            [
+                soffice,
+                f"-env:UserInstallation={Path(profile_dir).resolve().as_uri()}",
+                "--headless",
+                "--convert-to",
+                "pdf",
+                "--outdir",
+                str(output_dir),
+                str(source),
+            ],
+            capture_output=True,
+            text=True,
+            timeout=_SOFFICE_TIMEOUT_SECONDS,
+        )
+    if proc.returncode != 0:
+        logger.warning(
+            "office_preview: soffice exited %d for '%s' "
+            "(stdout=%d bytes, stderr=%d bytes)",
+            proc.returncode,
+            source.name,
+            len((proc.stdout or "").strip()),
+            len((proc.stderr or "").strip()),
+        )
+        raise subprocess.CalledProcessError(
+            proc.returncode, proc.args, proc.stdout, proc.stderr
+        )
+
+
+async def convert_office_bytes_to_preview_pdf(
+    filename: str,
+    file_bytes: bytes,
+    tmp_dir: Path,
+    logger: logging.Logger,
+) -> Path | None:
+    """Write *file_bytes* into *tmp_dir* and convert to a sibling preview PDF.
+
+    The original file is written as ``tmp_dir / Path(filename).name`` so the
+    caller can pass that path to the SDK uploader. The preview is rendered
+    into ``tmp_dir / .previews / <stem>.pdf`` so it cannot collide with a
+    same-named PDF the interpreter also produced.
+
+    Returns the preview path, or ``None`` when conversion is unavailable or
+    fails. Never raises for expected conversion problems.
+    """
+    safe_filename = Path(filename).name
+    source_path = tmp_dir / safe_filename
+    source_path.write_bytes(file_bytes)
+
+    soffice = _resolve_soffice_binary()
+    if soffice is None:
+        logger.warning(
+            "office_preview: soffice/libreoffice not found on PATH — "
+            "uploading '%s' without a PDF preview.",
+            safe_filename,
+        )
+        return None
+
+    previews_dir = tmp_dir / ".previews"
+    previews_dir.mkdir(exist_ok=True)
+    target = previews_dir / f"{source_path.stem}.pdf"
+
+    try:
+        await asyncio.to_thread(
+            _run_soffice, soffice, source_path, previews_dir, logger
+        )
+    except subprocess.TimeoutExpired:
+        logger.warning(
+            "office_preview: soffice timed out after %ds for '%s' — "
+            "uploading original only",
+            _SOFFICE_TIMEOUT_SECONDS,
+            safe_filename,
+        )
+        return None
+    except subprocess.CalledProcessError:
+        return None
+    except Exception:
+        logger.exception(
+            "office_preview: unexpected error for '%s' — uploading original only",
+            safe_filename,
+        )
+        return None
+
+    if target.is_file():
+        return target
+
+    logger.warning(
+        "office_preview: soffice returned 0 but '%s' is missing for '%s'",
+        target.name,
+        safe_filename,
+    )
+    return None

{unique_toolkit-2026.36.0.dev2 → unique_toolkit-2026.36.0.dev4}/unique_toolkit/services/chat_service.py

@@ -22,7 +22,6 @@ from unique_toolkit._common.metadata_filter_scope import (
     merge_scope_clause_into_metadata_filter,
 )
 from unique_toolkit._common.utils.files import is_file_content, is_image_content
-from unique_toolkit.agentic.feature_flags import FeatureFlagNames
 from unique_toolkit.agentic.message_log_order import next_message_log_order
 from unique_toolkit.app.unique_settings import UniqueContext, UniqueSettings
 from unique_toolkit.chat.cancellation import CancellationWatcher
@@ -100,7 +99,6 @@ from unique_toolkit.content.schemas import (
     ContentSearchType,
 )
 from unique_toolkit.elicitation.service import ElicitationService
-from unique_toolkit.experimental.resources.feature_flags import is_flag_enabled
 from unique_toolkit.language_model.constants import (
     DEFAULT_COMPLETE_TEMPERATURE,
     DEFAULT_COMPLETE_TIMEOUT,
@@ -1806,11 +1804,6 @@ class ChatService(ChatServiceDeprecated):
 
             if not rate_limit_retry_config.log_message_on_retry:
                 return
-            if not await is_flag_enabled(
-                FeatureFlagNames.enable_new_answers_ui_un_14411,
-                company_id=self._company_id,
-            ):
-                return
 
             await _cancel_ticker()