@codingame/monaco-vscode-katex-common 24.1.0

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

@@ -0,0 +1,429 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { $, clearNode } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { ThinkingDisplayMode, ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { ChatCollapsibleContentPart } from './chatCollapsibleContentPart.js';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+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 '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { IChatMarkdownAnchorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContentParts/chatMarkdownAnchorService.service';
+import { ChatMessageRole } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
+import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+import { ExtensionIdentifier } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions';
+import * as chatThinkingContent from './media/chatThinkingContent.css';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+registerCss(chatThinkingContent);
+function extractTextFromPart(content) {
+    const raw = Array.isArray(content.value) ? content.value.join('') : (content.value || '');
+    return raw.trim();
+}
+function extractTitleFromThinkingContent(content) {
+    const headerMatch = content.match(/^\*\*([^*]+)\*\*/);
+    return headerMatch ? headerMatch[1] : undefined;
+}
+let ChatThinkingContentPart = class ChatThinkingContentPart extends ChatCollapsibleContentPart {
+    constructor(content, context, chatContentMarkdownRenderer, instantiationService, configurationService, chatMarkdownAnchorService, languageModelsService) {
+        const initialText = extractTextFromPart(content);
+        const extractedTitle = extractTitleFromThinkingContent(initialText)
+            ?? 'Thinking...';
+        super(extractedTitle, context);
+        this.chatContentMarkdownRenderer = chatContentMarkdownRenderer;
+        this.instantiationService = instantiationService;
+        this.configurationService = configurationService;
+        this.chatMarkdownAnchorService = chatMarkdownAnchorService;
+        this.languageModelsService = languageModelsService;
+        this.defaultTitle = ( localize(5103, 'Thinking...'));
+        this.fixedScrollingMode = false;
+        this.extractedTitles = [];
+        this.toolInvocationCount = 0;
+        this.streamingCompleted = false;
+        this.isActive = true;
+        this.toolInvocations = [];
+        this.id = content.id;
+        this.content = content;
+        const configuredMode = this.configurationService.getValue('chat.agent.thinkingStyle') ?? ThinkingDisplayMode.Collapsed;
+        this.fixedScrollingMode = configuredMode === ThinkingDisplayMode.FixedScrolling;
+        this.currentTitle = extractedTitle;
+        if (extractedTitle !== this.defaultTitle) {
+            this.lastExtractedTitle = extractedTitle;
+        }
+        this.currentThinkingValue = initialText;
+        if (configuredMode === ThinkingDisplayMode.Collapsed) {
+            this.setExpanded(false);
+        }
+        else {
+            this.setExpanded(true);
+        }
+        if (this.fixedScrollingMode) {
+            this.setExpanded(false);
+        }
+        const node = this.domNode;
+        node.classList.add('chat-thinking-box');
+        node.tabIndex = 0;
+        if (this.fixedScrollingMode) {
+            node.classList.add('chat-thinking-fixed-mode');
+            this.currentTitle = this.defaultTitle;
+            if (this._collapseButton && !this.context.element.isComplete) {
+                this._collapseButton.icon = ThemeIcon.modify(Codicon.loading, 'spin');
+            }
+        }
+        this._register(autorun(r => {
+            this.expanded.read(r);
+            if (this._collapseButton && this.wrapper) {
+                if (this.wrapper.classList.contains('chat-thinking-streaming') && !this.context.element.isComplete) {
+                    this._collapseButton.icon = ThemeIcon.modify(Codicon.loading, 'spin');
+                }
+                else {
+                    this._collapseButton.icon = Codicon.check;
+                }
+            }
+        }));
+        if (this._collapseButton && !this.streamingCompleted && !this.context.element.isComplete) {
+            this._collapseButton.icon = ThemeIcon.modify(Codicon.loading, 'spin');
+        }
+        const label = this.lastExtractedTitle ?? '';
+        if (!this.fixedScrollingMode && !this._isExpanded.get()) {
+            this.setTitle(label);
+        }
+        if (this._collapseButton) {
+            this._register(this._collapseButton.onDidClick(() => {
+                if (this.streamingCompleted || this.fixedScrollingMode) {
+                    return;
+                }
+                const expanded = this.isExpanded();
+                if (expanded) {
+                    this.setTitle(this.defaultTitle, true);
+                    this.currentTitle = this.defaultTitle;
+                }
+                else if (this.lastExtractedTitle) {
+                    const collapsedLabel = this.lastExtractedTitle ?? '';
+                    this.setTitle(collapsedLabel);
+                    this.currentTitle = collapsedLabel;
+                }
+            }));
+        }
+    }
+    initContent() {
+        this.wrapper = $('.chat-used-context-list.chat-thinking-collapsible');
+        this.wrapper.classList.add('chat-thinking-streaming');
+        if (this.currentThinkingValue) {
+            this.textContainer = $('.chat-thinking-item.markdown-content');
+            this.wrapper.appendChild(this.textContainer);
+            this.renderMarkdown(this.currentThinkingValue);
+        }
+        this.updateDropdownClickability();
+        return this.wrapper;
+    }
+    renderMarkdown(content, reuseExisting) {
+        if (this._store.isDisposed) {
+            return;
+        }
+        const cleanedContent = content.trim();
+        if (!cleanedContent) {
+            if (this.markdownResult) {
+                this.markdownResult.dispose();
+                this.markdownResult = undefined;
+            }
+            clearNode(this.textContainer);
+            return;
+        }
+        let contentToRender = cleanedContent;
+        if (cleanedContent.startsWith('**') && cleanedContent.endsWith('**')) {
+            contentToRender = cleanedContent.slice(2, -2);
+        }
+        const target = reuseExisting ? this.markdownResult?.element : undefined;
+        if (this.markdownResult) {
+            this.markdownResult.dispose();
+            this.markdownResult = undefined;
+        }
+        const rendered = this._register(this.chatContentMarkdownRenderer.render(( new MarkdownString(contentToRender)), {
+            fillInIncompleteTokens: true,
+            asyncRenderCallback: () => this._onDidChangeHeight.fire(),
+            codeBlockRendererSync: (_languageId, text, raw) => {
+                const codeElement = $('code');
+                codeElement.textContent = text;
+                return codeElement;
+            }
+        }, target));
+        this.markdownResult = rendered;
+        if (!target) {
+            clearNode(this.textContainer);
+            this.textContainer.appendChild(rendered.element);
+        }
+    }
+    setDropdownClickable(clickable) {
+        if (this._collapseButton) {
+            this._collapseButton.element.style.pointerEvents = clickable ? 'auto' : 'none';
+        }
+        if (!clickable && this.streamingCompleted) {
+            super.setTitle(this.lastExtractedTitle ?? this.currentTitle);
+        }
+    }
+    updateDropdownClickability() {
+        if (!this.wrapper) {
+            return;
+        }
+        if (this.wrapper.children.length > 1 || this.toolInvocationCount > 0) {
+            this.setDropdownClickable(true);
+            return;
+        }
+        const contentWithoutTitle = this.currentThinkingValue.trim();
+        const titleToCompare = this.lastExtractedTitle ?? this.currentTitle;
+        const stripMarkdown = (text) => {
+            return text
+                .replace(/\*\*(.+?)\*\*/g, '$1').replace(/\*(.+?)\*/g, '$1').replace(/`(.+?)`/g, '$1').trim();
+        };
+        const strippedContent = stripMarkdown(contentWithoutTitle);
+        const shouldDisable = !strippedContent || strippedContent === titleToCompare;
+        this.setDropdownClickable(!shouldDisable);
+    }
+    resetId() {
+        this.id = undefined;
+    }
+    collapseContent() {
+        this.setExpanded(false);
+    }
+    updateThinking(content) {
+        if (this._store.isDisposed) {
+            return;
+        }
+        this.content = content;
+        const raw = extractTextFromPart(content);
+        const next = raw;
+        if (next === this.currentThinkingValue) {
+            return;
+        }
+        const previousValue = this.currentThinkingValue;
+        const reuseExisting = !!(this.markdownResult && next.startsWith(previousValue) && next.length > previousValue.length);
+        this.currentThinkingValue = next;
+        this.renderMarkdown(next, reuseExisting);
+        if (this.fixedScrollingMode && this.wrapper) {
+            this.wrapper.scrollTop = this.wrapper.scrollHeight;
+        }
+        const extractedTitle = extractTitleFromThinkingContent(raw);
+        if (extractedTitle && extractedTitle !== this.currentTitle) {
+            if (!this.extractedTitles.includes(extractedTitle)) {
+                this.extractedTitles.push(extractedTitle);
+            }
+            this.lastExtractedTitle = extractedTitle;
+        }
+        if (!extractedTitle || extractedTitle === this.currentTitle) {
+            return;
+        }
+        const label = this.lastExtractedTitle ?? '';
+        if (!this.fixedScrollingMode && !this._isExpanded.get()) {
+            this.setTitle(label);
+        }
+        this.updateDropdownClickability();
+    }
+    getIsActive() {
+        return this.isActive;
+    }
+    markAsInactive() {
+        this.isActive = false;
+    }
+    finalizeTitleIfDefault() {
+        this.wrapper.classList.remove('chat-thinking-streaming');
+        this.streamingCompleted = true;
+        if (this._collapseButton) {
+            this._collapseButton.icon = Codicon.check;
+        }
+        this.updateDropdownClickability();
+        if (this.content.generatedTitle) {
+            this.currentTitle = this.content.generatedTitle;
+            super.setTitle(this.content.generatedTitle);
+            return;
+        }
+        const existingToolTitle = this.toolInvocations.find(t => t.generatedTitle)?.generatedTitle;
+        if (existingToolTitle) {
+            this.currentTitle = existingToolTitle;
+            this.content.generatedTitle = existingToolTitle;
+            super.setTitle(existingToolTitle);
+            return;
+        }
+        if (this.toolInvocationCount === 1 && this.extractedTitles.length === 1 && this.currentToolCallLabel && this.currentThinkingValue.trim() === '') {
+            const title = this.currentToolCallLabel;
+            this.currentTitle = title;
+            this.setTitleWithWidgets(( new MarkdownString(title)), this.instantiationService, this.chatMarkdownAnchorService, this.chatContentMarkdownRenderer);
+            return;
+        }
+        if (this.extractedTitles.length === 1 && this.toolInvocationCount === 0) {
+            const title = this.extractedTitles[0];
+            this.currentTitle = title;
+            this.content.generatedTitle = title;
+            super.setTitle(title);
+            return;
+        }
+        const generateTitles = this.configurationService.getValue(ChatConfiguration.ThinkingGenerateTitles) ?? true;
+        if (!generateTitles) {
+            this.setFallbackTitle();
+            return;
+        }
+        this.generateTitleViaLLM();
+    }
+    setGeneratedTitleOnToolInvocations(title) {
+        for (const toolInvocation of this.toolInvocations) {
+            toolInvocation.generatedTitle = title;
+        }
+    }
+    async generateTitleViaLLM() {
+        try {
+            let models = await this.languageModelsService.selectLanguageModels({ vendor: 'copilot', id: 'copilot-fast' });
+            if (!models.length) {
+                models = await this.languageModelsService.selectLanguageModels({ vendor: 'copilot', family: 'gpt-4o-mini' });
+            }
+            if (!models.length) {
+                this.setFallbackTitle();
+                return;
+            }
+            let context;
+            if (this.extractedTitles.length > 0) {
+                context = this.extractedTitles.join(', ');
+            }
+            else {
+                context = this.currentThinkingValue.substring(0, 1000);
+            }
+            const prompt = `Summarize the following actions in 6-7 words using past tense. Be very concise - focus on the main action only. No subjects, quotes, or punctuation.
+
+			Examples:
+			- "Preparing to create new page file, Read HomePage.tsx, Creating new TypeScript file" → "Created new page file"
+			- "Searching for files, Reading configuration, Analyzing dependencies" → "Analyzed project structure"
+			- "Invoked terminal command, Checked build output, Fixed errors" → "Ran build and fixed errors"
+
+			Actions: ${context}`;
+            const response = await this.languageModelsService.sendChatRequest(models[0], ( new ExtensionIdentifier('core')), [{ role: ChatMessageRole.User, content: [{ type: 'text', value: prompt }] }], {}, CancellationToken.None);
+            let generatedTitle = '';
+            for await (const part of response.stream) {
+                if (Array.isArray(part)) {
+                    for (const p of part) {
+                        if (p.type === 'text') {
+                            generatedTitle += p.value;
+                        }
+                    }
+                }
+                else if (part.type === 'text') {
+                    generatedTitle += part.value;
+                }
+            }
+            await response.result;
+            generatedTitle = generatedTitle.trim();
+            if (generatedTitle && !this._store.isDisposed) {
+                this.currentTitle = generatedTitle;
+                if (this._collapseButton) {
+                    this._collapseButton.label = generatedTitle;
+                }
+                this.content.generatedTitle = generatedTitle;
+                this.setGeneratedTitleOnToolInvocations(generatedTitle);
+                return;
+            }
+        }
+        catch (error) {
+        }
+        this.setFallbackTitle();
+    }
+    setFallbackTitle() {
+        const finalLabel = this.toolInvocationCount > 0
+            ? ( localize(
+            5104,
+            'Finished thinking and invoked {0} tool{1}',
+            this.toolInvocationCount,
+            this.toolInvocationCount === 1 ? '' : 's'
+        ))
+            : ( localize(5105, 'Finished Thinking'));
+        this.currentTitle = finalLabel;
+        this.wrapper.classList.remove('chat-thinking-streaming');
+        this.streamingCompleted = true;
+        if (this._collapseButton) {
+            this._collapseButton.icon = Codicon.check;
+            this._collapseButton.label = finalLabel;
+        }
+        this.updateDropdownClickability();
+    }
+    appendItem(content, toolInvocationId, toolInvocation) {
+        this.wrapper.appendChild(content);
+        if (toolInvocationId) {
+            this.toolInvocationCount++;
+            let toolCallLabel;
+            if (toolInvocation?.invocationMessage) {
+                const message = typeof toolInvocation.invocationMessage === 'string' ? toolInvocation.invocationMessage : toolInvocation.invocationMessage.value;
+                toolCallLabel = message;
+            }
+            else {
+                toolCallLabel = `Invoked \`${toolInvocationId}\``;
+            }
+            if (toolInvocation?.pastTenseMessage) {
+                this.currentToolCallLabel = typeof toolInvocation.pastTenseMessage === 'string' ? toolInvocation.pastTenseMessage : toolInvocation.pastTenseMessage.value;
+            }
+            if (toolInvocation) {
+                this.toolInvocations.push(toolInvocation);
+            }
+            if (!this.extractedTitles.includes(toolCallLabel)) {
+                this.extractedTitles.push(toolCallLabel);
+            }
+            if (!this.fixedScrollingMode && !this._isExpanded.get()) {
+                this.setTitle(toolCallLabel);
+            }
+        }
+        if (this.fixedScrollingMode && this.wrapper) {
+            this.wrapper.scrollTop = this.wrapper.scrollHeight;
+        }
+        this.updateDropdownClickability();
+    }
+    setupThinkingContainer(content, context) {
+        if (this._store.isDisposed) {
+            return;
+        }
+        this.textContainer = $('.chat-thinking-item.markdown-content');
+        if (content.value) {
+            this.wrapper.appendChild(this.textContainer);
+            this.id = content.id;
+            this.updateThinking(content);
+        }
+        this.updateDropdownClickability();
+    }
+    setTitle(title, omitPrefix) {
+        if (!title || this.context.element.isComplete) {
+            return;
+        }
+        if (omitPrefix) {
+            this.setTitleWithWidgets(( new MarkdownString(title)), this.instantiationService, this.chatMarkdownAnchorService, this.chatContentMarkdownRenderer);
+            this.currentTitle = title;
+            return;
+        }
+        const thinkingLabel = `Thinking: ${title}`;
+        this.lastExtractedTitle = title;
+        this.currentTitle = thinkingLabel;
+        this.setTitleWithWidgets(( new MarkdownString(thinkingLabel)), this.instantiationService, this.chatMarkdownAnchorService, this.chatContentMarkdownRenderer);
+    }
+    hasSameContent(other, _followingContent, _element) {
+        if (other.kind === 'toolInvocation' || other.kind === 'toolInvocationSerialized') {
+            return true;
+        }
+        if (other.kind !== 'thinking') {
+            return false;
+        }
+        return other?.id !== this.id;
+    }
+    dispose() {
+        if (this.markdownResult) {
+            this.markdownResult.dispose();
+            this.markdownResult = undefined;
+        }
+        super.dispose();
+    }
+};
+ChatThinkingContentPart = ( __decorate([
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IChatMarkdownAnchorService)),
+    ( __param(6, ILanguageModelsService))
+], ChatThinkingContentPart));
+
+export { ChatThinkingContentPart };

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

