@cartesia/cartesia-js 3.0.0-b11 → 3.0.0-b12

package/src/backcompat/types.ts

@@ -1,19 +1,19 @@
 export type Supplier<T> = T | Promise<T> | (() => T | Promise<T>);
 
 export interface CartesiaClientOptions {
-	environment?: Supplier<"https://api.cartesia.ai" | string>;
-	/** Specify a custom URL to connect the client to. */
-	baseUrl?: Supplier<string>;
-	apiKey?: Supplier<string | undefined>;
-	/** Override the Cartesia-Version header */
-	cartesiaVersion?: string;
-	fetcher?: any;
+  environment?: Supplier<'https://api.cartesia.ai' | string>;
+  /** Specify a custom URL to connect the client to. */
+  baseUrl?: Supplier<string>;
+  apiKey?: Supplier<string | undefined>;
+  /** Override the Cartesia-Version header */
+  cartesiaVersion?: string;
+  fetcher?: any;
 }
 
 export interface BackCompatRequestOptions {
-	timeoutInSeconds?: number;
-	maxRetries?: number;
-	abortSignal?: AbortSignal;
-	cartesiaVersion?: string;
-	headers?: Record<string, string>;
-}
+  timeoutInSeconds?: number;
+  maxRetries?: number;
+  abortSignal?: AbortSignal;
+  cartesiaVersion?: string;
+  headers?: Record<string, string>;
+}

package/src/backcompat/voice-changer-wrapper.ts

