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

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

@@ -0,0 +1,504 @@
+
+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 { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
+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 '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+
+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;
+let VoiceClientService = class VoiceClientService extends Disposable {
+    get isConnected() {
+        return this._isConnected;
+    }
+    get isResuming() {
+        return this._isResuming;
+    }
+    get currentSessionId() {
+        return this._lastSessionId;
+    }
+    constructor(_configurationService, _logService, _productService) {
+        super();
+        this._configurationService = _configurationService;
+        this._logService = _logService;
+        this._productService = _productService;
+        this._reconnectAttempts = 0;
+        this._isConnected = false;
+        this._isResuming = false;
+        this._lastSentById = ( new Map());
+        this._lastSentActive = "";
+        this._onTranscription = this._register(( new Emitter()));
+        this.onTranscription = this._onTranscription.event;
+        this._onAudioResponse = this._register(( new Emitter()));
+        this.onAudioResponse = this._onAudioResponse.event;
+        this._onToolCall = this._register(( new Emitter()));
+        this.onToolCall = this._onToolCall.event;
+        this._onSpeechStarted = this._register(( new Emitter()));
+        this.onSpeechStarted = this._onSpeechStarted.event;
+        this._onSessionInit = this._register(( new Emitter()));
+        this.onSessionInit = this._onSessionInit.event;
+        this._onError = this._register(( new Emitter()));
+        this.onError = this._onError.event;
+        this._onDidChangeConnectionState = this._register(( new Emitter()));
+        this.onDidChangeConnectionState = this._onDidChangeConnectionState.event;
+    }
+    _getWsUrl() {
+        const configured = this._configurationService.getValue("agents.voice.backendUrl");
+        const url = typeof configured === "string" ? configured.trim() : "";
+        return url || this._productService.voiceWsUrl || "";
+    }
+    async connect(window, authToken) {
+        this._window = window;
+        this._authToken = authToken;
+        this._reconnectAttempts = 0;
+        this._connectWebSocket();
+    }
+    _connectWebSocket() {
+        const win = this._window;
+        if (!win) {
+            return;
+        }
+        const baseUrl = this._getWsUrl();
+        if (!baseUrl) {
+            this._logService.error(
+                "[voice] No voice WebSocket URL configured (set voiceWsUrl in product.json or agents.voice.backendUrl in settings)"
+            );
+            return;
+        }
+        const url = this._authToken ? `${baseUrl}?token=${encodeURIComponent(this._authToken)}` : baseUrl;
+        const ws = new win.WebSocket(url);
+        this._ws = ws;
+        ws.onopen = () => {
+            this._reconnectAttempts = 0;
+            this._reconnectStartedAt = undefined;
+            this._isResuming = !!this._lastSessionId;
+            this._setConnected(true);
+            this._startPing();
+        };
+        ws.onmessage = evt => {
+            let msg;
+            try {
+                msg = JSON.parse(evt.data);
+            } catch {
+                return;
+            }
+            switch (msg.type) {
+            case "pong":
+                this._clearPongTimeout();
+                break;
+            case "session_init":
+                if (!this._isResuming) {
+                    this._lastSessionId = msg.session_id;
+                }
+                this._onSessionInit.fire({
+                    sessionId: msg.session_id ?? ""
+                });
+                break;
+            case "session_resumed":
+                this._lastSessionId = msg.session_id;
+                this._onSessionInit.fire({
+                    sessionId: msg.session_id ?? ""
+                });
+                break;
+            case "speech_started":
+                this._onSpeechStarted.fire({});
+                break;
+            case "transcription":
+                this._onTranscription.fire({
+                    text: msg.text ?? "",
+                    status: msg.status ?? "final",
+                    committed: msg.committed ?? ""
+                });
+                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
+                });
+                break;
+            case "tool_call":
+                this._onToolCall.fire({
+                    callId: msg.call_id ?? "",
+                    name: msg.name ?? "",
+                    args: msg.args ?? {}
+                });
+                break;
+            case "error":
+                this._onError.fire(msg.detail ?? "Unknown error");
+                break;
+            }
+        };
+        ws.onerror = () => {
+            this._onError.fire("WebSocket error");
+        };
+        ws.onclose = evt => {
+            this._logService.warn("[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})`);
+                    this._cleanup();
+                    return;
+                }
+                if (!this._reconnectStartedAt) {
+                    this._reconnectStartedAt = Date.now();
+                }
+                const elapsed = Date.now() - this._reconnectStartedAt;
+                if (elapsed >= MAX_RECONNECT_DURATION_MS) {
+                    this._logService.warn("[voice] reconnect timeout after 30 minutes, giving up");
+                    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);
+            }
+        };
+    }
+    disconnect() {
+        this._logService.warn("[voice] disconnect() called", ( new Error("disconnect trace")).stack);
+        if (this._ws && this._ws.readyState < WebSocket.CLOSING) {
+            this._ws.close();
+        }
+        this._cleanup();
+    }
+    _cleanup() {
+        this._stopPing();
+        if (this._reconnectTimer) {
+            clearTimeout(this._reconnectTimer);
+            this._reconnectTimer = undefined;
+        }
+        if (this._contextSendTimer) {
+            clearTimeout(this._contextSendTimer);
+            this._contextSendTimer = undefined;
+        }
+        this._pendingContext = undefined;
+        this._ws = undefined;
+        this._window = undefined;
+        this._lastSessionId = undefined;
+        this._lastSentById.clear();
+        this._lastSentActive = "";
+        this._setConnected(false);
+    }
+    _startPing() {
+        this._stopPing();
+        const win = this._window ?? mainWindow;
+        this._pingTimer = win.setInterval(() => {
+            if (this._ws?.readyState === WebSocket.OPEN) {
+                this._ws.send(JSON.stringify({
+                    type: "ping"
+                }));
+                this._pongTimer = setTimeout(() => {
+                    this._logService.warn("[voice] pong timeout — server unreachable, reconnecting");
+                    this._ws?.close(4000, "pong timeout");
+                }, PONG_TIMEOUT_MS);
+            }
+        }, PING_INTERVAL_MS);
+    }
+    _stopPing() {
+        if (this._pingTimer) {
+            (this._window ?? mainWindow).clearInterval(this._pingTimer);
+            this._pingTimer = undefined;
+        }
+        this._clearPongTimeout();
+    }
+    _clearPongTimeout() {
+        if (this._pongTimer) {
+            clearTimeout(this._pongTimer);
+            this._pongTimer = undefined;
+        }
+    }
+    _setConnected(connected) {
+        if (this._isConnected !== connected) {
+            this._isConnected = connected;
+            this._onDidChangeConnectionState.fire(connected);
+        }
+    }
+    sendPttStart(turnId) {
+        if (this._ws?.readyState === WebSocket.OPEN) {
+            this._ws.send(JSON.stringify({
+                type: "ptt_start",
+                turn_id: turnId
+            }));
+        }
+    }
+    sendPttAudioChunk(audio) {
+        if (this._ws?.readyState === WebSocket.OPEN) {
+            this._ws.send(JSON.stringify({
+                type: "ptt_audio_chunk",
+                audio
+            }));
+        }
+    }
+    sendPttEnd() {
+        if (this._ws?.readyState === WebSocket.OPEN) {
+            this._ws.send(JSON.stringify({
+                type: "ptt_end"
+            }));
+        }
+    }
+    sendPttDiagnostic(turnId, metrics) {
+        if (this._ws?.readyState === WebSocket.OPEN) {
+            this._ws.send(JSON.stringify({
+                type: "ptt_diagnostic",
+                turn_id: turnId,
+                metrics
+            }));
+        }
+    }
+    sendSessionContext(context) {
+        if (!this._isConnected) {
+            return;
+        }
+        this._pendingContext = context;
+        if (this._contextSendTimer) {
+            clearTimeout(this._contextSendTimer);
+        }
+        this._contextSendTimer = setTimeout(() => {
+            this._contextSendTimer = undefined;
+            const pending = this._pendingContext;
+            this._pendingContext = undefined;
+            if (pending && this._ws?.readyState === WebSocket.OPEN) {
+                this._sendDelta(pending);
+            }
+        }, 500);
+    }
+    flushSessionContext() {
+        if (!this._contextSendTimer) {
+            return;
+        }
+        clearTimeout(this._contextSendTimer);
+        this._contextSendTimer = undefined;
+        const pending = this._pendingContext;
+        this._pendingContext = undefined;
+        if (pending && this._ws?.readyState === WebSocket.OPEN) {
+            this._sendDelta(pending);
+        }
+    }
+    invalidateSessionCache(sessionId) {
+        this._lastSentById.delete(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;
+            const prev = this._lastSentById.get(session.id);
+            if (!prev) {
+                upserts.push(current);
+            } else {
+                const patch = {
+                    id: session.id
+                };
+                let hasChanges = false;
+                for (const key of ( Object.keys(current))) {
+                    if (key === "id") {
+                        continue;
+                    }
+                    if (stableStringify(current[key]) !== stableStringify(prev[key])) {
+                        patch[key] = current[key];
+                        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")) {
+                    if (Object.prototype.hasOwnProperty.call(patch, "agent_state_detail")) {
+                        delete patch.agent_state_detail;
+                    }
+                    if (Object.prototype.hasOwnProperty.call(patch, "last_response_summary")) {
+                        delete patch.last_response_summary;
+                    }
+                    hasChanges = ( ( Object.keys(patch)).some(k => k !== "id"));
+                }
+                if (hasChanges) {
+                    upserts.push(patch);
+                }
+            }
+        }
+        if (upserts.length === 0 && removes.length === 0 && !activeChanged) {
+            return;
+        }
+        for (const session of context.sessions) {
+            const obj = {};
+            for (const [k, v] of Object.entries(session)) {
+                if (v !== undefined) {
+                    obj[k] = v;
+                }
+            }
+            this._lastSentById.set(session.id, obj);
+        }
+        for (const id of removes) {
+            this._lastSentById.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
+            } : {})
+        }));
+    }
+    _seedTracking(context) {
+        this._lastSentById.clear();
+        for (const session of context.sessions) {
+            const obj = {};
+            for (const [k, v] of Object.entries(session)) {
+                if (v !== undefined) {
+                    obj[k] = v;
+                }
+            }
+            this._lastSentById.set(session.id, obj);
+        }
+        this._lastSentActive = context.active_session ? stableStringify(context.active_session) : "";
+    }
+    sendToolResult(callId, result) {
+        if (this._ws?.readyState === WebSocket.OPEN) {
+            this._ws.send(JSON.stringify({
+                type: "tool_result",
+                call_id: callId,
+                result
+            }));
+        }
+    }
+    sendSessionStateChange(sessionId, newState, _label, detail, lastResponseSummary) {
+        if (this._ws?.readyState === WebSocket.OPEN) {
+            const payload = {
+                type: "session_state_change",
+                session_id: sessionId,
+                new_state: newState
+            };
+            if (detail) {
+                payload.detail = detail;
+            }
+            if (lastResponseSummary) {
+                payload.last_response_summary = lastResponseSummary;
+            }
+            this._ws.send(JSON.stringify(payload));
+        }
+    }
+    stopSpeaking() {}
+    sendStartSession(context, machineId, priorTimeline) {
+        if (this._ws?.readyState === WebSocket.OPEN) {
+            this._seedTracking(context);
+            const payload = {
+                type: "start_session",
+                session_context: context,
+                machine_id: machineId
+            };
+            if (priorTimeline && priorTimeline.length > 0) {
+                payload.prior_timeline = priorTimeline;
+            }
+            this._ws.send(JSON.stringify(payload));
+        }
+    }
+    sendResumeSession(context, machineId) {
+        if (this._ws?.readyState === WebSocket.OPEN && this._lastSessionId) {
+            this._seedTracking(context);
+            this._ws.send(JSON.stringify({
+                type: "resume_session",
+                session_id: this._lastSessionId,
+                session_context: context,
+                machine_id: machineId
+            }));
+        }
+    }
+    async submitFeedback(payload) {
+        const httpUrl = this._getWsUrl().replace("wss://", "https://").replace("ws://", "http://").replace(/\/realtime\/voice$/, "/feedback");
+        const headers = {
+            "Content-Type": "application/json"
+        };
+        if (this._authToken) {
+            headers["Authorization"] = `Bearer ${this._authToken}`;
+        }
+        try {
+            const response = await fetch(httpUrl, {
+                method: "POST",
+                headers,
+                body: JSON.stringify({
+                    feedback_text: payload.feedbackText,
+                    machine_id: payload.machineId,
+                    user_id: payload.userId,
+                    session_id: payload.sessionId,
+                    submission_id: payload.submissionId,
+                    transcript_history: ( payload.transcriptHistory.map(t => ({
+                        role: t.role,
+                        text: t.text,
+                        timestamp: t.timestamp
+                    }))),
+                    client_session_state: payload.clientSessionState,
+                    client_environment: payload.clientEnvironment,
+                    timestamp: payload.timestamp
+                })
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                return {
+                    ok: false,
+                    error: `HTTP ${response.status}: ${text}`
+                };
+            }
+            return {
+                ok: true
+            };
+        } catch (err) {
+            return {
+                ok: false,
+                error: String(err)
+            };
+        }
+    }
+    dispose() {
+        this.disconnect();
+        super.dispose();
+    }
+};
+VoiceClientService = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, ILogService)), ( __param(2, IProductService))], VoiceClientService));
+function stableStringify(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return "[" + ( value.map(stableStringify)).join(",") + "]";
+    }
+    const keys = ( Object.keys(value)).sort();
+    return "{" + ( keys.map(k => JSON.stringify(k) + ":" + stableStringify(value[k]))).join(",") + "}";
+}
+
+export { VoiceClientService };