@@ -0,0 +1,40 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.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 { IChatTodoListService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatTodoListService.service";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+export declare class ChatTodoListWidget extends Disposable {
+    private readonly chatTodoListService;
+    private readonly configurationService;
+    private readonly instantiationService;
+    private readonly contextKeyService;
+    readonly domNode: HTMLElement;
+    private readonly _onDidChangeHeight;
+    readonly onDidChangeHeight: Event<void>;
+    private _isExpanded;
+    private _userManuallyExpanded;
+    private expandoButton;
+    private expandIcon;
+    private titleElement;
+    private todoListContainer;
+    private clearButtonContainer;
+    private clearButton;
+    private _currentSessionResource;
+    private _todoList;
+    constructor(chatTodoListService: IChatTodoListService, configurationService: IConfigurationService, instantiationService: IInstantiationService, contextKeyService: IContextKeyService);
+    get height(): number;
+    private hideWidget;
+    private createChatTodoWidget;
+    private createClearButton;
+    render(sessionResource: URI | undefined): void;
+    clear(sessionResource: URI | undefined, force?: boolean): void;
+    private updateTodoDisplay;
+    private renderTodoList;
+    private toggleExpanded;
+    private clearAllTodos;
+    private updateClearButtonState;
+    private updateTitleElement;
+    private getStatusText;
+}