@codingame/monaco-vscode-chat-service-override 34.1.3 → 35.0.1

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

@@ -0,0 +1,24 @@
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IAgentSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service";
+import { IAgentTitleBarStatusService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/experiments/agentTitleBarStatusService.service";
+import { IVoicePlaybackService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/voicePlaybackService.service";
+import { IVoiceSessionController } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/voiceClient/voiceSessionController.service";
+import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { AgentsVoiceWidget } from "./agentsVoiceWidget.js";
+export interface IWidgetBindingServices {
+    readonly voiceSessionController: IVoiceSessionController;
+    readonly agentSessionsService: IAgentSessionsService;
+    readonly agentTitleBarStatusService: IAgentTitleBarStatusService;
+    readonly voicePlaybackService: IVoicePlaybackService;
+    readonly environmentService: IWorkbenchEnvironmentService;
+    readonly chatService?: IChatService;
+    readonly configurationService?: IConfigurationService;
+}
+/**
+ * Wire all controller observables and session/playback service events into the
+ * widget. Used by both the floating agentsVoice window and the in-pane voice
+ * bar so they stay in lock-step.
+ */
+export declare function bindWidgetToController(widget: AgentsVoiceWidget, services: IWidgetBindingServices): IDisposable;

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

@@ -0,0 +1,204 @@
+
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { getAgentChangesSummary } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsModel';
+import { getRepositoryName } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsViewer';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { ChatSessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+
+function bindWidgetToController(widget, services) {
+    const store = ( new DisposableStore());
+    const {
+        voiceSessionController: controller,
+        agentSessionsService,
+        agentTitleBarStatusService,
+        voicePlaybackService,
+        configurationService
+    } = services;
+    store.add(autorun(reader => {
+        const state = controller.voiceState.read(reader);
+        const connected = controller.isConnected.read(reader);
+        const connecting = controller.isConnecting.read(reader);
+        const reconnecting = controller.isReconnecting.read(reader);
+        const toolConfirmations = controller.pendingToolConfirmations.read(reader);
+        const speakingSession = voicePlaybackService.speakingSession.read(reader);
+        const statusText = controller.statusText.read(reader);
+        const turns = controller.transcriptTurns.read(reader);
+        const targetSession = controller.targetSession.read(reader);
+        widget.setConnected(connected);
+        widget.setConnecting(connecting);
+        widget.setReconnecting(reconnecting);
+        widget.setVoiceState(state);
+        widget.setPendingToolConfirmations(toolConfirmations);
+        const showTranscript = configurationService?.getValue("agents.voice.showTranscript") !== false;
+        widget.setTranscriptTurns(showTranscript ? turns : []);
+        widget.setStatusText(statusText);
+        widget.setSelectedTargetSession(targetSession);
+        if (speakingSession) {
+            const sessions = agentSessionsService.model.sessions;
+            const match = sessions.find(s => ( s.resource.toString()) === ( speakingSession.toString()));
+            widget.setSpeakingSession(speakingSession, match?.label);
+        } else {
+            widget.setSpeakingSession(undefined, undefined);
+        }
+        _updateSessionData(widget, services);
+    }));
+    const updateAll = () => {
+        _updateStatusCounts(widget, services);
+        _updateSessionData(widget, services);
+    };
+    store.add(agentSessionsService.model.onDidChangeSessions(updateAll));
+    store.add(agentSessionsService.onDidChangeSessionArchivedState(updateAll));
+    store.add(agentTitleBarStatusService.onDidChangeSessionInfo(updateAll));
+    store.add(autorun(reader => {
+        voicePlaybackService.speakingSession.read(reader);
+        if (services.chatService) {
+            for (const model of services.chatService.chatModels.read(reader)) {
+                model.hasActiveRequest.read(reader);
+                model.requestNeedsInput.read(reader);
+                const lastReq = model.lastRequestObs.read(reader);
+                if (lastReq?.response) {
+                    lastReq.response.isIncomplete.read(reader);
+                    lastReq.response.isPendingConfirmation.read(reader);
+                }
+            }
+        }
+        _updateSessionData(widget, services);
+    }));
+    _updateStatusCounts(widget, services);
+    _updateSessionData(widget, services);
+    return store;
+}
+function _updateStatusCounts(
+    widget,
+    {
+        agentSessionsService
+    }
+) {
+    const sessions = agentSessionsService.model.sessions.filter(s => !s.isArchived());
+    const oneHourAgo = Date.now() - 60 * 60 * 1000;
+    let working = 0;
+    let needsInput = 0;
+    let done = 0;
+    for (const session of sessions) {
+        switch (session.status) {
+        case ChatSessionStatus.InProgress:
+            working++;
+            break;
+        case ChatSessionStatus.NeedsInput:
+            needsInput++;
+            break;
+        case ChatSessionStatus.Completed:
+            {
+                const endedAt = session.timing.lastRequestEnded ?? session.timing.created;
+                if (endedAt && endedAt > oneHourAgo) {
+                    done++;
+                }
+                break;
+            }
+        }
+    }
+    widget.setStatusCounts(working, needsInput, done);
+}
+function _updateSessionData(widget, services) {
+    const {
+        agentSessionsService,
+        voiceSessionController,
+        voicePlaybackService,
+        environmentService,
+        chatService
+    } = services;
+    const sessions = agentSessionsService.model.sessions.filter(s => !s.isArchived());
+    const toolConfirmations = voiceSessionController.pendingToolConfirmations.get();
+    const speakingSession = voicePlaybackService.speakingSession.get();
+    const statusOrder = s => s.status === ChatSessionStatus.NeedsInput ? 0 : s.status === ChatSessionStatus.InProgress ? 1 : 2;
+    const lastActivity = s => s.timing.lastRequestEnded ?? s.timing.lastRequestStarted ?? s.timing.created ?? 0;
+    const sorted = [...sessions].sort((a, b) => {
+        const statusDiff = statusOrder(a) - statusOrder(b);
+        if (statusDiff !== 0) {
+            return statusDiff;
+        }
+        return lastActivity(b) - lastActivity(a);
+    });
+    const sessionRows = ( sorted.map(session => {
+        const isSpeaking = speakingSession?.toString() === ( session.resource.toString());
+        const changes = getAgentChangesSummary(session.changes);
+        const tc = toolConfirmations.find(c => ( c.sessionResource.toString()) === ( session.resource.toString()));
+        return {
+            resource: session.resource,
+            label: session.label || ( localize(4802, "Untitled session")),
+            isActive: session.status === ChatSessionStatus.InProgress,
+            needsInput: session.status === ChatSessionStatus.NeedsInput,
+            isIdle: session.status === ChatSessionStatus.Completed,
+            isSpeaking,
+            insertions: changes?.insertions ?? 0,
+            deletions: changes?.deletions ?? 0,
+            toolConfirmation: tc
+        };
+    }));
+    if (chatService) {
+        const agentResources = ( new Set(( sessionRows.map(r => ( r.resource.toString())))));
+        const chatModels = chatService.chatModels.get();
+        for (const model of chatModels) {
+            if (( agentResources.has(( model.sessionResource.toString())))) {
+                continue;
+            }
+            const requests = model.getRequests();
+            if (requests.length === 0) {
+                continue;
+            }
+            const isActive = model.hasActiveRequest.get();
+            const needsInput = !!model.requestNeedsInput.get();
+            const tc = toolConfirmations.find(c => ( c.sessionResource.toString()) === ( model.sessionResource.toString()));
+            sessionRows.push({
+                resource: model.sessionResource,
+                label: model.title || ( localize(4803, "Chat")),
+                isActive: isActive && !needsInput,
+                needsInput,
+                isIdle: !isActive && !needsInput,
+                isSpeaking: speakingSession?.toString() === ( model.sessionResource.toString()),
+                insertions: 0,
+                deletions: 0,
+                toolConfirmation: tc
+            });
+        }
+    }
+    widget.setSessions(sessionRows);
+    if (environmentService.isSessionsWindow) {
+        const repoMap = ( new Map());
+        const otherRows = [];
+        for (let i = 0; i < sorted.length; i++) {
+            const repoName = getRepositoryName(sorted[i]);
+            const row = sessionRows[i];
+            if (repoName) {
+                let group = repoMap.get(repoName);
+                if (!group) {
+                    group = [];
+                    repoMap.set(repoName, group);
+                }
+                group.push(row);
+            } else {
+                otherRows.push(row);
+            }
+        }
+        const groups = [];
+        for (const [label, rows] of repoMap) {
+            groups.push({
+                label,
+                sessions: rows
+            });
+        }
+        if (otherRows.length > 0) {
+            groups.push({
+                label: ( localize(4804, "Other")),
+                sessions: otherRows
+            });
+        }
+        widget.setSessionGroups(groups.length > 0 ? groups : undefined);
+    } else {
+        widget.setSessionGroups(undefined);
+    }
+}
+
+export { bindWidgetToController };

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

@@ -0,0 +1,61 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IAuxiliaryWindowService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService.service";
+import { IAgentsVoiceWindowService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/agentsVoice/common/agentsVoice.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IHostService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service";
+import { IAgentSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service";
+import { IAgentTitleBarStatusService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/experiments/agentTitleBarStatusService.service";
+import { IMicCaptureService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/voiceClient/micCaptureService.service";
+import { ITtsPlaybackService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/voiceClient/ttsPlaybackService.service";
+import { IVoiceSessionController } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/voiceClient/voiceSessionController.service";
+import { IVoicePlaybackService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/voicePlaybackService.service";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+export declare class AgentsVoiceWindowService extends Disposable implements IAgentsVoiceWindowService {
+    private readonly auxiliaryWindowService;
+    private readonly storageService;
+    private readonly configurationService;
+    private readonly hostService;
+    private readonly agentSessionsService;
+    private readonly agentTitleBarStatusService;
+    private readonly micCaptureService;
+    private readonly ttsPlaybackService;
+    private readonly voiceSessionController;
+    private readonly voicePlaybackService;
+    private readonly commandService;
+    private readonly chatService;
+    private readonly workspaceContextService;
+    private readonly environmentService;
+    private readonly themeService;
+    private readonly keybindingService;
+    private readonly instantiationService;
+    readonly _serviceBrand: undefined;
+    private readonly _onDidChangeOpen;
+    readonly onDidChangeOpen: Event<boolean>;
+    private readonly _auxiliaryWindowRef;
+    private _window;
+    private readonly _windowDisposables;
+    private readonly _ownershipChannel;
+    private _resizeTimeout;
+    get isOpen(): boolean;
+    /**
+     * Calls setWindowAlwaysOnTop via a registered command (Electron only).
+     * Avoids importing INativeHostService in the browser layer.
+     */
+    constructor(auxiliaryWindowService: IAuxiliaryWindowService, storageService: IStorageService, configurationService: IConfigurationService, hostService: IHostService, agentSessionsService: IAgentSessionsService, agentTitleBarStatusService: IAgentTitleBarStatusService, micCaptureService: IMicCaptureService, ttsPlaybackService: ITtsPlaybackService, voiceSessionController: IVoiceSessionController, voicePlaybackService: IVoicePlaybackService, commandService: ICommandService, chatService: IChatService, workspaceContextService: IWorkspaceContextService, environmentService: IWorkbenchEnvironmentService, themeService: IThemeService, keybindingService: IKeybindingService, instantiationService: IInstantiationService);
+    openWindow(): Promise<void>;
+    closeWindow(): void;
+    toggleWindow(): Promise<void>;
+    private _resizeWindow;
+    private _doResizeWindow;
+    private _defaultBounds;
+    private loadBounds;
+    private saveBounds;
+}

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

@@ -0,0 +1,338 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
+import { disposableWindowInterval } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { FileAccess } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+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 { IAuxiliaryWindowService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/auxiliaryWindow/browser/auxiliaryWindowService.service';
+import { AgentsVoiceStorageKeys, AGENTS_VOICE_WINDOW_DEFAULT_HEIGHT, AGENTS_VOICE_WINDOW_DEFAULT_WIDTH } from '../common/agentsVoice.js';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IHostService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/host/browser/host.service';
+import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
+import { IAgentTitleBarStatusService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/experiments/agentTitleBarStatusService.service';
+import { IMicCaptureService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/voiceClient/micCaptureService.service';
+import { ITtsPlaybackService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/voiceClient/ttsPlaybackService.service';
+import { IVoiceSessionController } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/voiceClient/voiceSessionController.service';
+import { IVoicePlaybackService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/voicePlaybackService.service';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/baseColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/chartsColors';
+import { editorBackground } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/editorColors';
+import { inputBackground, inputBorder } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/inputColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/listColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/menuColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/minimapColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/miscColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/quickpickColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/searchColors';
+import { AgentsVoiceWidget } from './agentsVoiceWidget.js';
+import { bindWidgetToController } from './agentsVoiceWidgetBinding.js';
+import { AgentsVoiceSessionsPicker } from './agentsVoiceSessionsPicker.js';
+
+let AgentsVoiceWindowService = class AgentsVoiceWindowService extends Disposable {
+    get isOpen() {
+        return !!this._window;
+    }
+    constructor(
+        auxiliaryWindowService,
+        storageService,
+        configurationService,
+        hostService,
+        agentSessionsService,
+        agentTitleBarStatusService,
+        micCaptureService,
+        ttsPlaybackService,
+        voiceSessionController,
+        voicePlaybackService,
+        commandService,
+        chatService,
+        workspaceContextService,
+        environmentService,
+        themeService,
+        keybindingService,
+        instantiationService
+    ) {
+        super();
+        this.auxiliaryWindowService = auxiliaryWindowService;
+        this.storageService = storageService;
+        this.configurationService = configurationService;
+        this.hostService = hostService;
+        this.agentSessionsService = agentSessionsService;
+        this.agentTitleBarStatusService = agentTitleBarStatusService;
+        this.micCaptureService = micCaptureService;
+        this.ttsPlaybackService = ttsPlaybackService;
+        this.voiceSessionController = voiceSessionController;
+        this.voicePlaybackService = voicePlaybackService;
+        this.commandService = commandService;
+        this.chatService = chatService;
+        this.workspaceContextService = workspaceContextService;
+        this.environmentService = environmentService;
+        this.themeService = themeService;
+        this.keybindingService = keybindingService;
+        this.instantiationService = instantiationService;
+        this._onDidChangeOpen = this._register(( new Emitter()));
+        this.onDidChangeOpen = this._onDidChangeOpen.event;
+        this._auxiliaryWindowRef = this._register(( new MutableDisposable()));
+        this._windowDisposables = this._register(( new DisposableStore()));
+        const ownershipChannel = ( new BroadcastChannel("agents-voice-ownership"));
+        ownershipChannel.onmessage = e => {
+            if (e.data?.type === "claim" && this._window) {
+                this.closeWindow();
+            }
+        };
+        this._register({
+            dispose: () => ownershipChannel.close()
+        });
+        this._ownershipChannel = ownershipChannel;
+        const onBeforeUnload = () => {
+            if (this._window) {
+                this.closeWindow();
+            }
+        };
+        mainWindow.addEventListener("beforeunload", onBeforeUnload);
+        this._register({
+            dispose: () => mainWindow.removeEventListener("beforeunload", onBeforeUnload)
+        });
+        const wasOpen = this.storageService.getBoolean(AgentsVoiceStorageKeys.WindowOpen, StorageScope.WORKSPACE, false);
+        if (wasOpen) {
+            this.storageService.store(
+                AgentsVoiceStorageKeys.WindowOpen,
+                false,
+                StorageScope.WORKSPACE,
+                StorageTarget.MACHINE
+            );
+        }
+    }
+    async openWindow() {
+        if (this._window) {
+            return;
+        }
+        const bounds = this.loadBounds();
+        const auxiliaryWindow = await this.auxiliaryWindowService.open({
+            bounds,
+            alwaysOnTop: true,
+            frameless: true,
+            transparent: false,
+            disableFullscreen: true,
+            nativeTitlebar: false,
+            noBackgroundThrottling: true,
+            backgroundColor: this.themeService.getColorTheme().getColor(editorBackground)?.toString() ?? "#1e1e1e"
+        });
+        this._window = auxiliaryWindow;
+        this._auxiliaryWindowRef.value = auxiliaryWindow;
+        const workspace = this.workspaceContextService.getWorkspace();
+        const projectName = workspace.folders.length > 0 ? workspace.folders[0].name : "";
+        auxiliaryWindow.window.document.title = projectName ? `Agents Voice — ${projectName}` : "Agents Voice";
+        auxiliaryWindow.container.style.overflow = "hidden";
+        auxiliaryWindow.window.document.body.style.setProperty("margin", "0", "important");
+        const theme = this.themeService.getColorTheme();
+        const bgColor = theme.getColor(editorBackground)?.toString() ?? "#1e1e1e";
+        const inputBg = theme.getColor(inputBackground)?.toString() ?? "#3C3C3C";
+        const inputBd = theme.getColor(inputBorder)?.toString() ?? "transparent";
+        auxiliaryWindow.container.style.setProperty("--vscode-agents-background", bgColor);
+        auxiliaryWindow.container.style.backgroundColor = inputBg;
+        auxiliaryWindow.container.style.border = `1px solid ${inputBd}`;
+        auxiliaryWindow.container.style.boxSizing = "border-box";
+        auxiliaryWindow.window.document.body.style.setProperty("background-color", inputBg, "important");
+        this._windowDisposables.clear();
+        const widget = ( new AgentsVoiceWidget(auxiliaryWindow.container, {
+            copilotIconSrc: ( ( FileAccess.asBrowserUri("vs/sessions/browser/media/sessions-icon.svg")).toString(true)),
+            hideDisconnect: (this.configurationService.getValue("agents.voice.autoSendDelay") ?? 500) >= 0,
+            connect: () => {
+                this.storageService.store(
+                    AgentsVoiceStorageKeys.OnboardingCompleted,
+                    true,
+                    StorageScope.PROFILE,
+                    StorageTarget.USER
+                );
+                this.voiceSessionController.connect(mainWindow);
+            },
+            disconnect: () => this.voiceSessionController.disconnect(),
+            pttDown: () => {
+                if (!this.voiceSessionController.isConnected.get() && !this.voiceSessionController.isConnecting.get()) {
+                    this.voiceSessionController.connect(mainWindow).then(() => {
+                        if (this.voiceSessionController.isConnected.get()) {
+                            this.voiceSessionController.pttDown();
+                        }
+                    });
+                    return;
+                }
+                this.voiceSessionController.pttDown();
+            },
+            pttUp: () => this.voiceSessionController.pttUp(),
+            closeWindow: () => this.closeWindow(),
+            stopPlayback: () => this.ttsPlaybackService.stopPlayback(),
+            openSession: resource => {
+                this.commandService.executeCommand("_chat.voice.switchToSession", ( resource.toString()));
+                this.hostService.focus(mainWindow);
+            },
+            stopSession: resource => {
+                const model = this.chatService.getSession(resource);
+                if (model) {
+                    const lastReq = model.getRequests().at(-1);
+                    if (lastReq) {
+                        this.voiceSessionController.markUserCancelled(( resource.toString()));
+                        this.chatService.cancelCurrentRequestForSession(resource);
+                    }
+                }
+            },
+            cancelSession: resource => {
+                this.voiceSessionController.markUserCancelled(( resource.toString()));
+                this.chatService.cancelCurrentRequestForSession(resource);
+            },
+            selectTargetSession: resource => {
+                this.voiceSessionController.setTargetSession(resource);
+                if (resource) {
+                    this.commandService.executeCommand("_chat.voice.switchToSession", ( resource.toString())).catch(() => {});
+                }
+            },
+            newSessionAsTarget: () => {
+                this.voiceSessionController.newSessionAsTarget();
+            },
+            getAnalyserNode: () => {
+                const state = this.voiceSessionController.voiceState.get();
+                return this.ttsPlaybackService.analyserNode ?? (state === "listening" ? this.micCaptureService.analyserNode : null) ?? null;
+            },
+            onResize: () => this._resizeWindow(auxiliaryWindow),
+            openPttKeySettings: () => this.commandService.executeCommand("workbench.action.openGlobalKeybindings", "agentsVoice.pushToTalk"),
+            submitFeedback: text => this.voiceSessionController.submitFeedback(text),
+            showSessionsPicker: () => {
+                const picker = this.instantiationService.createInstance(
+                    AgentsVoiceSessionsPicker,
+                    resource => this.voiceSessionController.setTargetSession(resource)
+                );
+                picker.show();
+            }
+        }, {
+            defaultExpanded: false,
+            inputBoxLayout: true
+        }));
+        this._windowDisposables.add(widget);
+        const getPttLabel = () => this.keybindingService.lookupKeybinding("agentsVoice.pushToTalk")?.getLabel() ?? undefined;
+        widget.setPttKeyLabel(getPttLabel());
+        this._windowDisposables.add(this.keybindingService.onDidUpdateKeybindings(() => {
+            widget.setPttKeyLabel(getPttLabel());
+        }));
+        this._windowDisposables.add(bindWidgetToController(widget, {
+            voiceSessionController: this.voiceSessionController,
+            agentSessionsService: this.agentSessionsService,
+            agentTitleBarStatusService: this.agentTitleBarStatusService,
+            voicePlaybackService: this.voicePlaybackService,
+            environmentService: this.environmentService,
+            chatService: this.chatService,
+            configurationService: this.configurationService
+        }));
+        this.agentSessionsService.model.resolve(undefined);
+        this._windowDisposables.add(disposableWindowInterval(auxiliaryWindow.window, () => {
+            this.agentSessionsService.model.resolve(undefined);
+        }, 3000));
+        Event.once(auxiliaryWindow.onUnload)(() => {
+            this.voiceSessionController.setTargetSession(undefined);
+            this.voiceSessionController.disconnect();
+            this._window = undefined;
+            this._windowDisposables.clear();
+            this._auxiliaryWindowRef.value = undefined;
+            this.storageService.store(
+                AgentsVoiceStorageKeys.WindowOpen,
+                false,
+                StorageScope.WORKSPACE,
+                StorageTarget.MACHINE
+            );
+            this._onDidChangeOpen.fire(false);
+        });
+        this.storageService.store(
+            AgentsVoiceStorageKeys.WindowOpen,
+            true,
+            StorageScope.WORKSPACE,
+            StorageTarget.MACHINE
+        );
+        this._onDidChangeOpen.fire(true);
+    }
+    closeWindow() {
+        if (!this._window) {
+            return;
+        }
+        this.saveBounds(this._window);
+        this.voiceSessionController.setTargetSession(undefined);
+        this.storageService.store(
+            AgentsVoiceStorageKeys.WindowOpen,
+            false,
+            StorageScope.WORKSPACE,
+            StorageTarget.MACHINE
+        );
+        this._window = undefined;
+        this._windowDisposables.clear();
+        this._auxiliaryWindowRef.value = undefined;
+        this._onDidChangeOpen.fire(false);
+    }
+    async toggleWindow() {
+        if (this.isOpen) {
+            this.closeWindow();
+        } else {
+            this._ownershipChannel.postMessage({
+                type: "claim"
+            });
+            await this.openWindow();
+        }
+    }
+    _resizeWindow(auxiliaryWindow) {
+        if (this._resizeTimeout) {
+            clearTimeout(this._resizeTimeout);
+        }
+        this._resizeTimeout = setTimeout(() => {
+            this._resizeTimeout = undefined;
+            this._doResizeWindow(auxiliaryWindow);
+        }, 100);
+    }
+    _doResizeWindow(auxiliaryWindow) {
+        const pill = auxiliaryWindow.container.querySelector("div");
+        if (!pill) {
+            return;
+        }
+        const pillWidth = pill.offsetWidth;
+        const pillHeight = pill.offsetHeight;
+        if (pillWidth <= 0 || pillHeight <= 0) {
+            return;
+        }
+        const currentWidth = auxiliaryWindow.window.outerWidth;
+        const currentHeight = auxiliaryWindow.window.outerHeight;
+        if (pillWidth !== currentWidth || pillHeight !== currentHeight) {
+            try {
+                const screenBottom = auxiliaryWindow.window.screen.availHeight;
+                const maxHeight = screenBottom - auxiliaryWindow.window.screenY;
+                const clampedHeight = Math.min(pillHeight, Math.max(maxHeight, AGENTS_VOICE_WINDOW_DEFAULT_HEIGHT));
+                auxiliaryWindow.window.resizeTo(pillWidth, clampedHeight);
+            } catch {}
+        }
+    }
+    _defaultBounds() {
+        const x = Math.round(
+            mainWindow.screenX + (mainWindow.outerWidth - AGENTS_VOICE_WINDOW_DEFAULT_WIDTH) / 2
+        );
+        const y = mainWindow.screenY + mainWindow.outerHeight - AGENTS_VOICE_WINDOW_DEFAULT_HEIGHT - 100;
+        return {
+            x,
+            y,
+            width: AGENTS_VOICE_WINDOW_DEFAULT_WIDTH,
+            height: AGENTS_VOICE_WINDOW_DEFAULT_HEIGHT
+        };
+    }
+    loadBounds() {
+        return this._defaultBounds();
+    }
+    saveBounds(_window) {}
+};
+AgentsVoiceWindowService = ( __decorate([( __param(0, IAuxiliaryWindowService)), ( __param(1, IStorageService)), ( __param(2, IConfigurationService)), ( __param(3, IHostService)), ( __param(4, IAgentSessionsService)), ( __param(5, IAgentTitleBarStatusService)), ( __param(6, IMicCaptureService)), ( __param(7, ITtsPlaybackService)), ( __param(8, IVoiceSessionController)), ( __param(9, IVoicePlaybackService)), ( __param(10, ICommandService)), ( __param(11, IChatService)), ( __param(12, IWorkspaceContextService)), ( __param(13, IWorkbenchEnvironmentService)), ( __param(14, IThemeService)), ( __param(15, IKeybindingService)), ( __param(16, IInstantiationService))], AgentsVoiceWindowService));
+
+export { AgentsVoiceWindowService };

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

@@ -0,0 +1,10 @@
+import type { IPendingToolConfirmation } from "../../../chat/browser/voiceClient/voiceSessionController.js";
+export interface ToolConfirmationsProps {
+    readonly confirmations: readonly IPendingToolConfirmation[];
+    readonly onOpenSession: (resource: IPendingToolConfirmation["sessionResource"]) => void;
+}
+export interface ToolConfirmationsComponent {
+    readonly element: HTMLElement;
+    update(props: ToolConfirmationsProps): void;
+}
+export declare function createToolConfirmations(): ToolConfirmationsComponent;