@codingame/monaco-vscode-api 13.1.6 → 14.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatQuotasService.js

@@ -0,0 +1,198 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { safeIntl } from '../../../../base/common/date.js';
+import { language } from '../../../../base/common/platform.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
+import { MarkdownString } from '../../../../base/common/htmlContent.js';
+import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { localize } from '../../../../nls.js';
+import { Action2, registerAction2 } from '../../../../platform/actions/common/actions.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.service.js';
+import { StatusbarAlignment } from '../../../services/statusbar/browser/statusbar.js';
+import { IStatusbarService } from '../../../services/statusbar/browser/statusbar.service.js';
+import { ChatContextKeys } from '../common/chatContextKeys.js';
+import { ICommandService } from '../../../../platform/commands/common/commands.service.js';
+import { IChatQuotasService } from './chatQuotasService.service.js';
+
+var ChatQuotasStatusBarEntry_1;
+const OPEN_CHAT_QUOTA_EXCEEDED_DIALOG = 'workbench.action.chat.openQuotaExceededDialog';
+let ChatQuotasService = class ChatQuotasService extends Disposable {
+    get quotas() { return this._quotas; }
+    constructor(contextKeyService) {
+        super();
+        this.contextKeyService = contextKeyService;
+        this._onDidChangeQuotas = this._register(( new Emitter()));
+        this.onDidChangeQuotas = this._onDidChangeQuotas.event;
+        this._quotas = { chatQuotaExceeded: false, completionsQuotaExceeded: false, quotaResetDate: undefined };
+        this.chatQuotaExceededContextKey = ChatContextKeys.chatQuotaExceeded.bindTo(this.contextKeyService);
+        this.completionsQuotaExceededContextKey = ChatContextKeys.completionsQuotaExceeded.bindTo(this.contextKeyService);
+        this.ExtensionQuotaContextKeys = {
+            chatQuotaExceeded: 'github.copilot.chat.quotaExceeded',
+            completionsQuotaExceeded: 'github.copilot.completions.quotaExceeded',
+        };
+        this.registerListeners();
+        this.registerActions();
+    }
+    registerListeners() {
+        const chatQuotaExceededSet = ( new Set([this.ExtensionQuotaContextKeys.chatQuotaExceeded]));
+        const completionsQuotaExceededSet = ( new Set([this.ExtensionQuotaContextKeys.completionsQuotaExceeded]));
+        this._register(this.contextKeyService.onDidChangeContext(e => {
+            let changed = false;
+            if (e.affectsSome(chatQuotaExceededSet)) {
+                const newChatQuotaExceeded = this.contextKeyService.getContextKeyValue(this.ExtensionQuotaContextKeys.chatQuotaExceeded);
+                if (typeof newChatQuotaExceeded === 'boolean' && newChatQuotaExceeded !== this._quotas.chatQuotaExceeded) {
+                    this._quotas.chatQuotaExceeded = newChatQuotaExceeded;
+                    changed = true;
+                }
+            }
+            if (e.affectsSome(completionsQuotaExceededSet)) {
+                const newCompletionsQuotaExceeded = this.contextKeyService.getContextKeyValue(this.ExtensionQuotaContextKeys.completionsQuotaExceeded);
+                if (typeof newCompletionsQuotaExceeded === 'boolean' && newCompletionsQuotaExceeded !== this._quotas.completionsQuotaExceeded) {
+                    this._quotas.completionsQuotaExceeded = newCompletionsQuotaExceeded;
+                    changed = true;
+                }
+            }
+            if (changed) {
+                this.updateContextKeys();
+                this._onDidChangeQuotas.fire();
+            }
+        }));
+    }
+    registerActions() {
+        const that = this;
+        class ShowLimitReachedDialogAction extends Action2 {
+            constructor() {
+                super({
+                    id: OPEN_CHAT_QUOTA_EXCEEDED_DIALOG,
+                    title: ( localize(4620, "Upgrade to Copilot Pro")),
+                });
+            }
+            async run(accessor) {
+                const commandService = accessor.get(ICommandService);
+                const dialogService = accessor.get(IDialogService);
+                const dateFormatter = safeIntl.DateTimeFormat(language, { year: 'numeric', month: 'long', day: 'numeric' });
+                let message;
+                const { chatQuotaExceeded, completionsQuotaExceeded } = that.quotas;
+                if (chatQuotaExceeded && !completionsQuotaExceeded) {
+                    message = ( localize(
+                        4621,
+                        "You've run out of free chat messages. You still have free code completions available in the Copilot Free plan. These limits will reset on {0}.",
+                        dateFormatter.format(that.quotas.quotaResetDate)
+                    ));
+                }
+                else if (completionsQuotaExceeded && !chatQuotaExceeded) {
+                    message = ( localize(
+                        4622,
+                        "You've run out of free code completions. You still have free chat messages available in the Copilot Free plan. These limits will reset on {0}.",
+                        dateFormatter.format(that.quotas.quotaResetDate)
+                    ));
+                }
+                else {
+                    message = ( localize(
+                        4623,
+                        "You've reached the limit of the Copilot Free plan. These limits will reset on {0}.",
+                        dateFormatter.format(that.quotas.quotaResetDate)
+                    ));
+                }
+                const upgradeToPro = ( localize(
+                    4624,
+                    "Upgrade to Copilot Pro (your first 30 days are free) for:\n- Unlimited code completions\n- Unlimited chat messages\n- Access to additional models"
+                ));
+                await dialogService.prompt({
+                    type: 'none',
+                    message: ( localize(4625, "Copilot Limit Reached")),
+                    cancelButton: {
+                        label: ( localize(4626, "Dismiss")),
+                        run: () => { }
+                    },
+                    buttons: [
+                        {
+                            label: ( localize(4627, "Upgrade to Copilot Pro")),
+                            run: () => commandService.executeCommand('workbench.action.chat.upgradePlan')
+                        },
+                    ],
+                    custom: {
+                        icon: Codicon.copilotWarningLarge,
+                        markdownDetails: [
+                            { markdown: ( new MarkdownString(message, true)) },
+                            { markdown: ( new MarkdownString(upgradeToPro, true)) }
+                        ]
+                    }
+                });
+            }
+        }
+        registerAction2(ShowLimitReachedDialogAction);
+    }
+    acceptQuotas(quotas) {
+        this._quotas = quotas;
+        this.updateContextKeys();
+        this._onDidChangeQuotas.fire();
+    }
+    clearQuotas() {
+        if (this.quotas.chatQuotaExceeded || this.quotas.completionsQuotaExceeded) {
+            this.acceptQuotas({ chatQuotaExceeded: false, completionsQuotaExceeded: false, quotaResetDate: undefined });
+        }
+    }
+    updateContextKeys() {
+        this.chatQuotaExceededContextKey.set(this._quotas.chatQuotaExceeded);
+        this.completionsQuotaExceededContextKey.set(this._quotas.completionsQuotaExceeded);
+    }
+};
+ChatQuotasService = ( __decorate([
+    ( __param(0, IContextKeyService))
+], ChatQuotasService));
+let ChatQuotasStatusBarEntry = class ChatQuotasStatusBarEntry extends Disposable {
+    static { ChatQuotasStatusBarEntry_1 = this; }
+    static { this.ID = 'chat.quotasStatusBarEntry'; }
+    constructor(statusbarService, chatQuotasService) {
+        super();
+        this.statusbarService = statusbarService;
+        this.chatQuotasService = chatQuotasService;
+        this.entry = this._register(( new DisposableStore()));
+        this._register(Event.runAndSubscribe(this.chatQuotasService.onDidChangeQuotas, () => this.updateStatusbarEntry()));
+    }
+    updateStatusbarEntry() {
+        this.entry.clear();
+        const { chatQuotaExceeded, completionsQuotaExceeded } = this.chatQuotasService.quotas;
+        if (chatQuotaExceeded || completionsQuotaExceeded) {
+            let text;
+            if (chatQuotaExceeded && !completionsQuotaExceeded) {
+                text = ( localize(4628, "Chat limit reached"));
+            }
+            else if (completionsQuotaExceeded && !chatQuotaExceeded) {
+                text = ( localize(4629, "Completions limit reached"));
+            }
+            else {
+                text = ( localize(4630, "Copilot limit reached"));
+            }
+            this.entry.add(this.statusbarService.addEntry({
+                name: ( localize(4631, "Copilot Limit Indicator")),
+                text: `$(copilot-warning) ${text}`,
+                ariaLabel: text,
+                command: OPEN_CHAT_QUOTA_EXCEEDED_DIALOG,
+                showInAllWindows: true,
+                kind: 'prominent',
+                tooltip: quotaToButtonMessage({ chatQuotaExceeded, completionsQuotaExceeded })
+            }, ChatQuotasStatusBarEntry_1.ID, StatusbarAlignment.RIGHT, 1));
+        }
+    }
+};
+ChatQuotasStatusBarEntry = ChatQuotasStatusBarEntry_1 = ( __decorate([
+    ( __param(0, IStatusbarService)),
+    ( __param(1, IChatQuotasService))
+], ChatQuotasStatusBarEntry));
+function quotaToButtonMessage({ chatQuotaExceeded, completionsQuotaExceeded }) {
+    if (chatQuotaExceeded && !completionsQuotaExceeded) {
+        return localize(4632, "Monthly chat messages limit reached. Click for details.");
+    }
+    else if (completionsQuotaExceeded && !chatQuotaExceeded) {
+        return localize(4633, "Monthly code completions limit reached. Click for details.");
+    }
+    else {
+        return localize(4634, "Copilot Free plan limit reached. Click for details.");
+    }
+}
+
+export { ChatQuotasService, ChatQuotasStatusBarEntry, OPEN_CHAT_QUOTA_EXCEEDED_DIALOG, quotaToButtonMessage };

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

