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

package/vscode/src/vs/workbench/contrib/chat/browser/chatSessions/searchableOptionPickerActionItem.js

@@ -89,8 +89,8 @@ let SearchableOptionPickerActionItem = class SearchableOptionPickerActionItem ex
                 checked: false,
                 class: "searchable-picker-see-more",
                 description: undefined,
-                tooltip: ( localize(6187, "Search for more options")),
-                label: ( localize(6188, "See more...")),
+                tooltip: ( localize(6236, "Search for more options")),
+                label: ( localize(6237, "See more...")),
                 run: () => {
                     this.showSearchableQuickPick(optionGroup);
                 }
@@ -105,7 +105,7 @@ let SearchableOptionPickerActionItem = class SearchableOptionPickerActionItem ex
         if (optionGroup?.icon) {
             domChildren.push(renderIcon(optionGroup.icon));
         }
-        const label = this.currentOption?.name ?? optionGroup?.name ?? ( localize(6189, "Select..."));
+        const label = this.currentOption?.name ?? optionGroup?.name ?? ( localize(6238, "Select..."));
         domChildren.push($("span.chat-session-option-label", undefined, label));
         domChildren.push(...renderLabelWithIcons(`$(chevron-down)`));
         reset(element, ...domChildren);
@@ -120,9 +120,10 @@ let SearchableOptionPickerActionItem = class SearchableOptionPickerActionItem ex
             const disposables = ( new DisposableStore());
             const quickPick = this.quickInputService.createQuickPick();
             disposables.add(quickPick);
-            quickPick.placeholder = optionGroup.description ?? ( localize(6190, "Select {0}", optionGroup.name));
+            quickPick.placeholder = optionGroup.description ?? ( localize(6239, "Select {0}", optionGroup.name));
             quickPick.matchOnDescription = true;
             quickPick.matchOnDetail = true;
+            quickPick.matchOnLabelMode = "fuzzy";
             quickPick.ignoreFocusOut = true;
             quickPick.busy = true;
             quickPick.show();

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

