@supertone/supertone 0.1.0

package/src/sdk/texttospeech.ts

@@ -0,0 +1,488 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import {
+	CreateSpeechAcceptEnum,
+	textToSpeechCreateSpeech,
+} from "../funcs/textToSpeechCreateSpeech.js";
+import { textToSpeechPredictDuration } from "../funcs/textToSpeechPredictDuration.js";
+import {
+	StreamSpeechAcceptEnum,
+	textToSpeechStreamSpeech,
+} from "../funcs/textToSpeechStreamSpeech.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+// #region imports
+import {
+	chunkText,
+	DEFAULT_MAX_TEXT_LENGTH,
+	detectAudioFormat,
+	mergeMp3Binary,
+	mergeWavBinary,
+	removeMp3Header,
+	removeWavHeader,
+} from "../lib/custom_utils/index.js";
+// #endregion imports
+
+export { CreateSpeechAcceptEnum } from "../funcs/textToSpeechCreateSpeech.js";
+
+export { StreamSpeechAcceptEnum } from "../funcs/textToSpeechStreamSpeech.js";
+
+export class TextToSpeech extends ClientSDK {
+	// #region sdk-class-body
+	private _createSpeechOriginal?: typeof TextToSpeech.prototype.createSpeech;
+	private _streamSpeechOriginal?: typeof TextToSpeech.prototype.streamSpeech;
+
+	constructor(options: any) {
+		super(options);
+		// Store original methods before overriding
+		this._createSpeechOriginal = this.createSpeech.bind(this);
+		this._streamSpeechOriginal = this.streamSpeech.bind(this);
+
+		// Override with auto-chunking versions
+		this.createSpeech = this.createSpeechWithChunking.bind(this) as any;
+		this.streamSpeech = this.streamSpeechWithChunking.bind(this) as any;
+	}
+
+	/**
+	 * Check if text needs to be chunked
+	 */
+	private shouldChunkText(text: string, maxLength: number): boolean {
+		return text.length > maxLength;
+	}
+
+	/**
+	 * Extract audio data from response
+	 */
+	private async extractAudioFromResponse(
+		response: operations.CreateSpeechResponse | operations.StreamSpeechResponse
+	): Promise<Uint8Array> {
+		const result = response.result;
+
+		if (result instanceof Uint8Array) {
+			return result;
+		}
+
+		if (result instanceof Blob) {
+			return new Uint8Array(await result.arrayBuffer());
+		}
+
+		if (result instanceof ArrayBuffer) {
+			return new Uint8Array(result);
+		}
+
+		if (
+			typeof result === "object" &&
+			result !== null &&
+			"getReader" in result
+		) {
+			// ReadableStream
+			const reader = (result as ReadableStream<Uint8Array>).getReader();
+			const chunks: Uint8Array[] = [];
+
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				if (value) chunks.push(value);
+			}
+
+			// Merge all chunks
+			const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+			const merged = new Uint8Array(totalLength);
+			let offset = 0;
+			for (const chunk of chunks) {
+				merged.set(chunk, offset);
+				offset += chunk.length;
+			}
+			return merged;
+		}
+
+		// Handle CreateSpeechResponseBody with audioBase64
+		if (typeof result === "object" && result !== null) {
+			if ("audioBase64" in result) {
+				const audioBase64 = (result as any).audioBase64;
+				if (typeof audioBase64 === "string") {
+					// Decode base64 to binary
+					const binaryString = atob(audioBase64);
+					const bytes = new Uint8Array(binaryString.length);
+					for (let i = 0; i < binaryString.length; i++) {
+						bytes[i] = binaryString.charCodeAt(i);
+					}
+					return bytes;
+				}
+			}
+
+			// Fallback: try to access other properties
+			if ("content" in result) {
+				const content = (result as any).content;
+				if (content instanceof Uint8Array) return content;
+				if (typeof content === "string") {
+					return new TextEncoder().encode(content);
+				}
+			}
+			if ("_content" in result) {
+				const content = (result as any)._content;
+				if (content instanceof Uint8Array) return content;
+			}
+		}
+
+		// Enhanced error message with object inspection
+		const resultType = typeof result;
+		const resultConstructor = result?.constructor?.name || "unknown";
+		const resultKeys =
+			result && typeof result === "object"
+				? Object.keys(result).join(", ")
+				: "N/A";
+
+		throw new Error(
+			`Unsupported result type: ${resultType}, ` +
+				`constructor: ${resultConstructor}, ` +
+				`keys: [${resultKeys}]`
+		);
+	}
+
+	/**
+	 * Merge multiple audio responses into one
+	 */
+	private async mergeAudioResponses(
+		responses: operations.CreateSpeechResponse[]
+	): Promise<operations.CreateSpeechResponse> {
+		if (responses.length === 0) {
+			throw new Error("No responses to merge");
+		}
+
+		const firstResponse = responses[0];
+		if (!firstResponse) {
+			throw new Error("First response is undefined");
+		}
+
+		if (responses.length === 1) {
+			return firstResponse;
+		}
+
+		// Extract audio data from all responses
+		const audioChunks: Uint8Array[] = await Promise.all(
+			responses.map((r) => this.extractAudioFromResponse(r))
+		);
+
+		const firstChunk = audioChunks[0];
+		if (!firstChunk) {
+			throw new Error("First audio chunk is undefined");
+		}
+
+		// Detect format from first chunk
+		const audioFormat = detectAudioFormat(firstChunk);
+
+		// Merge based on format
+		let mergedAudio: Uint8Array;
+		if (audioFormat === "wav") {
+			mergedAudio = mergeWavBinary(audioChunks);
+		} else {
+			// MP3 or other formats
+			mergedAudio = mergeMp3Binary(audioChunks);
+		}
+
+		// Convert Uint8Array to ReadableStream for compatibility with CreateSpeechResponse type
+		const stream = new ReadableStream<Uint8Array>({
+			start(controller) {
+				controller.enqueue(mergedAudio);
+				controller.close();
+			},
+		});
+
+		// Return merged response with proper type
+		return {
+			result: stream,
+			headers: firstResponse.headers ?? {},
+		};
+	}
+
+	/**
+	 * Create extended streaming response for long text
+	 * Streams each text chunk progressively without waiting for full completion
+	 */
+	private createExtendedStreamingResponse(
+		firstResponse: operations.StreamSpeechResponse,
+		remainingChunks: string[],
+		originalRequest: operations.StreamSpeechRequest,
+		options?: RequestOptions & {
+			acceptHeaderOverride?: StreamSpeechAcceptEnum;
+		}
+	): operations.StreamSpeechResponse {
+		let audioFormat: "wav" | "mp3" | null = null;
+		let isFirstAudioChunk = true;
+
+		// Use arrow function to preserve 'this' context
+		const processStream = async (
+			controller: ReadableStreamDefaultController<Uint8Array>
+		) => {
+			try {
+				// Stream first response (first text chunk)
+				if (firstResponse.result) {
+					const result = firstResponse.result;
+
+					if (typeof result === "object" && "getReader" in result) {
+						const reader = (result as ReadableStream<Uint8Array>).getReader();
+
+						try {
+							while (true) {
+								const { done, value } = await reader.read();
+								if (done) break;
+
+								if (value) {
+									// Detect format from first audio chunk
+									if (isFirstAudioChunk) {
+										const detectedFormat = detectAudioFormat(value);
+										audioFormat = detectedFormat as "wav" | "mp3";
+										isFirstAudioChunk = false;
+									}
+
+									controller.enqueue(value);
+								}
+							}
+						} finally {
+							reader.releaseLock();
+						}
+					}
+				}
+
+				// Process remaining text chunks sequentially
+				for (const chunk of remainingChunks) {
+					const chunkRequest: operations.StreamSpeechRequest = {
+						...originalRequest,
+						apiConvertTextToSpeechUsingCharacterRequest: {
+							...originalRequest.apiConvertTextToSpeechUsingCharacterRequest,
+							text: chunk,
+						},
+					};
+
+					// Call original streaming method
+					if (!this._streamSpeechOriginal) {
+						throw new Error("Original streamSpeech method not found");
+					}
+					const chunkResponse = await this._streamSpeechOriginal(
+						chunkRequest,
+						options
+					);
+
+					// Stream this text chunk's audio
+					if (chunkResponse.result) {
+						const result = chunkResponse.result;
+
+						if (typeof result === "object" && "getReader" in result) {
+							const reader = (result as ReadableStream<Uint8Array>).getReader();
+							let isFirstChunkOfThisText = true;
+
+							try {
+								while (true) {
+									const { done, value } = await reader.read();
+									if (done) break;
+
+									if (value) {
+										let processedAudio = value;
+
+										// Remove header from first chunk of subsequent text chunks
+										if (isFirstChunkOfThisText && audioFormat) {
+											if (audioFormat === "wav") {
+												processedAudio = removeWavHeader(value);
+											} else if (audioFormat === "mp3") {
+												processedAudio = removeMp3Header(value);
+											}
+											isFirstChunkOfThisText = false;
+										}
+
+										controller.enqueue(processedAudio);
+									}
+								}
+							} finally {
+								reader.releaseLock();
+							}
+						}
+					}
+				}
+
+				controller.close();
+			} catch (error) {
+				controller.error(error);
+			}
+		};
+
+		const stream = new ReadableStream<Uint8Array>({
+			start: (controller) => processStream(controller),
+		});
+
+		return {
+			result: stream,
+			headers: firstResponse.headers ?? {},
+		};
+	}
+
+	/**
+	 * Create speech with auto-chunking support (internal implementation)
+	 */
+	private async createSpeechWithChunking(
+		request: operations.CreateSpeechRequest,
+		options?: RequestOptions & {
+			acceptHeaderOverride?: CreateSpeechAcceptEnum;
+			maxTextLength?: number;
+		}
+	): Promise<operations.CreateSpeechResponse> {
+		const maxLength = options?.maxTextLength ?? DEFAULT_MAX_TEXT_LENGTH;
+		const text =
+			request.apiConvertTextToSpeechUsingCharacterRequest?.text ?? "";
+
+		// Short text: call original method directly
+		if (!this.shouldChunkText(text, maxLength)) {
+			if (!this._createSpeechOriginal) {
+				throw new Error("Original createSpeech method not found");
+			}
+			return this._createSpeechOriginal(request, options);
+		}
+
+		// Long text: chunk, process sequentially (to avoid schema parsing issues), and merge
+		const textChunks = chunkText(text, maxLength);
+
+		// Determine Accept header based on output format
+		const outputFormat =
+			request.apiConvertTextToSpeechUsingCharacterRequest?.outputFormat;
+		const acceptHeader: CreateSpeechAcceptEnum =
+			outputFormat === "mp3"
+				? CreateSpeechAcceptEnum.audioMpeg
+				: CreateSpeechAcceptEnum.audioWav;
+
+		// Process chunks sequentially to avoid race conditions in schema parsing
+		const responses: operations.CreateSpeechResponse[] = [];
+		for (const chunk of textChunks) {
+			const chunkRequest: operations.CreateSpeechRequest = {
+				...request,
+				apiConvertTextToSpeechUsingCharacterRequest: {
+					...request.apiConvertTextToSpeechUsingCharacterRequest,
+					text: chunk,
+				},
+			};
+			if (!this._createSpeechOriginal) {
+				throw new Error("Original createSpeech method not found");
+			}
+			const response = await this._createSpeechOriginal(chunkRequest, {
+				...options,
+				acceptHeaderOverride: acceptHeader,
+			});
+			responses.push(response);
+		}
+
+		return this.mergeAudioResponses(responses);
+	}
+
+	/**
+	 * Stream speech with auto-chunking support (internal implementation)
+	 */
+	private async streamSpeechWithChunking(
+		request: operations.StreamSpeechRequest,
+		options?: RequestOptions & {
+			acceptHeaderOverride?: StreamSpeechAcceptEnum;
+			maxTextLength?: number;
+		}
+	): Promise<operations.StreamSpeechResponse> {
+		const maxLength = options?.maxTextLength ?? DEFAULT_MAX_TEXT_LENGTH;
+		const text =
+			request.apiConvertTextToSpeechUsingCharacterRequest?.text ?? "";
+
+		// Short text: call original method directly
+		if (!this.shouldChunkText(text, maxLength)) {
+			if (!this._streamSpeechOriginal) {
+				throw new Error("Original streamSpeech method not found");
+			}
+			return this._streamSpeechOriginal(request, options);
+		}
+
+		// Long text: chunk and stream sequentially
+		const textChunks = chunkText(text, maxLength);
+
+		if (textChunks.length === 0) {
+			throw new Error("No text chunks to process");
+		}
+
+		const firstChunk = textChunks[0];
+		if (!firstChunk) {
+			throw new Error("First text chunk is undefined");
+		}
+
+		// Get first response to start streaming
+		const firstChunkRequest: operations.StreamSpeechRequest = {
+			...request,
+			apiConvertTextToSpeechUsingCharacterRequest: {
+				...request.apiConvertTextToSpeechUsingCharacterRequest,
+				text: firstChunk,
+			},
+		};
+
+		if (!this._streamSpeechOriginal) {
+			throw new Error("Original streamSpeech method not found");
+		}
+		const firstResponse = await this._streamSpeechOriginal(
+			firstChunkRequest,
+			options
+		);
+
+		// Single chunk: return as-is
+		if (textChunks.length === 1) {
+			return firstResponse;
+		}
+
+		// Multiple chunks: create extended streaming response
+		const remainingChunks = textChunks.slice(1);
+		return this.createExtendedStreamingResponse(
+			firstResponse,
+			remainingChunks,
+			request,
+			options
+		);
+	}
+	// #endregion sdk-class-body
+
+	/**
+	 * Convert text to speech
+	 *
+	 * @remarks
+	 * Convert text to speech using the specified voice
+	 */
+	async createSpeech(
+		request: operations.CreateSpeechRequest,
+		options?: RequestOptions & {
+			acceptHeaderOverride?: CreateSpeechAcceptEnum;
+		}
+	): Promise<operations.CreateSpeechResponse> {
+		return unwrapAsync(textToSpeechCreateSpeech(this, request, options));
+	}
+
+	/**
+	 * Convert text to speech with streaming response
+	 *
+	 * @remarks
+	 * Convert text to speech using the specified voice with streaming response. Returns binary audio stream.
+	 */
+	async streamSpeech(
+		request: operations.StreamSpeechRequest,
+		options?: RequestOptions & {
+			acceptHeaderOverride?: StreamSpeechAcceptEnum;
+		}
+	): Promise<operations.StreamSpeechResponse> {
+		return unwrapAsync(textToSpeechStreamSpeech(this, request, options));
+	}
+
+	/**
+	 * Predict text-to-speech duration
+	 *
+	 * @remarks
+	 * Predict the duration of text-to-speech conversion without generating audio
+	 */
+	async predictDuration(
+		request: operations.PredictDurationRequest,
+		options?: RequestOptions
+	): Promise<operations.PredictDurationResponse> {
+		return unwrapAsync(textToSpeechPredictDuration(this, request, options));
+	}
+}

