@quantum-ai/gemini-cli 0.45.8 → 0.45.9

package/dist/ui/utils/markdownParsingUtils.js

@@ -0,0 +1,184 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import chalk from 'chalk';
+import { resolveColor, INK_SUPPORTED_NAMES, INK_NAME_TO_HEX_MAP, } from '../themes/color-utils.js';
+import { theme } from '../semantic-colors.js';
+import { debugLogger } from '@google/gemini-cli-core';
+import { convertLatexToUnicode } from './latexToUnicode.js';
+// Constants for Markdown parsing
+const BOLD_MARKER_LENGTH = 2; // For "**"
+const ITALIC_MARKER_LENGTH = 1; // For "*" or "_"
+const STRIKETHROUGH_MARKER_LENGTH = 2; // For "~~")
+const INLINE_CODE_MARKER_LENGTH = 1; // For "`"
+const UNDERLINE_TAG_START_LENGTH = 3; // For "<u>"
+const UNDERLINE_TAG_END_LENGTH = 4; // For "</u>"
+/**
+ * Helper to apply color to a string using ANSI escape codes,
+ * consistent with how Ink's colorize works.
+ */
+const ansiColorize = (str, color) => {
+    if (!color)
+        return str;
+    const resolved = resolveColor(color);
+    if (!resolved)
+        return str;
+    if (resolved.startsWith('#')) {
+        return chalk.hex(resolved)(str);
+    }
+    const mappedHex = INK_NAME_TO_HEX_MAP[resolved];
+    if (mappedHex) {
+        return chalk.hex(mappedHex)(str);
+    }
+    if (INK_SUPPORTED_NAMES.has(resolved)) {
+        switch (resolved) {
+            case 'black':
+                return chalk.black(str);
+            case 'red':
+                return chalk.red(str);
+            case 'green':
+                return chalk.green(str);
+            case 'yellow':
+                return chalk.yellow(str);
+            case 'blue':
+                return chalk.blue(str);
+            case 'magenta':
+                return chalk.magenta(str);
+            case 'cyan':
+                return chalk.cyan(str);
+            case 'white':
+                return chalk.white(str);
+            case 'gray':
+            case 'grey':
+                return chalk.gray(str);
+            default:
+                return str;
+        }
+    }
+    return str;
+};
+/**
+ * Converts markdown text into a string with ANSI escape codes.
+ * This mirrors the parsing logic in InlineMarkdownRenderer.tsx
+ */
+// Private-Use-Area codepoint used as a placeholder sentinel when masking
+// inline code / URL spans from LaTeX conversion. Not touched by
+// stripUnsafeCharacters and not matched by the markdown tokenizer.
+const MASK_SENTINEL = '\uE000';
+const MASK_PATTERN = /\uE000(\d+)\uE000/g;
+/**
+ * Runs LaTeX conversion on `text` while keeping inline code spans and bare
+ * URLs verbatim. Without masking, the LaTeX pass would happily rewrite
+ * ``$\to$`` inside a backtick code span — violating the "code is verbatim"
+ * contract — and could rewrite URL query strings containing `$`.
+ */
+const convertLatexPreservingSpans = (text) => {
+    const preserved = [];
+    // Match inline code spans (with matched backtick counts) and bare URLs.
+    // Order matters: code spans first so they win over a URL inside a span.
+    const masked = text.replace(/(`+)([^`\n]+?)\1|https?:\/\/\S+/g, (match) => {
+        const index = preserved.push(match) - 1;
+        return `${MASK_SENTINEL}${index}${MASK_SENTINEL}`;
+    });
+    const converted = convertLatexToUnicode(masked);
+    return converted.replace(MASK_PATTERN, 
+    // Fallback to the literal match if the index is somehow out of range —
+    // defensive against the unlikely case where the PUA sentinel appears in
+    // user input. Without the fallback, replace would emit "undefined".
+    (match, i) => preserved[Number(i)] ?? match);
+};
+export const parseMarkdownToANSI = (rawText, defaultColor) => {
+    const baseColor = defaultColor ?? theme.text.primary;
+    // Convert LaTeX-style math/commands to Unicode BEFORE tokenizing markdown,
+    // so constructs like `$\{P_0, \dots, P_n\}$` are handled as a whole even
+    // when they contain underscores (which the tokenizer would otherwise treat
+    // as italic markers). Inline code and URLs are masked during the
+    // conversion so their contents are preserved verbatim. Unknown `\foo`
+    // sequences are left alone, so Windows paths and regex escapes survive.
+    // See issue #25656.
+    const text = convertLatexPreservingSpans(rawText);
+    // Early return for plain text without markdown or URLs
+    if (!/[*_~`<[https?:]/.test(text)) {
+        return ansiColorize(text, baseColor);
+    }
+    let result = '';
+    const inlineRegex = /(\*\*\*.*?\*\*\*|\*\*.*?\*\*|\*.*?\*|_.*?_|~~.*?~~|\[.*?\]\(.*?\)|`+.+?`+|<u>.*?<\/u>|https?:\/\/\S+)/g;
+    let lastIndex = 0;
+    let match;
+    while ((match = inlineRegex.exec(text)) !== null) {
+        if (match.index > lastIndex) {
+            result += ansiColorize(text.slice(lastIndex, match.index), baseColor);
+        }
+        const fullMatch = match[0];
+        let styledPart = '';
+        try {
+            if (fullMatch.endsWith('***') &&
+                fullMatch.startsWith('***') &&
+                fullMatch.length > (BOLD_MARKER_LENGTH + ITALIC_MARKER_LENGTH) * 2) {
+                styledPart = chalk.bold(chalk.italic(parseMarkdownToANSI(fullMatch.slice(BOLD_MARKER_LENGTH + ITALIC_MARKER_LENGTH, -BOLD_MARKER_LENGTH - ITALIC_MARKER_LENGTH), baseColor)));
+            }
+            else if (fullMatch.endsWith('**') &&
+                fullMatch.startsWith('**') &&
+                fullMatch.length > BOLD_MARKER_LENGTH * 2) {
+                styledPart = chalk.bold(parseMarkdownToANSI(fullMatch.slice(BOLD_MARKER_LENGTH, -BOLD_MARKER_LENGTH), baseColor));
+            }
+            else if (fullMatch.length > ITALIC_MARKER_LENGTH * 2 &&
+                ((fullMatch.startsWith('*') && fullMatch.endsWith('*')) ||
+                    (fullMatch.startsWith('_') && fullMatch.endsWith('_'))) &&
+                !/\w/.test(text.substring(match.index - 1, match.index)) &&
+                !/\w/.test(text.substring(inlineRegex.lastIndex, inlineRegex.lastIndex + 1)) &&
+                !/\S[./\\]/.test(text.substring(match.index - 2, match.index)) &&
+                !/[./\\]\S/.test(text.substring(inlineRegex.lastIndex, inlineRegex.lastIndex + 2))) {
+                styledPart = chalk.italic(parseMarkdownToANSI(fullMatch.slice(ITALIC_MARKER_LENGTH, -ITALIC_MARKER_LENGTH), baseColor));
+            }
+            else if (fullMatch.startsWith('~~') &&
+                fullMatch.endsWith('~~') &&
+                fullMatch.length > STRIKETHROUGH_MARKER_LENGTH * 2) {
+                styledPart = chalk.strikethrough(parseMarkdownToANSI(fullMatch.slice(STRIKETHROUGH_MARKER_LENGTH, -STRIKETHROUGH_MARKER_LENGTH), baseColor));
+            }
+            else if (fullMatch.startsWith('`') &&
+                fullMatch.endsWith('`') &&
+                fullMatch.length > INLINE_CODE_MARKER_LENGTH) {
+                const codeMatch = fullMatch.match(/^(`+)(.+?)\1$/s);
+                if (codeMatch && codeMatch[2]) {
+                    styledPart = ansiColorize(codeMatch[2], theme.text.accent);
+                }
+            }
+            else if (fullMatch.startsWith('[') &&
+                fullMatch.includes('](') &&
+                fullMatch.endsWith(')')) {
+                const linkMatch = fullMatch.match(/\[(.*?)\]\((.*?)\)/);
+                if (linkMatch) {
+                    const linkText = linkMatch[1];
+                    const url = linkMatch[2];
+                    styledPart =
+                        parseMarkdownToANSI(linkText, baseColor) +
+                            ansiColorize(' (', baseColor) +
+                            ansiColorize(url, theme.text.link) +
+                            ansiColorize(')', baseColor);
+                }
+            }
+            else if (fullMatch.startsWith('<u>') &&
+                fullMatch.endsWith('</u>') &&
+                fullMatch.length >
+                    UNDERLINE_TAG_START_LENGTH + UNDERLINE_TAG_END_LENGTH - 1) {
+                styledPart = chalk.underline(parseMarkdownToANSI(fullMatch.slice(UNDERLINE_TAG_START_LENGTH, -UNDERLINE_TAG_END_LENGTH), baseColor));
+            }
+            else if (fullMatch.match(/^https?:\/\//)) {
+                styledPart = ansiColorize(fullMatch, theme.text.link);
+            }
+        }
+        catch (e) {
+            debugLogger.warn('Error parsing inline markdown part:', fullMatch, e);
+            styledPart = '';
+        }
+        result += styledPart || ansiColorize(fullMatch, baseColor);
+        lastIndex = inlineRegex.lastIndex;
+    }
+    if (lastIndex < text.length) {
+        result += ansiColorize(text.slice(lastIndex), baseColor);
+    }
+    return result;
+};

package/dist/ui/utils/markdownUtilities.js

@@ -0,0 +1,109 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/*
+**Background & Purpose:**
+
+The `findSafeSplitPoint` function is designed to address the challenge of displaying or processing large, potentially streaming, pieces of Markdown text. When content (e.g., from an LLM like Gemini) arrives in chunks or grows too large for a single display unit (like a message bubble), it needs to be split. A naive split (e.g., just at a character limit) can break Markdown formatting, especially critical for multi-line elements like code blocks, lists, or blockquotes, leading to incorrect rendering.
+
+This function aims to find an *intelligent* or "safe" index within the provided `content` string at which to make such a split, prioritizing the preservation of Markdown integrity.
+
+**Key Expectations & Behavior (Prioritized):**
+
+1.  **No Split if Short Enough:**
+    * If `content.length` is less than or equal to `idealMaxLength`, the function should return `content.length` (indicating no split is necessary for length reasons).
+
+2.  **Code Block Integrity (Highest Priority for Safety):**
+    * The function must try to avoid splitting *inside* a fenced code block (i.e., between ` ``` ` and ` ``` `).
+    * If `idealMaxLength` falls within a code block:
+        * The function will attempt to return an index that splits the content *before* the start of that code block.
+        * If a code block starts at the very beginning of the `content` and `idealMaxLength` falls within it (meaning the block itself is too long for the first chunk), the function might return `0`. This effectively makes the first chunk empty, pushing the entire oversized code block to the second part of the split.
+    * When considering splits near code blocks, the function prefers to keep the entire code block intact in one of the resulting chunks.
+
+3.  **Markdown-Aware Newline Splitting (If Not Governed by Code Block Logic):**
+    * If `idealMaxLength` does not fall within a code block (or after code block considerations have been made), the function will look for natural break points by scanning backwards from `idealMaxLength`:
+        * **Paragraph Breaks:** It prioritizes splitting after a double newline (`\n\n`), as this typically signifies the end of a paragraph or a block-level element.
+        * **Single Line Breaks:** If no double newline is found in a suitable range, it will look for a single newline (`\n`).
+    * Any newline chosen as a split point must also not be inside a code block.
+
+4.  **Fall back to `idealMaxLength`:**
+    * If no "safer" split point (respecting code blocks or finding suitable newlines) is identified before or at `idealMaxLength`, and `idealMaxLength` itself is not determined to be an unsafe split point (e.g., inside a code block), the function may return a length larger than `idealMaxLength`, again it CANNOT break markdown formatting. This could happen with very long lines of text without Markdown block structures or newlines.
+
+**In essence, `findSafeSplitPoint` tries to be a good Markdown citizen when forced to divide content, preferring structural boundaries over arbitrary character limits, with a strong emphasis on not corrupting code blocks.**
+*/
+/**
+ * Checks if a given character index within a string is inside a fenced (```) code block.
+ * @param content The full string content.
+ * @param indexToTest The character index to test.
+ * @returns True if the index is inside a code block's content, false otherwise.
+ */
+const isIndexInsideCodeBlock = (content, indexToTest) => {
+    let fenceCount = 0;
+    let searchPos = 0;
+    while (searchPos < content.length) {
+        const nextFence = content.indexOf('```', searchPos);
+        if (nextFence === -1 || nextFence >= indexToTest) {
+            break;
+        }
+        fenceCount++;
+        searchPos = nextFence + 3;
+    }
+    return fenceCount % 2 === 1;
+};
+/**
+ * Finds the starting index of the code block that encloses the given index.
+ * Returns -1 if the index is not inside a code block.
+ * @param content The markdown content.
+ * @param index The index to check.
+ * @returns Start index of the enclosing code block or -1.
+ */
+const findEnclosingCodeBlockStart = (content, index) => {
+    if (!isIndexInsideCodeBlock(content, index)) {
+        return -1;
+    }
+    let currentSearchPos = 0;
+    while (currentSearchPos < index) {
+        const blockStartIndex = content.indexOf('```', currentSearchPos);
+        if (blockStartIndex === -1 || blockStartIndex >= index) {
+            break;
+        }
+        const blockEndIndex = content.indexOf('```', blockStartIndex + 3);
+        if (blockStartIndex < index) {
+            if (blockEndIndex === -1 || index < blockEndIndex + 3) {
+                return blockStartIndex;
+            }
+        }
+        if (blockEndIndex === -1)
+            break;
+        currentSearchPos = blockEndIndex + 3;
+    }
+    return -1;
+};
+export const findLastSafeSplitPoint = (content) => {
+    const enclosingBlockStart = findEnclosingCodeBlockStart(content, content.length);
+    if (enclosingBlockStart !== -1) {
+        // The end of the content is contained in a code block. Split right before.
+        return enclosingBlockStart;
+    }
+    // Search for the last double newline (\n\n) not in a code block.
+    let searchStartIndex = content.length;
+    while (searchStartIndex >= 0) {
+        const dnlIndex = content.lastIndexOf('\n\n', searchStartIndex);
+        if (dnlIndex === -1) {
+            // No more double newlines found.
+            break;
+        }
+        const potentialSplitPoint = dnlIndex + 2;
+        if (!isIndexInsideCodeBlock(content, potentialSplitPoint)) {
+            return potentialSplitPoint;
+        }
+        // If potentialSplitPoint was inside a code block,
+        // the next search should start *before* the \n\n we just found to ensure progress.
+        searchStartIndex = dnlIndex - 1;
+    }
+    // If no safe double newline is found, return content.length
+    // to keep the entire content as one piece.
+    return content.length;
+};

package/dist/ui/utils/memorySnapshot.js

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createWriteStream } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import { getHeapSnapshot } from 'node:v8';
+/**
+ * RSS threshold at which `/bug` auto-captures a heap snapshot.
+ */
+export const MEMORY_SNAPSHOT_AUTO_THRESHOLD_BYTES = 2 * 1024 * 1024 * 1024;
+/**
+ * Capture a V8 heap snapshot from the current process and write it to disk.
+ *
+ * `v8.getHeapSnapshot()` returns a Readable stream whose producer is V8's
+ * internal snapshot generator. Piping it through `node:stream/promises`'
+ * `pipeline` propagates backpressure end-to-end, so even a multi-gigabyte
+ * heap is written without buffering the serialized snapshot in memory.
+ * Nothing is exposed over a debugger port.
+ */
+export async function captureHeapSnapshot(filePath) {
+    await mkdir(dirname(filePath), { recursive: true });
+    await pipeline(getHeapSnapshot(), createWriteStream(filePath));
+}

package/dist/ui/utils/mouse.js

@@ -0,0 +1,182 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { enableMouseEvents, disableMouseEvents } from '@google/gemini-cli-core';
+import { SGR_MOUSE_REGEX, X11_MOUSE_REGEX, SGR_EVENT_PREFIX, X11_EVENT_PREFIX, couldBeMouseSequence as inputCouldBeMouseSequence, } from './input.js';
+export const DOUBLE_CLICK_THRESHOLD_MS = 400;
+export const DOUBLE_CLICK_DISTANCE_TOLERANCE = 2;
+export function getMouseEventName(buttonCode, isRelease) {
+    const isMove = (buttonCode & 32) !== 0;
+    if (buttonCode === 66) {
+        return 'scroll-left';
+    }
+    else if (buttonCode === 67) {
+        return 'scroll-right';
+    }
+    else if ((buttonCode & 64) === 64) {
+        if ((buttonCode & 1) === 0) {
+            return 'scroll-up';
+        }
+        else {
+            return 'scroll-down';
+        }
+    }
+    else if (isMove) {
+        return 'move';
+    }
+    else {
+        const button = buttonCode & 3;
+        const type = isRelease ? 'release' : 'press';
+        switch (button) {
+            case 0:
+                return `left-${type}`;
+            case 1:
+                return `middle-${type}`;
+            case 2:
+                return `right-${type}`;
+            default:
+                return null;
+        }
+    }
+}
+function getButtonFromCode(code) {
+    const button = code & 3;
+    switch (button) {
+        case 0:
+            return 'left';
+        case 1:
+            return 'middle';
+        case 2:
+            return 'right';
+        default:
+            return 'none';
+    }
+}
+export function parseSGRMouseEvent(buffer) {
+    const match = buffer.match(SGR_MOUSE_REGEX);
+    if (match) {
+        const buttonCode = parseInt(match[1], 10);
+        const col = parseInt(match[2], 10);
+        const row = parseInt(match[3], 10);
+        const action = match[4];
+        const isRelease = action === 'm';
+        const shift = (buttonCode & 4) !== 0;
+        const meta = (buttonCode & 8) !== 0;
+        const ctrl = (buttonCode & 16) !== 0;
+        const name = getMouseEventName(buttonCode, isRelease);
+        if (name) {
+            return {
+                event: {
+                    name,
+                    ctrl,
+                    meta,
+                    shift,
+                    col,
+                    row,
+                    button: getButtonFromCode(buttonCode),
+                },
+                length: match[0].length,
+            };
+        }
+        return null;
+    }
+    return null;
+}
+export function parseX11MouseEvent(buffer) {
+    const match = buffer.match(X11_MOUSE_REGEX);
+    if (!match)
+        return null;
+    // The 3 bytes are in match[1]
+    const b = match[1].charCodeAt(0) - 32;
+    const col = match[1].charCodeAt(1) - 32;
+    const row = match[1].charCodeAt(2) - 32;
+    const shift = (b & 4) !== 0;
+    const meta = (b & 8) !== 0;
+    const ctrl = (b & 16) !== 0;
+    const isMove = (b & 32) !== 0;
+    const isWheel = (b & 64) !== 0;
+    let name = null;
+    if (isWheel) {
+        const button = b & 3;
+        switch (button) {
+            case 0:
+                name = 'scroll-up';
+                break;
+            case 1:
+                name = 'scroll-down';
+                break;
+            default:
+                break;
+        }
+    }
+    else if (isMove) {
+        name = 'move';
+    }
+    else {
+        const button = b & 3;
+        if (button === 3) {
+            // X11 reports 'release' (3) for all button releases without specifying which one.
+            // We'll default to 'left-release' as a best-effort guess if we don't track state.
+            name = 'left-release';
+        }
+        else {
+            switch (button) {
+                case 0:
+                    name = 'left-press';
+                    break;
+                case 1:
+                    name = 'middle-press';
+                    break;
+                case 2:
+                    name = 'right-press';
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    if (name) {
+        let button = getButtonFromCode(b);
+        if (name === 'left-release' && button === 'none') {
+            button = 'left';
+        }
+        return {
+            event: {
+                name,
+                ctrl,
+                meta,
+                shift,
+                col,
+                row,
+                button,
+            },
+            length: match[0].length,
+        };
+    }
+    return null;
+}
+export function parseMouseEvent(buffer) {
+    return parseSGRMouseEvent(buffer) || parseX11MouseEvent(buffer);
+}
+export function isIncompleteMouseSequence(buffer) {
+    if (!inputCouldBeMouseSequence(buffer))
+        return false;
+    // If it matches a complete sequence, it's not incomplete.
+    if (parseMouseEvent(buffer))
+        return false;
+    if (buffer.startsWith(X11_EVENT_PREFIX)) {
+        // X11 needs exactly 3 bytes after prefix.
+        return buffer.length < X11_EVENT_PREFIX.length + 3;
+    }
+    if (buffer.startsWith(SGR_EVENT_PREFIX)) {
+        // SGR sequences end with 'm' or 'M'.
+        // If it doesn't have it yet, it's incomplete.
+        // Add a reasonable max length check to fail early on garbage.
+        return !/[mM]/.test(buffer) && buffer.length < 50;
+    }
+    // It's a prefix of the prefix (e.g. "ESC" or "ESC [")
+    return true;
+}
+export { enableMouseEvents, disableMouseEvents };

package/dist/ui/utils/pendingAttentionNotification.js

@@ -0,0 +1,97 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { getConfirmingToolState } from './confirmingTool.js';
+function keyFromReactNode(node) {
+    if (typeof node === 'string' || typeof node === 'number') {
+        return String(node);
+    }
+    if (Array.isArray(node)) {
+        return node.map((item) => keyFromReactNode(item)).join('|');
+    }
+    return 'react-node';
+}
+export function getPendingAttentionNotification(pendingHistoryItems, commandConfirmationRequest, authConsentRequest, permissionConfirmationRequest, hasConfirmUpdateExtensionRequests, hasLoopDetectionConfirmationRequest) {
+    const confirmingToolState = getConfirmingToolState(pendingHistoryItems);
+    if (confirmingToolState) {
+        const details = confirmingToolState.tool.confirmationDetails;
+        if (details?.type === 'ask_user') {
+            const firstQuestion = details.questions.at(0)?.header;
+            return {
+                key: `ask_user:${confirmingToolState.tool.callId}`,
+                event: {
+                    type: 'attention',
+                    heading: 'Answer requested by agent',
+                    detail: firstQuestion || 'The agent needs your response to continue.',
+                },
+            };
+        }
+        const toolTitle = details?.title || confirmingToolState.tool.description;
+        return {
+            key: `tool_confirmation:${confirmingToolState.tool.callId}`,
+            event: {
+                type: 'attention',
+                heading: 'Approval required',
+                detail: toolTitle
+                    ? `Approve tool action: ${toolTitle}`
+                    : 'Approve a pending tool action to continue.',
+            },
+        };
+    }
+    if (commandConfirmationRequest) {
+        const promptKey = keyFromReactNode(commandConfirmationRequest.prompt);
+        return {
+            key: `command_confirmation:${promptKey}`,
+            event: {
+                type: 'attention',
+                heading: 'Confirmation required',
+                detail: 'A command is waiting for your confirmation.',
+            },
+        };
+    }
+    if (authConsentRequest) {
+        const promptKey = keyFromReactNode(authConsentRequest.prompt);
+        return {
+            key: `auth_consent:${promptKey}`,
+            event: {
+                type: 'attention',
+                heading: 'Authentication confirmation required',
+                detail: 'Authentication is waiting for your confirmation.',
+            },
+        };
+    }
+    if (permissionConfirmationRequest) {
+        const filesKey = permissionConfirmationRequest.files.join('|');
+        return {
+            key: `filesystem_permission_confirmation:${filesKey}`,
+            event: {
+                type: 'attention',
+                heading: 'Filesystem permission required',
+                detail: 'Read-only path access is waiting for your confirmation.',
+            },
+        };
+    }
+    if (hasConfirmUpdateExtensionRequests) {
+        return {
+            key: 'extension_update_confirmation',
+            event: {
+                type: 'attention',
+                heading: 'Extension update confirmation required',
+                detail: 'An extension update is waiting for your confirmation.',
+            },
+        };
+    }
+    if (hasLoopDetectionConfirmationRequest) {
+        return {
+            key: 'loop_detection_confirmation',
+            event: {
+                type: 'attention',
+                heading: 'Loop detection confirmation required',
+                detail: 'A loop detection prompt is waiting for your response.',
+            },
+        };
+    }
+    return null;
+}