@hasna/connectors 0.0.1

package/connectors/connect-elevenlabs/src/api/sts.ts

@@ -0,0 +1,109 @@
+import type { ElevenLabsClient } from './client';
+import type { STSRequest, STSModelId, AudioFormat, VoiceSettings } from '../types';
+import { DEFAULT_AUDIO_FORMAT } from '../types';
+
+/**
+ * Speech-to-Speech API module
+ * Voice conversion - transform one voice into another
+ */
+export class STSApi {
+  constructor(private readonly client: ElevenLabsClient) {}
+
+  /**
+   * Convert speech from one voice to another
+   */
+  async convert(
+    voiceId: string,
+    audioFile: File | Blob,
+    options?: {
+      modelId?: STSModelId;
+      voiceSettings?: VoiceSettings;
+      seed?: number;
+      removeBackgroundNoise?: boolean;
+      outputFormat?: AudioFormat;
+    }
+  ): Promise<ArrayBuffer> {
+    const formData = new FormData();
+    formData.append('audio', audioFile);
+
+    if (options?.modelId) {
+      formData.append('model_id', options.modelId);
+    }
+    if (options?.voiceSettings) {
+      formData.append('voice_settings', JSON.stringify(options.voiceSettings));
+    }
+    if (options?.seed !== undefined) {
+      formData.append('seed', String(options.seed));
+    }
+    if (options?.removeBackgroundNoise !== undefined) {
+      formData.append('remove_background_noise', String(options.removeBackgroundNoise));
+    }
+
+    const params: Record<string, string | number | boolean | undefined> = {
+      output_format: options?.outputFormat || DEFAULT_AUDIO_FORMAT,
+    };
+
+    return this.client.post<ArrayBuffer>(
+      `/v1/speech-to-speech/${voiceId}`,
+      formData,
+      params,
+      { responseType: 'arraybuffer' }
+    );
+  }
+
+  /**
+   * Convert speech with streaming
+   */
+  async stream(
+    voiceId: string,
+    audioFile: File | Blob,
+    options?: {
+      modelId?: STSModelId;
+      voiceSettings?: VoiceSettings;
+      removeBackgroundNoise?: boolean;
+      outputFormat?: AudioFormat;
+    }
+  ): Promise<ArrayBuffer> {
+    const formData = new FormData();
+    formData.append('audio', audioFile);
+
+    if (options?.modelId) {
+      formData.append('model_id', options.modelId);
+    }
+    if (options?.voiceSettings) {
+      formData.append('voice_settings', JSON.stringify(options.voiceSettings));
+    }
+    if (options?.removeBackgroundNoise !== undefined) {
+      formData.append('remove_background_noise', String(options.removeBackgroundNoise));
+    }
+
+    const params: Record<string, string | number | boolean | undefined> = {
+      output_format: options?.outputFormat || DEFAULT_AUDIO_FORMAT,
+    };
+
+    return this.client.post<ArrayBuffer>(
+      `/v1/speech-to-speech/${voiceId}/stream`,
+      formData,
+      params,
+      { responseType: 'arraybuffer' }
+    );
+  }
+
+  /**
+   * Get available models for STS
+   */
+  getAvailableModels(): { id: STSModelId; name: string; description: string }[] {
+    return [
+      {
+        id: 'eleven_multilingual_sts_v2',
+        name: 'Eleven Multilingual STS v2',
+        description: 'Multilingual voice conversion, 29 languages',
+      },
+      {
+        id: 'eleven_english_sts_v2',
+        name: 'Eleven English STS v2',
+        description: 'English-only voice conversion',
+      },
+    ];
+  }
+}

package/connectors/connect-elevenlabs/src/api/stt.ts

