@jingyi0605/codingns4dsh 0.2.1-beta.2 → 0.2.1-beta.4

package/data/build/dist/client/sherpa-voice-adapter.js

@@ -1,7 +1,14 @@
 import { CODINGNS_RPC_CHANNEL } from '../shared/contracts/transport.js';
-import { encodeVoiceStreamMessage, encodeVoiceStreamOpen } from '../shared/voice-stream.js';
+import { ASSISTANT_VOICE_EVENTS_PATH, ASSISTANT_VOICE_STREAM_PATH } from '../shared/voice-stream.js';
 import { BrowserVoiceDeviceManager } from './voice-device-manager.js';
 import { ClientVoiceCapture } from './voice-capture.js';
+import { createVoiceHttpError, VoiceStreamUploader } from './voice-stream-uploader.js';
+import { MossVoiceOutput } from './moss-voice-output.js';
+import { StreamingSentenceQueue } from './streaming-sentence-queue.js';
+import { readAssistantTtsParameters, readAssistantTtsSettings } from '../shared/assistant-tts.js';
+import { ClientVoiceDiagnostics } from './voice-diagnostics.js';
+import { voiceDiagnosticError } from '../shared/voice-diagnostics.js';
+import { VoiceChatUpdates } from './voice-chat-updates.js';
 /** 浏览器侧 Sherpa 数据面：设备和权限在 Client，识别在 Host。 */
 export class ClientSherpaVoiceAdapter {
     listeners = new Set();
@@ -11,12 +18,24 @@ export class ClientSherpaVoiceAdapter {
     capture;
     uploader;
     responseAbort;
+    leaseRequest;
+    stopOperation;
     active = false;
     hostLeaseActive = false;
     epoch = 0;
     configuredOwner;
     selectedInputDeviceId;
     selectedOutputDeviceId;
+    diagnostics;
+    trace = (event, fields) => this.diagnostics?.record(event, fields);
+    output = new MossVoiceOutput({ trace: this.trace, traceContext: () => ({ ownerId: this.configuredOwner, epoch: this.epoch, requestId: this.reply?.requestId }) });
+    reply;
+    chatStreaming = false;
+    clearOperation;
+    settleSpeech;
+    replySequence = 0;
+    microphoneMuted = false;
+    speakerMuted = false;
     constructor(options) {
         this.options = options;
         this.services = options.services;
@@ -33,13 +52,32 @@ export class ClientSherpaVoiceAdapter {
     get capabilities() {
         const secure = this.devices.snapshot().secureContext;
         const supported = secure && typeof globalThis.fetch === 'function' && typeof globalThis.ReadableStream === 'function';
-        return { realtime: supported, wakeWord: false, streamingInput: supported, streamingOutput: false, bargeIn: supported, speechToText: supported, textToSpeech: typeof globalThis.speechSynthesis !== 'undefined' };
+        const moss = readAssistantTtsSettings(this.services.settings?.getSnapshot().value?.assistant.tts).backend === 'moss-onnx';
+        const output = moss ? typeof globalThis.AudioContext === 'function' : typeof globalThis.speechSynthesis !== 'undefined';
+        return { realtime: supported, wakeWord: false, streamingInput: supported, streamingOutput: moss && output, bargeIn: supported, speechToText: supported, textToSpeech: output };
     }
     get ownerId() { return this.active ? this.configuredOwner : undefined; }
     get configuredOwnerId() { return this.configuredOwner; }
     get inputDeviceId() { return this.selectedInputDeviceId; }
     get outputDeviceId() { return this.selectedOutputDeviceId; }
-    get outputDeviceSupported() { return typeof globalThis.HTMLMediaElement?.prototype?.setSinkId === 'function'; }
+    get outputDeviceSupported() { return readAssistantTtsSettings(this.services.settings?.getSnapshot().value?.assistant.tts).backend === 'moss-onnx' && this.output.outputDeviceSupported; }
+    get isMicrophoneMuted() { return this.microphoneMuted; }
+    get isSpeakerMuted() { return this.speakerMuted; }
+    setMicrophoneMuted(muted) {
+        this.microphoneMuted = muted;
+        this.capture?.setMuted(muted);
+        if (muted)
+            this.emit({ type: 'partial', text: '', epoch: this.epoch });
+    }
+    setSpeakerMuted(muted) {
+        this.speakerMuted = muted;
+        this.output.setMuted(muted);
+        if (muted && readAssistantTtsSettings(this.services.settings?.getSnapshot().value?.assistant.tts).backend === 'browser') {
+            this.settleSpeech?.();
+            this.settleSpeech = undefined;
+            globalThis.speechSynthesis?.cancel();
+        }
+    }
     subscribe(listener) { this.listeners.add(listener); return () => this.listeners.delete(listener); }
     async enumerateInputDevices() { return (await this.devices.refresh()).inputs; }
     async enumerateOutputDevices() { return (await this.devices.refresh()).outputs; }
@@ -54,60 +92,117 @@ export class ClientSherpaVoiceAdapter {
     async selectOutputDevice(deviceId) {
         if (!this.outputDeviceSupported)
             throw new Error('当前浏览器不支持输出设备选择');
+        await this.output.setOutputDevice(deviceId);
         await this.devices.selectOutput(deviceId);
         this.selectedOutputDeviceId = this.devices.snapshot().selectedOutputId ?? undefined;
-        await this.applyOutputDevice();
     }
     async start(ownerId) {
+        if (this.stopOperation !== undefined)
+            await this.stopOperation;
         if (this.active)
             return;
         this.configuredOwner = ownerId?.trim() || this.configuredOwner;
         if (this.configuredOwner === '')
             throw new Error('全局语音租约缺少 ownerId');
-        const lease = await this.services.rpc.call(CODINGNS_RPC_CHANNEL, 'assistant/voice/start', { ownerId: this.configuredOwner });
-        if (!lease.ok)
-            throw new Error(lease.error.message);
-        if (isRecord(lease.value) && lease.value.unavailable === true)
-            throw new Error(typeof lease.value.message === 'string' ? lease.value.message : '本地 Sherpa 语音运行时不可用');
-        this.hostLeaseActive = true;
-        const snapshot = await this.devices.refresh();
-        if (!snapshot.secureContext)
-            throw new Error('当前页面不是安全上下文，请改用 HTTPS 或 localhost 后访问麦克风');
-        this.epoch += 1;
-        const epoch = this.epoch;
-        const uploader = new VoiceStreamUploader();
         const abort = new AbortController();
-        this.uploader = uploader;
+        const started = performance.now();
+        const callId = createClientId();
         this.responseAbort = abort;
         this.active = true;
-        this.emit({ type: 'state', state: 'loading', epoch });
+        this.setMicrophoneMuted(false);
+        this.setSpeakerMuted(false);
         try {
-            uploader.enqueue(encodeVoiceStreamOpen({ ownerId: this.configuredOwner, clientId: createClientId(), sampleRate: 16_000, channels: 1, encoding: 'pcm16le' }));
-            const response = await globalThis.fetch(resolveVoiceStreamUrl(), {
-                method: 'POST',
-                body: uploader.stream,
+            if (readAssistantTtsSettings(this.services.settings?.getSnapshot().value?.assistant.tts).backend === 'moss-onnx') {
+                await this.output.prepare();
+                if (this.output.outputDeviceSupported && this.selectedOutputDeviceId !== undefined)
+                    await this.output.setOutputDevice(this.selectedOutputDeviceId);
+            }
+            const leaseStarted = performance.now();
+            const leaseRequest = this.services.rpc.call(CODINGNS_RPC_CHANNEL, 'assistant/voice/start', { ownerId: this.configuredOwner, voiceSessionId: callId }, abort.signal);
+            this.leaseRequest = leaseRequest;
+            const lease = await leaseRequest.finally(() => { if (this.leaseRequest === leaseRequest)
+                this.leaseRequest = undefined; });
+            if (!lease.ok)
+                throw new Error(lease.error.message);
+            if (isRecord(lease.value) && lease.value.unavailable === true)
+                throw new Error(typeof lease.value.message === 'string' ? lease.value.message : '本地 Sherpa 语音运行时不可用');
+            if (abort.signal.aborted)
+                throw new Error('语音启动已取消');
+            this.hostLeaseActive = true;
+            // epoch 以 Host 租约为准，不能让刷新后的页面从 1 重新计数。
+            this.epoch = readEpoch(isRecord(lease.value) ? lease.value : {}, this.epoch + 1);
+            if (isRecord(lease.value) && lease.value.diagnosticsEnabled === true) {
+                this.diagnostics = new ClientVoiceDiagnostics(this.services, { ownerId: this.configuredOwner, callId });
+                this.trace('client.call.lease', { epoch: this.epoch, durationMs: performance.now() - leaseStarted });
+            }
+            this.emit({ type: 'state', state: 'loading', epoch: this.epoch });
+            const snapshot = await this.devices.refresh();
+            if (!snapshot.secureContext)
+                throw new Error('当前页面不是安全上下文，请改用 HTTPS 或 localhost 后访问麦克风');
+            if (abort.signal.aborted)
+                throw new Error('语音启动已取消');
+            const clientId = createClientId();
+            this.uploader = new VoiceStreamUploader({ url: resolveVoiceStreamUrl(ASSISTANT_VOICE_STREAM_PATH, { mode: 'frames' }), ownerId: this.configuredOwner, clientId, trace: this.trace, onError: (error) => this.failTransport(error, abort) });
+            const eventsStarted = performance.now();
+            const response = await globalThis.fetch(resolveVoiceStreamUrl(ASSISTANT_VOICE_EVENTS_PATH, { ownerId: this.configuredOwner, clientId }), {
+                method: 'GET',
                 signal: abort.signal,
                 credentials: 'same-origin',
-                headers: { 'content-type': 'application/octet-stream', accept: 'application/x-ndjson' },
-                ...{ duplex: 'half' },
+                headers: { accept: 'application/x-ndjson' },
             });
-            if (!response.ok || response.body === null)
-                throw new Error(`语音流连接失败（HTTP ${response.status}）`);
-            void this.readEvents(response.body, epoch);
-            const capture = new ClientVoiceCapture({ devices: this.devices, targetSampleRate: 16_000, onFrame: (frame) => this.sendPcmFrame(frame, epoch), onEnded: (error) => this.emit({ type: 'error', code: 'voice_capture_ended', message: error.message, recoverable: true, epoch }) });
+            if (!response.ok)
+                throw await createVoiceHttpError(response, '语音流连接失败');
+            if (response.body === null)
+                throw new Error('语音事件连接缺少响应正文');
+            this.chatStreaming = response.headers.get('x-codingns-voice-chat-stream') === '1';
+            this.trace('client.events.connected', { durationMs: performance.now() - eventsStarted, status: response.status, streaming: this.chatStreaming });
+            void this.readEvents(response.body, abort);
+            const capture = new ClientVoiceCapture({ devices: this.devices, targetSampleRate: 16_000, trace: this.trace, onFrame: (frame) => { if (this.responseAbort === abort)
+                    this.sendPcmFrame(frame, this.epoch); }, onEnded: (error) => this.failTransport(error, abort) });
             this.capture = capture;
             await capture.start();
-            this.emit({ type: 'state', state: 'listening', epoch });
+            if (abort.signal.aborted) {
+                await capture.stop();
+                throw new Error('语音启动已取消');
+            }
+            this.emit({ type: 'state', state: 'listening', epoch: this.epoch });
+            this.trace('client.call.started', { epoch: this.epoch, durationMs: performance.now() - started });
         }
         catch (error) {
-            await this.stop().catch(() => undefined);
+            this.trace('client.call.error', { durationMs: performance.now() - started, errorName: voiceDiagnosticError(error) });
+            if (this.responseAbort === abort)
+                await this.stop().catch(() => undefined);
             throw error;
         }
     }
     async stop() {
+        if (this.stopOperation !== undefined)
+            return this.stopOperation;
+        const operation = this.stopSession();
+        this.stopOperation = operation;
+        try {
+            await operation;
+        }
+        finally {
+            if (this.stopOperation === operation)
+                this.stopOperation = undefined;
+        }
+    }
+    async stopSession() {
         if (!this.active && this.capture === undefined && !this.hostLeaseActive)
             return;
+        const leaseRequest = this.leaseRequest;
+        const diagnostics = this.diagnostics;
+        const stopped = performance.now();
         this.active = false;
+        this.chatStreaming = false;
+        this.cancelReply();
+        this.uploader?.close();
+        this.uploader = undefined;
+        this.responseAbort?.abort();
+        this.responseAbort = undefined;
+        globalThis.speechSynthesis?.cancel();
+        this.output.dispose();
         let captureError;
         try {
             await this.capture?.stop();
@@ -117,102 +212,302 @@ export class ClientSherpaVoiceAdapter {
             captureError = error;
         }
         this.capture = undefined;
-        this.uploader?.enqueue(encodeVoiceStreamMessage({ type: 'close', epoch: this.epoch }));
-        this.uploader?.close();
-        this.uploader = undefined;
-        this.responseAbort?.abort();
-        this.responseAbort = undefined;
+        // 用户在模型启动期间关闭窗口时，RPC 取消不一定能撤销 Host 已创建的租约。
+        // 等待该请求结算后再释放，避免迟到的 start 留下无人持有的实时识别器。
+        const pendingLease = await leaseRequest?.catch(() => undefined);
+        if (pendingLease?.ok && !(isRecord(pendingLease.value) && pendingLease.value.unavailable === true))
+            this.hostLeaseActive = true;
         if (this.hostLeaseActive) {
             this.hostLeaseActive = false;
             await this.services.rpc.call(CODINGNS_RPC_CHANNEL, 'assistant/voice/stop', { ownerId: this.configuredOwner }).catch(() => undefined);
         }
         this.epoch += 1;
         this.emit({ type: 'state', state: 'disabled', epoch: this.epoch });
+        diagnostics?.record('client.call.stopped', { epoch: this.epoch, durationMs: performance.now() - stopped });
+        diagnostics?.dispose();
+        if (this.diagnostics === diagnostics)
+            this.diagnostics = undefined;
         if (captureError !== undefined)
             throw captureError;
     }
     async interrupt() {
-        this.epoch += 1;
-        globalThis.speechSynthesis?.cancel();
-        this.uploader?.enqueue(encodeVoiceStreamMessage({ type: 'interrupt', epoch: this.epoch }));
-        await this.services.rpc.call(CODINGNS_RPC_CHANNEL, 'assistant/voice/interrupt', { ownerId: this.configuredOwner }).catch(() => undefined);
+        if (!this.active)
+            return;
+        this.cancelReply();
+        this.uploader?.clearPending();
+        // 只走一次控制 RPC，避免数据面与 RPC 各打断一次，导致双方 epoch 错位。
+        const result = await this.services.rpc.call(CODINGNS_RPC_CHANNEL, 'assistant/voice/interrupt', { ownerId: this.configuredOwner });
+        if (!result.ok)
+            throw new Error(result.error.message);
+        if (!this.active)
+            return;
+        this.epoch = readEpoch(isRecord(result.value) ? result.value : {}, this.epoch + 1);
         this.emit({ type: 'barge-in', epoch: this.epoch });
     }
     sendPcm(frame, epoch) { this.sendPcmFrame(frame, epoch); }
-    async speak(text, epoch) {
-        if (epoch !== this.epoch || text.trim() === '')
+    async speak(text, epoch, isCurrent = () => true, settleState = true) {
+        if (epoch !== this.epoch || text.trim() === '' || !isCurrent())
+            return;
+        const tts = readAssistantTtsSettings(this.services.settings?.getSnapshot().value?.assistant.tts);
+        const parameters = readAssistantTtsParameters(tts.parameters);
+        const reply = this.reply;
+        const onStart = () => {
+            if (epoch !== this.epoch || !isCurrent())
+                return;
+            if (reply !== undefined && !reply.playbackStarted) {
+                reply.playbackStarted = true;
+                this.trace('client.turn.first_playback_scheduled', { requestId: reply.requestId, epoch, firstPlaybackMs: performance.now() - reply.startedAt });
+            }
+            this.emit({ type: 'state', state: 'speaking', epoch });
+        };
+        if (tts.backend === 'moss-onnx') {
+            globalThis.speechSynthesis?.cancel();
+            // 完整试听等待播放结束；对话分段只等待合成结束，下一段可在播放期间准备。
+            const completed = await this.output[settleState ? 'speak' : 'append'](text.trim(), tts.selectedId, onStart, parameters);
+            if (settleState && completed && this.active && epoch === this.epoch && isCurrent())
+                this.emit({ type: 'state', state: 'listening', epoch });
+            return;
+        }
+        this.output.cancel();
+        if (this.speakerMuted)
             return;
         const synthesis = globalThis.speechSynthesis;
         if (synthesis === undefined || typeof globalThis.SpeechSynthesisUtterance !== 'function')
             throw new Error('当前浏览器不支持语音播报');
-        synthesis.cancel();
-        await new Promise((resolve) => {
+        this.cancelOutput();
+        await new Promise((resolve, reject) => {
+            this.settleSpeech = resolve;
             const utterance = new SpeechSynthesisUtterance(text.trim());
             utterance.lang = 'zh-CN';
+            utterance.rate = parameters.rate;
+            utterance.volume = parameters.volume;
+            utterance.onstart = onStart;
             utterance.onend = () => resolve();
-            utterance.onerror = () => resolve();
+            utterance.onerror = (event) => { if (isCurrent())
+                reject(new Error(`浏览器语音播报失败：${event.error}`));
+            else
+                resolve(); };
             synthesis.speak(utterance);
         });
+        if (isCurrent())
+            this.settleSpeech = undefined;
+        if (settleState && this.active && epoch === this.epoch && isCurrent())
+            this.emit({ type: 'state', state: 'listening', epoch });
+    }
+    async clearConversation() {
+        this.cancelReply();
+        if (!this.active)
+            return;
+        const epoch = this.epoch;
+        const operation = this.services.rpc.call(CODINGNS_RPC_CHANNEL, 'assistant/voice/chat/clear', { ownerId: this.configuredOwner, epoch }).then((result) => {
+            if (!result.ok)
+                throw new Error(result.error.message);
+            if (this.active && this.epoch === epoch && this.reply === undefined)
+                this.emit({ type: 'state', state: 'listening', epoch });
+        });
+        this.clearOperation = operation;
+        try {
+            await operation;
+        }
+        finally {
+            if (this.clearOperation === operation)
+                this.clearOperation = undefined;
+        }
     }
     dispose() { void this.stop(); this.devices.dispose(); this.listeners.clear(); }
     sendPcmFrame(frame, epoch) {
         if (!this.active || this.uploader === undefined || epoch !== this.epoch)
             return;
-        this.uploader.enqueue(encodeVoiceStreamMessage({ type: 'pcm', sequence: frame.sequence, sampleRate: frame.sampleRate, channels: 1, epoch, byteLength: frame.bytes.byteLength }));
-        this.uploader.enqueue(frame.bytes);
+        this.uploader.enqueue(frame, epoch);
     }
-    async readEvents(body, streamEpoch) {
+    async readEvents(body, abort) {
         const reader = body.getReader();
         const decoder = new TextDecoder();
         let text = '';
         try {
             while (true) {
                 const next = await reader.read();
-                if (next.done)
+                if (next.done) {
+                    if (!abort.signal.aborted)
+                        throw new Error('语音事件连接已断开，请重新开始实时对话');
                     break;
+                }
                 text += decoder.decode(next.value, { stream: true });
                 let newline = text.indexOf('\n');
                 while (newline >= 0) {
                     const line = text.slice(0, newline).trim();
                     text = text.slice(newline + 1);
-                    if (line !== '')
-                        await this.handleEvent(JSON.parse(line), streamEpoch);
+                    if (line !== '' && this.responseAbort === abort)
+                        this.handleEvent(JSON.parse(line));
                     newline = text.indexOf('\n');
                 }
             }
         }
         catch (error) {
-            if (this.active)
-                this.emit({ type: 'error', code: 'voice_stream_response_failed', message: error instanceof Error ? error.message : String(error), recoverable: true, epoch: streamEpoch });
+            if (!abort.signal.aborted)
+                this.failTransport(error instanceof Error ? error : new Error(String(error)), abort);
+        }
+        finally {
+            reader.releaseLock();
         }
     }
-    async handleEvent(value, streamEpoch) {
-        if (streamEpoch !== this.epoch || typeof value.type !== 'string')
+    handleEvent(value) {
+        const eventEpoch = readEpoch(value, this.epoch);
+        if (eventEpoch < this.epoch || typeof value.type !== 'string')
             return;
-        if (value.type === 'state' && typeof value.state === 'string')
-            this.emit({ type: 'state', state: value.state, epoch: readEpoch(value, streamEpoch) });
-        else if (value.type === 'partial' && typeof value.text === 'string')
-            this.emit({ type: 'partial', text: value.text, epoch: readEpoch(value, streamEpoch) });
+        if (value.type === 'chat') {
+            const reply = this.reply;
+            if (reply !== undefined && eventEpoch === reply.epoch && isVoiceChatRun(value.run) && value.run.requestId === reply.requestId) {
+                reply.updates.push(value.run);
+                this.trace('client.turn.stream_update', { requestId: reply.requestId, epoch: eventEpoch, state: value.run.state, textLength: value.run.text.length });
+            }
+            return;
+        }
+        if (eventEpoch > this.epoch || value.type === 'barge-in')
+            this.cancelReply();
+        this.epoch = eventEpoch;
+        this.trace('client.voice.event', { epoch: eventEpoch, state: value.type, textLength: typeof value.text === 'string' ? value.text.length : undefined });
+        if (value.type === 'state' && typeof value.state === 'string') {
+            // 识别器继续收音，等待回复时保留思考／播报状态。
+            if (this.reply === undefined || value.state !== 'listening')
+                this.emit({ type: 'state', state: value.state, epoch: eventEpoch });
+        }
+        else if (value.type === 'partial' && typeof value.text === 'string' && !this.microphoneMuted)
+            this.emit({ type: 'partial', text: value.text, epoch: eventEpoch });
         else if (value.type === 'final' && typeof value.text === 'string') {
-            const eventEpoch = readEpoch(value, streamEpoch);
-            this.emit({ type: 'final', text: value.text, epoch: eventEpoch });
-            const result = await this.services.rpc.call(CODINGNS_RPC_CHANNEL, 'assistant/voice/text', { ownerId: this.configuredOwner, text: value.text, requestId: createClientId() });
-            if (result.ok && isRecord(result.value) && typeof result.value.speechText === 'string')
-                await this.speak(result.value.speechText, eventEpoch);
+            if (this.microphoneMuted)
+                return;
+            if (value.text.trim() === '')
+                return;
+            const requestId = createClientId();
+            this.emit({ type: 'final', text: value.text, epoch: eventEpoch, requestId });
+            // LLM 和播报在后台运行，下一句的 partial 继续实时显示。
+            void this.handleFinalText(value.text, eventEpoch, requestId);
         }
         else if (value.type === 'barge-in')
-            this.emit({ type: 'barge-in', epoch: readEpoch(value, streamEpoch) });
+            this.emit({ type: 'barge-in', epoch: eventEpoch });
         else if (value.type === 'error')
-            this.emit({ type: 'error', code: String(value.code ?? 'voice_stream_error'), message: String(value.message ?? value.code ?? ''), recoverable: value.recoverable !== false, epoch: readEpoch(value, streamEpoch) });
+            this.emit({ type: 'error', code: String(value.code ?? 'voice_stream_error'), message: String(value.message ?? value.code ?? ''), recoverable: value.recoverable !== false, epoch: eventEpoch });
     }
-    async applyOutputDevice() {
-        if (!this.outputDeviceSupported)
-            return;
-        for (const media of [...document.querySelectorAll('audio,video')]) {
-            const sink = media.setSinkId;
-            if (typeof sink === 'function')
-                await sink.call(media, this.selectedOutputDeviceId ?? '');
+    async handleFinalText(text, epoch, requestId) {
+        this.cancelReply();
+        const reply = { requestId, epoch, abort: new AbortController(), startedAt: performance.now(), updates: new VoiceChatUpdates(), playbackStarted: false };
+        this.reply = reply;
+        const started = performance.now();
+        const fields = { requestId, epoch, textLength: text.length };
+        const diagnostics = this.diagnostics;
+        const trace = (event, metrics) => diagnostics?.record(event, { ...fields, ...metrics });
+        let polls = 0;
+        let firstText = false;
+        let firstSentence = false;
+        let outcome = 'cancelled';
+        trace('client.turn.start');
+        const isCurrent = () => this.active && this.epoch === epoch && this.reply === reply && !reply.abort.signal.aborted;
+        const sentences = new StreamingSentenceQueue(async (sentence) => {
+            if (!firstSentence) {
+                firstSentence = true;
+                trace('client.turn.first_sentence', { firstSentenceMs: performance.now() - started });
+            }
+            await this.speak(sentence, epoch, isCurrent, false);
+        }, isCurrent, Date.now, (event, metrics) => trace(`client.${event}`, metrics));
+        const payload = { ownerId: this.configuredOwner, epoch, requestId, sequence: ++this.replySequence };
+        try {
+            await this.clearOperation;
+            if (!isCurrent())
+                return;
+            this.emit({ type: 'state', state: 'thinking', epoch });
+            let result = await this.services.rpc.call(CODINGNS_RPC_CHANNEL, 'assistant/voice/chat/start', { ...payload, text }, reply.abort.signal);
+            let previousText = '';
+            while (isCurrent()) {
+                if (!result.ok)
+                    throw new Error(result.error.message);
+                // 首次推送可能早于 start RPC 返回；累计快照优先，不能被旧响应覆盖。
+                const pushed = reply.updates.take();
+                if (pushed !== undefined && (!isRecord(result.value) || result.value.state === 'running' || pushed.state !== 'running'))
+                    result = { ok: true, value: pushed };
+                const run = result.value;
+                if (!isRecord(run) || typeof run.text !== 'string' || !['running', 'completed', 'failed', 'cancelled'].includes(String(run.state)))
+                    throw new Error('语音 LLM 返回了无效的对话状态');
+                if (run.text !== previousText || run.state === 'completed') {
+                    if (!firstText && run.text.trim() !== '') {
+                        firstText = true;
+                        trace('client.turn.first_text', { firstTextMs: performance.now() - started });
+                    }
+                    previousText = run.text;
+                    this.emit({ type: 'reply', requestId, text: run.text, final: run.state === 'completed', epoch });
+                }
+                if (run.state === 'running' || run.state === 'completed')
+                    sentences.push(run.text, run.state === 'completed');
+                if (run.state === 'completed') {
+                    trace('client.turn.llm_completed', { durationMs: performance.now() - started, count: polls, textLength: run.text.length });
+                    await sentences.drain();
+                    if (isCurrent())
+                        await this.output.finish();
+                    if (isCurrent())
+                        this.emit({ type: 'state', state: 'listening', epoch });
+                    outcome = isCurrent() ? 'completed' : 'cancelled';
+                    return;
+                }
+                if (run.state !== 'running')
+                    throw new Error(typeof run.error === 'string' ? run.error : '语音 LLM 对话已停止');
+                if (this.chatStreaming) {
+                    const pushed = await reply.updates.next(reply.abort.signal);
+                    if (pushed !== undefined) {
+                        result = { ok: true, value: pushed };
+                        continue;
+                    }
+                    if (isCurrent())
+                        trace('client.turn.poll_fallback');
+                }
+                else
+                    await waitForReplyPoll(reply.abort.signal);
+                if (!isCurrent())
+                    return;
+                const pollStarted = performance.now();
+                polls++;
+                result = await this.services.rpc.call(CODINGNS_RPC_CHANNEL, 'assistant/voice/chat/read', payload, reply.abort.signal);
+                if (performance.now() - pollStarted >= 250)
+                    trace('client.turn.slow_poll', { durationMs: performance.now() - pollStarted });
+            }
         }
+        catch (error) {
+            if (isCurrent()) {
+                outcome = 'failed';
+                trace('client.turn.error', { errorName: voiceDiagnosticError(error), durationMs: performance.now() - started });
+                this.emit({ type: 'error', code: 'voice_chat_failed', message: error instanceof Error ? error.message : String(error), recoverable: true, epoch });
+                this.cancelReply();
+            }
+        }
+        finally {
+            trace('client.turn.finished', { state: outcome, count: polls, durationMs: performance.now() - started });
+            if (this.reply === reply)
+                this.reply = undefined;
+        }
+    }
+    cancelReply() {
+        const reply = this.reply;
+        this.reply = undefined;
+        if (reply !== undefined)
+            this.trace('client.turn.cancel', { requestId: reply.requestId, epoch: reply.epoch });
+        reply?.abort.abort();
+        this.cancelOutput();
+        if (reply !== undefined)
+            void this.services.rpc.call(CODINGNS_RPC_CHANNEL, 'assistant/voice/chat/cancel', { ownerId: this.configuredOwner, epoch: reply.epoch, requestId: reply.requestId }).catch(() => undefined);
+    }
+    cancelOutput() {
+        this.settleSpeech?.();
+        this.settleSpeech = undefined;
+        globalThis.speechSynthesis?.cancel();
+        this.output.cancel();
+    }
+    failTransport(error, abort) {
+        if (this.responseAbort !== abort || abort.signal.aborted)
+            return;
+        this.trace('client.transport.error', { epoch: this.epoch, errorName: voiceDiagnosticError(error) });
+        void this.stop().catch(() => undefined).then(() => {
+            if (!this.active)
+                this.emit({ type: 'error', code: 'voice_stream_failed', message: error.message, recoverable: false, epoch: this.epoch });
+        });
     }
     emit(event) { for (const listener of [...this.listeners]) {
         try {
@@ -221,26 +516,12 @@ export class ClientSherpaVoiceAdapter {
         catch { /* UI 订阅者异常不能破坏语音数据面 */ }
     } }
 }
-class VoiceStreamUploader {
-    stream;
-    controller;
-    closed = false;
-    constructor() { this.stream = new ReadableStream({ start: (controller) => { this.controller = controller; } }); }
-    enqueue(bytes) { if (!this.closed) {
-        try {
-            this.controller?.enqueue(bytes.slice());
-        }
-        catch {
-            this.closed = true;
-        }
-    } }
-    close() { if (this.closed)
-        return; this.closed = true; try {
-        this.controller?.close();
-    }
-    catch { /* fetch 已断开 */ } }
+function resolveVoiceStreamUrl(path, parameters) {
+    const url = new URL(path, globalThis.location?.origin ?? 'http://localhost');
+    for (const [key, value] of Object.entries(parameters))
+        url.searchParams.set(key, value);
+    return url.toString();
 }
-function resolveVoiceStreamUrl() { return new URL('/api/codingns/assistant/voice/stream', globalThis.location?.origin ?? 'http://localhost').toString(); }
 function createClientId() { try {
     return globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random()}`;
 }
@@ -249,4 +530,16 @@ catch {
 } }
 function readEpoch(value, fallback) { return typeof value.epoch === 'number' && Number.isInteger(value.epoch) ? value.epoch : fallback; }
 function isRecord(value) { return typeof value === 'object' && value !== null && !Array.isArray(value); }
+function isVoiceChatRun(value) {
+    return isRecord(value) && typeof value.requestId === 'string' && typeof value.text === 'string' && value.text.length <= 16000 && ['running', 'completed', 'failed', 'cancelled'].includes(String(value.state));
+}
+function waitForReplyPoll(signal) {
+    return new Promise((resolve) => {
+        const finish = () => { clearTimeout(timer); signal.removeEventListener('abort', finish); resolve(); };
+        const timer = setTimeout(finish, 250);
+        signal.addEventListener('abort', finish, { once: true });
+        if (signal.aborted)
+            finish();
+    });
+}
 //# sourceMappingURL=sherpa-voice-adapter.js.map