@codingame/monaco-vscode-api 36.2.7 → 37.1.0

package/vscode/src/vs/workbench/contrib/chat/browser/attachments/chatDynamicVariables.js

@@ -1,6 +1,7 @@
 
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
 import { coalesce } from '../../../../../base/common/arrays.js';
+import { Emitter } from '../../../../../base/common/event.js';
 import { MarkdownString } from '../../../../../base/common/htmlContent.js';
 import { Disposable, MutableDisposable, dispose, isDisposable } from '../../../../../base/common/lifecycle.js';
 import { URI } from '../../../../../base/common/uri.js';
@@ -9,6 +10,8 @@ import { isLocation } from '../../../../../editor/common/languages.js';
 import { Action2, registerAction2 } from '../../../../../platform/actions/common/actions.js';
 import { ICommandService } from '../../../../../platform/commands/common/commands.service.js';
 import { ILabelService } from '../../../../../platform/label/common/label.service.js';
+import { isImageVariableEntry, IChatRequestVariableEntry } from '../../common/attachments/chatVariableEntries.js';
+import { toAttachedContextDynamicVariable } from '../../common/attachments/chatVariables.js';
 import { addDynamicVariableActionId } from '../widget/input/editor/chatDynamicVariablesConstant.js';
 
 var ChatDynamicVariableModel_1;
@@ -31,6 +34,8 @@ let ChatDynamicVariableModel = class ChatDynamicVariableModel extends Disposable
         this.widget = widget;
         this.labelService = labelService;
         this._variables = [];
+        this._onDidChangeReferences = this._register(( new Emitter()));
+        this.onDidChangeReferences = this._onDidChangeReferences.event;
         this.decorationData = [];
         this._editorListener = this._register(( new MutableDisposable()));
         this._subscribeToEditor();
@@ -38,6 +43,7 @@ let ChatDynamicVariableModel = class ChatDynamicVariableModel extends Disposable
             this._subscribeToEditor();
             this.updateDecorations();
         }));
+        this._register(widget.input.attachmentModel.onDidChange(() => this.updateDecorations()));
     }
     _subscribeToEditor() {
         this._editorListener.value = this.widget.inputEditor.onDidChangeModelContent(e => {
@@ -61,11 +67,24 @@ let ChatDynamicVariableModel = class ChatDynamicVariableModel extends Disposable
                 }
                 const newText = model.getValueInRange(newRange);
                 if (newText !== data.text) {
-                    this.widget.inputEditor.executeEdits(this.id, [{
-                        range: newRange,
-                        text: ""
-                    }]);
-                    this.widget.refreshParsedInput();
+                    const replacement = e.changes.find(
+                        change => change.rangeOffset <= data.rangeOffset && change.rangeOffset + change.rangeLength >= data.rangeOffset + data.text.length
+                    );
+                    const preservedRange = replacement && this.findReferenceRangeInReplacement(model, e.changes, replacement, data);
+                    if (preservedRange) {
+                        didChange = true;
+                        return {
+                            ...ref,
+                            range: preservedRange
+                        };
+                    }
+                    if (!replacement) {
+                        this.widget.inputEditor.executeEdits(this.id, [{
+                            range: newRange,
+                            text: ""
+                        }]);
+                        this.widget.refreshParsedInput();
+                    }
                     removed.push(ref);
                     return null;
                 }
@@ -81,12 +100,40 @@ let ChatDynamicVariableModel = class ChatDynamicVariableModel extends Disposable
             dispose(removed.filter(isDisposable));
             if (didChange || removed.length > 0) {
                 this.widget.refreshParsedInput();
+                this._onDidChangeReferences.fire();
             }
             this.updateDecorations();
         });
     }