@@ -1,71 +1,73 @@
-import * as fs from "fs";
-import { Cartesia } from "../client";
-import { type Uploadable } from "../core/uploads";
-import { type RequestOptions as InternalRequestOptions } from "../internal/request-options";
-import { Readable } from "stream";
-import { BackCompatRequestOptions } from "./types";
-import { wrap } from "./errors";
+import * as fs from 'fs';
+import { Cartesia } from '../client';
+import { type Uploadable } from '../core/uploads';
+import { type RequestOptions as InternalRequestOptions } from '../internal/request-options';
+import { Readable } from 'stream';
+import { BackCompatRequestOptions } from './types';
+import { wrap } from './errors';
 
 export interface BackCompatVoiceChangerBytesRequest {
-	voiceId: string;
-	outputFormatContainer: "raw" | "wav" | "mp3";
-	outputFormatSampleRate: 8000 | 16000 | 22050 | 24000 | 44100 | 48000;
-	outputFormatEncoding?: "pcm_f32le" | "pcm_s16le" | "mulaw" | "alaw";
-	outputFormatBitRate?: 32000 | 64000 | 96000 | 128000 | 192000;
+  voiceId: string;
+  outputFormatContainer: 'raw' | 'wav' | 'mp3';
+  outputFormatSampleRate: 8000 | 16000 | 22050 | 24000 | 44100 | 48000;
+  outputFormatEncoding?: 'pcm_f32le' | 'pcm_s16le' | 'mulaw' | 'alaw';
+  outputFormatBitRate?: 32000 | 64000 | 96000 | 128000 | 192000;
 }
 
 /** @deprecated Use the new SDK's voice changer methods on the {@link Cartesia} instance instead. */
 export class VoiceChangerWrapper {
-	private client: Cartesia;
+  private client: Cartesia;
 
-	constructor(client: Cartesia) {
-		this.client = client;
-	}
+  constructor(client: Cartesia) {
+    this.client = client;
+  }
 
-	/** @deprecated Use {@link Cartesia.voiceChanger.changeVoiceBytes} instead. */
-	async bytes(
-		clip: File | fs.ReadStream | Blob,
-		request: BackCompatVoiceChangerBytesRequest,
-		requestOptions?: BackCompatRequestOptions
-	): Promise<Readable> {
-		const params: any = {
-			clip: clip as Uploadable,
-			"voice[id]": request.voiceId,
-			"output_format[container]": request.outputFormatContainer,
-			"output_format[sample_rate]": request.outputFormatSampleRate,
-		};
+  /** @deprecated Use {@link Cartesia.voiceChanger.changeVoiceBytes} instead. */
+  async bytes(
+    clip: File | fs.ReadStream | Blob,
+    request: BackCompatVoiceChangerBytesRequest,
+    requestOptions?: BackCompatRequestOptions,
+  ): Promise<Readable> {
+    const params: any = {
+      clip: clip as Uploadable,
+      'voice[id]': request.voiceId,
+      'output_format[container]': request.outputFormatContainer,
+      'output_format[sample_rate]': request.outputFormatSampleRate,
+    };
 
-		if (request.outputFormatEncoding) {
-			params["output_format[encoding]"] = request.outputFormatEncoding;
-		}
-		if (request.outputFormatBitRate) {
-			params["output_format[bit_rate]"] = request.outputFormatBitRate;
-		}
+    if (request.outputFormatEncoding) {
+      params['output_format[encoding]'] = request.outputFormatEncoding;
+    }
+    if (request.outputFormatBitRate) {
+      params['output_format[bit_rate]'] = request.outputFormatBitRate;
+    }
 
-		const options: InternalRequestOptions = {};
-		if (requestOptions) {
-			if (requestOptions.timeoutInSeconds) {
-				options.timeout = requestOptions.timeoutInSeconds * 1000;
-			}
-			if (requestOptions.maxRetries !== undefined) {
-				options.maxRetries = requestOptions.maxRetries;
-			}
-			options.headers = requestOptions.headers;
-			options.signal = requestOptions.abortSignal;
-		}
+    const options: InternalRequestOptions = {};
+    if (requestOptions) {
+      if (requestOptions.timeoutInSeconds) {
+        options.timeout = requestOptions.timeoutInSeconds * 1000;
+      }
+      if (requestOptions.maxRetries !== undefined) {
+        options.maxRetries = requestOptions.maxRetries;
+      }
+      options.headers = requestOptions.headers;
+      options.signal = requestOptions.abortSignal;
+    }
 
-		const response = await wrap(this.client.voiceChanger.changeVoiceBytes(params, {
-			...options,
-			__binaryResponse: true,
-		} as any));
+    const response = await wrap(
+      this.client.voiceChanger.changeVoiceBytes(params, {
+        ...options,
+        __binaryResponse: true,
+      } as any),
+    );
 
-		const responseAny = response as any;
+    const responseAny = response as any;
 
-		if (!responseAny.body) {
-			throw new Error("Response body is null");
-		}
+    if (!responseAny.body) {
+      throw new Error('Response body is null');
+    }
 
-		// @ts-ignore
-		return Readable.fromWeb(responseAny.body);
-	}
+    // @ts-ignore
+    return Readable.fromWeb(responseAny.body);
+  }
 }

package/src/backcompat/voices-wrapper.ts

