@codingame/monaco-vscode-api 26.2.2 → 28.0.0

package/vscode/src/vs/workbench/contrib/chat/common/model/chatProgressTypes/chatToolInvocation.js

@@ -0,0 +1,298 @@
+
+import { encodeBase64 } from '../../../../../../base/common/buffer.js';
+import '../../../../../../base/common/observableInternal/index.js';
+import { localize } from '../../../../../../nls.js';
+import { ToolConfirmKind, IChatToolInvocation } from '../../chatService/chatService.js';
+import { isToolResultOutputDetails } from '../../tools/languageModelToolsService.js';
+import { observableValue } from '../../../../../../base/common/observableInternal/observables/observableValue.js';
+
+class ChatToolInvocation {
+    get state() {
+        return this._state;
+    }
+    static createStreaming(options) {
+        return ( new ChatToolInvocation(
+            undefined,
+            options.toolData,
+            options.toolCallId,
+            options.subagentInvocationId,
+            undefined,
+            {
+                startInStreaming: true
+            },
+            options.chatRequestId
+        ));
+    }
+    static createCancelled(options, parameters, reason, reasonMessage) {
+        return ( new ChatToolInvocation(
+            undefined,
+            options.toolData,
+            options.toolCallId,
+            options.subagentInvocationId,
+            parameters,
+            {
+                startInCancelled: true,
+                cancelReason: reason,
+                cancelReasonMessage: reasonMessage
+            },
+            options.chatRequestId
+        ));
+    }
+    constructor(
+        preparedInvocation,
+        toolData,
+        toolCallId,
+        subAgentInvocationId,
+        parameters,
+        startOptions = {},
+        chatRequestId
+    ) {
+        this.toolCallId = toolCallId;
+        this.kind = "toolInvocation";
+        this._progress = observableValue(this, {
+            progress: 0
+        });
+        this._partialInput = observableValue(this, undefined);
+        this._streamingMessage = observableValue(this, undefined);
+        let defaultMessage = "";
+        if (startOptions.startInStreaming) {
+            defaultMessage = ( localize(7018, "Using \"{0}\"", toolData.displayName));
+        } else if (startOptions.startInCancelled) {
+            defaultMessage = startOptions.cancelReasonMessage ?? ( localize(7019, "Tool \"{0}\" was denied", toolData.displayName));
+        }
+        this.invocationMessage = preparedInvocation?.invocationMessage ?? defaultMessage;
+        this.pastTenseMessage = preparedInvocation?.pastTenseMessage;
+        this.originMessage = preparedInvocation?.originMessage;
+        this.confirmationMessages = preparedInvocation?.confirmationMessages;
+        this.presentation = preparedInvocation?.presentation;
+        this.toolSpecificData = preparedInvocation?.toolSpecificData;
+        this.toolId = toolData.id;
+        this.source = toolData.source;
+        this.subAgentInvocationId = subAgentInvocationId;
+        this.parameters = parameters;
+        this.chatRequestId = chatRequestId;
+        if (startOptions.startInCancelled) {
+            this._state = observableValue(this, {
+                type: IChatToolInvocation.StateKind.Cancelled,
+                reason: startOptions.cancelReason ?? ToolConfirmKind.Denied,
+                reasonMessage: startOptions.cancelReasonMessage,
+                parameters: this.parameters,
+                confirmationMessages: this.confirmationMessages
+            });
+        } else if (startOptions.startInStreaming) {
+            this._state = observableValue(this, {
+                type: IChatToolInvocation.StateKind.Streaming,
+                partialInput: this._partialInput,
+                streamingMessage: this._streamingMessage
+            });
+        } else if (!this.confirmationMessages?.title) {
+            this._state = observableValue(this, {
+                type: IChatToolInvocation.StateKind.Executing,
+                confirmed: {
+                    type: ToolConfirmKind.ConfirmationNotNeeded,
+                    reason: this.confirmationMessages?.confirmationNotNeededReason
+                },
+                progress: this._progress,
+                parameters: this.parameters,
+                confirmationMessages: this.confirmationMessages
+            });
+        } else {
+            this._state = observableValue(this, {
+                type: IChatToolInvocation.StateKind.WaitingForConfirmation,
+                parameters: this.parameters,
+                confirmationMessages: this.confirmationMessages,
+                confirm: reason => {
+                    if (reason.type === ToolConfirmKind.Denied || reason.type === ToolConfirmKind.Skipped) {
+                        this._state.set({
+                            type: IChatToolInvocation.StateKind.Cancelled,
+                            reason: reason.type,
+                            parameters: this.parameters,
+                            confirmationMessages: this.confirmationMessages
+                        }, undefined);
+                    } else {
+                        this._state.set({
+                            type: IChatToolInvocation.StateKind.Executing,
+                            confirmed: reason,
+                            progress: this._progress,
+                            parameters: this.parameters,
+                            confirmationMessages: this.confirmationMessages
+                        }, undefined);
+                    }
+                }
+            });
+        }
+    }
+    updatePartialInput(input) {
+        if (this._state.get().type !== IChatToolInvocation.StateKind.Streaming) {
+            return;
+        }
+        this._partialInput.set(input, undefined);
+    }
+    updateStreamingMessage(message) {
+        const state = this._state.get();
+        if (state.type !== IChatToolInvocation.StateKind.Streaming) {
+            return;
+        }
+        this._streamingMessage.set(message, undefined);
+    }
+    cancelFromStreaming(reason, reasonMessage) {
+        const currentState = this._state.get();
+        if (currentState.type !== IChatToolInvocation.StateKind.Streaming) {
+            return false;
+        }
+        this._state.set({
+            type: IChatToolInvocation.StateKind.Cancelled,
+            reason: reason,
+            reasonMessage: reasonMessage,
+            parameters: this.parameters,
+            confirmationMessages: this.confirmationMessages
+        }, undefined);
+        return true;
+    }
+    transitionFromStreaming(preparedInvocation, parameters, autoConfirmed) {
+        const currentState = this._state.get();
+        if (currentState.type !== IChatToolInvocation.StateKind.Streaming) {
+            return;
+        }
+        const lastStreamingMessage = this._streamingMessage.get();
+        if (lastStreamingMessage && !preparedInvocation?.invocationMessage) {
+            this.invocationMessage = lastStreamingMessage;
+        }
+        this.parameters = parameters;
+        if (preparedInvocation) {
+            if (preparedInvocation.invocationMessage) {
+                this.invocationMessage = preparedInvocation.invocationMessage;
+            }
+            this.pastTenseMessage = preparedInvocation.pastTenseMessage;
+            this.confirmationMessages = preparedInvocation.confirmationMessages;
+            this.presentation = preparedInvocation.presentation;
+            this.toolSpecificData = preparedInvocation.toolSpecificData;
+        }
+        const confirm = reason => {
+            if (reason.type === ToolConfirmKind.Denied || reason.type === ToolConfirmKind.Skipped) {
+                this._state.set({
+                    type: IChatToolInvocation.StateKind.Cancelled,
+                    reason: reason.type,
+                    parameters: this.parameters,
+                    confirmationMessages: this.confirmationMessages
+                }, undefined);
+            } else {
+                this._state.set({
+                    type: IChatToolInvocation.StateKind.Executing,
+                    confirmed: reason,
+                    progress: this._progress,
+                    parameters: this.parameters,
+                    confirmationMessages: this.confirmationMessages
+                }, undefined);
+            }
+        };
+        if (autoConfirmed) {
+            confirm(autoConfirmed);
+        } else if (!this.confirmationMessages?.title) {
+            this._state.set({
+                type: IChatToolInvocation.StateKind.Executing,
+                confirmed: {
+                    type: ToolConfirmKind.ConfirmationNotNeeded,
+                    reason: this.confirmationMessages?.confirmationNotNeededReason
+                },
+                progress: this._progress,
+                parameters: this.parameters,
+                confirmationMessages: this.confirmationMessages
+            }, undefined);
+        } else {
+            this._state.set({
+                type: IChatToolInvocation.StateKind.WaitingForConfirmation,
+                parameters: this.parameters,
+                confirmationMessages: this.confirmationMessages,
+                confirm
+            }, undefined);
+        }
+    }
+    _setCompleted(result, postConfirmed) {
+        if (postConfirmed && (postConfirmed.type === ToolConfirmKind.Denied || postConfirmed.type === ToolConfirmKind.Skipped)) {
+            this._state.set({
+                type: IChatToolInvocation.StateKind.Cancelled,
+                reason: postConfirmed.type,
+                parameters: this.parameters,
+                confirmationMessages: this.confirmationMessages
+            }, undefined);
+            return;
+        }
+        this._state.set({
+            type: IChatToolInvocation.StateKind.Completed,
+            confirmed: IChatToolInvocation.executionConfirmedOrDenied(this) || {
+                type: ToolConfirmKind.ConfirmationNotNeeded
+            },
+            resultDetails: result?.toolResultDetails,
+            postConfirmed,
+            contentForModel: result?.content || [],
+            parameters: this.parameters,
+            confirmationMessages: this.confirmationMessages
+        }, undefined);
+    }
+    async didExecuteTool(result, final, checkIfResultAutoApproved) {
+        if (result?.toolResultMessage) {
+            this.pastTenseMessage = result.toolResultMessage;
+        } else if (this._progress.get().message) {
+            this.pastTenseMessage = this._progress.get().message;
+        }
+        if (this.confirmationMessages?.confirmResults && !result?.toolResultError && result?.confirmResults !== false && !final) {
+            const autoApproved = await checkIfResultAutoApproved?.();
+            if (autoApproved) {
+                this._setCompleted(result, autoApproved);
+            } else {
+                this._state.set({
+                    type: IChatToolInvocation.StateKind.WaitingForPostApproval,
+                    confirmed: IChatToolInvocation.executionConfirmedOrDenied(this) || {
+                        type: ToolConfirmKind.ConfirmationNotNeeded
+                    },
+                    resultDetails: result?.toolResultDetails,
+                    contentForModel: result?.content || [],
+                    confirm: reason => this._setCompleted(result, reason),
+                    parameters: this.parameters,
+                    confirmationMessages: this.confirmationMessages
+                }, undefined);
+            }
+        } else {
+            this._setCompleted(result);
+        }
+        return this._state.get();
+    }
+    acceptProgress(step) {
+        const prev = this._progress.get();
+        this._progress.set({
+            progress: step.progress || prev.progress || 0,
+            message: step.message
+        }, undefined);
+    }
+    toJSON() {
+        const waitingForPostApproval = this.state.get().type === IChatToolInvocation.StateKind.WaitingForPostApproval;
+        const details = waitingForPostApproval ? undefined : IChatToolInvocation.resultDetails(this);
+        return {
+            kind: "toolInvocationSerialized",
+            presentation: this.presentation,
+            invocationMessage: this.invocationMessage,
+            pastTenseMessage: this.pastTenseMessage,
+            originMessage: this.originMessage,
+            isConfirmed: waitingForPostApproval ? {
+                type: ToolConfirmKind.Skipped
+            } : IChatToolInvocation.executionConfirmedOrDenied(this),
+            isComplete: true,
+            source: this.source,
+            resultDetails: isToolResultOutputDetails(details) ? {
+                output: {
+                    type: "data",
+                    mimeType: details.output.mimeType,
+                    base64Data: encodeBase64(details.output.value)
+                }
+            } : details,
+            toolSpecificData: this.toolSpecificData,
+            toolCallId: this.toolCallId,
+            toolId: this.toolId,
+            subAgentInvocationId: this.subAgentInvocationId,
+            generatedTitle: this.generatedTitle
+        };
+    }
+}
+
+export { ChatToolInvocation };

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