+    findReferenceRangeInReplacement(model, changes, replacement, data) {
+        if (!data.text) {
+            return undefined;
+        }
+        const previousRelativeOffset = data.rangeOffset - replacement.rangeOffset;
+        let matchOffset = replacement.text.indexOf(data.text);
+        let closestMatchOffset = matchOffset;
+        while (matchOffset !== -1) {
+            if (Math.abs(matchOffset - previousRelativeOffset) < Math.abs(closestMatchOffset - previousRelativeOffset)) {
+                closestMatchOffset = matchOffset;
+            }
+            matchOffset = replacement.text.indexOf(data.text, matchOffset + data.text.length);
+        }
+        if (closestMatchOffset === -1) {
+            return undefined;
+        }
+        const precedingChangesDelta = changes.reduce(
+            (delta, change) => change.rangeOffset < replacement.rangeOffset ? delta + change.text.length - change.rangeLength : delta,
+            0
+        );
+        const startOffset = replacement.rangeOffset + precedingChangesDelta + closestMatchOffset;
+        const range = Range.fromPositions(
+            model.getPositionAt(startOffset),
+            model.getPositionAt(startOffset + data.text.length)
+        );
+        return model.getValueInRange(range) === data.text ? range : undefined;
+    }
     getInputState(contrib) {
-        contrib[ChatDynamicVariableModel_1.ID] = this.variables;
+        contrib[ChatDynamicVariableModel_1.ID] = [...this._variables];
     }
     setInputState(contrib) {
         let s = contrib[ChatDynamicVariableModel_1.ID];
@@ -106,9 +153,14 @@ let ChatDynamicVariableModel = class ChatDynamicVariableModel extends Disposable
         if (!isValidEditorRange(ref.range)) {
             return;
         }
+        const existingAttachment = this.widget.input.attachmentModel.attachments.find(attachment => attachment.id === ref.id && !attachment.range);
+        if (existingAttachment) {
+            ref = toAttachedContextDynamicVariable(existingAttachment, ref.range);
+        }
         this._variables.push(ref);
         this.updateDecorations();
         this.widget.refreshParsedInput();
+        this._onDidChangeReferences.fire();
     }
     updateDecorations() {
         const model = this.widget.inputEditor.getModel();
@@ -124,13 +176,22 @@ let ChatDynamicVariableModel = class ChatDynamicVariableModel extends Disposable
         this._variables = validVariables.slice(0, decorationIds.length);
         this.decorationData = [];
         for (let i = 0; i < decorationIds.length; i++) {
+            const range = this._variables[i].range;
             this.decorationData.push({
                 id: decorationIds[i],
-                text: model.getValueInRange(this._variables[i].range)
+                text: model.getValueInRange(range),
+                rangeOffset: model.getOffsetAt({
+                    lineNumber: range.startLineNumber,
+                    column: range.startColumn
+                })
             });
         }
     }
     getHoverForReference(ref) {
+        const attachment = this.widget.input.attachmentModel.attachments.find(attachment => attachment.id === ref.id && !attachment.range);
+        if (attachment) {
+            return isImageVariableEntry(attachment) ? undefined : this.createAttachmentLabelHover(attachment);
+        }
         const value = ref.data;
         if (URI.isUri(value)) {
             return ( new MarkdownString(this.labelService.getUriLabel(value, {
@@ -146,6 +207,13 @@ let ChatDynamicVariableModel = class ChatDynamicVariableModel extends Disposable
             return undefined;
         }
     }
+    createAttachmentLabelHover(attachment) {
+        const resource = IChatRequestVariableEntry.toUri(attachment) ?? attachment.references?.find(reference => URI.isUri(reference.reference))?.reference;
+        const label = URI.isUri(resource) ? this.labelService.getUriLabel(resource, {
+            relative: true
+        }) : attachment.modelDescription ?? attachment.fullName ?? attachment.name;
+        return ( new MarkdownString()).appendText(label);
+    }
     disposeVariables() {
         for (const variable of this._variables) {
             if (isDisposable(variable)) {

package/vscode/src/vs/workbench/contrib/chat/browser/attachments/chatScreenshotContext.js

@@ -5,7 +5,7 @@ const ScreenshotVariableId = "screenshot-focused-window";
 function convertBufferToScreenshotVariable(buffer) {
     return {
         id: ScreenshotVariableId,
-        name: ( localize(6230, "Screenshot")),
+        name: ( localize(7280, "Screenshot")),
         value: buffer.buffer,
         kind: "image"
     };

package/vscode/src/vs/workbench/contrib/chat/browser/attachments/chatVariables.js

@@ -6,13 +6,16 @@ import { ChatDynamicVariableModel } from './chatDynamicVariables.js';
 import { Range } from '../../../../../editor/common/core/range.js';
 
 function getDynamicVariablesForWidget(widget) {
-    if (!widget.viewModel || !widget.supportsFileReferences) {
+    if (!widget.viewModel) {
         return [];
     }
     const model = widget.getContrib(ChatDynamicVariableModel.ID);
     if (!model) {
         return [];
     }
+    if (!widget.supportsFileReferences) {
+        return model.variables.filter(variable => variable.isAttachmentReference);
+    }
     if (widget.viewModel.editing && model.variables.length > 0) {
         return model.variables;
     }

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

@@ -3,11 +3,14 @@ import { Event } from "../../../../base/common/event.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { URI } from "../../../../base/common/uri.js";
 import { ICodeEditor } from "../../../../editor/browser/editorBrowser.js";
+import { IRange } from "../../../../editor/common/core/range.js";
 import { Selection } from "../../../../editor/common/core/selection.js";
 import { EditDeltaInfo } from "../../../../editor/common/textModelEditSource.js";
 import { MenuId } from "../../../../platform/actions/common/actions.js";
 import { RawContextKey } from "../../../../platform/contextkey/common/contextkey.js";
 import { IContextKeyService } from "../../../../platform/contextkey/common/contextkey.service.js";
+import { IChatRequestVariableEntry } from "../common/attachments/chatVariableEntries.js";
+import { IDynamicVariable } from "../common/attachments/chatVariables.js";
 import { IChatAgentAttachmentCapabilities, IChatAgentCommand, IChatAgentData } from "../common/participants/chatAgents.js";
 import { IChatResponseModel, IChatModelInputState } from "../common/model/chatModel.js";
 import { IChatMode } from "../common/chatModes.js";
@@ -15,12 +18,13 @@ import { IParsedChatRequest } from "../common/requestParser/chatParserTypes.js";
 import { IHandOff } from "../common/promptSyntax/promptFileParser.js";
 import { ChatRequestQueueKind, IChatLocationData, IChatSendRequestOptions } from "../common/chatService/chatService.js";
 import { IChatRequestViewModel, IChatResponseViewModel, IChatViewModel, IChatPendingDividerViewModel } from "../common/model/chatViewModel.js";
-import { ChatAgentLocation, ChatModeKind } from "../common/constants.js";
+import { ChatAgentLocation, ChatModeKind, IResolvedNewChatSessionType } from "../common/constants.js";
 import { ChatAttachmentModel } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/attachments/chatAttachmentModel";
 import { ChatInputPart } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputPart";
 import { IChatWidgetContrib } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/chatWidget";
-import { ICodeBlockActionContext } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/chatContentParts/codeBlockPart";
+import { ICodeBlockActionContext, ICodeBlockRenderOptions } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/chatContentParts/codeBlockPart";
 import { AgentSessionTarget } from "./agentSessions/agentSessions.js";
+export { ChatOutline } from "./chatOutline.js";
 /**
  * A workspace item that can be selected in the workspace picker.
  */
@@ -29,22 +33,6 @@ export interface IWorkspacePickerItem {
     readonly label: string;
     readonly isFolder: boolean;
 }
-/**
- * Narrow contract for a workspace picker hosted as a chip in
- * {@link ChatInputPart}'s primary toolbar. Implementers own all selection
- * state; the chip is purely a rendering / interaction surface.
- *
- * Used by the automations dialog so a single picker instance can drive both
- * the form-row trigger and a toolbar chip without duplicating state.
- */
-export interface IChatInputWorkspacePicker {
-    /**
-     * Renders a trigger chip into the given container. The returned disposable
-     * removes only this trigger; sibling triggers (e.g. the form-row trigger
-     * in the automations dialog) keep working.
-     */
-    renderTrigger(container: HTMLElement): IDisposable;
-}
 /**
  * Delegate interface for the workspace picker.
  * Allows consumers to get and set the target workspace for chat submissions in empty window contexts.
@@ -108,14 +96,6 @@ export interface ISessionTypePickerDelegate {
      * Used to gate cloud delegation which requires a GitHub repository.
      */
     hasGitRepository?(): boolean;
-    /**
-     * Optional visibility filter for the session-type dropdown. When
-     * provided, the picker hides any session type for which this returns
-     * `false`. Use to scope the dropdown to a host-specific subset (e.g.
-     * the automations dialog, which only supports a handful of session
-     * types). When omitted, every contributed session type is shown.
-     */
-    isSessionTypeVisible?(type: AgentSessionTarget): boolean;
 }
 export declare const ChatViewPaneTarget: unique symbol;
 export interface IQuickChatOpenOptions {
@@ -157,21 +137,35 @@ export interface IChatListItemRendererOptions {
     readonly restorable?: boolean;
     readonly supportsFork?: boolean;
     readonly editable?: boolean;
+    /** Whether the chat is read-only, independently of whether request editing is enabled. */
+    readonly readOnly?: boolean;
     readonly renderTextEditsAsSummary?: (uri: URI) => boolean;
     readonly referencesExpandedWhenEmptyResponse?: boolean | ((mode: ChatModeKind) => boolean);
     readonly progressMessageAtBottomOfResponse?: boolean | ((mode: ChatModeKind) => boolean);
     readonly contentHorizontalPadding?: number;
+    /**
+     * Render options applied to code blocks in response markdown (e.g. force word-wrap
+     * so command/tool output pasted by the model wraps instead of overflowing).
+     */
+    readonly codeBlockRenderOptions?: ICodeBlockRenderOptions;
 }
 export interface IChatWidgetViewOptions {
     autoScroll?: boolean | ((mode: ChatModeKind) => boolean);
     renderInputOnTop?: boolean;
+    /** Show the read-only status banner above the transcript instead of beside the composer. */
+    readOnlyBannerAtTop?: boolean;
     renderFollowups?: boolean;
     renderStyle?: "compact" | "minimal";
     renderInputToolbarBelowInput?: boolean;
+    renderGettingStartedTip?: boolean | (() => boolean);
     supportsFileReferences?: boolean;
     filter?: (item: ChatTreeItem) => boolean;
-    /** Action triggered when 'clear' is called on the widget. */
-    clear?: () => Promise<void>;
+    /**
+     * Action triggered when 'clear' is called on the widget. The optional
+     * `resolvedSessionType` carries the already-resolved new session type and
+     * selection reason so the host does not recompute either value.
+     */
+    clear?: (resolvedSessionType?: IResolvedNewChatSessionType) => Promise<void>;
     rendererOptions?: IChatListItemRendererOptions;
     menus?: {
         /**
@@ -215,13 +209,30 @@ export interface IChatWidgetViewOptions {
      * If it returns true (handled), the normal submission is skipped.
      * This is useful for contexts like the welcome view where submission should
      * redirect to a different workspace rather than executing locally.
+     *
+     * `attachedContext` carries the explicit attachments (paste/drop/pick) present
+     * on the input so a host that routes the request elsewhere can forward them
+     * instead of silently dropping them.
      */
-    submitHandler?: (query: string, mode: ChatModeKind) => Promise<boolean>;
+    submitHandler?: (query: string, mode: ChatModeKind, attachedContext?: IChatRequestVariableEntry[], isVoiceModeInput?: boolean) => Promise<boolean>;
     /**
      * Whether we are running in the sessions window.
      * When true, the secondary toolbar (permissions picker) is hidden.
      */
     isSessionsWindow?: boolean;
+    /** Tab index for the transcript tree root. Use `-1` to exclude it from sequential keyboard navigation while preserving programmatic focus. */
+    transcriptTabIndex?: 0 | -1;
+    /** Whether this host supports the experimental session state indicator. Defaults to false. */
+    enableSessionStateIndicator?: boolean;
+    /** Enables the transcript Find widget (`Ctrl/Cmd+F`) for this chat widget. Off by default. */
+    enableFind?: boolean;
+    /**
+     * Height of the content this host mounts into
+     * {@link ChatInputPart.persistentContentContainerElement}. Setting it floats that
+     * content above the input, so the transcript scrolls underneath it, and reserves
+     * the same space below the transcript. Must match the content's rendered height.
+     */
+    persistentContentHeight?: number;
 }
 export interface IChatViewViewContext {
     viewId: string;
@@ -236,6 +247,7 @@ export type IChatWidgetViewContext = IChatViewViewContext | IChatResourceViewCon
 export interface IChatAcceptInputOptions {
     noCommandDetection?: boolean;
     isVoiceInput?: boolean;
+    isVoiceModeInput?: boolean;
     enableImplicitContext?: boolean;
     storeToHistory?: boolean;
     /**
@@ -248,13 +260,34 @@ export interface IChatAcceptInputOptions {
      */
     cancelCurrentRequest?: boolean;
     preserveFocus?: boolean;
+    /** Keeps the input box contents and attachments after submitting a programmatic query, and omits them from it. The query itself is sent as-is: prompt slash commands in it are not resolved. */
+    preserveInput?: boolean;
+    /**
+     * Called once the request has been handed over to the chat service, i.e. it was either sent
+     * right away or queued because another request is in progress. Callers that must not wait for
+     * a queued request to actually run should use this instead of awaiting `acceptInput`, which
+     * only resolves once the request has been sent.
+     */
+    onRequestAccepted?: () => void;
 }
 export interface IChatWidgetViewModelChangeEvent {
     readonly previousSessionResource: URI | undefined;
     readonly currentSessionResource: URI | undefined;
 }
+/**
+ * Visual presentation state restored when a widget is rebound to a chat.
+ * Composer data such as text, attachments, mode, and model belongs in {@link IChatModelInputState}.
+ */
+export interface IChatWidgetViewState {
+    readonly scrollTop: number;
+    readonly isAtBottom?: boolean;
+}
+export declare const CHAT_WIDGET_VIEW_STATE_CACHE_LIMIT = 100;
 export interface IChatWidget {
     readonly domNode: HTMLElement;
+    /** DOM node of the scrollable transcript area, excluding the input part. */
+    readonly transcriptDomNode: HTMLElement;
+    readonly visible: boolean;
     readonly onDidChangeViewModel: Event<IChatWidgetViewModelChangeEvent>;
     readonly onDidAcceptInput: Event<void>;
     readonly onDidHide: Event<void>;
@@ -270,11 +303,14 @@ export interface IChatWidget {
     readonly onDidChangeParsedInput: Event<void>;
     readonly onDidChangeActiveInputEditor: Event<void>;
     readonly onDidFocus: Event<void>;
+    readonly onDidScroll: Event<void>;
     readonly location: ChatAgentLocation;
     readonly viewContext: IChatWidgetViewContext;
     readonly viewModel: IChatViewModel | undefined;
     readonly inputEditor: ICodeEditor;
     readonly supportsFileReferences: boolean;
+    /** Whether the input part is rendered above the transcript instead of below it (quick chat, composer-style widgets). */
+    readonly rendersInputOnTop: boolean;
     readonly attachmentCapabilities: IChatAgentAttachmentCapabilities;
     readonly parsedInput: IParsedChatRequest;
     readonly lockedAgentId: string | undefined;
@@ -295,9 +331,13 @@ export interface IChatWidget {
     setInput(query?: string): void;
     getInput(): string;
     refreshParsedInput(): void;
+    /** Floats persistent input content and reserves matching space below the transcript. */
+    setPersistentContentHeight(height: number | undefined): void;
     logInputHistory(): void;
     acceptInput(query?: string, options?: IChatAcceptInputOptions): Promise<IChatResponseModel | undefined>;
+    getSelectedModelRequestOptions(): Pick<IChatSendRequestOptions, "userSelectedModelId" | "userSelectedModelConfiguration">;
     startEditing(requestId: string): void;
+    cancelEditing(): Promise<void>;
     finishedEditing(completedEdit?: boolean): void;
     rerunLastRequest(): Promise<void>;
     setInputPlaceholder(placeholder: string): void;
@@ -343,26 +383,60 @@ export interface IChatWidget {
      * @returns Whether the operation succeeded (i.e., a terminal was found and focused).
      */
     focusQuestionCarouselTerminal(): boolean;
-    /**
-     * Toggles focus between the tip widget and the chat input.
-     * Returns false if no tip is visible.
-     * @returns Whether the operation succeeded (i.e., the focus was toggled).
-     */
-    toggleTipFocus(): boolean;
     hasInputFocus(): boolean;
     getModeRequestOptions(): Partial<IChatSendRequestOptions>;
     getCodeBlockInfoForEditor(uri: URI): IChatCodeBlockInfo | undefined;
     getCodeBlockInfosForResponse(response: IChatResponseViewModel): IChatCodeBlockInfo[];
     getFileTreeInfosForResponse(response: IChatResponseViewModel): IChatFileTreeInfo[];
     getLastFocusedFileTreeForResponse(response: IChatResponseViewModel): IChatFileTreeInfo | undefined;
-    clear(): Promise<void>;
-    getViewState(): IChatModelInputState | undefined;
+    /**
+     * Returns the currently rendered chat item containing the node, if any.
+     */
+    getElementFromNode(node: HTMLElement): ChatTreeItem | undefined;
+    /**
+     * Suppresses auto-scrolling the transcript to the bottom until the returned
+     * disposable is disposed. Holds compose, so concurrent callers do not
+     * clobber each other.
+     */
+    holdAutoScroll(): IDisposable;
+    clear(resolvedSessionType?: IResolvedNewChatSessionType): Promise<void>;
+    getInputState(): IChatModelInputState | undefined;
+    getViewState(): IChatWidgetViewState;
+    restoreViewState(state: IChatWidgetViewState): void;
     lockToCodingAgent(name: string, displayName: string, agentId?: string, agentHostProviderId?: string): void;
     unlockFromCodingAgent(): void;
     handleDelegationExitIfNeeded(sourceAgent: Pick<IChatAgentData, "id" | "name"> | undefined, targetAgent: IChatAgentData | undefined): Promise<void>;
     executeHandoff(handoff: IHandOff, agentId?: string): Promise<void>;
     delegateScrollFromMouseWheelEvent(event: IMouseWheelEvent): void;
+    /** Returns the widget's transcript Find controller, or `undefined` if `enableFind` was not set. */
+    getFindController(): IChatFindController | undefined;
+}
+/** Minimal surface used to route `Ctrl/Cmd+F` and Find Next/Previous to a chat widget's transcript Find widget. */
+export interface IChatFindController {
+    readonly visible: boolean;
+    /** Shows the Find widget, optionally seeding the query and focusing the input. */
+    show(seedText?: string, focus?: boolean): void;
+    hide(): void;
+    next(): void;
+    previous(): void;
+    toggleCaseSensitive(): void;
+    toggleWholeWord(): void;
+    toggleRegex(): void;
+    /** Focuses the Find widget's last-focused element (defaults to the input). */
+    focus(): void;
 }
+/**
+ * Binds a freshly loaded model to a chat widget, preserving any text the user
+ * typed into the input while the session was still loading (the input stays
+ * editable during the async load, and binding would otherwise reset it to the
+ * session's own draft). See #325323.
+ *
+ * @param inputBeforeLoad Input value captured when the load window started, used
+ * as a baseline so a previous session's leftover draft is not mistaken for newly
+ * typed text.
+ * @param setModel Callback that performs the actual `setModel` binding.
+ */
+export declare function setModelPreservingInputTypedWhileLoading(widget: IChatWidget, inputBeforeLoad: string, setModel: () => void): void;
 export interface ICodeBlockActionContextProvider {
     getCodeBlockContext(editor?: ICodeEditor): ICodeBlockActionContext | undefined;
 }
@@ -370,3 +444,32 @@ export declare const ChatViewId = "workbench.panel.chat.view.copilot";
 export declare const ChatViewContainerId = "workbench.panel.chat";
 export declare const HasInstalledAgentPluginsContext: RawContextKey<boolean>;
 export declare const InstalledAgentPluginsViewId = "workbench.views.agentPlugins.installed";
+/**
+ * A surface that can receive chat context attachments.
+ */
+export interface IChatAttachmentTarget {
+    readonly attachments: readonly IChatRequestVariableEntry[];
+    addAttachments(entries: readonly IChatRequestVariableEntry[]): void;
+}
+/**
+ * A chat input surface that paste providers can attach context to. Implemented
+ * by both the workbench chat widget and the Agents window composer so the paste
+ * pipeline does not depend on {@link IChatWidget}.
+ */
+export interface IChatPasteTarget extends IChatAttachmentTarget {
+    /** Scopes resources created for this input, so they are cleaned up with the session. */
+    readonly sessionResource: URI;
+    /** Inline references currently present in the input. */
+    readonly inlineReferences: readonly IDynamicVariable[];
+    removeAttachments(ids: readonly string[]): void;
+    /** Attaches `entry` and binds it to the inline `text` inserted at `range`. */
+    addInlineAttachment(entry: IChatRequestVariableEntry, text: string, range: IRange): void;
+    /** Adds an inline reference that is not backed by an attachment, such as a symbol. */
+    addInlineReference(reference: IDynamicVariable): void;
+    /** Whether pasting `text` over `range` would turn the input into a terminal command. */
+    isTerminalCommandPaste(text: string, range: IRange): boolean;
+}
+export declare const UpdateAgentPluginsCommandId = "workbench.agentPlugins.checkForUpdates";
+export declare const ForceUpdateAgentPluginsCommandId = "workbench.agentPlugins.forceUpdate";
+export declare const RefreshAgentPluginMarketplacesCommandId = "workbench.agentPlugins.refreshMarketplaces";
+export declare const UpdatingAgentPluginsContext: RawContextKey<boolean>;

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

@@ -1,6 +1,7 @@
 
 import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
 import { CHAT_PROVIDER_ID } from '../common/participants/chatParticipantContribTypes.js';
+export { ChatOutline } from './chatOutline.js';
 
 const ChatViewPaneTarget = Symbol("ChatViewPaneTarget");
 function isIChatViewViewContext(context) {
@@ -9,9 +10,21 @@ function isIChatViewViewContext(context) {
 function isIChatResourceViewContext(context) {
     return !isIChatViewViewContext(context);
 }
+const CHAT_WIDGET_VIEW_STATE_CACHE_LIMIT = 100;
+function setModelPreservingInputTypedWhileLoading(widget, inputBeforeLoad, setModel) {
+    const typedWhileLoading = widget.getInput();
+    setModel();
+    if (typedWhileLoading && typedWhileLoading !== inputBeforeLoad && !widget.getInput()) {
+        widget.setInput(typedWhileLoading);
+    }
+}
 const ChatViewId = `workbench.panel.chat.view.${CHAT_PROVIDER_ID}`;
 const ChatViewContainerId = "workbench.panel.chat";
 const HasInstalledAgentPluginsContext = ( new RawContextKey("hasInstalledAgentPlugins", false));
 const InstalledAgentPluginsViewId = "workbench.views.agentPlugins.installed";
+const UpdateAgentPluginsCommandId = "workbench.agentPlugins.checkForUpdates";
+const ForceUpdateAgentPluginsCommandId = "workbench.agentPlugins.forceUpdate";
+const RefreshAgentPluginMarketplacesCommandId = "workbench.agentPlugins.refreshMarketplaces";
+const UpdatingAgentPluginsContext = ( new RawContextKey("agentPluginsUpdating", false));
 
-export { ChatViewContainerId, ChatViewId, ChatViewPaneTarget, HasInstalledAgentPluginsContext, InstalledAgentPluginsViewId, isIChatResourceViewContext, isIChatViewViewContext };
+export { CHAT_WIDGET_VIEW_STATE_CACHE_LIMIT, ChatViewContainerId, ChatViewId, ChatViewPaneTarget, ForceUpdateAgentPluginsCommandId, HasInstalledAgentPluginsContext, InstalledAgentPluginsViewId, RefreshAgentPluginMarketplacesCommandId, UpdateAgentPluginsCommandId, UpdatingAgentPluginsContext, isIChatResourceViewContext, isIChatViewViewContext, setModelPreservingInputTypedWhileLoading };

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

@@ -5,8 +5,7 @@ import { PreferredGroup } from "../../../services/editor/common/editorService.js
 import { IChatElicitationRequest } from "../common/chatService/chatService.js";
 import { ChatAgentLocation } from "../common/constants.js";
 import { IChatResponseViewModel } from "../common/model/chatViewModel.js";
-import { IChatWidget, ChatViewPaneTarget, type IQuickChatOpenOptions, type ICodeBlockActionContextProvider } from "./chat.js";
-import { ChatWidget } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/chatWidget";
+import { IChatWidget, ChatViewPaneTarget, type IQuickChatOpenOptions, type ICodeBlockActionContextProvider, type IChatPasteTarget } from "./chat.js";
 import { IChatEditorOptions } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/browser/widgetHosts/editor/chatEditor";
 export declare const IChatWidgetService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatWidgetService>;
 export interface IChatWidgetService {
@@ -20,6 +19,8 @@ export interface IChatWidgetService {
     */
     readonly lastFocusedWidget: IChatWidget | undefined;
     readonly onDidAddWidget: Event<IChatWidget>;
+    readonly onDidRemoveWidget: Event<IChatWidget>;
+    readonly onDidChangeWidgetVisibility: Event<IChatWidget>;
     /**
     * Fires when a chat session is no longer open in any chat widget.
     */
@@ -72,7 +73,7 @@ export interface IChatAccessibilityService {
     readonly _serviceBrand: undefined;
     acceptRequest(uri: URI, skipRequestSignal?: boolean): void;
     disposeRequest(requestId: URI): void;
-    acceptResponse(widget: ChatWidget, container: HTMLElement, response: IChatResponseViewModel | string | undefined, requestId: URI | undefined, isVoiceInput?: boolean): void;
+    acceptResponse(response: IChatResponseViewModel | string | undefined, requestId: URI | undefined, isVoiceInput?: boolean): void;
     acceptElicitation(message: IChatElicitationRequest): void;
 }
 export declare const IChatCodeBlockContextProviderService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatCodeBlockContextProviderService>;
@@ -81,3 +82,9 @@ export interface IChatCodeBlockContextProviderService {
     readonly providers: ICodeBlockActionContextProvider[];
     registerProvider(provider: ICodeBlockActionContextProvider, id: string): IDisposable;
 }
+export declare const IChatPasteTargetService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatPasteTargetService>;
+export interface IChatPasteTargetService {
+    readonly _serviceBrand: undefined;
+    registerTarget(inputUri: URI, target: IChatPasteTarget): IDisposable;
+    getTarget(inputUri: URI): IChatPasteTarget | undefined;
+}

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

@@ -5,5 +5,6 @@ const IChatWidgetService = ( createDecorator("chatWidgetService"));
 const IQuickChatService = ( createDecorator("quickChatService"));
 const IChatAccessibilityService = ( createDecorator("chatAccessibilityService"));
 const IChatCodeBlockContextProviderService = ( createDecorator("chatCodeBlockContextProviderService"));
+const IChatPasteTargetService = ( createDecorator("chatPasteTargetService"));
 
-export { IChatAccessibilityService, IChatCodeBlockContextProviderService, IChatWidgetService, IQuickChatService };
+export { IChatAccessibilityService, IChatCodeBlockContextProviderService, IChatPasteTargetService, IChatWidgetService, IQuickChatService };

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

@@ -5,7 +5,7 @@ import { IInstantiationService } from "../../../../../platform/instantiation/com
 import { IWorkbenchContribution } from "../../../../common/contributions.js";
 import { IEditorGroupsService } from "../../../../services/editor/common/editorGroupsService.service.js";
 import { IInlineChatSessionService } from "../../../inlineChat/browser/inlineChatSessionService.service.js";
-import { IChatEditingSession, IModifiedFileEntry } from "../../common/editing/chatEditingService.js";
+import { IChatEditReviewSession, IModifiedFileEntry } from "../../common/editing/chatEditingService.js";
 import { IChatEditingService } from "../../common/editing/chatEditingService.service.js";
 export declare const ctxIsGlobalEditingSession: RawContextKey<boolean>;
 export declare const ctxHasEditorModification: RawContextKey<boolean>;
@@ -22,7 +22,7 @@ export declare class ChatEditingEditorContextKeys implements IWorkbenchContribut
 }
 export declare class ObservableEditorSession {
     readonly value: IObservable<undefined | {
-        session: IChatEditingSession;
+        session: IChatEditReviewSession;
         entry: IModifiedFileEntry | undefined;
         isInlineChat: boolean;
     }>;

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingEditorContextKeys.js

@@ -17,16 +17,16 @@ import { autorun } from '../../../../../base/common/observableInternal/reactions
 import { derived } from '../../../../../base/common/observableInternal/observables/derived.js';
 import { constObservable } from '../../../../../base/common/observableInternal/observables/constObservable.js';
 
-const ctxIsGlobalEditingSession = ( new RawContextKey("chatEdits.isGlobalEditingSession", undefined, ( localize(6990, "The current editor is part of the global edit session"))));
-const ctxHasEditorModification = ( new RawContextKey("chatEdits.hasEditorModifications", undefined, ( localize(6991, "The current editor contains chat modifications"))));
-const ctxIsCurrentlyBeingModified = ( new RawContextKey("chatEdits.isCurrentlyBeingModified", undefined, ( localize(6992, "The current editor is currently being modified"))));
-const ctxReviewModeEnabled = ( new RawContextKey("chatEdits.isReviewModeEnabled", true, ( localize(6993, "Review mode for chat changes is enabled"))));
+const ctxIsGlobalEditingSession = ( new RawContextKey("chatEdits.isGlobalEditingSession", undefined, ( localize(8229, "The current editor is part of the global edit session"))));
+const ctxHasEditorModification = ( new RawContextKey("chatEdits.hasEditorModifications", undefined, ( localize(8230, "The current editor contains chat modifications"))));
+const ctxIsCurrentlyBeingModified = ( new RawContextKey("chatEdits.isCurrentlyBeingModified", undefined, ( localize(8231, "The current editor is currently being modified"))));
+const ctxReviewModeEnabled = ( new RawContextKey("chatEdits.isReviewModeEnabled", true, ( localize(8232, "Review mode for chat changes is enabled"))));
 const ctxHasRequestInProgress = ( new RawContextKey("chatEdits.isRequestInProgress", false, ( localize(
-    6994,
+    8233,
     "The current editor shows a file from an edit session which is still in progress"
 ))));
-const ctxRequestCount = ( new RawContextKey("chatEdits.requestCount", 0, ( localize(6995, "The number of turns the editing session in this editor has"))));
-const ctxCursorInChangeRange = ( new RawContextKey("chatEdits.cursorInChangeRange", false, ( localize(6996, "The cursor is inside a change range made by chat editing."))));
+const ctxRequestCount = ( new RawContextKey("chatEdits.requestCount", 0, ( localize(8234, "The number of turns the editing session in this editor has"))));
+const ctxCursorInChangeRange = ( new RawContextKey("chatEdits.cursorInChangeRange", false, ( localize(8235, "The cursor is inside a change range made by chat editing."))));
 let ChatEditingEditorContextKeys = class ChatEditingEditorContextKeys {
     static {
         this.ID = "chat.edits.editorContextKeys";

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

@@ -8,6 +8,7 @@ import { ILogService } from "../../../../platform/log/common/log.service.js";
  * @returns A promise that resolves to the UInt8Array string of the resized image.
  */
 export declare function resizeImage(data: Uint8Array | string, mimeType?: string): Promise<Uint8Array>;
+export declare const CHAT_IMAGE_HOVER_THUMBNAIL_MAX_SIZE = 768;
 /**
  * Memoized variant of {@link createImageThumbnail}. Repeated calls with the same
  * {@link cacheKey} (and matching size/byte length) reuse the previously generated

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

@@ -101,6 +101,7 @@ function createImageThumbnail(data, maxSize) {
 }
 const thumbnailCache = ( new LRUCache(50));
 const THUMBNAIL_DECODE_TIMEOUT_MS = 10_000;
+const CHAT_IMAGE_HOVER_THUMBNAIL_MAX_SIZE = 768;
 function getOrCreateImageThumbnail(cacheKey, data, maxSize) {
     const key = `${cacheKey}:${maxSize}:${data.byteLength}`;
     const cached = thumbnailCache.get(key);
@@ -185,4 +186,4 @@ async function imageToHash(data) {
     return ( hashArray.map(b => ( b.toString(16)).padStart(2, "0"))).join("");
 }
 
-export { cleanupOldImages, convertStringToUInt8Array, createFileForMedia, getOrCreateImageThumbnail, imageToHash, resizeImage };
+export { CHAT_IMAGE_HOVER_THUMBNAIL_MAX_SIZE, cleanupOldImages, convertStringToUInt8Array, createFileForMedia, getOrCreateImageThumbnail, imageToHash, resizeImage };