@codingame/monaco-vscode-api 16.1.1 → 17.1.0

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

@@ -0,0 +1,435 @@
+
+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 { 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 './chatContextKeys.js';
+import { ChatMode, ChatAgentLocation } from './constants.js';
+import { observableValue } from '../../../../base/common/observableInternal/base.js';
+
+var ChatAgentNameService_1;
+let ChatAgentService = class ChatAgentService extends Disposable {
+    static { this.AGENT_LEADER = '@'; }
+    constructor(contextKeyService) {
+        super();
+        this.contextKeyService = contextKeyService;
+        this._agents = ( new Map());
+        this._onDidChangeAgents = ( new Emitter());
+        this.onDidChangeAgents = this._onDidChangeAgents.event;
+        this._agentsContextKeys = ( new Set());
+        this._hasToolsAgent = false;
+        this._chatParticipantDetectionProviders = ( new Map());
+        this._agentCompletionProviders = ( new Map());
+        this._hasDefaultAgent = ChatContextKeys.enabled.bindTo(this.contextKeyService);
+        this._extensionAgentRegistered = ChatContextKeys.extensionParticipantRegistered.bindTo(this.contextKeyService);
+        this._defaultAgentRegistered = ChatContextKeys.panelParticipantRegistered.bindTo(this.contextKeyService);
+        this._editingAgentRegistered = ChatContextKeys.editingParticipantRegistered.bindTo(this.contextKeyService);
+        this._register(contextKeyService.onDidChangeContext((e) => {
+            if (e.affectsSome(this._agentsContextKeys)) {
+                this._updateContextKeys();
+            }
+        }));
+    }
+    registerAgent(id, data) {
+        const existingAgent = this.getAgent(id);
+        if (existingAgent) {
+            throw ( new Error(`Agent already registered: ${JSON.stringify(id)}`));
+        }
+        const that = this;
+        const commands = data.slashCommands;
+        data = {
+            ...data,
+            get slashCommands() {
+                return commands.filter(c => !c.when || that.contextKeyService.contextMatchesRules(ContextKeyExpr.deserialize(c.when)));
+            }
+        };
+        const entry = { data };
+        this._agents.set(id, entry);
+        this._updateAgentsContextKeys();
+        this._updateContextKeys();
+        this._onDidChangeAgents.fire(undefined);
+        return toDisposable(() => {
+            this._agents.delete(id);
+            this._updateAgentsContextKeys();
+            this._updateContextKeys();
+            this._onDidChangeAgents.fire(undefined);
+        });
+    }
+    _updateAgentsContextKeys() {
+        this._agentsContextKeys.clear();
+        for (const agent of ( this._agents.values())) {
+            if (agent.data.when) {
+                const expr = ContextKeyExpr.deserialize(agent.data.when);
+                for (const key of expr?.keys() || []) {
+                    this._agentsContextKeys.add(key);
+                }
+            }
+        }
+    }
+    _updateContextKeys() {
+        let editingAgentRegistered = false;
+        let extensionAgentRegistered = false;
+        let defaultAgentRegistered = false;
+        let toolsAgentRegistered = false;
+        for (const agent of this.getAgents()) {
+            if (agent.isDefault) {
+                if (!agent.isCore) {
+                    extensionAgentRegistered = true;
+                }
+                if (agent.modes.includes(ChatMode.Agent)) {
+                    toolsAgentRegistered = true;
+                }
+                else if (agent.modes.includes(ChatMode.Edit)) {
+                    editingAgentRegistered = true;
+                }
+                else {
+                    defaultAgentRegistered = true;
+                }
+            }
+        }
+        this._editingAgentRegistered.set(editingAgentRegistered);
+        this._defaultAgentRegistered.set(defaultAgentRegistered);
+        this._extensionAgentRegistered.set(extensionAgentRegistered);
+        if (toolsAgentRegistered !== this._hasToolsAgent) {
+            this._hasToolsAgent = toolsAgentRegistered;
+            this._onDidChangeAgents.fire(this.getDefaultAgent(ChatAgentLocation.Panel, ChatMode.Agent));
+        }
+    }
+    registerAgentImplementation(id, agentImpl) {
+        const entry = this._agents.get(id);
+        if (!entry) {
+            throw ( new Error(`Unknown agent: ${JSON.stringify(id)}`));
+        }
+        if (entry.impl) {
+            throw ( new Error(`Agent already has implementation: ${JSON.stringify(id)}`));
+        }
+        if (entry.data.isDefault) {
+            this._hasDefaultAgent.set(true);
+        }
+        entry.impl = agentImpl;
+        this._onDidChangeAgents.fire(( new MergedChatAgent(entry.data, agentImpl)));
+        return toDisposable(() => {
+            entry.impl = undefined;
+            this._onDidChangeAgents.fire(undefined);
+            if (entry.data.isDefault) {
+                this._hasDefaultAgent.set(false);
+            }
+        });
+    }
+    registerDynamicAgent(data, agentImpl) {
+        data.isDynamic = true;
+        const agent = { data, impl: agentImpl };
+        this._agents.set(data.id, agent);
+        this._onDidChangeAgents.fire(( new MergedChatAgent(data, agentImpl)));
+        return toDisposable(() => {
+            this._agents.delete(data.id);
+            this._onDidChangeAgents.fire(undefined);
+        });
+    }
+    registerAgentCompletionProvider(id, provider) {
+        this._agentCompletionProviders.set(id, provider);
+        return {
+            dispose: () => { this._agentCompletionProviders.delete(id); }
+        };
+    }
+    async getAgentCompletionItems(id, query, token) {
+        return (await this._agentCompletionProviders.get(id)?.(query, token)) ?? [];
+    }
+    updateAgent(id, updateMetadata) {
+        const agent = this._agents.get(id);
+        if (!agent?.impl) {
+            throw ( new Error(`No activated agent with id ${JSON.stringify(id)} registered`));
+        }
+        agent.data.metadata = { ...agent.data.metadata, ...updateMetadata };
+        this._onDidChangeAgents.fire(( new MergedChatAgent(agent.data, agent.impl)));
+    }
+    getDefaultAgent(location, mode = ChatMode.Ask) {
+        return this._preferExtensionAgent(this.getActivatedAgents().filter(a => {
+            if (mode && !a.modes.includes(mode)) {
+                return false;
+            }
+            return !!a.isDefault && a.locations.includes(location);
+        }));
+    }
+    get hasToolsAgent() {
+        return !!this._hasToolsAgent;
+    }
+    getContributedDefaultAgent(location) {
+        return this._preferExtensionAgent(this.getAgents().filter(a => !!a.isDefault && a.locations.includes(location)));
+    }
+    _preferExtensionAgent(agents) {
+        return findLast(agents, agent => !agent.isCore) ?? agents.at(-1);
+    }
+    getAgent(id, includeDisabled = false) {
+        if (!this._agentIsEnabled(id) && !includeDisabled) {
+            return;
+        }
+        return this._agents.get(id)?.data;
+    }
+    _agentIsEnabled(idOrAgent) {
+        const entry = typeof idOrAgent === 'string' ? this._agents.get(idOrAgent) : idOrAgent;
+        return !entry?.data.when || this.contextKeyService.contextMatchesRules(ContextKeyExpr.deserialize(entry.data.when));
+    }
+    getAgentByFullyQualifiedId(id) {
+        const agent = Iterable.find(( this._agents.values()), a => getFullyQualifiedId(a.data) === id)?.data;
+        if (agent && !this._agentIsEnabled(agent.id)) {
+            return;
+        }
+        return agent;
+    }
+    getAgents() {
+        return ( Array.from(( this._agents.values()))
+            .map(entry => entry.data))
+            .filter(a => this._agentIsEnabled(a.id));
+    }
+    getActivatedAgents() {
+        return ( Array.from(( this._agents.values()))
+            .filter(a => !!a.impl)
+            .filter(a => this._agentIsEnabled(a.data.id))
+            .map(a => ( new MergedChatAgent(a.data, a.impl))));
+    }
+    getAgentsByName(name) {
+        return this._preferExtensionAgents(this.getAgents().filter(a => a.name === name));
+    }
+    _preferExtensionAgents(agents) {
+        const extensionAgents = agents.filter(a => !a.isCore);
+        return extensionAgents.length > 0 ? extensionAgents : agents;
+    }
+    agentHasDupeName(id) {
+        const agent = this.getAgent(id);
+        if (!agent) {
+            return false;
+        }
+        return this.getAgentsByName(agent.name)
+            .filter(a => a.extensionId.value !== agent.extensionId.value).length > 0;
+    }
+    async invokeAgent(id, request, progress, history, token) {
+        const data = this._agents.get(id);
+        if (!data?.impl) {
+            throw ( new Error(`No activated agent with id "${id}"`));
+        }
+        return await data.impl.invoke(request, progress, history, token);
+    }
+    setRequestPaused(id, requestId, isPaused) {
+        const data = this._agents.get(id);
+        if (!data?.impl) {
+            throw ( new Error(`No activated agent with id "${id}"`));
+        }
+        data.impl.setRequestPaused?.(requestId, isPaused);
+    }
+    async getFollowups(id, request, result, history, token) {
+        const data = this._agents.get(id);
+        if (!data?.impl?.provideFollowups) {
+            return [];
+        }
+        return data.impl.provideFollowups(request, result, history, token);
+    }
+    async getChatTitle(id, history, token) {
+        const data = this._agents.get(id);
+        if (!data?.impl) {
+            throw ( new Error(`No activated agent with id "${id}"`));
+        }
+        if (!data.impl?.provideChatTitle) {
+            return undefined;
+        }
+        return data.impl.provideChatTitle(history, token);
+    }
+    registerChatParticipantDetectionProvider(handle, provider) {
+        this._chatParticipantDetectionProviders.set(handle, provider);
+        return toDisposable(() => {
+            this._chatParticipantDetectionProviders.delete(handle);
+        });
+    }
+    hasChatParticipantDetectionProviders() {
+        return this._chatParticipantDetectionProviders.size > 0;
+    }
+    async detectAgentOrCommand(request, history, options, token) {
+        const provider = Iterable.first(( this._chatParticipantDetectionProviders.values()));
+        if (!provider) {
+            return;
+        }
+        const participants = this.getAgents().reduce((acc, a) => {
+            if (a.locations.includes(options.location)) {
+                acc.push({ participant: a.id, disambiguation: a.disambiguation ?? [] });
+                for (const command of a.slashCommands) {
+                    acc.push({ participant: a.id, command: command.name, disambiguation: command.disambiguation ?? [] });
+                }
+            }
+            return acc;
+        }, []);
+        const result = await provider.provideParticipantDetection(request, history, { ...options, participants }, token);
+        if (!result) {
+            return;
+        }
+        const agent = this.getAgent(result.participant);
+        if (!agent) {
+            return;
+        }
+        if (!result.command) {
+            return { agent };
+        }
+        const command = agent?.slashCommands.find(c => c.name === result.command);
+        if (!command) {
+            return;
+        }
+        return { agent, command };
+    }
+};
+ChatAgentService = ( __decorate([
+    ( __param(0, IContextKeyService))
+], ChatAgentService));
+class MergedChatAgent {
+    constructor(data, impl) {
+        this.data = data;
+        this.impl = impl;
+    }
+    get id() { return this.data.id; }
+    get name() { return this.data.name ?? ''; }
+    get fullName() { return this.data.fullName ?? ''; }
+    get description() { return this.data.description ?? ''; }
+    get extensionId() { return this.data.extensionId; }
+    get extensionPublisherId() { return this.data.extensionPublisherId; }
+    get extensionPublisherDisplayName() { return this.data.publisherDisplayName; }
+    get extensionDisplayName() { return this.data.extensionDisplayName; }
+    get isDefault() { return this.data.isDefault; }
+    get isCore() { return this.data.isCore; }
+    get metadata() { return this.data.metadata; }
+    get slashCommands() { return this.data.slashCommands; }
+    get locations() { return this.data.locations; }
+    get modes() { return this.data.modes; }
+    get disambiguation() { return this.data.disambiguation; }
+    async invoke(request, progress, history, token) {
+        return this.impl.invoke(request, progress, history, token);
+    }
+    setRequestPaused(requestId, isPaused) {
+        if (this.impl.setRequestPaused) {
+            this.impl.setRequestPaused(requestId, isPaused);
+        }
+    }
+    async provideFollowups(request, result, history, token) {
+        if (this.impl.provideFollowups) {
+            return this.impl.provideFollowups(request, result, history, token);
+        }
+        return [];
+    }
+    provideSampleQuestions(location, token) {
+        if (this.impl.provideSampleQuestions) {
+            return this.impl.provideSampleQuestions(location, token);
+        }
+        return undefined;
+    }
+    toJSON() {
+        return this.data;
+    }
+}
+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);
+    }
+    getAgentNameRestriction(chatAgentData) {
+        if (chatAgentData.isCore) {
+            return true;
+        }
+        const nameAllowed = this.checkAgentNameRestriction(chatAgentData.name, chatAgentData).get();
+        const fullNameAllowed = !chatAgentData.fullName || this.checkAgentNameRestriction(chatAgentData.fullName.replace(/\s/g, ''), chatAgentData).get();
+        return nameAllowed && fullNameAllowed;
+    }
+    checkAgentNameRestriction(name, chatAgentData) {
+        const allowList = ( this.registry.map(registry => registry[name.toLowerCase()]));
+        return ( allowList.map(allowList => {
+            if (!allowList) {
+                return true;
+            }
+            return ( allowList.some(
+                id => equalsIgnoreCase(id, id.includes('.') ? chatAgentData.extensionId.value : chatAgentData.extensionPublisherId)
+            ));
+        }));
+    }
+    dispose() {
+        this.disposed = true;
+    }
+};
+ChatAgentNameService = ChatAgentNameService_1 = ( __decorate([
+    ( __param(0, IProductService)),
+    ( __param(1, IRequestService)),
+    ( __param(2, ILogService)),
+    ( __param(3, IStorageService))
+], ChatAgentNameService));
+function getFullyQualifiedId(chatAgentData) {
+    return `${chatAgentData.extensionId.value}.${chatAgentData.id}`;
+}
+function reviveSerializedAgent(raw) {
+    const agent = 'name' in raw ?
+        raw :
+        {
+            ...raw,
+            name: raw.id,
+        };
+    if (!('extensionPublisherId' in agent)) {
+        agent.extensionPublisherId = agent.extensionPublisher ?? '';
+    }
+    if (!('extensionDisplayName' in agent)) {
+        agent.extensionDisplayName = '';
+    }
+    if (!('extensionId' in agent)) {
+        agent.extensionId = ( new ExtensionIdentifier(''));
+    }
+    return revive(agent);
+}
+
+export { ChatAgentNameService, ChatAgentService, MergedChatAgent, getFullyQualifiedId, reviveSerializedAgent };

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

