@codingame/monaco-vscode-chat-service-override 34.1.2 → 35.0.0

package/vscode/src/vs/workbench/contrib/agentsVoice/browser/agentsVoice.contribution.js

@@ -0,0 +1,399 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import '../../chat/browser/voiceClient/micCaptureService.js';
+import '../../chat/browser/voiceClient/ttsPlaybackService.js';
+import '../../chat/browser/voiceClient/voiceClientService.js';
+import { IVoiceSessionController } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/voiceClient/voiceSessionController.service';
+import '../../chat/browser/voiceClient/voiceToolDispatchService.js';
+import '../../chat/common/voicePlaybackService.js';
+import '../common/voiceTranscriptStore.js';
+import './transcriptsView/voiceTranscripts.contribution.js';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { KeyMod, KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { registerAction2, Action2, MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { Extensions, ConfigurationScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
+import { RawContextKey, ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { KeybindingWeight } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { AgentsVoiceStorageKeys } from '../common/agentsVoice.js';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+var AgentsVoiceTelemetryContribution_1;
+const AGENTS_VOICE_WIDGET_FOCUSED = ( new RawContextKey("agentsVoiceWidgetFocused", false));
+const AGENTS_VOICE_CONNECTED = ( new RawContextKey("agentsVoiceConnected", false));
+const AGENTS_VOICE_CONNECTING = ( new RawContextKey("agentsVoiceConnecting", false));
+const AGENTS_VOICE_LISTENING = ( new RawContextKey("agentsVoiceListening", false));
+const AGENTS_VOICE_ACTIVE = ( new RawContextKey("agentsVoiceActive", false));
+const AGENTS_VOICE_INITIATED_HERE = ( new RawContextKey("agentsVoiceInitiatedHere", false));
+let AgentsVoiceConnectedKeyContribution = class AgentsVoiceConnectedKeyContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.agentsVoiceConnectedKey";
+    }
+    constructor(voiceSessionController, contextKeyService, chatWidgetService) {
+        super();
+        const connectedKey = AGENTS_VOICE_CONNECTED.bindTo(contextKeyService);
+        const connectingKey = AGENTS_VOICE_CONNECTING.bindTo(contextKeyService);
+        const listeningKey = AGENTS_VOICE_LISTENING.bindTo(contextKeyService);
+        const activeKey = AGENTS_VOICE_ACTIVE.bindTo(contextKeyService);
+        let wasConnected = false;
+        this._register(autorun(reader => {
+            const connected = voiceSessionController.isConnected.read(reader);
+            connectedKey.set(connected);
+            connectingKey.set(voiceSessionController.isConnecting.read(reader));
+            const state = voiceSessionController.voiceState.read(reader);
+            listeningKey.set(state === "listening");
+            activeKey.set(state === "listening" || state === "speaking");
+            if (wasConnected && !connected) {
+                for (const widget of chatWidgetService.getAllWidgets()) {
+                    AGENTS_VOICE_INITIATED_HERE.bindTo(widget.scopedContextKeyService).set(false);
+                }
+            }
+            wasConnected = connected;
+        }));
+    }
+};
+AgentsVoiceConnectedKeyContribution = ( __decorate([( __param(0, IVoiceSessionController)), ( __param(1, IContextKeyService)), ( __param(2, IChatWidgetService))], AgentsVoiceConnectedKeyContribution));
+registerWorkbenchContribution2(
+    AgentsVoiceConnectedKeyContribution.ID,
+    AgentsVoiceConnectedKeyContribution,
+    WorkbenchPhase.Eventually
+);
+let AgentsVoiceTelemetryContribution = class AgentsVoiceTelemetryContribution extends Disposable {
+    static {
+        AgentsVoiceTelemetryContribution_1 = this;
+    }
+    static {
+        this.ID = "workbench.contrib.agentsVoiceTelemetry";
+    }
+    static {
+        this._ENABLED_AT_KEY = "agents.voice.enabledAtMs";
+    }
+    constructor(configurationService, telemetryService, storageService) {
+        super();
+        this._register(configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration("agents.voice.enabled")) {
+                const enabled = configurationService.getValue("agents.voice.enabled");
+                if (enabled) {
+                    storageService.store(
+                        AgentsVoiceTelemetryContribution_1._ENABLED_AT_KEY,
+                        Date.now(),
+                        StorageScope.PROFILE,
+                        StorageTarget.MACHINE
+                    );
+                    telemetryService.publicLog2("voiceEnabled", {
+                        source: "setting"
+                    });
+                } else {
+                    const enabledAt = storageService.getNumber(
+                        AgentsVoiceTelemetryContribution_1._ENABLED_AT_KEY,
+                        StorageScope.PROFILE,
+                        0
+                    );
+                    const daysActive = enabledAt ? Math.round((Date.now() - enabledAt) / (1000 * 60 * 60 * 24)) : 0;
+                    telemetryService.publicLog2("voiceDisabled", {
+                        daysActive
+                    });
+                    storageService.remove(AgentsVoiceTelemetryContribution_1._ENABLED_AT_KEY, StorageScope.PROFILE);
+                }
+            }
+        }));
+    }
+};
+AgentsVoiceTelemetryContribution = AgentsVoiceTelemetryContribution_1 = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, ITelemetryService)), ( __param(2, IStorageService))], AgentsVoiceTelemetryContribution));
+registerWorkbenchContribution2(
+    AgentsVoiceTelemetryContribution.ID,
+    AgentsVoiceTelemetryContribution,
+    WorkbenchPhase.AfterRestored
+);
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: "agentsVoice.connecting",
+            title: ( localize2(4767, "Connecting...")),
+            icon: Codicon.loading,
+            precondition: ( ContextKeyExpr.and(( ContextKeyExpr.equals("config.agents.voice.enabled", true)), ( AGENTS_VOICE_CONNECTING.isEqualTo(true)))),
+            menu: {
+                id: MenuId.ChatExecute,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals("config.agents.voice.enabled", true)), ( ChatContextKeys.location.isEqualTo(ChatAgentLocation.Chat)), ( AGENTS_VOICE_CONNECTING.isEqualTo(true)), ( AGENTS_VOICE_INITIATED_HERE.isEqualTo(true)))),
+                group: "navigation",
+                order: -10
+            }
+        });
+    }
+    async run() {}
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: "agentsVoice.startVoiceInChat",
+            title: ( localize2(4768, "Voice Mode")),
+            icon: Codicon.voiceMode,
+            precondition: ( ContextKeyExpr.equals("config.agents.voice.enabled", true)),
+            menu: {
+                id: MenuId.ChatExecute,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals("config.agents.voice.enabled", true)), ( ChatContextKeys.location.isEqualTo(ChatAgentLocation.Chat)), ( ChatContextKeys.currentlyEditing.negate()), ( AGENTS_VOICE_ACTIVE.negate()), ( AGENTS_VOICE_CONNECTING.negate()))),
+                group: "navigation",
+                order: -10
+            },
+            keybinding: {
+                weight: KeybindingWeight.WorkbenchContrib,
+                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.Space,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals("config.agents.voice.enabled", true)), ChatContextKeys.inChatInput))
+            }
+        });
+    }
+    async run(accessor) {
+        const voiceController = accessor.get(IVoiceSessionController);
+        if (!voiceController.isConnected.get()) {
+            const chatWidgetService = accessor.get(IChatWidgetService);
+            const widget = chatWidgetService.lastFocusedWidget;
+            if (widget) {
+                AGENTS_VOICE_INITIATED_HERE.bindTo(widget.scopedContextKeyService).set(true);
+            }
+            await voiceController.connect(mainWindow);
+        } else {
+            voiceController.pttDown();
+            voiceController.pttUp();
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: "agentsVoice.pttStopInChat",
+            title: ( localize2(4769, "Voice Mode: Stop Recording")),
+            icon: Codicon.voiceMode,
+            precondition: ( ContextKeyExpr.and(( ContextKeyExpr.equals("config.agents.voice.enabled", true)), ( AGENTS_VOICE_ACTIVE.isEqualTo(true)))),
+            menu: {
+                id: MenuId.ChatExecute,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals("config.agents.voice.enabled", true)), ( ChatContextKeys.location.isEqualTo(ChatAgentLocation.Chat)), ( ChatContextKeys.currentlyEditing.negate()), ( AGENTS_VOICE_ACTIVE.isEqualTo(true)), ( AGENTS_VOICE_INITIATED_HERE.isEqualTo(true)))),
+                group: "navigation",
+                order: -10
+            },
+            keybinding: {
+                weight: KeybindingWeight.WorkbenchContrib,
+                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.Space,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals("config.agents.voice.enabled", true)), ChatContextKeys.inChatInput, ( AGENTS_VOICE_ACTIVE.isEqualTo(true))))
+            }
+        });
+    }
+    async run(accessor) {
+        const voiceController = accessor.get(IVoiceSessionController);
+        const configService = accessor.get(IConfigurationService);
+        const autoSendDelay = configService.getValue("agents.voice.autoSendDelay") ?? 500;
+        if (autoSendDelay >= 0) {
+            voiceController.disconnect();
+        } else {
+            voiceController.pttDown();
+            voiceController.pttUp();
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: "agentsVoice.disconnect",
+            title: ( localize2(4770, "Disconnect Voice Mode")),
+            icon: Codicon.debugDisconnect,
+            f1: true,
+            precondition: ( ContextKeyExpr.and(( ContextKeyExpr.equals("config.agents.voice.enabled", true)), ( AGENTS_VOICE_CONNECTED.isEqualTo(true))))
+        });
+    }
+    async run(accessor) {
+        const voiceController = accessor.get(IVoiceSessionController);
+        voiceController.disconnect();
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: "agentsVoice.simulateConnection",
+            title: ( localize2(4771, "Voice: Simulate Connection (Dev)")),
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const voiceController = accessor.get(IVoiceSessionController);
+        voiceController.simulateConnection();
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: "agentsVoice.resetOnboarding",
+            title: ( localize2(4772, "Voice: Reset Onboarding")),
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const storageService = accessor.get(IStorageService);
+        storageService.remove(AgentsVoiceStorageKeys.OnboardingCompleted, StorageScope.PROFILE);
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: "agentsVoice.pushToTalk",
+            title: ( localize2(4773, "Voice Mode: Push to Talk")),
+            f1: true,
+            precondition: ( ContextKeyExpr.equals("config.agents.voice.enabled", true)),
+            keybinding: {
+                weight: KeybindingWeight.WorkbenchContrib,
+                primary: KeyMod.CtrlCmd | KeyMod.Shift | KeyCode.Space,
+                when: ( ContextKeyExpr.and(AGENTS_VOICE_WIDGET_FOCUSED, ContextKeyExpr.not("inputFocus")))
+            }
+        });
+    }
+    async run(accessor) {
+        const voiceController = accessor.get(IVoiceSessionController);
+        if (!voiceController.isConnected.get() && !voiceController.isConnecting.get()) {
+            await voiceController.connect(mainWindow);
+        }
+        if (!voiceController.isConnected.get()) {
+            return;
+        }
+        voiceController.pttDown();
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: "agentsVoice.selectMicrophone",
+            title: ( localize2(4774, "Voice: Select Microphone")),
+            f1: true,
+            precondition: ( ContextKeyExpr.equals("config.agents.voice.enabled", true))
+        });
+    }
+    async run(accessor) {
+        const quickInputService = accessor.get(IQuickInputService);
+        const storageService = accessor.get(IStorageService);
+        const devices = await navigator.mediaDevices.enumerateDevices();
+        const audioInputs = devices.filter(d => d.kind === "audioinput" && d.deviceId !== "default");
+        if (audioInputs.length === 0) {
+            quickInputService.pick([{
+                label: ( localize(4775, "No microphones found"))
+            }]);
+            return;
+        }
+        const currentDeviceId = storageService.get(AgentsVoiceStorageKeys.MicrophoneDevice, StorageScope.APPLICATION, "");
+        const items = [];
+        items.push({
+            label: ( localize(4776, "System Default")),
+            description: currentDeviceId === "" ? ( localize(4777, "(current)")) : undefined,
+            deviceId: ""
+        });
+        for (const d of audioInputs) {
+            const label = d.label || ( localize(4778, "Unknown Device ({0})", d.deviceId.slice(0, 8)));
+            items.push({
+                label,
+                description: d.deviceId === currentDeviceId ? ( localize(4777, "(current)")) : undefined,
+                deviceId: d.deviceId
+            });
+        }
+        const picked = await quickInputService.pick(items, {
+            placeHolder: ( localize(4779, "Select a microphone for Voice Mode"))
+        });
+        if (picked) {
+            const selection = picked;
+            if (selection.deviceId) {
+                storageService.store(
+                    AgentsVoiceStorageKeys.MicrophoneDevice,
+                    selection.deviceId,
+                    StorageScope.APPLICATION,
+                    StorageTarget.MACHINE
+                );
+            } else {
+                storageService.remove(AgentsVoiceStorageKeys.MicrophoneDevice, StorageScope.APPLICATION);
+            }
+        }
+    }
+});
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
+configurationRegistry.registerConfiguration({
+    id: "agentsVoice",
+    title: ( localize(4780, "Voice Mode")),
+    type: "object",
+    properties: {
+        "agents.voice.enabled": {
+            type: "boolean",
+            description: ( localize(
+                4781,
+                "Enable the Voice Mode panel in the chat view for voice-driven coding conversations."
+            )),
+            default: false,
+            scope: ConfigurationScope.APPLICATION,
+            restricted: true,
+            included: false
+        },
+        "agents.voice.backendUrl": {
+            type: "string",
+            description: ( localize(
+                4782,
+                "Voice backend WebSocket URL. Leave empty to use the default hosted backend. Set to e.g. `ws://localhost:8000/api/v1/realtime/voice` to point at a backend running on your machine."
+            )),
+            default: "",
+            scope: ConfigurationScope.APPLICATION,
+            included: false
+        },
+        "agents.voice.textToSpeech": {
+            type: "boolean",
+            description: ( localize(
+                4783,
+                "When enabled, the assistant reads responses aloud. When disabled, responses appear as text transcripts only."
+            )),
+            default: true,
+            scope: ConfigurationScope.APPLICATION,
+            included: false
+        },
+        "agents.voice.showTranscript": {
+            type: "boolean",
+            description: ( localize(
+                4784,
+                "Show the voice transcript overlay in the chat input area while voice mode is active."
+            )),
+            default: false,
+            scope: ConfigurationScope.APPLICATION,
+            included: false,
+            tags: ["advanced"]
+        },
+        "agents.voice.autoSendDelay": {
+            type: "number",
+            description: ( localize(
+                4785,
+                "In toggle voice mode (short tap), automatically finish recording after this many milliseconds of silence. Set to -1 to disable."
+            )),
+            default: 500,
+            minimum: -1,
+            scope: ConfigurationScope.APPLICATION,
+            included: false,
+            tags: ["advanced"]
+        },
+        "agents.voice.sendKeyword": {
+            type: "string",
+            description: ( localize(
+                4786,
+                "A keyword phrase (e.g. \"send it\") that, when spoken at the end of an utterance in toggle mode, triggers sending the request immediately. The keyword is stripped from the sent message. Leave empty to disable."
+            )),
+            default: "",
+            scope: ConfigurationScope.APPLICATION,
+            included: false,
+            tags: ["advanced"]
+        }
+    }
+});
+
+export { AGENTS_VOICE_WIDGET_FOCUSED };

