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

package/src/app/providers/url-preview.service.ts

@@ -0,0 +1,82 @@
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { firstValueFrom } from 'rxjs';
+import { AppConfigService } from './app-config.service';
+import { Globals } from '../utils/globals';
+
+export type UrlPreviewItem = {
+  url: string;
+  title?: string;
+  description?: string;
+  image?: string;
+  siteName?: string;
+  favicon?: string;
+  favicon_hd?: string;
+};
+
+@Injectable({
+  providedIn: 'root'
+})
+export class UrlPreviewService {
+  constructor(
+    private http: HttpClient,
+    private appConfigService: AppConfigService,
+    private g: Globals
+  ) {}
+
+  async previewUrls(urls: string[]): Promise<UrlPreviewItem[]> {
+    const apiUrl = this.appConfigService.getConfig()?.apiUrl;
+    const projectId = this.g.projectid;
+
+    const cleaned = (urls || []).map((u) => (u || '').trim()).filter(Boolean).slice(0, 10);
+    if (!apiUrl || !projectId || cleaned.length === 0) return [];
+
+    const base = apiUrl.endsWith('/') ? apiUrl : apiUrl + '/';
+    const url = `${base}${projectId}/url-preview`;
+
+    const token = this.g.tiledeskToken;
+    const headers = new HttpHeaders({
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+      Authorization: token || ''
+    });
+
+    const body = { urls: cleaned };
+
+    try {
+      const res = await firstValueFrom(
+        this.http.post<any>(url, body, { headers })
+      );
+
+      // Expected response:
+      // [
+      //   { url: "...", success: true, data: { url,title,description,image,siteName,... } },
+      //   ...
+      // ]
+      // But we stay liberal and accept some alternative wrappers.
+      const items: any[] = Array.isArray(res)
+        ? res
+        : (Array.isArray(res?.items) ? res.items : (Array.isArray(res?.data) ? res.data : []));
+
+      return (items || [])
+        .filter((x) => x && typeof x === 'object')
+        .filter((x) => x.success !== false) // keep true/undefined, drop explicit failures
+        .map((x) => {
+          const d = x.data && typeof x.data === 'object' ? x.data : x;
+          return {
+            url: (d.url || x.url || x.link || '').toString(),
+            title: typeof d.title === 'string' ? d.title : (typeof x.title === 'string' ? x.title : undefined),
+            description: typeof d.description === 'string' ? d.description : (typeof x.description === 'string' ? x.description : undefined),
+            image: typeof d.image === 'string' ? d.image : (typeof x.image === 'string' ? x.image : undefined),
+            siteName: typeof d.siteName === 'string' ? d.siteName : undefined,
+            favicon: typeof d.favicon === 'string' ? d.favicon : (typeof x.favicon === 'string' ? x.favicon : undefined),
+            favicon_hd: typeof d.favicon_hd === 'string' ? d.favicon_hd : (typeof x.favicon_hd === 'string' ? x.favicon_hd : undefined)
+          } as UrlPreviewItem;
+        })
+        .filter((x) => !!x.url);
+    } catch {
+      return [];
+    }
+  }
+}
+

package/src/app/providers/voice/STT&TTS/openai-voice.config.ts

@@ -0,0 +1,12 @@
+/**
+ * Configurazione opzionale per i servizi voce OpenAI (da `environment` o runtime).
+ */
+export interface OpenAiVoiceEnvironmentConfig {
+  /** Obbligatoria per chiamate API reali; se assente, STT/TTS non inviano richieste. */
+  apiKey?: string;
+  baseUrl?: string;
+  transcriptionModel?: string;
+  ttsModel?: string;
+  /** Voce predefinita TTS (es. `alloy`). */
+  ttsVoice?: string;
+}

package/src/app/providers/voice/STT&TTS/openai-voice.provider.ts

