@codingame/monaco-vscode-api 18.4.0 → 19.0.1

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

@@ -9,12 +9,13 @@ import { ISelection } from "../../../../editor/common/core/selection.js";
 import { Command, Location, TextEdit } from "../../../../editor/common/languages.js";
 import { FileType } from "../../../../platform/files/common/files.js";
 import { ICellEditOperation } from "../../notebook/common/notebookCommon.js";
-import { IWorkspaceSymbol } from "@codingame/monaco-vscode-47472025-cc45-5680-86cd-09ceaba921a1-common/vscode/vs/workbench/contrib/search/common/search";
-import { IChatAgentCommand, IChatAgentData, IChatAgentResult } from "./chatAgents.js";
-import { IChatRequestVariableEntry, IChatResponseModel } from "./chatModel.js";
-import { IChatParserContext } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/chatRequestParser";
+import { IWorkspaceSymbol } from "@codingame/monaco-vscode-6f931a91-88ea-5232-897f-a17ec3929ba5-common/vscode/vs/workbench/contrib/search/common/search";
+import { IChatAgentCommand, IChatAgentData, IChatAgentResult } from "@codingame/monaco-vscode-9ebd6daf-8734-5a28-ad24-b238f5e5819d-common/vscode/vs/workbench/contrib/chat/common/chatAgents";
+import { IChatResponseModel } from "@codingame/monaco-vscode-9911aec2-e4dd-5483-8369-9d695cc70d8a-common/vscode/vs/workbench/contrib/chat/common/chatModel";
+import { IChatParserContext } from "@codingame/monaco-vscode-9ebd6daf-8734-5a28-ad24-b238f5e5819d-common/vscode/vs/workbench/contrib/chat/common/chatRequestParser";
+import { IChatRequestVariableEntry } from "./chatVariableEntries.js";
 import { IChatRequestVariableValue } from "./chatVariables.js";
