playkit-sdk 1.0.0-beta.2

package/dist/index.cjs.js

@@ -0,0 +1,2800 @@
+/**
+ * playkit-sdk v1.0.0-beta.2
+ * PlayKit SDK for JavaScript
+ * @license SEE LICENSE IN LICENSE
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var EventEmitter = require('eventemitter3');
+
+/**
+ * Common types used across the SDK
+ */
+/**
+ * Error types that can be thrown by the SDK
+ */
+class PlayKitError extends Error {
+    constructor(message, code, statusCode) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.name = 'PlayKitError';
+    }
+}
+
+/**
+ * Token storage with encryption using Web Crypto API
+ * Stores tokens in localStorage with AES-128-GCM encryption
+ */
+const STORAGE_KEY_PREFIX = 'playkit_';
+const SHARED_TOKEN_KEY = 'playkit_shared_token';
+const ENCRYPTION_KEY_NAME = 'playkit_encryption_key';
+class TokenStorage {
+    constructor() {
+        this.encryptionKey = null;
+    }
+    /**
+     * Initialize the encryption key
+     */
+    async initialize() {
+        if (typeof window === 'undefined' || !window.crypto || !window.crypto.subtle) {
+            console.warn('Web Crypto API not available, encryption disabled');
+            return;
+        }
+        // Try to load existing key or generate new one
+        const storedKey = localStorage.getItem(ENCRYPTION_KEY_NAME);
+        if (storedKey) {
+            try {
+                const keyData = this.base64ToArrayBuffer(storedKey);
+                this.encryptionKey = await crypto.subtle.importKey('raw', keyData, { name: 'AES-GCM' }, true, ['encrypt', 'decrypt']);
+            }
+            catch (error) {
+                console.warn('Failed to import encryption key, generating new one', error);
+                await this.generateNewKey();
+            }
+        }
+        else {
+            await this.generateNewKey();
+        }
+    }
+    /**
+     * Generate a new encryption key
+     */
+    async generateNewKey() {
+        if (!crypto.subtle)
+            return;
+        this.encryptionKey = await crypto.subtle.generateKey({ name: 'AES-GCM', length: 128 }, true, ['encrypt', 'decrypt']);
+        // Store the key
+        const exported = await crypto.subtle.exportKey('raw', this.encryptionKey);
+        localStorage.setItem(ENCRYPTION_KEY_NAME, this.arrayBufferToBase64(exported));
+    }
+    /**
+     * Encrypt data
+     */
+    async encrypt(data) {
+        if (!this.encryptionKey || !crypto.subtle) {
+            // Fallback to plain storage if encryption unavailable
+            return data;
+        }
+        const iv = crypto.getRandomValues(new Uint8Array(12));
+        const encoded = new TextEncoder().encode(data);
+        const encrypted = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, this.encryptionKey, encoded);
+        // Combine IV and encrypted data
+        const combined = new Uint8Array(iv.length + encrypted.byteLength);
+        combined.set(iv, 0);
+        combined.set(new Uint8Array(encrypted), iv.length);
+        return this.arrayBufferToBase64(combined);
+    }
+    /**
+     * Decrypt data
+     */
+    async decrypt(encryptedData) {
+        if (!this.encryptionKey || !crypto.subtle) {
+            // Data not encrypted
+            return encryptedData;
+        }
+        try {
+            const combined = this.base64ToArrayBuffer(encryptedData);
+            const iv = combined.slice(0, 12);
+            const encrypted = combined.slice(12);
+            const decrypted = await crypto.subtle.decrypt({ name: 'AES-GCM', iv }, this.encryptionKey, encrypted);
+            return new TextDecoder().decode(decrypted);
+        }
+        catch (error) {
+            console.error('Decryption failed', error);
+            return encryptedData; // Return original if decryption fails
+        }
+    }
+    /**
+     * Save auth state
+     */
+    async saveAuthState(gameId, authState) {
+        const key = `${STORAGE_KEY_PREFIX}${gameId}_auth`;
+        const data = JSON.stringify(authState);
+        const encrypted = await this.encrypt(data);
+        localStorage.setItem(key, encrypted);
+    }
+    /**
+     * Load auth state
+     */
+    async loadAuthState(gameId) {
+        const key = `${STORAGE_KEY_PREFIX}${gameId}_auth`;
+        const encrypted = localStorage.getItem(key);
+        if (!encrypted)
+            return null;
+        try {
+            const decrypted = await this.decrypt(encrypted);
+            return JSON.parse(decrypted);
+        }
+        catch (error) {
+            console.error('Failed to load auth state', error);
+            return null;
+        }
+    }
+    /**
+     * Save shared token (accessible by all DeveloperWorks games)
+     */
+    async saveSharedToken(token) {
+        const encrypted = await this.encrypt(token);
+        localStorage.setItem(SHARED_TOKEN_KEY, encrypted);
+    }
+    /**
+     * Load shared token
+     */
+    async loadSharedToken() {
+        const encrypted = localStorage.getItem(SHARED_TOKEN_KEY);
+        if (!encrypted)
+            return null;
+        try {
+            return await this.decrypt(encrypted);
+        }
+        catch (error) {
+            console.error('Failed to load shared token', error);
+            return null;
+        }
+    }
+    /**
+     * Clear auth state for a game
+     */
+    clearAuthState(gameId) {
+        const key = `${STORAGE_KEY_PREFIX}${gameId}_auth`;
+        localStorage.removeItem(key);
+    }
+    /**
+     * Clear shared token
+     */
+    clearSharedToken() {
+        localStorage.removeItem(SHARED_TOKEN_KEY);
+    }
+    /**
+     * Clear all PlayKit data
+     */
+    clearAll() {
+        Object.keys(localStorage).forEach((key) => {
+            if (key.startsWith(STORAGE_KEY_PREFIX) || key === SHARED_TOKEN_KEY) {
+                localStorage.removeItem(key);
+            }
+        });
+    }
+    /**
+     * Utility: ArrayBuffer to Base64
+     */
+    arrayBufferToBase64(buffer) {
+        const bytes = new Uint8Array(buffer);
+        let binary = '';
+        for (let i = 0; i < bytes.byteLength; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return btoa(binary);
+    }
+    /**
+     * Utility: Base64 to ArrayBuffer
+     */
+    base64ToArrayBuffer(base64) {
+        const binary = atob(base64);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
+        }
+        return bytes.buffer;
+    }
+}
+
+/**
+ * Authentication Flow Manager
+ * Manages the headless authentication flow with automatic UI
+ */
+// i18n translations
+const translations$1 = {
+    en: {
+        signIn: 'Sign In / Register',
+        signInSubtitle: 'If you don\'t have an account, we\'ll create one for you. Sign up and get free credits!',
+        email: 'Email',
+        phone: 'Phone',
+        emailPlaceholder: 'Enter your email address',
+        phonePlaceholder: 'Enter your phone number (+86 Only)',
+        sendCode: 'Send Code',
+        enterCode: 'Enter Code',
+        enterCodeSubtitle: "We've sent a 6-digit code to your",
+        verify: 'Verify',
+        pleaseEnterEmail: 'Please enter your email address',
+        pleaseEnterPhone: 'Please enter your phone number',
+        enterAllDigits: 'Please enter all 6 digits',
+        verificationFailed: 'Verification failed',
+        failedToSendCode: 'Failed to send code',
+        invalidCode: 'Invalid verification code',
+    },
+    zh: {
+        signIn: '登录/注册',
+        signInSubtitle: '如果您没有帐户，我们会为您自动注册。注册即送积分！',
+        email: '邮箱',
+        phone: '手机',
+        emailPlaceholder: '请输入邮箱地址',
+        phonePlaceholder: '请输入手机号（仅限 +86）',
+        sendCode: '发送验证码',
+        enterCode: '输入验证码',
+        enterCodeSubtitle: '我们已向您发送了 6 位验证码：',
+        verify: '验证',
+        pleaseEnterEmail: '请输入邮箱地址',
+        pleaseEnterPhone: '请输入手机号',
+        enterAllDigits: '请输入完整的 6 位验证码',
+        verificationFailed: '验证失败',
+        failedToSendCode: '发送验证码失败',
+        invalidCode: '验证码无效',
+    },
+    'zh-TW': {
+        signIn: '登入/註冊',
+        signInSubtitle: '如果您沒有帳戶，我們會為您自動註冊。註冊即送積分！',
+        email: '電子郵件',
+        phone: '手機',
+        emailPlaceholder: '請輸入電子郵件地址',
+        phonePlaceholder: '請輸入手機號碼（僅限 +86）',
+        sendCode: '發送驗證碼',
+        enterCode: '輸入驗證碼',
+        enterCodeSubtitle: '我們已向您發送了 6 位驗證碼：',
+        verify: '驗證',
+        pleaseEnterEmail: '請輸入電子郵件地址',
+        pleaseEnterPhone: '請輸入手機號碼',
+        enterAllDigits: '請輸入完整的 6 位驗證碼',
+        verificationFailed: '驗證失敗',
+        failedToSendCode: '發送驗證碼失敗',
+        invalidCode: '驗證碼無效',
+    },
+    ja: {
+        signIn: 'サインイン/登録',
+        signInSubtitle: 'アカウントをお持ちでない場合は、自動的に作成します。登録すると無料クレジットがもらえます！',
+        email: 'メール',
+        phone: '電話',
+        emailPlaceholder: 'メールアドレスを入力してください',
+        phonePlaceholder: '電話番号を入力してください（+86のみ）',
+        sendCode: '認証コードを送信',
+        enterCode: '認証コードを入力',
+        enterCodeSubtitle: '6桁の認証コードを送信しました：',
+        verify: '検証',
+        pleaseEnterEmail: 'メールアドレスを入力してください',
+        pleaseEnterPhone: '電話番号を入力してください',
+        enterAllDigits: '6桁すべて入力してください',
+        verificationFailed: '検証に失敗しました',
+        failedToSendCode: '認証コードの送信に失敗しました',
+        invalidCode: '認証コードが無効です',
+    },
+    ko: {
+        signIn: '로그인/가입',
+        signInSubtitle: '계정이 없으시면 자동으로 생성해 드립니다. 가입하면 무료 크레딧을 받으세요！',
+        email: '이메일',
+        phone: '전화',
+        emailPlaceholder: '이메일 주소를 입력하세요',
+        phonePlaceholder: '전화번호를 입력하세요（+86만 지원）',
+        sendCode: '인증 코드 전송',
+        enterCode: '인증 코드 입력',
+        enterCodeSubtitle: '6자리 인증 코드를 보냈습니다：',
+        verify: '확인',
+        pleaseEnterEmail: '이메일 주소를 입력하세요',
+        pleaseEnterPhone: '전화번호를 입력하세요',
+        enterAllDigits: '6자리를 모두 입력하세요',
+        verificationFailed: '인증 실패',
+        failedToSendCode: '인증 코드 전송 실패',
+        invalidCode: '인증 코드가 잘못되었습니다',
+    },
+};
+class AuthFlowManager extends EventEmitter {
+    constructor(baseURL = 'https://playkit.agentlandlab.com') {
+        super();
+        this.currentSessionId = null;
+        this.uiContainer = null;
+        this.isSuccess = false;
+        this.currentLanguage = 'en';
+        // UI Elements
+        this.modal = null;
+        this.identifierPanel = null;
+        this.verificationPanel = null;
+        this.loadingOverlay = null;
+        this.baseURL = baseURL;
+        this.currentLanguage = this.detectLanguage();
+    }
+    /**
+     * Detect browser language (safe for Node.js environment)
+     */
+    detectLanguage() {
+        // Check if running in browser environment
+        if (typeof window === 'undefined' || typeof navigator === 'undefined') {
+            return 'en'; // Default to English in Node.js environment
+        }
+        try {
+            const browserLang = navigator.language.toLowerCase();
+            // Match language codes
+            if (browserLang.startsWith('zh-tw') || browserLang.startsWith('zh-hk')) {
+                return 'zh-TW'; // Traditional Chinese
+            }
+            else if (browserLang.startsWith('zh')) {
+                return 'zh'; // Simplified Chinese
+            }
+            else if (browserLang.startsWith('ja')) {
+                return 'ja'; // Japanese
+            }
+            else if (browserLang.startsWith('ko')) {
+                return 'ko'; // Korean
+            }
+            else {
+                return 'en'; // Default to English
+            }
+        }
+        catch (error) {
+            // Fallback to English if detection fails
+            return 'en';
+        }
+    }
+    /**
+     * Get translated text
+     */
+    t(key) {
+        return translations$1[this.currentLanguage][key];
+    }
+    /**
+     * Start the authentication flow
+     * Returns a promise that resolves with the JWT token
+     */
+    async startFlow() {
+        return new Promise((resolve, reject) => {
+            // Create and show UI
+            this.createUI();
+            this.showModal();
+            // Listen for success/failure
+            this.once('success', (token) => {
+                this.hideModal();
+                resolve(token);
+            });
+            this.once('error', (error) => {
+                this.hideModal();
+                reject(error);
+            });
+            // Set default auth type based on region
+            this.setDefaultAuthTypeByRegion().catch((err) => {
+                console.error('[PlayKit Auth] Failed to detect region:', err);
+            });
+        });
+    }
+    /**
+     * Create the authentication UI
+     */
+    createUI() {
+        // Create modal container
+        this.modal = document.createElement('div');
+        this.modal.className = 'playkit-auth-modal';
+        this.modal.innerHTML = `
+      <div class="playkit-auth-overlay"></div>
+      <div class="playkit-auth-container">
+        <!-- Identifier Panel -->
+        <div class="playkit-auth-panel" id="playkit-identifier-panel">
+          <div class="playkit-auth-header">
+            <h2>${this.t('signIn')}</h2>
+            <p>${this.t('signInSubtitle')}</p>
+          </div>
+
+          <div class="playkit-auth-toggle">
+            <label class="playkit-toggle-option">
+              <input type="radio" name="auth-type" value="email" checked>
+              <span>${this.t('email')}</span>
+            </label>
+            <label class="playkit-toggle-option">
+              <input type="radio" name="auth-type" value="phone">
+              <span>${this.t('phone')}</span>
+            </label>
+          </div>
+
+          <div class="playkit-auth-input-group">
+            <div class="playkit-input-wrapper">
+              <svg class="playkit-input-icon" id="playkit-identifier-icon" width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                <path d="M4 4h16c1.1 0 2 .9 2 2v12c0 1.1-.9 2-2 2H4c-1.1 0-2-.9-2-2V6c0-1.1.9-2 2-2z"></path>
+                <polyline points="22,6 12,13 2,6"></polyline>
+              </svg>
+              <input
+                type="text"
+                id="playkit-identifier-input"
+                placeholder="${this.t('emailPlaceholder')}"
+                autocomplete="off"
+              >
+            </div>
+          </div>
+
+          <button class="playkit-auth-button" id="playkit-send-code-btn">
+            ${this.t('sendCode')}
+          </button>
+
+          <div class="playkit-auth-error" id="playkit-error-text"></div>
+        </div>
+
+        <!-- Verification Panel -->
+        <div class="playkit-auth-panel" id="playkit-verification-panel" style="display: none;">
+          <div class="playkit-auth-header">
+            <button class="playkit-back-button" id="playkit-back-btn">
+              <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                <path d="M19 12H5M12 19l-7-7 7-7"/>
+              </svg>
+            </button>
+            <h2>${this.t('enterCode')}</h2>
+            <p>${this.t('enterCodeSubtitle')} <span id="playkit-identifier-display"></span></p>
+          </div>
+
+          <div class="playkit-auth-input-group">
+            <div class="playkit-code-inputs">
+              <input type="text" maxlength="1" class="playkit-code-input" data-index="0">
+              <input type="text" maxlength="1" class="playkit-code-input" data-index="1">
+              <input type="text" maxlength="1" class="playkit-code-input" data-index="2">
+              <input type="text" maxlength="1" class="playkit-code-input" data-index="3">
+              <input type="text" maxlength="1" class="playkit-code-input" data-index="4">
+              <input type="text" maxlength="1" class="playkit-code-input" data-index="5">
+            </div>
+          </div>
+
+          <button class="playkit-auth-button" id="playkit-verify-btn">
+            ${this.t('verify')}
+          </button>
+
+          <div class="playkit-auth-error" id="playkit-verify-error-text"></div>
+        </div>
+
+        <!-- Loading Overlay -->
+        <div class="playkit-loading-overlay" id="playkit-loading-overlay" style="display: none;">
+          <div class="playkit-spinner"></div>
+        </div>
+      </div>
+    `;
+        // Add styles
+        this.addStyles();
+        // Append to body
+        document.body.appendChild(this.modal);
+        // Get references
+        this.identifierPanel = document.getElementById('playkit-identifier-panel');
+        this.verificationPanel = document.getElementById('playkit-verification-panel');
+        this.loadingOverlay = document.getElementById('playkit-loading-overlay');
+        // Setup event listeners
+        this.setupEventListeners();
+    }
+    /**
+     * Add CSS styles to the page
+     */
+    addStyles() {
+        const styleId = 'playkit-auth-styles';
+        if (document.getElementById(styleId))
+            return;
+        const style = document.createElement('style');
+        style.id = styleId;
+        style.textContent = `
+      .playkit-auth-modal {
+        position: fixed;
+        top: 0;
+        left: 0;
+        right: 0;
+        bottom: 0;
+        z-index: 999999;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+      }
+
+      .playkit-auth-overlay {
+        position: absolute;
+        top: 0;
+        left: 0;
+        right: 0;
+        bottom: 0;
+        background: rgba(0, 0, 0, 0.48);
+        backdrop-filter: blur(8px);
+      }
+
+      .playkit-auth-container {
+        position: relative;
+        background: #FFFFFF;
+        border-radius: 4px;
+        box-shadow: 0 8px 24px rgba(0, 0, 0, 0.12);
+        width: 90%;
+        max-width: 420px;
+        overflow: hidden;
+      }
+
+      .playkit-auth-panel {
+        padding: 40px 32px;
+      }
+
+      .playkit-auth-header {
+        text-align: center;
+        margin-bottom: 32px;
+        position: relative;
+      }
+
+      .playkit-auth-header h2 {
+        margin: 0 0 8px 0;
+        font-size: 28px;
+        font-weight: 600;
+        color: #000000;
+      }
+
+      .playkit-auth-header p {
+        margin: 0;
+        font-size: 14px;
+        color: #666666;
+        line-height: 1.5;
+      }
+
+      .playkit-back-button {
+        position: absolute;
+        left: 0;
+        top: 0;
+        background: transparent;
+        border: none;
+        cursor: pointer;
+        padding: 4px;
+        border-radius: 2px;
+        color: #666666;
+        transition: background-color 0.15s ease, color 0.15s ease;
+      }
+
+      .playkit-back-button:hover {
+        background: #F6F6F6;
+        color: #000000;
+      }
+
+      .playkit-auth-toggle {
+        display: flex;
+        background: #F6F6F6;
+        border-radius: 2px;
+        padding: 2px;
+        margin-bottom: 24px;
+        gap: 2px;
+      }
+
+      .playkit-toggle-option {
+        flex: 1;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        padding: 10px 16px;
+        border-radius: 2px;
+        cursor: pointer;
+        transition: background-color 0.15s ease;
+      }
+
+      .playkit-toggle-option input {
+        display: none;
+      }
+
+      .playkit-toggle-option span {
+        font-size: 14px;
+        font-weight: 500;
+        color: #666666;
+        transition: color 0.15s ease;
+      }
+
+      .playkit-toggle-option input:checked + span {
+        color: #FFFFFF;
+      }
+
+      .playkit-toggle-option:has(input:checked) {
+        background: #276EF1;
+      }
+
+      .playkit-auth-input-group {
+        margin-bottom: 24px;
+      }
+
+      .playkit-input-wrapper {
+        position: relative;
+        display: flex;
+        align-items: center;
+      }
+
+      .playkit-input-icon {
+        position: absolute;
+        left: 12px;
+        color: #999999;
+        pointer-events: none;
+      }
+
+      .playkit-input-wrapper input {
+        width: 100%;
+        padding: 12px 12px 12px 44px;
+        border: 1px solid #CCCCCC;
+        border-radius: 2px;
+        font-size: 14px;
+        transition: border-color 0.15s ease, box-shadow 0.15s ease;
+        box-sizing: border-box;
+        background: #FFFFFF;
+      }
+
+      .playkit-input-wrapper input:hover {
+        border-color: #999999;
+      }
+
+      .playkit-input-wrapper input:focus {
+        outline: none;
+        border-color: #276EF1;
+        box-shadow: 0 0 0 3px rgba(39, 110, 241, 0.1);
+      }
+
+      .playkit-code-inputs {
+        display: flex;
+        gap: 8px;
+        justify-content: center;
+      }
+
+      .playkit-code-input {
+        width: 48px !important;
+        height: 56px;
+        text-align: center;
+        font-size: 24px;
+        font-weight: 600;
+        border: 1px solid #CCCCCC !important;
+        border-radius: 2px;
+        padding: 0 !important;
+        transition: border-color 0.15s ease, box-shadow 0.15s ease;
+        background: #FFFFFF;
+      }
+
+      .playkit-code-input:hover {
+        border-color: #999999 !important;
+      }
+
+      .playkit-code-input:focus {
+        outline: none;
+        border-color: #276EF1 !important;
+        box-shadow: 0 0 0 3px rgba(39, 110, 241, 0.1);
+      }
+
+      .playkit-auth-button {
+        width: 100%;
+        padding: 12px 16px;
+        background: #276EF1;
+        color: #FFFFFF;
+        border: none;
+        border-radius: 2px;
+        font-size: 14px;
+        font-weight: 500;
+        cursor: pointer;
+        transition: background-color 0.15s ease;
+      }
+
+      .playkit-auth-button:hover:not(:disabled) {
+        background: #174EB6;
+      }
+
+      .playkit-auth-button:active:not(:disabled) {
+        background: #0F3A8A;
+      }
+
+      .playkit-auth-button:disabled {
+        background: #CCCCCC;
+        cursor: not-allowed;
+      }
+
+      .playkit-auth-error {
+        margin-top: 16px;
+        padding: 12px 16px;
+        background: #FEF0F0;
+        border: 1px solid #FDD;
+        border-radius: 2px;
+        color: #CC3333;
+        font-size: 13px;
+        text-align: left;
+        display: none;
+      }
+
+      .playkit-auth-error.show {
+        display: block;
+      }
+
+      .playkit-loading-overlay {
+        position: absolute;
+        top: 0;
+        left: 0;
+        right: 0;
+        bottom: 0;
+        background: rgba(255, 255, 255, 0.96);
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        border-radius: 4px;
+      }
+
+      .playkit-spinner {
+        width: 40px;
+        height: 40px;
+        border: 3px solid #F0F0F0;
+        border-top: 3px solid #276EF1;
+        border-radius: 50%;
+        animation: playkit-spin 0.8s linear infinite;
+      }
+
+      @keyframes playkit-spin {
+        0% { transform: rotate(0deg); }
+        100% { transform: rotate(360deg); }
+      }
+
+      @media (max-width: 480px) {
+        .playkit-auth-container {
+          width: 95%;
+          max-width: none;
+          border-radius: 2px;
+        }
+
+        .playkit-auth-panel {
+          padding: 32px 24px;
+        }
+
+        .playkit-code-input {
+          width: 40px !important;
+          height: 48px;
+          font-size: 20px;
+        }
+
+        .playkit-code-inputs {
+          gap: 6px;
+        }
+      }
+    `;
+        document.head.appendChild(style);
+    }
+    /**
+     * Setup event listeners
+     */
+    setupEventListeners() {
+        var _a, _b, _c;
+        // Auth type toggle
+        const emailRadio = (_a = this.modal) === null || _a === void 0 ? void 0 : _a.querySelector('input[value="email"]');
+        const phoneRadio = (_b = this.modal) === null || _b === void 0 ? void 0 : _b.querySelector('input[value="phone"]');
+        const identifierInput = document.getElementById('playkit-identifier-input');
+        const identifierIcon = document.getElementById('playkit-identifier-icon');
+        const updateIcon = () => {
+            const isEmail = emailRadio === null || emailRadio === void 0 ? void 0 : emailRadio.checked;
+            identifierInput.placeholder = isEmail
+                ? this.t('emailPlaceholder')
+                : this.t('phonePlaceholder');
+            // Update icon
+            if (isEmail) {
+                identifierIcon.innerHTML = `
+          <path d="M4 4h16c1.1 0 2 .9 2 2v12c0 1.1-.9 2-2 2H4c-1.1 0-2-.9-2-2V6c0-1.1.9-2 2-2z"></path>
+          <polyline points="22,6 12,13 2,6"></polyline>
+        `;
+            }
+            else {
+                identifierIcon.innerHTML = `
+          <path d="M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z"></path>
+        `;
+            }
+        };
+        emailRadio === null || emailRadio === void 0 ? void 0 : emailRadio.addEventListener('change', updateIcon);
+        phoneRadio === null || phoneRadio === void 0 ? void 0 : phoneRadio.addEventListener('change', updateIcon);
+        // Send code button
+        const sendCodeBtn = document.getElementById('playkit-send-code-btn');
+        sendCodeBtn === null || sendCodeBtn === void 0 ? void 0 : sendCodeBtn.addEventListener('click', () => this.onSendCodeClicked());
+        // Enter key in identifier input
+        identifierInput === null || identifierInput === void 0 ? void 0 : identifierInput.addEventListener('keypress', (e) => {
+            if (e.key === 'Enter') {
+                this.onSendCodeClicked();
+            }
+        });
+        // Code inputs
+        const codeInputs = (_c = this.modal) === null || _c === void 0 ? void 0 : _c.querySelectorAll('.playkit-code-input');
+        codeInputs === null || codeInputs === void 0 ? void 0 : codeInputs.forEach((input, index) => {
+            input.addEventListener('input', (e) => {
+                const target = e.target;
+                if (target.value.length === 1 && index < codeInputs.length - 1) {
+                    codeInputs[index + 1].focus();
+                }
+                // Auto-submit when all 6 digits entered
+                if (index === 5 && target.value.length === 1) {
+                    this.onVerifyClicked();
+                }
+            });
+            input.addEventListener('keydown', (e) => {
+                if (e.key === 'Backspace' && !input.value && index > 0) {
+                    codeInputs[index - 1].focus();
+                }
+            });
+            // Paste support
+            input.addEventListener('paste', (e) => {
+                var _a;
+                e.preventDefault();
+                const pastedData = ((_a = e.clipboardData) === null || _a === void 0 ? void 0 : _a.getData('text')) || '';
+                const digits = pastedData.replace(/\D/g, '').slice(0, 6);
+                digits.split('').forEach((digit, i) => {
+                    if (codeInputs[i]) {
+                        codeInputs[i].value = digit;
+                    }
+                });
+                if (digits.length === 6) {
+                    this.onVerifyClicked();
+                }
+            });
+        });
+        // Verify button
+        const verifyBtn = document.getElementById('playkit-verify-btn');
+        verifyBtn === null || verifyBtn === void 0 ? void 0 : verifyBtn.addEventListener('click', () => this.onVerifyClicked());
+        // Back button
+        const backBtn = document.getElementById('playkit-back-btn');
+        backBtn === null || backBtn === void 0 ? void 0 : backBtn.addEventListener('click', () => {
+            this.showIdentifierPanel();
+        });
+    }
+    /**
+     * Handle send code button click
+     */
+    async onSendCodeClicked() {
+        var _a;
+        this.clearError();
+        const identifierInput = document.getElementById('playkit-identifier-input');
+        const identifier = identifierInput.value.trim();
+        const emailRadio = (_a = this.modal) === null || _a === void 0 ? void 0 : _a.querySelector('input[value="email"]');
+        const type = emailRadio.checked ? 'email' : 'phone';
+        if (!identifier) {
+            this.showError(type === 'email' ? this.t('pleaseEnterEmail') : this.t('pleaseEnterPhone'));
+            return;
+        }
+        const sendCodeBtn = document.getElementById('playkit-send-code-btn');
+        sendCodeBtn.disabled = true;
+        this.showLoading();
+        try {
+            const success = await this.sendVerificationCode(identifier, type);
+            if (success) {
+                // Store identifier for display
+                const displaySpan = document.getElementById('playkit-identifier-display');
+                if (displaySpan) {
+                    displaySpan.textContent = type === 'email' ? identifier : identifier;
+                }
+                // Switch to verification panel
+                this.showVerificationPanel();
+            }
+        }
+        catch (error) {
+            this.showError(error instanceof Error ? error.message : this.t('failedToSendCode'));
+        }
+        finally {
+            this.hideLoading();
+            sendCodeBtn.disabled = false;
+        }
+    }
+    /**
+     * Handle verify button click
+     */
+    async onVerifyClicked() {
+        var _a;
+        this.clearError('verify');
+        const codeInputs = (_a = this.modal) === null || _a === void 0 ? void 0 : _a.querySelectorAll('.playkit-code-input');
+        const code = Array.from(codeInputs).map((input) => input.value).join('');
+        if (code.length !== 6) {
+            this.showError(this.t('enterAllDigits'), 'verify');
+            return;
+        }
+        this.showLoading();
+        try {
+            const globalToken = await this.verifyCode(code);
+            this.emit('success', globalToken);
+        }
+        catch (error) {
+            this.showError(error instanceof Error ? error.message : this.t('verificationFailed'), 'verify');
+            this.hideLoading();
+        }
+    }
+    /**
+     * Send verification code to backend
+     */
+    async sendVerificationCode(identifier, type) {
+        const response = await fetch(`${this.baseURL}/api/auth/send-code`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ identifier, type }),
+        });
+        if (!response.ok) {
+            throw new PlayKitError(this.t('failedToSendCode'), 'SEND_CODE_ERROR', response.status);
+        }
+        const data = await response.json();
+        if (!data.success || !data.sessionId) {
+            throw new PlayKitError(this.t('failedToSendCode'), 'INVALID_RESPONSE');
+        }
+        this.currentSessionId = data.sessionId;
+        return true;
+    }
+    /**
+     * Verify the code and get global token
+     */
+    async verifyCode(code) {
+        if (!this.currentSessionId) {
+            throw new PlayKitError('No session ID available', 'NO_SESSION');
+        }
+        const response = await fetch(`${this.baseURL}/api/auth/verify-code`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                sessionId: this.currentSessionId,
+                code,
+            }),
+        });
+        if (!response.ok) {
+            throw new PlayKitError(this.t('invalidCode'), 'INVALID_CODE', response.status);
+        }
+        const data = await response.json();
+        if (!data.success || !data.globalToken) {
+            throw new PlayKitError(this.t('verificationFailed'), 'VERIFICATION_FAILED');
+        }
+        return data.globalToken;
+    }
+    /**
+     * Set default auth type based on user region
+     */
+    async setDefaultAuthTypeByRegion() {
+        var _a;
+        try {
+            const response = await fetch(`${this.baseURL}/api/reachability`);
+            if (response.ok) {
+                const data = await response.json();
+                if (data.region === 'CN') {
+                    const phoneRadio = (_a = this.modal) === null || _a === void 0 ? void 0 : _a.querySelector('input[value="phone"]');
+                    if (phoneRadio) {
+                        phoneRadio.checked = true;
+                        phoneRadio.dispatchEvent(new Event('change'));
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error('[PlayKit Auth] Failed to detect region:', error);
+        }
+    }
+    /**
+     * Show/hide panels
+     */
+    showIdentifierPanel() {
+        var _a;
+        if (this.identifierPanel)
+            this.identifierPanel.style.display = 'block';
+        if (this.verificationPanel)
+            this.verificationPanel.style.display = 'none';
+        // Clear code inputs
+        const codeInputs = (_a = this.modal) === null || _a === void 0 ? void 0 : _a.querySelectorAll('.playkit-code-input');
+        codeInputs === null || codeInputs === void 0 ? void 0 : codeInputs.forEach((input) => (input.value = ''));
+    }
+    showVerificationPanel() {
+        var _a;
+        if (this.identifierPanel)
+            this.identifierPanel.style.display = 'none';
+        if (this.verificationPanel)
+            this.verificationPanel.style.display = 'block';
+        // Focus first code input
+        const firstInput = (_a = this.modal) === null || _a === void 0 ? void 0 : _a.querySelector('.playkit-code-input');
+        firstInput === null || firstInput === void 0 ? void 0 : firstInput.focus();
+    }
+    /**
+     * Show/hide loading
+     */
+    showLoading() {
+        if (this.loadingOverlay)
+            this.loadingOverlay.style.display = 'flex';
+    }
+    hideLoading() {
+        if (this.loadingOverlay)
+            this.loadingOverlay.style.display = 'none';
+    }
+    /**
+     * Show/hide error messages
+     */
+    showError(message, panel = 'identifier') {
+        const errorEl = panel === 'identifier'
+            ? document.getElementById('playkit-error-text')
+            : document.getElementById('playkit-verify-error-text');
+        if (errorEl) {
+            errorEl.textContent = message;
+            errorEl.classList.add('show');
+        }
+    }
+    clearError(panel = 'both') {
+        if (panel === 'identifier' || panel === 'both') {
+            const errorEl = document.getElementById('playkit-error-text');
+            if (errorEl) {
+                errorEl.textContent = '';
+                errorEl.classList.remove('show');
+            }
+        }
+        if (panel === 'verify' || panel === 'both') {
+            const errorEl = document.getElementById('playkit-verify-error-text');
+            if (errorEl) {
+                errorEl.textContent = '';
+                errorEl.classList.remove('show');
+            }
+        }
+    }
+    /**
+     * Show/hide modal
+     */
+    showModal() {
+        if (this.modal)
+            this.modal.style.display = 'flex';
+    }
+    hideModal() {
+        if (this.modal) {
+            this.modal.style.display = 'none';
+            // Remove from DOM after animation
+            setTimeout(() => {
+                var _a;
+                (_a = this.modal) === null || _a === void 0 ? void 0 : _a.remove();
+            }, 300);
+        }
+    }
+    /**
+     * Clean up
+     */
+    destroy() {
+        var _a;
+        (_a = this.modal) === null || _a === void 0 ? void 0 : _a.remove();
+        this.removeAllListeners();
+    }
+}
+
+/**
+ * Authentication manager
+ * Handles JWT exchange and token management
+ */
+const DEFAULT_BASE_URL$3 = 'https://playkit.agentlandlab.com';
+const JWT_EXCHANGE_ENDPOINT = '/api/external/exchange-jwt';
+class AuthManager extends EventEmitter {
+    constructor(config) {
+        super();
+        this.authFlowManager = null;
+        this.config = config;
+        this.storage = new TokenStorage();
+        this.baseURL = config.baseURL || DEFAULT_BASE_URL$3;
+        this.authState = {
+            isAuthenticated: false,
+        };
+    }
+    /**
+     * Initialize authentication
+     */
+    async initialize() {
+        await this.storage.initialize();
+        // Check for developer token (development mode)
+        if (this.config.developerToken) {
+            this.authState = {
+                isAuthenticated: true,
+                token: this.config.developerToken,
+                tokenType: 'developer',
+            };
+            this.emit('authenticated', this.authState);
+            return;
+        }
+        // Try to load saved auth state
+        const savedState = await this.storage.loadAuthState(this.config.gameId);
+        if (savedState && savedState.token) {
+            // Check if token is still valid
+            if (savedState.expiresAt && Date.now() < savedState.expiresAt) {
+                this.authState = savedState;
+                this.emit('authenticated', this.authState);
+                return;
+            }
+        }
+        // Try to load shared token
+        const sharedToken = await this.storage.loadSharedToken();
+        if (sharedToken) {
+            this.authState = {
+                isAuthenticated: true,
+                token: sharedToken,
+                tokenType: 'player',
+            };
+            await this.storage.saveAuthState(this.config.gameId, this.authState);
+            this.emit('authenticated', this.authState);
+            return;
+        }
+        // Check if player JWT was provided
+        if (this.config.playerJWT) {
+            await this.exchangeJWT(this.config.playerJWT);
+            return;
+        }
+        // Not authenticated - trigger auto-login UI
+        this.emit('unauthenticated');
+        // Auto-start login flow in browser environment
+        if (typeof window !== 'undefined') {
+            await this.startAuthFlow();
+            // If we reach here, authentication was successful
+            // If it failed, startAuthFlow() will have thrown an error
+        }
+        else {
+            // Node.js environment - cannot show UI, must provide token manually
+            throw new PlayKitError('No authentication token provided. Please provide developerToken, playerJWT, or call login() manually.', 'NOT_AUTHENTICATED');
+        }
+    }
+    /**
+     * Start the authentication flow UI
+     */
+    async startAuthFlow() {
+        var _a;
+        if (this.authFlowManager) {
+            // Already in progress
+            return;
+        }
+        try {
+            this.authFlowManager = new AuthFlowManager(this.baseURL);
+            // Get global token from auth flow
+            const globalToken = await this.authFlowManager.startFlow();
+            // Exchange for player token
+            await this.exchangeJWT(globalToken);
+            // Clean up
+            this.authFlowManager.destroy();
+            this.authFlowManager = null;
+        }
+        catch (error) {
+            // User canceled or error occurred
+            (_a = this.authFlowManager) === null || _a === void 0 ? void 0 : _a.destroy();
+            this.authFlowManager = null;
+            // Re-emit error
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    /**
+     * Exchange JWT for player token
+     */
+    async exchangeJWT(jwt) {
+        try {
+            const response = await fetch(`${this.baseURL}${JWT_EXCHANGE_ENDPOINT}`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${jwt}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ gameId: this.config.gameId }),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({ message: 'JWT exchange failed' }));
+                throw new PlayKitError(error.message || 'JWT exchange failed', error.code, response.status);
+            }
+            const data = await response.json();
+            const playerToken = data.playerToken || data.token;
+            if (!playerToken) {
+                throw new PlayKitError('No player token received from server');
+            }
+            // Calculate expiration (assume 24 hours if not provided)
+            const expiresIn = data.expiresIn || 86400;
+            const expiresAt = Date.now() + expiresIn * 1000;
+            this.authState = {
+                isAuthenticated: true,
+                token: playerToken,
+                tokenType: 'player',
+                expiresAt,
+            };
+            // Save to storage
+            await this.storage.saveAuthState(this.config.gameId, this.authState);
+            await this.storage.saveSharedToken(playerToken);
+            this.emit('authenticated', this.authState);
+            return playerToken;
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    /**
+     * Get current authentication token
+     */
+    getToken() {
+        return this.authState.token;
+    }
+    /**
+     * Get current authentication state
+     */
+    getAuthState() {
+        return Object.assign({}, this.authState);
+    }
+    /**
+     * Check if authenticated
+     */
+    isAuthenticated() {
+        return this.authState.isAuthenticated;
+    }
+    /**
+     * Check if token is expired
+     */
+    isTokenExpired() {
+        if (!this.authState.expiresAt)
+            return false;
+        return Date.now() >= this.authState.expiresAt;
+    }
+    /**
+     * Logout and clear authentication
+     */
+    async logout() {
+        this.authState = {
+            isAuthenticated: false,
+        };
+        this.storage.clearAuthState(this.config.gameId);
+        this.emit('unauthenticated');
+    }
+    /**
+     * Clear all stored data
+     */
+    clearAll() {
+        this.storage.clearAll();
+    }
+}
+
+/**
+ * Translations for the recharge modal
+ */
+const translations = {
+    en: {
+        title: 'Insufficient Balance',
+        message: 'Your current balance is not enough to complete this action.',
+        currentBalance: 'Current Balance',
+        credits: 'Credits',
+        rechargeButton: 'Recharge Now',
+        cancelButton: 'Cancel',
+    },
+    zh: {
+        title: '余额不足',
+        message: '您的当前余额不足以完成此操作。',
+        currentBalance: '当前余额',
+        credits: '积分',
+        rechargeButton: '立即充值',
+        cancelButton: '取消',
+    },
+    'zh-TW': {
+        title: '餘額不足',
+        message: '您的當前餘額不足以完成此操作。',
+        currentBalance: '當前餘額',
+        credits: '積分',
+        rechargeButton: '立即充值',
+        cancelButton: '取消',
+    },
+    ja: {
+        title: '残高不足',
+        message: '現在の残高ではこの操作を完了できません。',
+        currentBalance: '現在の残高',
+        credits: 'クレジット',
+        rechargeButton: '今すぐチャージ',
+        cancelButton: 'キャンセル',
+    },
+    ko: {
+        title: '잔액 부족',
+        message: '현재 잔액으로는 이 작업을 완료할 수 없습니다.',
+        currentBalance: '현재 잔액',
+        credits: '크레딧',
+        rechargeButton: '지금 충전',
+        cancelButton: '취소',
+    },
+};
+/**
+ * RechargeManager handles the recharge modal UI and recharge window opening
+ */
+class RechargeManager extends EventEmitter {
+    constructor(playerToken, rechargePortalUrl = 'https://playkit.agentlandlab.com/playerPortal/recharge') {
+        super();
+        this.modalContainer = null;
+        this.styleElement = null;
+        this.playerToken = playerToken;
+        this.rechargePortalUrl = rechargePortalUrl;
+        this.language = this.detectLanguage();
+    }
+    /**
+     * Detect user's preferred language
+     */
+    detectLanguage() {
+        const browserLang = navigator.language.toLowerCase();
+        if (browserLang.startsWith('zh-tw') || browserLang.startsWith('zh-hk')) {
+            return 'zh-TW';
+        }
+        else if (browserLang.startsWith('zh')) {
+            return 'zh';
+        }
+        else if (browserLang.startsWith('ja')) {
+            return 'ja';
+        }
+        else if (browserLang.startsWith('ko')) {
+            return 'ko';
+        }
+        return 'en';
+    }
+    /**
+     * Get translation text for current language
+     */
+    t(key) {
+        return translations[this.language][key];
+    }
+    /**
+     * Build recharge URL with player token
+     */
+    buildRechargeUrl() {
+        return `${this.rechargePortalUrl}?playerToken=${encodeURIComponent(this.playerToken)}`;
+    }
+    /**
+     * Open recharge window in a new tab
+     */
+    openRechargeWindow() {
+        const url = this.buildRechargeUrl();
+        window.open(url, '_blank');
+        this.emit('recharge_opened');
+    }
+    /**
+     * Show insufficient balance modal
+     */
+    showInsufficientBalanceModal(options = {}) {
+        return new Promise((resolve) => {
+            var _a, _b;
+            // If modal is already shown, don't show another
+            if (this.modalContainer) {
+                resolve();
+                return;
+            }
+            this.injectStyles();
+            this.createModal(options);
+            this.emit('recharge_modal_shown');
+            // Resolve when modal is dismissed
+            const cleanup = () => {
+                this.destroy();
+                this.emit('recharge_modal_dismissed');
+                resolve();
+            };
+            // Add event listeners for dismiss
+            const cancelButton = (_a = this.modalContainer) === null || _a === void 0 ? void 0 : _a.querySelector('.playkit-recharge-cancel');
+            if (cancelButton) {
+                cancelButton.addEventListener('click', cleanup);
+            }
+            const overlay = (_b = this.modalContainer) === null || _b === void 0 ? void 0 : _b.querySelector('.playkit-recharge-overlay');
+            if (overlay) {
+                overlay.addEventListener('click', (e) => {
+                    if (e.target === overlay) {
+                        cleanup();
+                    }
+                });
+            }
+        });
+    }
+    /**
+     * Inject CSS styles for the modal
+     */
+    injectStyles() {
+        if (this.styleElement) {
+            return;
+        }
+        this.styleElement = document.createElement('style');
+        this.styleElement.textContent = `
+      .playkit-recharge-overlay {
+        position: fixed;
+        top: 0;
+        left: 0;
+        right: 0;
+        bottom: 0;
+        background-color: rgba(0, 0, 0, 0.5);
+        backdrop-filter: blur(4px);
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        z-index: 999999;
+        animation: playkit-recharge-fadeIn 0.2s ease-out;
+      }
+
+      @keyframes playkit-recharge-fadeIn {
+        from {
+          opacity: 0;
+        }
+        to {
+          opacity: 1;
+        }
+      }
+
+      .playkit-recharge-modal {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        border-radius: 16px;
+        box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
+        padding: 32px;
+        max-width: 400px;
+        width: 90%;
+        position: relative;
+        animation: playkit-recharge-slideUp 0.3s ease-out;
+      }
+
+      @keyframes playkit-recharge-slideUp {
+        from {
+          transform: translateY(20px);
+          opacity: 0;
+        }
+        to {
+          transform: translateY(0);
+          opacity: 1;
+        }
+      }
+
+      .playkit-recharge-title {
+        font-size: 24px;
+        font-weight: bold;
+        color: #ffffff;
+        margin: 0 0 16px 0;
+        text-align: center;
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+      }
+
+      .playkit-recharge-message {
+        font-size: 16px;
+        color: rgba(255, 255, 255, 0.9);
+        margin: 0 0 24px 0;
+        text-align: center;
+        line-height: 1.5;
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+      }
+
+      .playkit-recharge-balance {
+        background: rgba(255, 255, 255, 0.15);
+        border-radius: 12px;
+        padding: 16px;
+        margin: 0 0 24px 0;
+        text-align: center;
+        backdrop-filter: blur(10px);
+      }
+
+      .playkit-recharge-balance-label {
+        font-size: 14px;
+        color: rgba(255, 255, 255, 0.8);
+        margin: 0 0 8px 0;
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+      }
+
+      .playkit-recharge-balance-value {
+        font-size: 32px;
+        font-weight: bold;
+        color: #ffffff;
+        margin: 0;
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+      }
+
+      .playkit-recharge-balance-unit {
+        font-size: 16px;
+        color: rgba(255, 255, 255, 0.8);
+        margin-left: 8px;
+      }
+
+      .playkit-recharge-buttons {
+        display: flex;
+        gap: 12px;
+        justify-content: center;
+      }
+
+      .playkit-recharge-button {
+        flex: 1;
+        padding: 12px 24px;
+        border: none;
+        border-radius: 8px;
+        font-size: 16px;
+        font-weight: 600;
+        cursor: pointer;
+        transition: all 0.2s ease;
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+      }
+
+      .playkit-recharge-button-primary {
+        background: #ffffff;
+        color: #667eea;
+      }
+
+      .playkit-recharge-button-primary:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 8px 16px rgba(255, 255, 255, 0.2);
+      }
+
+      .playkit-recharge-button-primary:active {
+        transform: translateY(0);
+      }
+
+      .playkit-recharge-button-secondary {
+        background: rgba(255, 255, 255, 0.15);
+        color: #ffffff;
+        border: 1px solid rgba(255, 255, 255, 0.3);
+      }
+
+      .playkit-recharge-button-secondary:hover {
+        background: rgba(255, 255, 255, 0.25);
+      }
+
+      .playkit-recharge-button-secondary:active {
+        background: rgba(255, 255, 255, 0.15);
+      }
+
+      @media (max-width: 480px) {
+        .playkit-recharge-modal {
+          padding: 24px;
+        }
+
+        .playkit-recharge-title {
+          font-size: 20px;
+        }
+
+        .playkit-recharge-message {
+          font-size: 14px;
+        }
+
+        .playkit-recharge-balance-value {
+          font-size: 28px;
+        }
+
+        .playkit-recharge-buttons {
+          flex-direction: column;
+        }
+      }
+    `;
+        document.head.appendChild(this.styleElement);
+    }
+    /**
+     * Create the modal DOM structure
+     */
+    createModal(options) {
+        this.modalContainer = document.createElement('div');
+        this.modalContainer.className = 'playkit-recharge-overlay';
+        const modal = document.createElement('div');
+        modal.className = 'playkit-recharge-modal';
+        // Title
+        const title = document.createElement('h2');
+        title.className = 'playkit-recharge-title';
+        title.textContent = this.t('title');
+        modal.appendChild(title);
+        // Message
+        const message = document.createElement('p');
+        message.className = 'playkit-recharge-message';
+        message.textContent = options.message || this.t('message');
+        modal.appendChild(message);
+        // Balance display (if provided)
+        if (options.currentBalance !== undefined) {
+            const balanceContainer = document.createElement('div');
+            balanceContainer.className = 'playkit-recharge-balance';
+            const balanceLabel = document.createElement('div');
+            balanceLabel.className = 'playkit-recharge-balance-label';
+            balanceLabel.textContent = this.t('currentBalance');
+            balanceContainer.appendChild(balanceLabel);
+            const balanceValue = document.createElement('div');
+            balanceValue.className = 'playkit-recharge-balance-value';
+            balanceValue.innerHTML = `${options.currentBalance}<span class="playkit-recharge-balance-unit">${this.t('credits')}</span>`;
+            balanceContainer.appendChild(balanceValue);
+            modal.appendChild(balanceContainer);
+        }
+        // Buttons
+        const buttonsContainer = document.createElement('div');
+        buttonsContainer.className = 'playkit-recharge-buttons';
+        const rechargeButton = document.createElement('button');
+        rechargeButton.className = 'playkit-recharge-button playkit-recharge-button-primary';
+        rechargeButton.textContent = this.t('rechargeButton');
+        rechargeButton.addEventListener('click', () => {
+            this.openRechargeWindow();
+            this.destroy();
+            this.emit('recharge_modal_dismissed');
+        });
+        buttonsContainer.appendChild(rechargeButton);
+        const cancelButton = document.createElement('button');
+        cancelButton.className = 'playkit-recharge-button playkit-recharge-button-secondary playkit-recharge-cancel';
+        cancelButton.textContent = this.t('cancelButton');
+        buttonsContainer.appendChild(cancelButton);
+        modal.appendChild(buttonsContainer);
+        this.modalContainer.appendChild(modal);
+        document.body.appendChild(this.modalContainer);
+    }
+    /**
+     * Update player token (if it changes)
+     */
+    updateToken(newToken) {
+        this.playerToken = newToken;
+    }
+    /**
+     * Destroy the modal and clean up
+     */
+    destroy() {
+        if (this.modalContainer) {
+            this.modalContainer.remove();
+            this.modalContainer = null;
+        }
+        if (this.styleElement) {
+            this.styleElement.remove();
+            this.styleElement = null;
+        }
+    }
+}
+
+/**
+ * Player client for managing player information and credits
+ */
+const DEFAULT_BASE_URL$2 = 'https://playkit.agentlandlab.com';
+const PLAYER_INFO_ENDPOINT = '/api/external/player-info';
+class PlayerClient extends EventEmitter {
+    constructor(authManager, config, rechargeConfig = {}) {
+        var _a, _b, _c;
+        super();
+        this.playerInfo = null;
+        this.rechargeManager = null;
+        this.balanceCheckInterval = null;
+        this.authManager = authManager;
+        this.baseURL = config.baseURL || DEFAULT_BASE_URL$2;
+        this.rechargeConfig = {
+            autoShowBalanceModal: (_a = rechargeConfig.autoShowBalanceModal) !== null && _a !== void 0 ? _a : true,
+            balanceCheckInterval: (_b = rechargeConfig.balanceCheckInterval) !== null && _b !== void 0 ? _b : 30000,
+            checkBalanceAfterApiCall: (_c = rechargeConfig.checkBalanceAfterApiCall) !== null && _c !== void 0 ? _c : true,
+            rechargePortalUrl: rechargeConfig.rechargePortalUrl || 'https://playkit.agentlandlab.com/playerPortal/recharge',
+        };
+    }
+    /**
+     * Get player information
+     */
+    async getPlayerInfo() {
+        const token = this.authManager.getToken();
+        if (!token) {
+            throw new PlayKitError('Not authenticated', 'NOT_AUTHENTICATED');
+        }
+        // If using developer token, return mock player info
+        const authState = this.authManager.getAuthState();
+        if (authState.tokenType === 'developer') {
+            return {
+                userId: 'developer',
+                credits: 999999,
+            };
+        }
+        try {
+            const response = await fetch(`${this.baseURL}${PLAYER_INFO_ENDPOINT}`, {
+                method: 'GET',
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({ message: 'Failed to get player info' }));
+                throw new PlayKitError(error.message || 'Failed to get player info', error.code, response.status);
+            }
+            const data = await response.json();
+            this.playerInfo = {
+                userId: data.userId,
+                credits: data.credits,
+            };
+            this.emit('player_info_updated', this.playerInfo);
+            return this.playerInfo;
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    /**
+     * Get cached player info (without API call)
+     */
+    getCachedPlayerInfo() {
+        return this.playerInfo;
+    }
+    /**
+     * Refresh player info
+     */
+    async refreshPlayerInfo() {
+        return this.getPlayerInfo();
+    }
+    /**
+     * Initialize recharge manager
+     */
+    initializeRechargeManager() {
+        const token = this.authManager.getToken();
+        if (token && !this.rechargeManager) {
+            this.rechargeManager = new RechargeManager(token, this.rechargeConfig.rechargePortalUrl);
+            // Forward recharge events
+            this.rechargeManager.on('recharge_opened', () => this.emit('recharge_opened'));
+            this.rechargeManager.on('recharge_modal_shown', () => this.emit('recharge_modal_shown'));
+            this.rechargeManager.on('recharge_modal_dismissed', () => this.emit('recharge_modal_dismissed'));
+        }
+    }
+    /**
+     * Show insufficient balance modal
+     */
+    async showInsufficientBalanceModal(customMessage) {
+        var _a;
+        this.initializeRechargeManager();
+        if (!this.rechargeManager) {
+            console.warn('RechargeManager not initialized. Cannot show modal.');
+            return;
+        }
+        const balance = (_a = this.playerInfo) === null || _a === void 0 ? void 0 : _a.credits;
+        await this.rechargeManager.showInsufficientBalanceModal({
+            currentBalance: balance,
+            message: customMessage,
+        });
+    }
+    /**
+     * Open recharge window in new tab
+     */
+    openRechargeWindow() {
+        this.initializeRechargeManager();
+        if (!this.rechargeManager) {
+            console.warn('RechargeManager not initialized. Cannot open recharge window.');
+            return;
+        }
+        this.rechargeManager.openRechargeWindow();
+    }
+    /**
+     * Enable automatic periodic balance checking
+     */
+    enableAutoBalanceCheck(intervalMs) {
+        var _a;
+        const interval = (_a = intervalMs !== null && intervalMs !== void 0 ? intervalMs : this.rechargeConfig.balanceCheckInterval) !== null && _a !== void 0 ? _a : 30000;
+        // Don't enable if interval is 0 or negative
+        if (interval <= 0) {
+            return;
+        }
+        // Clear existing interval if any
+        this.disableAutoBalanceCheck();
+        // Start periodic balance check
+        this.balanceCheckInterval = setInterval(async () => {
+            var _a, _b;
+            try {
+                const oldBalance = (_a = this.playerInfo) === null || _a === void 0 ? void 0 : _a.credits;
+                await this.refreshPlayerInfo();
+                const newBalance = (_b = this.playerInfo) === null || _b === void 0 ? void 0 : _b.credits;
+                // Emit balance_updated event
+                if (newBalance !== undefined) {
+                    this.emit('balance_updated', newBalance);
+                    // Check for low balance (less than 10 credits)
+                    if (newBalance < 10 && newBalance !== oldBalance) {
+                        this.emit('balance_low', newBalance);
+                    }
+                }
+            }
+            catch (error) {
+                // Silently fail periodic checks to avoid spamming errors
+                console.debug('Failed to check balance:', error);
+            }
+        }, interval);
+    }
+    /**
+     * Disable automatic balance checking
+     */
+    disableAutoBalanceCheck() {
+        if (this.balanceCheckInterval) {
+            clearInterval(this.balanceCheckInterval);
+            this.balanceCheckInterval = null;
+        }
+    }
+    /**
+     * Check balance after API call (called internally by providers)
+     */
+    async checkBalanceAfterApiCall() {
+        if (!this.rechargeConfig.checkBalanceAfterApiCall) {
+            return;
+        }
+        try {
+            await this.refreshPlayerInfo();
+        }
+        catch (error) {
+            // Silently fail to avoid disrupting the main flow
+            console.debug('Failed to check balance after API call:', error);
+        }
+    }
+    /**
+     * Handle insufficient credits error (called by providers)
+     */
+    async handleInsufficientCredits(error) {
+        this.emit('insufficient_credits', error);
+        // Auto-show modal if enabled
+        if (this.rechargeConfig.autoShowBalanceModal) {
+            await this.showInsufficientBalanceModal();
+        }
+    }
+    /**
+     * Get recharge manager instance
+     */
+    getRechargeManager() {
+        this.initializeRechargeManager();
+        return this.rechargeManager;
+    }
+    /**
+     * Clean up resources
+     */
+    destroy() {
+        this.disableAutoBalanceCheck();
+        if (this.rechargeManager) {
+            this.rechargeManager.destroy();
+            this.rechargeManager = null;
+        }
+        this.removeAllListeners();
+    }
+}
+
+/**
+ * Chat provider for HTTP communication with chat API
+ */
+const DEFAULT_BASE_URL$1 = 'https://playkit.agentlandlab.com';
+class ChatProvider {
+    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;
+    }
+    /**
+     * Make a chat completion request (non-streaming)
+     */
+    async chatCompletion(chatConfig) {
+        var _a;
+        const token = this.authManager.getToken();
+        if (!token) {
+            throw new PlayKitError('Not authenticated', 'NOT_AUTHENTICATED');
+        }
+        const model = chatConfig.model || this.config.defaultChatModel || 'gpt-4o-mini';
+        const endpoint = `/ai/${this.config.gameId}/v1/chat`;
+        const requestBody = {
+            model,
+            messages: chatConfig.messages,
+            temperature: (_a = chatConfig.temperature) !== null && _a !== void 0 ? _a : 0.7,
+            stream: false,
+            max_tokens: chatConfig.maxTokens || null,
+            seed: chatConfig.seed || null,
+            stop: chatConfig.stop || null,
+            top_p: chatConfig.topP || null,
+        };
+        try {
+            const response = await fetch(`${this.baseURL}${endpoint}`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(requestBody),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({ message: 'Chat request failed' }));
+                const playKitError = new PlayKitError(error.message || 'Chat request failed', error.code, response.status);
+                // Check for insufficient credits error
+                if (error.code === 'INSUFFICIENT_CREDITS' || response.status === 402) {
+                    if (this.playerClient) {
+                        await this.playerClient.handleInsufficientCredits(playKitError);
+                    }
+                }
+                throw playKitError;
+            }
+            const result = await response.json();
+            // Check balance after successful API call
+            if (this.playerClient) {
+                this.playerClient.checkBalanceAfterApiCall().catch(() => {
+                    // Silently fail
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            if (error instanceof PlayKitError) {
+                throw error;
+            }
+            throw new PlayKitError(error instanceof Error ? error.message : 'Unknown error', 'CHAT_ERROR');
+        }
+    }
+    /**
+     * Make a streaming chat completion request
+     */
+    async chatCompletionStream(chatConfig) {
+        var _a;
+        const token = this.authManager.getToken();
+        if (!token) {
+            throw new PlayKitError('Not authenticated', 'NOT_AUTHENTICATED');
+        }
+        const model = chatConfig.model || this.config.defaultChatModel || 'gpt-4o-mini';
+        const endpoint = `/ai/${this.config.gameId}/v1/chat`;
+        const requestBody = {
+            model,
+            messages: chatConfig.messages,
+            temperature: (_a = chatConfig.temperature) !== null && _a !== void 0 ? _a : 0.7,
+            stream: true,
+            max_tokens: chatConfig.maxTokens || null,
+            seed: chatConfig.seed || null,
+            stop: chatConfig.stop || null,
+            top_p: chatConfig.topP || null,
+        };
+        try {
+            const response = await fetch(`${this.baseURL}${endpoint}`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(requestBody),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({ message: 'Chat stream request failed' }));
+                const playKitError = new PlayKitError(error.message || 'Chat stream request failed', error.code, response.status);
+                // Check for insufficient credits error
+                if (error.code === 'INSUFFICIENT_CREDITS' || response.status === 402) {
+                    if (this.playerClient) {
+                        await this.playerClient.handleInsufficientCredits(playKitError);
+                    }
+                }
+                throw playKitError;
+            }
+            if (!response.body) {
+                throw new PlayKitError('Response body is null', 'NO_RESPONSE_BODY');
+            }
+            // Check balance after successful API call
+            if (this.playerClient) {
+                this.playerClient.checkBalanceAfterApiCall().catch(() => {
+                    // Silently fail
+                });
+            }
+            return response.body.getReader();
+        }
+        catch (error) {
+            if (error instanceof PlayKitError) {
+                throw error;
+            }
+            throw new PlayKitError(error instanceof Error ? error.message : 'Unknown error', 'CHAT_STREAM_ERROR');
+        }
+    }
+    /**
+     * Generate structured output using JSON schema
+     */
+    async generateStructured(schemaName, prompt, model, temperature) {
+        var _a;
+        const messages = [{ role: 'user', content: prompt }];
+        const chatConfig = {
+            messages,
+            model: model || this.config.defaultChatModel,
+            temperature: temperature !== null && temperature !== void 0 ? temperature : 0.7,
+        };
+        // Add schema information to the request
+        // (Implementation depends on how the API handles structured output)
+        const response = await this.chatCompletion(chatConfig);
+        // Parse the response content as JSON
+        const content = (_a = response.choices[0]) === null || _a === void 0 ? void 0 : _a.message.content;
+        if (!content) {
+            throw new PlayKitError('No content in response', 'NO_CONTENT');
+        }
+        try {
+            return JSON.parse(content);
+        }
+        catch (error) {
+            throw new PlayKitError('Failed to parse structured output', 'PARSE_ERROR');
+        }
+    }
+}
+
+/**
+ * Image generation provider for HTTP communication with image API
+ */
+const DEFAULT_BASE_URL = 'https://playkit.agentlandlab.com';
+class ImageProvider {
+    constructor(authManager, config) {
+        this.authManager = authManager;
+        this.config = config;
+        this.baseURL = config.baseURL || DEFAULT_BASE_URL;
+    }
+    /**
+     * Set player client for balance checking
+     */
+    setPlayerClient(playerClient) {
+        this.playerClient = playerClient;
+    }
+    /**
+     * Generate one or more images
+     */
+    async generateImages(imageConfig) {
+        const token = this.authManager.getToken();
+        if (!token) {
+            throw new PlayKitError('Not authenticated', 'NOT_AUTHENTICATED');
+        }
+        const model = imageConfig.model || this.config.defaultImageModel || 'dall-e-3';
+        const endpoint = `/ai/${this.config.gameId}/v1/image`;
+        const requestBody = {
+            model,
+            prompt: imageConfig.prompt,
+            n: imageConfig.n || 1,
+            size: imageConfig.size || '1024x1024',
+            seed: imageConfig.seed || null,
+        };
+        // Add optional quality and style if provided (for DALL-E models)
+        if (imageConfig.quality) {
+            requestBody.quality = imageConfig.quality;
+        }
+        if (imageConfig.style) {
+            requestBody.style = imageConfig.style;
+        }
+        try {
+            const response = await fetch(`${this.baseURL}${endpoint}`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(requestBody),
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({ message: 'Image generation failed' }));
+                const playKitError = new PlayKitError(error.message || 'Image generation failed', error.code, response.status);
+                // Check for insufficient credits error
+                if (error.code === 'INSUFFICIENT_CREDITS' || response.status === 402) {
+                    if (this.playerClient) {
+                        await this.playerClient.handleInsufficientCredits(playKitError);
+                    }
+                }
+                throw playKitError;
+            }
+            const result = await response.json();
+            // Check balance after successful API call
+            if (this.playerClient) {
+                this.playerClient.checkBalanceAfterApiCall().catch(() => {
+                    // Silently fail
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            if (error instanceof PlayKitError) {
+                throw error;
+            }
+            throw new PlayKitError(error instanceof Error ? error.message : 'Unknown error', 'IMAGE_GENERATION_ERROR');
+        }
+    }
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+function __await(v) {
+    return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+
+function __asyncGenerator(thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+}
+
+function __asyncValues(o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * Server-Sent Events (SSE) stream parser
+ * Handles parsing of streaming text responses
+ */
+class StreamParser {
+    /**
+     * Parse SSE stream using ReadableStream
+     */
+    static parseStream(reader) {
+        return __asyncGenerator(this, arguments, function* parseStream_1() {
+            const decoder = new TextDecoder();
+            let buffer = '';
+            try {
+                while (true) {
+                    const { done, value } = yield __await(reader.read());
+                    if (done) {
+                        break;
+                    }
+                    buffer += decoder.decode(value, { stream: true });
+                    // Split by newlines to process complete messages
+                    const lines = buffer.split('\n');
+                    // Keep the last incomplete line in buffer
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (!trimmed || trimmed.startsWith(':')) {
+                            // Empty line or comment, skip
+                            continue;
+                        }
+                        if (trimmed === 'data: [DONE]') {
+                            // End of stream
+                            return yield __await(void 0);
+                        }
+                        if (trimmed.startsWith('data: ')) {
+                            const data = trimmed.substring(6); // Remove 'data: ' prefix
+                            try {
+                                const parsed = JSON.parse(data);
+                                const text = this.extractTextFromChunk(parsed);
+                                if (text) {
+                                    yield yield __await(text);
+                                }
+                                if (parsed.type === 'done' || parsed.finish_reason) {
+                                    return yield __await(void 0);
+                                }
+                            }
+                            catch (error) {
+                                // If JSON parse fails, treat as plain text
+                                yield yield __await(data);
+                            }
+                        }
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+        });
+    }
+    /**
+     * Extract text from a stream chunk
+     * Supports multiple formats (UI Message Stream and OpenAI)
+     */
+    static extractTextFromChunk(chunk) {
+        var _a, _b;
+        // UI Message Stream format: { type: "text-delta", delta: "..." }
+        if (chunk.type === 'text-delta' && chunk.delta) {
+            return chunk.delta;
+        }
+        // OpenAI format: { choices: [{ delta: { content: "..." } }] }
+        if (chunk.choices && ((_b = (_a = chunk.choices[0]) === null || _a === void 0 ? void 0 : _a.delta) === null || _b === void 0 ? void 0 : _b.content)) {
+            return chunk.choices[0].delta.content;
+        }
+        // Direct delta format
+        if (chunk.delta) {
+            return typeof chunk.delta === 'string' ? chunk.delta : chunk.delta.content || null;
+        }
+        return null;
+    }
+    /**
+     * Collect all chunks from a stream
+     */
+    static async collectFullText(reader) {
+        var _a, e_1, _b, _c;
+        let fullText = '';
+        try {
+            for (var _d = true, _e = __asyncValues(this.parseStream(reader)), _f; _f = await _e.next(), _a = _f.done, !_a; _d = true) {
+                _c = _f.value;
+                _d = false;
+                const chunk = _c;
+                fullText += chunk;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return fullText;
+    }
+    /**
+     * Stream with callbacks
+     */
+    static async streamWithCallbacks(reader, onChunk, onComplete, onError) {
+        var _a, e_2, _b, _c;
+        let fullText = '';
+        try {
+            try {
+                for (var _d = true, _e = __asyncValues(this.parseStream(reader)), _f; _f = await _e.next(), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const chunk = _c;
+                    fullText += chunk;
+                    onChunk(chunk);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            if (onComplete) {
+                onComplete(fullText);
+            }
+        }
+        catch (error) {
+            if (onError && error instanceof Error) {
+                onError(error);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+}
+
+/**
+ * Chat client for AI text generation
+ */
+class ChatClient {
+    constructor(provider, model) {
+        this.provider = provider;
+        this.model = model || 'gpt-4o-mini';
+    }
+    /**
+     * Generate text (non-streaming)
+     */
+    async textGeneration(config) {
+        const chatConfig = Object.assign(Object.assign({}, config), { model: config.model || this.model });
+        const response = await this.provider.chatCompletion(chatConfig);
+        const choice = response.choices[0];
+        if (!choice) {
+            throw new Error('No choices in response');
+        }
+        return {
+            content: choice.message.content,
+            model: response.model,
+            finishReason: choice.finish_reason,
+            usage: response.usage
+                ? {
+                    promptTokens: response.usage.prompt_tokens,
+                    completionTokens: response.usage.completion_tokens,
+                    totalTokens: response.usage.total_tokens,
+                }
+                : undefined,
+            id: response.id,
+            created: response.created,
+        };
+    }
+    /**
+     * Generate text with streaming
+     */
+    async textGenerationStream(config) {
+        const chatConfig = Object.assign(Object.assign({}, config), { model: config.model || this.model });
+        const reader = await this.provider.chatCompletionStream(chatConfig);
+        await StreamParser.streamWithCallbacks(reader, config.onChunk, config.onComplete, config.onError);
+    }
+    /**
+     * Generate structured output using a JSON schema
+     */
+    async generateStructured(config) {
+        const model = config.model || this.model;
+        return await this.provider.generateStructured(config.schemaName, config.prompt, model, config.temperature);
+    }
+    /**
+     * Simple chat with single message
+     */
+    async chat(message, systemPrompt) {
+        const messages = [];
+        if (systemPrompt) {
+            messages.push({ role: 'system', content: systemPrompt });
+        }
+        messages.push({ role: 'user', content: message });
+        const result = await this.textGeneration({ messages });
+        return result.content;
+    }
+    /**
+     * Simple chat with streaming
+     */
+    async chatStream(message, onChunk, onComplete, systemPrompt) {
+        const messages = [];
+        if (systemPrompt) {
+            messages.push({ role: 'system', content: systemPrompt });
+        }
+        messages.push({ role: 'user', content: message });
+        await this.textGenerationStream({
+            messages,
+            onChunk,
+            onComplete,
+        });
+    }
+}
+
+/**
+ * Image generation client
+ */
+/**
+ * Implementation of GeneratedImage interface
+ */
+class GeneratedImageImpl {
+    constructor(base64, originalPrompt, revisedPrompt, size) {
+        this.base64 = base64;
+        this.originalPrompt = originalPrompt;
+        this.revisedPrompt = revisedPrompt;
+        this.generatedAt = Date.now();
+        this.size = size;
+    }
+    toDataURL() {
+        return `data:image/png;base64,${this.base64}`;
+    }
+    async toHTMLImage() {
+        return new Promise((resolve, reject) => {
+            const img = new Image();
+            img.onload = () => resolve(img);
+            img.onerror = (e) => reject(new Error('Failed to load image'));
+            img.src = this.toDataURL();
+        });
+    }
+}
+class ImageClient {
+    constructor(provider, model) {
+        this.provider = provider;
+        this.model = model || 'dall-e-3';
+    }
+    /**
+     * Generate a single image
+     */
+    async generateImage(config) {
+        const imageConfig = Object.assign(Object.assign({}, config), { model: config.model || this.model, n: 1 });
+        const response = await this.provider.generateImages(imageConfig);
+        const imageData = response.data[0];
+        if (!imageData || !imageData.b64_json) {
+            throw new Error('No image data in response');
+        }
+        return new GeneratedImageImpl(imageData.b64_json, config.prompt, imageData.revised_prompt, config.size);
+    }
+    /**
+     * Generate multiple images
+     */
+    async generateImages(config) {
+        const imageConfig = Object.assign(Object.assign({}, config), { model: config.model || this.model, n: config.n || 1 });
+        const response = await this.provider.generateImages(imageConfig);
+        return response.data.map((imageData) => {
+            if (!imageData.b64_json) {
+                throw new Error('No image data in response');
+            }
+            return new GeneratedImageImpl(imageData.b64_json, config.prompt, imageData.revised_prompt, config.size);
+        });
+    }
+    /**
+     * Simple image generation with just a prompt
+     */
+    async generate(prompt, size) {
+        return this.generateImage({ prompt, size });
+    }
+}
+
+/**
+ * NPC Client for simplified conversation management
+ * Automatically handles conversation history
+ */
+class NPCClient extends EventEmitter {
+    constructor(chatClient, config) {
+        var _a;
+        super();
+        this.chatClient = chatClient;
+        this.systemPrompt = (config === null || config === void 0 ? void 0 : config.systemPrompt) || 'You are a helpful assistant.';
+        this.temperature = (_a = config === null || config === void 0 ? void 0 : config.temperature) !== null && _a !== void 0 ? _a : 0.7;
+        this.maxHistoryLength = (config === null || config === void 0 ? void 0 : config.maxHistoryLength) || 50;
+        this.history = [];
+    }
+    /**
+     * Set the system prompt (NPC personality)
+     */
+    setSystemPrompt(prompt) {
+        this.systemPrompt = prompt;
+    }
+    /**
+     * Get the current system prompt
+     */
+    getSystemPrompt() {
+        return this.systemPrompt;
+    }
+    /**
+     * Talk to the NPC (non-streaming)
+     */
+    async talk(message) {
+        // Add user message to history
+        const userMessage = { role: 'user', content: message };
+        this.history.push(userMessage);
+        // Build messages array with system prompt
+        const messages = [
+            { role: 'system', content: this.systemPrompt },
+            ...this.history,
+        ];
+        // Generate response
+        const result = await this.chatClient.textGeneration({
+            messages,
+            temperature: this.temperature,
+        });
+        // Add assistant response to history
+        const assistantMessage = { role: 'assistant', content: result.content };
+        this.history.push(assistantMessage);
+        // Trim history if needed
+        this.trimHistory();
+        this.emit('response', result.content);
+        return result.content;
+    }
+    /**
+     * Talk to the NPC with streaming
+     */
+    async talkStream(message, onChunk, onComplete) {
+        // Add user message to history
+        const userMessage = { role: 'user', content: message };
+        this.history.push(userMessage);
+        // Build messages array with system prompt
+        const messages = [
+            { role: 'system', content: this.systemPrompt },
+            ...this.history,
+        ];
+        // Generate response
+        await this.chatClient.textGenerationStream({
+            messages,
+            temperature: this.temperature,
+            onChunk,
+            onComplete: (fullText) => {
+                // Add assistant response to history
+                const assistantMessage = { role: 'assistant', content: fullText };
+                this.history.push(assistantMessage);
+                // Trim history if needed
+                this.trimHistory();
+                this.emit('response', fullText);
+                if (onComplete) {
+                    onComplete(fullText);
+                }
+            },
+        });
+    }
+    /**
+     * Talk with structured output
+     */
+    async talkStructured(message, schemaName) {
+        // Add user message to history
+        const userMessage = { role: 'user', content: message };
+        this.history.push(userMessage);
+        // Generate structured response
+        const result = await this.chatClient.generateStructured({
+            schemaName,
+            prompt: message,
+            messages: [{ role: 'system', content: this.systemPrompt }, ...this.history],
+            temperature: this.temperature,
+        });
+        // Add a text representation to history
+        const assistantMessage = {
+            role: 'assistant',
+            content: JSON.stringify(result),
+        };
+        this.history.push(assistantMessage);
+        this.trimHistory();
+        return result;
+    }
+    /**
+     * Get conversation history
+     */
+    getHistory() {
+        return [...this.history];
+    }
+    /**
+     * Clear conversation history
+     */
+    clearHistory() {
+        this.history = [];
+        this.emit('history_cleared');
+    }
+    /**
+     * Save history to JSON string
+     */
+    saveHistory() {
+        return JSON.stringify({
+            systemPrompt: this.systemPrompt,
+            history: this.history,
+        });
+    }
+    /**
+     * Load history from JSON string
+     */
+    loadHistory(saveData) {
+        try {
+            const data = JSON.parse(saveData);
+            this.systemPrompt = data.systemPrompt || this.systemPrompt;
+            this.history = data.history || [];
+            this.emit('history_loaded');
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to load history', error);
+            return false;
+        }
+    }
+    /**
+     * Revert to a specific point in history
+     */
+    revertToMessage(index) {
+        if (index >= 0 && index < this.history.length) {
+            this.history = this.history.slice(0, index + 1);
+            this.emit('history_reverted', index);
+        }
+    }
+    /**
+     * Append a message to history manually
+     */
+    appendMessage(message) {
+        this.history.push(message);
+        this.trimHistory();
+    }
+    /**
+     * Trim history to max length
+     */
+    trimHistory() {
+        if (this.history.length > this.maxHistoryLength) {
+            // Keep the most recent messages
+            this.history = this.history.slice(-this.maxHistoryLength);
+        }
+    }
+    /**
+     * Get the number of messages in history
+     */
+    getHistoryLength() {
+        return this.history.length;
+    }
+}
+
+/**
+ * Main SDK class - Entry point for PlayKit SDK
+ */
+class PlayKitSDK extends EventEmitter {
+    constructor(config) {
+        super();
+        this.initialized = false;
+        this.devTokenIndicator = null;
+        this.config = Object.assign({ defaultChatModel: 'gpt-4o-mini', defaultImageModel: 'dall-e-3', debug: false }, config);
+        // Initialize managers and providers
+        this.authManager = new AuthManager(this.config);
+        this.playerClient = new PlayerClient(this.authManager, this.config, this.config.recharge);
+        this.chatProvider = new ChatProvider(this.authManager, this.config);
+        this.imageProvider = new ImageProvider(this.authManager, this.config);
+        // Connect providers to player client for balance checking
+        this.chatProvider.setPlayerClient(this.playerClient);
+        this.imageProvider.setPlayerClient(this.playerClient);
+        // Forward authentication events
+        this.authManager.on('authenticated', (authState) => {
+            this.emit('authenticated', authState);
+            if (this.config.debug) {
+                console.log('[PlayKitSDK] Authenticated', authState);
+            }
+        });
+        this.authManager.on('unauthenticated', () => {
+            this.emit('unauthenticated');
+            if (this.config.debug) {
+                console.log('[PlayKitSDK] Not authenticated');
+            }
+        });
+        this.authManager.on('error', (error) => {
+            this.emit('error', error);
+            if (this.config.debug) {
+                console.error('[PlayKitSDK] Auth error', error);
+            }
+        });
+        // Forward recharge events
+        this.playerClient.on('recharge_opened', () => this.emit('recharge_opened'));
+        this.playerClient.on('recharge_modal_shown', () => this.emit('recharge_modal_shown'));
+        this.playerClient.on('recharge_modal_dismissed', () => this.emit('recharge_modal_dismissed'));
+        this.playerClient.on('insufficient_credits', (error) => this.emit('insufficient_credits', error));
+        this.playerClient.on('balance_low', (credits) => this.emit('balance_low', credits));
+        this.playerClient.on('balance_updated', (credits) => this.emit('balance_updated', credits));
+        this.playerClient.on('player_info_updated', (info) => this.emit('player_info_updated', info));
+    }
+    /**
+     * Initialize the SDK
+     * Must be called before using any features
+     */
+    async initialize() {
+        if (this.initialized) {
+            if (this.config.debug) {
+                console.warn('[PlayKitSDK] Already initialized');
+            }
+            return;
+        }
+        try {
+            await this.authManager.initialize();
+            this.initialized = true;
+            // Show developer token indicator if using developer token
+            if (this.config.developerToken && typeof window !== 'undefined') {
+                this.showDeveloperTokenIndicator();
+            }
+            this.emit('ready');
+            if (this.config.debug) {
+                console.log('[PlayKitSDK] Initialized successfully');
+            }
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    /**
+     * Show developer token indicator in top-left corner
+     */
+    showDeveloperTokenIndicator() {
+        if (this.devTokenIndicator) {
+            return; // Already shown
+        }
+        // Create indicator element
+        this.devTokenIndicator = document.createElement('div');
+        this.devTokenIndicator.textContent = 'DeveloperToken';
+        this.devTokenIndicator.style.cssText = `
+      position: fixed;
+      top: 10px;
+      left: 10px;
+      background-color: #dc2626;
+      color: white;
+      padding: 4px 12px;
+      border-radius: 4px;
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+      font-size: 12px;
+      font-weight: 600;
+      z-index: 999999;
+      pointer-events: none;
+      box-shadow: 0 2px 8px rgba(0, 0, 0, 0.15);
+    `;
+        document.body.appendChild(this.devTokenIndicator);
+    }
+    /**
+     * Hide developer token indicator
+     */
+    hideDeveloperTokenIndicator() {
+        if (this.devTokenIndicator) {
+            this.devTokenIndicator.remove();
+            this.devTokenIndicator = null;
+        }
+    }
+    /**
+     * Check if SDK is initialized
+     */
+    isInitialized() {
+        return this.initialized;
+    }
+    /**
+     * Check if authenticated
+     */
+    isAuthenticated() {
+        return this.authManager.isAuthenticated();
+    }
+    /**
+     * Exchange JWT for player token
+     */
+    async login(jwt) {
+        return await this.authManager.exchangeJWT(jwt);
+    }
+    /**
+     * Logout
+     */
+    async logout() {
+        await this.authManager.logout();
+        this.hideDeveloperTokenIndicator();
+    }
+    /**
+     * Get player information
+     */
+    async getPlayerInfo() {
+        return await this.playerClient.getPlayerInfo();
+    }
+    /**
+     * Create a chat client
+     */
+    createChatClient(model) {
+        return new ChatClient(this.chatProvider, model || this.config.defaultChatModel);
+    }
+    /**
+     * Create an image client
+     */
+    createImageClient(model) {
+        return new ImageClient(this.imageProvider, model || this.config.defaultImageModel);
+    }
+    /**
+     * Create an NPC client
+     */
+    createNPCClient(config) {
+        const chatClient = this.createChatClient(config === null || config === void 0 ? void 0 : config.model);
+        return new NPCClient(chatClient, config);
+    }
+    /**
+     * Get authentication manager (advanced usage)
+     */
+    getAuthManager() {
+        return this.authManager;
+    }
+    /**
+     * Get player client (advanced usage)
+     */
+    getPlayerClient() {
+        return this.playerClient;
+    }
+    /**
+     * Enable or disable debug mode
+     */
+    setDebug(enabled) {
+        this.config.debug = enabled;
+    }
+    /**
+     * Show insufficient balance modal
+     */
+    async showInsufficientBalanceModal(customMessage) {
+        return await this.playerClient.showInsufficientBalanceModal(customMessage);
+    }
+    /**
+     * Open recharge window in new tab
+     */
+    openRechargeWindow() {
+        this.playerClient.openRechargeWindow();
+    }
+    /**
+     * Enable automatic periodic balance checking
+     * @param intervalMs - Check interval in milliseconds (default: 30000)
+     */
+    enableAutoBalanceCheck(intervalMs) {
+        this.playerClient.enableAutoBalanceCheck(intervalMs);
+    }
+    /**
+     * Disable automatic balance checking
+     */
+    disableAutoBalanceCheck() {
+        this.playerClient.disableAutoBalanceCheck();
+    }
+    /**
+     * Get player's current cached balance
+     */
+    getCachedBalance() {
+        var _a;
+        const playerInfo = this.playerClient.getCachedPlayerInfo();
+        return (_a = playerInfo === null || playerInfo === void 0 ? void 0 : playerInfo.credits) !== null && _a !== void 0 ? _a : null;
+    }
+    /**
+     * Refresh and get player's current balance
+     */
+    async refreshBalance() {
+        const playerInfo = await this.playerClient.refreshPlayerInfo();
+        return playerInfo.credits;
+    }
+}
+
+exports.AuthManager = AuthManager;
+exports.ChatClient = ChatClient;
+exports.ImageClient = ImageClient;
+exports.NPCClient = NPCClient;
+exports.PlayKitSDK = PlayKitSDK;
+exports.PlayerClient = PlayerClient;
+exports.RechargeManager = RechargeManager;
+exports.StreamParser = StreamParser;
+exports.TokenStorage = TokenStorage;
+exports.default = PlayKitSDK;
+//# sourceMappingURL=index.cjs.js.map