@@ -0,0 +1,24 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { Action2 } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { ILifecycleService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+import { IUserDataProfileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service";
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service";
+export declare class UserToolSetsContributions extends Disposable implements IWorkbenchContribution {
+    private readonly _languageModelToolsService;
+    private readonly _userDataProfileService;
+    private readonly _fileService;
+    private readonly _logService;
+    static readonly ID = "chat.userToolSets";
+    constructor(extensionService: IExtensionService, lifecycleService: ILifecycleService, _languageModelToolsService: ILanguageModelToolsService, _userDataProfileService: IUserDataProfileService, _fileService: IFileService, _logService: ILogService);
+    private _initToolSets;
+}
+export declare class ConfigureToolSets extends Action2 {
+    static readonly ID = "chat.configureToolSets";
+    constructor();
+    run(accessor: ServicesAccessor): Promise<void>;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/tools/toolSetsContribution.js

@@ -0,0 +1,384 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { isFalsyOrEmpty } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { basename, joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { isFalsyOrWhitespace } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { isObject, assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Action2, MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { LifecyclePhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { IUserDataProfileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
+import { CHAT_CONFIG_MENU_ID, CHAT_CATEGORY } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { getAllCodicons, Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { isValidBasename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/extpath';
+import { ITextFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service';
+import { parse } from '@codingame/monaco-vscode-api/vscode/vs/base/common/jsonc';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/jsonschemas/common/jsonContributionRegistry';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { ChatViewId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+
+const toolEnumValues = [];
+const toolEnumDescriptions = [];
+const toolSetSchemaId = "vscode://schemas/toolsets";
+const toolSetsSchema = {
+    id: toolSetSchemaId,
+    allowComments: true,
+    allowTrailingCommas: true,
+    defaultSnippets: [{
+        label: ( localize(6683, "Empty tool set")),
+        body: {
+            "${1:toolSetName}": {
+                "tools": ["${2:someTool}", "${3:anotherTool}"],
+                "description": "${4:description}",
+                "icon": "${5:tools}"
+            }
+        }
+    }],
+    type: "object",
+    description: ( localize(6684, "User tool sets configuration")),
+    additionalProperties: {
+        type: "object",
+        required: ["tools"],
+        additionalProperties: false,
+        properties: {
+            tools: {
+                description: ( localize(
+                    6685,
+                    "A list of tools or tool sets to include in this tool set. Cannot be empty and must reference tools the way they are referenced in prompts."
+                )),
+                type: "array",
+                minItems: 1,
+                items: {
+                    type: "string",
+                    enum: toolEnumValues,
+                    enumDescriptions: toolEnumDescriptions
+                }
+            },
+            icon: {
+                description: ( localize(
+                    6686,
+                    "Icon to use for this tool set in the UI. Uses the \"\\$(name)\"-syntax, like \"\\$(zap)\""
+                )),
+                type: "string",
+                enum: Array.from(getAllCodicons(), icon => icon.id),
+                markdownEnumDescriptions: Array.from(getAllCodicons(), icon => `$(${icon.id})`)
+            },
+            description: {
+                description: ( localize(6687, "A short description of this tool set.")),
+                type: "string"
+            }
+        }
+    }
+};
+const reg = ( Registry.as(Extensions.JSONContribution));
+class RawToolSetsShape {
+    static {
+        this.suffix = ".toolsets.jsonc";
+    }
+    static isToolSetFileName(uri) {
+        return basename(uri).endsWith(RawToolSetsShape.suffix);
+    }
+    static from(data, logService) {
+        if (!isObject(data)) {
+            throw ( new Error(`Invalid tool set data`));
+        }
+        const map = ( new Map());
+        for (const [name, value] of Object.entries(data)) {
+            if (isFalsyOrWhitespace(name)) {
+                logService.error(`Tool set name cannot be empty`);
+            }
+            if (isFalsyOrEmpty(value.tools)) {
+                logService.error(`Tool set '${name}' cannot have an empty tools array`);
+            }
+            map.set(name, {
+                name,
+                tools: value.tools,
+                description: value.description,
+                icon: value.icon
+            });
+        }
+        return new class extends RawToolSetsShape {}(map);
+    }
+    constructor(entries) {
+        this.entries = ( Object.freeze(( new Map(entries))));
+    }
+}
+let UserToolSetsContributions = class UserToolSetsContributions extends Disposable {
+    static {
+        this.ID = "chat.userToolSets";
+    }
+    constructor(
+        extensionService,
+        lifecycleService,
+        _languageModelToolsService,
+        _userDataProfileService,
+        _fileService,
+        _logService
+    ) {
+        super();
+        this._languageModelToolsService = _languageModelToolsService;
+        this._userDataProfileService = _userDataProfileService;
+        this._fileService = _fileService;
+        this._logService = _logService;
+        Promise.allSettled([
+            extensionService.whenInstalledExtensionsRegistered,
+            lifecycleService.when(LifecyclePhase.Restored)
+        ]).then(() => this._initToolSets());
+        const toolsObs = observableFromEvent(
+            this,
+            _languageModelToolsService.onDidChangeTools,
+            () => Array.from(_languageModelToolsService.getAllToolsIncludingDisabled())
+        );
+        const store = this._store.add(( new DisposableStore()));
+        this._store.add(autorun(r => {
+            const tools = toolsObs.read(r);
+            const toolSets = this._languageModelToolsService.toolSets.read(r);
+            const data = [];
+            for (const tool of tools) {
+                if (tool.canBeReferencedInPrompt) {
+                    data.push({
+                        name: tool.toolReferenceName ?? tool.displayName,
+                        sourceLabel: ToolDataSource.classify(tool.source).label,
+                        sourceOrdinal: ToolDataSource.classify(tool.source).ordinal,
+                        description: tool.userDescription ?? tool.modelDescription
+                    });
+                }
+            }
+            for (const toolSet of toolSets) {
+                data.push({
+                    name: toolSet.referenceName,
+                    sourceLabel: ToolDataSource.classify(toolSet.source).label,
+                    sourceOrdinal: ToolDataSource.classify(toolSet.source).ordinal,
+                    description: toolSet.description
+                });
+            }
+            toolEnumValues.length = 0;
+            toolEnumDescriptions.length = 0;
+            data.sort((a, b) => {
+                if (a.sourceOrdinal !== b.sourceOrdinal) {
+                    return a.sourceOrdinal - b.sourceOrdinal;
+                }
+                if (a.sourceLabel !== b.sourceLabel) {
+                    return a.sourceLabel.localeCompare(b.sourceLabel);
+                }
+                return a.name.localeCompare(b.name);
+            });
+            for (const item of data) {
+                toolEnumValues.push(item.name);
+                toolEnumDescriptions.push(( localize(6688, "{1} ({0})\n\n{2}", item.sourceLabel, item.name, item.description)));
+            }
+            store.clear();
+            reg.registerSchema(toolSetSchemaId, toolSetsSchema, store);
+        }));
+    }
+    _initToolSets() {
+        const promptFolder = observableFromEvent(
+            this,
+            this._userDataProfileService.onDidChangeCurrentProfile,
+            () => this._userDataProfileService.currentProfile.promptsHome
+        );
+        const toolsSig = observableSignalFromEvent(this, this._languageModelToolsService.onDidChangeTools);
+        const fileEventSig = observableSignalFromEvent(
+            this,
+            Event.filter(this._fileService.onDidFilesChange, e => e.affects(promptFolder.get()))
+        );
+        const store = this._store.add(( new DisposableStore()));
+        const getFilesInFolder = async folder => {
+            try {
+                return (await this._fileService.resolve(folder)).children ?? [];
+            } catch (err) {
+                return [];
+            }
+        };
+        this._store.add(autorun(async r => {
+            store.clear();
+            toolsSig.read(r);
+            fileEventSig.read(r);
+            const uri = promptFolder.read(r);
+            const cts = ( new CancellationTokenSource());
+            store.add(toDisposable(() => cts.dispose(true)));
+            const entries = await getFilesInFolder(uri);
+            if (cts.token.isCancellationRequested) {
+                return;
+            }
+            for (const entry of entries) {
+                if (!entry.isFile || !RawToolSetsShape.isToolSetFileName(entry.resource)) {
+                    continue;
+                }
+                store.add(this._fileService.watch(entry.resource));
+                let data;
+                try {
+                    const content = await this._fileService.readFile(entry.resource, undefined, cts.token);
+                    const rawObj = parse(( content.value.toString()));
+                    data = RawToolSetsShape.from(rawObj, this._logService);
+                } catch (err) {
+                    this._logService.error(`Error reading tool set file ${( entry.resource.toString())}:`, err);
+                    continue;
+                }
+                if (cts.token.isCancellationRequested) {
+                    return;
+                }
+                for (const [name, value] of data.entries) {
+                    const tools = [];
+                    const toolSets = [];
+                    value.tools.forEach(name => {
+                        const tool = this._languageModelToolsService.getToolByName(name);
+                        if (tool) {
+                            tools.push(tool);
+                            return;
+                        }
+                        const toolSet = this._languageModelToolsService.getToolSetByName(name);
+                        if (toolSet) {
+                            toolSets.push(toolSet);
+                            return;
+                        }
+                    });
+                    if (tools.length === 0 && toolSets.length === 0) {
+                        continue;
+                    }
+                    const toolset = this._languageModelToolsService.createToolSet({
+                        type: "user",
+                        file: entry.resource,
+                        label: basename(entry.resource)
+                    }, `user/${( entry.resource.toString())}/${name}`, name, {
+                        icon: value.icon ? ThemeIcon.fromId(value.icon) : undefined,
+                        description: value.description
+                    });
+                    transaction(tx => {
+                        store.add(toolset);
+                        tools.forEach(tool => store.add(toolset.addTool(tool, tx)));
+                        toolSets.forEach(toolSet => store.add(toolset.addToolSet(toolSet, tx)));
+                    });
+                }
+            }
+        }));
+    }
+};
+UserToolSetsContributions = ( __decorate([( __param(0, IExtensionService)), ( __param(1, ILifecycleService)), ( __param(2, ILanguageModelToolsService)), ( __param(3, IUserDataProfileService)), ( __param(4, IFileService)), ( __param(5, ILogService))], UserToolSetsContributions));
+class ConfigureToolSets extends Action2 {
+    static {
+        this.ID = "chat.configureToolSets";
+    }
+    constructor() {
+        super({
+            id: ConfigureToolSets.ID,
+            title: ( localize2(6689, "Configure Tool Sets...")),
+            shortTitle: ( localize(6690, "Tool Sets")),
+            category: CHAT_CATEGORY,
+            f1: true,
+            precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ChatContextKeys.Tools.toolsCount.greater(0))),
+            menu: [{
+                id: CHAT_CONFIG_MENU_ID,
+                when: ( ContextKeyExpr.equals("view", ChatViewId)),
+                order: 11,
+                group: "2_level"
+            }, {
+                id: MenuId.ViewTitle,
+                when: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ContextKeyExpr.equals("view", ChatViewId)), ( ContextKeyExpr.has(`config.${ChatConfiguration.ChatCustomizationMenuEnabled}`)))),
+                order: 11,
+                group: "2_level"
+            }]
+        });
+    }
+    async run(accessor) {
+        const toolsService = accessor.get(ILanguageModelToolsService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const editorService = accessor.get(IEditorService);
+        const userDataProfileService = accessor.get(IUserDataProfileService);
+        const fileService = accessor.get(IFileService);
+        const textFileService = accessor.get(ITextFileService);
+        const picks = [];
+        picks.push({
+            label: ( localize(6691, "Create new tool sets file...")),
+            alwaysShow: true,
+            iconClass: ThemeIcon.asClassName(Codicon.plus)
+        });
+        for (const toolSet of toolsService.toolSets.get()) {
+            if (toolSet.source.type !== "user") {
+                continue;
+            }
+            picks.push({
+                label: toolSet.referenceName,
+                toolset: toolSet,
+                tooltip: toolSet.description,
+                iconClass: ThemeIcon.asClassName(toolSet.icon)
+            });
+        }
+        const pick = await quickInputService.pick(picks, {
+            canPickMany: false,
+            placeHolder: ( localize(6692, "Select a tool set to configure"))
+        });
+        if (!pick) {
+            return;
+        }
+        let resource;
+        if (!pick.toolset) {
+            const name = await quickInputService.input({
+                placeHolder: ( localize(6693, "Type tool sets file name")),
+                validateInput: async input => {
+                    if (!input) {
+                        return localize(6694, "Invalid file name");
+                    }
+                    if (!isValidBasename(input)) {
+                        return localize(6695, "'{0}' is not a valid file name", input);
+                    }
+                    return undefined;
+                }
+            });
+            if (isFalsyOrWhitespace(name)) {
+                return;
+            }
+            resource = joinPath(
+                userDataProfileService.currentProfile.promptsHome,
+                `${name}${RawToolSetsShape.suffix}`
+            );
+            if (!(await fileService.exists(resource))) {
+                await textFileService.write(resource, [
+                    "// Place your tool sets here...",
+                    "// Example:",
+                    "// {",
+                    "// \t\"toolSetName\": {",
+                    "// \t\t\"tools\": [",
+                    "// \t\t\t\"someTool\",",
+                    "// \t\t\t\"anotherTool\"",
+                    "// \t\t],",
+                    "// \t\t\"description\": \"description\",",
+                    "// \t\t\"icon\": \"tools\"",
+                    "// \t}",
+                    "// }"
+                ].join("\n"));
+            }
+        } else {
+            assertType(pick.toolset.source.type === "user");
+            resource = pick.toolset.source.file;
+        }
+        await editorService.openEditor({
+            resource,
+            options: {
+                pinned: true
+            }
+        });
+    }
+}
+
+export { ConfigureToolSets, UserToolSetsContributions };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatAgentHover.js

@@ -49,7 +49,7 @@ let ChatAgentHover = class ChatAgentHover extends Disposable {
         this.publisherName = $("span.chat-agent-hover-publisher-name");
         append(hoverElement.publisher, verifiedBadge, this.publisherName);
         hoverElement.warning.appendChild(renderIcon(Codicon.warning));
-        hoverElement.warning.appendChild($("span", undefined, ( localize(6657, "This chat extension is using a reserved name."))));
+        hoverElement.warning.appendChild($("span", undefined, ( localize(6708, "This chat extension is using a reserved name."))));
     }
     setAgent(id) {
         const agent = this.chatAgentService.getAgent(id);
@@ -95,7 +95,7 @@ function getChatAgentHoverOptions(getAgent, commandService) {
     return {
         actions: [{
             commandId: showExtensionsWithIdsCommandId,
-            label: ( localize(6658, "View Extension")),
+            label: ( localize(6709, "View Extension")),
             run: () => {
                 const agent = getAgent();
                 if (agent) {

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

@@ -1,31 +1,36 @@
 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 { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
 import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IFileDialogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service";
 import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
 import { IChatArtifactsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/chatArtifactsService.service";
+import { IChatImageCarouselService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatImageCarouselService.service";
 export declare class ChatArtifactsWidget extends Disposable {
     private readonly _chatArtifactsService;
     private readonly _instantiationService;
     private readonly _openerService;
     private readonly _configurationService;
-    private readonly _commandService;
     private readonly _fileService;
+    private readonly _fileDialogService;
+    private readonly _chatImageCarouselService;
     readonly domNode: HTMLElement;
     private readonly _autorunDisposable;
-    private _currentObs;
+    private _currentArtifacts;
     private _isCollapsed;
-    private _list;
-    private readonly _listStore;
+    private _tree;
+    private readonly _treeStore;
     private _expandIcon;
     private _titleElement;
+    private _clearButton;
     static readonly ELEMENT_HEIGHT = 22;
     private static readonly MAX_ITEMS_SHOWN;
-    private _sessionResource;
-    constructor(_chatArtifactsService: IChatArtifactsService, _instantiationService: IInstantiationService, _openerService: IOpenerService, _configurationService: IConfigurationService, _commandService: ICommandService, _fileService: IFileService);
+    constructor(_chatArtifactsService: IChatArtifactsService, _instantiationService: IInstantiationService, _openerService: IOpenerService, _configurationService: IConfigurationService, _fileService: IFileService, _fileDialogService: IFileDialogService, _chatImageCarouselService: IChatImageCarouselService);
     render(sessionResource: URI): void;
+    private _openGroupInCarousel;
     private _openScreenshotInCarousel;
+    private _clearAllArtifacts;
+    private _saveArtifact;
     hide(): void;
 }