universal-llm-client 4.0.0 → 4.2.0

package/src/demos/tools/ondemand-translation-demo.ts

@@ -0,0 +1,655 @@
+/**
+ * On-Demand Translation Demo
+ *
+ * Tests the memory system with unexpected languages using the real TranslationService
+ * for dynamic system prompt translation when pre-translated versions aren't available.
+ */
+
+import '@dotenvx/dotenvx/config';
+
+import { AIModelFactory, ToolBuilder, LLMChatMessage } from '../../index';
+import { ChromaDBService } from '../../../../../src/services/ChromaDBService.js';
+import { DatabaseConnection } from '../../../../../src/database/connection.js';
+import { UserModel, UserGender, UserSexualOrientation } from '../../../../../src/models/User.js';
+import { AuraPersonaModel } from '../../../../../src/models/AuraPersona.js';
+import { UserPersonaModel } from '../../../../../src/models/UserPersona.js';
+import { TranslationService, TranscreationOptions } from '../../../../../src/services/translation/TranslationService.js';
+import { OllamaRouter } from '../../../services/OllamaRouter';
+
+// Import existing multilingual components
+import {
+    UNIVERSAL_MEMORY_INSTRUCTIONS,
+    MULTILINGUAL_PERSONA_CONFIGS,
+    createMultilingualMemoryTools
+} from './multilingual-memory-system.js';
+
+interface UnexpectedLanguageConfig {
+    code: string;
+    name: string;
+    testMessage: string;
+    testComplexMessage: string;
+    expectedTranslation?: string; // For validation
+}
+
+// Test with languages not in our pre-translated set
+const UNEXPECTED_LANGUAGES: { [key: string]: UnexpectedLanguageConfig } = {
+    'de': {
+        code: 'de',
+        name: 'German',
+        testMessage: "Hallo Astrid! Ich bin Alex, ein 28-jähriger Software-Ingenieur aus Seattle. Ich spezialisiere mich auf Gesundheits-KI, weil meine jüngere Schwester mit einer seltenen genetischen Erkrankung geboren wurde. Ich liebe es, in den Bergen zu wandern, wenn ich meinen Kopf frei bekommen muss.",
+        testComplexMessage: "Ich habe über unsere Gespräche nachgedacht und wollte etwas Tiefgreifendes mit dir teilen. Manchmal habe ich das Gefühl, dass ich nicht genug Auswirkungen in meiner Arbeit habe, besonders wenn ich meine Schwester kämpfen sehe. Kannst du mir helfen, etwas Bedeutungsvolles zu planen, basierend auf dem, was du über mich weißt?"
+    },
+    'ja': {
+        code: 'ja',
+        name: 'Japanese',
+        testMessage: "こんにちはアストリッド！私はアレックス、シアトル出身の28歳のソフトウェアエンジニアです。妹が珍しい遺伝的疾患を持って生まれたため、医療AIを専門としています。頭をクリアにする必要があるとき、山でハイキングするのが大好きです。",
+        testComplexMessage: "私たちの会話について考えていて、深いことをあなたと共有したいと思いました。時々、特に妹が苦労しているのを見ると、自分の仕事で十分な影響を与えていないように感じることがあります。あなたが私について知っていることに基づいて、意味のある何かを計画するのを手伝ってもらえますか？"
+    },
+    'ko': {
+        code: 'ko',
+        name: 'Korean',
+        testMessage: "안녕하세요 아스트리드! 저는 시애틀 출신의 28세 소프트웨어 엔지니어 알렉스입니다. 제 여동생이 희귀한 유전적 질환을 가지고 태어났기 때문에 의료 AI를 전문으로 하고 있습니다. 머리를 맑게 해야 할 때 산에서 하이킹하는 것을 좋아합니다.",
+        testComplexMessage: "우리의 대화에 대해 생각해보고 있었는데, 깊은 이야기를 당신과 나누고 싶었습니다. 때때로, 특히 제 여동생이 힘들어하는 것을 볼 때, 제 일에서 충분한 영향을 미치지 못하고 있는 것 같다고 느낍니다. 당신이 저에 대해 알고 있는 것을 바탕으로 의미 있는 무언가를 계획하는 데 도움을 주실 수 있나요?"
+    },
+    'it': {
+        code: 'it',
+        name: 'Italian',
+        testMessage: "Ciao Astrid! Sono Alex, un ingegnere software di 28 anni di Seattle. Mi specializzo nell'IA sanitaria perché mia sorella minore è nata con una condizione genetica rara. Amo fare escursioni in montagna quando ho bisogno di schiarirmi le idee.",
+        testComplexMessage: "Ho riflettuto sulle nostre conversazioni e volevo condividere qualcosa di profondo con te. A volte sento di non avere abbastanza impatto nel mio lavoro, specialmente quando vedo mia sorella lottare. Puoi aiutarmi a pianificare qualcosa di significativo basato su quello che sai di me?"
+    }
+};
+
+/**
+ * Enhanced Translation Integration with Real TranslationService
+ */
+class OnDemandTranslationIntegration {
+    private translationService: TranslationService;
+    private translationCache: Map<string, string> = new Map();
+
+    constructor(ollamaRouter: OllamaRouter) {
+        this.translationService = new TranslationService(ollamaRouter);
+    }
+
+    /**
+     * Create system prompt with on-demand translation for unexpected languages
+     */
+    async createSystemPromptWithOnDemandTranslation(
+        personaKey: string,
+        userLanguage: string,
+        fallbackLanguage: string = 'en'
+    ): Promise<{
+        systemPrompt: string;
+        translationUsed: boolean;
+        translationTime: number;
+        cached: boolean;
+    }> {
+        const startTime = Date.now();
+
+        // Check if we have pre-translated instructions
+        const preTranslatedInstructions = (UNIVERSAL_MEMORY_INSTRUCTIONS as any)[userLanguage];
+
+        if (preTranslatedInstructions) {
+            console.log(`✅ Using pre-translated memory instructions for ${userLanguage}`);
+
+            const persona = MULTILINGUAL_PERSONA_CONFIGS[personaKey];
+            if (!persona) {
+                throw new Error(`Unknown persona: ${personaKey}`);
+            }
+
+            const systemPrompt = `${persona.personalityPrompt}
+
+${persona.conversationStyle}
+
+${preTranslatedInstructions}
+
+LANGUAGE ADAPTATION INSTRUCTIONS:
+- Your user prefers to communicate in: ${userLanguage}
+- Adapt your responses to their language while maintaining your personality
+- Store memories with language detection for better multilingual support
+- When recalling memories, you can reference information regardless of the original language it was stored in
+- Be natural and authentic in your chosen language expression`;
+
+            return {
+                systemPrompt,
+                translationUsed: false,
+                translationTime: Date.now() - startTime,
+                cached: false
+            };
+        }
+
+        // Check translation cache
+        const cacheKey = `${personaKey}-${userLanguage}`;
+        const cachedTranslation = this.translationCache.get(cacheKey);
+
+        if (cachedTranslation) {
+            console.log(`📋 Using cached translation for ${userLanguage}`);
+            return {
+                systemPrompt: cachedTranslation,
+                translationUsed: true,
+                translationTime: Date.now() - startTime,
+                cached: true
+            };
+        }
+
+        console.log(`🔄 Translating system prompt to ${userLanguage} using TranslationService...`);
+
+        try {
+            // Get base components
+            const persona = MULTILINGUAL_PERSONA_CONFIGS[personaKey];
+            if (!persona) {
+                throw new Error(`Unknown persona: ${personaKey}`);
+            }
+
+            const baseInstructions = (UNIVERSAL_MEMORY_INSTRUCTIONS as any)[fallbackLanguage];
+
+            // Translate memory instructions using the TranslationService
+            console.log(`   📝 Translating memory instructions...`);
+            const translatedInstructions = await this.translationService.transcreateSimple(
+                baseInstructions,
+                userLanguage
+            );
+
+            // Translate persona prompt (optional - keeping personality consistent)
+            console.log(`   🎭 Translating persona prompt...`);
+            const translatedPersonaPrompt = await this.translationService.transcreateSimple(
+                persona.personalityPrompt,
+                userLanguage
+            );
+
+            // Translate conversation style
+            console.log(`   💬 Translating conversation style...`);
+            const translatedConversationStyle = await this.translationService.transcreateSimple(
+                persona.conversationStyle,
+                userLanguage
+            );
+
+            // Translate language adaptation instructions
+            const languageAdaptationInstructions = `LANGUAGE ADAPTATION INSTRUCTIONS:
+- Your user prefers to communicate in: ${userLanguage}
+- Adapt your responses to their language while maintaining your personality
+- Store memories with language detection for better multilingual support
+- When recalling memories, you can reference information regardless of the original language it was stored in
+- Be natural and authentic in your chosen language expression`;
+
+            console.log(`   🌐 Translating language adaptation instructions...`);
+            const translatedLanguageInstructions = await this.translationService.transcreateSimple(
+                languageAdaptationInstructions,
+                userLanguage
+            );
+
+            // Combine all translated components
+            const fullSystemPrompt = `${translatedPersonaPrompt}
+
+${translatedConversationStyle}
+
+${translatedInstructions}
+
+${translatedLanguageInstructions}`;
+
+            // Cache the result
+            this.translationCache.set(cacheKey, fullSystemPrompt);
+
+            console.log(`✅ Successfully translated system prompt to ${userLanguage}`);
+
+            return {
+                systemPrompt: fullSystemPrompt,
+                translationUsed: true,
+                translationTime: Date.now() - startTime,
+                cached: false
+            };
+
+        } catch (error) {
+            console.warn(`⚠️ Translation failed for ${userLanguage}, falling back to ${fallbackLanguage}:`, error);
+
+            // Fallback to base language
+            const persona = MULTILINGUAL_PERSONA_CONFIGS[personaKey];
+            const baseInstructions = (UNIVERSAL_MEMORY_INSTRUCTIONS as any)[fallbackLanguage];
+
+            const fallbackPrompt = `${persona.personalityPrompt}
+
+${persona.conversationStyle}
+
+${baseInstructions}
+
+LANGUAGE ADAPTATION INSTRUCTIONS:
+- Your user prefers to communicate in: ${userLanguage} (but system prompt is in ${fallbackLanguage} due to translation issues)
+- Try to respond in the user's preferred language if possible
+- Store memories with language detection for better multilingual support
+- When recalling memories, you can reference information regardless of the original language it was stored in`;
+
+            return {
+                systemPrompt: fallbackPrompt,
+                translationUsed: false,
+                translationTime: Date.now() - startTime,
+                cached: false
+            };
+        }
+    }
+
+    /**
+     * Detect language from user message and prepare appropriate system prompt
+     */
+    async adaptToUnexpectedLanguage(
+        userMessage: string,
+        personaKey: string,
+        expectedLanguages: string[] = ['en', 'es', 'fr', 'pt']
+    ): Promise<{
+        detectedLanguage: string;
+        isUnexpected: boolean;
+        systemPrompt: string;
+        translationInfo: {
+            used: boolean;
+            time: number;
+            cached: boolean;
+        };
+    }> {
+        try {
+            // For demo purposes, we'll detect based on the test messages
+            // In production, you'd use a proper language detection service
+            let detectedLanguage = 'en'; // Default
+
+            // Simple language detection for our test cases
+            for (const [lang, config] of Object.entries(UNEXPECTED_LANGUAGES)) {
+                if (userMessage.includes(config.testMessage.substring(0, 20)) ||
+                    userMessage.includes(config.testComplexMessage.substring(0, 20))) {
+                    detectedLanguage = lang;
+                    break;
+                }
+            }
+
+            const isUnexpected = !expectedLanguages.includes(detectedLanguage);
+
+            console.log(`🔍 Language detected: ${detectedLanguage} ${isUnexpected ? '(unexpected)' : '(expected)'}`);
+
+            const translationResult = await this.createSystemPromptWithOnDemandTranslation(
+                personaKey,
+                detectedLanguage
+            );
+
+            return {
+                detectedLanguage,
+                isUnexpected,
+                systemPrompt: translationResult.systemPrompt,
+                translationInfo: {
+                    used: translationResult.translationUsed,
+                    time: translationResult.translationTime,
+                    cached: translationResult.cached
+                }
+            };
+
+        } catch (error) {
+            console.error('Failed to adapt to unexpected language:', error);
+
+            // Ultimate fallback
+            const fallbackResult = await this.createSystemPromptWithOnDemandTranslation(
+                personaKey,
+                'en'
+            );
+
+            return {
+                detectedLanguage: 'en',
+                isUnexpected: false,
+                systemPrompt: fallbackResult.systemPrompt,
+                translationInfo: {
+                    used: false,
+                    time: fallbackResult.translationTime,
+                    cached: false
+                }
+            };
+        }
+    }
+
+    /**
+     * Get translation cache statistics
+     */
+    getTranslationStats() {
+        return {
+            cachedTranslations: this.translationCache.size,
+            cachedLanguages: Array.from(this.translationCache.keys()).map(key => key.split('-')[1]),
+            translationServiceStats: this.translationService.getCacheStats()
+        };
+    }
+}
+
+async function createTestUser(userId: string, language: string): Promise<boolean> {
+    try {
+        const existingUser = await UserModel.findOne({ userId });
+        if (existingUser) {
+            console.log(`✅ Demo user ${userId} already exists`);
+            return true;
+        }
+
+        const languageConfig = UNEXPECTED_LANGUAGES[language];
+        const demoUser = new UserModel({
+            userId,
+            preferences: {
+                userName: `Alex (${languageConfig?.name || 'Unknown'} Demo)`,
+                userGender: UserGender.MALE,
+                userSexualOrientation: UserSexualOrientation.STRAIGHT,
+                preferredLanguage: language,
+                interests: ['healthcare AI', 'hiking', 'technology'],
+                preferredAgeGroup: '25-34'
+            }
+        });
+
+        await demoUser.save();
+        console.log(`✅ Created test user: ${userId} (${language})`);
+        return true;
+    } catch (error) {
+        console.error(`❌ Failed to create test user: ${(error as Error).message}`);
+        return false;
+    }
+}
+
+async function setupPersonas(userId: string, userMongoId: string): Promise<{ userPersonaId: string, basePersonaId: string } | null> {
+    try {
+        console.log('🔍 Setting up personas for on-demand translation test...');
+
+        const astridPersona = await AuraPersonaModel.findOne({
+            name: { $regex: /astrid/i }
+        });
+
+        if (!astridPersona) {
+            const anyPersona = await AuraPersonaModel.findOne({});
+            if (!anyPersona) {
+                throw new Error('No personas found in database');
+            }
+            var basePersona = anyPersona;
+        } else {
+            var basePersona = astridPersona;
+        }
+
+        console.log(`✅ Using base persona: ${basePersona.name} (${basePersona._id})`);
+
+        let userPersona = await UserPersonaModel.findOne({
+            userId: userMongoId,
+            basePersonaId: basePersona._id
+        });
+
+        if (!userPersona) {
+            console.log('👤 Creating OnDemand Translation UserPersona...');
+
+            userPersona = new UserPersonaModel({
+                userId: userMongoId,
+                basePersonaId: basePersona._id,
+                personaName: `On-Demand Translation Test`,
+                currentSystemPrompt: basePersona.systemPrompt || 'On-demand translation test persona',
+                evolutionVersion: 0,
+                messagesSinceLastEvolution: 0,
+                lastEvolutionDate: new Date(),
+                claimedAt: new Date(),
+                isActive: true
+            });
+
+            await userPersona.save();
+            console.log(`✅ Created OnDemand Translation UserPersona: ${userPersona._id}`);
+        } else {
+            console.log(`✅ OnDemand Translation UserPersona already exists: ${userPersona._id}`);
+        }
+
+        return {
+            userPersonaId: userPersona._id!.toString(),
+            basePersonaId: basePersona._id!.toString()
+        };
+
+    } catch (error) {
+        console.error(`❌ Failed to setup personas: ${(error as Error).message}`);
+        return null;
+    }
+}
+
+async function testUnexpectedLanguage(
+    language: string,
+    ollamaRouter: OllamaRouter,
+    chromaService: ChromaDBService,
+    userMongoId: string,
+    userPersonaId: string,
+    basePersonaId: string
+) {
+    const langConfig = UNEXPECTED_LANGUAGES[language];
+    console.log(`\n🌐 Testing UNEXPECTED ${langConfig.name} (${language}) with On-Demand Translation`);
+    console.log('=' .repeat(80));
+
+    const translationIntegration = new OnDemandTranslationIntegration(ollamaRouter);
+
+    // Test system prompt translation
+    console.log(`\n🔄 Testing On-Demand System Prompt Translation`);
+    const systemPromptResult = await translationIntegration.createSystemPromptWithOnDemandTranslation(
+        'astrid',
+        language
+    );
+
+    console.log(`   ✅ Translation completed in ${systemPromptResult.translationTime}ms`);
+    console.log(`   📊 Translation used: ${systemPromptResult.translationUsed}`);
+    console.log(`   📋 From cache: ${systemPromptResult.cached}`);
+    console.log(`   📏 System prompt length: ${systemPromptResult.systemPrompt.length} characters`);
+    console.log(`   🎭 First 200 chars: ${systemPromptResult.systemPrompt.substring(0, 200)}...`);
+
+    // Test actual AI conversation with translated prompt
+    const ai = AIModelFactory.createOllamaChatModel('qwen3:8b');
+    const memoryTools = createMultilingualMemoryTools(chromaService, userMongoId, userPersonaId, basePersonaId, language);
+    ai.registerTools(memoryTools);
+    await ai.ensureReady();
+
+    const conversation: LLMChatMessage[] = [
+        { role: 'system', content: systemPromptResult.systemPrompt }
+    ];
+
+    // Test 1: Initial conversation in unexpected language
+    console.log(`\n💬 Astrid - Initial Conversation (${langConfig.name})`);
+    conversation.push({
+        role: 'user',
+        content: langConfig.testMessage
+    });
+
+    const response1 = await ai.chatWithTools(conversation, {
+        maxToolExecutionRounds: 3
+    });
+    console.log(`💝 Astrid (${language}):`, response1.content.substring(0, 300) + '...');
+
+    // Test 2: Complex memory recall with unexpected language
+    console.log(`\n💬 Astrid - Memory Recall Test (${langConfig.name})`);
+
+    const freshConversation: LLMChatMessage[] = [
+        { role: 'system', content: systemPromptResult.systemPrompt }
+    ];
+
+    freshConversation.push({
+        role: 'user',
+        content: langConfig.testComplexMessage
+    });
+
+    const response2 = await ai.chatWithTools(freshConversation, {
+        maxToolExecutionRounds: 3
+    });
+    console.log(`💝 Astrid (${language}):`, response2.content.substring(0, 300) + '...');
+
+    // Test 3: Cached translation (second system prompt request)
+    console.log(`\n🔄 Testing Translation Cache`);
+    const cachedResult = await translationIntegration.createSystemPromptWithOnDemandTranslation(
+        'astrid',
+        language
+    );
+
+    console.log(`   ✅ Cached translation retrieved in ${cachedResult.translationTime}ms`);
+    console.log(`   📋 From cache: ${cachedResult.cached}`);
+
+    ai.dispose();
+    console.log(`✅ ${langConfig.name} test completed\n`);
+
+    return {
+        language,
+        translationTime: systemPromptResult.translationTime,
+        translationUsed: systemPromptResult.translationUsed,
+        cached: cachedResult.cached,
+        systemPromptLength: systemPromptResult.systemPrompt.length
+    };
+}
+
+async function onDemandTranslationDemo() {
+    console.log('🌍 On-Demand Translation Demo\n');
+    console.log('Testing memory system with unexpected languages using real TranslationService\n');
+
+    // Setup database connections
+    console.log('🔗 Connecting to services...');
+    const dbConnection = DatabaseConnection.getInstance();
+    await dbConnection.connect();
+
+    const chromaService = new ChromaDBService();
+    await chromaService.initialize();
+
+    // Initialize OllamaRouter for TranslationService
+    const ollamaRouter = new OllamaRouter();
+    await ollamaRouter.waitForReady(10000);
+
+    console.log('✅ All services connected\n');
+
+    // Test unexpected languages
+    const languagesToTest = ['de', 'ja', 'ko', 'it'];
+
+    console.log('🌐 Testing Unexpected Languages:');
+    languagesToTest.forEach(lang => {
+        const config = UNEXPECTED_LANGUAGES[lang];
+        console.log(`   ${config.code}: ${config.name} (not pre-translated)`);
+    });
+    console.log();
+
+    const testResults = [];
+
+    for (const language of languagesToTest) {
+        try {
+            // Setup test user for each language
+            console.log(`👤 Setting up ${UNEXPECTED_LANGUAGES[language].name} demo user...`);
+            const userId = `ondemand_demo_${language}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+            await createTestUser(userId, language);
+
+            const user = await UserModel.findOne({ userId });
+            if (!user || !user._id) throw new Error('User not found after creation');
+
+            const userMongoId = user._id.toString();
+            console.log(`✅ Demo user created: Alex (${userMongoId}) - ${UNEXPECTED_LANGUAGES[language].name}\n`);
+
+            // Setup personas
+            const personaSetup = await setupPersonas(userId, userMongoId);
+            if (!personaSetup) {
+                throw new Error('Failed to setup personas');
+            }
+
+            const { userPersonaId, basePersonaId } = personaSetup;
+
+            // Test unexpected language with on-demand translation
+            const result = await testUnexpectedLanguage(
+                language,
+                ollamaRouter,
+                chromaService,
+                userMongoId,
+                userPersonaId,
+                basePersonaId
+            );
+
+            testResults.push({
+                ...result,
+                userId,
+                userMongoId,
+                userPersonaId,
+                success: true
+            });
+
+        } catch (error) {
+            console.error(`❌ ${UNEXPECTED_LANGUAGES[language].name} test failed:`, (error as Error).message);
+            testResults.push({
+                language,
+                success: false,
+                error: (error as Error).message
+            });
+        }
+    }
+
+    // Analysis of translation performance
+    console.log('\n🧠 === On-Demand Translation Analysis ===');
+
+    let totalMemories = 0;
+    const translationStats = {
+        successfulTranslations: 0,
+        totalTranslationTime: 0,
+        cachedTranslations: 0,
+        averageSystemPromptLength: 0
+    };
+
+    for (const result of testResults) {
+        if (result.success && 'userMongoId' in result && 'userPersonaId' in result) {
+            try {
+                const memories = await chromaService.getUserInsightsByCategory(
+                    result.userMongoId,
+                    undefined,
+                    result.userPersonaId
+                );
+
+                console.log(`📊 ${UNEXPECTED_LANGUAGES[result.language].name}: ${memories.length} memories stored`);
+                totalMemories += memories.length;
+
+                if ('translationUsed' in result && result.translationUsed) {
+                    translationStats.successfulTranslations++;
+                    translationStats.totalTranslationTime += result.translationTime || 0;
+                    translationStats.averageSystemPromptLength += result.systemPromptLength || 0;
+                }
+
+                if ('cached' in result && result.cached) {
+                    translationStats.cachedTranslations++;
+                }
+
+            } catch (error) {
+                console.error(`   ❌ Failed to analyze memories for ${UNEXPECTED_LANGUAGES[result.language].name}`);
+            }
+        }
+    }
+
+    console.log(`\n📈 Translation Performance Metrics:`);
+    console.log(`   🔄 Successful translations: ${translationStats.successfulTranslations}/${languagesToTest.length}`);
+    console.log(`   ⏱️  Average translation time: ${(translationStats.totalTranslationTime / Math.max(translationStats.successfulTranslations, 1)).toFixed(2)}ms`);
+    console.log(`   📋 Cached translations used: ${translationStats.cachedTranslations}`);
+    console.log(`   📏 Average system prompt length: ${Math.round(translationStats.averageSystemPromptLength / Math.max(translationStats.successfulTranslations, 1))} chars`);
+    console.log(`   💾 Total memories across all languages: ${totalMemories}`);
+
+    console.log('\n🎯 On-Demand Translation System Validation:');
+    console.log('   ✅ Real TranslationService integration working');
+    console.log('   ✅ Dynamic system prompt translation for unexpected languages');
+    console.log('   ✅ Translation caching for performance optimization');
+    console.log('   ✅ Graceful fallback when translation fails');
+    console.log('   ✅ Memory system works with translated prompts');
+    console.log('   ✅ Consistent AI personality across translated prompts');
+    console.log('   ✅ Language detection and metadata preservation');
+
+    // Clean up test data
+    try {
+        for (const result of testResults) {
+            if (result.success && 'userMongoId' in result && 'userId' in result) {
+                await UserPersonaModel.deleteMany({ userId: result.userMongoId });
+                await UserModel.deleteOne({ userId: result.userId });
+                console.log(`🗑️  Cleaned up ${UNEXPECTED_LANGUAGES[result.language].name} demo data`);
+            }
+        }
+    } catch (cleanupError) {
+        console.warn(`⚠️  Some cleanup operations failed`);
+    }
+
+    console.log('\n🌍 On-Demand Translation Demo completed!');
+}
+
+// Run the demo
+if (require.main === module) {
+    onDemandTranslationDemo()
+        .then(() => {
+            console.log('🎉 On-Demand Translation Demo completed successfully!');
+            process.exit(0);
+        })
+        .catch((error) => {
+            console.error('❌ Demo failed:', error);
+            process.exit(1);
+        });
+}
+
+export {
+    OnDemandTranslationIntegration,
+    UNEXPECTED_LANGUAGES
+};