@codingame/monaco-vscode-katex-common 30.0.1 → 31.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/toolInvocationParts/chatToolConfirmationCarouselPart.d.ts

@@ -0,0 +1,53 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IChatToolInvocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
+import { ChatToolInvocationPart } from "./chatToolInvocationPart.js";
+export type ToolInvocationPartFactory = (tool: IChatToolInvocation) => ChatToolInvocationPart;
+export type ScrollToSubagentCallback = (subAgentInvocationId: string) => void;
+export declare class ChatToolConfirmationCarouselPart extends Disposable {
+    private readonly toolPartFactory;
+    private readonly scrollToSubagent?;
+    private readonly initialSubAgentInvocationId?;
+    private readonly initialAgentName?;
+    readonly domNode: HTMLElement;
+    private readonly _onDidEmpty;
+    readonly onDidEmpty: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    private readonly items;
+    private readonly toolCallIds;
+    private activeIndex;
+    private readonly collapsedTitle;
+    private readonly agentLabel;
+    private readonly contentContainer;
+    private readonly stepIndicator;
+    private readonly prevButton;
+    private readonly nextButton;
+    private readonly allowAllButton;
+    private readonly dismissButton;
+    private readonly activeContentDisposables;
+    private maxHeight;
+    constructor(toolPartFactory: ToolInvocationPartFactory, initialTools: IChatToolInvocation[], scrollToSubagent?: ScrollToSubagentCallback | undefined, initialSubAgentInvocationId?: string | undefined, initialAgentName?: string | undefined);
+    get pendingCount(): number;
+    setMaxHeight(maxHeight: number | undefined): void;
+    hasToolInvocation(toolCallId: string): boolean;
+    addToolInvocation(tool: IChatToolInvocation, subAgentInvocationId?: string, agentName?: string, scrollToSubagent?: ScrollToSubagentCallback, toolPart?: ChatToolInvocationPart): void;
+    private replaceExternalToolPart;
+    private watchExternalToolPart;
+    dispose(): void;
+    private removeItem;
+    private setActiveIndex;
+    private navigateRelative;
+    private onKeydown;
+    private shouldIgnoreNavigationKeydown;
+    private focusActiveContent;
+    private updateUI;
+    private renderActiveContent;
+    private updateMaxHeightStyle;
+    private getCollapsedMaxHeight;
+    allowAll(): void;
+    private skipAll;
+    private getToolTitle;
+    private truncateTitle;
+    private toPlainText;
+    private basename;
+    private scrollToActiveSubagent;
+    activateFirstToolForSubagent(subAgentInvocationId: string): void;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/toolInvocationParts/chatToolConfirmationCarouselPart.js

@@ -0,0 +1,392 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { h, addDisposableListener, hide, isHTMLElement, setVisibility, show, clearNode, getWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { StandardKeyboardEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/keyboardEvent';
+import { Button } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { Disposable, DisposableStore, toDisposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { defaultButtonStyles } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/browser/defaultStyles';
+import { IChatToolInvocation, ToolConfirmKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
+import * as chatToolConfirmationCarousel from '../media/chatToolConfirmationCarousel.css';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+registerCss(chatToolConfirmationCarousel);
+const COLLAPSED_CAROUSEL_MAX_HEIGHT = 300;
+const MIN_CAROUSEL_MAX_HEIGHT = 80;
+class ChatToolConfirmationCarouselPart extends Disposable {
+    constructor(
+        toolPartFactory,
+        initialTools,
+        scrollToSubagent,
+        initialSubAgentInvocationId,
+        initialAgentName
+    ) {
+        super();
+        this.toolPartFactory = toolPartFactory;
+        this.scrollToSubagent = scrollToSubagent;
+        this.initialSubAgentInvocationId = initialSubAgentInvocationId;
+        this.initialAgentName = initialAgentName;
+        this._onDidEmpty = this._register(( new Emitter()));
+        this.onDidEmpty = this._onDidEmpty.event;
+        this.items = [];
+        this.toolCallIds = ( new Set());
+        this.activeIndex = 0;
+        const elements = h(".chat-tool-confirmation-carousel@root", [h(
+            ".chat-tool-carousel-overlay@overlay",
+            [h(".chat-tool-carousel-title-group@titleGroup", [
+                h("span.chat-tool-carousel-collapsed-title@collapsedTitle"),
+                h("button.chat-tool-carousel-agent-label@agentLabel")
+            ]), h(".chat-tool-carousel-overlay-actions@overlayActions", [
+                h(".chat-tool-carousel-step-indicator@stepIndicator"),
+                h(".chat-tool-carousel-nav-arrows@navArrows")
+            ])]
+        ), h(".chat-tool-carousel-content@content")]);
+        this.domNode = elements.root;
+        this.domNode.tabIndex = -1;
+        this.domNode.setAttribute("role", "group");
+        this.domNode.setAttribute("aria-label", ( localize(7077, "Tool confirmation carousel")));
+        this.collapsedTitle = elements.collapsedTitle;
+        this.agentLabel = elements.agentLabel;
+        this.contentContainer = elements.content;
+        this.stepIndicator = elements.stepIndicator;
+        this.activeContentDisposables = this._register(( new DisposableStore()));
+        this.allowAllButton = this._register(( new Button(elements.overlayActions, {
+            ...defaultButtonStyles,
+            small: true
+        })));
+        this.allowAllButton.element.classList.add("chat-tool-carousel-allow-all-button");
+        this.allowAllButton.label = ( localize(7078, "Allow All"));
+        this._register(this.allowAllButton.onDidClick(() => this.allowAll()));
+        this.dismissButton = this._register(( new Button(elements.overlayActions, {
+            ...defaultButtonStyles,
+            secondary: true,
+            supportIcons: true
+        })));
+        this.dismissButton.element.classList.add("chat-tool-carousel-dismiss-button");
+        this.dismissButton.label = `$(${Codicon.close.id})`;
+        const dismissButtonLabel = this.items.length === 1 ? ( localize(7079, "Skip")) : ( localize(7080, "Skip All"));
+        this.dismissButton.element.setAttribute("aria-label", dismissButtonLabel);
+        this.dismissButton.element.title = dismissButtonLabel;
+        this._register(this.dismissButton.onDidClick(() => this.skipAll()));
+        this.prevButton = this._register(( new Button(elements.navArrows, {
+            ...defaultButtonStyles,
+            secondary: true,
+            supportIcons: true
+        })));
+        this.prevButton.element.classList.add("chat-tool-carousel-nav-arrow");
+        this.prevButton.label = `$(${Codicon.chevronLeft.id})`;
+        this.prevButton.element.setAttribute("aria-label", ( localize(7081, "Previous")));
+        this._register(this.prevButton.onDidClick(() => this.navigateRelative(-1)));
+        this.nextButton = this._register(( new Button(elements.navArrows, {
+            ...defaultButtonStyles,
+            secondary: true,
+            supportIcons: true
+        })));
+        this.nextButton.element.classList.add("chat-tool-carousel-nav-arrow");
+        this.nextButton.label = `$(${Codicon.chevronRight.id})`;
+        this.nextButton.element.setAttribute("aria-label", ( localize(7082, "Next")));
+        this._register(this.nextButton.onDidClick(() => this.navigateRelative(1)));
+        this._register(addDisposableListener(this.agentLabel, "click", e => {
+            e.preventDefault();
+            this.scrollToActiveSubagent();
+        }));
+        this._register(addDisposableListener(this.domNode, "keydown", e => this.onKeydown(e)));
+        for (const tool of initialTools) {
+            this.addToolInvocation(
+                tool,
+                this.initialSubAgentInvocationId,
+                this.initialAgentName,
+                this.scrollToSubagent
+            );
+        }
+    }
+    get pendingCount() {
+        return this.items.length;
+    }
+    setMaxHeight(maxHeight) {
+        this.maxHeight = maxHeight;
+        this.updateMaxHeightStyle();
+    }
+    hasToolInvocation(toolCallId) {
+        return ( this.toolCallIds.has(toolCallId));
+    }
+    addToolInvocation(tool, subAgentInvocationId, agentName, scrollToSubagent, toolPart) {
+        if (( this.toolCallIds.has(tool.toolCallId))) {
+            const existing = this.items.find(item => item.toolCallId === tool.toolCallId);
+            if (existing && toolPart && !existing.toolPart) {
+                this.replaceExternalToolPart(existing, toolPart);
+            }
+            return;
+        }
+        this.toolCallIds.add(tool.toolCallId);
+        const disposables = ( new DisposableStore());
+        const item = {
+            tool,
+            toolCallId: tool.toolCallId,
+            disposables,
+            subAgentInvocationId,
+            agentName,
+            scrollToSubagent,
+            ownsToolPart: !toolPart,
+            toolPart
+        };
+        this.items.push(item);
+        if (toolPart) {
+            this.watchExternalToolPart(item, toolPart);
+        }
+        disposables.add(autorun(reader => {
+            const currentState = tool.state.read(reader);
+            if (currentState.type !== IChatToolInvocation.StateKind.WaitingForConfirmation) {
+                this.removeItem(tool.toolCallId);
+            }
+        }));
+        this.updateUI();
+        if (this.items.length === 1) {
+            this.setActiveIndex(0);
+        }
+    }
+    replaceExternalToolPart(item, toolPart) {
+        if (item.toolPart === toolPart) {
+            return;
+        }
+        if (item.toolPart && item.ownsToolPart) {
+            item.toolPart.dispose();
+        }
+        item.toolPart = toolPart;
+        item.ownsToolPart = false;
+        this.watchExternalToolPart(item, toolPart);
+        if (this.items[this.activeIndex] === item) {
+            this.renderActiveContent();
+        }
+    }
+    watchExternalToolPart(item, toolPart) {
+        let isItemAlive = true;
+        item.disposables.add(toDisposable(() => isItemAlive = false));
+        const externalPartDisposeWatcher = ( new MutableDisposable());
+        externalPartDisposeWatcher.value = toDisposable(() => {
+            if (!isItemAlive || item.toolPart !== toolPart) {
+                return;
+            }
+            item.toolPart = undefined;
+            item.ownsToolPart = true;
+            if (this.items[this.activeIndex] === item) {
+                this.renderActiveContent();
+            }
+        });
+        toolPart.addDisposable(externalPartDisposeWatcher);
+        item.disposables.add(toDisposable(() => externalPartDisposeWatcher.clear()));
+    }
+    dispose() {
+        for (const item of this.items) {
+            if (item.toolPart && item.ownsToolPart) {
+                item.toolPart.dispose();
+            }
+            item.disposables.dispose();
+        }
+        this.items.splice(0);
+        this.toolCallIds.clear();
+        super.dispose();
+    }
+    removeItem(toolCallId) {
+        const index = this.items.findIndex(i => i.toolCallId === toolCallId);
+        if (index < 0) {
+            return;
+        }
+        const [removed] = this.items.splice(index, 1);
+        this.toolCallIds.delete(toolCallId);
+        if (removed.toolPart && removed.ownsToolPart) {
+            removed.toolPart.dispose();
+        }
+        removed.disposables.dispose();
+        if (this.items.length === 0) {
+            hide(this.domNode);
+            this._onDidEmpty.fire();
+            return;
+        }
+        if (this.activeIndex >= this.items.length) {
+            this.activeIndex = this.items.length - 1;
+        }
+        this.updateUI();
+        this.renderActiveContent();
+    }
+    setActiveIndex(index) {
+        this.activeIndex = index;
+        this.updateUI();
+        this.renderActiveContent();
+    }
+    navigateRelative(delta) {
+        if (this.items.length <= 1) {
+            return;
+        }
+        const newIndex = (this.activeIndex + delta + this.items.length) % this.items.length;
+        this.setActiveIndex(newIndex);
+    }
+    onKeydown(e) {
+        if (this.items.length === 0) {
+            return;
+        }
+        if (this.shouldIgnoreNavigationKeydown(e.target)) {
+            return;
+        }
+        const event = ( new StandardKeyboardEvent(e));
+        const focusContentAfterNavigation = isHTMLElement(e.target) && this.contentContainer.contains(e.target);
+        let didNavigate = false;
+        switch (event.keyCode) {
+        case KeyCode.LeftArrow:
+            this.navigateRelative(-1);
+            didNavigate = true;
+            break;
+        case KeyCode.RightArrow:
+            this.navigateRelative(1);
+            didNavigate = true;
+            break;
+        case KeyCode.Home:
+            this.setActiveIndex(0);
+            didNavigate = true;
+            break;
+        case KeyCode.End:
+            this.setActiveIndex(this.items.length - 1);
+            didNavigate = true;
+            break;
+        }
+        if (!didNavigate) {
+            return;
+        }
+        e.preventDefault();
+        e.stopPropagation();
+        if (focusContentAfterNavigation) {
+            this.focusActiveContent();
+        }
+    }
+    shouldIgnoreNavigationKeydown(target) {
+        if (!isHTMLElement(target)) {
+            return false;
+        }
+        return !!target.closest(
+            ".monaco-editor, .interactive-result-editor, .chat-confirmation-widget-message, input, textarea, select, [contenteditable=\"true\"]"
+        );
+    }
+    focusActiveContent() {
+        this.domNode.focus();
+    }
+    updateUI() {
+        const item = this.items[this.activeIndex];
+        this.collapsedTitle.textContent = this.getToolTitle(item) ?? "";
+        setVisibility(!!this.collapsedTitle.textContent, this.collapsedTitle);
+        if (item?.agentName) {
+            this.agentLabel.textContent = `\u2014 ${item.agentName}`;
+            this.agentLabel.disabled = !item.subAgentInvocationId || !item.scrollToSubagent;
+            this.agentLabel.title = ( localize(7083, "Scroll to {0}", item.agentName));
+            this.agentLabel.setAttribute("aria-label", this.agentLabel.title);
+            show(this.agentLabel);
+        } else {
+            this.agentLabel.textContent = "";
+            this.agentLabel.title = "";
+            this.agentLabel.removeAttribute("aria-label");
+            hide(this.agentLabel);
+        }
+        this.stepIndicator.textContent = `${this.activeIndex + 1}/${this.items.length}`;
+        const multi = this.items.length > 1;
+        this.prevButton.enabled = multi;
+        this.nextButton.enabled = multi;
+        setVisibility(multi, this.stepIndicator);
+        setVisibility(multi, this.prevButton.element);
+        setVisibility(multi, this.nextButton.element);
+        setVisibility(multi, this.allowAllButton.element);
+        this.allowAllButton.label = multi ? ( localize(7078, "Allow All")) : ( localize(7084, "Allow"));
+    }
+    renderActiveContent() {
+        clearNode(this.contentContainer);
+        this.activeContentDisposables.clear();
+        const item = this.items[this.activeIndex];
+        if (!item) {
+            return;
+        }
+        if (!item.toolPart) {
+            item.toolPart = this.toolPartFactory(item.tool);
+            if (item.ownsToolPart) {
+                item.disposables.add(item.toolPart);
+            }
+        }
+        this.contentContainer.appendChild(item.toolPart.domNode);
+    }
+    updateMaxHeightStyle() {
+        if (this.maxHeight === undefined) {
+            this.domNode.style.removeProperty("max-height");
+            return;
+        }
+        const maxHeight = this.getCollapsedMaxHeight();
+        this.domNode.style.maxHeight = `${Math.floor(maxHeight)}px`;
+    }
+    getCollapsedMaxHeight() {
+        const configuredMaxHeight = this.maxHeight === undefined ? Number.POSITIVE_INFINITY : Math.max(MIN_CAROUSEL_MAX_HEIGHT, this.maxHeight);
+        return Math.min(
+            configuredMaxHeight,
+            COLLAPSED_CAROUSEL_MAX_HEIGHT,
+            getWindow(this.domNode).innerHeight * 0.45
+        );
+    }
+    allowAll() {
+        for (const item of [...this.items]) {
+            IChatToolInvocation.confirmWith(item.tool, {
+                type: ToolConfirmKind.UserAction
+            });
+        }
+    }
+    skipAll() {
+        for (const item of [...this.items]) {
+            IChatToolInvocation.confirmWith(item.tool, {
+                type: ToolConfirmKind.Skipped
+            });
+        }
+    }
+    getToolTitle(item) {
+        if (!item) {
+            return undefined;
+        }
+        const messages = IChatToolInvocation.getConfirmationMessages(item.tool);
+        if (!messages?.title) {
+            return undefined;
+        }
+        return this.truncateTitle(this.toPlainText(messages.title));
+    }
+    truncateTitle(text) {
+        text = text.replace(/\s+/g, " ").trim();
+        const maxLength = 100;
+        return text.length > maxLength ? `${text.substring(0, maxLength)}\u2026` : text;
+    }
+    toPlainText(message) {
+        const markdown = typeof message === "string" ? message : message.value;
+        return markdown.replace(
+            /\[([^\]]*)\]\(([^)]+)\)/g,
+            (_match, text, url) => text || this.basename(url)
+        ).replace(/\*\*([^*]+)\*\*/g, "$1").replace(/__([^_]+)__/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/[\\*_#>]/g, "");
+    }
+    basename(url) {
+        try {
+            const path = decodeURIComponent(url.split("?")[0].split("#")[0]);
+            const segments = path.split("/").filter(Boolean);
+            return segments.at(-1) ?? url;
+        } catch {
+            return url;
+        }
+    }
+    scrollToActiveSubagent() {
+        const item = this.items[this.activeIndex];
+        if (item?.subAgentInvocationId) {
+            item.scrollToSubagent?.(item.subAgentInvocationId);
+        }
+    }
+    activateFirstToolForSubagent(subAgentInvocationId) {
+        const index = this.items.findIndex(i => i.subAgentInvocationId === subAgentInvocationId);
+        if (index >= 0) {
+            this.setActiveIndex(index);
+        }
+    }
+}
+
+export { ChatToolConfirmationCarouselPart };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/toolInvocationParts/chatToolConfirmationSubPart.d.ts

@@ -7,7 +7,6 @@ import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platf
 import { IMarkdownRenderer } from "@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer";
 import { IMarkerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers.service";
 import { IChatToolInvocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
-import { CodeBlockModelCollection } from "../../../../common/widget/codeBlockModelCollection.js";
 import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service";
 import { ILanguageModelToolsConfirmationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsConfirmationService.service";
 import { IChatCodeBlockInfo } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
@@ -20,7 +19,6 @@ export declare class ToolConfirmationSubPart extends AbstractToolConfirmationSub
     private readonly renderer;
     private readonly editorPool;
     private readonly currentWidthDelegate;
-    private readonly codeBlockModelCollection;
     private readonly codeBlockStartIndex;
     private readonly languageService;
     private readonly commandService;
@@ -29,7 +27,7 @@ export declare class ToolConfirmationSubPart extends AbstractToolConfirmationSub
     private readonly confirmationService;
     private markdownParts;
     get codeblocks(): IChatCodeBlockInfo[];
-    constructor(toolInvocation: IChatToolInvocation, context: IChatContentPartRenderContext, renderer: IMarkdownRenderer, editorPool: EditorPool, currentWidthDelegate: () => number, codeBlockModelCollection: CodeBlockModelCollection, codeBlockStartIndex: number, instantiationService: IInstantiationService, keybindingService: IKeybindingService, languageService: ILanguageService, contextKeyService: IContextKeyService, chatWidgetService: IChatWidgetService, commandService: ICommandService, markerService: IMarkerService, languageModelToolsService: ILanguageModelToolsService, chatMarkdownAnchorService: IChatMarkdownAnchorService, confirmationService: ILanguageModelToolsConfirmationService);
+    constructor(toolInvocation: IChatToolInvocation, context: IChatContentPartRenderContext, renderer: IMarkdownRenderer, editorPool: EditorPool, currentWidthDelegate: () => number, codeBlockStartIndex: number, instantiationService: IInstantiationService, keybindingService: IKeybindingService, languageService: ILanguageService, contextKeyService: IContextKeyService, chatWidgetService: IChatWidgetService, commandService: ICommandService, markerService: IMarkerService, languageModelToolsService: ILanguageModelToolsService, chatMarkdownAnchorService: IChatMarkdownAnchorService, confirmationService: ILanguageModelToolsConfirmationService);
     protected additionalPrimaryActions(): (Separator | import("./abstractToolConfirmationSubPart.js").IAbstractToolPrimaryAction)[];
     protected useAllowOnceAsPrimary(): boolean;
     protected createContentElement(): HTMLElement | string;

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/toolInvocationParts/chatToolConfirmationSubPart.js

@@ -18,12 +18,13 @@ import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platf
 import { MarkerSeverity } from '@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers';
 import { IMarkerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers.service';
 import { IChatToolInvocation, ToolConfirmKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
-import { createToolInputUri, createToolSchemaUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+import { createToolSchemaUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
 import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
 import { ILanguageModelToolsConfirmationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsConfirmationService.service';
 import { SkipToolConfirmationActionId, AcceptToolConfirmationActionId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatConstants';
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
 import { renderFileWidgets } from '../chatInlineAnchorWidget.js';
+import { CodeBlockPart } from '../codeBlockPart.js';
 import { IChatMarkdownAnchorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatMarkdownAnchorService.service';
 import { ChatMarkdownContentPart } from '../chatMarkdownContentPart.js';
 import { AbstractToolConfirmationSubPart } from './abstractToolConfirmationSubPart.js';
@@ -39,7 +40,6 @@ let ToolConfirmationSubPart = class ToolConfirmationSubPart extends AbstractTool
         renderer,
         editorPool,
         currentWidthDelegate,
-        codeBlockModelCollection,
         codeBlockStartIndex,
         instantiationService,
         keybindingService,
@@ -68,7 +68,6 @@ let ToolConfirmationSubPart = class ToolConfirmationSubPart extends AbstractTool
         this.renderer = renderer;
         this.editorPool = editorPool;
         this.currentWidthDelegate = currentWidthDelegate;
-        this.codeBlockModelCollection = codeBlockModelCollection;
         this.codeBlockStartIndex = codeBlockStartIndex;
         this.languageService = languageService;
         this.commandService = commandService;
@@ -79,8 +78,8 @@ let ToolConfirmationSubPart = class ToolConfirmationSubPart extends AbstractTool
         this.render({
             allowActionId: AcceptToolConfirmationActionId,
             skipActionId: SkipToolConfirmationActionId,
-            allowLabel: state.confirmationMessages.confirmResults ? ( localize(6965, "Allow and Review Once")) : ( localize(6966, "Allow Once")),
-            skipLabel: ( localize(6967, "Proceed without running this tool")),
+            allowLabel: state.confirmationMessages.confirmResults ? ( localize(7085, "Allow and Review Once")) : ( localize(7086, "Allow Once")),
+            skipLabel: ( localize(7087, "Proceed without running this tool")),
             partType: "chatToolConfirmation",
             subtitle: typeof toolInvocation.originMessage === "string" ? toolInvocation.originMessage : toolInvocation.originMessage?.value
         });
@@ -95,7 +94,8 @@ let ToolConfirmationSubPart = class ToolConfirmationSubPart extends AbstractTool
             const approveCombination = state.confirmationMessages?.approveCombination;
             const combination = approveCombination ? {
                 label: typeof approveCombination.label === "string" ? approveCombination.label : approveCombination.label.value,
-                key: approveCombination.key
+                key: approveCombination.key,
+                arguments: approveCombination.arguments
             } : undefined;
             const confirmActions = this.confirmationService.getPreConfirmActions({
                 toolId: this.toolInvocation.toolId,
@@ -125,7 +125,7 @@ let ToolConfirmationSubPart = class ToolConfirmationSubPart extends AbstractTool
         }
         if (state.confirmationMessages?.confirmResults) {
             actions.unshift({
-                label: ( localize(6968, "Allow and Skip Reviewing Result")),
+                label: ( localize(7088, "Allow and Skip Reviewing Result")),
                 data: () => {
                     state.confirmationMessages.confirmResults = undefined;
                     this.confirmWith(this.toolInvocation, {
@@ -167,11 +167,11 @@ let ToolConfirmationSubPart = class ToolConfirmationSubPart extends AbstractTool
             };
             const elements = h("div", [h(".message@messageContainer", [
                 h(".message-wrapper@message"),
-                h(".see-more@showMore", [h("a", [( localize(6969, "Show More"))])])
+                h(".see-more@showMore", [h("a", [( localize(7089, "Show More"))])])
             ]), h(".editor@editor"), h(".disclaimer@disclaimer")]);
             if (toolInvocation.toolSpecificData?.kind === "input" && toolInvocation.toolSpecificData.rawInput && !isEmptyObject(toolInvocation.toolSpecificData.rawInput)) {
                 const titleEl = createElement("h3");
-                titleEl.textContent = ( localize(6970, "Input"));
+                titleEl.textContent = ( localize(7090, "Input"));
                 elements.editor.appendChild(titleEl);
                 const inputData = toolInvocation.toolSpecificData;
                 const codeBlockRenderOptions = {
@@ -188,13 +188,18 @@ let ToolConfirmationSubPart = class ToolConfirmationSubPart extends AbstractTool
                 const langId = this.languageService.getLanguageIdByLanguageName("json");
                 const rawJsonInput = JSON.stringify(inputData.rawInput ?? {}, null, 1);
                 const canSeeMore = count(rawJsonInput, "\n") > 2;
-                const modelRef = this._register(this.context.inlineTextModels.acquire(
-                    createToolInputUri(toolInvocation.toolCallId),
-                    rawJsonInput.replace(/\n */g, " "),
-                    this.languageService.createById(langId),
-                    true
-                ));
-                const model = modelRef.object;
+                const initialText = rawJsonInput.replace(/\n */g, " ");
+                const key = CodeBlockPart.poolKey(this.context.element.id, this.codeBlockStartIndex);
+                const editor = this._register(this.editorPool.get(key));
+                editor.object.render({
+                    codeBlockIndex: this.codeBlockStartIndex,
+                    element: this.context.element,
+                    languageId: langId ?? "json",
+                    text: initialText,
+                    renderOptions: codeBlockRenderOptions,
+                    chatSessionResource: this.context.element.sessionResource
+                }, this.currentWidthDelegate());
+                const model = editor.object.editor.getModel();
                 const markerOwner = generateUuid();
                 const schemaUri = createToolSchemaUri(toolInvocation.toolId);
                 const validator = ( new RunOnceScheduler(async () => {
@@ -219,16 +224,6 @@ let ToolConfirmationSubPart = class ToolConfirmationSubPart extends AbstractTool
                 this._register(model.onDidChangeContent(() => validator.schedule()));
                 this._register(toDisposable(() => this.markerService.remove(markerOwner, [model.uri])));
                 this._register(validator);
-                const editor = this._register(this.editorPool.get());
-                editor.object.render({
-                    codeBlockIndex: this.codeBlockStartIndex,
-                    codeBlockPartIndex: 0,
-                    element: this.context.element,
-                    languageId: langId ?? "json",
-                    renderOptions: codeBlockRenderOptions,
-                    textModel: Promise.resolve(model),
-                    chatSessionResource: this.context.element.sessionResource
-                }, this.currentWidthDelegate());
                 this.codeblocks.push({
                     codeBlockIndex: this.codeBlockStartIndex,
                     codemapperUri: undefined,
@@ -236,7 +231,6 @@ let ToolConfirmationSubPart = class ToolConfirmationSubPart extends AbstractTool
                     focus: () => editor.object.focus(),
                     ownerMarkdownPartId: this.codeblocksPartId,
                     uri: model.uri,
-                    uriPromise: Promise.resolve(model.uri),
                     chatSessionResource: this.context.element.sessionResource
                 });
                 this._register(model.onDidChangeContent(e => {
@@ -247,7 +241,7 @@ let ToolConfirmationSubPart = class ToolConfirmationSubPart extends AbstractTool
                 elements.editor.append(editor.object.element);
                 if (canSeeMore) {
                     const seeMore = h("div.see-more", [h("a@link")]);
-                    seeMore.link.textContent = ( localize(6971, "See more"));
+                    seeMore.link.textContent = ( localize(7091, "See more"));
                     this._register(addDisposableGenericMouseDownListener(seeMore.link, () => {
                         try {
                             const parsed = JSON.parse(model.getValue());
@@ -301,7 +295,7 @@ let ToolConfirmationSubPart = class ToolConfirmationSubPart extends AbstractTool
         const part = this._register(this.instantiationService.createInstance(ChatMarkdownContentPart, {
             kind: "markdownContent",
             content: typeof message === "string" ? ( new MarkdownString()).appendMarkdown(message) : message
-        }, this.context, this.editorPool, false, this.codeBlockStartIndex, this.renderer, undefined, this.currentWidthDelegate(), this.codeBlockModelCollection, {
+        }, this.context, this.editorPool, false, this.codeBlockStartIndex, this.renderer, undefined, this.currentWidthDelegate(), {
             codeBlockRenderOptions
         }));
         renderFileWidgets(
@@ -314,6 +308,6 @@ let ToolConfirmationSubPart = class ToolConfirmationSubPart extends AbstractTool
         return part;
     }
 };
-ToolConfirmationSubPart = ( __decorate([( __param(7, IInstantiationService)), ( __param(8, IKeybindingService)), ( __param(9, ILanguageService)), ( __param(10, IContextKeyService)), ( __param(11, IChatWidgetService)), ( __param(12, ICommandService)), ( __param(13, IMarkerService)), ( __param(14, ILanguageModelToolsService)), ( __param(15, IChatMarkdownAnchorService)), ( __param(16, ILanguageModelToolsConfirmationService))], ToolConfirmationSubPart));
+ToolConfirmationSubPart = ( __decorate([( __param(6, IInstantiationService)), ( __param(7, IKeybindingService)), ( __param(8, ILanguageService)), ( __param(9, IContextKeyService)), ( __param(10, IChatWidgetService)), ( __param(11, ICommandService)), ( __param(12, IMarkerService)), ( __param(13, ILanguageModelToolsService)), ( __param(14, IChatMarkdownAnchorService)), ( __param(15, ILanguageModelToolsConfirmationService))], ToolConfirmationSubPart));
 
 export { ToolConfirmationSubPart };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/toolInvocationParts/chatToolInvocationPart.d.ts

@@ -4,7 +4,6 @@ import { IMarkdownRenderer } from "@codingame/monaco-vscode-api/vscode/vs/platfo
 import { IChatToolInvocation, IChatToolInvocationSerialized } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
 import { IChatRendererContent } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatViewModel";
 import { IChatTodoListService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/chatTodoListService.service";
-import { CodeBlockModelCollection } from "../../../../common/widget/codeBlockModelCollection.js";
 import { ChatTreeItem, IChatCodeBlockInfo } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
 import { EditorPool } from "../chatContentCodePools.js";
 import { IChatContentPart, IChatContentPartRenderContext } from "../chatContentParts.js";
@@ -16,18 +15,18 @@ export declare class ChatToolInvocationPart extends Disposable implements IChatC
     private readonly listPool;
     private readonly editorPool;
     private readonly currentWidthDelegate;
-    private readonly codeBlockModelCollection;
     private readonly announcedToolProgressKeys;
     private readonly codeBlockStartIndex;
     private readonly instantiationService;
     private readonly chatTodoListService;
     readonly domNode: HTMLElement;
+    get toolCallId(): string;
     get codeblocks(): IChatCodeBlockInfo[];
     get codeblocksPartId(): string | undefined;
     private subPart;
     private mcpAppPart;
     private readonly _onDidRemount;
-    constructor(toolInvocation: IChatToolInvocation | IChatToolInvocationSerialized, context: IChatContentPartRenderContext, renderer: IMarkdownRenderer, listPool: CollapsibleListPool, editorPool: EditorPool, currentWidthDelegate: () => number, codeBlockModelCollection: CodeBlockModelCollection, announcedToolProgressKeys: Set<string> | undefined, codeBlockStartIndex: number, instantiationService: IInstantiationService, chatTodoListService: IChatTodoListService);
+    constructor(toolInvocation: IChatToolInvocation | IChatToolInvocationSerialized, context: IChatContentPartRenderContext, renderer: IMarkdownRenderer, listPool: CollapsibleListPool, editorPool: EditorPool, currentWidthDelegate: () => number, announcedToolProgressKeys: Set<string> | undefined, codeBlockStartIndex: number, instantiationService: IInstantiationService, chatTodoListService: IChatTodoListService);
     private createToolInvocationSubPart;
     /**
      * Gets MCP App render data if this tool invocation has MCP App UI.