@@ -0,0 +1,93 @@
+import type { ElevenLabsClient } from './client';
+import type { STTRequest, STTResponse, STTModelId } from '../types';
+
+/**
+ * Speech-to-Text API module
+ * Transcribe audio to text using Scribe models
+ */
+export class STTApi {
+  constructor(private readonly client: ElevenLabsClient) {}
+
+  /**
+   * Transcribe audio file to text
+   */
+  async transcribe(
+    audioFile: File | Blob,
+    options?: {
+      modelId?: STTModelId;
+      languageCode?: string;
+      tagAudioEvents?: boolean;
+      numSpeakers?: number;
+      timestampsGranularity?: 'word' | 'character' | 'segment';
+      diarize?: boolean;
+    }
+  ): Promise<STTResponse> {
+    const formData = new FormData();
+    formData.append('file', audioFile);
+
+    if (options?.modelId) {
+      formData.append('model_id', options.modelId);
+    }
+    if (options?.languageCode) {
+      formData.append('language_code', options.languageCode);
+    }
+    if (options?.tagAudioEvents !== undefined) {
+      formData.append('tag_audio_events', String(options.tagAudioEvents));
+    }
+    if (options?.numSpeakers !== undefined) {
+      formData.append('num_speakers', String(options.numSpeakers));
+    }
+    if (options?.timestampsGranularity) {
+      formData.append('timestamps_granularity', options.timestampsGranularity);
+    }
+    if (options?.diarize !== undefined) {
+      formData.append('diarize', String(options.diarize));
+    }
+
+    return this.client.uploadFile<STTResponse>('/v1/speech-to-text', formData);
+  }
+
+  /**
+   * Transcribe audio from URL
+   */
+  async transcribeFromUrl(
+    audioUrl: string,
+    options?: {
+      modelId?: STTModelId;
+      languageCode?: string;
+      tagAudioEvents?: boolean;
+      numSpeakers?: number;
+      timestampsGranularity?: 'word' | 'character' | 'segment';
+      diarize?: boolean;
+    }
+  ): Promise<STTResponse> {
+    // First fetch the audio
+    const response = await fetch(audioUrl);
+    const blob = await response.blob();
+
+    return this.transcribe(blob, options);
+  }
+
+  /**
+   * Get available models for STT
+   */
+  getAvailableModels(): { id: STTModelId; name: string; description: string }[] {
+    return [
+      {
+        id: 'scribe_v2',
+        name: 'Scribe v2',
+        description: 'Best quality transcription, 90+ languages, speaker diarization',
+      },
+      {
+        id: 'scribe_v2_realtime',
+        name: 'Scribe v2 Realtime',
+        description: 'Real-time transcription (~150ms latency), 90+ languages',
+      },
+      {
+        id: 'scribe_v1',
+        name: 'Scribe v1',
+        description: 'Legacy model (use v2 for better results)',
+      },
+    ];
+  }
+}

package/connectors/connect-elevenlabs/src/api/tts.ts

