playkit-sdk 1.3.0 → 1.4.0-beta.2

package/dist/playkit-sdk.d.ts

@@ -413,6 +413,8 @@ interface SDKConfig {
     defaultImageModel?: string;
     /** Default transcription model to use */
     defaultTranscriptionModel?: string;
+    /** Default text-to-speech model to use */
+    defaultTTSModel?: string;
     /**
      * Enable debug logging
      * @deprecated Use `logging.level` instead. Will be removed in v2.0.
@@ -876,6 +878,112 @@ interface TranscriptionResponse {
     segments?: TranscriptionSegment[];
 }
 
+/**
+ * Text-to-speech (TTS) type definitions
+ */
+/** One voice in a `voiceMix` blend. */
+interface VoiceMixEntry {
+    /** Voice id to include in the blend. */
+    voice: string;
+    /** Relative weight, integer 1–100. */
+    weight: number;
+}
+/** Neutral voice tuning knobs (ElevenLabs-style nested object). */
+interface VoiceSettings {
+    /** Playback speed multiplier (0.5–2). */
+    speed?: number;
+    /** Volume (0–10). */
+    volume?: number;
+    /** Pitch adjustment (-12–12). */
+    pitch?: number;
+    /** Emotion, e.g. 'happy' | 'sad' | 'calm'. */
+    emotion?: string;
+}
+/**
+ * Configuration for text-to-speech requests.
+ *
+ * Inline markup in `text` is supported: pause via `[pause 1.5s]` or
+ * `<break time="1.5s"/>`, and interjections via `[laughs]` / `[breath]` (on
+ * models that support them). These are translated server-side.
+ */
+interface TTSConfig {
+    /** Text to synthesize into speech (max 10000 characters). */
+    text: string;
+    /**
+     * Model to use for synthesis.
+     * Defaults to 'default-tts-model' (alias resolved by the backend).
+     */
+    model?: string;
+    /** Voice id to use (e.g., 'male-qn-qingse'). Mutually exclusive with `voiceMix`. */
+    voice?: string;
+    /**
+     * Blend multiple voices (1–4 entries, weights 1–100). Mutually exclusive with
+     * `voice`.
+     */
+    voiceMix?: VoiceMixEntry[];
+    /** Neutral voice tuning (speed/volume/pitch/emotion). */
+    voiceSettings?: VoiceSettings;
+    /**
+     * Output audio format, ElevenLabs-style: `{codec}_{sampleRate}_{bitrateKbps}`.
+     * Examples: 'mp3', 'mp3_44100_128', 'pcm_24000', 'wav', 'flac_44100', 'opus'.
+     */
+    outputFormat?: string;
+    /** Language hint to improve pronunciation, e.g. 'Chinese' | 'English' | 'auto'. */
+    language?: string;
+    /**
+     * Escape hatch for advanced provider-specific fields not modeled above
+     * (e.g. voice effects, pronunciation dictionaries).
+     */
+    providerOptions?: Record<string, unknown>;
+}
+/**
+ * Options for simplified text-to-speech methods (everything except the text)
+ */
+type TTSOptions = Omit<TTSConfig, 'text'>;
+/** Config for `synthesizeWithTimestamps`: adds subtitle granularity. */
+interface TTSTimestampsConfig extends TTSConfig {
+    /** Timestamp granularity; defaults to 'word'. */
+    granularity?: 'sentence' | 'word';
+}
+/**
+ * Result of a text-to-speech request
+ */
+interface TTSResult {
+    /** Raw audio bytes. */
+    audio: ArrayBuffer;
+    /** Audio format / content type (e.g., 'audio/mpeg' or 'mp3'). */
+    format: string;
+    /** Number of characters billed for this request. */
+    usageCharacters: number;
+    /** Length of the generated audio in milliseconds (if reported). */
+    audioLengthMs?: number;
+}
+/** One timed unit (word or sentence) in an {@link Alignment}. */
+interface AlignmentItem {
+    /** The spoken text of this unit. */
+    text: string;
+    /** Start time in milliseconds. */
+    startMs: number;
+    /** End time in milliseconds. */
+    endMs: number;
+    /** Character offset of this unit's start in the input text (if reported). */
+    textStart?: number;
+    /** Character offset of this unit's end in the input text (if reported). */
+    textEnd?: number;
+}
+/** Timestamp alignment for synthesized speech. */
+interface Alignment {
+    /** 'word' | 'sentence' — the granularity of `items`. */
+    granularity: string;
+    /** Timed units in order. */
+    items: AlignmentItem[];
+}
+/** Result of `synthesizeWithTimestamps`: audio plus timestamp alignment. */
+interface TTSTimestampsResult extends TTSResult {
+    /** Word/sentence timings, or null if unavailable. */
+    alignment: Alignment | null;
+}
+
 /**
  * Device Authorization Flow Manager
  * Manages Device Auth polling flow for desktop/CLI/Unity applications
@@ -1911,6 +2019,76 @@ declare class TranscriptionClient {
     transcribeFile(file: File, options?: TranscriptionOptions): Promise<TranscriptionResult>;
 }
 
+/**
+ * TTS provider for HTTP communication with the text-to-speech API
+ */
+
+declare class TTSProvider {
+    private authManager;
+    private config;
+    private baseURL;
+    private playerClient?;
+    constructor(authManager: AuthManager, config: SDKConfig);
+    /**
+     * Set player client for balance checking
+     */
+    setPlayerClient(playerClient: PlayerClient): void;
+    /** Build the shared request body from a TTS config (new fields + legacy). */
+    private buildRequestBody;
+    /** POST to a TTS endpoint; throws a PlayKitError on a non-ok response. */
+    private post;
+    private checkBalanceAfter;
+    /**
+     * Synthesize text into speech audio (raw bytes).
+     */
+    synthesize(ttsConfig: TTSConfig): Promise<TTSResult>;
+    /**
+     * Synthesize text into speech AND return timestamp alignment. Hits the
+     * `speech-with-timestamps` variant, whose success response is a JSON envelope
+     * (base64 audio + alignment), so it is parsed as JSON — not raw bytes.
+     */
+    synthesizeWithTimestamps(ttsConfig: TTSTimestampsConfig): Promise<TTSTimestampsResult>;
+}
+
+/**
+ * High-level client for text-to-speech synthesis
+ */
+
+declare class TTSClient {
+    private provider;
+    private model;
+    constructor(provider: TTSProvider, model?: string);
+    /**
+     * Get the current model name
+     */
+    get modelName(): string;
+    /**
+     * Synthesize text into speech audio
+     * @param config - Full TTS configuration
+     * @returns TTS result containing raw audio bytes and usage metadata
+     */
+    synthesize(config: TTSConfig): Promise<TTSResult>;
+    /**
+     * Synthesize text into speech AND return timestamp alignment (word/sentence
+     * timings). Returns the audio bytes plus an `alignment` object.
+     * @param config - TTS configuration; `granularity` defaults to 'word'.
+     */
+    synthesizeWithTimestamps(config: TTSTimestampsConfig): Promise<TTSTimestampsResult>;
+    /**
+     * Synthesize text into speech and return it as a Blob (browser-friendly)
+     * @param config - Full TTS configuration
+     * @returns Audio Blob with the appropriate MIME type
+     */
+    synthesizeToBlob(config: TTSConfig): Promise<Blob>;
+    /**
+     * Synthesize text into speech and return an object URL (browser only)
+     * @param config - Full TTS configuration
+     * @returns An object URL that can be assigned to an <audio> element
+     * @throws PlayKitError if URL.createObjectURL is unavailable (e.g. Node.js)
+     */
+    synthesizeToObjectURL(config: TTSConfig): Promise<string>;
+}
+
 /**
  * NPC Client for simplified conversation management
  * Automatically handles conversation history
@@ -2359,6 +2537,7 @@ declare class PlayKitSDK extends EventEmitter {
     private chatProvider;
     private imageProvider;
     private transcriptionProvider;
+    private ttsProvider;
     private contextManager;
     private schemaLibrary;
     private initialized;
@@ -2428,6 +2607,11 @@ declare class PlayKitSDK extends EventEmitter {
      * @param model - Transcription model to use (default: 'whisper-large')
      */
     createTranscriptionClient(model?: string): TranscriptionClient;
+    /**
+     * Create a TTS client for text-to-speech
+     * @param model - TTS model to use (default: 'default-tts-model')
+     */
+    createTTSClient(model?: string): TTSClient;
     /**
      * Create an NPC client
      * Automatically registers with AIContextManager
@@ -2957,5 +3141,5 @@ declare global {
     }
 }
 
-export { AIContextManager, AuthFlowManager, AuthManager, BrowserStorage, BufferLogHandler, CallbackLogHandler, ChatClient, DeviceAuthFlowManager, ImageClient, LogLevel, Logger, MemoryStorage, NPCClient, PlayKitError, PlayKitSDK, PlayerClient, RechargeManager, SchemaLibrary, StreamParser, TokenStorage, TokenValidator, TranscriptionClient, createMultimodalMessage, createStorage, createTextMessage, PlayKitSDK as default, defaultContextManager, defaultSchemaLibrary, defaultTokenValidator, isLocalStorageAvailable };
-export type { AIContextManagerConfig, AIContextManagerEvents, APIResult, AudioContentPart, AuthState, ChatCompletionResponse, ChatConfig, ChatResult, ChatStreamConfig, ChatWithToolsConfig, ChatWithToolsStreamConfig, ConversationSaveData, DeveloperTokenFallbackConfig, DeviceAuthFlowOptions, DeviceAuthInitResult, DeviceAuthResult, GameInfo, GeneratedImage, IStorage, ImageContentPart, ImageGenerationConfig, ImageGenerationResponse, ImageInput, ImageSize, LogConfig, LogEntry, LogHandler, MemoryEntry, Message, MessageContent, MessageContentPart, MessageRole, NPCConfig, PlayerInfo, RechargeConfig, RechargeEvents, RechargeModalOptions, SDKConfig, SDKMode, SchemaEntry, SetNicknameRequest, SetNicknameResponse, StreamChunk, StructuredGenerationConfig, StructuredOutputConfig, StructuredResult, TextContentPart, TokenRefreshResult, TokenScope, TokenStorageOptions, TokenValidatorOptions, TokenVerificationResult, TranscriptionConfig, TranscriptionOptions, TranscriptionResult, TranscriptionSegment, ValidatedPlayerInfo };
+export { AIContextManager, AuthFlowManager, AuthManager, BrowserStorage, BufferLogHandler, CallbackLogHandler, ChatClient, DeviceAuthFlowManager, ImageClient, LogLevel, Logger, MemoryStorage, NPCClient, PlayKitError, PlayKitSDK, PlayerClient, RechargeManager, SchemaLibrary, StreamParser, TTSClient, TokenStorage, TokenValidator, TranscriptionClient, createMultimodalMessage, createStorage, createTextMessage, PlayKitSDK as default, defaultContextManager, defaultSchemaLibrary, defaultTokenValidator, isLocalStorageAvailable };
+export type { AIContextManagerConfig, AIContextManagerEvents, APIResult, Alignment, AlignmentItem, AudioContentPart, AuthState, ChatCompletionResponse, ChatConfig, ChatResult, ChatStreamConfig, ChatWithToolsConfig, ChatWithToolsStreamConfig, ConversationSaveData, DeveloperTokenFallbackConfig, DeviceAuthFlowOptions, DeviceAuthInitResult, DeviceAuthResult, GameInfo, GeneratedImage, IStorage, ImageContentPart, ImageGenerationConfig, ImageGenerationResponse, ImageInput, ImageSize, LogConfig, LogEntry, LogHandler, MemoryEntry, Message, MessageContent, MessageContentPart, MessageRole, NPCConfig, PlayerInfo, RechargeConfig, RechargeEvents, RechargeModalOptions, SDKConfig, SDKMode, SchemaEntry, SetNicknameRequest, SetNicknameResponse, StreamChunk, StructuredGenerationConfig, StructuredOutputConfig, StructuredResult, TTSConfig, TTSOptions, TTSResult, TTSTimestampsConfig, TTSTimestampsResult, TextContentPart, TokenRefreshResult, TokenScope, TokenStorageOptions, TokenValidatorOptions, TokenVerificationResult, TranscriptionConfig, TranscriptionOptions, TranscriptionResult, TranscriptionSegment, ValidatedPlayerInfo, VoiceMixEntry, VoiceSettings };

package/dist/playkit-sdk.esm.js

@@ -1,5 +1,5 @@
 /**
- * playkit-sdk v1.3.0
+ * playkit-sdk v1.4.0-beta.2
  * PlayKit SDK for JavaScript
  * @license SEE LICENSE IN LICENSE
  */
@@ -826,7 +826,7 @@ class TokenStorage {
 }
 
 const SDK_TYPE = 'Javascript';
-const SDK_VERSION = '"1.3.0"';
+const SDK_VERSION = '"1.4.0-beta.2"';
 function getSDKHeaders() {
     return {
         'X-SDK-Type': SDK_TYPE,
@@ -2422,7 +2422,7 @@ DeviceAuthFlowManager.activeInstance = null;
  * Handles JWT exchange and token management
  */
 // @ts-ignore - replaced at build time
-const DEFAULT_BASE_URL$5 = "https://api.playkit.ai";
+const DEFAULT_BASE_URL$6 = "https://api.playkit.ai";
 const JWT_EXCHANGE_ENDPOINT = '/api/external/exchange-jwt';
 const TOKEN_REFRESH_ENDPOINT = '/api/auth/refresh';
 class AuthManager extends EventEmitter {
@@ -2440,7 +2440,7 @@ class AuthManager extends EventEmitter {
         this.storage = new TokenStorage({
             mode: config.mode === 'server' ? 'server' : 'browser',
         });
-        this.baseURL = config.baseURL || DEFAULT_BASE_URL$5;
+        this.baseURL = config.baseURL || DEFAULT_BASE_URL$6;
         this.authState = {
             isAuthenticated: false,
         };
@@ -3529,7 +3529,7 @@ class RechargeManager extends EventEmitter {
  * Player client for managing player information and credits
  */
 // @ts-ignore - replaced at build time
-const DEFAULT_BASE_URL$4 = "https://api.playkit.ai";
+const DEFAULT_BASE_URL$5 = "https://api.playkit.ai";
 const PLAYER_INFO_ENDPOINT = '/api/external/player-info';
 const SET_NICKNAME_ENDPOINT = '/api/external/set-game-player-nickname';
 class PlayerClient extends EventEmitter {
@@ -3541,7 +3541,7 @@ class PlayerClient extends EventEmitter {
         this.balanceCheckInterval = null;
         this.logger = Logger.getLogger('PlayerClient');
         this.authManager = authManager;
-        this.baseURL = config.baseURL || DEFAULT_BASE_URL$4;
+        this.baseURL = config.baseURL || DEFAULT_BASE_URL$5;
         this.gameId = config.gameId;
         this.rechargeConfig = {
             autoShowBalanceModal: (_a = rechargeConfig.autoShowBalanceModal) !== null && _a !== void 0 ? _a : true,
@@ -3889,12 +3889,12 @@ function contentToString$1(content) {
     return textParts.map(part => part.text).join('');
 }
 // @ts-ignore - replaced at build time
-const DEFAULT_BASE_URL$3 = "https://api.playkit.ai";
+const DEFAULT_BASE_URL$4 = "https://api.playkit.ai";
 class ChatProvider {
     constructor(authManager, config) {
         this.authManager = authManager;
         this.config = config;
-        this.baseURL = config.baseURL || DEFAULT_BASE_URL$3;
+        this.baseURL = config.baseURL || DEFAULT_BASE_URL$4;
     }
     /**
      * Set player client for balance checking
@@ -4221,12 +4221,12 @@ class ChatProvider {
  * Image generation provider for HTTP communication with image API
  */
 // @ts-ignore - replaced at build time
-const DEFAULT_BASE_URL$2 = "https://api.playkit.ai";
+const DEFAULT_BASE_URL$3 = "https://api.playkit.ai";
 class ImageProvider {
     constructor(authManager, config) {
         this.authManager = authManager;
         this.config = config;
-        this.baseURL = config.baseURL || DEFAULT_BASE_URL$2;
+        this.baseURL = config.baseURL || DEFAULT_BASE_URL$3;
     }
     /**
      * Set player client for balance checking
@@ -4310,12 +4310,12 @@ class ImageProvider {
  * Transcription provider for HTTP communication with audio transcription API
  */
 // @ts-ignore - replaced at build time
-const DEFAULT_BASE_URL$1 = "https://api.playkit.ai";
+const DEFAULT_BASE_URL$2 = "https://api.playkit.ai";
 class TranscriptionProvider {
     constructor(authManager, config) {
         this.authManager = authManager;
         this.config = config;
-        this.baseURL = config.baseURL || DEFAULT_BASE_URL$1;
+        this.baseURL = config.baseURL || DEFAULT_BASE_URL$2;
     }
     /**
      * Set player client for balance checking
@@ -4409,6 +4409,171 @@ class TranscriptionProvider {
     }
 }
 
+/**
+ * TTS provider for HTTP communication with the text-to-speech API
+ */
+// @ts-ignore - replaced at build time
+const DEFAULT_BASE_URL$1 = "https://api.playkit.ai";
+/** Decode a base64 string to an ArrayBuffer (browser + Node). */
+function base64ToArrayBuffer(b64) {
+    if (typeof atob === 'function') {
+        const bin = atob(b64);
+        const bytes = new Uint8Array(bin.length);
+        for (let i = 0; i < bin.length; i++)
+            bytes[i] = bin.charCodeAt(i);
+        return bytes.buffer;
+    }
+    // Node fallback
+    const buf = globalThis.Buffer.from(b64, 'base64');
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+}
+class TTSProvider {
+    constructor(authManager, config) {
+        this.authManager = authManager;
+        this.config = config;
+        this.baseURL = config.baseURL || DEFAULT_BASE_URL$1;
+    }
+    /**
+     * Set player client for balance checking
+     */
+    setPlayerClient(playerClient) {
+        this.playerClient = playerClient;
+    }
+    /** Build the shared request body from a TTS config (new fields + legacy). */
+    buildRequestBody(ttsConfig) {
+        const model = ttsConfig.model || this.config.defaultTTSModel || 'default-tts-model';
+        const body = { model, text: ttsConfig.text };
+        if (ttsConfig.voice !== undefined)
+            body.voice = ttsConfig.voice;
+        if (ttsConfig.voiceMix !== undefined)
+            body.voice_mix = ttsConfig.voiceMix;
+        if (ttsConfig.voiceSettings !== undefined) {
+            body.voice_settings = ttsConfig.voiceSettings;
+        }
+        if (ttsConfig.outputFormat !== undefined) {
+            body.output_format = ttsConfig.outputFormat;
+        }
+        if (ttsConfig.language !== undefined)
+            body.language = ttsConfig.language;
+        if (ttsConfig.providerOptions !== undefined) {
+            body.provider_options = ttsConfig.providerOptions;
+        }
+        return body;
+    }
+    /** POST to a TTS endpoint; throws a PlayKitError on a non-ok response. */
+    async post(endpoint, body) {
+        await this.authManager.ensureValidToken();
+        const token = this.authManager.getToken();
+        if (!token) {
+            throw new PlayKitError('Not authenticated', 'NOT_AUTHENTICATED');
+        }
+        const response = await fetch(`${this.baseURL}${endpoint}`, {
+            method: 'POST',
+            headers: Object.assign({ Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' }, getSDKHeaders()),
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const error = await response
+                .json()
+                .catch(() => ({ message: 'Speech synthesis failed' }));
+            const playKitError = new PlayKitError(error.message || 'Speech synthesis failed', error.code, response.status);
+            if (error.code === 'INSUFFICIENT_CREDITS' ||
+                error.code === 'PLAYER_INSUFFICIENT_CREDIT' ||
+                response.status === 402) {
+                if (this.playerClient) {
+                    await this.playerClient.handleInsufficientCredits(playKitError);
+                }
+            }
+            throw playKitError;
+        }
+        return response;
+    }
+    checkBalanceAfter() {
+        if (this.playerClient) {
+            this.playerClient.checkBalanceAfterApiCall().catch(() => {
+                /* silently fail */
+            });
+        }
+    }
+    /**
+     * Synthesize text into speech audio (raw bytes).
+     */
+    async synthesize(ttsConfig) {
+        const endpoint = `/ai/${this.config.gameId}/v2/audio/speech`;
+        try {
+            const response = await this.post(endpoint, this.buildRequestBody(ttsConfig));
+            // SUCCESS: response is raw audio bytes, NOT JSON.
+            const audio = await response.arrayBuffer();
+            const contentType = response.headers.get('Content-Type');
+            const usageHeader = response.headers.get('X-Usage-Characters');
+            const audioLengthHeader = response.headers.get('X-Audio-Length-Ms');
+            const result = {
+                audio,
+                format: contentType || 'mp3',
+                usageCharacters: Number(usageHeader) || 0,
+            };
+            if (audioLengthHeader !== null) {
+                result.audioLengthMs = Number(audioLengthHeader) || 0;
+            }
+            this.checkBalanceAfter();
+            return result;
+        }
+        catch (error) {
+            if (error instanceof PlayKitError)
+                throw error;
+            throw new PlayKitError(error instanceof Error ? error.message : 'Unknown error', 'TTS_ERROR');
+        }
+    }
+    /**
+     * Synthesize text into speech AND return timestamp alignment. Hits the
+     * `speech-with-timestamps` variant, whose success response is a JSON envelope
+     * (base64 audio + alignment), so it is parsed as JSON — not raw bytes.
+     */
+    async synthesizeWithTimestamps(ttsConfig) {
+        const endpoint = `/ai/${this.config.gameId}/v2/audio/speech-with-timestamps`;
+        const body = this.buildRequestBody(ttsConfig);
+        if (ttsConfig.granularity !== undefined) {
+            body.subtitle_type = ttsConfig.granularity;
+        }
+        try {
+            const response = await this.post(endpoint, body);
+            const json = (await response.json());
+            let alignment = null;
+            if (json.alignment && Array.isArray(json.alignment.items)) {
+                alignment = {
+                    granularity: json.alignment.granularity || 'word',
+                    items: json.alignment.items.map((it) => {
+                        var _a, _b, _c;
+                        return ({
+                            text: (_a = it.text) !== null && _a !== void 0 ? _a : '',
+                            startMs: (_b = it.start_ms) !== null && _b !== void 0 ? _b : 0,
+                            endMs: (_c = it.end_ms) !== null && _c !== void 0 ? _c : 0,
+                            textStart: it.text_start,
+                            textEnd: it.text_end,
+                        });
+                    }),
+                };
+            }
+            const result = {
+                audio: base64ToArrayBuffer(json.audio_base64),
+                format: json.format || 'mp3',
+                usageCharacters: Number(json.usage_characters) || 0,
+                alignment,
+            };
+            if (json.audio_length_ms != null) {
+                result.audioLengthMs = Number(json.audio_length_ms) || 0;
+            }
+            this.checkBalanceAfter();
+            return result;
+        }
+        catch (error) {
+            if (error instanceof PlayKitError)
+                throw error;
+            throw new PlayKitError(error instanceof Error ? error.message : 'Unknown error', 'TTS_ERROR');
+        }
+    }
+}
+
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -5073,6 +5238,88 @@ class TranscriptionClient {
     }
 }
 
+/**
+ * High-level client for text-to-speech synthesis
+ */
+/**
+ * Resolve an audio format/content-type string into a valid MIME type.
+ * The provider's `result.format` may be a full MIME (e.g. 'audio/mpeg' from
+ * the Content-Type header) or a bare token (e.g. 'mp3' from the fallback).
+ * Full MIME strings pass through; bare tokens are mapped.
+ */
+function contentTypeFor(format) {
+    if (format.includes('/')) {
+        return format;
+    }
+    switch (format.toLowerCase()) {
+        case 'mp3':
+            return 'audio/mpeg';
+        case 'wav':
+            return 'audio/wav';
+        case 'ogg':
+            return 'audio/ogg';
+        case 'flac':
+            return 'audio/flac';
+        case 'aac':
+            return 'audio/aac';
+        case 'pcm':
+            return 'audio/pcm';
+        default:
+            return 'audio/mpeg';
+    }
+}
+class TTSClient {
+    constructor(provider, model) {
+        this.provider = provider;
+        this.model = model || 'default-tts-model';
+    }
+    /**
+     * Get the current model name
+     */
+    get modelName() {
+        return this.model;
+    }
+    /**
+     * Synthesize text into speech audio
+     * @param config - Full TTS configuration
+     * @returns TTS result containing raw audio bytes and usage metadata
+     */
+    async synthesize(config) {
+        return this.provider.synthesize(Object.assign(Object.assign({}, config), { model: config.model || this.model }));
+    }
+    /**
+     * Synthesize text into speech AND return timestamp alignment (word/sentence
+     * timings). Returns the audio bytes plus an `alignment` object.
+     * @param config - TTS configuration; `granularity` defaults to 'word'.
+     */
+    async synthesizeWithTimestamps(config) {
+        return this.provider.synthesizeWithTimestamps(Object.assign(Object.assign({}, config), { model: config.model || this.model }));
+    }
+    /**
+     * Synthesize text into speech and return it as a Blob (browser-friendly)
+     * @param config - Full TTS configuration
+     * @returns Audio Blob with the appropriate MIME type
+     */
+    async synthesizeToBlob(config) {
+        const result = await this.synthesize(config);
+        return new Blob([result.audio], { type: contentTypeFor(result.format) });
+    }
+    /**
+     * Synthesize text into speech and return an object URL (browser only)
+     * @param config - Full TTS configuration
+     * @returns An object URL that can be assigned to an <audio> element
+     * @throws PlayKitError if URL.createObjectURL is unavailable (e.g. Node.js)
+     */
+    async synthesizeToObjectURL(config) {
+        if (typeof URL === 'undefined' || typeof URL.createObjectURL !== 'function') {
+            throw new PlayKitError('URL.createObjectURL is not available in this environment. ' +
+                'Use synthesize() to access the raw audio bytes instead.', 'TTS_OBJECT_URL_UNAVAILABLE');
+        }
+        const blob = await this.synthesizeToBlob(config);
+        return URL.createObjectURL(blob);
+    }
+}
+
 /**
  * Global AI Context Manager for managing NPC conversations and player context.
  *
@@ -6396,10 +6643,12 @@ class PlayKitSDK extends EventEmitter {
         this.chatProvider = new ChatProvider(this.authManager, this.config);
         this.imageProvider = new ImageProvider(this.authManager, this.config);
         this.transcriptionProvider = new TranscriptionProvider(this.authManager, this.config);
+        this.ttsProvider = new TTSProvider(this.authManager, this.config);
         // Connect providers to player client for balance checking
         this.chatProvider.setPlayerClient(this.playerClient);
         this.imageProvider.setPlayerClient(this.playerClient);
         this.transcriptionProvider.setPlayerClient(this.playerClient);
+        this.ttsProvider.setPlayerClient(this.playerClient);
         // Initialize AI context manager
         this.contextManager = new AIContextManager(this.config.aiContext);
         // Set chat client factory for compaction
@@ -6648,6 +6897,14 @@ class PlayKitSDK extends EventEmitter {
         this.ensureInitialized();
         return new TranscriptionClient(this.transcriptionProvider, model || this.config.defaultTranscriptionModel);
     }
+    /**
+     * Create a TTS client for text-to-speech
+     * @param model - TTS model to use (default: 'default-tts-model')
+     */
+    createTTSClient(model) {
+        this.ensureInitialized();
+        return new TTSClient(this.ttsProvider, model || this.config.defaultTTSModel);
+    }
     /**
      * Create an NPC client
      * Automatically registers with AIContextManager
@@ -7038,5 +7295,5 @@ class TokenValidator {
  */
 const defaultTokenValidator = new TokenValidator();
 
-export { AIContextManager, AuthFlowManager, AuthManager, BrowserStorage, BufferLogHandler, CallbackLogHandler, ChatClient, DeviceAuthFlowManager, ImageClient, LogLevel, Logger, MemoryStorage, NPCClient, PlayKitSDK, PlayerClient, RechargeManager, SchemaLibrary, StreamParser, TokenStorage, TokenValidator, TranscriptionClient, createMultimodalMessage, createStorage, createTextMessage, PlayKitSDK as default, defaultContextManager, defaultSchemaLibrary, defaultTokenValidator, isLocalStorageAvailable };
+export { AIContextManager, AuthFlowManager, AuthManager, BrowserStorage, BufferLogHandler, CallbackLogHandler, ChatClient, DeviceAuthFlowManager, ImageClient, LogLevel, Logger, MemoryStorage, NPCClient, PlayKitSDK, PlayerClient, RechargeManager, SchemaLibrary, StreamParser, TTSClient, TokenStorage, TokenValidator, TranscriptionClient, createMultimodalMessage, createStorage, createTextMessage, PlayKitSDK as default, defaultContextManager, defaultSchemaLibrary, defaultTokenValidator, isLocalStorageAvailable };
 //# sourceMappingURL=playkit-sdk.esm.js.map