@@ -1,163 +1,230 @@
-import * as fs from "fs";
-import { Cartesia } from "../client";
-import { type Uploadable } from "../core/uploads";
+import * as fs from 'fs';
+import { Cartesia } from '../client';
+import { type Uploadable } from '../core/uploads';
 import {
-	type VoiceCloneParams,
-	type VoiceMetadata,
-	type SupportedLanguage,
-	type VoiceUpdateParams,
-	type Voice,
-	type VoiceLocalizeParams,
-} from "../resources/voices";
-import { type RequestOptions as InternalRequestOptions } from "../internal/request-options";
-import { BackCompatRequestOptions } from "./types";
-import { wrap } from "./errors";
+  type VoiceCloneParams,
+  type VoiceMetadata,
+  type SupportedLanguage,
+  type VoiceUpdateParams,
+  type Voice,
+  type VoiceLocalizeParams,
+  type VoiceListParams,
+} from '../resources/voices';
+import { type RequestOptions as InternalRequestOptions } from '../internal/request-options';
+import { BackCompatRequestOptions } from './types';
+import { wrap } from './errors';
+
+export interface BackCompatVoiceListOptions {
+  gender?: 'masculine' | 'feminine' | 'gender_neutral' | null;
+  isOwner?: boolean | null;
+  limit?: number | null;
+  q?: string | null;
+  expand?: Array<'preview_file_url'> | null;
+}
 
 export interface BackCompatCloneVoiceRequest {
-	name: string;
-	description?: string;
-	language: string;
-	mode: "similarity" | "stability";
-	enhance?: boolean;
-	baseVoiceId?: string;
+  name: string;
+  description?: string;
+  language: string;
+  mode: 'similarity' | 'stability';
+  enhance?: boolean;
+  baseVoiceId?: string;
 }
 
 export interface BackCompatUpdateVoiceRequest {
-	name: string;
-	description: string;
+  name: string;
+  description: string;
 }
 
 export interface BackCompatLocalizeVoiceRequest {
-	voiceId: string;
-	name: string;
-	description: string;
-	language:
-		| "en"
-		| "de"
-		| "es"
-		| "fr"
-		| "ja"
-		| "pt"
-		| "zh"
-		| "hi"
-		| "it"
-		| "ko"
-		| "nl"
-		| "pl"
-		| "ru"
-		| "sv"
-		| "tr";
-	originalSpeakerGender: "male" | "female";
-	dialect?:
-		| "au"
-		| "in"
-		| "so"
-		| "uk"
-		| "us"
-		| "mx"
-		| "pe"
-		| "br"
-		| "eu"
-		| "ca";
+  voiceId: string;
+  name: string;
+  description: string;
+  language:
+    | 'en'
+    | 'de'
+    | 'es'
+    | 'fr'
+    | 'ja'
+    | 'pt'
+    | 'zh'
+    | 'hi'
+    | 'it'
+    | 'ko'
+    | 'nl'
+    | 'pl'
+    | 'ru'
+    | 'sv'
+    | 'tr';
+  originalSpeakerGender: 'male' | 'female';
+  dialect?: 'au' | 'in' | 'so' | 'uk' | 'us' | 'mx' | 'pe' | 'br' | 'eu' | 'ca';
 }
 
 /** @deprecated Use the new SDK's voices methods on the {@link Cartesia} instance instead. */
 export class VoicesWrapper {
-	private client: Cartesia;
-
-	constructor(client: Cartesia) {
-		this.client = client;
-	}
-
-	/** @deprecated Use {@link Cartesia.voices.clone} instead. */
-	async clone(
-		clip: File | fs.ReadStream | Blob,
-		request: BackCompatCloneVoiceRequest,
-		requestOptions?: BackCompatRequestOptions
-	): Promise<VoiceMetadata> {
-		const params: VoiceCloneParams = {
-			clip: clip as Uploadable,
-			name: request.name,
-			language: request.language as SupportedLanguage,
-		};
-
-		if (request.description !== undefined) {
-			params.description = request.description;
-		}
-		if (request.baseVoiceId !== undefined) {
-			params.base_voice_id = request.baseVoiceId;
-		}
-
-		const options: InternalRequestOptions = {};
-		if (requestOptions) {
-			if (requestOptions.timeoutInSeconds) {
-				options.timeout = requestOptions.timeoutInSeconds * 1000;
-			}
-			if (requestOptions.maxRetries !== undefined) {
-				options.maxRetries = requestOptions.maxRetries;
-			}
-			options.headers = requestOptions.headers;
-			options.signal = requestOptions.abortSignal;
-		}
-
-		return wrap(this.client.voices.clone(params, options));
-	}
-
-	/** @deprecated Use {@link Cartesia.voices.update} instead. */
-	async update(
-		id: string,
-		request: BackCompatUpdateVoiceRequest,
-		requestOptions?: BackCompatRequestOptions
-	): Promise<Voice> {
-		const params: VoiceUpdateParams = {
-			name: request.name,
-			description: request.description,
-		};
-
-		const options: InternalRequestOptions = {};
-		if (requestOptions) {
-			if (requestOptions.timeoutInSeconds) {
-				options.timeout = requestOptions.timeoutInSeconds * 1000;
-			}
-			if (requestOptions.maxRetries !== undefined) {
-				options.maxRetries = requestOptions.maxRetries;
-			}
-			options.headers = requestOptions.headers;
-			options.signal = requestOptions.abortSignal;
-		}
-
-		return wrap(this.client.voices.update(id, params, options));
-	}
-
-	/** @deprecated Use {@link Cartesia.voices.localize} instead. */
-	async localize(
-		request: BackCompatLocalizeVoiceRequest,
-		requestOptions?: BackCompatRequestOptions
-	): Promise<VoiceMetadata> {
-		const params: VoiceLocalizeParams = {
-			voice_id: request.voiceId,
-			name: request.name,
-			description: request.description,
-			language: request.language as any,
-			original_speaker_gender: request.originalSpeakerGender,
-		};
-
-		if (request.dialect) {
-			params.dialect = request.dialect as any; // Cast dialect as list might vary slightly or be strict
-		}
-
-		const options: InternalRequestOptions = {};
-		if (requestOptions) {
-			if (requestOptions.timeoutInSeconds) {
-				options.timeout = requestOptions.timeoutInSeconds * 1000;
-			}
-			if (requestOptions.maxRetries !== undefined) {
-				options.maxRetries = requestOptions.maxRetries;
-			}
-			options.headers = requestOptions.headers;
-			options.signal = requestOptions.abortSignal;
-		}
-
-		return wrap(this.client.voices.localize(params, options));
-	}
-}
+  private client: Cartesia;
+
+  constructor(client: Cartesia) {
+    this.client = client;
+  }
+
+  /** @deprecated Use {@link Cartesia.voices.clone} instead. */
+  async clone(
+    clip: File | fs.ReadStream | Blob,
+    request: BackCompatCloneVoiceRequest,
+    requestOptions?: BackCompatRequestOptions,
+  ): Promise<VoiceMetadata> {
+    const params: VoiceCloneParams = {
+      clip: clip as Uploadable,
+      name: request.name,
+      language: request.language as SupportedLanguage,
+    };
+
+    if (request.description !== undefined) {
+      params.description = request.description;
+    }
+    if (request.baseVoiceId !== undefined) {
+      params.base_voice_id = request.baseVoiceId;
+    }
+
+    const options: InternalRequestOptions = {};
+    if (requestOptions) {
+      if (requestOptions.timeoutInSeconds) {
+        options.timeout = requestOptions.timeoutInSeconds * 1000;
+      }
+      if (requestOptions.maxRetries !== undefined) {
+        options.maxRetries = requestOptions.maxRetries;
+      }
+      options.headers = requestOptions.headers;
+      options.signal = requestOptions.abortSignal;
+    }
+
+    return wrap(this.client.voices.clone(params, options));
+  }
+
+  /** @deprecated Use {@link Cartesia.voices.update} instead. */
+  async update(
+    id: string,
+    request: BackCompatUpdateVoiceRequest,
+    requestOptions?: BackCompatRequestOptions,
+  ): Promise<Voice> {
+    const params: VoiceUpdateParams = {
+      name: request.name,
+      description: request.description,
+    };
+
+    const options: InternalRequestOptions = {};
+    if (requestOptions) {
+      if (requestOptions.timeoutInSeconds) {
+        options.timeout = requestOptions.timeoutInSeconds * 1000;
+      }
+      if (requestOptions.maxRetries !== undefined) {
+        options.maxRetries = requestOptions.maxRetries;
+      }
+      options.headers = requestOptions.headers;
+      options.signal = requestOptions.abortSignal;
+    }
+
+    return wrap(this.client.voices.update(id, params, options));
+  }
+
+  /** @deprecated Use {@link Cartesia.voices.localize} instead. */
+  async localize(
+    request: BackCompatLocalizeVoiceRequest,
+    requestOptions?: BackCompatRequestOptions,
+  ): Promise<VoiceMetadata> {
+    const params: VoiceLocalizeParams = {
+      voice_id: request.voiceId,
+      name: request.name,
+      description: request.description,
+      language: request.language as any,
+      original_speaker_gender: request.originalSpeakerGender,
+    };
+
+    if (request.dialect) {
+      params.dialect = request.dialect as any; // Cast dialect as list might vary slightly or be strict
+    }
+
+    const options: InternalRequestOptions = {};
+    if (requestOptions) {
+      if (requestOptions.timeoutInSeconds) {
+        options.timeout = requestOptions.timeoutInSeconds * 1000;
+      }
+      if (requestOptions.maxRetries !== undefined) {
+        options.maxRetries = requestOptions.maxRetries;
+      }
+      options.headers = requestOptions.headers;
+      options.signal = requestOptions.abortSignal;
+    }
+
+    return wrap(this.client.voices.localize(params, options));
+  }
+
+  /** @deprecated Use {@link Cartesia.voices.get} instead. */
+  async get(id: string, requestOptions?: BackCompatRequestOptions): Promise<Voice> {
+    const options: InternalRequestOptions = {};
+    if (requestOptions) {
+      if (requestOptions.timeoutInSeconds) {
+        options.timeout = requestOptions.timeoutInSeconds * 1000;
+      }
+      if (requestOptions.maxRetries !== undefined) {
+        options.maxRetries = requestOptions.maxRetries;
+      }
+      options.headers = requestOptions.headers;
+      options.signal = requestOptions.abortSignal;
+    }
+
+    return wrap(this.client.voices.get(id, {}, options));
+  }
+
+  /** @deprecated Use {@link Cartesia.voices.list} instead. */
+  async list(
+    listOptions?: BackCompatVoiceListOptions,
+    requestOptions?: BackCompatRequestOptions,
+  ): Promise<Voice[]> {
+    const params: VoiceListParams = {};
+    if (listOptions) {
+      if (listOptions.gender !== undefined) params.gender = listOptions.gender;
+      if (listOptions.isOwner !== undefined) params.is_owner = listOptions.isOwner;
+      if (listOptions.limit !== undefined) params.limit = listOptions.limit;
+      if (listOptions.q !== undefined) params.q = listOptions.q;
+      if (listOptions.expand !== undefined) params.expand = listOptions.expand;
+    }
+
+    const options: InternalRequestOptions = {};
+    if (requestOptions) {
+      if (requestOptions.timeoutInSeconds) {
+        options.timeout = requestOptions.timeoutInSeconds * 1000;
+      }
+      if (requestOptions.maxRetries !== undefined) {
+        options.maxRetries = requestOptions.maxRetries;
+      }
+      options.headers = requestOptions.headers;
+      options.signal = requestOptions.abortSignal;
+    }
+
+    // The new SDK returns a paginated result, we collect all pages
+    const voices: Voice[] = [];
+    for await (const voice of this.client.voices.list(params, options)) {
+      voices.push(voice);
+    }
+    return voices;
+  }
+
+  /** @deprecated Use {@link Cartesia.voices.remove} instead. */
+  async remove(id: string, requestOptions?: BackCompatRequestOptions): Promise<void> {
+    const options: InternalRequestOptions = {};
+    if (requestOptions) {
+      if (requestOptions.timeoutInSeconds) {
+        options.timeout = requestOptions.timeoutInSeconds * 1000;
+      }
+      if (requestOptions.maxRetries !== undefined) {
+        options.maxRetries = requestOptions.maxRetries;
+      }
+      options.headers = requestOptions.headers;
+      options.signal = requestOptions.abortSignal;
+    }
+
+    return wrap(this.client.voices.remove(id, options));
+  }
+}

