@supertone/supertone 0.1.1 → 0.1.3

package/custom_test/test_real_api.ts

@@ -127,19 +127,25 @@ async function extractAudioData(response: any): Promise<Uint8Array> {
 		console.log(`  🔍 Debug - has audioBase64: ${"audioBase64" in result}`);
 		console.log(`  🔍 Debug - has getReader: ${"getReader" in result}`);
 	}
-	
+
 	// Check for capital-case Result (SDK internal structure)
-	if (!result || (typeof result === "object" && Object.keys(result).length === 0)) {
+	if (
+		!result ||
+		(typeof result === "object" && Object.keys(result).length === 0)
+	) {
 		console.log(`  💡 Checking SDK internal Result field...`);
 		if ((response as any).Result) {
 			result = (response as any).Result;
 			console.log(`  ✅ Found Result (capital R) - using that instead`);
 		}
 	}
-	
+
 	// Debug response headers
 	if (response.headers) {
-		console.log(`  🔍 Debug - response headers:`, JSON.stringify(response.headers, null, 2));
+		console.log(
+			`  🔍 Debug - response headers:`,
+			JSON.stringify(response.headers, null, 2)
+		);
 	}
 
 	if (result instanceof Uint8Array) {
@@ -198,7 +204,7 @@ async function extractAudioData(response: any): Promise<Uint8Array> {
 			return bytes;
 		}
 	}
-	
+
 	// Handle empty object case - this might happen when the SDK doesn't properly parse audio responses
 	if (
 		typeof result === "object" &&
@@ -207,22 +213,25 @@ async function extractAudioData(response: any): Promise<Uint8Array> {
 	) {
 		console.log(`  ⚠️  Warning: Empty result object detected`);
 		console.log(`  💡 This might be a parsing issue with the SDK`);
-		console.log(`  💡 Check if the response was actually a stream but got parsed as an empty object`);
-		
+		console.log(
+			`  💡 Check if the response was actually a stream but got parsed as an empty object`
+		);
+
 		throw new Error(
 			`Empty result object - SDK may have failed to parse audio stream response. ` +
-			`This usually happens when audio/* content-type responses are not properly handled.`
+				`This usually happens when audio/* content-type responses are not properly handled.`
 		);
 	}
 
 	// Enhanced error message with debug info
-	const errorDetails = typeof result === "object" && result !== null
-		? `constructor: ${result.constructor.name}, keys: [${Object.keys(result).join(", ")}]`
-		: `value: ${result}`;
-	
-	throw new Error(
-		`Unsupported result type: ${typeof result}, ${errorDetails}`
-	);
+	const errorDetails =
+		typeof result === "object" && result !== null
+			? `constructor: ${result.constructor.name}, keys: [${Object.keys(
+					result
+			  ).join(", ")}]`
+			: `value: ${result}`;
+
+	throw new Error(`Unsupported result type: ${typeof result}, ${errorDetails}`);
 }
 
 /**
@@ -928,12 +937,15 @@ async function testCreateSpeechLongText(
 }
 
 /**
- * Test TTS streaming with long text
+ * Test TTS with long text WITHOUT punctuation (word-based chunking)
+ * This tests the word-based splitting fallback when sentences exceed 300 chars
  */
-async function testStreamSpeechLongText(
+async function testCreateSpeechLongSentenceNoPunctuation(
 	voiceId: string | null
 ): Promise<[boolean, any]> {
-	console.log("📡 Long Text Streaming TTS Test");
+	console.log(
+		"📜 Long Sentence WITHOUT Punctuation Test (Word-based chunking)"
+	);
 
 	if (!voiceId) {
 		console.log("  ⚠️  No voice ID available");
@@ -945,44 +957,64 @@ async function testStreamSpeechLongText(
 		const models = await import("../src/models/index.js");
 		const client = new Supertone({ apiKey: API_KEY });
 
-		const longText = `
-		Hello! This is a long text streaming test.
-		The SDK automatically chunks and streams the audio in real-time.
-		This enables efficient processing of longer content without waiting for complete generation.
-		`
-			.trim()
-			.repeat(3);
+		// Long text without punctuation - forces word-based splitting
+		// This is a single continuous sentence with no periods or other punctuation marks
+		const longSentenceNoPunctuation =
+			"This is a very long sentence without any punctuation marks that is designed to test the word based chunking feature of the SDK when a sentence exceeds the maximum character limit of three hundred characters the system should automatically split this text by word boundaries rather than sentence boundaries to ensure proper processing and this behavior is critical for handling user generated content that may not follow standard punctuation conventions such as chat messages or informal text inputs that users commonly provide in real world applications where grammatically correct sentences are not always guaranteed";
 
-		console.log(`  🔍 Streaming long text with voice '${voiceId}'...`);
-		console.log(`     Text length: ${longText.length} characters`);
+		const actualLength = longSentenceNoPunctuation.length;
+		console.log(
+			`  📏 Text length: ${actualLength} characters (single sentence, no punctuation)`
+		);
+		console.log(`  🔧 Expected behavior: Word-based chunking`);
 		console.log("  ⚠️  This test consumes credits!");
 
-		const response = await client.textToSpeech.streamSpeech({
+		const response = await client.textToSpeech.createSpeech({
 			voiceId,
 			apiConvertTextToSpeechUsingCharacterRequest: {
-				text: longText,
+				text: longSentenceNoPunctuation,
 				language: models.APIConvertTextToSpeechUsingCharacterRequestLanguage.En,
 				outputFormat:
 					models.APIConvertTextToSpeechUsingCharacterRequestOutputFormat.Wav,
+				style: "neutral",
+				model: "sona_speech_1",
 			},
 		});
 
-		console.log(`  ✅ Stream started successfully`);
+		if (response.result) {
+			const audioData = await extractAudioData(response);
+
+			console.log(
+				`  ✅ Word-based chunking TTS success: ${audioData.length} bytes`
+			);
+			console.log(
+				`  🎯 Long sentence without punctuation processed correctly!`
+			);
+
+			const outputFile = "test_word_chunking_speech_output.wav";
+			fs.writeFileSync(outputFile, audioData);
+			console.log(`  💾 Audio saved: ${outputFile}`);
+
+			const estimatedChunks = Math.ceil(actualLength / 300);
+			console.log(`  📊 Estimated chunks: ${estimatedChunks}`);
+		}
 
 		return [true, response];
 	} catch (e: any) {
-		console.error(`  ❌ Error: ${e.message || e}`);
+		logDetailedError(e, "Long sentence word-based chunking");
 		return [false, e];
 	}
 }
 
 /**
- * Test TTS with voice settings
+ * Test TTS with Japanese text (character-based chunking)
+ * Japanese doesn't use spaces, AND this test uses NO punctuation marks (。！？etc)
+ * to ensure the SDK uses character-based splitting
  */
-async function testCreateSpeechWithVoiceSettings(
+async function testCreateSpeechJapaneseNoSpaces(
 	voiceId: string | null
 ): Promise<[boolean, any]> {
-	console.log("🎛️  TTS with Voice Settings Test");
+	console.log("🇯🇵 Japanese Text Test (Character-based chunking)");
 
 	if (!voiceId) {
 		console.log("  ⚠️  No voice ID available");
@@ -994,58 +1026,72 @@ async function testCreateSpeechWithVoiceSettings(
 		const models = await import("../src/models/index.js");
 		const client = new Supertone({ apiKey: API_KEY });
 
-		const voiceSettings = {
-			pitchShift: 0.95,
-			pitchVariance: 1.1,
-			speed: 0.9,
-		};
-
+		// Long Japanese text WITHOUT spaces AND WITHOUT punctuation - forces character-based splitting
+		// This text intentionally has NO punctuation marks (。！？etc) to test pure character-based chunking
+		// Text length: ~450 characters (exceeds 300 char limit)
+		const longJapaneseText =
+			"日本語のテキストは通常スペースを含まないため特別な処理が必要です" +
+			"このテストは三百文字を超える長い日本語テキストが正しく処理されることを確認します" +
+			"自然言語処理技術の発展により音声合成の品質は大幅に向上しました" +
+			"特にディープラーニングを活用した最新のテキスト音声変換システムは人間の発話に非常に近い自然な音声を生成できます" +
+			"スペースがない言語では文字単位での分割が必要でありこのSDKはそのような状況を自動的に検出して適切に処理します" +
+			"これにより日本語中国語韓国語などのアジア言語でも問題なく長いテキストを音声に変換することができます" +
+			"音声合成技術は視覚障害者のためのアクセシビリティツールから対話型AIアシスタントまで幅広い用途で活用されています" +
+			"さらにリアルタイムストリーミング技術と組み合わせることで待ち時間を大幅に短縮し優れたユーザー体験を提供することができます" +
+			"最新の音声合成技術は感情や抑揚も自然に表現できるようになりました";
+
+		const actualLength = longJapaneseText.length;
 		console.log(
-			`  🔍 TTS conversion with voice settings using voice '${voiceId}'...`
+			`  📏 Text length: ${actualLength} characters (Japanese, no spaces, no punctuation)`
 		);
 		console.log(
-			`     Settings: pitchShift=${voiceSettings.pitchShift}, speed=${voiceSettings.speed}`
+			`  🔧 Expected behavior: Character-based chunking (300 chars per chunk)`
 		);
 		console.log("  ⚠️  This test consumes credits!");
 
 		const response = await client.textToSpeech.createSpeech({
 			voiceId,
 			apiConvertTextToSpeechUsingCharacterRequest: {
-				text: "Hello world! This is a voice settings test. You can hear the adjusted pitch and speed.",
-				language: models.APIConvertTextToSpeechUsingCharacterRequestLanguage.En,
+				text: longJapaneseText,
+				language: models.APIConvertTextToSpeechUsingCharacterRequestLanguage.Ja,
 				outputFormat:
 					models.APIConvertTextToSpeechUsingCharacterRequestOutputFormat.Wav,
 				style: "neutral",
 				model: "sona_speech_1",
-				voiceSettings,
-				includePhonemes: false,
 			},
 		});
 
-		console.log(`  ✅ TTS with voice settings success`);
-
 		if (response.result) {
-			const outputFile = "test_voice_settings_speech_output.wav";
 			const audioData = await extractAudioData(response);
 
+			console.log(
+				`  ✅ Character-based chunking TTS success: ${audioData.length} bytes`
+			);
+			console.log(`  🎯 Japanese text without spaces processed correctly!`);
+
+			const outputFile = "test_japanese_char_chunking_speech_output.wav";
 			fs.writeFileSync(outputFile, audioData);
-			console.log(`  💾 Voice settings audio file saved: ${outputFile}`);
+			console.log(`  💾 Audio saved: ${outputFile}`);
+
+			const estimatedChunks = Math.ceil(actualLength / 300);
+			console.log(`  📊 Estimated chunks: ${estimatedChunks}`);
 		}
 
 		return [true, response];
 	} catch (e: any) {
-		console.error(`  ❌ Error: ${e.message || e}`);
+		logDetailedError(e, "Japanese character-based chunking");
 		return [false, e];
 	}
 }
 
 /**
- * Test TTS with phoneme information
+ * Test TTS with Arabic text and Arabic punctuation marks (؟ ؛ ۔)
+ * This tests multilingual sentence punctuation support added in fix/text_utils
  */
-async function testCreateSpeechWithPhonemes(
+async function testCreateSpeechArabicPunctuation(
 	voiceId: string | null
 ): Promise<[boolean, any]> {
-	console.log("🔤 TTS with Phoneme Information Test");
+	console.log("🇸🇦 Arabic Text with Arabic Punctuation Test");
 
 	if (!voiceId) {
 		console.log("  ⚠️  No voice ID available");
@@ -1057,81 +1103,71 @@ async function testCreateSpeechWithPhonemes(
 		const models = await import("../src/models/index.js");
 		const client = new Supertone({ apiKey: API_KEY });
 
+		// Arabic text with Arabic punctuation marks (؟ ؛ ۔ ،)
+		// Text length: ~350 characters (exceeds 300 char limit)
+		const arabicText =
+			"مرحبا بكم في اختبار تقنية تحويل النص إلى كلام؟ " +
+			"هذا النظام يدعم اللغة العربية بشكل كامل؛ " +
+			"يمكنه التعرف على علامات الترقيم العربية مثل علامة الاستفهام وعلامة الفاصلة المنقوطة۔ " +
+			"تقنية الذكاء الاصطناعي تتطور بسرعة كبيرة، " +
+			"والآن يمكننا تحويل النصوص الطويلة إلى كلام طبيعي؟ " +
+			"هذا الاختبار يتحقق من أن النظام يقسم النص بشكل صحيح عند علامات الترقيم العربية؛ " +
+			"نأمل أن يعمل كل شيء بشكل مثالي۔";
+
+		const actualLength = arabicText.length;
 		console.log(
-			`  🔍 TTS conversion with phonemes using voice '${voiceId}'...`
+			`  📏 Text length: ${actualLength} characters (Arabic with Arabic punctuation)`
 		);
+		console.log(`  🔧 Expected behavior: Sentence-based chunking with Arabic punctuation (؟ ؛ ۔)`);
 		console.log("  ⚠️  This test consumes credits!");
 
+		if (actualLength <= 300) {
+			console.log(`  ❌ Text length ${actualLength} is <= 300, test may not trigger chunking`);
+		}
+
 		const response = await client.textToSpeech.createSpeech({
 			voiceId,
 			apiConvertTextToSpeechUsingCharacterRequest: {
-				text: "Hello world! This is a phoneme timing test.",
-				language: models.APIConvertTextToSpeechUsingCharacterRequestLanguage.En,
+				text: arabicText,
+				language: models.APIConvertTextToSpeechUsingCharacterRequestLanguage.Ar,
 				outputFormat:
 					models.APIConvertTextToSpeechUsingCharacterRequestOutputFormat.Wav,
 				style: "neutral",
-				model: "sona_speech_1",
-				includePhonemes: true,
+				model: models.APIConvertTextToSpeechUsingCharacterRequestModel.SonaSpeech2,
 			},
 		});
 
-		console.log(`  ✅ TTS with phonemes success`);
-
 		if (response.result) {
-			const outputFile = "test_phoneme_speech_output.wav";
+			const audioData = await extractAudioData(response);
 
-			// Check if response is JSON with phonemes data
-			if (
-				typeof response.result === "object" &&
-				"audioBase64" in response.result
-			) {
-				const audioData = await extractAudioData(response);
-				fs.writeFileSync(outputFile, audioData);
-				console.log(`  💾 Phoneme audio file saved: ${outputFile}`);
+			console.log(
+				`  ✅ Arabic punctuation chunking TTS success: ${audioData.length} bytes`
+			);
+			console.log(`  🎯 Arabic text with Arabic punctuation processed correctly!`);
 
-				// Display phoneme information as JSON
-				const phonemes = (response.result as any).phonemes;
-				if (phonemes) {
-					console.log(`  📊 Phoneme data (JSON):`);
-					console.log(JSON.stringify(phonemes, null, 2));
-					console.log(`  📈 Summary:`);
-					console.log(`     Symbols count: ${phonemes.symbols?.length || 0}`);
-					console.log(
-						`     Durations count: ${phonemes.durations_seconds?.length || 0}`
-					);
-					console.log(
-						`     Start times count: ${
-							phonemes.start_times_seconds?.length || 0
-						}`
-					);
-					if (phonemes.symbols && phonemes.symbols.length > 0) {
-						console.log(
-							`     First 5 symbols: ${phonemes.symbols.slice(0, 5).join(", ")}`
-						);
-					}
-				}
-			} else {
-				// Binary audio without phonemes
-				const audioData = await extractAudioData(response);
-				fs.writeFileSync(outputFile, audioData);
-				console.log(`  💾 Phoneme audio file saved: ${outputFile}`);
-			}
+			const outputFile = "test_arabic_punctuation_speech_output.wav";
+			fs.writeFileSync(outputFile, audioData);
+			console.log(`  💾 Audio saved: ${outputFile}`);
+
+			const estimatedChunks = Math.ceil(actualLength / 300);
+			console.log(`  📊 Estimated chunks: ${estimatedChunks}`);
 		}
 
 		return [true, response];
 	} catch (e: any) {
-		console.error(`  ❌ Error: ${e.message || e}`);
+		logDetailedError(e, "Arabic punctuation chunking");
 		return [false, e];
 	}
 }
 
 /**
- * Test TTS streaming with phonemes
+ * Test TTS with Hindi text and Devanagari punctuation marks (। ॥)
+ * This tests multilingual sentence punctuation support added in fix/text_utils
  */
-async function testStreamSpeechWithPhonemes(
+async function testCreateSpeechHindiPunctuation(
 	voiceId: string | null
 ): Promise<[boolean, any]> {
-	console.log("📡 TTS Streaming with Phonemes Test");
+	console.log("🇮🇳 Hindi Text with Devanagari Punctuation Test");
 
 	if (!voiceId) {
 		console.log("  ⚠️  No voice ID available");
@@ -1143,38 +1179,71 @@ async function testStreamSpeechWithPhonemes(
 		const models = await import("../src/models/index.js");
 		const client = new Supertone({ apiKey: API_KEY });
 
+		// Hindi text with Devanagari punctuation marks (। ॥)
+		// Text length: ~380 characters (exceeds 300 char limit)
+		const hindiText =
+			"नमस्ते और स्वागत है आपका इस परीक्षण में। " +
+			"यह प्रणाली हिंदी भाषा का पूर्ण समर्थन करती है। " +
+			"देवनागरी लिपि में पूर्ण विराम और दोहरा दंड जैसे विराम चिह्न होते हैं॥ " +
+			"कृत्रिम बुद्धिमत्ता की तकनीक बहुत तेजी से विकसित हो रही है। " +
+			"अब हम लंबे पाठों को स्वाभाविक वाणी में बदल सकते हैं। " +
+			"यह परीक्षण जांचता है कि सिस्टम हिंदी विराम चिह्नों पर सही ढंग से पाठ को विभाजित करता है। " +
+			"हमें आशा है कि सब कुछ ठीक से काम करेगा॥";
+
+		const actualLength = hindiText.length;
 		console.log(
-			`  🔍 Streaming speech with phonemes for voice '${voiceId}'...`
+			`  📏 Text length: ${actualLength} characters (Hindi with Devanagari punctuation)`
 		);
+		console.log(`  🔧 Expected behavior: Sentence-based chunking with Devanagari punctuation (। ॥)`);
 		console.log("  ⚠️  This test consumes credits!");
 
-		const response = await client.textToSpeech.streamSpeech({
+		if (actualLength <= 300) {
+			console.log(`  ❌ Text length ${actualLength} is <= 300, test may not trigger chunking`);
+		}
+
+		const response = await client.textToSpeech.createSpeech({
 			voiceId,
 			apiConvertTextToSpeechUsingCharacterRequest: {
-				text: "Streaming with phoneme timing information.",
-				language: models.APIConvertTextToSpeechUsingCharacterRequestLanguage.En,
+				text: hindiText,
+				language: models.APIConvertTextToSpeechUsingCharacterRequestLanguage.Hi,
 				outputFormat:
 					models.APIConvertTextToSpeechUsingCharacterRequestOutputFormat.Wav,
-				includePhonemes: true,
+				style: "neutral",
+				model: models.APIConvertTextToSpeechUsingCharacterRequestModel.SonaSpeech2,
 			},
 		});
 
-		console.log(`  ✅ Stream with phonemes started successfully`);
+		if (response.result) {
+			const audioData = await extractAudioData(response);
+
+			console.log(
+				`  ✅ Hindi punctuation chunking TTS success: ${audioData.length} bytes`
+			);
+			console.log(`  🎯 Hindi text with Devanagari punctuation processed correctly!`);
+
+			const outputFile = "test_hindi_punctuation_speech_output.wav";
+			fs.writeFileSync(outputFile, audioData);
+			console.log(`  💾 Audio saved: ${outputFile}`);
+
+			const estimatedChunks = Math.ceil(actualLength / 300);
+			console.log(`  📊 Estimated chunks: ${estimatedChunks}`);
+		}
 
 		return [true, response];
 	} catch (e: any) {
-		console.error(`  ❌ Error: ${e.message || e}`);
+		logDetailedError(e, "Hindi punctuation chunking");
 		return [false, e];
 	}
 }
 
 /**
- * Test duration prediction with voice settings
+ * Test TTS with ellipsis punctuation marks (… ‥)
+ * This tests multilingual sentence punctuation support added in fix/text_utils
  */
-async function testPredictDurationWithVoiceSettings(
+async function testCreateSpeechEllipsisPunctuation(
 	voiceId: string | null
 ): Promise<[boolean, any]> {
-	console.log("⏱️  Duration Prediction with Voice Settings Test");
+	console.log("⏳ Text with Ellipsis Punctuation Test (… ‥)");
 
 	if (!voiceId) {
 		console.log("  ⚠️  No voice ID available");
@@ -1186,40 +1255,71 @@ async function testPredictDurationWithVoiceSettings(
 		const models = await import("../src/models/index.js");
 		const client = new Supertone({ apiKey: API_KEY });
 
-		const voiceSettings = {
-			speed: 0.8,
-		};
-
+		// Text with ellipsis punctuation marks (… ‥)
+		// Text length: ~380 characters (exceeds 300 char limit)
+		const ellipsisText =
+			"Sometimes we need to pause and think… " +
+			"The ellipsis character is used to indicate a trailing thought or a pause in speech… " +
+			"This test verifies that the text chunking system correctly handles Unicode ellipsis characters‥ " +
+			"There are actually multiple types of ellipsis in Unicode… " +
+			"The horizontal ellipsis U+2026 and the two dot leader U+2025 are both supported‥ " +
+			"When processing long texts the SDK should split at these punctuation marks… " +
+			"This ensures natural pauses in the generated speech output‥ " +
+			"Let us verify that everything works correctly…";
+
+		const actualLength = ellipsisText.length;
 		console.log(
-			`  🔍 Predicting duration with voice settings for voice '${voiceId}'...`
+			`  📏 Text length: ${actualLength} characters (with ellipsis punctuation)`
 		);
-		console.log(`     Settings: speed=${voiceSettings.speed}`);
+		console.log(`  🔧 Expected behavior: Sentence-based chunking with ellipsis (… ‥)`);
+		console.log("  ⚠️  This test consumes credits!");
 
-		const response = await client.textToSpeech.predictDuration({
+		if (actualLength <= 300) {
+			console.log(`  ❌ Text length ${actualLength} is <= 300, test may not trigger chunking`);
+		}
+
+		const response = await client.textToSpeech.createSpeech({
 			voiceId,
-			predictTTSDurationUsingCharacterRequest: {
-				text: "This is a duration test with adjusted speed.",
-				language: models.PredictTTSDurationUsingCharacterRequestLanguage.En,
-				voiceSettings,
+			apiConvertTextToSpeechUsingCharacterRequest: {
+				text: ellipsisText,
+				language: models.APIConvertTextToSpeechUsingCharacterRequestLanguage.En,
+				outputFormat:
+					models.APIConvertTextToSpeechUsingCharacterRequestOutputFormat.Wav,
+				style: "neutral",
+				model: models.APIConvertTextToSpeechUsingCharacterRequestModel.SonaSpeech1,
 			},
 		});
 
-		console.log(`  ✅ Predicted duration: ${response.duration}s`);
+		if (response.result) {
+			const audioData = await extractAudioData(response);
+
+			console.log(
+				`  ✅ Ellipsis punctuation chunking TTS success: ${audioData.length} bytes`
+			);
+			console.log(`  🎯 Text with ellipsis punctuation processed correctly!`);
+
+			const outputFile = "test_ellipsis_punctuation_speech_output.wav";
+			fs.writeFileSync(outputFile, audioData);
+			console.log(`  💾 Audio saved: ${outputFile}`);
+
+			const estimatedChunks = Math.ceil(actualLength / 300);
+			console.log(`  📊 Estimated chunks: ${estimatedChunks}`);
+		}
 
 		return [true, response];
 	} catch (e: any) {
-		console.error(`  ❌ Error: ${e.message || e}`);
+		logDetailedError(e, "Ellipsis punctuation chunking");
 		return [false, e];
 	}
 }
 
 /**
- * Test TTS streaming with voice settings
+ * Test TTS streaming with long text
  */
-async function testStreamSpeechWithVoiceSettings(
+async function testStreamSpeechLongText(
 	voiceId: string | null
 ): Promise<[boolean, any]> {
-	console.log("📡 TTS Streaming with Voice Settings Test");
+	console.log("📡 Long Text Streaming TTS Test");
 
 	if (!voiceId) {
 		console.log("  ⚠️  No voice ID available");
@@ -1231,31 +1331,29 @@ async function testStreamSpeechWithVoiceSettings(
 		const models = await import("../src/models/index.js");
 		const client = new Supertone({ apiKey: API_KEY });
 
-		const voiceSettings = {
-			pitchShift: 1.05,
-			speed: 1.1,
-		};
+		const longText = `
+		Hello! This is a long text streaming test.
+		The SDK automatically chunks and streams the audio in real-time.
+		This enables efficient processing of longer content without waiting for complete generation.
+		`
+			.trim()
+			.repeat(3);
 
-		console.log(
-			`  🔍 Streaming speech with voice settings for voice '${voiceId}'...`
-		);
-		console.log(
-			`     Settings: pitchShift=${voiceSettings.pitchShift}, speed=${voiceSettings.speed}`
-		);
+		console.log(`  🔍 Streaming long text with voice '${voiceId}'...`);
+		console.log(`     Text length: ${longText.length} characters`);
 		console.log("  ⚠️  This test consumes credits!");
 
 		const response = await client.textToSpeech.streamSpeech({
 			voiceId,
 			apiConvertTextToSpeechUsingCharacterRequest: {
-				text: "Streaming with adjusted voice settings.",
+				text: longText,
 				language: models.APIConvertTextToSpeechUsingCharacterRequestLanguage.En,
 				outputFormat:
 					models.APIConvertTextToSpeechUsingCharacterRequestOutputFormat.Wav,
-				voiceSettings,
 			},
 		});
 
-		console.log(`  ✅ Stream with voice settings started successfully`);
+		console.log(`  ✅ Stream started successfully`);
 
 		return [true, response];
 	} catch (e: any) {
@@ -1265,12 +1363,12 @@ async function testStreamSpeechWithVoiceSettings(
 }
 
 /**
- * Test MP3 format TTS
+ * Test TTS with voice settings
  */
-async function testCreateSpeechMp3(
+async function testCreateSpeechWithVoiceSettings(
 	voiceId: string | null
 ): Promise<[boolean, any]> {
-	console.log("🎤 MP3 Format TTS Test");
+	console.log("🎛️  TTS with Voice Settings Test");
 
 	if (!voiceId) {
 		console.log("  ⚠️  No voice ID available");
@@ -1282,39 +1380,1021 @@ async function testCreateSpeechMp3(
 		const models = await import("../src/models/index.js");
 		const client = new Supertone({ apiKey: API_KEY });
 
-		console.log(`  🔍 MP3 TTS conversion with voice '${voiceId}'...`);
+		const voiceSettings = {
+			pitchShift: 0.95,
+			pitchVariance: 1.1,
+			speed: 0.9,
+		};
+
+		console.log(
+			`  🔍 TTS conversion with voice settings using voice '${voiceId}'...`
+		);
+		console.log(
+			`     Settings: pitchShift=${voiceSettings.pitchShift}, speed=${voiceSettings.speed}`
+		);
 		console.log("  ⚠️  This test consumes credits!");
 
 		const response = await client.textToSpeech.createSpeech({
 			voiceId,
 			apiConvertTextToSpeechUsingCharacterRequest: {
-				text: "Hello! This is an MP3 format SDK test. Let's verify if it works correctly.",
+				text: "Hello world! This is a voice settings test. You can hear the adjusted pitch and speed.",
 				language: models.APIConvertTextToSpeechUsingCharacterRequestLanguage.En,
 				outputFormat:
-					models.APIConvertTextToSpeechUsingCharacterRequestOutputFormat.Mp3,
+					models.APIConvertTextToSpeechUsingCharacterRequestOutputFormat.Wav,
 				style: "neutral",
 				model: "sona_speech_1",
+				voiceSettings,
+				includePhonemes: false,
 			},
 		});
 
-		console.log(`  ✅ MP3 TTS conversion success`);
+		console.log(`  ✅ TTS with voice settings success`);
 
 		if (response.result) {
-			const outputFile = "test_create_speech_output.mp3";
+			const outputFile = "test_voice_settings_speech_output.wav";
 			const audioData = await extractAudioData(response);
 
 			fs.writeFileSync(outputFile, audioData);
-			console.log(`  💾 MP3 audio file saved: ${outputFile}`);
+			console.log(`  💾 Voice settings audio file saved: ${outputFile}`);
+		}
 
-			// Verify MP3 header
-			const header = audioData.slice(0, 10);
-			if (header[0] === 0x49 && header[1] === 0x44 && header[2] === 0x33) {
-				console.log(`  ✅ Valid MP3 file generated (ID3 tag)`);
-			} else if (
-				(header[0] === 0xff && header[1] === 0xfb) ||
-				(header[0] === 0xff && header[1] === 0xfa)
-			) {
-				console.log(`  ✅ Valid MP3 file generated (MPEG frame)`);
+		return [true, response];
+	} catch (e: any) {
+		console.error(`  ❌ Error: ${e.message || e}`);
+		return [false, e];
+	}
+}
+
+/**
+ * Test TTS with phoneme information
+ */
+async function testCreateSpeechWithPhonemes(
+	voiceId: string | null
+): Promise<[boolean, any]> {
+	console.log("🔤 TTS with Phoneme Information Test");
+
+	if (!voiceId) {
+		console.log("  ⚠️  No voice ID available");
+		return [false, null];
+	}
+
+	try {
+		const { Supertone } = await import("../src/index.js");
+		const models = await import("../src/models/index.js");
+		const client = new Supertone({ apiKey: API_KEY });
+
+		console.log(
+			`  🔍 TTS conversion with phonemes using voice '${voiceId}'...`
+		);
+		console.log("  ⚠️  This test consumes credits!");
+
+		const response = await client.textToSpeech.createSpeech({
+			voiceId,
+			apiConvertTextToSpeechUsingCharacterRequest: {
+				text: "Hello world! This is a phoneme timing test.",
+				language: models.APIConvertTextToSpeechUsingCharacterRequestLanguage.En,
+				outputFormat:
+					models.APIConvertTextToSpeechUsingCharacterRequestOutputFormat.Wav,
+				style: "neutral",
+				model: "sona_speech_1",
+				includePhonemes: true,
+			},
+		});
+
+		console.log(`  ✅ TTS with phonemes success`);
+
+		if (response.result) {
+			const outputFile = "test_phoneme_speech_output.wav";
+
+			// Check if response is JSON with phonemes data
+			if (
+				typeof response.result === "object" &&
+				"audioBase64" in response.result
+			) {
+				const audioData = await extractAudioData(response);
+				fs.writeFileSync(outputFile, audioData);
+				console.log(`  💾 Phoneme audio file saved: ${outputFile}`);
+
+				// Display phoneme information as JSON
+				const phonemes = (response.result as any).phonemes;
+				if (phonemes) {
+					console.log(`  📊 Phoneme data (JSON):`);
+					console.log(JSON.stringify(phonemes, null, 2));
+					console.log(`  📈 Summary:`);
+					console.log(`     Symbols count: ${phonemes.symbols?.length || 0}`);
+					console.log(
+						`     Durations count: ${phonemes.durations_seconds?.length || 0}`
+					);
+					console.log(
+						`     Start times count: ${
+							phonemes.start_times_seconds?.length || 0
+						}`
+					);
+					if (phonemes.symbols && phonemes.symbols.length > 0) {
+						console.log(
+							`     First 5 symbols: ${phonemes.symbols.slice(0, 5).join(", ")}`
+						);
+					}
+				}
+			} else {
+				// Binary audio without phonemes
+				const audioData = await extractAudioData(response);
+				fs.writeFileSync(outputFile, audioData);
+				console.log(`  💾 Phoneme audio file saved: ${outputFile}`);
+			}
+		}
+
+		return [true, response];
+	} catch (e: any) {
+		console.error(`  ❌ Error: ${e.message || e}`);
+		return [false, e];
+	}
+}
+
+/**
+ * Test TTS streaming with phonemes
+ */
+async function testStreamSpeechWithPhonemes(
+	voiceId: string | null
+): Promise<[boolean, any]> {
+	console.log("📡 TTS Streaming with Phonemes Test");
+
+	if (!voiceId) {
+		console.log("  ⚠️  No voice ID available");
+		return [false, null];
+	}
+
+	try {
+		const { Supertone } = await import("../src/index.js");
+		const models = await import("../src/models/index.js");
+		const client = new Supertone({ apiKey: API_KEY });
+
+		console.log(
+			`  🔍 Streaming speech with phonemes for voice '${voiceId}'...`
+		);
+		console.log("  ⚠️  This test consumes credits!");
+
+		const response = await client.textToSpeech.streamSpeech({
+			voiceId,
+			apiConvertTextToSpeechUsingCharacterRequest: {
+				text: "Streaming with phoneme timing information.",
+				language: models.APIConvertTextToSpeechUsingCharacterRequestLanguage.En,
+				outputFormat:
+					models.APIConvertTextToSpeechUsingCharacterRequestOutputFormat.Wav,
+				includePhonemes: true,
+			},
+		});
+
+		console.log(`  ✅ Stream with phonemes started successfully`);
+
+		return [true, response];
+	} catch (e: any) {
+		console.error(`  ❌ Error: ${e.message || e}`);
+		return [false, e];
+	}
+}
+
+// =============================================================================
+// Model & Language Compatibility Tests
+// =============================================================================
+
+/**
+ * Model-Language compatibility matrix
+ * - sona_speech_1: ko, en, ja
+ * - sona_speech_2: all languages (23 languages)
+ * - supertonic_api_1: ko, en, ja, es, pt
+ */
+const MODEL_LANGUAGE_MATRIX = {
+	sona_speech_1: ["ko", "en", "ja"],
+	sona_speech_2: [
+		"en",
+		"ko",
+		"ja",
+		"bg",
+		"cs",
+		"da",
+		"el",
+		"es",
+		"et",
+		"fi",
+		"hu",
+		"it",
+		"nl",
+		"pl",
+		"pt",
+		"ro",
+		"ar",
+		"de",
+		"fr",
+		"hi",
+		"id",
+		"ru",
+		"vi",
+	],
+	supertonic_api_1: ["ko", "en", "ja", "es", "pt"],
+} as const;
+
+/**
+ * Test TTS with sona_speech_2 model
+ */
+async function testCreateSpeechWithSonaSpeech2(
+	voiceId: string | null
+): Promise<[boolean, any]> {
+	console.log("🤖 TTS with sona_speech_2 Model Test");
+
+	if (!voiceId) {
+		console.log("  ⚠️  No voice ID available");
+		return [false, null];
+	}
+
+	try {
+		const { Supertone } = await import("../src/index.js");
+		const models = await import("../src/models/index.js");
+		const client = new Supertone({ apiKey: API_KEY });
+
+		const testText =
+			"Hello! Testing sona_speech_2 model for text-to-speech conversion.";
+		console.log(`  🔍 Creating speech with sona_speech_2 model`);
+		console.log(`     Voice ID: ${voiceId}`);
+		console.log(`     Model: sona_speech_2`);
+		console.log("  ⚠️  This test consumes credits!");
+
+		const response = await client.textToSpeech.createSpeech({
+			voiceId,
+			apiConvertTextToSpeechUsingCharacterRequest: {
+				text: testText,
+				language: models.APIConvertTextToSpeechUsingCharacterRequestLanguage.En,
+				outputFormat:
+					models.APIConvertTextToSpeechUsingCharacterRequestOutputFormat.Wav,
+				model:
+					models.APIConvertTextToSpeechUsingCharacterRequestModel.SonaSpeech2,
+			},
+		});
+
+		console.log(`  ✅ sona_speech_2 TTS success`);
+
+		if (response.result) {
+			const audioData = await extractAudioData(response);
+			const outputFile = "test_sona_speech_2_output.wav";
+			fs.writeFileSync(outputFile, audioData);
+			console.log(
+				`  💾 Audio saved: ${outputFile} (${audioData.length} bytes)`
+			);
+		}
+
+		return [true, response];
+	} catch (e: any) {
+		logDetailedError(e, "sona_speech_2 TTS");
+		return [false, e];
+	}
+}
+
+/**
+ * Test TTS with supertonic_api_1 model
+ */
+async function testCreateSpeechWithSupertonicApi1(
+	voiceId: string | null
+): Promise<[boolean, any]> {
+	console.log("🤖 TTS with supertonic_api_1 Model Test");
+
+	if (!voiceId) {
+		console.log("  ⚠️  No voice ID available");
+		return [false, null];
+	}
+
+	try {
+		const { Supertone } = await import("../src/index.js");
+		const models = await import("../src/models/index.js");
+		const client = new Supertone({ apiKey: API_KEY });
+
+		const testText =
+			"Hello! Testing supertonic_api_1 model for text-to-speech conversion.";
+		console.log(`  🔍 Creating speech with supertonic_api_1 model`);
+		console.log(`     Voice ID: ${voiceId}`);
+		console.log(`     Model: supertonic_api_1`);
+		console.log("  ⚠️  This test consumes credits!");
+
+		const response = await client.textToSpeech.createSpeech({
+			voiceId,
+			apiConvertTextToSpeechUsingCharacterRequest: {
+				text: testText,
+				language: models.APIConvertTextToSpeechUsingCharacterRequestLanguage.En,
+				outputFormat:
+					models.APIConvertTextToSpeechUsingCharacterRequestOutputFormat.Wav,
+				model:
+					models.APIConvertTextToSpeechUsingCharacterRequestModel
+						.SupertonicApi1,
+			},
+		});
+
+		console.log(`  ✅ supertonic_api_1 TTS success`);
+
+		if (response.result) {
+			const audioData = await extractAudioData(response);
+			const outputFile = "test_supertonic_api_1_output.wav";
+			fs.writeFileSync(outputFile, audioData);
+			console.log(
+				`  💾 Audio saved: ${outputFile} (${audioData.length} bytes)`
+			);
+		}
+
+		return [true, response];
+	} catch (e: any) {
+		logDetailedError(e, "supertonic_api_1 TTS");
+		return [false, e];
+	}
+}
+
+/**
+ * Test TTS with unsupported model (should fail with validation error)
+ */
+async function testCreateSpeechWithUnsupportedModel(
+	voiceId: string | null
+): Promise<[boolean, any]> {
+	console.log("🚫 TTS with Unsupported Model Test (Expected to Fail)");
+
+	if (!voiceId) {
+		console.log("  ⚠️  No voice ID available");
+		return [false, null];
+	}
+
+	try {
+		const { Supertone } = await import("../src/index.js");
+		const models = await import("../src/models/index.js");
+		const client = new Supertone({ apiKey: API_KEY });
+
+		const testText = "This should fail with unsupported model.";
+		console.log(
+			`  🔍 Attempting TTS with unsupported model: 'invalid_model_xyz'`
+		);
+
+		// Using type assertion to bypass TypeScript validation for testing
+		const response = await client.textToSpeech.createSpeech({
+			voiceId,
+			apiConvertTextToSpeechUsingCharacterRequest: {
+				text: testText,
+				language: models.APIConvertTextToSpeechUsingCharacterRequestLanguage.En,
+				outputFormat:
+					models.APIConvertTextToSpeechUsingCharacterRequestOutputFormat.Wav,
+				model: "invalid_model_xyz" as any, // Intentionally invalid model
+			},
+		});
+
+		// If we reach here, the test failed (should have thrown an error)
+		console.log(`  ❌ Expected error but got success - this is unexpected!`);
+		return [false, response];
+	} catch (e: any) {
+		// Expected to fail - this is the success case for this test
+		console.log(`  ✅ Correctly rejected unsupported model`);
+		console.log(`  📋 Error type: ${e.constructor?.name || typeof e}`);
+		console.log(`  📋 Error message: ${e.message?.substring(0, 100) || e}`);
+		return [true, e];
+	}
+}
+
+/**
+ * Test prediction with sona_speech_2 model
+ */
+async function testPredictDurationWithSonaSpeech2(
+	voiceId: string | null
+): Promise<[boolean, any]> {
+	console.log("⏱️  Duration Prediction with sona_speech_2 Model Test");
+
+	if (!voiceId) {
+		console.log("  ⚠️  No voice ID available");
+		return [false, null];
+	}
+
+	try {
+		const { Supertone } = await import("../src/index.js");
+		const models = await import("../src/models/index.js");
+		const client = new Supertone({ apiKey: API_KEY });
+
+		const testText = "Testing duration prediction with sona_speech_2 model.";
+		console.log(`  🔍 Predicting duration with sona_speech_2 model`);
+
+		const response = await client.textToSpeech.predictDuration({
+			voiceId,
+			predictTTSDurationUsingCharacterRequest: {
+				text: testText,
+				language: models.PredictTTSDurationUsingCharacterRequestLanguage.En,
+				model: models.PredictTTSDurationUsingCharacterRequestModel.SonaSpeech2,
+			},
+		});
+
+		console.log(
+			`  ✅ sona_speech_2 duration prediction: ${response.duration}s`
+		);
+		return [true, response];
+	} catch (e: any) {
+		logDetailedError(e, "sona_speech_2 duration prediction");
+		return [false, e];
+	}
+}
+
+/**
+ * Test prediction with supertonic_api_1 model
+ */
+async function testPredictDurationWithSupertonicApi1(
+	voiceId: string | null
+): Promise<[boolean, any]> {
+	console.log("⏱️  Duration Prediction with supertonic_api_1 Model Test");
+
+	if (!voiceId) {
+		console.log("  ⚠️  No voice ID available");
+		return [false, null];
+	}
+
+	try {
+		const { Supertone } = await import("../src/index.js");
+		const models = await import("../src/models/index.js");
+		const client = new Supertone({ apiKey: API_KEY });
+
+		const testText = "Testing duration prediction with supertonic_api_1 model.";
+		console.log(`  🔍 Predicting duration with supertonic_api_1 model`);
+
+		const response = await client.textToSpeech.predictDuration({
+			voiceId,
+			predictTTSDurationUsingCharacterRequest: {
+				text: testText,
+				language: models.PredictTTSDurationUsingCharacterRequestLanguage.En,
+				model:
+					models.PredictTTSDurationUsingCharacterRequestModel.SupertonicApi1,
+			},
+		});
+
+		console.log(
+			`  ✅ supertonic_api_1 duration prediction: ${response.duration}s`
+		);
+		return [true, response];
+	} catch (e: any) {
+		logDetailedError(e, "supertonic_api_1 duration prediction");
+		return [false, e];
+	}
+}
+
+/**
+ * Test prediction with unsupported model (should fail with validation error)
+ */
+async function testPredictDurationWithUnsupportedModel(
+	voiceId: string | null
+): Promise<[boolean, any]> {
+	console.log(
+		"🚫 Duration Prediction with Unsupported Model Test (Expected to Fail)"
+	);
+
+	if (!voiceId) {
+		console.log("  ⚠️  No voice ID available");
+		return [false, null];
+	}
+
+	try {
+		const { Supertone } = await import("../src/index.js");
+		const models = await import("../src/models/index.js");
+		const client = new Supertone({ apiKey: API_KEY });
+
+		const testText = "This should fail with unsupported model.";
+		console.log(
+			`  🔍 Attempting prediction with unsupported model: 'invalid_model_xyz'`
+		);
+
+		const response = await client.textToSpeech.predictDuration({
+			voiceId,
+			predictTTSDurationUsingCharacterRequest: {
+				text: testText,
+				language: models.PredictTTSDurationUsingCharacterRequestLanguage.En,
+				model: "invalid_model_xyz" as any, // Intentionally invalid model
+			},
+		});
+
+		console.log(`  ❌ Expected error but got success - this is unexpected!`);
+		return [false, response];
+	} catch (e: any) {
+		console.log(`  ✅ Correctly rejected unsupported model`);
+		console.log(`  📋 Error type: ${e.constructor?.name || typeof e}`);
+		console.log(`  📋 Error message: ${e.message?.substring(0, 100) || e}`);
+		return [true, e];
+	}
+}
+
+// =============================================================================
+// Multilingual Tests per Model
+// =============================================================================
+
+/**
+ * Test TTS multilingual support with sona_speech_1 (supports: ko, en, ja)
+ */
+async function testMultilingualSonaSpeech1(
+	voiceId: string | null
+): Promise<[boolean, any]> {
+	console.log("🌍 Multilingual Test - sona_speech_1 (ko, en, ja)");
+
+	if (!voiceId) {
+		console.log("  ⚠️  No voice ID available");
+		return [false, null];
+	}
+
+	const testCases = [
+		{
+			lang: "ko" as const,
+			text: "안녕하세요, 소나 스피치 원 모델입니다.",
+			label: "Korean",
+		},
+		{
+			lang: "en" as const,
+			text: "Hello, this is sona_speech_1 model.",
+			label: "English",
+		},
+		{
+			lang: "ja" as const,
+			text: "こんにちは、ソナスピーチワンモデルです。",
+			label: "Japanese",
+		},
+	];
+
+	try {
+		const { Supertone } = await import("../src/index.js");
+		const models = await import("../src/models/index.js");
+		const client = new Supertone({ apiKey: API_KEY });
+
+		let allPassed = true;
+		const results: any[] = [];
+
+		for (const tc of testCases) {
+			console.log(`  🔍 Testing ${tc.label} (${tc.lang})...`);
+
+			try {
+				const langEnum =
+					models.APIConvertTextToSpeechUsingCharacterRequestLanguage[
+						(tc.lang.charAt(0).toUpperCase() +
+							tc.lang.slice(
+								1
+							)) as keyof typeof models.APIConvertTextToSpeechUsingCharacterRequestLanguage
+					];
+
+				const response = await client.textToSpeech.createSpeech({
+					voiceId,
+					apiConvertTextToSpeechUsingCharacterRequest: {
+						text: tc.text,
+						language: langEnum,
+						outputFormat:
+							models.APIConvertTextToSpeechUsingCharacterRequestOutputFormat
+								.Wav,
+						model:
+							models.APIConvertTextToSpeechUsingCharacterRequestModel
+								.SonaSpeech1,
+					},
+				});
+
+				console.log(`     ✅ ${tc.label} success`);
+				results.push({ lang: tc.lang, success: true });
+			} catch (e: any) {
+				console.log(
+					`     ❌ ${tc.label} failed: ${e.message?.substring(0, 50)}`
+				);
+				results.push({ lang: tc.lang, success: false, error: e.message });
+				allPassed = false;
+			}
+		}
+
+		console.log(
+			`  📊 Result: ${results.filter((r) => r.success).length}/${
+				testCases.length
+			} languages passed`
+		);
+		return [allPassed, results];
+	} catch (e: any) {
+		logDetailedError(e, "sona_speech_1 multilingual");
+		return [false, e];
+	}
+}
+
+/**
+ * Test TTS multilingual support with sona_speech_2 (supports all languages)
+ */
+async function testMultilingualSonaSpeech2(
+	voiceId: string | null
+): Promise<[boolean, any]> {
+	console.log("🌍 Multilingual Test - sona_speech_2 (all languages sample)");
+
+	if (!voiceId) {
+		console.log("  ⚠️  No voice ID available");
+		return [false, null];
+	}
+
+	// Test a diverse subset of languages
+	const testCases = [
+		{ lang: "Ko" as const, text: "안녕하세요.", label: "Korean" },
+		{ lang: "En" as const, text: "Hello.", label: "English" },
+		{ lang: "Ja" as const, text: "こんにちは。", label: "Japanese" },
+		{ lang: "Es" as const, text: "Hola.", label: "Spanish" },
+		{ lang: "Fr" as const, text: "Bonjour.", label: "French" },
+		{ lang: "De" as const, text: "Hallo.", label: "German" },
+		{ lang: "Ar" as const, text: "مرحبا.", label: "Arabic" },
+		{ lang: "Hi" as const, text: "नमस्ते।", label: "Hindi" },
+	];
+
+	try {
+		const { Supertone } = await import("../src/index.js");
+		const models = await import("../src/models/index.js");
+		const client = new Supertone({ apiKey: API_KEY });
+
+		let allPassed = true;
+		const results: any[] = [];
+
+		for (const tc of testCases) {
+			console.log(`  🔍 Testing ${tc.label} (${tc.lang})...`);
+
+			try {
+				const langEnum =
+					models.APIConvertTextToSpeechUsingCharacterRequestLanguage[tc.lang];
+
+				const response = await client.textToSpeech.createSpeech({
+					voiceId,
+					apiConvertTextToSpeechUsingCharacterRequest: {
+						text: tc.text,
+						language: langEnum,
+						outputFormat:
+							models.APIConvertTextToSpeechUsingCharacterRequestOutputFormat
+								.Wav,
+						model:
+							models.APIConvertTextToSpeechUsingCharacterRequestModel
+								.SonaSpeech2,
+					},
+				});
+
+				console.log(`     ✅ ${tc.label} success`);
+				results.push({ lang: tc.lang, success: true });
+			} catch (e: any) {
+				console.log(
+					`     ❌ ${tc.label} failed: ${e.message?.substring(0, 50)}`
+				);
+				results.push({ lang: tc.lang, success: false, error: e.message });
+				allPassed = false;
+			}
+		}
+
+		console.log(
+			`  📊 Result: ${results.filter((r) => r.success).length}/${
+				testCases.length
+			} languages passed`
+		);
+		return [allPassed, results];
+	} catch (e: any) {
+		logDetailedError(e, "sona_speech_2 multilingual");
+		return [false, e];
+	}
+}
+
+/**
+ * Test TTS multilingual support with supertonic_api_1 (supports: ko, en, ja, es, pt)
+ */
+async function testMultilingualSupertonicApi1(
+	voiceId: string | null
+): Promise<[boolean, any]> {
+	console.log("🌍 Multilingual Test - supertonic_api_1 (ko, en, ja, es, pt)");
+
+	if (!voiceId) {
+		console.log("  ⚠️  No voice ID available");
+		return [false, null];
+	}
+
+	const testCases = [
+		{
+			lang: "Ko" as const,
+			text: "안녕하세요, 슈퍼토닉 API 원 모델입니다.",
+			label: "Korean",
+		},
+		{
+			lang: "En" as const,
+			text: "Hello, this is supertonic_api_1 model.",
+			label: "English",
+		},
+		{
+			lang: "Ja" as const,
+			text: "こんにちは、スーパートニックAPIワンです。",
+			label: "Japanese",
+		},
+		{
+			lang: "Es" as const,
+			text: "Hola, este es el modelo supertonic_api_1.",
+			label: "Spanish",
+		},
+		{
+			lang: "Pt" as const,
+			text: "Olá, este é o modelo supertonic_api_1.",
+			label: "Portuguese",
+		},
+	];
+
+	try {
+		const { Supertone } = await import("../src/index.js");
+		const models = await import("../src/models/index.js");
+		const client = new Supertone({ apiKey: API_KEY });
+
+		let allPassed = true;
+		const results: any[] = [];
+
+		for (const tc of testCases) {
+			console.log(`  🔍 Testing ${tc.label} (${tc.lang})...`);
+
+			try {
+				const langEnum =
+					models.APIConvertTextToSpeechUsingCharacterRequestLanguage[tc.lang];
+
+				const response = await client.textToSpeech.createSpeech({
+					voiceId,
+					apiConvertTextToSpeechUsingCharacterRequest: {
+						text: tc.text,
+						language: langEnum,
+						outputFormat:
+							models.APIConvertTextToSpeechUsingCharacterRequestOutputFormat
+								.Wav,
+						model:
+							models.APIConvertTextToSpeechUsingCharacterRequestModel
+								.SupertonicApi1,
+					},
+				});
+
+				console.log(`     ✅ ${tc.label} success`);
+				results.push({ lang: tc.lang, success: true });
+			} catch (e: any) {
+				console.log(
+					`     ❌ ${tc.label} failed: ${e.message?.substring(0, 50)}`
+				);
+				results.push({ lang: tc.lang, success: false, error: e.message });
+				allPassed = false;
+			}
+		}
+
+		console.log(
+			`  📊 Result: ${results.filter((r) => r.success).length}/${
+				testCases.length
+			} languages passed`
+		);
+		return [allPassed, results];
+	} catch (e: any) {
+		logDetailedError(e, "supertonic_api_1 multilingual");
+		return [false, e];
+	}
+}
+
+/**
+ * Test unsupported language for sona_speech_1 (should fail with French)
+ */
+async function testUnsupportedLanguageSonaSpeech1(
+	voiceId: string | null
+): Promise<[boolean, any]> {
+	console.log(
+		"🚫 Unsupported Language Test - sona_speech_1 with French (Expected to Fail)"
+	);
+
+	if (!voiceId) {
+		console.log("  ⚠️  No voice ID available");
+		return [false, null];
+	}
+
+	try {
+		const { Supertone } = await import("../src/index.js");
+		const models = await import("../src/models/index.js");
+		const client = new Supertone({ apiKey: API_KEY });
+
+		console.log(`  🔍 Attempting sona_speech_1 with French (unsupported)`);
+
+		const response = await client.textToSpeech.createSpeech({
+			voiceId,
+			apiConvertTextToSpeechUsingCharacterRequest: {
+				text: "Bonjour, ceci est un test.",
+				language: models.APIConvertTextToSpeechUsingCharacterRequestLanguage.Fr, // French - not supported by sona_speech_1
+				outputFormat:
+					models.APIConvertTextToSpeechUsingCharacterRequestOutputFormat.Wav,
+				model:
+					models.APIConvertTextToSpeechUsingCharacterRequestModel.SonaSpeech1,
+			},
+		});
+
+		// If we reach here, the API didn't reject - may need server-side validation
+		console.log(
+			`  ⚠️  API accepted the request - server-side validation may not enforce language restriction`
+		);
+		console.log(
+			`  📋 Note: Language restriction may be enforced at API level, not SDK level`
+		);
+		return [
+			true,
+			{ note: "API accepted - language restriction may be server-side" },
+		];
+	} catch (e: any) {
+		console.log(
+			`  ✅ Correctly rejected unsupported language for sona_speech_1`
+		);
+		console.log(`  📋 Error: ${e.message?.substring(0, 100)}`);
+		return [true, e];
+	}
+}
+
+/**
+ * Test unsupported language for supertonic_api_1 (should fail with German)
+ */
+async function testUnsupportedLanguageSupertonicApi1(
+	voiceId: string | null
+): Promise<[boolean, any]> {
+	console.log(
+		"🚫 Unsupported Language Test - supertonic_api_1 with German (Expected to Fail)"
+	);
+
+	if (!voiceId) {
+		console.log("  ⚠️  No voice ID available");
+		return [false, null];
+	}
+
+	try {
+		const { Supertone } = await import("../src/index.js");
+		const models = await import("../src/models/index.js");
+		const client = new Supertone({ apiKey: API_KEY });
+
+		console.log(`  🔍 Attempting supertonic_api_1 with German (unsupported)`);
+
+		const response = await client.textToSpeech.createSpeech({
+			voiceId,
+			apiConvertTextToSpeechUsingCharacterRequest: {
+				text: "Hallo, das ist ein Test.",
+				language: models.APIConvertTextToSpeechUsingCharacterRequestLanguage.De, // German - not supported by supertonic_api_1
+				outputFormat:
+					models.APIConvertTextToSpeechUsingCharacterRequestOutputFormat.Wav,
+				model:
+					models.APIConvertTextToSpeechUsingCharacterRequestModel
+						.SupertonicApi1,
+			},
+		});
+
+		// If we reach here, the API didn't reject - may need server-side validation
+		console.log(
+			`  ⚠️  API accepted the request - server-side validation may not enforce language restriction`
+		);
+		console.log(
+			`  📋 Note: Language restriction may be enforced at API level, not SDK level`
+		);
+		return [
+			true,
+			{ note: "API accepted - language restriction may be server-side" },
+		];
+	} catch (e: any) {
+		console.log(
+			`  ✅ Correctly rejected unsupported language for supertonic_api_1`
+		);
+		console.log(`  📋 Error: ${e.message?.substring(0, 100)}`);
+		return [true, e];
+	}
+}
+
+/**
+ * Test duration prediction with voice settings
+ */
+async function testPredictDurationWithVoiceSettings(
+	voiceId: string | null
+): Promise<[boolean, any]> {
+	console.log("⏱️  Duration Prediction with Voice Settings Test");
+
+	if (!voiceId) {
+		console.log("  ⚠️  No voice ID available");
+		return [false, null];
+	}
+
+	try {
+		const { Supertone } = await import("../src/index.js");
+		const models = await import("../src/models/index.js");
+		const client = new Supertone({ apiKey: API_KEY });
+
+		const voiceSettings = {
+			speed: 0.8,
+		};
+
+		console.log(
+			`  🔍 Predicting duration with voice settings for voice '${voiceId}'...`
+		);
+		console.log(`     Settings: speed=${voiceSettings.speed}`);
+
+		const response = await client.textToSpeech.predictDuration({
+			voiceId,
+			predictTTSDurationUsingCharacterRequest: {
+				text: "This is a duration test with adjusted speed.",
+				language: models.PredictTTSDurationUsingCharacterRequestLanguage.En,
+				voiceSettings,
+			},
+		});
+
+		console.log(`  ✅ Predicted duration: ${response.duration}s`);
+
+		return [true, response];
+	} catch (e: any) {
+		console.error(`  ❌ Error: ${e.message || e}`);
+		return [false, e];
+	}
+}
+
+/**
+ * Test TTS streaming with voice settings
+ */
+async function testStreamSpeechWithVoiceSettings(
+	voiceId: string | null
+): Promise<[boolean, any]> {
+	console.log("📡 TTS Streaming with Voice Settings Test");
+
+	if (!voiceId) {
+		console.log("  ⚠️  No voice ID available");
+		return [false, null];
+	}
+
+	try {
+		const { Supertone } = await import("../src/index.js");
+		const models = await import("../src/models/index.js");
+		const client = new Supertone({ apiKey: API_KEY });
+
+		const voiceSettings = {
+			pitchShift: 1.05,
+			speed: 1.1,
+		};
+
+		console.log(
+			`  🔍 Streaming speech with voice settings for voice '${voiceId}'...`
+		);
+		console.log(
+			`     Settings: pitchShift=${voiceSettings.pitchShift}, speed=${voiceSettings.speed}`
+		);
+		console.log("  ⚠️  This test consumes credits!");
+
+		const response = await client.textToSpeech.streamSpeech({
+			voiceId,
+			apiConvertTextToSpeechUsingCharacterRequest: {
+				text: "Streaming with adjusted voice settings.",
+				language: models.APIConvertTextToSpeechUsingCharacterRequestLanguage.En,
+				outputFormat:
+					models.APIConvertTextToSpeechUsingCharacterRequestOutputFormat.Wav,
+				voiceSettings,
+			},
+		});
+
+		console.log(`  ✅ Stream with voice settings started successfully`);
+
+		return [true, response];
+	} catch (e: any) {
+		console.error(`  ❌ Error: ${e.message || e}`);
+		return [false, e];
+	}
+}
+
+/**
+ * Test MP3 format TTS
+ */
+async function testCreateSpeechMp3(
+	voiceId: string | null
+): Promise<[boolean, any]> {
+	console.log("🎤 MP3 Format TTS Test");
+
+	if (!voiceId) {
+		console.log("  ⚠️  No voice ID available");
+		return [false, null];
+	}
+
+	try {
+		const { Supertone } = await import("../src/index.js");
+		const models = await import("../src/models/index.js");
+		const client = new Supertone({ apiKey: API_KEY });
+
+		console.log(`  🔍 MP3 TTS conversion with voice '${voiceId}'...`);
+		console.log("  ⚠️  This test consumes credits!");
+
+		const response = await client.textToSpeech.createSpeech({
+			voiceId,
+			apiConvertTextToSpeechUsingCharacterRequest: {
+				text: "Hello! This is an MP3 format SDK test. Let's verify if it works correctly.",
+				language: models.APIConvertTextToSpeechUsingCharacterRequestLanguage.En,
+				outputFormat:
+					models.APIConvertTextToSpeechUsingCharacterRequestOutputFormat.Mp3,
+				style: "neutral",
+				model: "sona_speech_1",
+			},
+		});
+
+		console.log(`  ✅ MP3 TTS conversion success`);
+
+		if (response.result) {
+			const outputFile = "test_create_speech_output.mp3";
+			const audioData = await extractAudioData(response);
+
+			fs.writeFileSync(outputFile, audioData);
+			console.log(`  💾 MP3 audio file saved: ${outputFile}`);
+
+			// Verify MP3 header
+			const header = audioData.slice(0, 10);
+			if (header[0] === 0x49 && header[1] === 0x44 && header[2] === 0x33) {
+				console.log(`  ✅ Valid MP3 file generated (ID3 tag)`);
+			} else if (
+				(header[0] === 0xff && header[1] === 0xfb) ||
+				(header[0] === 0xff && header[1] === 0xfa)
+			) {
+				console.log(`  ✅ Valid MP3 file generated (MPEG frame)`);
 			} else {
 				console.log(
 					`  📄 MP3 header: ${Array.from(header.slice(0, 10))
@@ -1536,6 +2616,304 @@ async function testCreateSpeechWithChunking(
 	}
 }
 
+// =============================================================================
+// Pronunciation Dictionary Tests
+// =============================================================================
+
+/**
+ * Test TTS with pronunciation dictionary (basic test with partial_match=true/false)
+ */
+async function testCreateSpeechWithPronunciationDictionary(
+	voiceId: string | null
+): Promise<[boolean, any]> {
+	console.log("📖 TTS with Pronunciation Dictionary Test");
+
+	if (!voiceId) {
+		console.log("  ⚠️  No voice ID available");
+		return [false, null];
+	}
+
+	try {
+		const { Supertone } = await import("../src/index.js");
+		const models = await import("../src/models/index.js");
+		const client = new Supertone({ apiKey: API_KEY });
+
+		// Test text with abbreviations and special terms
+		const testText =
+			"The CEO of OpenAI announced that GPT models are improving. Dr. Smith from MIT said AI research is accelerating.";
+
+		// Pronunciation dictionary with both partial_match=true and partial_match=false cases
+		const pronunciationDictionary = [
+			// partial_match=false: exact word boundary match
+			{ text: "CEO", pronunciation: "Chief Executive Officer", partial_match: false },
+			{ text: "MIT", pronunciation: "Massachusetts Institute of Technology", partial_match: false },
+			{ text: "AI", pronunciation: "Artificial Intelligence", partial_match: false },
+			// partial_match=true: substring match (will match "OpenAI" -> "OpenArtificial Intelligence")
+			{ text: "GPT", pronunciation: "Generative Pre-trained Transformer", partial_match: true },
+			{ text: "Dr.", pronunciation: "Doctor", partial_match: true },
+		];
+
+		console.log(`  🔍 Original text: "${testText}"`);
+		console.log(`  📖 Pronunciation dictionary entries: ${pronunciationDictionary.length}`);
+		console.log(`     - partial_match=false: CEO, MIT, AI (word boundary match)`);
+		console.log(`     - partial_match=true: GPT, Dr. (substring match)`);
+		console.log("  ⚠️  This test consumes credits!");
+
+		const response = await client.textToSpeech.createSpeech(
+			{
+				voiceId,
+				apiConvertTextToSpeechUsingCharacterRequest: {
+					text: testText,
+					language: models.APIConvertTextToSpeechUsingCharacterRequestLanguage.En,
+					outputFormat:
+						models.APIConvertTextToSpeechUsingCharacterRequestOutputFormat.Wav,
+					style: "neutral",
+					model: "sona_speech_1",
+				},
+			},
+			{
+				pronunciationDictionary,
+			}
+		);
+
+		console.log(`  ✅ TTS with pronunciation dictionary success`);
+
+		if (response.result) {
+			const audioData = await extractAudioData(response);
+			const outputFile = "test_pronunciation_dictionary_output.wav";
+			fs.writeFileSync(outputFile, audioData);
+			console.log(`  💾 Audio saved: ${outputFile} (${audioData.length} bytes)`);
+		}
+
+		return [true, response];
+	} catch (e: any) {
+		logDetailedError(e, "Pronunciation dictionary TTS");
+		return [false, e];
+	}
+}
+
+/**
+ * Test TTS with pronunciation dictionary causing text to exceed 300 chars (triggers chunking)
+ */
+async function testCreateSpeechWithPronunciationDictionaryLongText(
+	voiceId: string | null
+): Promise<[boolean, any]> {
+	console.log("📖 TTS with Pronunciation Dictionary + Long Text Chunking Test");
+
+	if (!voiceId) {
+		console.log("  ⚠️  No voice ID available");
+		return [false, null];
+	}
+
+	try {
+		const { Supertone } = await import("../src/index.js");
+		const models = await import("../src/models/index.js");
+		const client = new Supertone({ apiKey: API_KEY });
+
+		// Short original text (~200 chars) that will exceed 300 chars after pronunciation dictionary expansion
+		const testText =
+			"AI and ML are revolutionizing tech. The CEO of OpenAI discussed GPT advancements. " +
+			"Dr. Kim from MIT explained how NLP and CV work together. AWS and GCP provide cloud AI services.";
+
+		// Pronunciation dictionary that expands abbreviations significantly
+		const pronunciationDictionary = [
+			// partial_match=false: exact word boundary matches
+			{ text: "AI", pronunciation: "Artificial Intelligence", partial_match: false },
+			{ text: "ML", pronunciation: "Machine Learning", partial_match: false },
+			{ text: "CEO", pronunciation: "Chief Executive Officer", partial_match: false },
+			{ text: "MIT", pronunciation: "Massachusetts Institute of Technology", partial_match: false },
+			{ text: "NLP", pronunciation: "Natural Language Processing", partial_match: false },
+			{ text: "CV", pronunciation: "Computer Vision", partial_match: false },
+			{ text: "AWS", pronunciation: "Amazon Web Services", partial_match: false },
+			{ text: "GCP", pronunciation: "Google Cloud Platform", partial_match: false },
+			// partial_match=true: substring matches
+			{ text: "GPT", pronunciation: "Generative Pre-trained Transformer", partial_match: true },
+			{ text: "Dr.", pronunciation: "Doctor", partial_match: true },
+			{ text: "tech", pronunciation: "technology", partial_match: true },
+		];
+
+		const originalLength = testText.length;
+
+		console.log(`  🔍 Original text length: ${originalLength} characters (under 300)`);
+		console.log(`  📖 Pronunciation dictionary entries: ${pronunciationDictionary.length}`);
+		console.log(`     - partial_match=false: AI, ML, CEO, MIT, NLP, CV, AWS, GCP`);
+		console.log(`     - partial_match=true: GPT, Dr., tech`);
+		console.log(`  🔧 Expected: Text will expand to 300+ chars, triggering auto-chunking`);
+		console.log("  ⚠️  This test consumes credits!");
+
+		const response = await client.textToSpeech.createSpeech(
+			{
+				voiceId,
+				apiConvertTextToSpeechUsingCharacterRequest: {
+					text: testText,
+					language: models.APIConvertTextToSpeechUsingCharacterRequestLanguage.En,
+					outputFormat:
+						models.APIConvertTextToSpeechUsingCharacterRequestOutputFormat.Wav,
+					style: "neutral",
+					model: "sona_speech_1",
+				},
+			},
+			{
+				pronunciationDictionary,
+			}
+		);
+
+		console.log(`  ✅ TTS with pronunciation dictionary + long text chunking success`);
+		console.log(`  🎯 Auto-chunking was triggered after pronunciation expansion!`);
+
+		if (response.result) {
+			const audioData = await extractAudioData(response);
+			const outputFile = "test_pronunciation_dictionary_long_text_output.wav";
+			fs.writeFileSync(outputFile, audioData);
+			console.log(`  💾 Audio saved: ${outputFile} (${audioData.length} bytes)`);
+		}
+
+		return [true, response];
+	} catch (e: any) {
+		logDetailedError(e, "Pronunciation dictionary long text TTS");
+		return [false, e];
+	}
+}
+
+/**
+ * Test TTS streaming with pronunciation dictionary
+ */
+async function testStreamSpeechWithPronunciationDictionary(
+	voiceId: string | null
+): Promise<[boolean, any]> {
+	console.log("📡 TTS Streaming with Pronunciation Dictionary Test");
+
+	if (!voiceId) {
+		console.log("  ⚠️  No voice ID available");
+		return [false, null];
+	}
+
+	try {
+		const { Supertone } = await import("../src/index.js");
+		const models = await import("../src/models/index.js");
+		const client = new Supertone({ apiKey: API_KEY });
+
+		const testText =
+			"The API documentation explains how to use the SDK. " +
+			"Dr. Lee from NASA discussed the new AI system.";
+
+		const pronunciationDictionary = [
+			{ text: "API", pronunciation: "Application Programming Interface", partial_match: false },
+			{ text: "SDK", pronunciation: "Software Development Kit", partial_match: false },
+			{ text: "NASA", pronunciation: "National Aeronautics and Space Administration", partial_match: false },
+			{ text: "AI", pronunciation: "Artificial Intelligence", partial_match: false },
+			{ text: "Dr.", pronunciation: "Doctor", partial_match: true },
+		];
+
+		console.log(`  🔍 Original text: "${testText}"`);
+		console.log(`  📖 Pronunciation dictionary entries: ${pronunciationDictionary.length}`);
+		console.log("  ⚠️  This test consumes credits!");
+
+		const response = await client.textToSpeech.streamSpeech(
+			{
+				voiceId,
+				apiConvertTextToSpeechUsingCharacterRequest: {
+					text: testText,
+					language: models.APIConvertTextToSpeechUsingCharacterRequestLanguage.En,
+					outputFormat:
+						models.APIConvertTextToSpeechUsingCharacterRequestOutputFormat.Wav,
+				},
+			},
+			{
+				pronunciationDictionary,
+			}
+		);
+
+		console.log(`  ✅ Stream with pronunciation dictionary started successfully`);
+
+		// Consume the stream and save to file
+		if (response.result) {
+			const audioData = await extractAudioData(response);
+			const outputFile = "test_pronunciation_dictionary_stream_output.wav";
+			fs.writeFileSync(outputFile, audioData);
+			console.log(`  💾 Audio saved: ${outputFile} (${audioData.length} bytes)`);
+		}
+
+		return [true, response];
+	} catch (e: any) {
+		logDetailedError(e, "Pronunciation dictionary streaming TTS");
+		return [false, e];
+	}
+}
+
+/**
+ * Test TTS streaming with pronunciation dictionary + long text (triggers chunking)
+ */
+async function testStreamSpeechWithPronunciationDictionaryLongText(
+	voiceId: string | null
+): Promise<[boolean, any]> {
+	console.log("📡 TTS Streaming with Pronunciation Dictionary + Long Text Test");
+
+	if (!voiceId) {
+		console.log("  ⚠️  No voice ID available");
+		return [false, null];
+	}
+
+	try {
+		const { Supertone } = await import("../src/index.js");
+		const models = await import("../src/models/index.js");
+		const client = new Supertone({ apiKey: API_KEY });
+
+		// Short text that will expand after pronunciation dictionary
+		const testText =
+			"AI is everywhere. ML powers many apps. The CEO spoke about GPT. " +
+			"Dr. Smith from MIT and UCLA collaborated on NLP research. AWS and GCP offer AI services.";
+
+		const pronunciationDictionary = [
+			{ text: "AI", pronunciation: "Artificial Intelligence", partial_match: false },
+			{ text: "ML", pronunciation: "Machine Learning", partial_match: false },
+			{ text: "CEO", pronunciation: "Chief Executive Officer", partial_match: false },
+			{ text: "MIT", pronunciation: "Massachusetts Institute of Technology", partial_match: false },
+			{ text: "UCLA", pronunciation: "University of California Los Angeles", partial_match: false },
+			{ text: "NLP", pronunciation: "Natural Language Processing", partial_match: false },
+			{ text: "AWS", pronunciation: "Amazon Web Services", partial_match: false },
+			{ text: "GCP", pronunciation: "Google Cloud Platform", partial_match: false },
+			{ text: "GPT", pronunciation: "Generative Pre-trained Transformer", partial_match: true },
+			{ text: "Dr.", pronunciation: "Doctor", partial_match: true },
+		];
+
+		console.log(`  🔍 Original text length: ${testText.length} characters`);
+		console.log(`  📖 Pronunciation dictionary entries: ${pronunciationDictionary.length}`);
+		console.log(`  🔧 Expected: Text will expand to 300+ chars, triggering stream chunking`);
+		console.log("  ⚠️  This test consumes credits!");
+
+		const response = await client.textToSpeech.streamSpeech(
+			{
+				voiceId,
+				apiConvertTextToSpeechUsingCharacterRequest: {
+					text: testText,
+					language: models.APIConvertTextToSpeechUsingCharacterRequestLanguage.En,
+					outputFormat:
+						models.APIConvertTextToSpeechUsingCharacterRequestOutputFormat.Wav,
+				},
+			},
+			{
+				pronunciationDictionary,
+			}
+		);
+
+		console.log(`  ✅ Stream with pronunciation dictionary + long text started successfully`);
+		console.log(`  🎯 Stream chunking was triggered after pronunciation expansion!`);
+
+		if (response.result) {
+			const audioData = await extractAudioData(response);
+			const outputFile = "test_pronunciation_dictionary_stream_long_text_output.wav";
+			fs.writeFileSync(outputFile, audioData);
+			console.log(`  💾 Audio saved: ${outputFile} (${audioData.length} bytes)`);
+		}
+
+		return [true, response];
+	} catch (e: any) {
+		logDetailedError(e, "Pronunciation dictionary streaming long text TTS");
+		return [false, e];
+	}
+}
+
 /**
  * Main test execution
  */
@@ -1549,7 +2927,7 @@ async function main(): Promise<boolean> {
 	console.log("");
 
 	const testResults: TestResult = {};
-	let voiceIdForTTS: string | null = null;
+	const voiceIdForTTS: string = "91992bbd4758bdcf9c9b01";
 	let customVoiceId: string | null = null;
 	let createdCustomVoiceId: string | null = null;
 
@@ -1572,9 +2950,6 @@ async function main(): Promise<boolean> {
 
 	[success, result] = await testListVoices();
 	testResults["list_voices"] = success;
-	if (success && result.voiceId) {
-		voiceIdForTTS = result.voiceId;
-	}
 
 	[success, result] = await testSearchVoices();
 	testResults["search_voices"] = success;
@@ -1643,6 +3018,67 @@ async function main(): Promise<boolean> {
 		[success, result] = await testStreamSpeech(voiceIdForTTS);
 		testResults["stream_speech"] = success;
 
+		// 5.5 New Model Tests (sona_speech_2, supertonic_api_1)
+		console.log("\n🤖 New Model Tests (sona_speech_2, supertonic_api_1)");
+		console.log("-".repeat(60));
+		console.log("⚠️  These tests consume credits!");
+		console.log("");
+
+		[success, result] = await testCreateSpeechWithSonaSpeech2(voiceIdForTTS);
+		testResults["create_speech_sona_speech_2"] = success;
+
+		[success, result] = await testCreateSpeechWithSupertonicApi1(voiceIdForTTS);
+		testResults["create_speech_supertonic_api_1"] = success;
+
+		[success, result] = await testCreateSpeechWithUnsupportedModel(
+			voiceIdForTTS
+		);
+		testResults["create_speech_unsupported_model"] = success;
+
+		[success, result] = await testPredictDurationWithSonaSpeech2(voiceIdForTTS);
+		testResults["predict_duration_sona_speech_2"] = success;
+
+		[success, result] = await testPredictDurationWithSupertonicApi1(
+			voiceIdForTTS
+		);
+		testResults["predict_duration_supertonic_api_1"] = success;
+
+		[success, result] = await testPredictDurationWithUnsupportedModel(
+			voiceIdForTTS
+		);
+		testResults["predict_duration_unsupported_model"] = success;
+
+		// 5.6 Multilingual Tests per Model
+		console.log("\n🌍 Multilingual Tests per Model");
+		console.log("-".repeat(60));
+		console.log("⚠️  These tests consume credits!");
+		console.log("");
+
+		[success, result] = await testMultilingualSonaSpeech1(voiceIdForTTS);
+		testResults["multilingual_sona_speech_1"] = success;
+
+		[success, result] = await testMultilingualSonaSpeech2(voiceIdForTTS);
+		testResults["multilingual_sona_speech_2"] = success;
+
+		[success, result] = await testMultilingualSupertonicApi1(voiceIdForTTS);
+		testResults["multilingual_supertonic_api_1"] = success;
+
+		// 5.7 Unsupported Language Tests
+		console.log("\n🚫 Unsupported Language Tests");
+		console.log("-".repeat(60));
+		console.log(
+			"⚠️  These tests verify error handling for unsupported model-language combinations!"
+		);
+		console.log("");
+
+		[success, result] = await testUnsupportedLanguageSonaSpeech1(voiceIdForTTS);
+		testResults["unsupported_lang_sona_speech_1"] = success;
+
+		[success, result] = await testUnsupportedLanguageSupertonicApi1(
+			voiceIdForTTS
+		);
+		testResults["unsupported_lang_supertonic_api_1"] = success;
+
 		// 6. TTS Long Text Tests
 		console.log("\n📜 Text-to-Speech Long Text Tests");
 		console.log("-".repeat(60));
@@ -1652,6 +3088,29 @@ async function main(): Promise<boolean> {
 		[success, result] = await testCreateSpeechLongText(voiceIdForTTS);
 		testResults["create_speech_long_text"] = success;
 
+		[success, result] = await testCreateSpeechLongSentenceNoPunctuation(
+			voiceIdForTTS
+		);
+		testResults["create_speech_long_sentence_no_punctuation"] = success;
+
+		[success, result] = await testCreateSpeechJapaneseNoSpaces(voiceIdForTTS);
+		testResults["create_speech_japanese_no_spaces"] = success;
+
+		// 6.5 Multilingual Punctuation Tests (fix/text_utils)
+		console.log("\n🌍 Multilingual Punctuation Chunking Tests");
+		console.log("-".repeat(60));
+		console.log("⚠️  These tests verify multilingual sentence punctuation support!");
+		console.log("");
+
+		[success, result] = await testCreateSpeechArabicPunctuation(voiceIdForTTS);
+		testResults["create_speech_arabic_punctuation"] = success;
+
+		[success, result] = await testCreateSpeechHindiPunctuation(voiceIdForTTS);
+		testResults["create_speech_hindi_punctuation"] = success;
+
+		[success, result] = await testCreateSpeechEllipsisPunctuation(voiceIdForTTS);
+		testResults["create_speech_ellipsis_punctuation"] = success;
+
 		[success, result] = await testStreamSpeechLongText(voiceIdForTTS);
 		testResults["stream_speech_long_text"] = success;
 
@@ -1704,6 +3163,32 @@ async function main(): Promise<boolean> {
 
 		[success, result] = await testStreamSpeechLongTextMp3(voiceIdForTTS);
 		testResults["stream_speech_long_text_mp3"] = success;
+
+		// 10. Pronunciation Dictionary Tests
+		console.log("\n📖 Pronunciation Dictionary Tests");
+		console.log("-".repeat(60));
+		console.log("⚠️  These tests consume credits!");
+		console.log("");
+
+		[success, result] = await testCreateSpeechWithPronunciationDictionary(
+			voiceIdForTTS
+		);
+		testResults["create_speech_pronunciation_dictionary"] = success;
+
+		[success, result] = await testCreateSpeechWithPronunciationDictionaryLongText(
+			voiceIdForTTS
+		);
+		testResults["create_speech_pronunciation_dictionary_long_text"] = success;
+
+		[success, result] = await testStreamSpeechWithPronunciationDictionary(
+			voiceIdForTTS
+		);
+		testResults["stream_speech_pronunciation_dictionary"] = success;
+
+		[success, result] = await testStreamSpeechWithPronunciationDictionaryLongText(
+			voiceIdForTTS
+		);
+		testResults["stream_speech_pronunciation_dictionary_long_text"] = success;
 	}
 
 	// Results Summary
@@ -1761,6 +3246,12 @@ async function main(): Promise<boolean> {
 		"  • Text-to-Speech: predictDuration, createSpeech, streamSpeech"
 	);
 	console.log("  • TTS Long Text: createSpeechLongText, streamSpeechLongText");
+	console.log(
+		"  • TTS Chunking Strategies: Word-based (no punctuation), Character-based (Japanese)"
+	);
+	console.log(
+		"  • Multilingual Punctuation: Arabic (؟ ؛ ۔), Hindi (। ॥), Ellipsis (… ‥)"
+	);
 	console.log(
 		"  • TTS with Voice Settings: createSpeechWithVoiceSettings, predictDurationWithVoiceSettings, streamSpeechWithVoiceSettings"
 	);
@@ -1773,6 +3264,30 @@ async function main(): Promise<boolean> {
 	console.log(
 		"  • Custom Features: Auto-chunking in createSpeech/streamSpeech (transparent)"
 	);
+	console.log(
+		"  • Pronunciation Dictionary: createSpeech/streamSpeech with pronunciationDictionary option"
+	);
+	console.log(
+		"    - partial_match=false (word boundary) and partial_match=true (substring)"
+	);
+	console.log(
+		"    - Long text chunking after pronunciation expansion"
+	);
+	console.log("");
+	console.log("🤖 New Model & Language Tests:");
+	console.log(
+		"  • New Models: sona_speech_2, supertonic_api_1 (createSpeech & predictDuration)"
+	);
+	console.log(
+		"  • Unsupported Model Validation: Error handling for invalid model names"
+	);
+	console.log("  • Multilingual per Model:");
+	console.log("    - sona_speech_1: ko, en, ja");
+	console.log("    - sona_speech_2: all 23 languages");
+	console.log("    - supertonic_api_1: ko, en, ja, es, pt");
+	console.log(
+		"  • Unsupported Language Validation: Error handling for invalid model-language combinations"
+	);
 
 	if (customVoiceId) {
 		console.log("");