@codingame/monaco-vscode-api 15.0.2 → 16.0.0

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

@@ -9,10 +9,11 @@ import { Command, Location, TextEdit } from "../../../../editor/common/languages
 import { FileType } from "../../../../platform/files/common/files.js";
 import { ICellEditOperation } from "../../notebook/common/notebookCommon.js";
 import { IWorkspaceSymbol } from "@codingame/monaco-vscode-42931eb9-e564-530c-bafc-fa23ab43a070-common/vscode/vs/workbench/contrib/search/common/search";
-import { ChatAgentLocation, IChatAgentCommand, IChatAgentData, IChatAgentResult } from "./chatAgents.js";
+import { IChatAgentCommand, IChatAgentData, IChatAgentResult } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatAgents";
 import { IChatRequestVariableEntry, IChatResponseModel } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatModel";
 import { IChatParserContext } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatRequestParser";
 import { IChatRequestVariableValue } from "./chatVariables.js";
+import { ChatAgentLocation, ChatMode } from "./constants.js";
 import { IPreparedToolInvocation, IToolConfirmationMessages, IToolResult } from "./languageModelToolsService.js";
 export interface IChatRequest {
     message: string;
@@ -128,6 +129,7 @@ export interface IChatAgentVulnerabilityDetails {
 export interface IChatResponseCodeblockUriPart {
     kind: "codeblockUri";
     uri: URI;
+    isEdit?: boolean;
 }
 export interface IChatAgentMarkdownContentWithVulnerability {
     content: IMarkdownString;
@@ -168,15 +170,21 @@ export interface IChatTerminalToolInvocationData {
     command: string;
     language: string;
 }
+export interface IChatToolInputInvocationData {
+    kind: "input";
+    rawInput: any;
+}
 export interface IChatToolInvocation {
     presentation: IPreparedToolInvocation["presentation"];
-    toolSpecificData?: IChatTerminalToolInvocationData;
+    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData;
     confirmationMessages?: IToolConfirmationMessages;
     confirmed: DeferredPromise<boolean>;
     isConfirmed: boolean | undefined;
     invocationMessage: string | IMarkdownString;
     pastTenseMessage: string | IMarkdownString | undefined;
     resultDetails: IToolResult["toolResultDetails"];
+    readonly toolId: string;
+    readonly toolCallId: string;
     isCompletePromise: Promise<void>;
     isComplete: boolean;
     complete(result: IToolResult): void;
@@ -184,12 +192,13 @@ export interface IChatToolInvocation {
 }
 export interface IChatToolInvocationSerialized {
     presentation: IPreparedToolInvocation["presentation"];
-    toolSpecificData?: IChatTerminalToolInvocationData;
+    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData;
     invocationMessage: string | IMarkdownString;
     pastTenseMessage: string | IMarkdownString | undefined;
     resultDetails: IToolResult["toolResultDetails"];
     isConfirmed: boolean | undefined;
     isComplete: boolean;
+    toolCallId: string;
     kind: "toolInvocationSerialized";
 }
 export type IChatProgress = IChatMarkdownContent | IChatAgentMarkdownContentWithVulnerability | IChatTreeData | IChatUsedContext | IChatContentReference | IChatContentInlineReference | IChatCodeCitation | IChatProgressMessage | IChatTask | IChatTaskResult | IChatCommandButton | IChatWarningMessage | IChatTextEdit | IChatNotebookEdit | IChatMoveMessage | IChatResponseCodeblockUriPart | IChatConfirmation | IChatToolInvocation | IChatToolInvocationSerialized | IChatUndoStop;
@@ -304,7 +313,7 @@ export interface IChatTransferredSessionData {
     sessionId: string;
     inputValue: string;
     location: ChatAgentLocation;
-    toolsAgentModeEnabled: boolean;
+    mode: ChatMode;
 }
 export interface IChatSendRequestResponseState {
     responseCreatedPromise: Promise<IChatResponseModel>;
@@ -329,7 +338,9 @@ export interface IChatTerminalLocationData {
 }
 export type IChatLocationData = IChatEditorLocationData | IChatNotebookLocationData | IChatTerminalLocationData;
 export interface IChatSendRequestOptions {
+    mode?: ChatMode;
     userSelectedModelId?: string;
+    userSelectedTools?: string[];
     location?: ChatAgentLocation;
     locationData?: IChatLocationData;
     parserContext?: IChatParserContext;

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

@@ -1,10 +1,10 @@
 import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { Event } from "../../../../base/common/event.js";
 import { URI } from "../../../../base/common/uri.js";
-import { ChatAgentLocation } from "./chatAgents.js";
 import { ChatModel, IChatModel, IExportableChatData, ISerializableChatData, IChatRequestModel, IChatRequestVariableData } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatModel";
 import { IParsedChatRequest } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-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>;
 export interface IChatService {
     _serviceBrand: undefined;
@@ -14,21 +14,24 @@ export interface IChatService {
     }>;
     isEnabled(location: ChatAgentLocation): boolean;
     hasSessions(): boolean;
-    startSession(location: ChatAgentLocation, token: CancellationToken): ChatModel;
+    startSession(location: ChatAgentLocation, token: CancellationToken, isGlobalEditingSession?: boolean): ChatModel;
     getSession(sessionId: string): IChatModel | undefined;
-    getOrRestoreSession(sessionId: string): IChatModel | undefined;
+    getOrRestoreSession(sessionId: string): Promise<IChatModel | undefined>;
+    isPersistedSessionEmpty(sessionId: string): boolean;
     loadSessionFromContent(data: IExportableChatData | ISerializableChatData): IChatModel | undefined;
     sendRequest(sessionId: string, message: string, options?: IChatSendRequestOptions): Promise<IChatSendRequestData | undefined>;
     resendRequest(request: IChatRequestModel, options?: IChatSendRequestOptions): Promise<void>;
     adoptRequest(sessionId: string, request: IChatRequestModel): Promise<void>;
     removeRequest(sessionid: string, requestId: string): Promise<void>;
     cancelCurrentRequestForSession(sessionId: string): void;
-    clearSession(sessionId: string): void;
+    clearSession(sessionId: string): Promise<void>;
     addCompleteRequest(sessionId: string, message: IParsedChatRequest | string, variableData: IChatRequestVariableData | undefined, attempt: number | undefined, response: IChatCompleteResponse): void;
-    getHistory(): IChatDetail[];
+    getHistory(): Promise<IChatDetail[]>;
     setChatSessionTitle(sessionId: string, title: string): void;
-    clearAllHistoryEntries(): void;
-    removeHistoryEntry(sessionId: string): void;
+    clearAllHistoryEntries(): Promise<void>;
+    removeHistoryEntry(sessionId: string): Promise<void>;
+    getChatStorageFolder(): URI;
+    logChatIndex(): void;
     onDidPerformUserAction: Event<IChatUserActionEvent>;
     notifyUserAction(event: IChatUserActionEvent): void;
     onDidDisposeSession: Event<{
@@ -36,4 +39,6 @@ export interface IChatService {
         reason: "initializationFailed" | "cleared";
     }>;
     transferChatSession(transferredSessionData: IChatTransferredSessionData, toWorkspace: URI): void;
+    readonly unifiedViewEnabled: boolean;
+    isEditingLocation(location: ChatAgentLocation): boolean;
 }

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

@@ -2,9 +2,9 @@ import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { Event } from "../../../../base/common/event.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { IProgress } from "../../../../platform/progress/common/progress.js";
-import { ChatAgentLocation } from "./chatAgents.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 { 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): Array<IChatSlashData>;
+    getCommands(location: ChatAgentLocation, mode: ChatMode): Array<IChatSlashData>;
     hasCommand(id: string): boolean;
 }

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

@@ -0,0 +1,5 @@
+export declare const IChatTransferService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatTransferService>;
+export interface IChatTransferService {
+    readonly _serviceBrand: undefined;
+    checkAndSetWorkspaceTrust(): Promise<void>;
+}

package/vscode/src/vs/workbench/contrib/chat/common/chatTransferService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+
+const IChatTransferService = ( createDecorator('chatTransferService'));
+
+export { IChatTransferService };

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

@@ -1,9 +1,9 @@
 import { URI } from "../../../../base/common/uri.js";
 import { Location } from "../../../../editor/common/languages.js";
-import { ChatAgentLocation } from "./chatAgents.js";
 import { IChatRequestVariableEntry, IChatRequestVariableData } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatModel";
 import { IParsedChatRequest } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatParserTypes";
 import { IDynamicVariable } from "./chatVariables.js";
+import { ChatAgentLocation } from "./constants.js";
 export declare const IChatVariablesService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatVariablesService>;
 export interface IChatVariablesService {
     _serviceBrand: undefined;

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

@@ -1,6 +1,6 @@
 import { Event } from "../../../../base/common/event.js";
-import { ChatAgentLocation } from "./chatAgents.js";
 import { IChatHistoryEntry } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-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 {
     _serviceBrand: undefined;

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

@@ -0,0 +1,24 @@
+export declare enum ChatConfiguration {
+    UnifiedChatView = "chat.unifiedChatView",
+    UseFileStorage = "chat.useFileStorage",
+    AgentEnabled = "chat.agent.enabled",
+    Edits2Enabled = "chat.edits2.enabled",
+    ExtensionToolsEnabled = "chat.extensionTools.enabled"
+}
+export declare enum ChatMode {
+    Ask = "ask",
+    Edit = "edit",
+    Agent = "agent"
+}
+export declare function validateChatMode(mode: unknown): ChatMode | undefined;
+export type RawChatParticipantLocation = "panel" | "terminal" | "notebook" | "editing-session";
+export declare enum ChatAgentLocation {
+    Panel = "panel",
+    Terminal = "terminal",
+    Notebook = "notebook",
+    Editor = "editor",
+    EditingSession = "editing-session"
+}
+export declare namespace ChatAgentLocation {
+    function fromRaw(value: RawChatParticipantLocation | string): ChatAgentLocation;
+}

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

@@ -0,0 +1,49 @@
+
+
+var ChatConfiguration;
+(function (ChatConfiguration) {
+    ChatConfiguration["UnifiedChatView"] = "chat.unifiedChatView";
+    ChatConfiguration["UseFileStorage"] = "chat.useFileStorage";
+    ChatConfiguration["AgentEnabled"] = "chat.agent.enabled";
+    ChatConfiguration["Edits2Enabled"] = "chat.edits2.enabled";
+    ChatConfiguration["ExtensionToolsEnabled"] = "chat.extensionTools.enabled";
+})(ChatConfiguration || (ChatConfiguration = {}));
+var ChatMode;
+(function (ChatMode) {
+    ChatMode["Ask"] = "ask";
+    ChatMode["Edit"] = "edit";
+    ChatMode["Agent"] = "agent";
+})(ChatMode || (ChatMode = {}));
+function validateChatMode(mode) {
+    switch (mode) {
+        case ChatMode.Ask:
+        case ChatMode.Edit:
+        case ChatMode.Agent:
+            return mode;
+        default:
+            return undefined;
+    }
+}
+var ChatAgentLocation;
+(function (ChatAgentLocation) {
+    ChatAgentLocation["Panel"] = "panel";
+    ChatAgentLocation["Terminal"] = "terminal";
+    ChatAgentLocation["Notebook"] = "notebook";
+    ChatAgentLocation["Editor"] = "editor";
+    ChatAgentLocation["EditingSession"] = "editing-session";
+})(ChatAgentLocation || (ChatAgentLocation = {}));
+(function (ChatAgentLocation) {
+    function fromRaw(value) {
+        switch (value) {
+            case 'panel': return ChatAgentLocation.Panel;
+            case 'terminal': return ChatAgentLocation.Terminal;
+            case 'notebook': return ChatAgentLocation.Notebook;
+            case 'editor': return ChatAgentLocation.Editor;
+            case 'editing-session': return ChatAgentLocation.EditingSession;
+        }
+        return ChatAgentLocation.Panel;
+    }
+    ChatAgentLocation.fromRaw = fromRaw;
+})(ChatAgentLocation || (ChatAgentLocation = {}));
+
+export { ChatAgentLocation, ChatConfiguration, ChatMode, validateChatMode };

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

@@ -6,10 +6,10 @@ import { URI } from "../../../../base/common/uri.js";
 import { ContextKeyExpression } from "../../../../platform/contextkey/common/contextkey.js";
 import { ExtensionIdentifier } from "../../../../platform/extensions/common/extensions.js";
 import { Location } from "../../../../editor/common/languages.js";
-import { IChatTerminalToolInvocationData } from "./chatService.js";
+import { IChatTerminalToolInvocationData, IChatToolInputInvocationData } from "./chatService.js";
 export interface IToolData {
     id: string;
-    extensionId?: ExtensionIdentifier;
+    source: ToolDataSource;
     toolReferenceName?: string;
     icon?: {
         dark: URI;
@@ -22,6 +22,24 @@ export interface IToolData {
     modelDescription: string;
     inputSchema?: IJSONSchema;
     canBeReferencedInPrompt?: boolean;
+    runsInWorkspace?: boolean;
+    requiresConfirmation?: boolean;
+    alwaysDisplayInputOutput?: boolean;
+    supportsToolPicker?: boolean;
+}
+export type ToolDataSource = {
+    type: "extension";
+    extensionId: ExtensionIdentifier;
+    isExternalTool: boolean;
+} | {
+    type: "mcp";
+    collectionId: string;
+    definitionId: string;
+} | {
+    type: "internal";
+};
+export declare namespace ToolDataSource {
+    function toKey(source: ToolDataSource): string;
 }
 export interface IToolInvocation {
     callId: string;
@@ -30,21 +48,29 @@ export interface IToolInvocation {
     tokenBudget?: number;
     context: IToolInvocationContext | undefined;
     chatRequestId?: string;
-    toolSpecificData?: IChatTerminalToolInvocationData;
+    chatInteractionId?: string;
+    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData;
+    modelId?: string;
 }
 export interface IToolInvocationContext {
     sessionId: string;
 }
 export declare function isToolInvocationContext(obj: any): obj is IToolInvocationContext;
+export interface IToolResultInputOutputDetails {
+    readonly input: string;
+    readonly output: string;
+}
+export declare function isToolResultInputOutputDetails(obj: any): obj is IToolResultInputOutputDetails;
 export interface IToolResult {
     content: (IToolResultPromptTsxPart | IToolResultTextPart)[];
     toolResultMessage?: string | IMarkdownString;
-    toolResultDetails?: Array<URI | Location>;
+    toolResultDetails?: Array<URI | Location> | IToolResultInputOutputDetails;
 }
 export interface IToolResultPromptTsxPart {
     kind: "promptTsx";
     value: unknown;
 }
+export declare function stringifyPromptTsxPart(part: IToolResultPromptTsxPart): string;
 export interface IToolResultTextPart {
     kind: "text";
     value: string;
@@ -52,16 +78,18 @@ export interface IToolResultTextPart {
 export interface IToolConfirmationMessages {
     title: string;
     message: string | IMarkdownString;
+    allowAutoConfirm?: boolean;
 }
 export interface IPreparedToolInvocation {
     invocationMessage?: string | IMarkdownString;
     pastTenseMessage?: string | IMarkdownString;
     confirmationMessages?: IToolConfirmationMessages;
     presentation?: "hidden" | undefined;
-    toolSpecificData?: IChatTerminalToolInvocationData;
+    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData;
 }
 export interface IToolImpl {
     invoke(invocation: IToolInvocation, countTokens: CountTokensCallback, token: CancellationToken): Promise<IToolResult>;
     prepareToolInvocation?(parameters: any, token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
 }
 export type CountTokensCallback = (input: string, token: CancellationToken) => Promise<number>;
+export declare function createToolInputUri(toolOrId: IToolData | string): URI;

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

@@ -1,7 +1,33 @@
 
+import { URI } from '../../../../base/common/uri.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { stringifyPromptElementJSON } from './tools/promptTsxTypes.js';
 
+var ToolDataSource;
+(function (ToolDataSource) {
+    function toKey(source) {
+        switch (source.type) {
+            case 'extension': return `extension:${source.extensionId.value}`;
+            case 'mcp': return `mcp:${source.collectionId}:${source.definitionId}`;
+            case 'internal': return 'internal';
+        }
+    }
+    ToolDataSource.toKey = toKey;
+})(ToolDataSource || (ToolDataSource = {}));
 function isToolInvocationContext(obj) {
     return typeof obj === 'object' && typeof obj.sessionId === 'string';
 }
+function isToolResultInputOutputDetails(obj) {
+    return typeof obj === 'object' && typeof obj?.input === 'string' && typeof obj?.output === 'string';
+}
+function stringifyPromptTsxPart(part) {
+    return stringifyPromptElementJSON(part.value);
+}
+function createToolInputUri(toolOrId) {
+    if (typeof toolOrId !== 'string') {
+        toolOrId = toolOrId.id;
+    }
+    return ( URI.from({ scheme: Schemas.inMemory, path: `/lm/tool/${toolOrId}/tool_input.json` }));
+}
 
-export { isToolInvocationContext };
+export { ToolDataSource, createToolInputUri, isToolInvocationContext, isToolResultInputOutputDetails, stringifyPromptTsxPart };

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

@@ -12,5 +12,7 @@ export interface ILanguageModelToolsService {
     getTool(id: string): IToolData | undefined;
     getToolByName(name: string): IToolData | undefined;
     invokeTool(invocation: IToolInvocation, countTokens: CountTokensCallback, token: CancellationToken): Promise<IToolResult>;
+    setToolAutoConfirmation(toolId: string, scope: "workspace" | "profile" | "memory", autoConfirm?: boolean): void;
+    resetToolAutoConfirmation(): void;
     cancelToolCallsForRequest(requestId: string): void;
 }

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

@@ -1,3 +1,4 @@
+import { VSBuffer } from "../../../../base/common/buffer.js";
 import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { Event } from "../../../../base/common/event.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
@@ -15,13 +16,32 @@ export interface IChatMessageTextPart {
     type: "text";
     value: string;
 }
+export interface IChatMessageImagePart {
+    type: "image_url";
+    value: IChatImageURLPart;
+}
+export interface IChatImageURLPart {
+    mimeType: ChatImageMimeType;
+    data: VSBuffer;
+}
+export declare enum ChatImageMimeType {
+    PNG = "image/png",
+    JPEG = "image/jpeg",
+    GIF = "image/gif",
+    WEBP = "image/webp",
+    BMP = "image/bmp"
+}
+export declare enum ImageDetailLevel {
+    Low = "low",
+    High = "high"
+}
 export interface IChatMessageToolResultPart {
     type: "tool_result";
     toolCallId: string;
     value: (IChatResponseTextPart | IChatResponsePromptTsxPart)[];
     isError?: boolean;
 }
-export type IChatMessagePart = IChatMessageTextPart | IChatMessageToolResultPart | IChatResponseToolUsePart;
+export type IChatMessagePart = IChatMessageTextPart | IChatMessageToolResultPart | IChatResponseToolUsePart | IChatMessageImagePart;
 export interface IChatMessage {
     readonly name?: string | undefined;
     readonly role: ChatMessageRole;

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

@@ -19,19 +19,32 @@ var ChatMessageRole;
     ChatMessageRole[ChatMessageRole["User"] = 1] = "User";
     ChatMessageRole[ChatMessageRole["Assistant"] = 2] = "Assistant";
 })(ChatMessageRole || (ChatMessageRole = {}));
+var ChatImageMimeType;
+(function (ChatImageMimeType) {
+    ChatImageMimeType["PNG"] = "image/png";
+    ChatImageMimeType["JPEG"] = "image/jpeg";
+    ChatImageMimeType["GIF"] = "image/gif";
+    ChatImageMimeType["WEBP"] = "image/webp";
+    ChatImageMimeType["BMP"] = "image/bmp";
+})(ChatImageMimeType || (ChatImageMimeType = {}));
+var ImageDetailLevel;
+(function (ImageDetailLevel) {
+    ImageDetailLevel["Low"] = "low";
+    ImageDetailLevel["High"] = "high";
+})(ImageDetailLevel || (ImageDetailLevel = {}));
 const languageModelType = {
     type: 'object',
     properties: {
         vendor: {
             type: 'string',
-            description: ( localize(4862, "A globally unique vendor of language models."))
+            description: ( localize(4991, "A globally unique vendor of language models."))
         }
     }
 };
 const languageModelExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'languageModels',
     jsonSchema: {
-        description: ( localize(4863, "Contribute language models of a specific vendor.")),
+        description: ( localize(4992, "Contribute language models of a specific vendor.")),
         oneOf: [
             languageModelType,
             {
@@ -61,24 +74,24 @@ let LanguageModelsService = class LanguageModelsService {
             this._vendors.clear();
             for (const extension of extensions) {
                 if (!isProposedApiEnabled(extension.description, 'chatProvider')) {
-                    extension.collector.error(( localize(4864, "This contribution point requires the 'chatProvider' proposal.")));
+                    extension.collector.error(( localize(4993, "This contribution point requires the 'chatProvider' proposal.")));
                     continue;
                 }
                 for (const item of Iterable.wrap(extension.value)) {
                     if (( this._vendors.has(item.vendor))) {
                         extension.collector.error(( localize(
-                            4865,
+                            4994,
                             "The vendor '{0}' is already registered and cannot be registered twice",
                             item.vendor
                         )));
                         continue;
                     }
                     if (isFalsyOrWhitespace(item.vendor)) {
-                        extension.collector.error(( localize(4866, "The vendor field cannot be empty.")));
+                        extension.collector.error(( localize(4995, "The vendor field cannot be empty.")));
                         continue;
                     }
                     if (item.vendor.trim() !== item.vendor) {
-                        extension.collector.error(( localize(4867, "The vendor field cannot start or end with whitespace.")));
+                        extension.collector.error(( localize(4996, "The vendor field cannot start or end with whitespace.")));
                         continue;
                     }
                     this._vendors.add(item.vendor);
@@ -176,4 +189,4 @@ LanguageModelsService = ( __decorate([
     ( __param(2, IContextKeyService))
 ], LanguageModelsService));
 
-export { ChatMessageRole, LanguageModelsService, languageModelExtensionPoint };
+export { ChatImageMimeType, ChatMessageRole, ImageDetailLevel, LanguageModelsService, languageModelExtensionPoint };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/contentProviders/types.d.ts

@@ -1,9 +1,13 @@
 import { URI } from "../../../../../../base/common/uri.js";
-import { ParseError } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/promptFileReferenceErrors";
+import { ResolveError } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/promptFileReferenceErrors";
 import { IDisposable } from "../../../../../../base/common/lifecycle.js";
 import { VSBufferReadableStream } from "../../../../../../base/common/buffer.js";
 export interface IPromptContentsProvider extends IDisposable {
     readonly uri: URI;
     start(): this;
-    onContentChanged(callback: (streamOrError: VSBufferReadableStream | ParseError) => void): IDisposable;
+    onContentChanged(callback: (streamOrError: VSBufferReadableStream | ResolveError) => void): IDisposable;
+    onDispose(callback: () => void): this;
+    createNew(promptContentsSource: {
+        uri: URI;
+    }): IPromptContentsProvider;
 }

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/parsers/types.d.ts

@@ -1,30 +1,38 @@
 import { URI } from "../../../../../../base/common/uri.js";
-import { ParseError } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/promptFileReferenceErrors";
+import { ResolveError } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/promptFileReferenceErrors";
 import { IDisposable } from "../../../../../../base/common/lifecycle.js";
 import { IRange, Range } from "../../../../../../editor/common/core/range.js";
 export interface IResolveError {
-    message: string;
-    isRootError: boolean;
+    readonly originalError: ResolveError;
+    readonly parentUri?: URI;
 }
-type PromptReferenceTypes = "file";
-export interface IPromptReference extends IDisposable {
-    readonly type: PromptReferenceTypes;
+export interface ITopError extends IResolveError {
+    readonly errorSubject: "root" | "child" | "indirect-child";
+    readonly errorsCount: number;
+    readonly localizedMessage: string;
+}
+interface IPromptReferenceBase extends IDisposable {
+    readonly type: string;
+    readonly subtype: string;
     readonly uri: URI;
     readonly range: Range;
     readonly linkRange: IRange | undefined;
     readonly text: string;
     readonly path: string;
-    readonly isPromptSnippet: boolean;
+    readonly isPromptFile: boolean;
     readonly resolveFailed: boolean | undefined;
-    readonly errorCondition: ParseError | undefined;
-    readonly allErrors: readonly ParseError[];
-    readonly topError: IResolveError | undefined;
+    readonly errorCondition: ResolveError | undefined;
+    readonly errors: readonly ResolveError[];
+    readonly allErrors: readonly IResolveError[];
+    readonly topError: ITopError | undefined;
     references: readonly IPromptReference[];
     allReferences: readonly IPromptReference[];
     allValidReferences: readonly IPromptReference[];
     settled(): Promise<this>;
     allSettled(): Promise<this>;
 }
-export interface IPromptFileReference extends IPromptReference {
+export interface IPromptFileReference extends IPromptReferenceBase {
     readonly type: "file";
+    readonly subtype: "prompt" | "markdown";
 }
+export type IPromptReference = IPromptFileReference;

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

@@ -1,24 +1,26 @@
 import { CancellationToken } from "../../../../../base/common/cancellation.js";
 import { UriComponents } from "../../../../../base/common/uri.js";
 import { IWorkspaceContextService } from "../../../../../platform/workspace/common/workspace.service.js";
+import { IEditorGroupsService } from "../../../../services/editor/common/editorGroupsService.service.js";
 import { ITextFileService } from "../../../../services/textfile/common/textfiles.service.js";
+import { INotebookService } from "../../../notebook/common/notebookService.service.js";
 import { ICodeMapperService } from "../chatCodeMapperService.service.js";
-import { IChatEditingService } from "../chatEditingService.service.js";
 import { IChatService } from "../chatService.service.js";
 import { ILanguageModelIgnoredFilesService } from "../ignoredFiles.service.js";
 import { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolResult } from "../languageModelToolsService.js";
-import { IToolInputProcessor } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/common/tools/tools";
+import { IToolInputProcessor } from "./tools.js";
 export declare const ExtensionEditToolId = "vscode_editFile";
 export declare const InternalEditToolId = "vscode_editFile_internal";
 export declare const EditToolData: IToolData;
 export declare class EditTool implements IToolImpl {
     private readonly chatService;
-    private readonly chatEditingService;
     private readonly codeMapperService;
     private readonly workspaceContextService;
     private readonly ignoredFilesService;
     private readonly textFileService;
-    constructor(chatService: IChatService, chatEditingService: IChatEditingService, codeMapperService: ICodeMapperService, workspaceContextService: IWorkspaceContextService, ignoredFilesService: ILanguageModelIgnoredFilesService, textFileService: ITextFileService);
+    private readonly notebookService;
+    private readonly editorGroupsService;
+    constructor(chatService: IChatService, codeMapperService: ICodeMapperService, workspaceContextService: IWorkspaceContextService, ignoredFilesService: ILanguageModelIgnoredFilesService, textFileService: ITextFileService, notebookService: INotebookService, editorGroupsService: IEditorGroupsService);
     invoke(invocation: IToolInvocation, countTokens: CountTokensCallback, token: CancellationToken): Promise<IToolResult>;
     prepareToolInvocation(parameters: any, token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
 }