package/src/resources/agents/agents.ts

@@ -47,16 +47,6 @@ export class Agents extends APIResource {
     return this._client.get('/agents', options);
   }
 
-  /**
-   * Delete Agent
-   */
-  delete(agentID: string, options?: RequestOptions): APIPromise<void> {
-    return this._client.delete(path`/agents/${agentID}`, {
-      ...options,
-      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
-    });
-  }
-
   /**
    * List the phone numbers associated with an agent. Currently, you can only have
    * one phone number per agent and these are provisioned by Cartesia.
@@ -71,6 +61,16 @@ export class Agents extends APIResource {
   listTemplates(options?: RequestOptions): APIPromise<AgentListTemplatesResponse> {
     return this._client.get('/agents/templates', options);
   }
+
+  /**
+   * Delete Agent
+   */
+  remove(agentID: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.delete(path`/agents/${agentID}`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
 }
 
 /**

package/src/resources/agents/calls.ts

@@ -28,11 +28,10 @@ export class Calls extends APIResource {
    * The downloaded audio file is in .wav format. This endpoint streams the audio
    * file content (WAV format) to the client.
    */
-  downloadAudio(callID: string, options?: RequestOptions): APIPromise<Response> {
+  downloadAudio(callID: string, options?: RequestOptions): APIPromise<void> {
     return this._client.get(path`/agents/calls/${callID}/audio`, {
       ...options,
-      headers: buildHeaders([{ Accept: 'audio/wav' }, options?.headers]),
-      __binaryResponse: true,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
     });
   }
 }

package/src/resources/datasets/datasets.ts

@@ -3,10 +3,10 @@
 import { APIResource } from '../../core/resource';
 import * as FilesAPI from './files';
 import {
-  FileDeleteParams,
   FileListParams,
   FileListResponse,
   FileListResponsesCursorIDPage,
+  FileRemoveParams,
   FileUploadParams,
   Files,
 } from './files';
@@ -57,7 +57,7 @@ export class Datasets extends APIResource {
   /**
    * Delete a dataset
    */
-  delete(id: string, options?: RequestOptions): APIPromise<void> {
+  remove(id: string, options?: RequestOptions): APIPromise<void> {
     return this._client.delete(path`/datasets/${id}`, {
       ...options,
       headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
@@ -139,7 +139,7 @@ export declare namespace Datasets {
     type FileListResponse as FileListResponse,
     type FileListResponsesCursorIDPage as FileListResponsesCursorIDPage,
     type FileListParams as FileListParams,
-    type FileDeleteParams as FileDeleteParams,
+    type FileRemoveParams as FileRemoveParams,
     type FileUploadParams as FileUploadParams,
   };
 }

package/src/resources/datasets/files.ts

@@ -27,7 +27,7 @@ export class Files extends APIResource {
   /**
    * Remove a file from a dataset
    */
-  delete(fileID: string, params: FileDeleteParams, options?: RequestOptions): APIPromise<void> {
+  remove(fileID: string, params: FileRemoveParams, options?: RequestOptions): APIPromise<void> {
     const { id } = params;
     return this._client.delete(path`/datasets/${id}/files/${fileID}`, {
       ...options,
@@ -83,7 +83,7 @@ export interface FileListParams extends CursorIDPageParams {
   limit?: number | null;
 }
 
-export interface FileDeleteParams {
+export interface FileRemoveParams {
   /**
    * ID of the dataset containing the file
    */
@@ -104,7 +104,7 @@ export declare namespace Files {
     type FileListResponse as FileListResponse,
     type FileListResponsesCursorIDPage as FileListResponsesCursorIDPage,
     type FileListParams as FileListParams,
-    type FileDeleteParams as FileDeleteParams,
+    type FileRemoveParams as FileRemoveParams,
     type FileUploadParams as FileUploadParams,
   };
 }

package/src/resources/datasets/index.ts

@@ -12,7 +12,7 @@ export {
   Files,
   type FileListResponse,
   type FileListParams,
-  type FileDeleteParams,
+  type FileRemoveParams,
   type FileUploadParams,
   type FileListResponsesCursorIDPage,
 } from './files';