Inline large tool artifacts into conversation previews

Author: Mateusz

src/core/services/request_processor_service.py

@@ -9,6 +9,7 @@
 
 import logging
 import re
+from pathlib import Path
 from typing import Any
 
 from src.core.domain.chat import ChatRequest
@@ -25,6 +26,11 @@
     ProjectDirectoryResolutionService,
 )
 
+_TRUNCATED_ARTIFACT_PREFIX = "<system-reminder> CRITICAL: This output was truncated."
+_TRUNCATED_ARTIFACT_PATH_RE = re.compile(r"saved to ([A-Za-z]:\\[^\s]+)", re.IGNORECASE)
+_ARTIFACT_MAX_LINES = 120
+_ARTIFACT_MAX_CHARS = 6000
+
 logger = logging.getLogger(__name__)
 
 
@@ -114,6 +120,8 @@ async def process_request(
             f"command_results={len(command_result.command_results) if hasattr(command_result.command_results, '__len__') else 0}"
         )
 
+        self._expand_truncated_tool_outputs(command_result)
+
         # Special handling: Cline agent expects tool_calls for proxy commands
         try:
             if (
@@ -139,9 +147,9 @@ async def process_request(
             await self._session_manager.record_command_in_session(
                 request_data, session_id
             )
-            return await self._response_manager.process_command_result(
-                command_result, session
-            )
+        return await self._response_manager.process_command_result(
+            command_result, session
+        )
 
         # Prepare backend request
         backend_request = await self._backend_request_manager.prepare_backend_request(
@@ -625,20 +633,20 @@ async def process_request(
                     )
                     if isinstance(hybrid_disabled_map, dict):
                         hybrid_disabled_map = dict(hybrid_disabled_map)
-                        if session_id in hybrid_disabled_map:
-                            hybrid_reasoning_disabled = True
-                            # Remove the flag so it's only used for this request
-                            del hybrid_disabled_map[session_id]
-                            if self._app_state is not None:
-                                self._app_state.set_setting(
-                                    "edit_precision_hybrid_reasoning_disabled",
-                                    hybrid_disabled_map,
-                                )
-                                self._clear_active_hybrid_disable_flag(session_id)
-                            logger.info(
-                                f"Hybrid reasoning disabled for session {session_id} due to edit failure",
-                                extra={"session_id": session_id},
-                            )
+                        if session_id in hybrid_disabled_map:
+                            hybrid_reasoning_disabled = True
+                            # Remove the flag so it's only used for this request
+                            del hybrid_disabled_map[session_id]
+                            if self._app_state is not None:
+                                self._app_state.set_setting(
+                                    "edit_precision_hybrid_reasoning_disabled",
+                                    hybrid_disabled_map,
+                                )
+                                self._clear_active_hybrid_disable_flag(session_id)
+                            logger.info(
+                                f"Hybrid reasoning disabled for session {session_id} due to edit failure",
+                                extra={"session_id": session_id},
+                            )
                 except (AttributeError, TypeError, ValueError) as e:
                     logger.debug(
                         "Could not resolve hybrid reasoning disabled flag: %s",
@@ -836,38 +844,38 @@ async def process_request(
                     f"Failed to update session fingerprint: {e}", exc_info=True
                 )
 
-        return backend_response
-
-    def _clear_active_hybrid_disable_flag(self, session_id: str) -> None:
-        """Remove the active hybrid disable marker for the given session if present."""
-        if self._app_state is None:
-            return
-
-        try:
-            active_map = self._app_state.get_setting(
-                "edit_precision_hybrid_reasoning_active", {}
-            )
-            if not isinstance(active_map, dict) or session_id not in active_map:
-                return
-
-            updated_map = dict(active_map)
-            updated_map.pop(session_id, None)
-            self._app_state.set_setting(
-                "edit_precision_hybrid_reasoning_active", updated_map
-            )
-        except Exception as exc:
-            logger.debug(
-                "Failed to clear active hybrid disable marker for session %s: %s",
-                session_id,
-                exc,
-                exc_info=True,
-            )
-
-    def _apply_hybrid_reasoning_override(
-        self,
-        backend_request: ChatRequest,
-        session_id: str,
-        app_config: Any | None,
+        return backend_response
+
+    def _clear_active_hybrid_disable_flag(self, session_id: str) -> None:
+        """Remove the active hybrid disable marker for the given session if present."""
+        if self._app_state is None:
+            return
+
+        try:
+            active_map = self._app_state.get_setting(
+                "edit_precision_hybrid_reasoning_active", {}
+            )
+            if not isinstance(active_map, dict) or session_id not in active_map:
+                return
+
+            updated_map = dict(active_map)
+            updated_map.pop(session_id, None)
+            self._app_state.set_setting(
+                "edit_precision_hybrid_reasoning_active", updated_map
+            )
+        except Exception as exc:
+            logger.debug(
+                "Failed to clear active hybrid disable marker for session %s: %s",
+                session_id,
+                exc,
+                exc_info=True,
+            )
+
+    def _apply_hybrid_reasoning_override(
+        self,
+        backend_request: ChatRequest,
+        session_id: str,
+        app_config: Any | None,
     ) -> ChatRequest:
         """Temporarily disable hybrid reasoning for the given request if applicable."""
 
@@ -986,3 +994,124 @@ async def _handle_command_processing(
         return await self._command_processor.process_messages(
             request_data.messages, session_id, context
         )
+
+    def _expand_truncated_tool_outputs(self, command_result: ProcessedResult) -> None:
+        """Expand truncated tool outputs recorded as artifact references."""
+        messages = getattr(command_result, "modified_messages", None)
+        if not messages:
+            return
+
+        normalized_messages: list[Any] = []
+        changed = False
+
+        for raw_message in messages:
+            message, altered = self._normalize_tool_message(raw_message)
+            normalized_messages.append(message)
+            changed = changed or altered
+
+        if changed:
+            command_result.modified_messages = normalized_messages
+
+    def _normalize_tool_message(self, raw_message: Any) -> tuple[Any, bool]:
+        """Return tool message with expanded artifact content when possible."""
+        role = None
+        content = None
+
+        if isinstance(raw_message, dict):
+            role = raw_message.get("role")
+            content = raw_message.get("content")
+        else:
+            role = getattr(raw_message, "role", None)
+            content = getattr(raw_message, "content", None)
+
+        if role != "tool":
+            return raw_message, False
+
+        replacement = self._extract_truncated_artifact_preview(content)
+        if replacement is None:
+            return raw_message, False
+
+        if isinstance(raw_message, dict):
+            updated = dict(raw_message)
+            updated["content"] = replacement
+            return updated, True
+
+        if hasattr(raw_message, "model_copy"):
+            return raw_message.model_copy(update={"content": replacement}), True
+
+        # Fallback: attempt in-place assignment
+        try:
+            raw_message.content = replacement  # type: ignore[attr-defined]
+            return raw_message, True
+        except Exception:
+            return raw_message, False
+
+    def _extract_truncated_artifact_preview(self, content: Any) -> str | None:
+        """Extract and truncate the artifact referenced by the tool output."""
+        if not isinstance(content, str):
+            return None
+        if _TRUNCATED_ARTIFACT_PREFIX not in content:
+            return None
+
+        match = _TRUNCATED_ARTIFACT_PATH_RE.search(content)
+        if not match:
+            return None
+
+        raw_path = match.group(1)
+        artifact_path = self._convert_artifact_path(raw_path)
+        if artifact_path is None or not artifact_path.exists():
+            logger.debug(
+                "Artifact path %s could not be resolved or does not exist", raw_path
+            )
+            return None
+
+        try:
+            artifact_text = artifact_path.read_text(encoding="utf-8", errors="replace")
+        except OSError as exc:
+            logger.warning("Failed to read tool artifact %s: %s", artifact_path, exc)
+            return None
+
+        preview = self._build_artifact_preview(artifact_text)
+        note = (
+            f"<system-reminder> Extracted artifact from {raw_path}. "
+            f"Showing limited preview for the language model.\n\n"
+        )
+        return note + preview
+
+    def _convert_artifact_path(self, raw_path: str) -> Path | None:
+        """Convert CLI artifact path to a path accessible from this environment."""
+        potential_path = Path(raw_path)
+        if potential_path.exists():
+            return potential_path
+
+        # Handle Windows paths when running under WSL/Linux (e.g., C:\ -> /mnt/c/)
+        if len(raw_path) > 2 and raw_path[1:3] == ":\\":
+            drive = raw_path[0].lower()
+            remainder = raw_path[3:].replace("\\", "/")
+            candidate = Path(f"/mnt/{drive}/{remainder}")
+            if candidate.exists():
+                return candidate
+
+        return None
+
+    def _build_artifact_preview(self, artifact_text: str) -> str:
+        """Produce a trimmed preview of artifact contents."""
+        lines = artifact_text.splitlines()
+        truncated_lines = False
+
+        if len(lines) > _ARTIFACT_MAX_LINES:
+            omitted = len(lines) - _ARTIFACT_MAX_LINES
+            lines = lines[:_ARTIFACT_MAX_LINES]
+            lines.append(f"[... {omitted} additional lines omitted ...]")
+            truncated_lines = True
+
+        preview = "\n".join(lines)
+
+        if len(preview) > _ARTIFACT_MAX_CHARS:
+            preview = preview[:_ARTIFACT_MAX_CHARS] + "\n[... output truncated ...]"
+            truncated_lines = True
+
+        if truncated_lines:
+            preview += "\n"
+
+        return preview