@@ -2,6 +2,7 @@ import { URI } from "../../../../../base/common/uri.js";
 export declare namespace LocalChatSessionUri {
     const scheme = "vscode-chat-session";
     function forSession(sessionId: string): URI;
+    function getNewSessionUri(): URI;
     function parseLocalSessionId(resource: URI): string | undefined;
     function isLocalSession(resource: URI): boolean;
 }

package/vscode/src/vs/workbench/contrib/chat/common/model/chatUri.js

@@ -16,6 +16,11 @@ var LocalChatSessionUri;
         }));
     }
     LocalChatSessionUri.forSession = forSession;
+    function getNewSessionUri() {
+        const handle = Math.floor(Math.random() * 1e9);
+        return forSession(`chat-${handle}`);
+    }
+    LocalChatSessionUri.getNewSessionUri = getNewSessionUri;
     function parseLocalSessionId(resource) {
         const parsed = parse(resource);
         return parsed?.chatSessionType === localChatSessionType ? parsed.sessionId : undefined;

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

@@ -9,15 +9,12 @@ import { Command } from "../../../../../editor/common/languages.js";
 import { IConfigurationService } from "../../../../../platform/configuration/common/configuration.service.js";
 import { IContextKeyService } from "../../../../../platform/contextkey/common/contextkey.service.js";
 import { ExtensionIdentifier } from "../../../../../platform/extensions/common/extensions.js";
-import { ILogService } from "../../../../../platform/log/common/log.service.js";
-import { IProductService } from "../../../../../platform/product/common/productService.service.js";
-import { IRequestService } from "../../../../../platform/request/common/request.service.js";
-import { IStorageService } from "../../../../../platform/storage/common/storage.service.js";
 import { IChatAgentEditedFileEvent, IChatProgressHistoryResponseContent, IChatRequestModeInstructions, IChatRequestVariableData, ISerializableChatAgentData } from "../model/chatModel.js";
-import { IChatRequestHooks } from "../promptSyntax/hookSchema.js";
+import { ChatRequestHooks } from "../promptSyntax/hookSchema.js";
 import { IRawChatCommandContribution } from "./chatParticipantContribTypes.js";
 import { IChatFollowup, IChatLocationData, IChatProgress, IChatResponseErrorDetails, IChatTaskDto } from "../chatService/chatService.js";
-import { ChatAgentLocation, ChatModeKind } from "../constants.js";
+import { ChatAgentLocation, ChatModeKind, ChatPermissionLevel } from "../constants.js";
+import { ILanguageModelsService } from "../languageModels.service.js";
 import { IChatAgentService, type IChatAgentNameService } from "./chatAgents.service.js";
 export interface IChatAgentHistoryEntry {
     request: IChatAgentRequest;
@@ -35,6 +32,8 @@ export interface IChatAgentAttachmentCapabilities {
     supportsProblemAttachments?: boolean;
     supportsSymbolAttachments?: boolean;
     supportsTerminalAttachments?: boolean;
+    supportsPromptAttachments?: boolean;
+    supportsHandOffs?: boolean;
 }
 export interface IChatAgentData {
     id: string;
@@ -76,7 +75,7 @@ export interface IChatWelcomeMessageContent {
 export interface IChatAgentImplementation {
     invoke(request: IChatAgentRequest, progress: (parts: IChatProgress[]) => void, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatAgentResult>;
     setRequestTools?(requestId: string, tools: UserSelectedTools): void;
-    setYieldRequested?(requestId: string): void;
+    setYieldRequested?(requestId: string, value: boolean): void;
     provideFollowups?(request: IChatAgentRequest, result: IChatAgentResult, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatFollowup[]>;
     provideChatTitle?: (history: IChatAgentHistoryEntry[], token: CancellationToken) => Promise<string | undefined>;
     provideChatSummary?: (history: IChatAgentHistoryEntry[], token: CancellationToken) => Promise<string | undefined>;
@@ -139,11 +138,17 @@ export interface IChatAgentRequest {
      * Collected hooks configuration for this request.
      * Contains all hooks defined in hooks .json files, organized by hook type.
      */
-    hooks?: IChatRequestHooks;
+    hooks?: ChatRequestHooks;
     /**
      * Whether any hooks are enabled for this request.
      */
     hasHooksEnabled?: boolean;
+    /**
+     * The permission level for tool auto-approval in this request.
+     * - `'autoApprove'`: Auto-approve all tool calls and retry on errors.
+     * - `'autopilot'`: Everything autoApprove does plus continues until the task is done.
+     */
+    permissionLevel?: ChatPermissionLevel;
     /**
      * Unique ID for the subagent invocation, used to group tool calls from the same subagent run together.
      */
@@ -166,16 +171,6 @@ export interface IChatAgentResultTimings {
     firstProgress?: number;
     totalElapsed: number;
 }
-export interface IChatAgentPromptTokenDetail {
-    category: string;
-    label: string;
-    percentageOfPrompt: number;
-}
-export interface IChatAgentResultUsage {
-    promptTokens: number;
-    completionTokens: number;
-    promptTokenDetails?: readonly IChatAgentPromptTokenDetail[];
-}
 export interface IChatAgentResult {
     errorDetails?: IChatResponseErrorDetails;
     timings?: IChatAgentResultTimings;
@@ -185,8 +180,6 @@ export interface IChatAgentResult {
     };
     readonly details?: string;
     nextQuestion?: IChatQuestion;
-    /** Token usage information for this request */
-    readonly usage?: IChatAgentResultUsage;
 }
 export interface IChatAgentCompletionItem {
     id: string;
@@ -239,7 +232,7 @@ export declare class ChatAgentService extends Disposable implements IChatAgentSe
     agentHasDupeName(id: string): boolean;
     invokeAgent(id: string, request: IChatAgentRequest, progress: (parts: IChatProgress[]) => void, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatAgentResult>;
     setRequestTools(id: string, requestId: string, tools: UserSelectedTools): void;
-    setYieldRequested(id: string, requestId: string): void;
+    setYieldRequested(id: string, requestId: string, value: boolean): void;
     getFollowups(id: string, request: IChatAgentRequest, result: IChatAgentResult, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatFollowup[]>;
     getChatTitle(id: string, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<string | undefined>;
     getChatSummary(id: string, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<string | undefined>;
@@ -281,28 +274,19 @@ export declare class MergedChatAgent implements IChatAgent {
     }[];
     invoke(request: IChatAgentRequest, progress: (parts: IChatProgress[]) => void, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatAgentResult>;
     setRequestTools(requestId: string, tools: UserSelectedTools): void;
-    setYieldRequested(requestId: string): void;
+    setYieldRequested(requestId: string, value: boolean): void;
     provideFollowups(request: IChatAgentRequest, result: IChatAgentResult, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatFollowup[]>;
     toJSON(): IChatAgentData;
 }
 export declare class ChatAgentNameService implements IChatAgentNameService {
-    private readonly requestService;
-    private readonly logService;
-    private readonly storageService;
-    private static readonly StorageKey;
+    private readonly languageModelsService;
     _serviceBrand: undefined;
-    private readonly url;
-    private registry;
-    private disposed;
-    constructor(productService: IProductService, requestService: IRequestService, logService: ILogService, storageService: IStorageService);
-    private refresh;
-    private update;
+    constructor(languageModelsService: ILanguageModelsService);
     /**
      * Returns true if the agent is allowed to use this name
      */
     getAgentNameRestriction(chatAgentData: IChatAgentData): boolean;
     private checkAgentNameRestriction;
-    dispose(): void;
 }
 export declare function getFullyQualifiedId(chatAgentData: IChatAgentData): string;
 /**

package/vscode/src/vs/workbench/contrib/chat/common/participants/chatAgents.js

@@ -1,29 +1,19 @@
 
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
 import { findLast } from '../../../../../base/common/arraysFind.js';
-import { timeout } from '../../../../../base/common/async.js';
-import { CancellationToken } from '../../../../../base/common/cancellation.js';
 import { Emitter } from '../../../../../base/common/event.js';
 import { Iterable } from '../../../../../base/common/iterator.js';
 import { Disposable, toDisposable } from '../../../../../base/common/lifecycle.js';
 import { revive } from '../../../../../base/common/marshalling.js';
-import '../../../../../base/common/observableInternal/index.js';
 import { equalsIgnoreCase } from '../../../../../base/common/strings.js';
 import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.service.js';
 import { ContextKeyExpr } from '../../../../../platform/contextkey/common/contextkey.js';
 import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.service.js';
 import { ExtensionIdentifier } from '../../../../../platform/extensions/common/extensions.js';
-import { ILogService } from '../../../../../platform/log/common/log.service.js';
-import { IProductService } from '../../../../../platform/product/common/productService.service.js';
-import { asJson } from '../../../../../platform/request/common/request.js';
-import { IRequestService } from '../../../../../platform/request/common/request.service.js';
-import { StorageScope, StorageTarget } from '../../../../../platform/storage/common/storage.js';
-import { IStorageService } from '../../../../../platform/storage/common/storage.service.js';
 import { ChatContextKeys } from '../actions/chatContextKeys.js';
 import { ChatAgentLocation, ChatModeKind, ChatConfiguration } from '../constants.js';
-import { observableValue } from '../../../../../base/common/observableInternal/observables/observableValue.js';
+import { ILanguageModelsService } from '../languageModels.service.js';
 
-var ChatAgentNameService_1;
 let ChatAgentService = class ChatAgentService extends Disposable {
     static {
         this.AGENT_LEADER = "@";
@@ -33,7 +23,7 @@ let ChatAgentService = class ChatAgentService extends Disposable {
         this.contextKeyService = contextKeyService;
         this.configurationService = configurationService;
         this._agents = ( new Map());
-        this._onDidChangeAgents = ( new Emitter());
+        this._onDidChangeAgents = this._register(( new Emitter()));
         this.onDidChangeAgents = this._onDidChangeAgents.event;
         this._agentsContextKeys = ( new Set());
         this._hasToolsAgent = false;
@@ -237,12 +227,12 @@ let ChatAgentService = class ChatAgentService extends Disposable {
         }
         data.impl.setRequestTools?.(requestId, tools);
     }
-    setYieldRequested(id, requestId) {
+    setYieldRequested(id, requestId, value) {
         const data = this._agents.get(id);
         if (!data?.impl) {
             return;
         }
-        data.impl.setYieldRequested?.(requestId);
+        data.impl.setYieldRequested?.(requestId, value);
     }
     async getFollowups(id, request, result, history, token) {
         const data = this._agents.get(id);
@@ -381,8 +371,8 @@ class MergedChatAgent {
     setRequestTools(requestId, tools) {
         this.impl.setRequestTools?.(requestId, tools);
     }
-    setYieldRequested(requestId) {
-        this.impl.setYieldRequested?.(requestId);
+    setYieldRequested(requestId, value) {
+        this.impl.setYieldRequested?.(requestId, value);
     }
     async provideFollowups(request, result, history, token) {
         if (this.impl.provideFollowups) {
@@ -395,58 +385,8 @@ class MergedChatAgent {
     }
 }
 let ChatAgentNameService = class ChatAgentNameService {
-    static {
-        ChatAgentNameService_1 = this;
-    }
-    static {
-        this.StorageKey = "chat.participantNameRegistry";
-    }
-    constructor(productService, requestService, logService, storageService) {
-        this.requestService = requestService;
-        this.logService = logService;
-        this.storageService = storageService;
-        this.registry = observableValue(this, Object.create(null));
-        this.disposed = false;
-        if (!productService.chatParticipantRegistry) {
-            return;
-        }
-        this.url = productService.chatParticipantRegistry;
-        const raw = storageService.get(ChatAgentNameService_1.StorageKey, StorageScope.APPLICATION);
-        try {
-            this.registry.set(JSON.parse(raw ?? "{}"), undefined);
-        } catch (err) {
-            storageService.remove(ChatAgentNameService_1.StorageKey, StorageScope.APPLICATION);
-        }
-        this.refresh();
-    }
-    refresh() {
-        if (this.disposed) {
-            return;
-        }
-        this.update().catch(
-            err => this.logService.warn("Failed to fetch chat participant registry", err)
-        ).then(() => timeout(5 * 60 * 1000)).then(() => this.refresh());
-    }
-    async update() {
-        const context = await this.requestService.request({
-            type: "GET",
-            url: this.url
-        }, CancellationToken.None);
-        if (context.res.statusCode !== 200) {
-            throw ( new Error("Could not get extensions report."));
-        }
-        const result = await asJson(context);
-        if (!result || result.version !== 1) {
-            throw ( new Error("Unexpected chat participant registry response."));
-        }
-        const registry = result.restrictedChatParticipants;
-        this.registry.set(registry, undefined);
-        this.storageService.store(
-            ChatAgentNameService_1.StorageKey,
-            JSON.stringify(registry),
-            StorageScope.APPLICATION,
-            StorageTarget.MACHINE
-        );
+    constructor(languageModelsService) {
+        this.languageModelsService = languageModelsService;
     }
     getAgentNameRestriction(chatAgentData) {
         if (chatAgentData.isCore) {
@@ -457,7 +397,7 @@ let ChatAgentNameService = class ChatAgentNameService {
         return nameAllowed && fullNameAllowed;
     }
     checkAgentNameRestriction(name, chatAgentData) {
-        const allowList = ( this.registry.map(registry => registry[name.toLowerCase()]));
+        const allowList = ( this.languageModelsService.restrictedChatParticipants.map(registry => registry[name.toLowerCase()]));
         return ( allowList.map(allowList => {
             if (!allowList) {
                 return true;
@@ -468,11 +408,8 @@ let ChatAgentNameService = class ChatAgentNameService {
             )));
         }));
     }
-    dispose() {
-        this.disposed = true;
-    }
 };
-ChatAgentNameService = ChatAgentNameService_1 = ( __decorate([( __param(0, IProductService)), ( __param(1, IRequestService)), ( __param(2, ILogService)), ( __param(3, IStorageService))], ChatAgentNameService));
+ChatAgentNameService = ( __decorate([( __param(0, ILanguageModelsService))], ChatAgentNameService));
 function getFullyQualifiedId(chatAgentData) {
     return `${chatAgentData.extensionId.value}.${chatAgentData.id}`;
 }

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

@@ -27,7 +27,7 @@ export interface IChatAgentService {
     hasChatParticipantDetectionProviders(): boolean;
     invokeAgent(agent: string, request: IChatAgentRequest, progress: (parts: IChatProgress[]) => void, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatAgentResult>;
     setRequestTools(agent: string, requestId: string, tools: UserSelectedTools): void;
-    setYieldRequested(agent: string, requestId: string): void;
+    setYieldRequested(agent: string, requestId: string, value: boolean): void;
     getFollowups(id: string, request: IChatAgentRequest, result: IChatAgentResult, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatFollowup[]>;
     getChatTitle(id: string, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<string | undefined>;
     getChatSummary(id: string, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<string | undefined>;

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

@@ -3,7 +3,7 @@ import { Event } from "../../../../../base/common/event.js";
 import { IDisposable } from "../../../../../base/common/lifecycle.js";
 import { URI } from "../../../../../base/common/uri.js";
 import { IProgress } from "../../../../../platform/progress/common/progress.js";
-import { IChatProgress, IChatFollowup } from "../chatService/chatService.js";
+import { IChatProgress, IChatSendRequestOptions, IChatFollowup } from "../chatService/chatService.js";
 import { ChatAgentLocation, ChatModeKind } from "../constants.js";
 import { IChatMessage } from "../languageModels.js";
 import { IChatSlashData, IChatSlashCallback } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/common/participants/chatSlashCommands";
@@ -15,7 +15,7 @@ export interface IChatSlashCommandService {
     _serviceBrand: undefined;
     readonly onDidChangeCommands: Event<void>;
     registerSlashCommand(data: IChatSlashData, command: IChatSlashCallback): IDisposable;
-    executeCommand(id: string, prompt: string, progress: IProgress<IChatProgress>, history: IChatMessage[], location: ChatAgentLocation, sessionResource: URI, token: CancellationToken): Promise<{
+    executeCommand(id: string, prompt: string, progress: IProgress<IChatProgress>, history: IChatMessage[], location: ChatAgentLocation, sessionResource: URI, token: CancellationToken, options?: IChatSendRequestOptions): Promise<{
         followUp: IChatFollowup[];
     } | void>;
     getCommands(location: ChatAgentLocation, mode: ChatModeKind): Array<IChatSlashData>;

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

@@ -0,0 +1,23 @@
+import { MarketplaceType } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/common/plugins/pluginMarketplaceService";
+/**
+ * Options for ensuring a marketplace repository is available locally.
+ */
+export interface IEnsureRepositoryOptions {
+    /** Optional progress notification title shown during clone. */
+    readonly progressTitle?: string;
+    /** Label used in clone failure messaging. */
+    readonly failureLabel?: string;
+    /** Marketplace type metadata to persist in the marketplace index. */
+    readonly marketplaceType?: MarketplaceType;
+}
+/**
+ * Options for pulling the latest changes from a cloned marketplace repository.
+ */
+export interface IPullRepositoryOptions {
+    /** Optional plugin name used in progress messaging. */
+    readonly pluginName?: string;
+    /** Label used in pull failure messaging. */
+    readonly failureLabel?: string;
+    /** Marketplace type metadata for repository index updates. */
+    readonly marketplaceType?: MarketplaceType;
+}