@codingame/monaco-vscode-katex-common 24.1.0

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

@@ -0,0 +1,31 @@
+import { IAction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { IActionWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IChatEntitlementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service";
+import { ActionWidgetDropdownActionViewItem } from "../../../../../platform/actions/browser/actionWidgetDropdownActionViewItem.js";
+import { IChatSessionProviderOptionGroup, IChatSessionProviderOptionItem } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+export interface IChatSessionPickerDelegate {
+    readonly onDidChangeOption: Event<IChatSessionProviderOptionItem>;
+    getCurrentOption(): IChatSessionProviderOptionItem | undefined;
+    setOption(option: IChatSessionProviderOptionItem): void;
+    getAllOptions(): IChatSessionProviderOptionItem[];
+}
+/**
+ * Action view item for making an option selection for a contributed chat session
+ * These options are provided by the relevant ChatSession Provider
+ */
+export declare class ChatSessionPickerActionItem extends ActionWidgetDropdownActionViewItem {
+    private readonly delegate;
+    currentOption: IChatSessionProviderOptionItem | undefined;
+    constructor(action: IAction, initialState: {
+        group: IChatSessionProviderOptionGroup;
+        item: IChatSessionProviderOptionItem | undefined;
+    }, delegate: IChatSessionPickerDelegate, actionWidgetService: IActionWidgetService, contextKeyService: IContextKeyService, commandService: ICommandService, chatEntitlementService: IChatEntitlementService, keybindingService: IKeybindingService, telemetryService: ITelemetryService);
+    protected renderLabel(element: HTMLElement): IDisposable | null;
+    render(container: HTMLElement): void;
+}

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

@@ -0,0 +1,101 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as chatSessionAction from './media/chatSessionAction.css';
+import { $, reset } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { IActionWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+import { ActionWidgetDropdownActionViewItem } from '../../../../../platform/actions/browser/actionWidgetDropdownActionViewItem.js';
+import { renderIcon, renderLabelWithIcons } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/iconLabel/iconLabels';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+
+registerCss(chatSessionAction);
+let ChatSessionPickerActionItem = class ChatSessionPickerActionItem extends ActionWidgetDropdownActionViewItem {
+    constructor(action, initialState, delegate, actionWidgetService, contextKeyService, commandService, chatEntitlementService, keybindingService, telemetryService) {
+        const { group, item } = initialState;
+        const actionWithLabel = {
+            ...action,
+            label: item?.name || group.name,
+            tooltip: item?.description ?? group.description ?? group.name,
+            run: () => { }
+        };
+        const sessionPickerActionWidgetOptions = {
+            actionProvider: {
+                getActions: () => {
+                    const currentOption = this.delegate.getCurrentOption();
+                    if (currentOption?.locked) {
+                        return [{
+                                id: currentOption.id,
+                                enabled: false,
+                                icon: currentOption.icon,
+                                checked: true,
+                                class: undefined,
+                                description: undefined,
+                                tooltip: currentOption.description ?? currentOption.name,
+                                label: currentOption.name,
+                                run: () => { }
+                            }];
+                    }
+                    else {
+                        return ( this.delegate.getAllOptions().map(optionItem => {
+                            const isCurrent = optionItem.id === this.delegate.getCurrentOption()?.id;
+                            return {
+                                id: optionItem.id,
+                                enabled: true,
+                                icon: optionItem.icon,
+                                checked: isCurrent,
+                                class: undefined,
+                                description: undefined,
+                                tooltip: optionItem.description ?? optionItem.name,
+                                label: optionItem.name,
+                                run: () => {
+                                    this.delegate.setOption(optionItem);
+                                }
+                            };
+                        }));
+                    }
+                }
+            },
+            actionBarActionProvider: undefined,
+        };
+        super(actionWithLabel, sessionPickerActionWidgetOptions, actionWidgetService, keybindingService, contextKeyService);
+        this.delegate = delegate;
+        this.currentOption = item;
+        this._register(this.delegate.onDidChangeOption(newOption => {
+            this.currentOption = newOption;
+            if (this.element) {
+                this.renderLabel(this.element);
+            }
+        }));
+    }
+    renderLabel(element) {
+        const domChildren = [];
+        element.classList.add('chat-session-option-picker');
+        if (this.currentOption?.icon) {
+            domChildren.push(renderIcon(this.currentOption.icon));
+        }
+        domChildren.push($('span.chat-session-option-label', undefined, this.currentOption?.name ?? ( localize(5503, "Pick Option"))));
+        domChildren.push(...renderLabelWithIcons(`$(chevron-down)`));
+        reset(element, ...domChildren);
+        this.setAriaLabelAttributes(element);
+        return null;
+    }
+    render(container) {
+        super.render(container);
+        container.classList.add('chat-sessionPicker-item');
+    }
+};
+ChatSessionPickerActionItem = ( __decorate([
+    ( __param(3, IActionWidgetService)),
+    ( __param(4, IContextKeyService)),
+    ( __param(5, ICommandService)),
+    ( __param(6, IChatEntitlementService)),
+    ( __param(7, IKeybindingService)),
+    ( __param(8, ITelemetryService))
+], ChatSessionPickerActionItem));
+
+export { ChatSessionPickerActionItem };

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

@@ -0,0 +1,19 @@
+import { EditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorInput";
+import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
+import { IChatSessionItem, IChatSessionItemProvider } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
+import { ChatEditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatEditorInput";
+export declare const NEW_CHAT_SESSION_ACTION_ID = "workbench.action.chat.openNewSessionEditor";
+export type ChatSessionItemWithProvider = IChatSessionItem & {
+    readonly provider: IChatSessionItemProvider;
+    relativeTime?: string;
+    relativeTimeFullWord?: string;
+    hideRelativeTime?: boolean;
+};
+export declare function isChatSession(schemes: readonly string[], editor?: EditorInput): editor is ChatEditorInput;
+export declare function extractTimestamp(item: IChatSessionItem): number | undefined;
+export declare function processSessionsWithTimeGrouping(sessions: ChatSessionItemWithProvider[]): ChatSessionItemWithProvider[];
+export declare function getSessionItemContextOverlay(session: IChatSessionItem, provider?: IChatSessionItemProvider, chatService?: IChatService, editorGroupsService?: IEditorGroupsService): [
+    string,
+    any
+][];

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

@@ -0,0 +1,76 @@
+
+import { fromNow } from '@codingame/monaco-vscode-api/vscode/vs/base/common/date';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { localChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
+
+const NEW_CHAT_SESSION_ACTION_ID = 'workbench.action.chat.openNewSessionEditor';
+function updateRelativeTime(item, lastRelativeTime) {
+    if (item.timing?.startTime) {
+        item.relativeTime = fromNow(item.timing.startTime);
+        item.relativeTimeFullWord = fromNow(item.timing.startTime, false, true);
+        if (lastRelativeTime === undefined || item.relativeTime !== lastRelativeTime) {
+            lastRelativeTime = item.relativeTime;
+            item.hideRelativeTime = false;
+        }
+        else {
+            item.hideRelativeTime = true;
+        }
+    }
+    else {
+        item.relativeTime = undefined;
+        item.relativeTimeFullWord = undefined;
+        item.hideRelativeTime = false;
+    }
+    return lastRelativeTime;
+}
+function extractTimestamp(item) {
+    if (item.timing?.startTime) {
+        return item.timing.startTime;
+    }
+    if ('timestamp' in item) {
+        return item.timestamp;
+    }
+    return undefined;
+}
+function sortSessionsByTimestamp(sessions) {
+    sessions.sort((a, b) => {
+        const aTime = a.timing?.startTime ?? 0;
+        const bTime = b.timing?.startTime ?? 0;
+        return bTime - aTime;
+    });
+}
+function applyTimeGrouping(sessions) {
+    let lastRelativeTime;
+    sessions.forEach(session => {
+        lastRelativeTime = updateRelativeTime(session, lastRelativeTime);
+    });
+}
+function processSessionsWithTimeGrouping(sessions) {
+    const sessionsTemp = [...sessions];
+    if (( sessions.some(session => session.timing?.startTime !== undefined))) {
+        sortSessionsByTimestamp(sessionsTemp);
+        applyTimeGrouping(sessionsTemp);
+    }
+    return sessionsTemp;
+}
+function getSessionItemContextOverlay(session, provider, chatService, editorGroupsService
+) {
+    const overlay = [];
+    if (provider) {
+        overlay.push([ChatContextKeys.agentSessionType.key, provider.chatSessionType]);
+    }
+    overlay.push([ChatContextKeys.isArchivedAgentSession.key, session.archived]);
+    let isActiveSession = false;
+    if (!session.archived && provider?.chatSessionType === localChatSessionType) {
+        isActiveSession = true;
+    }
+    else if (session.archived && chatService && editorGroupsService) {
+        isActiveSession = !!chatService.getSession(session.resource);
+    }
+    overlay.push([ChatContextKeys.isActiveAgentSession.key, isActiveSession]);
+    return overlay;
+}
+
+export { NEW_CHAT_SESSION_ACTION_ID, extractTimestamp, getSessionItemContextOverlay, processSessionsWithTimeGrouping };

package/vscode/src/vs/workbench/contrib/chat/browser/chatSessions/media/chatSessionAction.css

@@ -0,0 +1,39 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/* .chat-session-option-picker {
+	align-items: center;
+} */
+
+/* .chat-session-option-picker .chat-session-option-label {
+	overflow: hidden;
+	text-overflow: ellipsis;
+}
+
+.chat-session-option-picker */
+
+.monaco-action-bar .action-item.chat-sessionPicker-item {
+	overflow: hidden;
+}
+
+.monaco-action-bar .action-item .chat-session-option-picker {
+	align-items: center;
+	overflow: hidden;
+
+	.chat-session-option-label {
+		overflow: hidden;
+		text-overflow: ellipsis;
+	}
+
+	span.codicon {
+		font-size: 12px;
+		margin-left: 2px;
+	}
+
+	span.codicon.codicon-chevron-down {
+		font-size: 12px;
+		margin-left: 2px;
+	}
+}

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

@@ -0,0 +1,292 @@
+import { IMouseWheelEvent } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/mouseEvent";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ICodeEditor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
+import { ICodeEditorService } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service";
+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 { IContextMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextview/browser/contextView.service";
+import { IInstantiationService } 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 { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IChatEntitlementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service";
+import { ILifecycleService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+import { IChatAgentAttachmentCapabilities, IChatAgentCommand, IChatAgentData } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents";
+import { IChatAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service";
+import { IChatEditingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService.service";
+import { IChatLayoutService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatLayoutService.service";
+import { IChatModel, IChatModelInputState, IChatResponseModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModel";
+import { IChatModeService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes.service";
+import { IParsedChatRequest } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatParserTypes";
+import { IChatLocationData, IChatSendRequestOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
+import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
+import { IChatSlashCommandService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSlashCommands.service";
+import { IChatTodoListService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatTodoListService.service";
+import { ChatViewModel, IChatResponseViewModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatViewModel";
+import { ChatAgentLocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service";
+import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service";
+import { ChatTreeItem, IChatAcceptInputOptions, IChatCodeBlockInfo, IChatFileTreeInfo, IChatWidget, IChatWidgetViewContext, IChatWidgetViewOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+import { IChatAccessibilityService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { ChatAttachmentModel } from "./chatAttachmentModel.js";
+import { ChatInputPart, IChatInputStyles } from "./chatInputPart.js";
+import { IAgentSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service";
+export interface IChatWidgetStyles extends IChatInputStyles {
+    readonly inputEditorBackground: string;
+    readonly resultEditorBackground: string;
+}
+export interface IChatWidgetContrib extends IDisposable {
+    readonly id: string;
+    /**
+     * A piece of state which is related to the input editor of the chat widget.
+     * Takes in the `contrib` object that will be saved in the {@link IChatModelInputState}.
+     */
+    getInputState?(contrib: Record<string, unknown>): void;
+    /**
+     * Called with the result of getInputState when navigating input history.
+     */
+    setInputState?(contrib: Readonly<Record<string, unknown>>): void;
+}
+export interface IChatWidgetLocationOptions {
+    location: ChatAgentLocation;
+    resolveData?(): IChatLocationData | undefined;
+}
+export declare function isQuickChat(widget: IChatWidget): boolean;
+export declare class ChatWidget extends Disposable implements IChatWidget {
+    private readonly viewOptions;
+    private readonly styles;
+    private readonly codeEditorService;
+    private readonly editorService;
+    private readonly configurationService;
+    private readonly contextKeyService;
+    private readonly instantiationService;
+    private readonly chatService;
+    private readonly chatAgentService;
+    private readonly chatWidgetService;
+    private readonly contextMenuService;
+    private readonly chatAccessibilityService;
+    private readonly logService;
+    private readonly themeService;
+    private readonly chatSlashCommandService;
+    private readonly telemetryService;
+    private readonly promptsService;
+    private readonly toolsService;
+    private readonly chatModeService;
+    private readonly chatLayoutService;
+    private readonly chatEntitlementService;
+    private readonly chatSessionsService;
+    private readonly agentSessionsService;
+    private readonly chatTodoListService;
+    private readonly contextService;
+    private readonly lifecycleService;
+    static readonly CONTRIBS: {
+        new (...args: [
+            IChatWidget,
+            ...any
+        ]): IChatWidgetContrib;
+    }[];
+    private readonly _onDidSubmitAgent;
+    readonly onDidSubmitAgent: Event<{
+        agent: IChatAgentData;
+        slashCommand?: IChatAgentCommand;
+    }>;
+    private _onDidChangeAgent;
+    readonly onDidChangeAgent: Event<{
+        agent: IChatAgentData;
+        slashCommand?: IChatAgentCommand;
+    }>;
+    private _onDidFocus;
+    readonly onDidFocus: Event<void>;
+    private _onDidChangeViewModel;
+    readonly onDidChangeViewModel: Event<void>;
+    private _onDidScroll;
+    readonly onDidScroll: Event<void>;
+    private _onDidAcceptInput;
+    readonly onDidAcceptInput: Event<void>;
+    private _onDidHide;
+    readonly onDidHide: Event<void>;
+    private _onDidShow;
+    readonly onDidShow: Event<void>;
+    private _onDidChangeParsedInput;
+    readonly onDidChangeParsedInput: Event<void>;
+    private readonly _onWillMaybeChangeHeight;
+    readonly onWillMaybeChangeHeight: Event<void>;
+    private _onDidChangeHeight;
+    readonly onDidChangeHeight: Event<number>;
+    private readonly _onDidChangeContentHeight;
+    readonly onDidChangeContentHeight: Event<void>;
+    private _onDidChangeEmptyState;
+    readonly onDidChangeEmptyState: Event<void>;
+    contribs: ReadonlyArray<IChatWidgetContrib>;
+    private listContainer;
+    private container;
+    get domNode(): HTMLElement;
+    private tree;
+    private renderer;
+    private readonly _codeBlockModelCollection;
+    private lastItem;
+    private readonly visibilityTimeoutDisposable;
+    private readonly inputPartDisposable;
+    private readonly inlineInputPartDisposable;
+    private inputContainer;
+    private focusedInputDOM;
+    private editorOptions;
+    private recentlyRestoredCheckpoint;
+    private settingChangeCounter;
+    private welcomeMessageContainer;
+    private readonly welcomePart;
+    private readonly chatSuggestNextWidget;
+    private bodyDimension;
+    private visibleChangeCount;
+    private requestInProgress;
+    private agentInInput;
+    private currentRequest;
+    private _visible;
+    get visible(): boolean;
+    private previousTreeScrollHeight;
+    /**
+     * Whether the list is scroll-locked to the bottom. Initialize to true so that we can scroll to the bottom on first render.
+     * The initial render leads to a lot of `onDidChangeTreeContentHeight` as the renderer works out the real heights of rows.
+    */
+    private scrollLock;
+    private _instructionFilesCheckPromise;
+    private _instructionFilesExist;
+    private _isRenderingWelcome;
+    private _lockedAgent?;
+    private readonly _lockedToCodingAgentContextKey;
+    private readonly _agentSupportsAttachmentsContextKey;
+    private readonly _sessionIsEmptyContextKey;
+    private _attachmentCapabilities;
+    private readonly promptDescriptionsCache;
+    private readonly promptUriCache;
+    private _isLoadingPromptDescriptions;
+    private _mostRecentlyFocusedItemIndex;
+    private readonly viewModelDisposables;
+    private _viewModel;
+    private set viewModel(value);
+    get viewModel(): ChatViewModel | undefined;
+    private readonly _editingSession;
+    private parsedChatRequest;
+    get parsedInput(): IParsedChatRequest;
+    get scopedContextKeyService(): IContextKeyService;
+    private readonly _location;
+    get location(): ChatAgentLocation;
+    readonly viewContext: IChatWidgetViewContext;
+    get supportsChangingModes(): boolean;
+    get locationData(): IChatLocationData | undefined;
+    constructor(location: ChatAgentLocation | IChatWidgetLocationOptions, viewContext: IChatWidgetViewContext | undefined, viewOptions: IChatWidgetViewOptions, styles: IChatWidgetStyles, codeEditorService: ICodeEditorService, editorService: IEditorService, configurationService: IConfigurationService, contextKeyService: IContextKeyService, instantiationService: IInstantiationService, chatService: IChatService, chatAgentService: IChatAgentService, chatWidgetService: IChatWidgetService, contextMenuService: IContextMenuService, chatAccessibilityService: IChatAccessibilityService, logService: ILogService, themeService: IThemeService, chatSlashCommandService: IChatSlashCommandService, chatEditingService: IChatEditingService, telemetryService: ITelemetryService, promptsService: IPromptsService, toolsService: ILanguageModelToolsService, chatModeService: IChatModeService, chatLayoutService: IChatLayoutService, chatEntitlementService: IChatEntitlementService, chatSessionsService: IChatSessionsService, agentSessionsService: IAgentSessionsService, chatTodoListService: IChatTodoListService, contextService: IWorkspaceContextService, lifecycleService: ILifecycleService);
+    private _lastSelectedAgent;
+    set lastSelectedAgent(agent: IChatAgentData | undefined);
+    get lastSelectedAgent(): IChatAgentData | undefined;
+    private _updateAgentCapabilitiesContextKeys;
+    get supportsFileReferences(): boolean;
+    get attachmentCapabilities(): IChatAgentAttachmentCapabilities;
+    get input(): ChatInputPart;
+    private get inputPart();
+    private get inlineInputPart();
+    get inputEditor(): ICodeEditor;
+    get contentHeight(): number;
+    get attachmentModel(): ChatAttachmentModel;
+    render(parent: HTMLElement): void;
+    private scrollToEnd;
+    focusInput(): void;
+    hasInputFocus(): boolean;
+    refreshParsedInput(): void;
+    getSibling(item: ChatTreeItem, type: "next" | "previous"): ChatTreeItem | undefined;
+    clear(): Promise<void>;
+    private onDidChangeItems;
+    /**
+     * Updates the DOM visibility of welcome view and chat list immediately
+     */
+    private updateChatViewVisibility;
+    isEmpty(): boolean;
+    /**
+     * Renders the welcome view content when needed.
+     */
+    private renderWelcomeViewContentIfNeeded;
+    private _getGenerateInstructionsMessage;
+    /**
+     * Checks if any agent instruction files (.github/copilot-instructions.md or AGENTS.md) exist in the workspace.
+     * Used to determine whether to show the "Generate Agent Instructions" hint.
+     *
+     * @returns true if instruction files exist OR if instruction features are disabled (to hide the hint)
+     */
+    private _checkForAgentInstructionFiles;
+    private getWelcomeViewContent;
+    private getPromptFileSuggestions;
+    private loadPromptDescriptions;
+    private renderChatEditingSessionState;
+    private renderFollowups;
+    private renderChatSuggestNextWidget;
+    private handleNextPromptSelection;
+    handleDelegationExitIfNeeded(sourceAgent: Pick<IChatAgentData, "id" | "name"> | undefined, targetAgent: IChatAgentData | undefined): Promise<void>;
+    private _shouldExitAfterDelegation;
+    /**
+     * Handles the exit of the panel chat when a delegation to another session occurs.
+     * Waits for the response to complete and any pending confirmations to be resolved,
+     * then clears the widget unless the final message is an error.
+     */
+    private _handleDelegationExit;
+    private archiveLocalParentSession;
+    setVisible(visible: boolean): void;
+    private createList;
+    startEditing(requestId: string): void;
+    private clickedRequest;
+    finishedEditing(completedEdit?: boolean): void;
+    private scrollToCurrentItem;
+    private onContextMenu;
+    private onDidChangeTreeContentHeight;
+    private getWidgetViewKindTag;
+    private createInput;
+    private onDidStyleChange;
+    setModel(model: IChatModel | undefined): void;
+    getFocus(): ChatTreeItem | undefined;
+    reveal(item: ChatTreeItem, relativeTop?: number): void;
+    focus(item: ChatTreeItem): void;
+    setInputPlaceholder(placeholder: string): void;
+    resetInputPlaceholder(): void;
+    setInput(value?: string): void;
+    getInput(): string;
+    getContrib<T extends IChatWidgetContrib>(id: string): T | undefined;
+    lockToCodingAgent(name: string, displayName: string, agentId: string): void;
+    unlockFromCodingAgent(): void;
+    get isLockedToCodingAgent(): boolean;
+    get lockedAgentId(): string | undefined;
+    logInputHistory(): void;
+    acceptInput(query?: string, options?: IChatAcceptInputOptions): Promise<IChatResponseModel | undefined>;
+    rerunLastRequest(): Promise<void>;
+    private _applyPromptFileIfSet;
+    private _acceptInput;
+    getModeRequestOptions(): Partial<IChatSendRequestOptions>;
+    getCodeBlockInfosForResponse(response: IChatResponseViewModel): IChatCodeBlockInfo[];
+    getCodeBlockInfoForEditor(uri: URI): IChatCodeBlockInfo | undefined;
+    getFileTreeInfosForResponse(response: IChatResponseViewModel): IChatFileTreeInfo[];
+    getLastFocusedFileTreeForResponse(response: IChatResponseViewModel): IChatFileTreeInfo | undefined;
+    focusResponseItem(lastFocused?: boolean): void;
+    layout(height: number, width: number): void;
+    private _dynamicMessageLayoutData?;
+    setDynamicChatTreeItemLayout(numOfChatTreeItems: number, maxHeight: number): void;
+    updateDynamicChatTreeItemLayout(numOfChatTreeItems: number, maxHeight: number): void;
+    get isDynamicChatTreeItemLayoutEnabled(): boolean;
+    set isDynamicChatTreeItemLayoutEnabled(value: boolean);
+    layoutDynamicChatTreeItemMode(): void;
+    saveState(): void;
+    getViewState(): IChatModelInputState | undefined;
+    private updateChatInputContext;
+    private _switchToAgentByName;
+    private _applyPromptMetadata;
+    /**
+     * Adds additional instructions to the context
+     * - instructions that have a 'applyTo' pattern that matches the current input
+     * - instructions referenced in the copilot settings 'copilot-instructions'
+     * - instructions referenced in an already included instruction file
+     */
+    private _autoAttachInstructions;
+    delegateScrollFromMouseWheelEvent(browserEvent: IMouseWheelEvent): void;
+}