@chat21/chat21-web-widget 5.1.33-rc9 → 5.1.34-rc1

package/src/app/providers/json-sources-parser.service.ts

@@ -7,25 +7,19 @@ import { mergeJsonSourcesMissingFields } from 'src/app/utils/json-sources-utils'
 
 export type UrlPreviewMessage = {
   type?: string; // "url_preview"
-  activeMode?: 'form' | 'list' | 'text' | string;
-  form?: { sources?: any[] };
-  list?: string;
   text?: string;
 };
 
 /**
  * Parse and enrich "url_preview" messages into `JsonSourceItem[]`.
  *
- * This service is intentionally isolated so it can be replaced/removed easily.
- *
  * Rules:
- * - It expects the full url_preview message object: `{ type: 'url_preview', activeMode: 'form'|'list'|'text', ... }`
- * - `activeMode` selects the source field to use:
- *   - `form`: reads `msg.form.sources` (array of `{source_name, source_file_name, ...}`)
- *   - `list`: reads `msg.list` (free text) and extracts URLs (max 10)
- *   - `text`: reads `msg.text` (a JSON array string with the same schema as `form.sources`)
- * - After building the initial array, it calls `url-preview` only for items that miss title or description,
- *   and merges the missing fields only (never overwriting existing values).
+ * - The payload is always read from `msg.text`, regardless of `activeMode`.
+ * - `msg.text` may be either:
+ *     - a JSON array of source objects (`{source_name, source_file_name, ...}`), or
+ *     - a plain string from which URLs are extracted (split by whitespace/punctuation).
+ * - After building the initial array, `url-preview` is called only for items that miss
+ *   title or description, and missing fields are merged in (never overwriting).
  */
 @Injectable({ providedIn: 'root' })
 export class JsonSourcesParserService {
@@ -98,23 +92,11 @@ export class JsonSourcesParserService {
   private parseBaseJsonSources(msg?: UrlPreviewMessage | null): JsonSourceItem[] | null {
     if (!msg || msg.type !== 'url_preview') return null;
 
-    const mode = (msg.activeMode || '').toString().trim();
-    const normalizedMode = mode === 'json_sources' ? 'form' : mode; // backward compat
-
-    if (normalizedMode === 'form') {
-      return this.mapSourcesArray(msg.form?.sources);
-    }
-    if (normalizedMode === 'list') {
-      return this.mapListToSources(msg.list);
-    }
-    if (normalizedMode === 'text') {
-      return this.mapTextToSources(msg.text);
-    }
-
-    // best-effort fallback order
-    return this.mapSourcesArray(msg.form?.sources)
-      || this.mapTextToSources(msg.text)
-      || this.mapListToSources(msg.list);
+    // Regardless of `activeMode`, the payload is always read from `msg.text`.
+    // It can be either a JSON array of source objects, or a plain string with URLs.
+    return this.isJsonArrayOfObjects(msg.text)
+      ? this.mapTextToSources(msg.text)
+      : this.mapListToSources(msg.text);
   }
 
   private mapListToSources(listValue?: string): JsonSourceItem[] | null {
@@ -122,6 +104,16 @@ export class JsonSourcesParserService {
     return urls.length ? urls.map(u => ({ link: u, title: u })) : null;
   }
 
+  private isJsonArrayOfObjects(text?: string): boolean {
+    if (!text) return false;
+    try {
+      const parsed = this.parseJsonLenient(text);
+      return Array.isArray(parsed) && parsed.some(it => it && typeof it === 'object' && !Array.isArray(it));
+    } catch {
+      return false;
+    }
+  }
+
   private mapTextToSources(text?: string): JsonSourceItem[] | null {
     if (!text) return null;
     try {
@@ -137,9 +129,10 @@ export class JsonSourcesParserService {
     if (!arr || arr.length === 0) return null;
     const mapped = arr
       .filter((s: any) => s && typeof s === 'object' && typeof s[JSON_SOURCE_FIELD_URL] === 'string')
-      .map((s: any): JsonSourceItem => {
+      .map((s: any): JsonSourceItem | null => {
         const rawUrl = (s[JSON_SOURCE_FIELD_URL] || '').toString().trim();
-        const normalized = extractUrlsFromText(rawUrl, 1)[0] || rawUrl;
+        const normalized = extractUrlsFromText(rawUrl, 1)[0];
+        if (!normalized) return null;
         return {
           link: normalized,
           title: (s[JSON_SOURCE_FIELD_TITLE] || rawUrl).toString(),
@@ -147,7 +140,7 @@ export class JsonSourcesParserService {
           image: typeof s.source_image === 'string' ? s.source_image : undefined
         };
       })
-      .filter((x: JsonSourceItem) => !!x.link);
+      .filter((x: JsonSourceItem | null): x is JsonSourceItem => !!x && !!x.link);
     return mapped.length ? mapped : null;
   }
 

package/src/app/providers/voice/voice-streaming.service.ts

@@ -13,10 +13,11 @@ import {
   VoiceWsControlMessage,
 } from './voice-streaming.types';
 
-// Flux docs recommend 80ms chunks for optimal latency; 250ms is a practical
-// balance for WebM containerization overhead in the browser.
+// Flux docs recommend 80ms chunks for optimal latency; 160ms is a practical
+// balance for WebM containerization overhead in the browser while providing
+// good STT accuracy.
 // Source: https://developers.deepgram.com/docs/flux/quickstart
-const DEFAULT_TIMESLICE_MS = 250;
+const DEFAULT_TIMESLICE_MS = 160;
 const READY_TIMEOUT_MS = 10_000;
 const SESSION_STARTED_TIMEOUT_MS = 10_000;
 
@@ -258,6 +259,12 @@ export class VoiceStreamingService {
       this.mediaStream = shared
         ? shared
         : await navigator.mediaDevices.getUserMedia({ audio: true });
+      const tracks = this.mediaStream.getAudioTracks();
+      this.logger.info('[VoiceStreaming] microphone acquired', {
+        shared: !!shared,
+        tracks: tracks.length,
+        label: tracks[0]?.label ?? '(unknown)',
+      });
       const recorderOpts: MediaRecorderOptions = {};
       if (mime) {
         recorderOpts.mimeType = mime;
@@ -571,7 +578,7 @@ export class VoiceStreamingService {
 
   /**
    * Send `{ event: "tts_playback_complete" }` to the proxy, signalling that TTS
-   * playback has finished and the microphone is ready to receive user speech.
+   * playback has finished and the microphone is now safe to receive user speech.
    */
   sendPlaybackComplete(): void {
     if (this.ws?.readyState === WebSocket.OPEN) {
@@ -580,21 +587,6 @@ export class VoiceStreamingService {
     }
   }
 
-  /**
-   * Send `{ event: "barge_in" }` to the proxy, requesting an immediate interruption
-   * of the ongoing TTS playback.  Use when the user explicitly wants to speak while
-   * the bot is talking (e.g. via a UI button or a client-side VAD onset).
-   *
-   * The proxy will stop the TTS stream and transition to LISTENING; the widget should
-   * handle the server-sent `barge_in` and `listening` events to update local state.
-   */
-  sendBargeIn(): void {
-    if (this.ws?.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify({ event: 'barge_in' }));
-      this.logger.info('[VoiceStreaming] barge_in sent');
-    }
-  }
-
   private cleanup(): void {
     this.logger.info('[VoiceStreaming] cleanup', { state: this._currentState, sessionId: this.currentSessionId });
     this.audioChunkCount = 0;

package/src/app/providers/voice/voice-streaming.types.ts

@@ -86,7 +86,6 @@ export type VoiceWsServerEventName =
   | 'thinking'
   | 'speaking'
   | 'done'
-  | 'barge_in'
   | 'error';
 
 /** Messaggio di controllo JSON dal proxy (`msg.event`); altri campi sono ignorati se non gestiti. */

package/src/app/providers/voice/voice.service.spec.ts

@@ -44,7 +44,7 @@ describe('VoiceService', () => {
 
     voiceStreamingMock = jasmine.createSpyObj<VoiceStreamingService>(
       'VoiceStreamingService',
-      ['start', 'stop', 'setAudioMuted', 'sendPlaybackComplete', 'sendBargeIn'],
+      ['start', 'stop', 'setAudioMuted', 'sendPlaybackComplete', 'pauseRecording', 'resumeRecording'],
     );
     voiceStreamingMock.start.and.returnValue(Promise.resolve());
     voiceStreamingMock.stop.and.returnValue(
@@ -65,6 +65,8 @@ describe('VoiceService', () => {
       ],
     });
     service = TestBed.inject(VoiceService);
+    spyOn(service as any, '_startKeyboardSound').and.stub();
+    spyOn(service as any, '_stopKeyboardSound').and.stub();
   });
 
   // ── Existing session lifecycle tests ──────────────────────────────────────
@@ -156,22 +158,21 @@ describe('VoiceService', () => {
     expect(voiceStreamingMock.setAudioMuted).not.toHaveBeenCalled();
   });
 
-  it('empty-audio path: sendPlaybackComplete immediately but acquisition stays blocked until "listening"', async () => {
+  it('empty-audio path: sendPlaybackComplete after flush but acquisition stays blocked until "listening"', async () => {
     const blocked = await startWssSession();
     const initialLen = blocked.length;
 
-    // Simulate done arriving with NO binary audio (_activeTtsSources === 0)
+    // done with no binary audio arms unblock; flush sends playback complete to proxy
     wsControl$.next({ event: 'speaking', text: 'hello' } as VoiceWsControlMessage);
     wsControl$.next({ event: 'done' } as VoiceWsControlMessage);
 
-    // Proxy signalled immediately
+    expect(voiceStreamingMock.sendPlaybackComplete).not.toHaveBeenCalled();
+    (service as any)._flushTtsUnblock(false);
     expect(voiceStreamingMock.sendPlaybackComplete).toHaveBeenCalledTimes(1);
 
-    // Acquisition must still be blocked — proxy hasn't confirmed LISTENING yet
     const afterDone = blocked.slice(initialLen);
     expect(afterDone.every((v) => v === true)).toBeTrue();
 
-    // Unblock only after proxy confirms
     wsControl$.next({ event: 'listening' } as VoiceWsControlMessage);
     expect(blocked[blocked.length - 1]).toBeFalse();
   });
@@ -189,22 +190,19 @@ describe('VoiceService', () => {
 
   // ── Audio preemption tests (SPEC-002) ────────────────────────────────────
 
-  it('second "speaking" cancels first audio: sendPlaybackComplete called exactly once for the new turn', async () => {
+  it('second "speaking" cancels first audio: sendPlaybackComplete only after flush for the new turn', async () => {
     await startWssSession();
     voiceStreamingMock.sendPlaybackComplete.calls.reset();
 
-    // First turn: audio chunk arrives → _activeTtsSources = 1 (sync) → done sets _unblockAfterTts
     wsControl$.next({ event: 'speaking', text: 'first' } as VoiceWsControlMessage);
-    ttsBinaryChunk$.next(new ArrayBuffer(4));           // _activeTtsSources++ synchronously
-    wsControl$.next({ event: 'done' } as VoiceWsControlMessage); // _unblockAfterTts = true
+    ttsBinaryChunk$.next(new ArrayBuffer(4));
+    wsControl$.next({ event: 'done' } as VoiceWsControlMessage);
 
-    // Second turn preempts while first audio is still "playing"
     wsControl$.next({ event: 'speaking', text: 'second' } as VoiceWsControlMessage);
-    // _cancelAllTtsAudio() resets _activeTtsSources=0, _unblockAfterTts=false
-
-    // done with no audio → sendPlaybackComplete immediately (new turn, _activeTtsSources = 0)
     wsControl$.next({ event: 'done' } as VoiceWsControlMessage);
 
+    expect(voiceStreamingMock.sendPlaybackComplete).not.toHaveBeenCalled();
+    (service as any)._flushTtsUnblock(false);
     expect(voiceStreamingMock.sendPlaybackComplete).toHaveBeenCalledTimes(1);
   });
 
@@ -226,35 +224,4 @@ describe('VoiceService', () => {
     expect(voiceStreamingMock.sendPlaybackComplete).not.toHaveBeenCalled();
   });
 
-  // ── Barge-in ──────────────────────────────────────────────────────────────
-
-  it('barge_in event cancels TTS audio and unblocks acquisition without sending tts_playback_complete', async () => {
-    await startWssSession();
-    voiceStreamingMock.sendPlaybackComplete.calls.reset();
-
-    // Simulate bot speaking with audio in flight
-    wsControl$.next({ event: 'speaking', text: 'hello' } as VoiceWsControlMessage);
-    ttsBinaryChunk$.next(new ArrayBuffer(4));   // _activeTtsSources++ synchronously
-    wsControl$.next({ event: 'done' } as VoiceWsControlMessage); // _unblockAfterTts = true
-
-    // Proxy detects user speech and sends barge_in
-    wsControl$.next({ event: 'barge_in' } as VoiceWsControlMessage);
-
-    // tts_playback_complete must NOT be sent — it was an interruption, not a completion
-    expect(voiceStreamingMock.sendPlaybackComplete).not.toHaveBeenCalled();
-    expect(voiceStreamingMock.setAudioMuted).not.toHaveBeenCalled();
-    expect((service as any)._isAcquisitionBlocked$.getValue()).toBe(false);
-  });
-
-  it('barge_in while no TTS is active does not throw and still unblocks acquisition', async () => {
-    await startWssSession();
-    voiceStreamingMock.sendPlaybackComplete.calls.reset();
-
-    // No speaking event — mic was never muted
-    expect(() => {
-      wsControl$.next({ event: 'barge_in' } as VoiceWsControlMessage);
-    }).not.toThrow();
-
-    expect(voiceStreamingMock.sendPlaybackComplete).not.toHaveBeenCalled();
-  });
 });