@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/voiceClient/voiceInputUtils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Combine any text already typed into a chat input with a voice transcript so
+ * the typed text is not dropped when voice mode submits the request.
+ *
+ * The transcript is appended after the existing text, inserting a single space
+ * separator only when the existing text does not already end in whitespace.
+ *
+ * @param existing The text currently in the chat input editor.
+ * @param transcript The recognized voice transcript to submit.
+ */
+export declare function combineVoiceInput(existing: string, transcript: string): string;

package/vscode/src/vs/workbench/contrib/chat/browser/voiceClient/voiceInputUtils.js

@@ -0,0 +1,13 @@
+
+
+function combineVoiceInput(existing, transcript) {
+    if (!existing) {
+        return transcript;
+    }
+    if (!transcript) {
+        return existing;
+    }
+    return /\s$/.test(existing) ? `${existing}${transcript}` : `${existing} ${transcript}`;
+}
+
+export { combineVoiceInput };

package/vscode/src/vs/workbench/contrib/chat/browser/voiceInputMode/voiceInputMode.d.ts

@@ -0,0 +1,66 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { RawContextKey } 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 { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IChatSpeechToTextService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/speechToText/chatSpeechToTextService.service";
+import { IVoiceInputModeService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/voiceInputMode/voiceInputMode.service";
+/**
+ * The two mutually-exclusive voice input modes exposed in the chat input.
+ * - `dictation`: speech-to-text that types the recognized words into the input box.
+ * - `voice`: the live, conversational Voice Mode agent (real-time listen + talk-back).
+ */
+export type VoiceInputMode = "dictation" | "voice";
+/**
+ * Simulated voice-cell visual states for development/preview, so the UI can be
+ * inspected without a live backend connection. `undefined` = use real state.
+ */
+export type SimulatedVoiceState = "off" | "connecting" | "idle" | "listening" | "speaking" | "dictating";
+/**
+ * The four push-to-talk interaction designs being compared. Each drives its own
+ * prototype walkthrough (state sequence + layout + hint) so they can be evaluated
+ * side by side without a live backend.
+ * - `handsFree`:   auto-listen + auto-send; hold a key only to barge in / interrupt.
+ * - `keyboardHold`: walkie-talkie — hold a keybinding to talk; button only connects.
+ * - `buttonHold`:  hold the voice button to talk; a quick tap disconnects.
+ * - `clickToggle`: tap the button to start listening, tap again to stop.
+ */
+export type VoiceWalkthroughVersion = "handsFree" | "keyboardHold" | "buttonHold" | "clickToggle";
+/**
+ * Which voice input mode is currently selected in the segmented toggle. This is the
+ * single source of truth for *which* segment is highlighted — distinct from whether
+ * that mode is currently active (listening / connected / speaking).
+ */
+export declare const CHAT_VOICE_INPUT_MODE: RawContextKey<VoiceInputMode>;
+export declare class VoiceInputModeService extends Disposable implements IVoiceInputModeService {
+    private readonly storageService;
+    readonly _serviceBrand: undefined;
+    private readonly _selectedMode;
+    readonly selectedMode: IObservable<VoiceInputMode>;
+    readonly voiceAvailable: IObservable<boolean>;
+    readonly dictationAvailable: IObservable<boolean>;
+    readonly handsFree: IObservable<boolean>;
+    private readonly _simulatedVoiceState;
+    readonly simulatedVoiceState: IObservable<SimulatedVoiceState | undefined>;
+    private readonly _simulatedHandsFree;
+    readonly simulatedHandsFree: IObservable<boolean | undefined>;
+    private readonly _simulatedVersion;
+    readonly simulatedVersion: IObservable<VoiceWalkthroughVersion | undefined>;
+    private readonly _simulatedHover;
+    readonly simulatedHover: IObservable<boolean>;
+    private readonly _contextKey;
+    constructor(storageService: IStorageService, configurationService: IConfigurationService, contextKeyService: IContextKeyService, chatSpeechToTextService: IChatSpeechToTextService);
+    setSelectedMode(mode: VoiceInputMode): void;
+    setSimulatedVoiceState(state: SimulatedVoiceState | undefined): void;
+    private static readonly WALKTHROUGHS;
+    private static readonly WALK_STEP_MS;
+    private _walkTimer;
+    private _walkIndex;
+    private _walkVersion;
+    startVoiceStateWalkthrough(version: VoiceWalkthroughVersion): void;
+    stepVoiceStateWalkthrough(): void;
+    clearSimulation(): void;
+    private _stopWalkTimer;
+    dispose(): void;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/voiceInputMode/voiceInputMode.js

@@ -0,0 +1,297 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+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 '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { RawContextKey } 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 '@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 { AGENTS_VOICE_ENTITLED, AgentsVoiceSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/agentsVoice/common/agentsVoice';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { DictationSettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/speechToText/chatSpeechToTextService';
+import { IChatSpeechToTextService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/speechToText/chatSpeechToTextService.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+
+var VoiceInputModeService_1;
+const CHAT_VOICE_INPUT_MODE = ( new RawContextKey("chatVoiceInputMode", "voice", {
+    type: "string",
+    description: ( localize(
+        9190,
+        "The currently selected voice input mode in the chat input (dictation or voice)."
+    ))
+}));
+const STORAGE_KEY = "chat.voiceInputMode.selected";
+let VoiceInputModeService = class VoiceInputModeService extends Disposable {
+    static {
+        VoiceInputModeService_1 = this;
+    }
+    constructor(
+        storageService,
+        configurationService,
+        contextKeyService,
+        chatSpeechToTextService
+    ) {
+        super();
+        this.storageService = storageService;
+        this._simulatedVoiceState = observableValue(this, undefined);
+        this.simulatedVoiceState = this._simulatedVoiceState;
+        this._simulatedHandsFree = observableValue(this, undefined);
+        this.simulatedHandsFree = this._simulatedHandsFree;
+        this._simulatedVersion = observableValue(this, undefined);
+        this.simulatedVersion = this._simulatedVersion;
+        this._simulatedHover = observableValue(this, false);
+        this.simulatedHover = this._simulatedHover;
+        this._walkIndex = 0;
+        const stored = this.storageService.get(STORAGE_KEY, StorageScope.PROFILE);
+        const initial = stored === "dictation" ? "dictation" : "voice";
+        this._selectedMode = observableValue(this, initial);
+        this.selectedMode = this._selectedMode;
+        this.voiceAvailable = observableFromEvent(this, Event.any(
+            configurationService.onDidChangeConfiguration,
+            contextKeyService.onDidChangeContext
+        ), () => configurationService.getValue("agents.voice.enabled") === true && ChatContextKeys.enabled.getValue(contextKeyService) === true && AGENTS_VOICE_ENTITLED.evaluate({
+            getValue: key => contextKeyService.getContextKeyValue(key)
+        }) && configurationService.getValue(AgentsVoiceSettingId.ShowButton) !== false);
+        this.dictationAvailable = observableFromEvent(this, Event.any(
+            configurationService.onDidChangeConfiguration,
+            contextKeyService.onDidChangeContext
+        ), () => chatSpeechToTextService.isConfigured && configurationService.getValue(DictationSettingId.ShowButton) !== false);
+        this.handsFree = observableFromEvent(
+            this,
+            configurationService.onDidChangeConfiguration,
+            () => configurationService.getValue("agents.voice.handsFree") !== false
+        );
+        this._contextKey = CHAT_VOICE_INPUT_MODE.bindTo(contextKeyService);
+        this._register(autorun(reader => {
+            this._contextKey.set(this._selectedMode.read(reader));
+        }));
+    }
+    setSelectedMode(mode) {
+        if (this._selectedMode.get() === mode) {
+            return;
+        }
+        this._selectedMode.set(mode, undefined);
+        this.storageService.store(STORAGE_KEY, mode, StorageScope.PROFILE, StorageTarget.USER);
+    }
+    setSimulatedVoiceState(state) {
+        this._simulatedVoiceState.set(state, undefined);
+    }
+    static {
+        this.WALKTHROUGHS = {
+            handsFree: {
+                handsFree: true,
+                steps: [{
+                    state: "off",
+                    ms: 1600
+                }, {
+                    state: "connecting",
+                    ms: 1400
+                }, {
+                    state: "idle",
+                    ms: 1400
+                }, {
+                    state: "listening",
+                    ms: 2800
+                }, {
+                    state: "speaking",
+                    ms: 2800
+                },
+                {
+                    state: "listening",
+                    ms: 1600
+                }, {
+                    state: "speaking",
+                    ms: 2400
+                }, {
+                    state: "idle",
+                    ms: 1600
+                }, {
+                    state: "off",
+                    ms: 1600
+                }]
+            },
+            keyboardHold: {
+                handsFree: false,
+                steps: [{
+                    state: "off",
+                    ms: 1600
+                }, {
+                    state: "connecting",
+                    ms: 1400
+                },
+                {
+                    state: "idle",
+                    ms: 2400
+                },
+                {
+                    state: "listening",
+                    ms: 2800
+                },
+                {
+                    state: "speaking",
+                    ms: 2800
+                }, {
+                    state: "idle",
+                    ms: 1800
+                }, {
+                    state: "listening",
+                    ms: 2600
+                }, {
+                    state: "speaking",
+                    ms: 2400
+                }, {
+                    state: "idle",
+                    ms: 1600
+                }, {
+                    state: "off",
+                    ms: 1600
+                }]
+            },
+            buttonHold: {
+                handsFree: false,
+                steps: [{
+                    state: "off",
+                    ms: 1600
+                }, {
+                    state: "connecting",
+                    ms: 1400
+                }, {
+                    state: "idle",
+                    ms: 2200
+                },
+                {
+                    state: "idle",
+                    hover: true,
+                    ms: 1800
+                },
+                {
+                    state: "listening",
+                    ms: 2800
+                }, {
+                    state: "speaking",
+                    ms: 2800
+                }, {
+                    state: "idle",
+                    ms: 1800
+                }, {
+                    state: "listening",
+                    ms: 2600
+                }, {
+                    state: "speaking",
+                    ms: 2400
+                }, {
+                    state: "idle",
+                    ms: 1600
+                }, {
+                    state: "off",
+                    ms: 1600
+                }]
+            },
+            clickToggle: {
+                handsFree: false,
+                steps: [{
+                    state: "off",
+                    ms: 1600
+                }, {
+                    state: "connecting",
+                    ms: 1400
+                }, {
+                    state: "idle",
+                    ms: 2000
+                },
+                {
+                    state: "listening",
+                    ms: 2800
+                },
+                {
+                    state: "idle",
+                    ms: 1800
+                }, {
+                    state: "listening",
+                    ms: 2600
+                },
+                {
+                    state: "speaking",
+                    ms: 2800
+                }, {
+                    state: "listening",
+                    ms: 1800
+                }, {
+                    state: "idle",
+                    ms: 1600
+                }, {
+                    state: "off",
+                    ms: 1600
+                }]
+            }
+        };
+    }
+    static {
+        this.WALK_STEP_MS = 2400;
+    }
+    startVoiceStateWalkthrough(version) {
+        this.clearSimulation();
+        const walkthrough = VoiceInputModeService_1.WALKTHROUGHS[version];
+        this._walkVersion = version;
+        this._simulatedHandsFree.set(walkthrough.handsFree, undefined);
+        this._simulatedVersion.set(version, undefined);
+        this._walkIndex = 0;
+        const advance = () => {
+            const steps = walkthrough.steps;
+            const step = steps[this._walkIndex % steps.length];
+            transaction(tx => {
+                this._simulatedVoiceState.set(step.state, tx);
+                this._simulatedHover.set(step.hover ?? false, tx);
+            });
+            this._walkIndex++;
+            this._walkTimer = setTimeout(advance, step.ms ?? VoiceInputModeService_1.WALK_STEP_MS);
+        };
+        advance();
+    }
+    stepVoiceStateWalkthrough() {
+        this._stopWalkTimer();
+        const version = this._walkVersion ?? "keyboardHold";
+        const steps = VoiceInputModeService_1.WALKTHROUGHS[version].steps;
+        this._walkIndex = this._walkIndex % steps.length;
+        const step = steps[this._walkIndex];
+        transaction(tx => {
+            this._simulatedVersion.set(version, tx);
+            this._simulatedHandsFree.set(VoiceInputModeService_1.WALKTHROUGHS[version].handsFree, tx);
+            this._simulatedVoiceState.set(step.state, tx);
+            this._simulatedHover.set(step.hover ?? false, tx);
+        });
+        this._walkIndex++;
+    }
+    clearSimulation() {
+        this._stopWalkTimer();
+        this._walkIndex = 0;
+        this._walkVersion = undefined;
+        transaction(tx => {
+            this._simulatedVoiceState.set(undefined, tx);
+            this._simulatedHandsFree.set(undefined, tx);
+            this._simulatedVersion.set(undefined, tx);
+            this._simulatedHover.set(false, tx);
+        });
+    }
+    _stopWalkTimer() {
+        if (this._walkTimer !== undefined) {
+            clearTimeout(this._walkTimer);
+            this._walkTimer = undefined;
+        }
+    }
+    dispose() {
+        this._stopWalkTimer();
+        super.dispose();
+    }
+};
+VoiceInputModeService = VoiceInputModeService_1 = ( __decorate([( __param(0, IStorageService)), ( __param(1, IConfigurationService)), ( __param(2, IContextKeyService)), ( __param(3, IChatSpeechToTextService))], VoiceInputModeService));
+
+export { CHAT_VOICE_INPUT_MODE, VoiceInputModeService };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatSubagentOpenChat.d.ts

@@ -0,0 +1,137 @@
+import { EventLike } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/dom";
+import { BaseActionViewItem, IActionViewItemOptions } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems";
+import { IAction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IAccessibilityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/common/accessibility.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IHoverService } from "@codingame/monaco-vscode-api/vscode/vs/platform/hover/browser/hover.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IMarkdownRendererService } from "@codingame/monaco-vscode-api/vscode/vs/platform/markdown/browser/markdownRenderer.service";
+import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
+import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { IChatMarkdownAnchorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatMarkdownAnchorService.service";
+export interface IOpenSubagentChatContext {
+    readonly chatResource: string;
+    readonly isChatAvailable?: boolean;
+    readonly parentSessionResource?: string;
+    readonly title?: string;
+    readonly agentType?: string;
+    /** Open the subagent chat to the side (in a new group) rather than in place. */
+    readonly toSide?: boolean;
+    readonly confirmationCount?: number;
+    readonly confirmationActive?: boolean;
+    readonly startedAt?: number;
+    readonly duration?: number;
+    readonly modelName?: string;
+    /** Copilot credits (AIC) this subagent has consumed so far. */
+    readonly credits?: number;
+    readonly parentModelId?: string;
+    readonly parentModelName?: string;
+    readonly parentResolvedModelId?: string;
+    readonly isActive?: boolean;
+    readonly activeToolCallId?: string;
+    readonly activeToolLabel?: string;
+    readonly activeToolIcon?: ThemeIcon;
+}
+export type SubagentChatStatus = "running" | "waiting" | "completed";
+export interface ISubagentChatOpener {
+    open(context: IOpenSubagentChatContext): Promise<boolean>;
+}
+declare class SubagentChatOpenerRegistry {
+    private readonly openers;
+    register(opener: ISubagentChatOpener): IDisposable;
+    open(context: IOpenSubagentChatContext): Promise<boolean>;
+}
+export declare const subagentChatOpenerRegistry: SubagentChatOpenerRegistry;
+export declare function getSubagentEditorResource(context: IOpenSubagentChatContext): URI | undefined;
+/**
+ * Whether the subagent's model is worth showing next to the parent's. It is not when
+ * it merely repeats the parent's, nor when it is "Auto", which names no real model.
+ * Under an Auto parent a concrete model always shows, since the parent only says "Auto".
+ */
+export declare function shouldShowSubagentModel(subagentModelName: string | undefined, parentModelId: string | undefined, parentModelName: string | undefined, parentModelMetadataId: string | undefined): boolean;
+export declare function formatCompactSubagentDuration(startedAt: number, duration: number | undefined, now?: number): string;
+export declare function shouldAnimateSubagentToolTransition(displayedToolCallId: string | undefined, displayedIsTool: boolean, targetToolCallId: string | undefined, targetIsTool: boolean): boolean;
+export declare class OpenSubagentChatActionViewItem extends BaseActionViewItem {
+    private readonly markdownRendererService;
+    private readonly instantiationService;
+    private readonly chatMarkdownAnchorService;
+    private readonly accessibilityService;
+    private readonly languageModelsService;
+    private readonly hoverService;
+    private readonly configurationService;
+    private readonly _sourceAction;
+    private readonly _showElapsedOnly;
+    private _resolvedTitle;
+    private _trackedEnabled;
+    private _reportedAgentType;
+    private _reportedModelName;
+    private _reportedCredits;
+    private _renderedStatus;
+    private _confirmationCount;
+    private readonly _spinner;
+    private readonly _durationTimer;
+    private readonly _toolTransition;
+    private readonly _activeToolRendered;
+    private readonly _activeToolFileWidgets;
+    private readonly _pillHover;
+    private readonly _enabledTracker;
+    private _enabledTrackerFactory;
+    private _dragDataProvider;
+    private _labelElement;
+    private _agentTypeElement;
+    private _pillContentElement;
+    private _modelElement;
+    private _creditsElement;
+    private _durationElement;
+    private _activeToolElement;
+    private _activeToolIconElement;
+    private _activeToolLabelElement;
+    private _confirmationCountElement;
+    private _iconElement;
+    private _displayedToolLabel;
+    private _displayedToolIcon;
+    private _displayedToolCallId;
+    private _displayedToolAccessibleLabel;
+    private _targetToolLabel;
+    private _targetToolIcon;
+    private _targetToolCallId;
+    private _targetActivityIsTool;
+    private _displayedActivityIsTool;
+    private _toolTransitionPhase;
+    constructor(context: unknown, action: IAction, options: IActionViewItemOptions, openInEditor: boolean | undefined, markdownRendererService: IMarkdownRendererService, instantiationService: IInstantiationService, chatMarkdownAnchorService: IChatMarkdownAnchorService, accessibilityService: IAccessibilityService, chatWidgetService: IChatWidgetService, notificationService: INotificationService, languageModelsService: ILanguageModelsService, hoverService: IHoverService, configurationService: IConfigurationService);
+    render(container: HTMLElement): void;
+    onClick(event: EventLike, preserveFocus?: boolean): void;
+    private _openToSide;
+    setActionContext(newContext: unknown): void;
+    private _update;
+    trackEnabled(tracker: (context: IOpenSubagentChatContext, update: (enabled: boolean) => void) => IDisposable): void;
+    setDragDataProvider(provider: (context: IOpenSubagentChatContext, event: DragEvent) => boolean): void;
+    private _restartEnabledTracker;
+    private _setEnabled;
+    private _setModelName;
+    private _setCredits;
+    private _updateCredits;
+    private get _showCreditUsage();
+    private _setAgentType;
+    private _updateStatus;
+    private _updateConfirmationCount;
+    private _updateDuration;
+    private _setActiveTool;
+    private _runToolTransition;
+    private _completeToolTransition;
+    private _finishToolTransition;
+    private _setDisplayedTool;
+    private _renderActiveToolIcon;
+    private _clearToolTransitionClasses;
+    private _restartToolTransition;
+    private _setResolvedTitle;
+    protected getTooltip(): string | undefined;
+    protected updateTooltip(): void;
+    protected updateEnabled(): void;
+    protected updateAriaLabel(): void;
+}
+export {};