@@ -0,0 +1,175 @@
+import type { ElevenLabsClient } from './client';
+import type {
+  TTSRequest,
+  TTSOptions,
+  TTSModelId,
+  AudioFormat,
+  VoiceSettings,
+} from '../types';
+import { DEFAULT_TTS_MODEL, DEFAULT_AUDIO_FORMAT, DEFAULT_VOICE_SETTINGS } from '../types';
+
+/**
+ * Text-to-Speech API module
+ * Convert text to speech using various models
+ */
+export class TTSApi {
+  constructor(private readonly client: ElevenLabsClient) {}
+
+  /**
+   * Convert text to speech
+   * Returns audio as ArrayBuffer
+   */
+  async convert(
+    voiceId: string,
+    text: string,
+    options?: {
+      modelId?: TTSModelId;
+      outputFormat?: AudioFormat;
+      voiceSettings?: VoiceSettings;
+      languageCode?: string;
+      seed?: number;
+      previousText?: string;
+      nextText?: string;
+      optimizeStreamingLatency?: 0 | 1 | 2 | 3 | 4;
+    }
+  ): Promise<ArrayBuffer> {
+    const body: TTSRequest = {
+      text,
+      model_id: options?.modelId || DEFAULT_TTS_MODEL,
+      voice_settings: options?.voiceSettings,
+      language_code: options?.languageCode,
+      seed: options?.seed,
+      previous_text: options?.previousText,
+      next_text: options?.nextText,
+    };
+
+    const params: Record<string, string | number | boolean | undefined> = {
+      output_format: options?.outputFormat || DEFAULT_AUDIO_FORMAT,
+      optimize_streaming_latency: options?.optimizeStreamingLatency,
+    };
+
+    return this.client.post<ArrayBuffer>(
+      `/v1/text-to-speech/${voiceId}`,
+      body,
+      params,
+      { responseType: 'arraybuffer' }
+    );
+  }
+
+  /**
+   * Convert text to speech with streaming
+   * Returns audio as ArrayBuffer (streamed response)
+   */
+  async stream(
+    voiceId: string,
+    text: string,
+    options?: {
+      modelId?: TTSModelId;
+      outputFormat?: AudioFormat;
+      voiceSettings?: VoiceSettings;
+      languageCode?: string;
+      optimizeStreamingLatency?: 0 | 1 | 2 | 3 | 4;
+    }
+  ): Promise<ArrayBuffer> {
+    const body: TTSRequest = {
+      text,
+      model_id: options?.modelId || DEFAULT_TTS_MODEL,
+      voice_settings: options?.voiceSettings,
+      language_code: options?.languageCode,
+    };
+
+    const params: Record<string, string | number | boolean | undefined> = {
+      output_format: options?.outputFormat || DEFAULT_AUDIO_FORMAT,
+      optimize_streaming_latency: options?.optimizeStreamingLatency ?? 3,
+    };
+
+    return this.client.post<ArrayBuffer>(
+      `/v1/text-to-speech/${voiceId}/stream`,
+      body,
+      params,
+      { responseType: 'arraybuffer' }
+    );
+  }
+
+  /**
+   * Convert text to speech with timestamps
+   * Returns audio + character-level timestamps
+   */
+  async convertWithTimestamps(
+    voiceId: string,
+    text: string,
+    options?: {
+      modelId?: TTSModelId;
+      outputFormat?: AudioFormat;
+      voiceSettings?: VoiceSettings;
+      languageCode?: string;
+    }
+  ): Promise<{
+    audio_base64: string;
+    alignment: {
+      characters: string[];
+      character_start_times_seconds: number[];
+      character_end_times_seconds: number[];
+    };
+    normalized_alignment?: {
+      characters: string[];
+      character_start_times_seconds: number[];
+      character_end_times_seconds: number[];
+    };
+  }> {
+    const body: TTSRequest = {
+      text,
+      model_id: options?.modelId || DEFAULT_TTS_MODEL,
+      voice_settings: options?.voiceSettings,
+      language_code: options?.languageCode,
+    };
+
+    const params: Record<string, string | number | boolean | undefined> = {
+      output_format: options?.outputFormat || DEFAULT_AUDIO_FORMAT,
+    };
+
+    return this.client.post(
+      `/v1/text-to-speech/${voiceId}/with-timestamps`,
+      body,
+      params
+    );
+  }
+
+  /**
+   * Get available models for TTS
+   */
+  getAvailableModels(): { id: TTSModelId; name: string; description: string }[] {
+    return [
+      {
+        id: 'eleven_v3',
+        name: 'Eleven v3',
+        description: 'Latest model - most expressive, 70+ languages, 5k char limit',
+      },
+      {
+        id: 'eleven_multilingual_v2',
+        name: 'Eleven Multilingual v2',
+        description: 'Stable for long-form, 29 languages, 10k char limit',
+      },
+      {
+        id: 'eleven_flash_v2_5',
+        name: 'Eleven Flash v2.5',
+        description: 'Ultra-low latency (~75ms), 32 languages, 40k char limit',
+      },
+      {
+        id: 'eleven_flash_v2',
+        name: 'Eleven Flash v2',
+        description: 'Ultra-low latency (~75ms), English only, 30k char limit',
+      },
+      {
+        id: 'eleven_turbo_v2_5',
+        name: 'Eleven Turbo v2.5',
+        description: 'Balanced quality/speed (~250ms), 32 languages, 40k char limit',
+      },
+      {
+        id: 'eleven_turbo_v2',
+        name: 'Eleven Turbo v2',
+        description: 'Balanced quality/speed (~250ms), English only, 30k char limit',
+      },
+    ];
+  }
+}

package/connectors/connect-elevenlabs/src/api/user.ts

@@ -0,0 +1,43 @@
+import type { ElevenLabsClient } from './client';
+import type { User, Subscription } from '../types';
+
+/**
+ * User API module
+ * Get user info and subscription details
+ */
+export class UserApi {
+  constructor(private readonly client: ElevenLabsClient) {}
+
+  /**
+   * Get current user info
+   */
+  async get(): Promise<User> {
+    return this.client.get<User>('/v1/user');
+  }
+
+  /**
+   * Get subscription info
+   */
+  async getSubscription(): Promise<Subscription> {
+    return this.client.get<Subscription>('/v1/user/subscription');
+  }
+
+  /**
+   * Get character usage info
+   */
+  async getUsage(): Promise<{
+    characterCount: number;
+    characterLimit: number;
+    percentUsed: number;
+    nextResetUnix: number;
+  }> {
+    const subscription = await this.getSubscription();
+
+    return {
+      characterCount: subscription.character_count,
+      characterLimit: subscription.character_limit,
+      percentUsed: Math.round((subscription.character_count / subscription.character_limit) * 100),
+      nextResetUnix: subscription.next_character_count_reset_unix,
+    };
+  }
+}

package/connectors/connect-elevenlabs/src/api/voices.ts