@@ -1,7 +1,7 @@
 import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { Event } from "../../../../base/common/event.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
-import { IChatAgent, IChatAgentCommand, IChatAgentCompletionItem, IChatAgentData, IChatAgentHistoryEntry, IChatAgentImplementation, IChatAgentMetadata, IChatAgentRequest, IChatAgentResult, IChatParticipantDetectionProvider } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatAgents";
+import { IChatAgent, IChatAgentCommand, IChatAgentCompletionItem, IChatAgentData, IChatAgentHistoryEntry, IChatAgentImplementation, IChatAgentMetadata, IChatAgentRequest, IChatAgentResult, IChatParticipantDetectionProvider } from "./chatAgents.js";
 import { IChatFollowup, IChatProgress } from "./chatService.js";
 import { ChatAgentLocation, ChatMode } from "./constants.js";
 export declare const IChatAgentService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatAgentService>;

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

@@ -18,11 +18,11 @@ export declare namespace ChatContextKeys {
     const inputHasFocus: RawContextKey<boolean>;
     const inChatInput: RawContextKey<boolean>;
     const inChatSession: RawContextKey<boolean>;
-    const inUnifiedChat: RawContextKey<boolean>;
-    const instructionsAttached: RawContextKey<boolean>;
+    const hasPromptFile: RawContextKey<boolean>;
     const chatMode: RawContextKey<ChatMode>;
     const supported: import("../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression | undefined;
     const enabled: RawContextKey<boolean>;
+    const extensionParticipantRegistered: RawContextKey<boolean>;
     const panelParticipantRegistered: RawContextKey<boolean>;
     const editingParticipantRegistered: RawContextKey<boolean>;
     const chatEditingCanUndo: RawContextKey<boolean>;
@@ -37,20 +37,20 @@ export declare namespace ChatContextKeys {
     const Setup: {
         hidden: RawContextKey<boolean>;
         installed: RawContextKey<boolean>;
-        fromDialog: import("../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression;
+        disabled: RawContextKey<boolean>;
     };
     const Entitlement: {
         signedOut: RawContextKey<boolean>;
         canSignUp: RawContextKey<boolean>;
         limited: RawContextKey<boolean>;
         pro: RawContextKey<boolean>;
+        proPlus: RawContextKey<boolean>;
+        business: RawContextKey<boolean>;
+        enterprise: RawContextKey<boolean>;
     };
-    const SetupViewKeys: Set<string>;
-    const SetupViewCondition: import("../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression;
     const chatQuotaExceeded: RawContextKey<boolean>;
     const completionsQuotaExceeded: RawContextKey<boolean>;
     const Editing: {
-        hasToolsAgent: RawContextKey<boolean>;
         agentModeDisallowed: RawContextKey<boolean>;
         hasToolConfirmation: RawContextKey<boolean>;
     };
@@ -59,8 +59,5 @@ export declare namespace ChatContextKeys {
     };
 }
 export declare namespace ChatContextKeyExprs {
-    const unifiedChatEnabled: import("../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression;
-    const inEditsOrUnified: import("../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression | undefined;
-    const inNonUnifiedPanel: import("../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression | undefined;
     const inEditingMode: import("../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression | undefined;
 }