@@ -0,0 +1,171 @@
+import { HttpClient, HttpErrorResponse, HttpHeaders } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { firstValueFrom } from 'rxjs';
+import { environment } from 'src/environments/environment';
+
+import type { OpenAiVoiceEnvironmentConfig } from './openai-voice.config';
+import {
+  SpeechToTextProvider,
+  TextToSpeechProvider,
+  type SpeechToTextRequest,
+  type SpeechToTextResult,
+  type TextToSpeechRequest,
+  type TextToSpeechResult,
+} from './speech-provider.abstract';
+import { AppConfigService } from '../../app-config.service';
+
+const DEFAULT_BASE = 'https://api.openai.com/v1';
+const DEFAULT_TRANSCRIPTION_MODEL = 'whisper-1';
+const DEFAULT_TTS_MODEL = 'tts-1';
+const DEFAULT_VOICE = 'alloy';
+const DEFAULT_FORMAT = 'mp3';
+
+/**
+ * Provider OpenAI unico: STT (Whisper) + TTS, entrambi via {@link HttpClient}.
+ */
+@Injectable({ providedIn: 'root' })
+export class OpenAiVoiceProviderService extends SpeechToTextProvider implements TextToSpeechProvider {
+  constructor(
+    private readonly httpClient: HttpClient,
+    private readonly appConfig: AppConfigService
+  ) {
+    super();
+  }
+
+  async transcribe(request: SpeechToTextRequest): Promise<SpeechToTextResult> {
+    const cfg = this.getConfig();
+    const apiKey = cfg.apiKey?.trim();
+    if (!apiKey) {
+      return { text: '' };
+    }
+
+    const base = (cfg.baseUrl ?? DEFAULT_BASE).replace(/\/$/, '');
+    const model = cfg.transcriptionModel ?? DEFAULT_TRANSCRIPTION_MODEL;
+    const url = `${base}/audio/transcriptions`;
+
+    const ext = this.extensionForMime(request.mimeType);
+    const file = new File([request.audio], `segment.${ext}`, { type: request.mimeType });
+
+    const form = new FormData();
+    form.append('file', file);
+    form.append('model', model);
+    if (request.language) {
+      form.append('language', request.language);
+    }
+
+    const headers = new HttpHeaders({
+      Authorization: `Bearer ${apiKey}`,
+    });
+
+    try {
+      const data = await firstValueFrom(
+        this.httpClient.post<{ text?: string }>(url, form, { headers }),
+      );
+      return { text: (data.text ?? '').trim() };
+    } catch (e) {
+      if (e instanceof HttpErrorResponse && e.error instanceof Blob) {
+        const errText = await e.error.text();
+        throw new Error(`OpenAI transcription ${e.status}: ${errText || e.statusText}`);
+      }
+      throw this.mapOpenAiHttpError(e);
+    }
+  }
+
+  async synthesize(request: TextToSpeechRequest): Promise<TextToSpeechResult> {
+    const cfg = this.getConfig();
+    const apiKey = cfg.apiKey?.trim();
+    if (!apiKey) {
+      throw new Error('OpenAI API key not configured (environment.openAiVoice.apiKey)');
+    }
+
+    const base = (cfg.baseUrl ?? DEFAULT_BASE).replace(/\/$/, '');
+    const model = cfg.ttsModel ?? DEFAULT_TTS_MODEL;
+    const voice = request.voice ?? cfg.ttsVoice ?? DEFAULT_VOICE;
+    const responseFormat =
+      (request.responseFormat as 'mp3' | 'opus' | 'aac' | 'flac' | undefined) ?? DEFAULT_FORMAT;
+    const url = `${base}/audio/speech`;
+
+    const body = {
+      model,
+      voice,
+      input: request.text,
+      response_format: responseFormat,
+    };
+
+    const headers = new HttpHeaders({
+      Authorization: `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+    });
+
+    try {
+      const blob = await firstValueFrom(
+        this.httpClient.post(url, body, {
+          headers,
+          responseType: 'blob',
+        }),
+      );
+      return { audio: blob, mimeType: this.mimeForFormat(responseFormat) };
+    } catch (e) {
+      if (e instanceof HttpErrorResponse && e.error instanceof Blob) {
+        const errText = await e.error.text();
+        throw new Error(`OpenAI TTS ${e.status}: ${errText || e.statusText}`);
+      }
+      if (e instanceof HttpErrorResponse) {
+        throw new Error(`OpenAI TTS ${e.status}: ${e.message || e.statusText}`);
+      }
+      throw e;
+    }
+  }
+
+  private getConfig(): OpenAiVoiceEnvironmentConfig {
+    return this.appConfig.getConfig().openAiKey ?? {};
+  }
+
+  private mapOpenAiHttpError(e: unknown): Error {
+    if (!(e instanceof HttpErrorResponse)) {
+      return e instanceof Error ? e : new Error(String(e));
+    }
+    const label = 'OpenAI transcription';
+    if (e.error instanceof Blob) {
+      return new Error(`${label} ${e.status}: ${e.statusText}`);
+    }
+    if (typeof e.error === 'object' && e.error !== null && 'error' in e.error) {
+      const err = (e.error as { error?: { message?: string } }).error;
+      return new Error(`${label} ${e.status}: ${err?.message ?? JSON.stringify(e.error)}`);
+    }
+    if (typeof e.error === 'string') {
+      return new Error(`${label} ${e.status}: ${e.error}`);
+    }
+    return new Error(`${label} ${e.status}: ${e.message || e.statusText}`);
+  }
+
+  private extensionForMime(mime: string): string {
+    if (mime.includes('webm')) {
+      return 'webm';
+    }
+    if (mime.includes('mp4') || mime.includes('m4a')) {
+      return 'm4a';
+    }
+    if (mime.includes('wav')) {
+      return 'wav';
+    }
+    if (mime.includes('mpeg') || mime.includes('mp3')) {
+      return 'mp3';
+    }
+    return 'webm';
+  }
+
+  private mimeForFormat(fmt: string): string {
+    switch (fmt) {
+      case 'opus':
+        return 'audio/opus';
+      case 'aac':
+        return 'audio/aac';
+      case 'flac':
+        return 'audio/flac';
+      case 'mp3':
+      default:
+        return 'audio/mpeg';
+    }
+  }
+}

package/src/app/providers/voice/STT&TTS/speech-provider.abstract.ts

@@ -0,0 +1,39 @@
+/**
+ * Contratti astratti per Speech-to-Text e Text-to-Speech.
+ * Implementazione OpenAI unificata: `OpenAiVoiceProviderService` (`openai-voice.provider.ts`).
+ */
+
+/** Input per la trascrizione di un segmento audio. */
+export interface SpeechToTextRequest {
+  audio: Blob;
+  mimeType: string;
+  /** ISO 639-1 opzionale (es. `it`, `en`). */
+  language?: string;
+}
+
+export interface SpeechToTextResult {
+  text: string;
+}
+
+/** Input per la sintesi vocale. */
+export interface TextToSpeechRequest {
+  text: string;
+  /** Voce provider-specific (es. OpenAI: `alloy`, `echo`, …). */
+  voice?: string;
+  language?: string;
+  /** Formato audio desiderato (dipende dal provider). */
+  responseFormat?: string;
+}
+
+export interface TextToSpeechResult {
+  audio: Blob;
+  mimeType: string;
+}
+
+export abstract class SpeechToTextProvider {
+  abstract transcribe(request: SpeechToTextRequest): Promise<SpeechToTextResult>;
+}
+
+export abstract class TextToSpeechProvider {
+  abstract synthesize(request: TextToSpeechRequest): Promise<TextToSpeechResult>;
+}

package/src/app/providers/voice/audio.types.ts

@@ -0,0 +1,40 @@
+/**
+ * Tipi condivisi per cattura microfono, VAD e registrazione (WebM).
+ */
+import type { VoiceStreamingSessionConfig } from './voice-streaming.types';
+
+export const DEFAULT_VOICE_AUDIO_CONSTRAINTS: MediaTrackConstraints = {
+  echoCancellation: true,
+  noiseSuppression: true,
+  autoGainControl: true,
+};
+
+export const DEFAULT_VOICE_MEDIA_STREAM_CONSTRAINTS: MediaStreamConstraints = {
+  audio: DEFAULT_VOICE_AUDIO_CONSTRAINTS,
+};
+
+export interface VoiceRecordedBlob {
+  blob: Blob;
+  mimeType: string;
+}
+
+/**
+ * Segmento audio dopo VAD; può includere `transcript` se STT è configurato e abilitato.
+ */
+export interface VoiceSegmentPayload extends VoiceRecordedBlob {
+  transcript?: string;
+  transcriptionError?: string;
+}
+
+export interface VoiceSessionStartOptions {
+  /** Opzionale se usi solo {@link VoiceService.audioSegment$}. */
+  onRecordingComplete?: (result: VoiceSegmentPayload) => void;
+  constraints?: MediaStreamConstraints;
+  /** Default `true`. Se `false`, non viene chiamato lo STT sul segmento. */
+  enableTranscription?: boolean;
+  /**
+   * Con `voiceIngressStream`: solo streaming WSS — niente VAD locale; transcript e TTS dal server.
+   * Senza: MicVAD + segmenti e upload/STT lato client.
+   */
+  voiceIngressStream?: VoiceStreamingSessionConfig | null;
+}

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

@@ -0,0 +1,28 @@
+import { Location } from '@angular/common';
+import { TestBed } from '@angular/core/testing';
+
+import { VadService } from './vad.service';
+
+describe('VadService', () => {
+  let service: VadService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [
+        VadService,
+        {
+          provide: Location,
+          useValue: {
+            prepareExternalUrl: (url: string) => `/${url}`,
+          },
+        },
+      ],
+    });
+    service = TestBed.inject(VadService);
+  });
+
+  it('should expose VAD and ONNX WASM base URLs with trailing slash', () => {
+    expect(service.getVadAssetBaseUrl()).toBe('/assets/vad/');
+    expect(service.getOnnxWasmBaseUrl()).toBe('/assets/onnx/');
+  });
+});

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

@@ -0,0 +1,70 @@
+import { Location } from '@angular/common';
+import { Injectable } from '@angular/core';
+import { MicVAD, getDefaultRealTimeVADOptions } from '@ricky0123/vad-web';
+import type { RealTimeVADOptions } from '@ricky0123/vad-web';
+
+/**
+ * MicVAD (@ricky0123/vad-web): modelli in assets/vad/, WASM ONNX in assets/onnx/
+ * (allineato a ort.env.wasm.wasmPaths = "/assets/onnx/").
+ */
+@Injectable({ providedIn: 'root' })
+export class VadService {
+  private onnxRuntimeEnvPromise: Promise<void> | null = null;
+
+  constructor(private readonly location: Location) {}
+
+  /**
+   * Base URL per silero_vad_legacy.onnx / vad.worklet.bundle.min.js
+   * (MicVAD usa baseAssetPath + nome file interno, non modelURL singolo).
+   */
+  getVadAssetBaseUrl(): string {
+    return this.ensureTrailingSlash(this.location.prepareExternalUrl('assets/vad/'));
+  }
+
+  /** Base URL per ort-wasm-*.mjs / .wasm (es. /assets/onnx/). */
+  getOnnxWasmBaseUrl(): string {
+    return this.ensureTrailingSlash(this.location.prepareExternalUrl('assets/onnx/'));
+  }
+
+  /**
+   * Pre-configura il modulo onnxruntime-web/wasm (stesso usato da MicVAD):
+   * wasmPaths + numThreads prima del primo MicVAD.new.
+   */
+  ensureOnnxRuntimeEnv(): Promise<void> {
+    if (!this.onnxRuntimeEnvPromise) {
+      this.onnxRuntimeEnvPromise = (async () => {
+        const ort = await import('onnxruntime-web/wasm');
+        const wasmBase = this.getOnnxWasmBaseUrl();
+        ort.env.wasm.wasmPaths = wasmBase;
+        ort.env.wasm.numThreads = 1;
+        ort.env.logLevel = 'error';
+      })();
+    }
+    return this.onnxRuntimeEnvPromise;
+  }
+
+  async createMicVad(overrides: Partial<RealTimeVADOptions>): Promise<MicVAD> {
+    await this.ensureOnnxRuntimeEnv();
+    const base = getDefaultRealTimeVADOptions('legacy');
+    const vadBase = this.getVadAssetBaseUrl();
+    const ortWasmBase = this.getOnnxWasmBaseUrl();
+
+    return MicVAD.new({
+      ...base,
+      startOnLoad: false,
+      baseAssetPath: vadBase,
+      onnxWASMBasePath: ortWasmBase,
+      ortConfig: (ort) => {
+        base.ortConfig?.(ort);
+        ort.env.wasm.wasmPaths = ortWasmBase;
+        ort.env.wasm.numThreads = 1;
+        ort.env.logLevel = 'error';
+      },
+      ...overrides,
+    });
+  }
+
+  private ensureTrailingSlash(path: string): string {
+    return path.endsWith('/') ? path : `${path}/`;
+  }
+}

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

@@ -0,0 +1,23 @@
+import { TestBed } from '@angular/core/testing';
+import { AppConfigService } from 'src/app/providers/app-config.service';
+import { VoiceStreamingService } from './voice-streaming.service';
+
+describe('VoiceStreamingService', () => {
+  let service: VoiceStreamingService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [
+        {
+          provide: AppConfigService,
+          useValue: { getConfig: () => ({ voiceProxyWsUrl: '' }) },
+        },
+      ],
+    });
+    service = TestBed.inject(VoiceStreamingService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});