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

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

@@ -0,0 +1,57 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IAgentSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service";
+import { IVoiceToolCall } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/voiceClient/voiceClientService";
+import { IVoiceToolDispatchService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/voiceClient/voiceToolDispatchService.service";
+/**
+ * Callbacks that require access to the chat widget or view state.
+ * Implemented by the ChatViewPane to bridge UI concerns.
+ */
+export interface IVoiceToolDispatchDelegate {
+    /** Accept input text in the current chat widget. Returns false if no widget available. */
+    acceptInput(text: string): boolean;
+    /** Get the resource URI of the currently active session. */
+    getCurrentSessionResource(): Promise<URI | undefined>;
+    /** Switch the view to a different session by resource URI. */
+    switchToSession(resource: URI): void;
+    /** Get the set of auto-approved session resource strings. */
+    getAutoApprovedSessions(): Set<string>;
+    /** Mark all current sessions as auto-approved. */
+    addAllAutoApprovedSessions(): void;
+    /** Remove a session from auto-approved set. */
+    removeAutoApprovedSession(resource: string): void;
+    /** Trigger an auto-approve check cycle. */
+    triggerAutoApproveCheck(): void;
+}
+export declare class VoiceToolDispatchService implements IVoiceToolDispatchService {
+    private readonly agentSessionsService;
+    private readonly chatService;
+    private readonly toolsService;
+    readonly _serviceBrand: undefined;
+    private _delegate;
+    constructor(agentSessionsService: IAgentSessionsService, chatService: IChatService, toolsService: ILanguageModelToolsService);
+    setDelegate(delegate: IVoiceToolDispatchDelegate): void;
+    /** Get the action label for a tool call name. */
+    static getActionLabel(name: string): string;
+    private get _agentModeOptions();
+    dispatchToolCall(toolCall: IVoiceToolCall): Promise<string>;
+    private _gatherSessionInfo;
+    /**
+     * Resolve a coding_session_id (resource URI string) to an IAgentSession.
+     * Falls back to the currently active session when id is missing/unknown.
+     */
+    private _resolveSession;
+    /**
+     * Gather files touched + per-file insertions/deletions for a session.
+     * Returns a JSON string keyed for the LLM follow-up to summarize.
+     */
+    private _gatherSessionChanges;
+    /**
+     * Gather the last N user/assistant turns of a coding session — actual
+     * conversation content, trimmed for spoken summarization.
+     */
+    private _gatherSessionThread;
+    /** Render a URI as a short relative-ish path for spoken summaries. */
+    private _formatPath;
+}

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

@@ -0,0 +1,367 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
+import { getAgentChangesSummary } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsModel';
+import { IChatToolInvocation, ToolConfirmKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { ChatModeKind, ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { constObservable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/constObservable';
+import { ChatSessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+
+const ACTION_LABELS = {
+    send_to_chat: ( localize(7763, "Sending to chat...")),
+    new_sessions: ( localize(7764, "Starting new sessions...")),
+    get_session_info: ( localize(7765, "Checking sessions...")),
+    get_session_changes: ( localize(7766, "Checking changes...")),
+    get_session_thread: ( localize(7767, "Checking conversation...")),
+    approve_confirmation: ( localize(7768, "Approving...")),
+    reject_confirmation: ( localize(7769, "Rejecting...")),
+    focus_session: ( localize(7770, "Focusing session...")),
+    auto_approve_session: ( localize(7771, "Auto-approving session...")),
+    revoke_auto_approve: ( localize(7772, "Revoking auto-approve..."))
+};
+let VoiceToolDispatchService = class VoiceToolDispatchService {
+    constructor(agentSessionsService, chatService, toolsService) {
+        this.agentSessionsService = agentSessionsService;
+        this.chatService = chatService;
+        this.toolsService = toolsService;
+    }
+    setDelegate(delegate) {
+        this._delegate = delegate;
+    }
+    static getActionLabel(name) {
+        return ACTION_LABELS[name] ?? ( localize(7773, "Working..."));
+    }
+    get _agentModeOptions() {
+        const allTools = {};
+        for (const tool of this.toolsService.getTools(undefined)) {
+            allTools[tool.id] = true;
+        }
+        return {
+            modeInfo: {
+                kind: ChatModeKind.Agent,
+                isBuiltin: true,
+                modeInstructions: undefined,
+                telemetryModeId: "agent",
+                applyCodeBlockSuggestionId: undefined
+            },
+            instructionContext: {
+                modeKind: ChatModeKind.Agent,
+                enabledTools: allTools
+            },
+            userSelectedTools: constObservable(allTools)
+        };
+    }
+    async dispatchToolCall(toolCall) {
+        const delegate = this._delegate;
+        if (!delegate) {
+            return "error: no delegate set";
+        }
+        const args = toolCall.args;
+        const argString = k => {
+            const v = args[k];
+            return typeof v === "string" ? v : "";
+        };
+        switch (toolCall.name) {
+        case "send_to_chat":
+            {
+                const text = argString("text");
+                if (text) {
+                    if (!delegate.acceptInput(text)) {
+                        const resource = await delegate.getCurrentSessionResource();
+                        if (resource) {
+                            await this.chatService.sendRequest(resource, text, this._agentModeOptions);
+                        } else {
+                            const ref = this.chatService.startNewLocalSession(ChatAgentLocation.Chat);
+                            await this.chatService.sendRequest(ref.object.sessionResource, text, this._agentModeOptions);
+                            ref.dispose();
+                        }
+                    }
+                }
+                break;
+            }
+        case "new_sessions":
+            {
+                const sessions = args["sessions"];
+                const items = Array.isArray(sessions) ? sessions : [{
+                    text: argString("text")
+                }];
+                let firstResource;
+                for (const item of items) {
+                    const text = item.text;
+                    if (text) {
+                        const ref = this.chatService.startNewLocalSession(ChatAgentLocation.Chat);
+                        const resource = ref.object.sessionResource;
+                        if (!firstResource) {
+                            firstResource = resource;
+                        }
+                        await this.chatService.sendRequest(resource, text, this._agentModeOptions);
+                        ref.dispose();
+                    }
+                }
+                if (firstResource) {
+                    delegate.switchToSession(firstResource);
+                }
+                break;
+            }
+        case "focus_session":
+            {
+                const targetSessionId = argString("coding_session_id");
+                let targetResource;
+                if (targetSessionId) {
+                    const agentSession = this.agentSessionsService.model.sessions.find(s => !s.isArchived() && ( s.resource.toString()) === targetSessionId);
+                    targetResource = agentSession?.resource;
+                    if (!targetResource) {
+                        for (const chatModel of this.chatService.chatModels.get()) {
+                            if (( chatModel.sessionResource.toString()) === targetSessionId) {
+                                targetResource = chatModel.sessionResource;
+                                break;
+                            }
+                        }
+                    }
+                }
+                if (targetResource) {
+                    const currentResource = await delegate.getCurrentSessionResource();
+                    if (( targetResource.toString()) !== currentResource?.toString()) {
+                        delegate.switchToSession(targetResource);
+                    }
+                }
+                break;
+            }
+        case "approve_confirmation":
+        case "reject_confirmation":
+            {
+                const targetSessionId = argString("coding_session_id");
+                let model;
+                if (targetSessionId) {
+                    const agentSession = this.agentSessionsService.model.sessions.find(s => !s.isArchived() && ( s.resource.toString()) === targetSessionId);
+                    model = agentSession ? this.chatService.getSession(agentSession.resource) : undefined;
+                    if (!model) {
+                        for (const chatModel of this.chatService.chatModels.get()) {
+                            if (( chatModel.sessionResource.toString()) === targetSessionId) {
+                                model = chatModel;
+                                break;
+                            }
+                        }
+                    }
+                    if (!model && agentSession) {
+                        const cts = ( new CancellationTokenSource());
+                        const ref = await this.chatService.acquireOrLoadSession(agentSession.resource, ChatAgentLocation.Chat, cts.token, "voice-confirm").catch(() => undefined);
+                        cts.dispose();
+                        if (ref) {
+                            model = this.chatService.getSession(agentSession.resource);
+                            ref.dispose();
+                        }
+                    }
+                }
+                if (!model) {
+                    const res = await delegate.getCurrentSessionResource();
+                    model = res ? this.chatService.getSession(res) : undefined;
+                }
+                if (model) {
+                    const lastReq = model.getRequests().at(-1);
+                    if (lastReq?.response) {
+                        for (const part of lastReq.response.response.value) {
+                            if (part.kind === "toolInvocation") {
+                                const confirmed = toolCall.name === "approve_confirmation" ? IChatToolInvocation.confirmWith(part, {
+                                    type: ToolConfirmKind.UserAction
+                                }) : IChatToolInvocation.confirmWith(part, {
+                                    type: ToolConfirmKind.Denied
+                                });
+                                if (confirmed) {
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+                break;
+            }
+        case "auto_approve_session":
+            {
+                delegate.addAllAutoApprovedSessions();
+                break;
+            }
+        case "revoke_auto_approve":
+            {
+                const sessionResource = await delegate.getCurrentSessionResource();
+                if (sessionResource) {
+                    delegate.removeAutoApprovedSession(( sessionResource.toString()));
+                }
+                break;
+            }
+        case "get_session_info":
+            {
+                return await this._gatherSessionInfo();
+            }
+        case "get_session_changes":
+            {
+                const sessionId = typeof toolCall.args?.coding_session_id === "string" ? toolCall.args.coding_session_id : undefined;
+                return await this._gatherSessionChanges(sessionId);
+            }
+        case "get_session_thread":
+            {
+                const sessionId = typeof toolCall.args?.coding_session_id === "string" ? toolCall.args.coding_session_id : undefined;
+                const rawN = toolCall.args?.last_n_turns;
+                const lastN = typeof rawN === "number" && rawN > 0 ? Math.min(10, Math.floor(rawN)) : 3;
+                return await this._gatherSessionThread(sessionId, lastN);
+            }
+        }
+        return "ok";
+    }
+    async _gatherSessionInfo() {
+        const allSessions = this.agentSessionsService.model.sessions.filter(s => !s.isArchived());
+        const delegate = this._delegate;
+        const currentResource = await delegate?.getCurrentSessionResource();
+        const lastActivityOf = s => s.timing.lastRequestEnded ?? s.timing.lastRequestStarted ?? s.timing.created ?? 0;
+        const dayKey = ms => {
+            const d = ( new Date(ms));
+            return `${d.getFullYear()}-${d.getMonth()}-${d.getDate()}`;
+        };
+        const todayKey = dayKey(Date.now());
+        const withTiming = ( allSessions.map(s => ({
+            s,
+            t: lastActivityOf(s)
+        }))).filter(x => x.t > 0);
+        let filtered;
+        const todays = withTiming.filter(x => dayKey(x.t) === todayKey);
+        if (todays.length > 0) {
+            filtered = ( todays.map(x => x.s));
+        } else if (withTiming.length > 0) {
+            const mostRecent = withTiming.reduce((a, b) => (a.t >= b.t ? a : b));
+            const mostRecentKey = dayKey(mostRecent.t);
+            filtered = ( withTiming.filter(x => dayKey(x.t) === mostRecentKey).map(x => x.s));
+        } else {
+            filtered = [];
+        }
+        const sessionData = ( filtered.map(session => {
+            const model = this.chatService.getSession(session.resource);
+            const changes = getAgentChangesSummary(session.changes);
+            const lastReq = model?.getRequests().at(-1);
+            const lastResponseSummary = lastReq?.response?.response.value.filter(p => p.kind === "markdownContent").map(p => p.content.value).join(" ").slice(0, 500) || "";
+            const statusLabel = session.status === ChatSessionStatus.InProgress ? "working" : session.status === ChatSessionStatus.NeedsInput ? "waiting_for_input" : session.status === ChatSessionStatus.Completed ? "idle" : "unknown";
+            const isActive = currentResource?.toString() === ( session.resource.toString());
+            const lastActivity = lastActivityOf(session);
+            const minutesAgo = lastActivity ? Math.round((Date.now() - lastActivity) / 60000) : undefined;
+            return {
+                id: ( session.resource.toString()),
+                state: statusLabel,
+                is_active: isActive,
+                insertions: changes?.insertions ?? 0,
+                deletions: changes?.deletions ?? 0,
+                last_activity_minutes_ago: minutesAgo,
+                last_response_summary: lastResponseSummary
+            };
+        }));
+        return JSON.stringify({
+            sessions: sessionData
+        });
+    }
+    async _resolveSession(coding_session_id) {
+        const sessions = this.agentSessionsService.model.sessions.filter(s => !s.isArchived());
+        if (coding_session_id) {
+            const match = sessions.find(s => ( s.resource.toString()) === coding_session_id);
+            if (match) {
+                return match;
+            }
+        }
+        const currentResource = await this._delegate?.getCurrentSessionResource();
+        if (currentResource) {
+            const active = sessions.find(s => ( s.resource.toString()) === ( currentResource.toString()));
+            if (active) {
+                return active;
+            }
+        }
+        return sessions[0];
+    }
+    async _gatherSessionChanges(coding_session_id) {
+        const session = await this._resolveSession(coding_session_id);
+        if (!session) {
+            return JSON.stringify({
+                session_id: coding_session_id ?? null,
+                files: [],
+                note: "session_not_found"
+            });
+        }
+        const changes = session.changes;
+        const files = [];
+        let totalInsertions = 0;
+        let totalDeletions = 0;
+        let totalFiles = 0;
+        if (Array.isArray(changes)) {
+            for (const c of changes) {
+                const uri = c.modifiedUri ?? c.uri;
+                const path = uri ? this._formatPath(uri) : "(unknown)";
+                files.push({
+                    path,
+                    insertions: c.insertions,
+                    deletions: c.deletions
+                });
+                totalInsertions += c.insertions;
+                totalDeletions += c.deletions;
+            }
+            totalFiles = files.length;
+        } else if (changes && !Array.isArray(changes)) {
+            const summary = changes;
+            totalInsertions = summary.insertions;
+            totalDeletions = summary.deletions;
+            totalFiles = summary.files;
+        }
+        return JSON.stringify({
+            session_id: ( session.resource.toString()),
+            total_files: totalFiles,
+            total_insertions: totalInsertions,
+            total_deletions: totalDeletions,
+            files: files.slice(0, 20),
+            truncated: files.length > 20
+        });
+    }
+    async _gatherSessionThread(coding_session_id, lastN) {
+        const session = await this._resolveSession(coding_session_id);
+        if (!session) {
+            return JSON.stringify({
+                session_id: coding_session_id ?? null,
+                turns: [],
+                note: "session_not_found"
+            });
+        }
+        const model = this.chatService.getSession(session.resource);
+        if (!model) {
+            return JSON.stringify({
+                session_id: ( session.resource.toString()),
+                turns: [],
+                note: "chat_model_not_loaded"
+            });
+        }
+        const reqs = model.getRequests().slice(-lastN);
+        const turns = ( reqs.map(req => {
+            const userText = req.message.text || "";
+            const assistantText = req.response?.response.value.filter(p => p.kind === "markdownContent").map(p => p.content.value).join(" ").slice(0, 600) || "";
+            return {
+                user: userText.slice(0, 400),
+                assistant: assistantText
+            };
+        }));
+        return JSON.stringify({
+            session_id: ( session.resource.toString()),
+            turn_count: turns.length,
+            turns
+        });
+    }
+    _formatPath(uri) {
+        const parts = uri.path.split("/").filter(Boolean);
+        if (parts.length <= 2) {
+            return uri.path.replace(/^\//, "");
+        }
+        return parts.slice(-2).join("/");
+    }
+};
+VoiceToolDispatchService = ( __decorate([( __param(0, IAgentSessionsService)), ( __param(1, IChatService)), ( __param(2, ILanguageModelToolsService))], VoiceToolDispatchService));
+
+export { VoiceToolDispatchService };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/chatQueuePickerActionItem.js

@@ -41,7 +41,7 @@ let ChatQueuePickerActionItem = class ChatQueuePickerActionItem extends BaseActi
         this.contextKeyService = contextKeyService;
         this._altKeyPressed = false;
         const isSteerDefault = this._isSteerDefault();
-        this._primaryActionAction = this._register(( new Action("chat.queuePickerPrimary", isSteerDefault ? ( localize(7737, "Steer with Message")) : ( localize(7738, "Add to Queue")), ThemeIcon.asClassName(isSteerDefault ? Codicon.arrowUp : Codicon.add), !!this.contextKeyService.getContextKeyValue(ChatContextKeys.inputHasText.key), () => this._runDefaultAction())));
+        this._primaryActionAction = this._register(( new Action("chat.queuePickerPrimary", isSteerDefault ? ( localize(8317, "Steer with Message")) : ( localize(8318, "Add to Queue")), ThemeIcon.asClassName(isSteerDefault ? Codicon.newLine : Codicon.add), !!this.contextKeyService.getContextKeyValue(ChatContextKeys.inputHasText.key), () => this._runDefaultAction())));
         this._primaryAction = this._register(( new ActionViewItem(undefined, this._primaryActionAction, {
             icon: true,
             label: false
@@ -49,7 +49,7 @@ let ChatQueuePickerActionItem = class ChatQueuePickerActionItem extends BaseActi
         this._register(this.contextKeyService.onDidChangeContext(e => {
             this._primaryActionAction.enabled = !!this.contextKeyService.getContextKeyValue(ChatContextKeys.inputHasText.key);
         }));
-        const dropdownAction = this._register(( new Action("chat.queuePickerDropdown", ( localize(7739, "More Actions...")))));
+        const dropdownAction = this._register(( new Action("chat.queuePickerDropdown", ( localize(8319, "More Actions...")))));
         this._dropdown = this._register(( new ChevronActionWidgetDropdown(dropdownAction, {
             actionProvider: {
                 getActions: () => this._getDropdownActions()
@@ -77,8 +77,8 @@ let ChatQueuePickerActionItem = class ChatQueuePickerActionItem extends BaseActi
     }
     _updatePrimaryAction() {
         const isSteer = this._isEffectiveSteer();
-        this._primaryActionAction.label = isSteer ? ( localize(7737, "Steer with Message")) : ( localize(7738, "Add to Queue"));
-        this._primaryActionAction.class = ThemeIcon.asClassName(isSteer ? Codicon.arrowUp : Codicon.add);
+        this._primaryActionAction.label = isSteer ? ( localize(8317, "Steer with Message")) : ( localize(8318, "Add to Queue"));
+        this._primaryActionAction.class = ThemeIcon.asClassName(isSteer ? Codicon.newLine : Codicon.add);
     }
     _runDefaultAction() {
         const actionId = this._isEffectiveSteer() ? ChatSteerWithMessageAction.ID : ChatQueueMessageAction.ID;
@@ -134,7 +134,7 @@ let ChatQueuePickerActionItem = class ChatQueuePickerActionItem extends BaseActi
         const steerKeybinding = this.keybindingService.lookupKeybinding(ChatSteerWithMessageAction.ID, lookupContext, true);
         const queueAction = {
             id: ChatQueueMessageAction.ID,
-            label: ( localize(7738, "Add to Queue")),
+            label: ( localize(8318, "Add to Queue")),
             tooltip: "",
             enabled: true,
             checked: !isSteerDefault,
@@ -143,7 +143,7 @@ let ChatQueuePickerActionItem = class ChatQueuePickerActionItem extends BaseActi
             keybinding: queueKeybinding,
             hover: {
                 content: ( localize(
-                    7740,
+                    8320,
                     "Queue this message to send after the current request completes. The current response will finish uninterrupted before the queued message is sent."
                 ))
             },
@@ -153,16 +153,16 @@ let ChatQueuePickerActionItem = class ChatQueuePickerActionItem extends BaseActi
         };
         const steerAction = {
             id: ChatSteerWithMessageAction.ID,
-            label: ( localize(7737, "Steer with Message")),
+            label: ( localize(8317, "Steer with Message")),
             tooltip: "",
             enabled: true,
             checked: isSteerDefault,
-            icon: Codicon.arrowUp,
+            icon: Codicon.newLine,
             class: undefined,
             keybinding: steerKeybinding,
             hover: {
                 content: ( localize(
-                    7741,
+                    8321,
                     "Send this message at the next opportunity, signaling the current request to yield. The current response will stop and the new message will be sent immediately."
                 ))
             },
@@ -172,16 +172,20 @@ let ChatQueuePickerActionItem = class ChatQueuePickerActionItem extends BaseActi
         };
         const sendAction = {
             id: "_" + ChatSubmitAction.ID,
-            label: ( localize(7742, "Stop and Send")),
+            label: ( localize(8322, "Stop and Send")),
             tooltip: "",
             enabled: true,
             icon: Codicon.arrowRight,
             class: undefined,
             hover: {
-                content: ( localize(7743, "Cancel the current request and send this message immediately."))
+                content: ( localize(8323, "Cancel the current request and send this message immediately."))
             },
             run: () => {
-                this.commandService.executeCommand(ChatSubmitAction.ID);
+                this.commandService.executeCommand(ChatSubmitAction.ID, {
+                    acceptInputOptions: {
+                        cancelCurrentRequest: true
+                    }
+                });
             }
         };
         return [sendAction, queueAction, steerAction];

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/editor/agentHostInputCompletions.d.ts

@@ -36,4 +36,6 @@ export declare class AgentHostInputCompletions extends AgentHostInputCompletions
         context: IChatWidget;
     } | undefined;
     protected _buildItem(position: Position, item: IChatInputCompletionItem, widget: IChatWidget): CompletionItem;
+    private static _insertedRange;
+    private static _insertedTokenRange;
 }