package/src/sdk/usage.ts

@@ -0,0 +1,62 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { usageGetCreditBalance } from "../funcs/usageGetCreditBalance.js";
+import { usageGetUsage } from "../funcs/usageGetUsage.js";
+import { usageGetVoiceUsage } from "../funcs/usageGetVoiceUsage.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Usage extends ClientSDK {
+  /**
+   * Retrieve TTS API usage data
+   *
+   * @remarks
+   * Retrieves a list of all TTS API usage records filtered by a specified date range. All dates are in UTC+0 timezone.
+   */
+  async getVoiceUsage(
+    request: operations.GetVoiceUsageRequest,
+    options?: RequestOptions,
+  ): Promise<models.GetUsageListV1Response> {
+    return unwrapAsync(usageGetVoiceUsage(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Retrieve advanced API usage analytics
+   *
+   * @remarks
+   * Retrieves API usage data with advanced features including time bucketing, multi-dimensional breakdowns, and pagination. All timestamps should be in RFC3339 format.
+   */
+  async getUsage(
+    request: operations.GetUsageRequest,
+    options?: RequestOptions,
+  ): Promise<models.UsageAnalyticsResponse> {
+    return unwrapAsync(usageGetUsage(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Retrieve credit balance
+   *
+   * @remarks
+   * Retrieves credit balance of the user.
+   */
+  async getCreditBalance(
+    options?: RequestOptions,
+  ): Promise<models.GetCreditBalanceResponse> {
+    return unwrapAsync(usageGetCreditBalance(
+      this,
+      options,
+    ));
+  }
+}

package/src/sdk/voices.ts

@@ -0,0 +1,64 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { voicesGetVoice } from "../funcs/voicesGetVoice.js";
+import { voicesListVoices } from "../funcs/voicesListVoices.js";
+import { voicesSearchVoices } from "../funcs/voicesSearchVoices.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Voices extends ClientSDK {
+  /**
+   * Gets available voices
+   *
+   * @remarks
+   * Gets a paginated list of voices available to the user based on internal group logic, using token-based pagination.
+   */
+  async listVoices(
+    request?: operations.ListVoicesRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<models.GetAPICharacterListResponse> {
+    return unwrapAsync(voicesListVoices(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Search voices.
+   *
+   * @remarks
+   * Search and filter voices based on various parameters.
+   */
+  async searchVoices(
+    request?: operations.SearchVoicesRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<models.GetAPICharacterListResponse> {
+    return unwrapAsync(voicesSearchVoices(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get voice details by ID
+   *
+   * @remarks
+   * Gets detailed information about a specific voice by its voice ID. Only supports preset voices.
+   */
+  async getVoice(
+    request: operations.GetVoiceRequest,
+    options?: RequestOptions,
+  ): Promise<models.GetCharacterByIdResponse> {
+    return unwrapAsync(voicesGetVoice(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/types/async.ts

@@ -0,0 +1,68 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+export type APICall =
+  | {
+      status: "complete";
+      request: Request;
+      response: Response;
+    }
+  | {
+      status: "request-error";
+      request: Request;
+      response?: undefined;
+    }
+  | {
+      status: "invalid";
+      request?: undefined;
+      response?: undefined;
+    };
+
+export class APIPromise<T> implements Promise<T> {
+  readonly #promise: Promise<[T, APICall]>;
+  readonly #unwrapped: Promise<T>;
+
+  readonly [Symbol.toStringTag] = "APIPromise";
+
+  constructor(p: [T, APICall] | Promise<[T, APICall]>) {
+    this.#promise = p instanceof Promise ? p : Promise.resolve(p);
+    this.#unwrapped =
+      p instanceof Promise
+        ? this.#promise.then(([value]) => value)
+        : Promise.resolve(p[0]);
+  }
+
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | PromiseLike<TResult1>)
+      | null
+      | undefined,
+    onrejected?:
+      | ((reason: any) => TResult2 | PromiseLike<TResult2>)
+      | null
+      | undefined,
+  ): Promise<TResult1 | TResult2> {
+    return this.#promise.then(
+      onfulfilled ? ([value]) => onfulfilled(value) : void 0,
+      onrejected,
+    );
+  }
+
+  catch<TResult = never>(
+    onrejected?:
+      | ((reason: any) => TResult | PromiseLike<TResult>)
+      | null
+      | undefined,
+  ): Promise<T | TResult> {
+    return this.#unwrapped.catch(onrejected);
+  }
+
+  finally(onfinally?: (() => void) | null | undefined): Promise<T> {
+    return this.#unwrapped.finally(onfinally);
+  }
+
+  $inspect(): Promise<[T, APICall]> {
+    return this.#promise;
+  }
+}

package/src/types/blobs.ts

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+
+export const blobLikeSchema: z.ZodType<Blob, z.ZodTypeDef, Blob> =
+  z.custom<Blob>(isBlobLike, {
+    message: "expected a Blob, File or Blob-like object",
+    fatal: true,
+  });
+
+export function isBlobLike(val: unknown): val is Blob {
+  if (val instanceof Blob) {
+    return true;
+  }
+
+  if (typeof val !== "object" || val == null || !(Symbol.toStringTag in val)) {
+    return false;
+  }
+
+  const name = val[Symbol.toStringTag];
+  if (typeof name !== "string") {
+    return false;
+  }
+  if (name !== "Blob" && name !== "File") {
+    return false;
+  }
+
+  return "stream" in val && typeof val.stream === "function";
+}