playkit-sdk 1.3.0 → 1.4.0-beta.2

package/dist/playkit-sdk.umd.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
  */
@@ -1177,7 +1177,7 @@
 	}
 
 	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,
@@ -2773,7 +2773,7 @@
 	 * 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 {
@@ -2791,7 +2791,7 @@
 	        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,
 	        };
@@ -3880,7 +3880,7 @@
 	 * 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 {
@@ -3892,7 +3892,7 @@
 	        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,
@@ -4240,12 +4240,12 @@
 	    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
@@ -4572,12 +4572,12 @@
 	 * 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
@@ -4661,12 +4661,12 @@
 	 * 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
@@ -4760,6 +4760,171 @@
 	    }
 	}
 
+	/**
+	 * 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.
 
@@ -5424,6 +5589,88 @@
 	    }
 	}
 
+	/**
+	 * 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.
 	 *
@@ -6747,10 +6994,12 @@ Output ONLY a JSON array of ${predictionNum} strings, nothing else:
 	        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
@@ -6999,6 +7248,14 @@ Output ONLY a JSON array of ${predictionNum} strings, nothing else:
 	        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
@@ -7415,6 +7672,7 @@ Output ONLY a JSON array of ${predictionNum} strings, nothing else:
 		RechargeManager: RechargeManager,
 		SchemaLibrary: SchemaLibrary,
 		StreamParser: StreamParser,
+		TTSClient: TTSClient,
 		TokenStorage: TokenStorage,
 		TokenValidator: TokenValidator,
 		TranscriptionClient: TranscriptionClient,