@@ -0,0 +1,169 @@
+import type { ElevenLabsClient } from './client';
+import type { Voice, VoicesResponse, VoiceSettings } from '../types';
+
+/**
+ * Voices API module
+ * Manage voices - list, get, add (clone), edit, delete
+ */
+export class VoicesApi {
+  constructor(private readonly client: ElevenLabsClient) {}
+
+  /**
+   * List all voices (v2 API with pagination)
+   */
+  async list(options?: {
+    pageSize?: number;
+    search?: string;
+    category?: 'premade' | 'cloned' | 'generated' | 'professional';
+    sort?: 'created_at_asc' | 'created_at_desc' | 'name_asc' | 'name_desc';
+    cursor?: string;
+  }): Promise<VoicesResponse> {
+    const params: Record<string, string | number | boolean | undefined> = {
+      page_size: options?.pageSize,
+      search: options?.search,
+      category: options?.category,
+      sort: options?.sort,
+      cursor: options?.cursor,
+    };
+
+    return this.client.get<VoicesResponse>('/v2/voices', params);
+  }
+
+  /**
+   * List all voices (v1 API - simpler, no pagination)
+   */
+  async listAll(): Promise<{ voices: Voice[] }> {
+    return this.client.get<{ voices: Voice[] }>('/v1/voices');
+  }
+
+  /**
+   * Get a specific voice by ID
+   */
+  async get(voiceId: string, withSettings: boolean = true): Promise<Voice> {
+    return this.client.get<Voice>(`/v1/voices/${voiceId}`, {
+      with_settings: withSettings,
+    });
+  }
+
+  /**
+   * Get default voice settings
+   */
+  async getDefaultSettings(): Promise<VoiceSettings> {
+    return this.client.get<VoiceSettings>('/v1/voices/settings/default');
+  }
+
+  /**
+   * Get voice settings
+   */
+  async getSettings(voiceId: string): Promise<VoiceSettings> {
+    return this.client.get<VoiceSettings>(`/v1/voices/${voiceId}/settings`);
+  }
+
+  /**
+   * Edit voice settings
+   */
+  async editSettings(voiceId: string, settings: VoiceSettings): Promise<VoiceSettings> {
+    return this.client.post<VoiceSettings>(`/v1/voices/${voiceId}/settings/edit`, settings);
+  }
+
+  /**
+   * Add/clone a voice from audio files
+   * Use FormData to upload files
+   */
+  async add(options: {
+    name: string;
+    files: File[] | Blob[];
+    description?: string;
+    labels?: Record<string, string>;
+    removeBackgroundNoise?: boolean;
+  }): Promise<Voice> {
+    const formData = new FormData();
+    formData.append('name', options.name);
+
+    if (options.description) {
+      formData.append('description', options.description);
+    }
+
+    if (options.labels) {
+      formData.append('labels', JSON.stringify(options.labels));
+    }
+
+    if (options.removeBackgroundNoise) {
+      formData.append('remove_background_noise', 'true');
+    }
+
+    for (const file of options.files) {
+      formData.append('files', file);
+    }
+
+    return this.client.uploadFile<Voice>('/v1/voices/add', formData);
+  }
+
+  /**
+   * Edit a voice's metadata
+   */
+  async edit(voiceId: string, options: {
+    name?: string;
+    description?: string;
+    labels?: Record<string, string>;
+  }): Promise<Voice> {
+    const formData = new FormData();
+
+    if (options.name) {
+      formData.append('name', options.name);
+    }
+    if (options.description) {
+      formData.append('description', options.description);
+    }
+    if (options.labels) {
+      formData.append('labels', JSON.stringify(options.labels));
+    }
+
+    return this.client.uploadFile<Voice>(`/v1/voices/${voiceId}/edit`, formData);
+  }
+
+  /**
+   * Delete a voice
+   */
+  async delete(voiceId: string): Promise<{ status: string }> {
+    return this.client.delete<{ status: string }>(`/v1/voices/${voiceId}`);
+  }
+
+  /**
+   * Get shared voices from the voice library
+   */
+  async getShared(options?: {
+    pageSize?: number;
+    category?: string;
+    gender?: string;
+    age?: string;
+    accent?: string;
+    language?: string;
+    search?: string;
+    sort?: string;
+    page?: number;
+  }): Promise<{ voices: Voice[]; has_more: boolean }> {
+    const params: Record<string, string | number | boolean | undefined> = {
+      page_size: options?.pageSize || 30,
+      category: options?.category,
+      gender: options?.gender,
+      age: options?.age,
+      accent: options?.accent,
+      language: options?.language,
+      search: options?.search,
+      sort: options?.sort,
+      page: options?.page,
+    };
+
+    return this.client.get<{ voices: Voice[]; has_more: boolean }>('/v1/shared-voices', params);
+  }
+
+  /**
+   * Add a shared voice to your library
+   */
+  async addShared(publicOwnerId: string, voiceId: string, newName: string): Promise<Voice> {
+    return this.client.post<Voice>(`/v1/voices/add/${publicOwnerId}/${voiceId}`, {
+      new_name: newName,
+    });
+  }
+}