package/vscode/src/vs/workbench/contrib/agentsVoice/browser/agentsVoiceSessionsPicker.d.ts

@@ -0,0 +1,20 @@
+import { IQuickInputService } from "@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service";
+import { IAgentSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+/**
+ * A quickpick that lists agent sessions and allows the user to select one
+ * as the voice transcription target. Mirrors the pattern of AgentSessionsPicker
+ * but with a voice-specific action.
+ */
+export declare class AgentsVoiceSessionsPicker {
+    private readonly onSelectTarget;
+    private readonly agentSessionsService;
+    private readonly quickInputService;
+    private readonly instantiationService;
+    private readonly sorter;
+    constructor(onSelectTarget: (resource: URI) => void, agentSessionsService: IAgentSessionsService, quickInputService: IQuickInputService, instantiationService: IInstantiationService);
+    show(): Promise<void>;
+    private createPickerItems;
+    private toPickItem;
+}

package/vscode/src/vs/workbench/contrib/agentsVoice/browser/agentsVoiceSessionsPicker.js

@@ -0,0 +1,85 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
+import { AgentSessionsSorter, groupAgentSessionsByDate } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsViewer';
+import { shouldShowSessionInPicker, getSessionDescription } from '../../chat/browser/agentSessions/agentSessionsPicker.js';
+import { AgentSessionsFilter } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsFilter';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+
+const setTargetButton = {
+    iconClass: ThemeIcon.asClassName(Codicon.voiceMode),
+    tooltip: ( localize(4787, "Set as voice target"))
+};
+let AgentsVoiceSessionsPicker = class AgentsVoiceSessionsPicker {
+    constructor(
+        onSelectTarget,
+        agentSessionsService,
+        quickInputService,
+        instantiationService
+    ) {
+        this.onSelectTarget = onSelectTarget;
+        this.agentSessionsService = agentSessionsService;
+        this.quickInputService = quickInputService;
+        this.instantiationService = instantiationService;
+        this.sorter = ( new AgentSessionsSorter());
+    }
+    async show() {
+        const disposables = ( new DisposableStore());
+        const picker = disposables.add(this.quickInputService.createQuickPick({
+            useSeparators: true
+        }));
+        const filter = disposables.add(this.instantiationService.createInstance(AgentSessionsFilter, {}));
+        picker.items = this.createPickerItems(filter);
+        picker.placeholder = ( localize(4788, "Select a session for voice input"));
+        disposables.add(picker.onDidAccept(() => {
+            const pick = picker.selectedItems[0];
+            if (pick) {
+                this.onSelectTarget(pick.session.resource);
+            }
+            picker.hide();
+        }));
+        disposables.add(picker.onDidTriggerItemButton(e => {
+            if (e.button === setTargetButton) {
+                this.onSelectTarget(e.item.session.resource);
+                picker.hide();
+            }
+        }));
+        disposables.add(picker.onDidHide(() => disposables.dispose()));
+        picker.show();
+    }
+    createPickerItems(filter) {
+        const sessions = this.agentSessionsService.model.sessions.filter(session => shouldShowSessionInPicker(session, filter)).sort(this.sorter.compare.bind(this.sorter));
+        const items = [];
+        const groupedSessions = groupAgentSessionsByDate(sessions);
+        for (const group of ( groupedSessions.values())) {
+            if (group.sessions.length > 0) {
+                items.push({
+                    type: "separator",
+                    label: group.label
+                });
+                items.push(...( group.sessions.map(session => this.toPickItem(session))));
+            }
+        }
+        return items;
+    }
+    toPickItem(session) {
+        const description = getSessionDescription(session);
+        return {
+            id: ( session.resource.toString()),
+            label: session.label,
+            tooltip: session.tooltip,
+            description,
+            iconClass: ThemeIcon.asClassName(session.icon),
+            buttons: [setTargetButton],
+            session
+        };
+    }
+};
+AgentsVoiceSessionsPicker = ( __decorate([( __param(1, IAgentSessionsService)), ( __param(2, IQuickInputService)), ( __param(3, IInstantiationService))], AgentsVoiceSessionsPicker));
+
+export { AgentsVoiceSessionsPicker };