@codingame/monaco-vscode-katex-common 24.1.0

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

@@ -0,0 +1,130 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $, append } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { renderMarkdown } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/markdownRenderer';
+import { decodeBase64 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IChatToolInvocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { IChatOutputRendererService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatOutputItemRenderer.service';
+import { ChatProgressSubPart } from '../chatProgressContentPart.js';
+import { BaseChatToolInvocationSubPart } from './chatToolInvocationSubPart.js';
+
+var ChatToolOutputSubPart_1;
+let ChatToolOutputSubPart = class ChatToolOutputSubPart extends BaseChatToolInvocationSubPart {
+    static { ChatToolOutputSubPart_1 = this; }
+    static { this._cachedStates = ( new WeakMap()); }
+    constructor(toolInvocation, context, chatOutputItemRendererService, chatWidgetService, instantiationService) {
+        super(toolInvocation);
+        this.context = context;
+        this.chatOutputItemRendererService = chatOutputItemRendererService;
+        this.chatWidgetService = chatWidgetService;
+        this.instantiationService = instantiationService;
+        this.codeblocks = [];
+        this._disposeCts = this._register(( new CancellationTokenSource()));
+        const details = toolInvocation.kind === 'toolInvocation'
+            ? IChatToolInvocation.resultDetails(toolInvocation)
+            : {
+                output: {
+                    type: 'data',
+                    mimeType: toolInvocation.resultDetails.output.mimeType,
+                    value: decodeBase64(toolInvocation.resultDetails.output.base64Data),
+                },
+            };
+        this.domNode = $('div.tool-output-part');
+        const titleEl = $('.output-title');
+        this.domNode.appendChild(titleEl);
+        if (typeof toolInvocation.invocationMessage === 'string') {
+            titleEl.textContent = toolInvocation.invocationMessage;
+        }
+        else {
+            const md = this._register(renderMarkdown(toolInvocation.invocationMessage));
+            titleEl.appendChild(md.element);
+        }
+        this.domNode.appendChild(this.createOutputPart(toolInvocation, details));
+    }
+    dispose() {
+        this._disposeCts.dispose(true);
+        super.dispose();
+    }
+    createOutputPart(toolInvocation, details) {
+        const vm = this.chatWidgetService.getWidgetBySessionResource(this.context.element.sessionResource)?.viewModel;
+        const parent = $('div.webview-output');
+        parent.style.maxHeight = '80vh';
+        let partState = { height: 0, webviewOrigin: generateUuid() };
+        if (vm) {
+            let allStates = ChatToolOutputSubPart_1._cachedStates.get(vm);
+            if (!allStates) {
+                allStates = ( new Map());
+                ChatToolOutputSubPart_1._cachedStates.set(vm, allStates);
+            }
+            const cachedState = allStates.get(toolInvocation.toolCallId);
+            if (cachedState) {
+                partState = cachedState;
+            }
+            else {
+                allStates.set(toolInvocation.toolCallId, partState);
+            }
+        }
+        if (partState.height) {
+            parent.style.height = `${partState.height}px`;
+        }
+        const progressMessage = $('span');
+        progressMessage.textContent = ( localize(5169, 'Rendering tool output...'));
+        const progressPart = this._register(this.instantiationService.createInstance(ChatProgressSubPart, progressMessage, ThemeIcon.modify(Codicon.loading, 'spin'), undefined));
+        parent.appendChild(progressPart.domNode);
+        this.chatOutputItemRendererService.renderOutputPart(details.output.mimeType, details.output.value.buffer, parent, { origin: partState.webviewOrigin }, this._disposeCts.token).then((renderedItem) => {
+            if (this._disposeCts.token.isCancellationRequested) {
+                return;
+            }
+            this._register(renderedItem);
+            progressPart.domNode.remove();
+            this._onDidChangeHeight.fire();
+            this._register(renderedItem.onDidChangeHeight(newHeight => {
+                this._onDidChangeHeight.fire();
+                partState.height = newHeight;
+            }));
+            this._register(renderedItem.webview.onDidWheel(e => {
+                this.chatWidgetService.getWidgetBySessionResource(this.context.element.sessionResource)?.delegateScrollFromMouseWheelEvent({
+                    ...e,
+                    preventDefault: () => { },
+                    stopPropagation: () => { }
+                });
+            }));
+            const widget = this.chatWidgetService.getWidgetBySessionResource(this.context.element.sessionResource);
+            if (widget) {
+                this._register(widget?.onDidShow(() => {
+                    renderedItem.reinitialize();
+                }));
+            }
+        }, (error) => {
+            console.error('Error rendering tool output:', error);
+            const errorNode = $('.output-error');
+            const errorHeaderNode = $('.output-error-header');
+            append(errorNode, errorHeaderNode);
+            const iconElement = $('div');
+            iconElement.classList.add(...ThemeIcon.asClassNameArray(Codicon.error));
+            errorHeaderNode.append(iconElement);
+            const errorTitleNode = $('.output-error-title');
+            errorTitleNode.textContent = ( localize(5170, "Error rendering the tool output"));
+            errorHeaderNode.append(errorTitleNode);
+            const errorMessageNode = $('.output-error-details');
+            errorMessageNode.textContent = error?.message || String(error);
+            errorNode.append(errorMessageNode);
+            progressPart.domNode.replaceWith(errorNode);
+        });
+        return parent;
+    }
+};
+ChatToolOutputSubPart = ChatToolOutputSubPart_1 = ( __decorate([
+    ( __param(2, IChatOutputRendererService)),
+    ( __param(3, IChatWidgetService)),
+    ( __param(4, IInstantiationService))
+], ChatToolOutputSubPart));
+
+export { ChatToolOutputSubPart };

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

@@ -0,0 +1,25 @@
+import { Separator } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service";
+import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+import { IChatToolInvocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
+import { ILanguageModelToolsConfirmationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsConfirmationService.service";
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service";
+import { IChatCodeBlockInfo } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { IChatContentPartRenderContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContentParts/chatContentParts";
+import { AbstractToolConfirmationSubPart } from "./abstractToolConfirmationSubPart.js";
+export declare class ChatToolPostExecuteConfirmationPart extends AbstractToolConfirmationSubPart {
+    private readonly modelService;
+    private readonly languageService;
+    private readonly confirmationService;
+    private _codeblocks;
+    get codeblocks(): IChatCodeBlockInfo[];
+    constructor(toolInvocation: IChatToolInvocation, context: IChatContentPartRenderContext, instantiationService: IInstantiationService, keybindingService: IKeybindingService, modelService: IModelService, languageService: ILanguageService, contextKeyService: IContextKeyService, chatWidgetService: IChatWidgetService, languageModelToolsService: ILanguageModelToolsService, confirmationService: ILanguageModelToolsConfirmationService);
+    protected createContentElement(): HTMLElement;
+    protected getTitle(): string;
+    protected additionalPrimaryActions(): (Separator | import("../chatConfirmationWidget.js").IChatConfirmationButton<() => void>)[];
+    private createResultsDisplay;
+}

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

@@ -0,0 +1,225 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $ } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Separator } from '@codingame/monaco-vscode-api/vscode/vs/base/common/actions';
+import { getExtensionForMimeType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/mime';
+import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { ChatResponseResource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModel';
+import { IChatToolInvocation, ToolConfirmKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService';
+import { ILanguageModelToolsConfirmationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsConfirmationService.service';
+import { stringifyPromptTsxPart } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
+import { SkipToolPostConfirmationActionId, AcceptToolPostConfirmationActionId } 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 { ChatToolOutputContentSubPart } from '../chatToolOutputContentSubPart.js';
+import { AbstractToolConfirmationSubPart } from './abstractToolConfirmationSubPart.js';
+
+let ChatToolPostExecuteConfirmationPart = class ChatToolPostExecuteConfirmationPart extends AbstractToolConfirmationSubPart {
+    get codeblocks() {
+        return this._codeblocks;
+    }
+    constructor(toolInvocation, context, instantiationService, keybindingService, modelService, languageService, contextKeyService, chatWidgetService, languageModelToolsService, confirmationService) {
+        super(toolInvocation, context, instantiationService, keybindingService, contextKeyService, chatWidgetService, languageModelToolsService);
+        this.modelService = modelService;
+        this.languageService = languageService;
+        this.confirmationService = confirmationService;
+        this._codeblocks = [];
+        const subtitle = toolInvocation.pastTenseMessage || toolInvocation.invocationMessage;
+        this.render({
+            allowActionId: AcceptToolPostConfirmationActionId,
+            skipActionId: SkipToolPostConfirmationActionId,
+            allowLabel: ( localize(5171, "Allow")),
+            skipLabel: ( localize(5172, 'Skip Results')),
+            partType: 'chatToolPostConfirmation',
+            subtitle: typeof subtitle === 'string' ? subtitle : subtitle?.value,
+        });
+    }
+    createContentElement() {
+        if (this.toolInvocation.kind !== 'toolInvocation') {
+            throw ( new Error('post-approval not supported for serialized data'));
+        }
+        const state = this.toolInvocation.state.get();
+        if (state.type !== IChatToolInvocation.StateKind.WaitingForPostApproval) {
+            throw ( new Error('Tool invocation is not waiting for post-approval'));
+        }
+        return this.createResultsDisplay(this.toolInvocation, state.contentForModel);
+    }
+    getTitle() {
+        return localize(5173, "Approve Tool Result");
+    }
+    additionalPrimaryActions() {
+        const actions = super.additionalPrimaryActions();
+        const confirmActions = this.confirmationService.getPostConfirmActions({
+            toolId: this.toolInvocation.toolId,
+            source: this.toolInvocation.source,
+            parameters: this.toolInvocation.parameters
+        });
+        for (const action of confirmActions) {
+            if (action.divider) {
+                actions.push(( new Separator()));
+            }
+            actions.push({
+                label: action.label,
+                tooltip: action.detail,
+                data: async () => {
+                    const shouldConfirm = await action.select();
+                    if (shouldConfirm) {
+                        this.confirmWith(this.toolInvocation, { type: ToolConfirmKind.UserAction });
+                    }
+                }
+            });
+        }
+        return actions;
+    }
+    createResultsDisplay(toolInvocation, contentForModel) {
+        const container = $('.tool-postconfirm-display');
+        if (!contentForModel || contentForModel.length === 0) {
+            container.textContent = ( localize(5174, 'No results to display'));
+            return container;
+        }
+        const parts = [];
+        for (const [i, part] of contentForModel.entries()) {
+            if (part.kind === 'text') {
+                const model = this._register(this.modelService.createModel(part.value, this.languageService.createById('plaintext'), undefined, true));
+                parts.push({
+                    kind: 'code',
+                    textModel: model,
+                    languageId: model.getLanguageId(),
+                    options: {
+                        hideToolbar: true,
+                        reserveWidth: 19,
+                        maxHeightInLines: 13,
+                        verticalPadding: 5,
+                        editorOptions: { wordWrap: 'on', readOnly: true }
+                    },
+                    codeBlockInfo: {
+                        codeBlockIndex: i,
+                        codemapperUri: undefined,
+                        elementId: this.context.element.id,
+                        focus: () => { },
+                        ownerMarkdownPartId: this.codeblocksPartId,
+                        uri: model.uri,
+                        chatSessionResource: this.context.element.sessionResource,
+                        uriPromise: Promise.resolve(model.uri)
+                    }
+                });
+            }
+            else if (part.kind === 'promptTsx') {
+                const stringified = stringifyPromptTsxPart(part);
+                const model = this._register(this.modelService.createModel(stringified, this.languageService.createById('json'), undefined, true));
+                parts.push({
+                    kind: 'code',
+                    textModel: model,
+                    languageId: model.getLanguageId(),
+                    options: {
+                        hideToolbar: true,
+                        reserveWidth: 19,
+                        maxHeightInLines: 13,
+                        verticalPadding: 5,
+                        editorOptions: { wordWrap: 'on', readOnly: true }
+                    },
+                    codeBlockInfo: {
+                        codeBlockIndex: i,
+                        codemapperUri: undefined,
+                        elementId: this.context.element.id,
+                        focus: () => { },
+                        ownerMarkdownPartId: this.codeblocksPartId,
+                        uri: model.uri,
+                        chatSessionResource: this.context.element.sessionResource,
+                        uriPromise: Promise.resolve(model.uri)
+                    }
+                });
+            }
+            else if (part.kind === 'data') {
+                const mimeType = part.value.mimeType;
+                const data = part.value.data;
+                if (mimeType?.startsWith('image/')) {
+                    const permalinkBasename = getExtensionForMimeType(mimeType) ? `image${getExtensionForMimeType(mimeType)}` : 'image.bin';
+                    const permalinkUri = ChatResponseResource.createUri(this.context.element.sessionResource, toolInvocation.toolCallId, i, permalinkBasename);
+                    parts.push({ kind: 'data', value: data.buffer, mimeType, uri: permalinkUri, audience: part.audience });
+                }
+                else {
+                    const decoder = ( new TextDecoder('utf-8', { fatal: true }));
+                    try {
+                        const text = decoder.decode(data.buffer);
+                        const model = this._register(this.modelService.createModel(text, this.languageService.createById('plaintext'), undefined, true));
+                        parts.push({
+                            kind: 'code',
+                            textModel: model,
+                            languageId: model.getLanguageId(),
+                            options: {
+                                hideToolbar: true,
+                                reserveWidth: 19,
+                                maxHeightInLines: 13,
+                                verticalPadding: 5,
+                                editorOptions: { wordWrap: 'on', readOnly: true }
+                            },
+                            codeBlockInfo: {
+                                codeBlockIndex: i,
+                                codemapperUri: undefined,
+                                elementId: this.context.element.id,
+                                focus: () => { },
+                                ownerMarkdownPartId: this.codeblocksPartId,
+                                uri: model.uri,
+                                chatSessionResource: this.context.element.sessionResource,
+                                uriPromise: Promise.resolve(model.uri)
+                            }
+                        });
+                    }
+                    catch {
+                        const base64 = ( data.toString());
+                        const model = this._register(this.modelService.createModel(base64, this.languageService.createById('plaintext'), undefined, true));
+                        parts.push({
+                            kind: 'code',
+                            textModel: model,
+                            languageId: model.getLanguageId(),
+                            options: {
+                                hideToolbar: true,
+                                reserveWidth: 19,
+                                maxHeightInLines: 13,
+                                verticalPadding: 5,
+                                editorOptions: { wordWrap: 'on', readOnly: true }
+                            },
+                            codeBlockInfo: {
+                                codeBlockIndex: i,
+                                codemapperUri: undefined,
+                                elementId: this.context.element.id,
+                                focus: () => { },
+                                ownerMarkdownPartId: this.codeblocksPartId,
+                                uri: model.uri,
+                                chatSessionResource: this.context.element.sessionResource,
+                                uriPromise: Promise.resolve(model.uri)
+                            }
+                        });
+                    }
+                }
+            }
+        }
+        if (parts.length > 0) {
+            const outputSubPart = this._register(this.instantiationService.createInstance(ChatToolOutputContentSubPart, this.context, parts));
+            this._codeblocks.push(...outputSubPart.codeblocks);
+            this._register(outputSubPart.onDidChangeHeight(() => this._onDidChangeHeight.fire()));
+            outputSubPart.domNode.classList.add('tool-postconfirm-display');
+            return outputSubPart.domNode;
+        }
+        container.textContent = ( localize(5175, 'No displayable results'));
+        return container;
+    }
+};
+ChatToolPostExecuteConfirmationPart = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IKeybindingService)),
+    ( __param(4, IModelService)),
+    ( __param(5, ILanguageService)),
+    ( __param(6, IContextKeyService)),
+    ( __param(7, IChatWidgetService)),
+    ( __param(8, ILanguageModelToolsService)),
+    ( __param(9, ILanguageModelToolsConfirmationService))
+], ChatToolPostExecuteConfirmationPart));
+
+export { ChatToolPostExecuteConfirmationPart };

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

@@ -0,0 +1,24 @@
+import { IMarkdownRenderer } from "@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IChatToolInvocation, IChatToolInvocationSerialized } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
+import { IChatCodeBlockInfo } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+import { IChatContentPartRenderContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContentParts/chatContentParts";
+import { BaseChatToolInvocationSubPart } from "./chatToolInvocationSubPart.js";
+export declare class ChatToolProgressSubPart extends BaseChatToolInvocationSubPart {
+    private readonly context;
+    private readonly renderer;
+    private readonly announcedToolProgressKeys;
+    private readonly instantiationService;
+    private readonly configurationService;
+    readonly domNode: HTMLElement;
+    readonly codeblocks: IChatCodeBlockInfo[];
+    constructor(toolInvocation: IChatToolInvocation | IChatToolInvocationSerialized, context: IChatContentPartRenderContext, renderer: IMarkdownRenderer, announcedToolProgressKeys: Set<string> | undefined, instantiationService: IInstantiationService, configurationService: IConfigurationService);
+    private createProgressPart;
+    private get toolIsConfirmed();
+    private renderProgressContent;
+    private getAnnouncementKey;
+    private computeShouldAnnounce;
+    private provideScreenReaderStatus;
+    private hasMeaningfulContent;
+}

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

@@ -0,0 +1,101 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { createElement, reset } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { status } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/aria/aria';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IChatToolInvocation, ToolConfirmKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService';
+import { AccessibilityWorkbenchSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
+import { ChatProgressContentPart } from '../chatProgressContentPart.js';
+import { BaseChatToolInvocationSubPart } from './chatToolInvocationSubPart.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+let ChatToolProgressSubPart = class ChatToolProgressSubPart extends BaseChatToolInvocationSubPart {
+    constructor(toolInvocation, context, renderer, announcedToolProgressKeys, instantiationService, configurationService) {
+        super(toolInvocation);
+        this.context = context;
+        this.renderer = renderer;
+        this.announcedToolProgressKeys = announcedToolProgressKeys;
+        this.instantiationService = instantiationService;
+        this.configurationService = configurationService;
+        this.codeblocks = [];
+        this.domNode = this.createProgressPart();
+    }
+    createProgressPart() {
+        if (IChatToolInvocation.isComplete(this.toolInvocation) && this.toolIsConfirmed && this.toolInvocation.pastTenseMessage) {
+            const key = this.getAnnouncementKey('complete');
+            const completionContent = this.toolInvocation.pastTenseMessage ?? this.toolInvocation.invocationMessage;
+            const shouldAnnounce = this.toolInvocation.kind === 'toolInvocation' && this.hasMeaningfulContent(completionContent) ? this.computeShouldAnnounce(key) : false;
+            const part = this.renderProgressContent(completionContent, shouldAnnounce);
+            this._register(part);
+            return part.domNode;
+        }
+        else {
+            const container = createElement('div');
+            const progressObservable = this.toolInvocation.kind === 'toolInvocation' ? ( this.toolInvocation.state.map(
+                (s, r) => s.type === IChatToolInvocation.StateKind.Executing ? s.progress.read(r) : undefined
+            )) : undefined;
+            this._register(autorun(reader => {
+                const progress = progressObservable?.read(reader);
+                const key = this.getAnnouncementKey('progress');
+                const progressContent = progress?.message ?? this.toolInvocation.invocationMessage;
+                const shouldAnnounce = this.toolInvocation.kind === 'toolInvocation' && this.hasMeaningfulContent(progressContent) ? this.computeShouldAnnounce(key) : false;
+                const part = reader.store.add(this.renderProgressContent(progressContent, shouldAnnounce));
+                reset(container, part.domNode);
+            }));
+            return container;
+        }
+    }
+    get toolIsConfirmed() {
+        const c = IChatToolInvocation.executionConfirmedOrDenied(this.toolInvocation);
+        return !!c && c.type !== ToolConfirmKind.Denied;
+    }
+    renderProgressContent(content, shouldAnnounce) {
+        if (typeof content === 'string') {
+            content = ( new MarkdownString()).appendText(content);
+        }
+        const progressMessage = {
+            kind: 'progressMessage',
+            content
+        };
+        if (shouldAnnounce) {
+            this.provideScreenReaderStatus(content);
+        }
+        return this.instantiationService.createInstance(ChatProgressContentPart, progressMessage, this.renderer, this.context, undefined, true, this.getIcon(), this.toolInvocation);
+    }
+    getAnnouncementKey(kind) {
+        return `${kind}:${this.toolInvocation.toolCallId}`;
+    }
+    computeShouldAnnounce(key) {
+        if (!this.announcedToolProgressKeys) {
+            return false;
+        }
+        if (!this.configurationService.getValue(AccessibilityWorkbenchSettingId.VerboseChatProgressUpdates)) {
+            return false;
+        }
+        if (( this.announcedToolProgressKeys.has(key))) {
+            return false;
+        }
+        this.announcedToolProgressKeys.add(key);
+        return true;
+    }
+    provideScreenReaderStatus(content) {
+        const message = typeof content === 'string' ? content : content.value;
+        status(message);
+    }
+    hasMeaningfulContent(content) {
+        if (!content) {
+            return false;
+        }
+        const text = typeof content === 'string' ? content : content.value;
+        return text.trim().length > 0;
+    }
+};
+ChatToolProgressSubPart = ( __decorate([
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IConfigurationService))
+], ChatToolProgressSubPart));
+
+export { ChatToolProgressSubPart };

package/vscode/src/vs/workbench/contrib/chat/browser/chatDiffBlockPart.d.ts

@@ -0,0 +1,42 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service";
+import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
+import { ITextModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service";
+import { IChatResponseViewModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatViewModel";
+import { DiffEditorPool } from "./chatContentParts/chatContentCodePools.js";
+/**
+ * Parses unified diff format into before/after content.
+ * Supports standard unified diff format with - and + prefixes.
+ */
+export declare function parseUnifiedDiff(diffText: string): {
+    before: string;
+    after: string;
+};
+export interface IMarkdownDiffBlockData {
+    readonly element: IChatResponseViewModel;
+    readonly codeBlockIndex: number;
+    readonly languageId: string;
+    readonly beforeContent: string;
+    readonly afterContent: string;
+    readonly codeBlockResource?: URI;
+    readonly isReadOnly?: boolean;
+    readonly horizontalPadding?: number;
+}
+/**
+ * Renders a diff block from markdown content.
+ * This is a lightweight wrapper that uses CodeCompareBlockPart for the actual rendering.
+ */
+export declare class MarkdownDiffBlockPart extends Disposable {
+    private readonly modelService;
+    private readonly textModelService;
+    private readonly languageService;
+    private readonly _onDidChangeContentHeight;
+    readonly onDidChangeContentHeight: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    readonly element: HTMLElement;
+    private readonly comparePart;
+    private readonly modelRef;
+    constructor(data: IMarkdownDiffBlockData, diffEditorPool: DiffEditorPool, currentWidth: number, modelService: IModelService, textModelService: ITextModelService, languageService: ILanguageService);
+    layout(width: number): void;
+    reset(): void;
+}