-import { ChatAgentLocation, ChatMode } from "./constants.js";
+import { ChatAgentLocation, ChatModeKind } from "./constants.js";
 import { IPreparedToolInvocation, IToolConfirmationMessages, IToolResult } from "./languageModelToolsService.js";
 export interface IChatRequest {
     message: string;
@@ -177,6 +178,16 @@ export interface IChatConfirmation {
     isUsed?: boolean;
     kind: "confirmation";
 }
+export interface IChatElicitationRequest {
+    kind: "elicitation";
+    title: string | IMarkdownString;
+    message: string | IMarkdownString;
+    originMessage?: string | IMarkdownString;
+    state: "pending" | "accepted" | "rejected";
+    acceptedResult?: Record<string, unknown>;
+    accept(): Promise<void>;
+    reject(): Promise<void>;
+}
 export interface IChatTerminalToolInvocationData {
     kind: "terminal";
     command: string;
@@ -228,7 +239,7 @@ export interface IChatPrepareToolInvocationPart {
     readonly kind: "prepareToolInvocation";
     readonly toolName: string;
 }
-export type IChatProgress = IChatMarkdownContent | IChatAgentMarkdownContentWithVulnerability | IChatTreeData | IChatUsedContext | IChatContentReference | IChatContentInlineReference | IChatCodeCitation | IChatProgressMessage | IChatTask | IChatTaskResult | IChatCommandButton | IChatWarningMessage | IChatTextEdit | IChatNotebookEdit | IChatMoveMessage | IChatResponseCodeblockUriPart | IChatConfirmation | IChatToolInvocation | IChatToolInvocationSerialized | IChatExtensionsContent | IChatUndoStop | IChatPrepareToolInvocationPart | IChatTaskSerialized;
+export type IChatProgress = IChatMarkdownContent | IChatAgentMarkdownContentWithVulnerability | IChatTreeData | IChatUsedContext | IChatContentReference | IChatContentInlineReference | IChatCodeCitation | IChatProgressMessage | IChatTask | IChatTaskResult | IChatCommandButton | IChatWarningMessage | IChatTextEdit | IChatNotebookEdit | IChatMoveMessage | IChatResponseCodeblockUriPart | IChatConfirmation | IChatToolInvocation | IChatToolInvocationSerialized | IChatExtensionsContent | IChatUndoStop | IChatPrepareToolInvocationPart | IChatTaskSerialized | IChatElicitationRequest;
 export interface IChatFollowup {
     kind: "reply";
     message: string;
@@ -268,17 +279,27 @@ export interface IChatCopyAction {
     copiedCharacters: number;
     totalCharacters: number;
     copiedText: string;
+    totalLines: number;
+    copiedLines: number;
+    modelId: string;
+    languageId?: string;
 }
 export interface IChatInsertAction {
     kind: "insert";
     codeBlockIndex: number;
     totalCharacters: number;
+    totalLines: number;
+    languageId?: string;
+    modelId: string;
     newFile?: boolean;
 }
 export interface IChatApplyAction {
     kind: "apply";
     codeBlockIndex: number;
     totalCharacters: number;
+    totalLines: number;
+    languageId?: string;
+    modelId: string;
     newFile?: boolean;
     codeMapper?: string;
     editsProposed: boolean;
@@ -340,7 +361,7 @@ export interface IChatTransferredSessionData {
     sessionId: string;
     inputValue: string;
     location: ChatAgentLocation;
-    mode: ChatMode;
+    mode: ChatModeKind;
 }
 export interface IChatSendRequestResponseState {
     responseCreatedPromise: Promise<IChatResponseModel>;
@@ -365,11 +386,10 @@ export interface IChatTerminalLocationData {
 }
 export type IChatLocationData = IChatEditorLocationData | IChatNotebookLocationData | IChatTerminalLocationData;
 export interface IChatSendRequestOptions {
-    mode?: ChatMode;
+    mode?: ChatModeKind;
     userSelectedModelId?: string;
     userSelectedTools?: Record<string, boolean>;
     modeInstructions?: string;
-    toolSelectionIsExclusive?: boolean;
     location?: ChatAgentLocation;
     locationData?: IChatLocationData;
     parserContext?: IChatParserContext;

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

@@ -1,8 +1,8 @@
 import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { Event } from "../../../../base/common/event.js";
 import { URI } from "../../../../base/common/uri.js";
-import { ChatModel, IChatModel, IExportableChatData, ISerializableChatData, IChatRequestModel, IChatRequestVariableData } from "./chatModel.js";
-import { IParsedChatRequest } from "./chatParserTypes.js";
+import { ChatModel, IChatModel, IExportableChatData, ISerializableChatData, IChatRequestModel, IChatRequestVariableData } from "@codingame/monaco-vscode-9911aec2-e4dd-5483-8369-9d695cc70d8a-common/vscode/vs/workbench/contrib/chat/common/chatModel";
+import { IParsedChatRequest } from "@codingame/monaco-vscode-9ebd6daf-8734-5a28-ad24-b238f5e5819d-common/vscode/vs/workbench/contrib/chat/common/chatParserTypes";
 import { IChatTransferredSessionData, IChatSendRequestOptions, IChatSendRequestData, IChatCompleteResponse, IChatDetail, IChatUserActionEvent } from "./chatService.js";
 import { ChatAgentLocation } from "./constants.js";
 export declare const IChatService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatService>;

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

@@ -4,7 +4,7 @@ import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { IProgress } from "../../../../platform/progress/common/progress.js";
 import { IChatProgress, IChatFollowup } from "./chatService.js";
 import { IChatSlashData, IChatSlashCallback } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/common/chatSlashCommands";
-import { ChatAgentLocation, ChatMode } from "./constants.js";
+import { ChatAgentLocation, ChatModeKind } from "./constants.js";
 import { IChatMessage } from "./languageModels.js";
 export declare const IChatSlashCommandService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatSlashCommandService>;
 export interface IChatSlashCommandService {
@@ -14,6 +14,6 @@ export interface IChatSlashCommandService {
     executeCommand(id: string, prompt: string, progress: IProgress<IChatProgress>, history: IChatMessage[], location: ChatAgentLocation, token: CancellationToken): Promise<{
         followUp: IChatFollowup[];
     } | void>;
-    getCommands(location: ChatAgentLocation, mode: ChatMode): Array<IChatSlashData>;
+    getCommands(location: ChatAgentLocation, mode: ChatModeKind): Array<IChatSlashData>;
     hasCommand(id: string): boolean;
 }

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

@@ -0,0 +1,152 @@
+import { ThemeIcon } from "../../../../base/common/themables.js";
+import { URI } from "../../../../base/common/uri.js";
+import { IRange } from "../../../../editor/common/core/range.js";
+import { IOffsetRange } from "../../../../editor/common/core/ranges/offsetRange.js";
+import { Location, SymbolKind } from "../../../../editor/common/languages.js";
+import { MarkerSeverity, IMarker } from "../../../../platform/markers/common/markers.js";
+import { ISCMHistoryItem } from "../../scm/common/history.js";
+import { IChatContentReference } from "./chatService.js";
+import { IChatRequestVariableValue } from "./chatVariables.js";
+interface IBaseChatRequestVariableEntry {
+    readonly id: string;
+    readonly fullName?: string;
+    readonly icon?: ThemeIcon;
+    readonly name: string;
+    readonly modelDescription?: string;
+    readonly range?: IOffsetRange;
+    readonly value: IChatRequestVariableValue;
+    readonly references?: IChatContentReference[];
+    omittedState?: OmittedState;
+}
+export interface IGenericChatRequestVariableEntry extends IBaseChatRequestVariableEntry {
+    kind: "generic";
+}
+export interface IChatRequestDirectoryEntry extends IBaseChatRequestVariableEntry {
+    kind: "directory";
+}
+export interface IChatRequestFileEntry extends IBaseChatRequestVariableEntry {
+    kind: "file";
+}
+export declare enum OmittedState {
+    NotOmitted = 0,
+    Partial = 1,
+    Full = 2
+}
+export interface IChatRequestToolEntry extends IBaseChatRequestVariableEntry {
+    readonly kind: "tool";
+}
+export interface IChatRequestToolSetEntry extends IBaseChatRequestVariableEntry {
+    readonly kind: "toolset";
+    readonly value: IChatRequestToolEntry[];
+}
+export interface IChatRequestImplicitVariableEntry extends IBaseChatRequestVariableEntry {
+    readonly kind: "implicit";
+    readonly isFile: true;
+    readonly value: URI | Location | undefined;
+    readonly isSelection: boolean;
+    enabled: boolean;
+}
+export interface IChatRequestPasteVariableEntry extends IBaseChatRequestVariableEntry {
+    readonly kind: "paste";
+    readonly code: string;
+    readonly language: string;
+    readonly pastedLines: string;
+    readonly fileName: string;
+    readonly copiedFrom: {
+        readonly uri: URI;
+        readonly range: IRange;
+    } | undefined;
+}
+export interface ISymbolVariableEntry extends IBaseChatRequestVariableEntry {
+    readonly kind: "symbol";
+    readonly value: Location;
+    readonly symbolKind: SymbolKind;
+}
+export interface ICommandResultVariableEntry extends IBaseChatRequestVariableEntry {
+    readonly kind: "command";
+}
+export interface IImageVariableEntry extends IBaseChatRequestVariableEntry {
+    readonly kind: "image";
+    readonly isPasted?: boolean;
+    readonly isURL?: boolean;
+    readonly mimeType?: string;
+}
+export interface INotebookOutputVariableEntry extends IBaseChatRequestVariableEntry {
+    readonly kind: "notebookOutput";
+    readonly outputIndex?: number;
+    readonly mimeType?: string;
+}
+export interface IDiagnosticVariableEntryFilterData {
+    readonly owner?: string;
+    readonly problemMessage?: string;
+    readonly filterUri?: URI;
+    readonly filterSeverity?: MarkerSeverity;
+    readonly filterRange?: IRange;
+}
+export declare namespace IDiagnosticVariableEntryFilterData {
+    const icon: ThemeIcon;
+    function fromMarker(marker: IMarker): IDiagnosticVariableEntryFilterData;
+    function toEntry(data: IDiagnosticVariableEntryFilterData): IDiagnosticVariableEntry;
+    function id(data: IDiagnosticVariableEntryFilterData): string;
+    function label(data: IDiagnosticVariableEntryFilterData): string;
+}
+export interface IDiagnosticVariableEntry extends IBaseChatRequestVariableEntry, IDiagnosticVariableEntryFilterData {
+    readonly kind: "diagnostic";
+}
+export interface IElementVariableEntry extends IBaseChatRequestVariableEntry {
+    readonly kind: "element";
+}
+export interface IPromptFileVariableEntry extends IBaseChatRequestVariableEntry {
+    readonly kind: "promptFile";
+    readonly value: URI;
+    readonly isRoot: boolean;
+    readonly originLabel?: string;
+    readonly modelDescription: string;
+    readonly automaticallyAdded: boolean;
+}
+export interface IPromptTextVariableEntry extends IBaseChatRequestVariableEntry {
+    readonly kind: "promptText";
+    readonly value: string;
+    readonly settingId?: string;
+    readonly modelDescription: string;
+    readonly automaticallyAdded: boolean;
+}
+export interface ISCMHistoryItemVariableEntry extends IBaseChatRequestVariableEntry {
+    readonly kind: "scmHistoryItem";
+    readonly value: URI;
+    readonly historyItem: ISCMHistoryItem;
+}
+export type IChatRequestVariableEntry = IGenericChatRequestVariableEntry | IChatRequestImplicitVariableEntry | IChatRequestPasteVariableEntry | ISymbolVariableEntry | ICommandResultVariableEntry | IDiagnosticVariableEntry | IImageVariableEntry | IChatRequestToolEntry | IChatRequestToolSetEntry | IChatRequestDirectoryEntry | IChatRequestFileEntry | INotebookOutputVariableEntry | IElementVariableEntry | IPromptFileVariableEntry | IPromptTextVariableEntry | ISCMHistoryItemVariableEntry;
+export declare namespace IChatRequestVariableEntry {
+    function toUri(entry: IChatRequestVariableEntry): URI | undefined;
+}
+export declare function isImplicitVariableEntry(obj: IChatRequestVariableEntry): obj is IChatRequestImplicitVariableEntry;
+export declare function isPasteVariableEntry(obj: IChatRequestVariableEntry): obj is IChatRequestPasteVariableEntry;
+export declare function isImageVariableEntry(obj: IChatRequestVariableEntry): obj is IImageVariableEntry;
+export declare function isNotebookOutputVariableEntry(obj: IChatRequestVariableEntry): obj is INotebookOutputVariableEntry;
+export declare function isElementVariableEntry(obj: IChatRequestVariableEntry): obj is IElementVariableEntry;
+export declare function isDiagnosticsVariableEntry(obj: IChatRequestVariableEntry): obj is IDiagnosticVariableEntry;
+export declare function isChatRequestFileEntry(obj: IChatRequestVariableEntry): obj is IChatRequestFileEntry;
+export declare function isPromptFileVariableEntry(obj: IChatRequestVariableEntry): obj is IPromptFileVariableEntry;
+export declare function isPromptTextVariableEntry(obj: IChatRequestVariableEntry): obj is IPromptTextVariableEntry;
+export declare function isChatRequestVariableEntry(obj: unknown): obj is IChatRequestVariableEntry;
+export declare function isSCMHistoryItemVariableEntry(obj: IChatRequestVariableEntry): obj is ISCMHistoryItemVariableEntry;
+export declare enum PromptFileVariableKind {
+    Instruction = "vscode.prompt.instructions.root",
+    InstructionReference = "vscode.prompt.instructions",
+    PromptFile = "vscode.prompt.file"
+}
+export declare function toPromptFileVariableEntry(uri: URI, kind: PromptFileVariableKind, originLabel?: string, automaticallyAdded?: boolean): IPromptFileVariableEntry;
+export declare function toPromptTextVariableEntry(content: string, settingId?: string, automaticallyAdded?: boolean): IPromptTextVariableEntry;
+export declare function toFileVariableEntry(uri: URI, range?: IRange): IChatRequestFileEntry;
+export declare class ChatRequestVariableSet {
+    private _ids;
+    private _entries;
+    constructor(entries?: IChatRequestVariableEntry[]);
+    add(...entry: IChatRequestVariableEntry[]): void;
+    insertFirst(entry: IChatRequestVariableEntry): void;
+    remove(entry: IChatRequestVariableEntry): void;
+    has(entry: IChatRequestVariableEntry): boolean;
+    asArray(): IChatRequestVariableEntry[];
+}
+export {};

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

@@ -0,0 +1,160 @@
+
+import { Codicon } from '../../../../base/common/codicons.js';
+import { basename } from '../../../../base/common/resources.js';
+import { URI } from '../../../../base/common/uri.js';
+import { isLocation } from '../../../../editor/common/languages.js';
+import { localize } from '../../../../nls.js';
+
+var OmittedState;
+(function (OmittedState) {
+    OmittedState[OmittedState["NotOmitted"] = 0] = "NotOmitted";
+    OmittedState[OmittedState["Partial"] = 1] = "Partial";
+    OmittedState[OmittedState["Full"] = 2] = "Full";
+})(OmittedState || (OmittedState = {}));
+var IDiagnosticVariableEntryFilterData;
+(function (IDiagnosticVariableEntryFilterData) {
+    IDiagnosticVariableEntryFilterData.icon = Codicon.error;
+    function fromMarker(marker) {
+        return {
+            filterUri: marker.resource,
+            owner: marker.owner,
+            problemMessage: marker.message,
+            filterRange: { startLineNumber: marker.startLineNumber, endLineNumber: marker.endLineNumber, startColumn: marker.startColumn, endColumn: marker.endColumn }
+        };
+    }
+    IDiagnosticVariableEntryFilterData.fromMarker = fromMarker;
+    function toEntry(data) {
+        return {
+            id: id(data),
+            name: label(data),
+            icon: IDiagnosticVariableEntryFilterData.icon,
+            value: data,
+            kind: 'diagnostic',
+            ...data,
+        };
+    }
+    IDiagnosticVariableEntryFilterData.toEntry = toEntry;
+    function id(data) {
+        return [data.filterUri, data.owner, data.filterSeverity, data.filterRange?.startLineNumber].join(':');
+    }
+    IDiagnosticVariableEntryFilterData.id = id;
+    function label(data) {
+        let TrimThreshold;
+        (function (TrimThreshold) {
+            TrimThreshold[TrimThreshold["MaxChars"] = 30] = "MaxChars";
+            TrimThreshold[TrimThreshold["MaxSpaceLookback"] = 10] = "MaxSpaceLookback";
+        })(TrimThreshold || (TrimThreshold = {}));
+        if (data.problemMessage) {
+            if (data.problemMessage.length < TrimThreshold.MaxChars) {
+                return data.problemMessage;
+            }
+            const lastSpace = data.problemMessage.lastIndexOf(' ', TrimThreshold.MaxChars);
+            if (lastSpace === -1 || lastSpace + TrimThreshold.MaxSpaceLookback < TrimThreshold.MaxChars) {
+                return data.problemMessage.substring(0, TrimThreshold.MaxChars) + '…';
+            }
+            return data.problemMessage.substring(0, lastSpace) + '…';
+        }
+        let labelStr = ( localize(5302, "All Problems"));
+        if (data.filterUri) {
+            labelStr = ( localize(5303, "Problems in {0}", basename(data.filterUri)));
+        }
+        return labelStr;
+    }
+    IDiagnosticVariableEntryFilterData.label = label;
+})(IDiagnosticVariableEntryFilterData || (IDiagnosticVariableEntryFilterData = {}));
+var IChatRequestVariableEntry;
+(function (IChatRequestVariableEntry) {
+    function toUri(entry) {
+        return URI.isUri(entry.value)
+            ? entry.value
+            : isLocation(entry.value)
+                ? entry.value.uri
+                : undefined;
+    }
+    IChatRequestVariableEntry.toUri = toUri;
+})(IChatRequestVariableEntry || (IChatRequestVariableEntry = {}));
+function isPasteVariableEntry(obj) {
+    return obj.kind === 'paste';
+}
+function isImageVariableEntry(obj) {
+    return obj.kind === 'image';
+}
+function isNotebookOutputVariableEntry(obj) {
+    return obj.kind === 'notebookOutput';
+}
+function isElementVariableEntry(obj) {
+    return obj.kind === 'element';
+}
+function isPromptFileVariableEntry(obj) {
+    return obj.kind === 'promptFile';
+}
+function isPromptTextVariableEntry(obj) {
+    return obj.kind === 'promptText';
+}
+function isSCMHistoryItemVariableEntry(obj) {
+    return obj.kind === 'scmHistoryItem';
+}
+var PromptFileVariableKind;
+(function (PromptFileVariableKind) {
+    PromptFileVariableKind["Instruction"] = "vscode.prompt.instructions.root";
+    PromptFileVariableKind["InstructionReference"] = "vscode.prompt.instructions";
+    PromptFileVariableKind["PromptFile"] = "vscode.prompt.file";
+})(PromptFileVariableKind || (PromptFileVariableKind = {}));
+function toPromptFileVariableEntry(uri, kind, originLabel, automaticallyAdded = false) {
+    return {
+        id: `${kind}__${( uri.toString())}`,
+        name: `prompt:${basename(uri)}`,
+        value: uri,
+        kind: 'promptFile',
+        modelDescription: 'Prompt instructions file',
+        isRoot: kind !== PromptFileVariableKind.InstructionReference,
+        originLabel,
+        automaticallyAdded
+    };
+}
+function toPromptTextVariableEntry(content, settingId, automaticallyAdded = false) {
+    return {
+        id: `vscode.prompt.instructions.text${settingId ? `.${settingId}` : ''}`,
+        name: `prompt:text`,
+        value: content,
+        settingId,
+        kind: 'promptText',
+        modelDescription: 'Prompt instructions text',
+        automaticallyAdded
+    };
+}
+class ChatRequestVariableSet {
+    constructor(entries) {
+        this._ids = ( new Set());
+        this._entries = [];
+        if (entries) {
+            this.add(...entries);
+        }
+    }
+    add(...entry) {
+        for (const e of entry) {
+            if (!( this._ids.has(e.id))) {
+                this._ids.add(e.id);
+                this._entries.push(e);
+            }
+        }
+    }
+    insertFirst(entry) {
+        if (!( this._ids.has(entry.id))) {
+            this._ids.add(entry.id);
+            this._entries.unshift(entry);
+        }
+    }
+    remove(entry) {
+        this._ids.delete(entry.id);
+        this._entries = this._entries.filter(e => e.id !== entry.id);
+    }
+    has(entry) {
+        return ( this._ids.has(entry.id));
+    }
+    asArray() {
+        return this._entries.slice(0);
+    }
+}
+
+export { ChatRequestVariableSet, IChatRequestVariableEntry, IDiagnosticVariableEntryFilterData, OmittedState, PromptFileVariableKind, isElementVariableEntry, isImageVariableEntry, isNotebookOutputVariableEntry, isPasteVariableEntry, isPromptFileVariableEntry, isPromptTextVariableEntry, isSCMHistoryItemVariableEntry, toPromptFileVariableEntry, toPromptTextVariableEntry };

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

@@ -3,8 +3,9 @@ import { ThemeIcon } from "../../../../base/common/themables.js";
 import { URI } from "../../../../base/common/uri.js";
 import { IRange } from "../../../../editor/common/core/range.js";
 import { Location } from "../../../../editor/common/languages.js";
-import { IChatModel, IDiagnosticVariableEntryFilterData } from "./chatModel.js";
+import { IChatModel } from "@codingame/monaco-vscode-9911aec2-e4dd-5483-8369-9d695cc70d8a-common/vscode/vs/workbench/contrib/chat/common/chatModel";
 import { IChatContentReference, IChatProgressMessage } from "./chatService.js";
+import { IDiagnosticVariableEntryFilterData } from "./chatVariableEntries.js";
 export interface IChatVariableData {
     id: string;
     name: string;

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

@@ -1,5 +1,5 @@
 import { Event } from "../../../../base/common/event.js";
-import { IChatHistoryEntry } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/chatWidgetHistoryService";
+import { IChatHistoryEntry } from "@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/common/chatWidgetHistoryService";
 import { ChatAgentLocation } from "./constants.js";
 export declare const IChatWidgetHistoryService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatWidgetHistoryService>;
 export interface IChatWidgetHistoryService {

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

@@ -2,16 +2,16 @@ export declare enum ChatConfiguration {
     UseFileStorage = "chat.useFileStorage",
     AgentEnabled = "chat.agent.enabled",
     Edits2Enabled = "chat.edits2.enabled",
-    ExtensionToolsEnabled = "chat.extensionTools.enabled"
+    ExtensionToolsEnabled = "chat.extensionTools.enabled",
+    EditRequests = "chat.editRequests"
 }
-export declare enum ChatMode {
+export declare enum ChatModeKind {
     Ask = "ask",
     Edit = "edit",
     Agent = "agent"
 }
-export declare function modeToString(mode: ChatMode): "Edit" | "Agent" | "Ask";
-export declare function validateChatMode(mode: unknown): ChatMode | undefined;
-export declare function isChatMode(mode: unknown): mode is ChatMode;
+export declare function validateChatMode(mode: unknown): ChatModeKind | undefined;
+export declare function isChatMode(mode: unknown): mode is ChatModeKind;
 export type RawChatParticipantLocation = "panel" | "terminal" | "notebook" | "editing-session";
 export declare enum ChatAgentLocation {
     Panel = "panel",

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

@@ -6,37 +6,24 @@ var ChatConfiguration;
     ChatConfiguration["AgentEnabled"] = "chat.agent.enabled";
     ChatConfiguration["Edits2Enabled"] = "chat.edits2.enabled";
     ChatConfiguration["ExtensionToolsEnabled"] = "chat.extensionTools.enabled";
+    ChatConfiguration["EditRequests"] = "chat.editRequests";
 })(ChatConfiguration || (ChatConfiguration = {}));
-var ChatMode;
-(function (ChatMode) {
-    ChatMode["Ask"] = "ask";
-    ChatMode["Edit"] = "edit";
-    ChatMode["Agent"] = "agent";
-})(ChatMode || (ChatMode = {}));
-function modeToString(mode) {
-    switch (mode) {
-        case ChatMode.Agent:
-            return 'Agent';
-        case ChatMode.Edit:
-            return 'Edit';
-        case ChatMode.Ask:
-        default:
-            return 'Ask';
-    }
-}
+var ChatModeKind;
+(function (ChatModeKind) {
+    ChatModeKind["Ask"] = "ask";
+    ChatModeKind["Edit"] = "edit";
+    ChatModeKind["Agent"] = "agent";
+})(ChatModeKind || (ChatModeKind = {}));
 function validateChatMode(mode) {
     switch (mode) {
-        case ChatMode.Ask:
-        case ChatMode.Edit:
-        case ChatMode.Agent:
+        case ChatModeKind.Ask:
+        case ChatModeKind.Edit:
+        case ChatModeKind.Agent:
             return mode;
         default:
             return undefined;
     }
 }
-function isChatMode(mode) {
-    return !!validateChatMode(mode);
-}
 var ChatAgentLocation;
 (function (ChatAgentLocation) {
     ChatAgentLocation["Panel"] = "panel";
@@ -57,4 +44,4 @@ var ChatAgentLocation;
     ChatAgentLocation.fromRaw = fromRaw;
 })(ChatAgentLocation || (ChatAgentLocation = {}));
 
-export { ChatAgentLocation, ChatConfiguration, ChatMode, isChatMode, modeToString, validateChatMode };
+export { ChatAgentLocation, ChatConfiguration, ChatModeKind, validateChatMode };

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

@@ -76,6 +76,12 @@ export interface IToolInvocationContext {
     sessionId: string;
 }
 export declare function isToolInvocationContext(obj: any): obj is IToolInvocationContext;
+export interface IToolInvocationPreparationContext {
+    parameters: any;
+    chatRequestId?: string;
+    chatSessionId?: string;
+    chatInteractionId?: string;
+}
 export interface IToolResultInputOutputDetails {
     readonly input: string;
     readonly output: ({
@@ -127,8 +133,9 @@ export interface IPreparedToolInvocation {
 }
 export interface IToolImpl {
     invoke(invocation: IToolInvocation, countTokens: CountTokensCallback, progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
-    prepareToolInvocation?(parameters: any, token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+    prepareToolInvocation?(context: IToolInvocationPreparationContext, token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
 }
+export type IToolAndToolSetEnablementMap = ReadonlyMap<IToolData | ToolSet, boolean>;
 export declare class ToolSet {
     readonly id: string;
     readonly referenceName: string;

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

@@ -27,16 +27,16 @@ var ToolDataSource;
     ToolDataSource.equals = equals;
     function classify(source) {
         if (source.type === 'internal') {
-            return { ordinal: 1, label: ( localize(5169, 'Built-In')) };
+            return { ordinal: 1, label: ( localize(5307, 'Built-In')) };
         }
         else if (source.type === 'mcp') {
-            return { ordinal: 2, label: ( localize(5170, 'MCP Server: {0}', source.label)) };
+            return { ordinal: 2, label: ( localize(5308, 'MCP Server: {0}', source.label)) };
         }
         else if (source.type === 'user') {
-            return { ordinal: 0, label: ( localize(5171, 'User Defined')) };
+            return { ordinal: 0, label: ( localize(5309, 'User Defined')) };
         }
         else {
-            return { ordinal: 3, label: ( localize(5172, 'Extension: {0}', source.label)) };
+            return { ordinal: 3, label: ( localize(5310, 'Extension: {0}', source.label)) };
         }
     }
     ToolDataSource.classify = classify;

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

@@ -3,7 +3,7 @@ import { Event } from "../../../../base/common/event.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { IObservable } from "../../../../base/common/observable.js";
 import { ThemeIcon } from "../../../../base/common/themables.js";
-import { IToolData, IToolImpl, IToolInvocation, CountTokensCallback, IToolResult, ToolSet, ToolDataSource } from "./languageModelToolsService.js";
+import { IToolData, IToolImpl, IToolInvocation, CountTokensCallback, IToolResult, IToolAndToolSetEnablementMap, ToolSet, ToolDataSource } from "./languageModelToolsService.js";
 export declare const ILanguageModelToolsService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ILanguageModelToolsService>;
 export interface ILanguageModelToolsService {
     _serviceBrand: undefined;
@@ -17,8 +17,10 @@ export interface ILanguageModelToolsService {
     setToolAutoConfirmation(toolId: string, scope: "workspace" | "profile" | "memory", autoConfirm?: boolean): void;
     resetToolAutoConfirmation(): void;
     cancelToolCallsForRequest(requestId: string): void;
-    toEnablementMap(toolOrToolSetNames: Iterable<string>): Record<string, boolean>;
+    toToolEnablementMap(toolOrToolSetNames: Set<string>): Record<string, boolean>;
+    toToolAndToolSetEnablementMap(toolOrToolSetNames: readonly string[] | undefined): IToolAndToolSetEnablementMap;
     readonly toolSets: IObservable<Iterable<ToolSet>>;
+    getToolSet(id: string): ToolSet | undefined;
     getToolSetByName(name: string): ToolSet | undefined;
     createToolSet(source: ToolDataSource, id: string, referenceName: string, options?: {
         icon?: ThemeIcon;

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

@@ -92,7 +92,7 @@ export interface ILanguageModelChatMetadata {
     readonly modelPickerCategory: {
         label: string;
         order: number;
-    };
+    } | undefined;
     readonly auth?: {
         readonly providerLabel: string;
         readonly accountLabel?: string;
@@ -103,6 +103,10 @@ export interface ILanguageModelChatMetadata {
         readonly agentMode?: boolean;
     };
 }
+export declare namespace ILanguageModelChatMetadata {
+    function suitableForAgentMode(metadata: ILanguageModelChatMetadata): boolean;
+    function asQualifiedName(metadata: ILanguageModelChatMetadata): string;
+}
 export interface ILanguageModelChatResponse {
     stream: AsyncIterable<IChatResponseFragment | IChatResponseFragment[]>;
     result: Promise<any>;