@@ -1,5 +1,5 @@
 import { Event } from "../../../../base/common/event.js";
-import { IChatQuotas } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/browser/chatQuotasService";
+import { IChatQuotas } from "./chatQuotasService.js";
 export declare const IChatQuotasService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatQuotasService>;
 export interface IChatQuotasService {
     _serviceBrand: undefined;

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

@@ -0,0 +1,3 @@
+import { IChatRequestVariableEntry } from "../../common/chatModel.js";
+export declare const ScreenshotVariableId = "screenshot-focused-window";
+export declare function convertBufferToScreenshotVariable(buffer: ArrayBufferLike): IChatRequestVariableEntry;

package/vscode/src/vs/workbench/contrib/chat/browser/contrib/screenshot.js

@@ -0,0 +1,15 @@
+
+import { localize } from '../../../../../nls.js';
+
+const ScreenshotVariableId = 'screenshot-focused-window';
+function convertBufferToScreenshotVariable(buffer) {
+    return {
+        id: ScreenshotVariableId,
+        name: ( localize(4704, 'Screenshot')),
+        value: ( new Uint8Array(buffer)),
+        isImage: true,
+        isDynamic: true
+    };
+}
+
+export { ScreenshotVariableId, convertBufferToScreenshotVariable };

package/vscode/src/vs/workbench/contrib/chat/browser/media/chatEditorController.css.js

@@ -0,0 +1,6 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+
+var css = ".chat-diff-change-content-widget{box-shadow:0 2px 8px var(--vscode-widget-shadow);display:flex;opacity:0;transition:opacity .2s ease-in-out}.chat-diff-change-content-widget.hover{opacity:1}.chat-diff-change-content-widget .monaco-action-bar{background-color:var(--vscode-button-background);border-radius:2px;color:var(--vscode-button-foreground);padding:0}.chat-diff-change-content-widget .monaco-action-bar .action-item .action-label{border-radius:2px;color:var(--vscode-button-foreground);height:14px}.chat-diff-change-content-widget .monaco-action-bar .action-item .action-label.codicon{color:var(--vscode-button-foreground);font-size:12px;line-height:14px;padding:2px;width:unset}.chat-diff-change-content-widget .monaco-action-bar .action-item .action-label.codicon[class*=codicon-]{font-size:12px}";
+n(css,{});
+
+export { css, css as default };

package/vscode/src/vs/workbench/contrib/chat/browser/media/chatEditorOverlay.css.js

@@ -0,0 +1,6 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+
+var css = ".chat-editor-overlay-widget{align-items:center;background-color:var(--vscode-button-background);border:1px solid var(--vscode-contrastBorder);border-radius:5px;box-shadow:0 2px 8px var(--vscode-widget-shadow);color:var(--vscode-button-foreground);display:flex;overflow:hidden;padding:0;z-index:10}@keyframes pulse{0%{box-shadow:0 2px 8px 0 var(--vscode-widget-shadow)}50%{box-shadow:0 2px 8px 4px var(--vscode-widget-shadow)}to{box-shadow:0 2px 8px 0 var(--vscode-widget-shadow)}}.chat-editor-overlay-widget.busy{animation:pulse 2.3s ease-in infinite}.chat-editor-overlay-widget .chat-editor-overlay-progress{align-items:center;display:none;font-size:12px;font-variant-numeric:tabular-nums;overflow:hidden;padding:0 5px;white-space:nowrap}.chat-editor-overlay-widget.busy .chat-editor-overlay-progress{display:inline-flex}.chat-editor-overlay-widget.busy .chat-editor-overlay-progress .busy-label{padding:5px}@keyframes ellipsis{0%{content:\"\"}25%{content:\".\"}50%{content:\"..\"}75%{content:\"...\"}to{content:\"\"}}.chat-editor-overlay-widget.busy .chat-editor-overlay-progress .busy-label:after{animation:ellipsis 1s steps(4) infinite;content:\"\";display:inline-flex;overflow:hidden;white-space:nowrap;width:3ch}.chat-editor-overlay-widget.busy .chat-editor-overlay-toolbar{display:none}.chat-editor-overlay-widget .action-item>.action-label{font-size:12px;padding:5px}.chat-editor-overlay-widget .action-item:first-child>.action-label{padding-left:7px}.chat-editor-overlay-widget .action-item:last-child>.action-label{padding-right:7px}.chat-editor-overlay-widget .action-item>.action-label.codicon,.chat-editor-overlay-widget.busy .chat-editor-overlay-progress .codicon{color:var(--vscode-button-foreground)}.chat-editor-overlay-widget .monaco-action-bar .action-item.disabled>.action-label,.chat-editor-overlay-widget .monaco-action-bar .action-item.disabled>.action-label.codicon,.chat-editor-overlay-widget .monaco-action-bar .action-item.disabled>.action-label.codicon:before,.chat-editor-overlay-widget .monaco-action-bar .action-item.disabled>.action-label:hover{color:var(--vscode-button-foreground);opacity:.7}.chat-editor-overlay-widget .action-item.label-item{font-variant-numeric:tabular-nums}.chat-editor-overlay-widget .monaco-action-bar .action-item.label-item>.action-label,.chat-editor-overlay-widget .monaco-action-bar .action-item.label-item>.action-label:hover{color:var(--vscode-button-foreground);opacity:1}.chat-editor-overlay-widget .action-item.auto{overflow:hidden;position:relative}.chat-editor-overlay-widget .action-item.auto:before{background-color:var(--vscode-toolbar-hoverBackground);content:\"\";height:100%;left:var(--vscode-action-item-auto-timeout,-100%);position:absolute;top:0;transition:left .5s linear;width:100%}";
+n(css,{});
+
+export { css, css as default };

package/vscode/src/vs/workbench/contrib/chat/common/annotations.d.ts

@@ -0,0 +1,20 @@
+import { URI } from "../../../../base/common/uri.js";
+import { IRange } from "../../../../editor/common/core/range.js";
+import { IChatProgressRenderableResponseContent, IChatProgressResponseContent } from "./chatModel.js";
+import { IChatMarkdownContent } from "./chatService.js";
+export declare const contentRefUrl = "http://_vscodecontentref_";
+export declare function annotateSpecialMarkdownContent(response: Iterable<IChatProgressResponseContent>): IChatProgressRenderableResponseContent[];
+export interface IMarkdownVulnerability {
+    readonly title: string;
+    readonly description: string;
+    readonly range: IRange;
+}
+export declare function annotateVulnerabilitiesInText(response: ReadonlyArray<IChatProgressResponseContent>): readonly IChatMarkdownContent[];
+export declare function extractCodeblockUrisFromText(text: string): {
+    uri: URI;
+    textWithoutResult: string;
+} | undefined;
+export declare function extractVulnerabilitiesFromText(text: string): {
+    newText: string;
+    vulnerabilities: IMarkdownVulnerability[];
+};

package/vscode/src/vs/workbench/contrib/chat/common/annotations.js

@@ -0,0 +1,134 @@
+
+import { MarkdownString } from '../../../../base/common/htmlContent.js';
+import { basename } from '../../../../base/common/resources.js';
+import { URI } from '../../../../base/common/uri.js';
+import { appendMarkdownString, canMergeMarkdownStrings } from './chatModel.js';
+
+const contentRefUrl = 'http://_vscodecontentref_';
+function annotateSpecialMarkdownContent(response) {
+    let refIdPool = 0;
+    const result = [];
+    for (const item of response) {
+        const previousItem = result.filter(p => p.kind !== 'textEditGroup').at(-1);
+        const previousItemIndex = result.findIndex(p => p === previousItem);
+        if (item.kind === 'inlineReference') {
+            let label = item.name;
+            if (!label) {
+                if (URI.isUri(item.inlineReference)) {
+                    label = basename(item.inlineReference);
+                }
+                else if ('name' in item.inlineReference) {
+                    label = item.inlineReference.name;
+                }
+                else {
+                    label = basename(item.inlineReference.uri);
+                }
+            }
+            const refId = refIdPool++;
+            const printUri = ( URI.parse(contentRefUrl)).with({ path: String(refId) });
+            const markdownText = `[${label}](${( printUri.toString())})`;
+            const annotationMetadata = { [refId]: item };
+            if (previousItem?.kind === 'markdownContent') {
+                const merged = appendMarkdownString(previousItem.content, ( new MarkdownString(markdownText)));
+                result[previousItemIndex] = { ...previousItem, content: merged, inlineReferences: { ...annotationMetadata, ...(previousItem.inlineReferences || {}) } };
+            }
+            else {
+                result.push({ content: ( new MarkdownString(markdownText)), inlineReferences: annotationMetadata, kind: 'markdownContent' });
+            }
+        }
+        else if (item.kind === 'markdownContent' && previousItem?.kind === 'markdownContent' && canMergeMarkdownStrings(previousItem.content, item.content)) {
+            const merged = appendMarkdownString(previousItem.content, item.content);
+            result[previousItemIndex] = { ...previousItem, content: merged };
+        }
+        else if (item.kind === 'markdownVuln') {
+            const vulnText = encodeURIComponent(JSON.stringify(item.vulnerabilities));
+            const markdownText = `<vscode_annotation details='${vulnText}'>${item.content.value}</vscode_annotation>`;
+            if (previousItem?.kind === 'markdownContent') {
+                const merged = appendMarkdownString(previousItem.content, ( new MarkdownString(markdownText)));
+                result[previousItemIndex] = { ...previousItem, content: merged };
+            }
+            else {
+                result.push({ content: ( new MarkdownString(markdownText)), kind: 'markdownContent' });
+            }
+        }
+        else if (item.kind === 'codeblockUri') {
+            if (previousItem?.kind === 'markdownContent') {
+                const markdownText = `<vscode_codeblock_uri>${( item.uri.toString())}</vscode_codeblock_uri>`;
+                const merged = appendMarkdownString(previousItem.content, ( new MarkdownString(markdownText)));
+                result[previousItemIndex] = { ...previousItem, content: merged };
+            }
+        }
+        else {
+            result.push(item);
+        }
+    }
+    return result;
+}
+function annotateVulnerabilitiesInText(response) {
+    const result = [];
+    for (const item of response) {
+        const previousItem = result[result.length - 1];
+        if (item.kind === 'markdownContent') {
+            if (previousItem?.kind === 'markdownContent') {
+                result[result.length - 1] = { content: ( new MarkdownString(
+                    previousItem.content.value + item.content.value,
+                    { isTrusted: previousItem.content.isTrusted }
+                )), kind: 'markdownContent' };
+            }
+            else {
+                result.push(item);
+            }
+        }
+        else if (item.kind === 'markdownVuln') {
+            const vulnText = encodeURIComponent(JSON.stringify(item.vulnerabilities));
+            const markdownText = `<vscode_annotation details='${vulnText}'>${item.content.value}</vscode_annotation>`;
+            if (previousItem?.kind === 'markdownContent') {
+                result[result.length - 1] = { content: ( new MarkdownString(
+                    previousItem.content.value + markdownText,
+                    { isTrusted: previousItem.content.isTrusted }
+                )), kind: 'markdownContent' };
+            }
+            else {
+                result.push({ content: ( new MarkdownString(markdownText)), kind: 'markdownContent' });
+            }
+        }
+    }
+    return result;
+}
+function extractCodeblockUrisFromText(text) {
+    const match = /<vscode_codeblock_uri>(.*?)<\/vscode_codeblock_uri>/ms.exec(text);
+    if (match && match[1]) {
+        const result = ( URI.parse(match[1]));
+        const textWithoutResult = text.substring(0, match.index) + text.substring(match.index + match[0].length);
+        return { uri: result, textWithoutResult };
+    }
+    return undefined;
+}
+function extractVulnerabilitiesFromText(text) {
+    const vulnerabilities = [];
+    let newText = text;
+    let match;
+    while ((match = /<vscode_annotation details='(.*?)'>(.*?)<\/vscode_annotation>/ms.exec(newText)) !== null) {
+        const [full, details, content] = match;
+        const start = match.index;
+        const textBefore = newText.substring(0, start);
+        const linesBefore = textBefore.split('\n').length - 1;
+        const linesInside = content.split('\n').length - 1;
+        const previousNewlineIdx = textBefore.lastIndexOf('\n');
+        const startColumn = start - (previousNewlineIdx + 1) + 1;
+        const endPreviousNewlineIdx = (textBefore + content).lastIndexOf('\n');
+        const endColumn = start + content.length - (endPreviousNewlineIdx + 1) + 1;
+        try {
+            const vulnDetails = JSON.parse(decodeURIComponent(details));
+            vulnDetails.forEach(({ title, description }) => vulnerabilities.push({
+                title, description, range: { startLineNumber: linesBefore + 1, startColumn, endLineNumber: linesBefore + linesInside + 1, endColumn }
+            }));
+        }
+        catch (err) {
+        }
+        newText = newText.substring(0, start) + content + newText.substring(start + full.length);
+    }
+    return { newText, vulnerabilities };
+}
+
+export { annotateSpecialMarkdownContent, annotateVulnerabilitiesInText, contentRefUrl, extractCodeblockUrisFromText, extractVulnerabilitiesFromText };

package/vscode/src/vs/workbench/contrib/chat/common/chatAgents.d.ts

@@ -11,10 +11,10 @@ import { ILogService } from "../../../../platform/log/common/log.service.js";
 import { IProductService } from "../../../../platform/product/common/productService.service.js";
 import { IRequestService } from "../../../../platform/request/common/request.service.js";
 import { IStorageService } from "../../../../platform/storage/common/storage.service.js";
-import { IChatProgressHistoryResponseContent, IChatRequestVariableData, ISerializableChatAgentData } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/chatModel";
-import { IRawChatCommandContribution, RawChatParticipantLocation } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/chatParticipantContribTypes";
-import { IChatFollowup, IChatLocationData, IChatProgress, IChatResponseErrorDetails, IChatTaskDto } from "./chatService.js";
 import { IChatAgentService, type IChatAgentNameService } from "./chatAgents.service.js";
+import { IChatProgressHistoryResponseContent, IChatRequestVariableData, ISerializableChatAgentData } from "./chatModel.js";
+import { IRawChatCommandContribution, RawChatParticipantLocation } from "./chatParticipantContribTypes.js";
+import { IChatFollowup, IChatLocationData, IChatProgress, IChatResponseErrorDetails, IChatTaskDto } from "./chatService.js";
 export interface IChatAgentHistoryEntry {
     request: IChatAgentRequest;
     response: ReadonlyArray<IChatProgressHistoryResponseContent | IChatTaskDto>;
@@ -41,6 +41,7 @@ export interface IChatAgentData {
     publisherDisplayName?: string;
     extensionDisplayName: string;
     isDefault?: boolean;
+    isToolsAgent?: boolean;
     isDynamic?: boolean;
     metadata: IChatAgentMetadata;
     slashCommands: IChatAgentCommand[];
@@ -59,6 +60,7 @@ export interface IChatWelcomeMessageContent {
 export declare function isChatWelcomeMessageContent(obj: any): obj is IChatWelcomeMessageContent;
 export interface IChatAgentImplementation {
     invoke(request: IChatAgentRequest, progress: (part: IChatProgress) => void, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatAgentResult>;
+    setRequestPaused?(requestId: string, isPaused: boolean): void;
     provideFollowups?(request: IChatAgentRequest, result: IChatAgentResult, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatFollowup[]>;
     provideWelcomeMessage?(token: CancellationToken): ProviderResult<IChatWelcomeMessageContent | undefined>;
     provideChatTitle?: (history: IChatAgentHistoryEntry[], token: CancellationToken) => Promise<string | undefined>;
@@ -149,17 +151,22 @@ export interface IChatAgentCompletionItem {
 }
 export declare class ChatAgentService extends Disposable implements IChatAgentService {
     private readonly contextKeyService;
+    private readonly storageService;
     static readonly AGENT_LEADER = "@";
     _serviceBrand: undefined;
     private _agents;
     private readonly _onDidChangeAgents;
     readonly onDidChangeAgents: Event<IChatAgent | undefined>;
+    private readonly _onDidChangeToolsAgentModeEnabled;
+    readonly onDidChangeToolsAgentModeEnabled: Event<void>;
     private readonly _agentsContextKeys;
     private readonly _hasDefaultAgent;
     private readonly _defaultAgentRegistered;
     private readonly _editingAgentRegistered;
+    private readonly _agentModeContextKey;
+    private readonly _hasToolsAgentContextKey;
     private _chatParticipantDetectionProviders;
-    constructor(contextKeyService: IContextKeyService);
+    constructor(contextKeyService: IContextKeyService, storageService: IStorageService);
     registerAgent(id: string, data: IChatAgentData): IDisposable;
     private _updateAgentsContextKeys;
     private _updateContextKeys;
@@ -172,6 +179,8 @@ export declare class ChatAgentService extends Disposable implements IChatAgentSe
     getAgentCompletionItems(id: string, query: string, token: CancellationToken): Promise<IChatAgentCompletionItem[]>;
     updateAgent(id: string, updateMetadata: IChatAgentMetadata): void;
     getDefaultAgent(location: ChatAgentLocation): IChatAgent | undefined;
+    get toolsAgentModeEnabled(): boolean;
+    toggleToolsAgentMode(enabled?: boolean): void;
     getContributedDefaultAgent(location: ChatAgentLocation): IChatAgentData | undefined;
     getSecondaryAgent(): IChatAgentData | undefined;
     getAgent(id: string, includeDisabled?: boolean): IChatAgentData | undefined;
@@ -182,6 +191,7 @@ export declare class ChatAgentService extends Disposable implements IChatAgentSe
     getAgentsByName(name: string): IChatAgentData[];
     agentHasDupeName(id: string): boolean;
     invokeAgent(id: string, request: IChatAgentRequest, progress: (part: IChatProgress) => void, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatAgentResult>;
+    setRequestPaused(id: string, requestId: string, isPaused: boolean): void;
     getFollowups(id: string, request: IChatAgentRequest, result: IChatAgentResult, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatFollowup[]>;
     getChatTitle(id: string, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<string | undefined>;
     registerChatParticipantDetectionProvider(handle: number, provider: IChatParticipantDetectionProvider): IDisposable;
@@ -209,6 +219,7 @@ export declare class MergedChatAgent implements IChatAgent {
     get extensionPublisherDisplayName(): string | undefined;
     get extensionDisplayName(): string;
     get isDefault(): boolean | undefined;
+    get isToolsAgent(): boolean | undefined;
     get metadata(): IChatAgentMetadata;
     get slashCommands(): IChatAgentCommand[];
     get locations(): ChatAgentLocation[];
@@ -218,6 +229,7 @@ export declare class MergedChatAgent implements IChatAgent {
         examples: string[];
     }[];
     invoke(request: IChatAgentRequest, progress: (part: IChatProgress) => void, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatAgentResult>;
+    setRequestPaused(requestId: string, isPaused: boolean): void;
     provideFollowups(request: IChatAgentRequest, result: IChatAgentResult, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatFollowup[]>;
     provideWelcomeMessage(token: CancellationToken): ProviderResult<IChatWelcomeMessageContent | undefined>;
     provideSampleQuestions(location: ChatAgentLocation, token: CancellationToken): ProviderResult<IChatFollowup[] | undefined>;

package/vscode/src/vs/workbench/contrib/chat/common/chatAgents.js

@@ -54,14 +54,18 @@ function isChatWelcomeMessageContent(obj) {
         typeof obj.title === 'string' &&
         isMarkdownString(obj.message);
 }
+const ChatToolsAgentModeStorageKey = 'chat.toolsAgentMode';
 let ChatAgentService = class ChatAgentService extends Disposable {
     static { this.AGENT_LEADER = '@'; }
-    constructor(contextKeyService) {
+    constructor(contextKeyService, storageService) {
         super();
         this.contextKeyService = contextKeyService;
+        this.storageService = storageService;
         this._agents = ( new Map());
         this._onDidChangeAgents = ( new Emitter());
         this.onDidChangeAgents = this._onDidChangeAgents.event;
+        this._onDidChangeToolsAgentModeEnabled = ( new Emitter());
+        this.onDidChangeToolsAgentModeEnabled = this._onDidChangeToolsAgentModeEnabled.event;
         this._agentsContextKeys = ( new Set());
         this._chatParticipantDetectionProviders = ( new Map());
         this._agentCompletionProviders = ( new Map());
@@ -73,6 +77,10 @@ let ChatAgentService = class ChatAgentService extends Disposable {
                 this._updateContextKeys();
             }
         }));
+        this._agentModeContextKey = ChatContextKeys.Editing.agentMode.bindTo(contextKeyService);
+        this._hasToolsAgentContextKey = ChatContextKeys.Editing.hasToolsAgent.bindTo(contextKeyService);
+        this._agentModeContextKey.set(this.storageService.getBoolean(ChatToolsAgentModeStorageKey, StorageScope.WORKSPACE, false));
+        this._register(this.storageService.onWillSaveState(() => this.storageService.store(ChatToolsAgentModeStorageKey, this._agentModeContextKey.get(), StorageScope.WORKSPACE, StorageTarget.USER)));
     }
     registerAgent(id, data) {
         const existingAgent = this.getAgent(id);
@@ -113,9 +121,13 @@ let ChatAgentService = class ChatAgentService extends Disposable {
     _updateContextKeys() {
         let editingAgentRegistered = false;
         let defaultAgentRegistered = false;
+        let toolsAgentRegistered = false;
         for (const agent of this.getAgents()) {
             if (agent.isDefault && agent.locations.includes(ChatAgentLocation.EditingSession)) {
                 editingAgentRegistered = true;
+                if (agent.isToolsAgent) {
+                    toolsAgentRegistered = true;
+                }
             }
             else if (agent.isDefault) {
                 defaultAgentRegistered = true;
@@ -123,6 +135,10 @@ let ChatAgentService = class ChatAgentService extends Disposable {
         }
         this._editingAgentRegistered.set(editingAgentRegistered);
         this._defaultAgentRegistered.set(defaultAgentRegistered);
+        if (toolsAgentRegistered !== this._hasToolsAgentContextKey.get()) {
+            this._hasToolsAgentContextKey.set(toolsAgentRegistered);
+            this._onDidChangeAgents.fire(this.getDefaultAgent(ChatAgentLocation.EditingSession));
+        }
     }
     registerAgentImplementation(id, agentImpl) {
         const entry = this._agents.get(id);
@@ -173,7 +189,20 @@ let ChatAgentService = class ChatAgentService extends Disposable {
         this._onDidChangeAgents.fire(( new MergedChatAgent(agent.data, agent.impl)));
     }
     getDefaultAgent(location) {
-        return findLast(this.getActivatedAgents(), a => !!a.isDefault && a.locations.includes(location));
+        return findLast(this.getActivatedAgents(), a => {
+            if (location === ChatAgentLocation.EditingSession && this.toolsAgentModeEnabled !== !!a.isToolsAgent) {
+                return false;
+            }
+            return !!a.isDefault && a.locations.includes(location);
+        });
+    }
+    get toolsAgentModeEnabled() {
+        return !!this._hasToolsAgentContextKey.get() && !!this._agentModeContextKey.get();
+    }
+    toggleToolsAgentMode(enabled) {
+        this._agentModeContextKey.set(enabled ?? !this._agentModeContextKey.get());
+        this._onDidChangeToolsAgentModeEnabled.fire();
+        this._onDidChangeAgents.fire(this.getDefaultAgent(ChatAgentLocation.EditingSession));
     }
     getContributedDefaultAgent(location) {
         return this.getAgents().find(a => !!a.isDefault && a.locations.includes(location));
@@ -187,8 +216,8 @@ let ChatAgentService = class ChatAgentService extends Disposable {
         }
         return this._agents.get(id)?.data;
     }
-    _agentIsEnabled(id) {
-        const entry = this._agents.get(id);
+    _agentIsEnabled(idOrAgent) {
+        const entry = typeof idOrAgent === 'string' ? this._agents.get(idOrAgent) : idOrAgent;
         return !entry?.data.when || this.contextKeyService.contextMatchesRules(ContextKeyExpr.deserialize(entry.data.when));
     }
     getAgentByFullyQualifiedId(id) {
@@ -227,6 +256,13 @@ let ChatAgentService = class ChatAgentService extends Disposable {
         }
         return await data.impl.invoke(request, progress, history, token);
     }
+    setRequestPaused(id, requestId, isPaused) {
+        const data = this._agents.get(id);
+        if (!data?.impl) {
+            throw ( new Error(`No activated agent with id "${id}"`));
+        }
+        data.impl.setRequestPaused?.(requestId, isPaused);
+    }
     async getFollowups(id, request, result, history, token) {
         const data = this._agents.get(id);
         if (!data?.impl) {
@@ -289,7 +325,8 @@ let ChatAgentService = class ChatAgentService extends Disposable {
     }
 };
 ChatAgentService = ( __decorate([
-    ( __param(0, IContextKeyService))
+    ( __param(0, IContextKeyService)),
+    ( __param(1, IStorageService))
 ], ChatAgentService));
 class MergedChatAgent {
     constructor(data, impl) {
@@ -305,6 +342,7 @@ class MergedChatAgent {
     get extensionPublisherDisplayName() { return this.data.publisherDisplayName; }
     get extensionDisplayName() { return this.data.extensionDisplayName; }
     get isDefault() { return this.data.isDefault; }
+    get isToolsAgent() { return this.data.isToolsAgent; }
     get metadata() { return this.data.metadata; }
     get slashCommands() { return this.data.slashCommands; }
     get locations() { return this.data.locations; }
@@ -312,6 +350,11 @@ class MergedChatAgent {
     async invoke(request, progress, history, token) {
         return this.impl.invoke(request, progress, history, token);
     }
+    setRequestPaused(requestId, isPaused) {
+        if (this.impl.setRequestPaused) {
+            this.impl.setRequestPaused(requestId, isPaused);
+        }
+    }
     async provideFollowups(request, result, history, token) {
         if (this.impl.provideFollowups) {
             return this.impl.provideFollowups(request, result, history, token);

package/vscode/src/vs/workbench/contrib/chat/common/chatAgents.service.d.ts

@@ -7,6 +7,9 @@ export declare const IChatAgentService: import("../../../../platform/instantiati
 export interface IChatAgentService {
     _serviceBrand: undefined;
     readonly onDidChangeAgents: Event<IChatAgent | undefined>;
+    readonly onDidChangeToolsAgentModeEnabled: Event<void>;
+    readonly toolsAgentModeEnabled: boolean;
+    toggleToolsAgentMode(enabled?: boolean): void;
     registerAgent(id: string, data: IChatAgentData): IDisposable;
     registerAgentImplementation(id: string, agent: IChatAgentImplementation): IDisposable;
     registerDynamicAgent(data: IChatAgentData, agentImpl: IChatAgentImplementation): IDisposable;
@@ -21,6 +24,7 @@ export interface IChatAgentService {
     } | undefined>;
     hasChatParticipantDetectionProviders(): boolean;
     invokeAgent(agent: string, request: IChatAgentRequest, progress: (part: IChatProgress) => void, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatAgentResult>;
+    setRequestPaused(agent: string, requestId: string, isPaused: boolean): void;
     getFollowups(id: string, request: IChatAgentRequest, result: IChatAgentResult, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatFollowup[]>;
     getChatTitle(id: string, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<string | undefined>;
     getAgent(id: string, includeDisabled?: boolean): IChatAgentData | undefined;

package/vscode/src/vs/workbench/contrib/chat/common/chatCodeMapperService.service.d.ts

@@ -1,11 +1,10 @@
 import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { ICodeMapperProvider, ICodeMapperRequest, ICodeMapperResponse, ICodeMapperResult } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/common/chatCodeMapperService";
-import { IChatResponseModel } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/chatModel";
 export declare const ICodeMapperService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ICodeMapperService>;
 export interface ICodeMapperService {
     readonly _serviceBrand: undefined;
+    readonly providers: ICodeMapperProvider[];
     registerCodeMapperProvider(handle: number, provider: ICodeMapperProvider): IDisposable;
     mapCode(request: ICodeMapperRequest, response: ICodeMapperResponse, token: CancellationToken): Promise<ICodeMapperResult | undefined>;
-    mapCodeFromResponse(responseModel: IChatResponseModel, response: ICodeMapperResponse, token: CancellationToken): Promise<ICodeMapperResult | undefined>;
 }