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

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

@@ -2,19 +2,81 @@
 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 { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
 import { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
+import { Language } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { normalizeAgentsVoiceId, isVoiceCheckpointId } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/common/voiceClient/voiceClientService';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { isTerminalCloseCode, voiceCloseCodeInfo } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/common/voiceClient/voiceCloseCodes';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { getVoiceWebSocketUrl } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/voiceClient/voiceEndpoint';
 
 const PING_INTERVAL_MS = 25_000;
 const PONG_TIMEOUT_MS = 10_000;
 const FAST_RETRY_COUNT = 3;
 const FAST_RETRY_DELAY_MS = 2_000;
-const SLOW_RETRY_DELAY_MS = 30_000;
-const MAX_RECONNECT_DURATION_MS = 30 * 60 * 1_000;
+const SLOW_RETRY_DELAY_MS = 10_000;
+const MAX_RECONNECT_DURATION_MS = 60_000;
+const TTS_SUPPORTED_LANGUAGE_BASES = ( new Set(["en", "de", "es", "fr", "it", "pt", "ja", "ko", "zh"]));
+const ASR_SUPPORTED_LANGUAGE_BASES = ( new Set([
+    "ar",
+    "cs",
+    "da",
+    "de",
+    "en",
+    "es",
+    "fi",
+    "fr",
+    "hi",
+    "hu",
+    "id",
+    "it",
+    "ja",
+    "ko",
+    "nb",
+    "nl",
+    "pl",
+    "pt",
+    "ro",
+    "ru",
+    "sv",
+    "th",
+    "tr",
+    "vi",
+    "zh"
+]));
+const DEFAULT_LANGUAGE = "en-US";
+function asOptionalString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function asOptionalNonEmptyString(value) {
+    const result = asOptionalString(value);
+    return result && result.length > 0 ? result : undefined;
+}
+function canonicalizeSupportedLanguage(value, supportedBases) {
+    const candidate = value?.trim();
+    if (!candidate || typeof Intl.getCanonicalLocales !== "function") {
+        return undefined;
+    }
+    try {
+        const canonical = Intl.getCanonicalLocales(candidate)[0];
+        return ( supportedBases.has(canonical.split("-")[0])) ? canonical : undefined;
+    } catch {
+        return undefined;
+    }
+}
+function resolveAutomaticVoiceLanguage(browserLanguage, displayLanguage) {
+    return canonicalizeSupportedLanguage(displayLanguage, ASR_SUPPORTED_LANGUAGE_BASES) ?? canonicalizeSupportedLanguage(browserLanguage, ASR_SUPPORTED_LANGUAGE_BASES) ?? DEFAULT_LANGUAGE;
+}
+function asTranscriptionStatus(value) {
+    return value === "partial" || value === "final" ? value : undefined;
+}
+function asTranscriptionRevision(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : undefined;
+}
 let VoiceClientService = class VoiceClientService extends Disposable {
     get isConnected() {
         return this._isConnected;
@@ -22,6 +84,9 @@ let VoiceClientService = class VoiceClientService extends Disposable {
     get isResuming() {
         return this._isResuming;
     }
+    get willReconnect() {
+        return this._reconnectTimer !== undefined;
+    }
     get currentSessionId() {
         return this._lastSessionId;
     }
@@ -33,12 +98,21 @@ let VoiceClientService = class VoiceClientService extends Disposable {
         this._reconnectAttempts = 0;
         this._isConnected = false;
         this._isResuming = false;
+        this._sessionStartedOnSocket = false;
         this._lastSentById = ( new Map());
-        this._lastSentActive = "";
+        this._invalidatedSessionIds = ( new Set());
         this._onTranscription = this._register(( new Emitter()));
         this.onTranscription = this._onTranscription.event;
         this._onAudioResponse = this._register(( new Emitter()));
         this.onAudioResponse = this._onAudioResponse.event;
+        this._onBargeIn = this._register(( new Emitter()));
+        this.onBargeIn = this._onBargeIn.event;
+        this._onNarrationAck = this._register(( new Emitter()));
+        this.onNarrationAck = this._onNarrationAck.event;
+        this._onNarrationUnblocked = this._register(( new Emitter()));
+        this.onNarrationUnblocked = this._onNarrationUnblocked.event;
+        this._onNarrationInterrupted = this._register(( new Emitter()));
+        this.onNarrationInterrupted = this._onNarrationInterrupted.event;
         this._onToolCall = this._register(( new Emitter()));
         this.onToolCall = this._onToolCall.event;
         this._onSpeechStarted = this._register(( new Emitter()));
@@ -49,16 +123,99 @@ let VoiceClientService = class VoiceClientService extends Disposable {
         this.onError = this._onError.event;
         this._onDidChangeConnectionState = this._register(( new Emitter()));
         this.onDidChangeConnectionState = this._onDidChangeConnectionState.event;
+        this._onFatalDisconnect = this._register(( new Emitter()));
+        this.onFatalDisconnect = this._onFatalDisconnect.event;
+        this._onConnectionIssue = this._register(( new Emitter()));
+        this.onConnectionIssue = this._onConnectionIssue.event;
+        this._onTurnAutoEnded = this._register(( new Emitter()));
+        this.onTurnAutoEnded = this._onTurnAutoEnded.event;
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration("agents.voice.turn.silenceMs") || e.affectsConfiguration("agents.voice.turn.stopPhrases") || e.affectsConfiguration("agents.voice.handsFree")) {
+                this._sendSetTurnConfig();
+            }
+            if (e.affectsConfiguration("agents.voice.voice")) {
+                this._sendSetVoice();
+            }
+            if (e.affectsConfiguration("agents.voice.language")) {
+                this._sendSetLanguage();
+            }
+        }));
+    }
+    _getVoice() {
+        return normalizeAgentsVoiceId(this._configurationService.getValue("agents.voice.voice"));
+    }
+    _sendSetVoice() {
+        if (this._ws?.readyState === WebSocket.OPEN) {
+            this._ws.send(JSON.stringify({
+                type: "set_voice",
+                voice: this._getVoice()
+            }));
+        }
+    }
+    _getLanguage() {
+        const configured = this._configurationService.getValue("agents.voice.language");
+        if (typeof configured === "string" && configured.trim().toLowerCase() !== "auto") {
+            const language = canonicalizeSupportedLanguage(configured, TTS_SUPPORTED_LANGUAGE_BASES);
+            if (language) {
+                return language;
+            }
+            this._logService.warn(
+                `[voice] Unsupported agents.voice.language value '${configured}', falling back to ${DEFAULT_LANGUAGE}`
+            );
+            return DEFAULT_LANGUAGE;
+        }
+        return resolveAutomaticVoiceLanguage(this._window?.navigator.language, Language.value());
+    }
+    _sendSetLanguage() {
+        if (this._ws?.readyState === WebSocket.OPEN && this._sessionStartedOnSocket) {
+            this._ws.send(JSON.stringify({
+                type: "set_language",
+                language: this._getLanguage()
+            }));
+        }
+    }
+    _isExplicitlyConfigured(key) {
+        const inspected = this._configurationService.inspect(key);
+        return inspected.userValue !== undefined || inspected.userLocalValue !== undefined || inspected.userRemoteValue !== undefined || inspected.workspaceValue !== undefined || inspected.workspaceFolderValue !== undefined || inspected.applicationValue !== undefined;
+    }
+    _getTurnConfig() {
+        const cfg = this._configurationService;
+        const handsFree = cfg.getValue("agents.voice.handsFree") === true;
+        const silenceRaw = cfg.getValue("agents.voice.turn.silenceMs");
+        let silenceEnabled = typeof silenceRaw === "number" && silenceRaw > 0;
+        if (!handsFree && !this._isExplicitlyConfigured("agents.voice.turn.silenceMs")) {
+            silenceEnabled = false;
+        }
+        const silence_ms = silenceEnabled ? Math.round(silenceRaw) : 800;
+        const phrasesRaw = cfg.getValue("agents.voice.turn.stopPhrases");
+        const stop_phrases = Array.isArray(phrasesRaw) ? ( phrasesRaw.map(p => String(p).trim())).filter(p => p.length > 0) : [];
+        let phrasesEnabled = stop_phrases.length > 0;
+        if (!handsFree && !this._isExplicitlyConfigured("agents.voice.turn.stopPhrases")) {
+            phrasesEnabled = false;
+        }
+        const auto_end_mode = silenceEnabled && phrasesEnabled ? "both" : silenceEnabled ? "vad" : phrasesEnabled ? "phrase" : "off";
+        return {
+            auto_end_mode,
+            silence_ms,
+            stop_phrases: phrasesEnabled ? stop_phrases : [],
+            vad_gate_asr: true
+        };
+    }
+    _sendSetTurnConfig() {
+        if (this._ws?.readyState === WebSocket.OPEN) {
+            this._ws.send(JSON.stringify({
+                type: "set_turn_config",
+                turn_config: this._getTurnConfig()
+            }));
+        }
     }
     _getWsUrl() {
-        const configured = this._configurationService.getValue("agents.voice.backendUrl");
-        const url = typeof configured === "string" ? configured.trim() : "";
-        return url || this._productService.voiceWsUrl || "";
+        return getVoiceWebSocketUrl(this._configurationService, this._productService);
     }
     async connect(window, authToken) {
         this._window = window;
         this._authToken = authToken;
-        this._reconnectAttempts = 0;
+        this._resetReconnectBudget();
         this._connectWebSocket();
     }
     _connectWebSocket() {
@@ -71,15 +228,22 @@ let VoiceClientService = class VoiceClientService extends Disposable {
             this._logService.error(
                 "[voice] No voice WebSocket URL configured (set voiceWsUrl in product.json or agents.voice.backendUrl in settings)"
             );
+            this._onFatalDisconnect.fire({
+                code: 0,
+                reason: "",
+                kind: "fatal",
+                clientSide: true
+            });
+            this._cleanup();
             return;
         }
         const url = this._authToken ? `${baseUrl}?token=${encodeURIComponent(this._authToken)}` : baseUrl;
         const ws = new win.WebSocket(url);
         this._ws = ws;
+        this._sessionStartedOnSocket = false;
         ws.onopen = () => {
-            this._reconnectAttempts = 0;
-            this._reconnectStartedAt = undefined;
             this._isResuming = !!this._lastSessionId;
+            this._sessionStartedOnSocket = false;
             this._setConnected(true);
             this._startPing();
         };
@@ -95,38 +259,116 @@ let VoiceClientService = class VoiceClientService extends Disposable {
                 this._clearPongTimeout();
                 break;
             case "session_init":
-                if (!this._isResuming) {
-                    this._lastSessionId = msg.session_id;
-                }
+                this._resetReconnectBudget();
+                this._lastSessionId = msg.session_id;
+                this._isResuming = false;
                 this._onSessionInit.fire({
                     sessionId: msg.session_id ?? ""
                 });
                 break;
             case "session_resumed":
+                this._resetReconnectBudget();
                 this._lastSessionId = msg.session_id;
+                this._isResuming = false;
                 this._onSessionInit.fire({
                     sessionId: msg.session_id ?? ""
                 });
                 break;
             case "speech_started":
-                this._onSpeechStarted.fire({});
+                this._onSpeechStarted.fire({
+                    turnId: asOptionalString(msg.turn_id)
+                });
                 break;
-            case "transcription":
-                this._onTranscription.fire({
-                    text: msg.text ?? "",
-                    status: msg.status ?? "final",
-                    committed: msg.committed ?? ""
+            case "barge_in":
+                this._onBargeIn.fire({
+                    turnId: asOptionalString(msg.turn_id) ?? "",
+                    interruptedTurnId: msg.interrupted_turn_id ?? ""
                 });
                 break;
-            case "audio_response":
-                this._onAudioResponse.fire({
-                    audio: msg.audio ?? "",
-                    isFirstChunk: msg.is_first_chunk === undefined ? true : Boolean(msg.is_first_chunk),
-                    isFinal: msg.is_final ?? false,
-                    codingSessionId: msg.coding_session_id,
-                    transcript: msg.transcript
+            case "narration_ack":
+                {
+                    const disposition = msg.disposition === "busy" || msg.disposition === "invalid" || msg.disposition === "suppressed" ? msg.disposition : "accepted";
+                    this._onNarrationAck.fire({
+                        narrationId: msg.narration_id ?? "",
+                        codingSessionId: msg.coding_session_id ?? "",
+                        disposition,
+                        reason: msg.reason
+                    });
+                    break;
+                }
+            case "narration_unblocked":
+                this._onNarrationUnblocked.fire({
+                    narrationId: msg.narration_id ?? "",
+                    codingSessionId: msg.coding_session_id ?? ""
+                });
+                break;
+            case "narration_interrupted":
+                this._onNarrationInterrupted.fire({
+                    narrationId: msg.narration_id ?? "",
+                    codingSessionId: msg.coding_session_id ?? "",
+                    ...(typeof msg.retryable === "boolean" ? {
+                        retryable: msg.retryable
+                    } : {}),
+                    ...(msg.reason ? {
+                        reason: msg.reason
+                    } : {})
                 });
                 break;
+            case "transcription":
+                {
+                    const status = msg.status === undefined ? "final" : asTranscriptionStatus(msg.status);
+                    const turnId = msg.turn_id === undefined ? undefined : asOptionalNonEmptyString(msg.turn_id);
+                    const revision = msg.revision === undefined ? undefined : asTranscriptionRevision(msg.revision);
+                    if (!status || (msg.turn_id !== undefined && !turnId) || (msg.revision !== undefined && (!turnId || revision === undefined))) {
+                        break;
+                    }
+                    this._onTranscription.fire({
+                        text: asOptionalString(msg.text) ?? "",
+                        status,
+                        committed: asOptionalString(msg.committed) ?? "",
+                        turnId,
+                        revision
+                    });
+                    break;
+                }
+            case "audio_response":
+                {
+                    const requestId = asOptionalString(msg.request_id);
+                    const checkpointId = isVoiceCheckpointId(msg.checkpoint_id) ? msg.checkpoint_id : undefined;
+                    const sequence = typeof msg.sequence === "number" && Number.isSafeInteger(msg.sequence) && msg.sequence > 0 ? msg.sequence : undefined;
+                    const narrationKind = msg.narration_kind === "response" || msg.narration_kind === "confirmation" || msg.narration_kind === "checkpoint" ? msg.narration_kind : undefined;
+                    const playbackId = asOptionalString(msg.playback_id);
+                    if (narrationKind === "checkpoint") {
+                        this._logService.info(
+                            `[voice] checkpoint audio request=${requestId ?? "none"} stage=${checkpointId ?? "none"} sequence=${sequence ?? "none"} first=${msg.is_first_chunk === undefined ? true : Boolean(msg.is_first_chunk)} final=${Boolean(msg.is_final)}`
+                        );
+                    }
+                    this._onAudioResponse.fire({
+                        audio: msg.audio ?? "",
+                        isFirstChunk: msg.is_first_chunk === undefined ? true : Boolean(msg.is_first_chunk),
+                        isFinal: msg.is_final ?? false,
+                        codingSessionId: msg.coding_session_id,
+                        transcript: msg.transcript,
+                        turnId: asOptionalString(msg.turn_id),
+                        responseId: msg.narration_id ?? asOptionalString(msg.turn_id),
+                        ...(requestId ? {
+                            requestId
+                        } : {}),
+                        ...(checkpointId ? {
+                            checkpointId
+                        } : {}),
+                        ...(sequence !== undefined ? {
+                            sequence
+                        } : {}),
+                        ...(narrationKind ? {
+                            narrationKind
+                        } : {}),
+                        ...(playbackId ? {
+                            playbackId
+                        } : {})
+                    });
+                    break;
+                }
             case "tool_call":
                 this._onToolCall.fire({
                     callId: msg.call_id ?? "",
@@ -134,6 +376,15 @@ let VoiceClientService = class VoiceClientService extends Disposable {
                     args: msg.args ?? {}
                 });
                 break;
+            case "turn_auto_ended":
+                {
+                    const reason = msg.reason === "stop_phrase" ? "stop_phrase" : "vad_silence";
+                    this._onTurnAutoEnded.fire({
+                        reason,
+                        turnId: asOptionalString(msg.turn_id) ?? ""
+                    });
+                    break;
+                }
             case "error":
                 this._onError.fire(msg.detail ?? "Unknown error");
                 break;
@@ -143,19 +394,20 @@ let VoiceClientService = class VoiceClientService extends Disposable {
             this._onError.fire("WebSocket error");
         };
         ws.onclose = evt => {
-            this._logService.warn("[voice] ws.onclose", {
-                code: evt.code,
-                reason: evt.reason,
-                wasClean: evt.wasClean
-            });
+            this._logService.trace(
+                `[voice] ws.onclose code=${evt.code} reason=${evt.reason ?? ""} wasClean=${evt.wasClean}`
+            );
             if (this._ws === ws) {
-                if (evt.code === 1000 || evt.code === 1001) {
-                    this._cleanup();
-                    return;
-                }
-                if (evt.code === 4001 || evt.code === 4008 || evt.code === 4029) {
-                    this._logService.warn(`[voice] fatal close code ${evt.code}: ${evt.reason}, not reconnecting`);
-                    this._onError.fire(evt.reason || `Connection rejected (code ${evt.code})`);
+                if (isTerminalCloseCode(evt.code)) {
+                    const kind = voiceCloseCodeInfo(evt.code)?.kind ?? "fatal";
+                    this._logService.warn(
+                        `[voice] terminal close ${evt.code} (${kind}): ${evt.reason}, not reconnecting`
+                    );
+                    this._onFatalDisconnect.fire({
+                        code: evt.code,
+                        reason: evt.reason ?? "",
+                        kind
+                    });
                     this._cleanup();
                     return;
                 }
@@ -164,28 +416,45 @@ let VoiceClientService = class VoiceClientService extends Disposable {
                 }
                 const elapsed = Date.now() - this._reconnectStartedAt;
                 if (elapsed >= MAX_RECONNECT_DURATION_MS) {
-                    this._logService.warn("[voice] reconnect timeout after 30 minutes, giving up");
+                    this._logService.warn(
+                        `[voice] reconnect budget of ${MAX_RECONNECT_DURATION_MS}ms exhausted, giving up`
+                    );
+                    this._onFatalDisconnect.fire({
+                        code: evt.code,
+                        reason: evt.reason ?? "",
+                        kind: "fatal"
+                    });
                     this._cleanup();
                     return;
                 }
                 this._reconnectAttempts++;
-                this._setConnected(false);
                 this._stopPing();
                 this._ws = undefined;
                 const delay = this._reconnectAttempts <= FAST_RETRY_COUNT ? FAST_RETRY_DELAY_MS : SLOW_RETRY_DELAY_MS;
-                this._logService.warn(`[voice] reconnecting in ${delay}ms (attempt ${this._reconnectAttempts})`);
-                this._reconnectTimer = setTimeout(() => this._connectWebSocket(), delay);
+                this._logService.warn(
+                    `[voice] ws closed abnormally (code=${evt.code} reason=${evt.reason || "none"} wasClean=${evt.wasClean}); reconnecting in ${delay}ms (attempt ${this._reconnectAttempts})`
+                );
+                this._reconnectTimer = setTimeout(() => {
+                    this._reconnectTimer = undefined;
+                    this._connectWebSocket();
+                }, delay);
+                this._setConnected(false);
+                this._onConnectionIssue.fire({
+                    code: evt.code,
+                    reason: evt.reason ?? ""
+                });
             }
         };
     }
     disconnect() {
-        this._logService.warn("[voice] disconnect() called", ( new Error("disconnect trace")).stack);
+        this._logService.trace("[voice] disconnect() called");
         if (this._ws && this._ws.readyState < WebSocket.CLOSING) {
             this._ws.close();
         }
         this._cleanup();
     }
     _cleanup() {
+        this._resetReconnectBudget();
         this._stopPing();
         if (this._reconnectTimer) {
             clearTimeout(this._reconnectTimer);
@@ -197,12 +466,18 @@ let VoiceClientService = class VoiceClientService extends Disposable {
         }
         this._pendingContext = undefined;
         this._ws = undefined;
+        this._sessionStartedOnSocket = false;
         this._window = undefined;
         this._lastSessionId = undefined;
+        this._isResuming = false;
         this._lastSentById.clear();
-        this._lastSentActive = "";
+        this._invalidatedSessionIds.clear();
         this._setConnected(false);
     }
+    _resetReconnectBudget() {
+        this._reconnectAttempts = 0;
+        this._reconnectStartedAt = undefined;
+    }
     _startPing() {
         this._stopPing();
         const win = this._window ?? mainWindow;
@@ -237,11 +512,15 @@ let VoiceClientService = class VoiceClientService extends Disposable {
             this._onDidChangeConnectionState.fire(connected);
         }
     }
-    sendPttStart(turnId) {
+    sendPttStart(turnId, options) {
         if (this._ws?.readyState === WebSocket.OPEN) {
             this._ws.send(JSON.stringify({
                 type: "ptt_start",
-                turn_id: turnId
+                turn_id: turnId,
+                has_active_session: options.hasActiveSession,
+                ...(options.passive ? {
+                    passive: true
+                } : {})
             }));
         }
     }
@@ -299,13 +578,11 @@ let VoiceClientService = class VoiceClientService extends Disposable {
         }
     }
     invalidateSessionCache(sessionId) {
-        this._lastSentById.delete(sessionId);
+        this._invalidatedSessionIds.add(sessionId);
     }
     _sendDelta(context) {
         const currentIds = ( new Set(( context.sessions.map(s => s.id))));
         const removes = [...( this._lastSentById.keys())].filter(id => !( currentIds.has(id)));
-        const activeKey = context.active_session ? stableStringify(context.active_session) : "";
-        const activeChanged = activeKey !== this._lastSentActive;
         const upserts = [];
         for (const session of context.sessions) {
             const current = session;
@@ -317,22 +594,37 @@ let VoiceClientService = class VoiceClientService extends Disposable {
                     id: session.id
                 };
                 let hasChanges = false;
-                for (const key of ( Object.keys(current))) {
-                    if (key === "id") {
-                        continue;
+                if (( this._invalidatedSessionIds.has(session.id))) {
+                    for (const key of ( Object.keys(current))) {
+                        if (key !== "id") {
+                            patch[key] = current[key] ?? null;
+                            hasChanges = true;
+                        }
                     }
-                    if (stableStringify(current[key]) !== stableStringify(prev[key])) {
-                        patch[key] = current[key];
-                        hasChanges = true;
+                    for (const key of ( Object.keys(prev))) {
+                        if (key !== "id" && (!Object.prototype.hasOwnProperty.call(current, key) || current[key] === undefined)) {
+                            patch[key] = null;
+                            hasChanges = true;
+                        }
                     }
-                }
-                for (const key of ( Object.keys(prev))) {
-                    if (key === "id") {
-                        continue;
+                } else {
+                    for (const key of ( Object.keys(current))) {
+                        if (key === "id") {
+                            continue;
+                        }
+                        if (stableStringify(current[key]) !== stableStringify(prev[key])) {
+                            patch[key] = current[key];
+                            hasChanges = true;
+                        }
                     }
-                    if (!Object.prototype.hasOwnProperty.call(current, key) || current[key] === undefined) {
-                        patch[key] = null;
-                        hasChanges = true;
+                    for (const key of ( Object.keys(prev))) {
+                        if (key === "id") {
+                            continue;
+                        }
+                        if (!Object.prototype.hasOwnProperty.call(current, key) || current[key] === undefined) {
+                            patch[key] = null;
+                            hasChanges = true;
+                        }
                     }
                 }
                 if (!Object.prototype.hasOwnProperty.call(patch, "agent_state")) {
@@ -349,7 +641,7 @@ let VoiceClientService = class VoiceClientService extends Disposable {
                 }
             }
         }
-        if (upserts.length === 0 && removes.length === 0 && !activeChanged) {
+        if (upserts.length === 0 && removes.length === 0) {
             return;
         }
         for (const session of context.sessions) {
@@ -360,23 +652,25 @@ let VoiceClientService = class VoiceClientService extends Disposable {
                 }
             }
             this._lastSentById.set(session.id, obj);
+            this._invalidatedSessionIds.delete(session.id);
         }
         for (const id of removes) {
             this._lastSentById.delete(id);
+            this._invalidatedSessionIds.delete(id);
         }
-        this._lastSentActive = activeKey;
         this._ws.send(JSON.stringify({
             type: "session_context",
             mode: "delta",
             upserts,
-            removes,
-            ...(activeChanged && context.active_session ? {
-                active_session: context.active_session
-            } : {})
+            removes
         }));
+        this._logService.trace(`[voice] _sendDelta upserts=[${( upserts.map(
+    u => `${String(u.id).slice(-8)}:${u.agent_state ?? "(no-state)"}${Object.prototype.hasOwnProperty.call(u, "agent_state_detail") ? "+detail" : ""}${Object.prototype.hasOwnProperty.call(u, "last_response_summary") && u.last_response_summary ? "+summary" : ""}`
+)).join(", ")}] removes=${removes.length}`);
     }
     _seedTracking(context) {
         this._lastSentById.clear();
+        this._invalidatedSessionIds.clear();
         for (const session of context.sessions) {
             const obj = {};
             for (const [k, v] of Object.entries(session)) {
@@ -386,7 +680,6 @@ let VoiceClientService = class VoiceClientService extends Disposable {
             }
             this._lastSentById.set(session.id, obj);
         }
-        this._lastSentActive = context.active_session ? stableStringify(context.active_session) : "";
     }
     sendToolResult(callId, result) {
         if (this._ws?.readyState === WebSocket.OPEN) {
@@ -397,6 +690,57 @@ let VoiceClientService = class VoiceClientService extends Disposable {
             }));
         }
     }
+    sendNarrationPlaybackComplete(codingSessionId, narrationId, playbackId) {
+        if (this._ws?.readyState === WebSocket.OPEN && this._sessionStartedOnSocket) {
+            this._ws.send(JSON.stringify({
+                type: "narration_playback_complete",
+                coding_session_id: codingSessionId,
+                narration_id: narrationId,
+                playback_id: playbackId
+            }));
+        }
+    }
+    requestNarration(
+        codingSessionId,
+        kind,
+        text,
+        narrationId,
+        checkpoint,
+        confirmationType,
+        pending
+    ) {
+        if (this._ws?.readyState === WebSocket.OPEN && this._sessionStartedOnSocket) {
+            const id = narrationId ?? generateUuid();
+            this._ws.send(JSON.stringify({
+                type: "request_narration",
+                coding_session_id: codingSessionId,
+                kind,
+                text,
+                narration_id: id,
+                ...(checkpoint ? {
+                    request_id: checkpoint.requestId,
+                    checkpoint_id: checkpoint.checkpointId,
+                    sequence: checkpoint.sequence
+                } : {}),
+                ...(kind === "confirmation" && confirmationType ? {
+                    confirmation_type: confirmationType
+                } : {}),
+                ...(pending ? {
+                    pending_id: pending.pendingId
+                } : {})
+            }));
+            this._logService.trace(
+                `[voice] request_narration kind=${kind} id=${codingSessionId.slice(-32)} narration_id=${id.slice(0, 8)}${narrationId ? " (retry)" : ""}`
+            );
+            if (checkpoint) {
+                this._logService.info(
+                    `[voice] checkpoint sent request=${checkpoint.requestId} stage=${checkpoint.checkpointId} sequence=${checkpoint.sequence}`
+                );
+            }
+            return id;
+        }
+        return undefined;
+    }
     sendSessionStateChange(sessionId, newState, _label, detail, lastResponseSummary) {
         if (this._ws?.readyState === WebSocket.OPEN) {
             const payload = {
@@ -414,29 +758,52 @@ let VoiceClientService = class VoiceClientService extends Disposable {
         }
     }
     stopSpeaking() {}
-    sendStartSession(context, machineId, priorTimeline) {
+    sendStartSession(context, machineId, priorTimeline, turnConfigOverride, voiceInstructions) {
         if (this._ws?.readyState === WebSocket.OPEN) {
-            this._seedTracking(context);
+            const sessionContext = {
+                ...context,
+                display_locale: this._getLanguage()
+            };
+            this._seedTracking(sessionContext);
             const payload = {
                 type: "start_session",
-                session_context: context,
-                machine_id: machineId
+                session_context: sessionContext,
+                machine_id: machineId,
+                turn_config: turnConfigOverride ?? this._getTurnConfig(),
+                voice: this._getVoice(),
+                auto_narrate: false
             };
             if (priorTimeline && priorTimeline.length > 0) {
                 payload.prior_timeline = priorTimeline;
             }
+            if (voiceInstructions) {
+                payload.voice_instructions = voiceInstructions;
+            }
             this._ws.send(JSON.stringify(payload));
+            this._sessionStartedOnSocket = true;
         }
     }
-    sendResumeSession(context, machineId) {
+    sendResumeSession(context, machineId, voiceInstructions) {
         if (this._ws?.readyState === WebSocket.OPEN && this._lastSessionId) {
-            this._seedTracking(context);
-            this._ws.send(JSON.stringify({
+            const sessionContext = {
+                ...context,
+                display_locale: this._getLanguage()
+            };
+            this._seedTracking(sessionContext);
+            const payload = {
                 type: "resume_session",
                 session_id: this._lastSessionId,
-                session_context: context,
-                machine_id: machineId
-            }));
+                session_context: sessionContext,
+                machine_id: machineId,
+                turn_config: this._getTurnConfig(),
+                voice: this._getVoice(),
+                auto_narrate: false
+            };
+            if (voiceInstructions) {
+                payload.voice_instructions = voiceInstructions;
+            }
+            this._ws.send(JSON.stringify(payload));
+            this._sessionStartedOnSocket = true;
         }
     }
     async submitFeedback(payload) {
@@ -501,4 +868,4 @@ function stableStringify(value) {
     return "{" + ( keys.map(k => JSON.stringify(k) + ":" + stableStringify(value[k]))).join(",") + "}";
 }
 
-export { VoiceClientService };
+export { VoiceClientService, resolveAutomaticVoiceLanguage };