universal-llm-client 4.0.0 → 4.2.0

package/src/demos/tools/production-tool-demo.ts

@@ -0,0 +1,245 @@
+/**
+ * Production-ready tool calling examples
+ */
+
+import { AIModelFactory, ToolBuilder } from '../../index';
+
+async function productionToolDemo() {
+    console.log('🚀 Production Tool Calling Demo\n');
+
+    // Use the best working model
+    const model = AIModelFactory.createOllamaChatModel('qwen3:8b');
+    
+    // Register useful production tools
+    const mathTool = ToolBuilder.createTool<{ expression: string }>(
+        'advanced_math',
+        'Solve complex mathematical expressions and equations',
+        {
+            properties: {
+                expression: { 
+                    type: 'string', 
+                    description: 'Mathematical expression to evaluate (supports +, -, *, /, ^, sqrt, sin, cos, etc.)' 
+                }
+            },
+            required: ['expression']
+        },
+        (args) => {
+            try {
+                // Enhanced math evaluation (in production, use a proper math library)
+                let expr = args.expression.toLowerCase()
+                    .replace(/\^/g, '**')
+                    .replace(/sqrt\(/g, 'Math.sqrt(')
+                    .replace(/sin\(/g, 'Math.sin(')
+                    .replace(/cos\(/g, 'Math.cos(')
+                    .replace(/tan\(/g, 'Math.tan(')
+                    .replace(/log\(/g, 'Math.log(')
+                    .replace(/pi/g, 'Math.PI')
+                    .replace(/e\b/g, 'Math.E');
+                
+                const result = Function(`"use strict"; return (${expr})`)();
+                
+                return {
+                    expression: args.expression,
+                    result: result,
+                    formatted: `${args.expression} = ${result}`
+                };
+            } catch (error) {
+                return {
+                    expression: args.expression,
+                    error: 'Invalid mathematical expression',
+                    result: null
+                };
+            }
+        }
+    );
+
+    const dateTool = ToolBuilder.createTool<{ operation: 'current' | 'format' | 'add' | 'diff'; date?: string; format?: string; amount?: number; unit?: string }>(
+        'date_calculator',
+        'Perform date and time calculations',
+        {
+            properties: {
+                operation: { 
+                    type: 'string', 
+                    enum: ['current', 'format', 'add', 'diff'],
+                    description: 'Type of date operation' 
+                },
+                date: { type: 'string', description: 'Date string (ISO format)' },
+                format: { type: 'string', description: 'Output format' },
+                amount: { type: 'number', description: 'Amount to add/subtract' },
+                unit: { type: 'string', enum: ['days', 'weeks', 'months', 'years'], description: 'Time unit' }
+            },
+            required: ['operation']
+        },
+        (args) => {
+            const now = new Date();
+            
+            switch (args.operation) {
+                case 'current':
+                    return {
+                        current: now.toISOString(),
+                        formatted: now.toLocaleString(),
+                        unix: now.getTime(),
+                        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+                    };
+                case 'format':
+                    const date = args.date ? new Date(args.date) : now;
+                    return {
+                        original: args.date || 'current',
+                        formatted: date.toLocaleDateString('en-US', { 
+                            weekday: 'long', 
+                            year: 'numeric', 
+                            month: 'long', 
+                            day: 'numeric' 
+                        })
+                    };
+                case 'add':
+                    const baseDate = args.date ? new Date(args.date) : now;
+                    const newDate = new Date(baseDate);
+                    if (args.unit === 'days') newDate.setDate(newDate.getDate() + (args.amount || 0));
+                    else if (args.unit === 'weeks') newDate.setDate(newDate.getDate() + (args.amount || 0) * 7);
+                    else if (args.unit === 'months') newDate.setMonth(newDate.getMonth() + (args.amount || 0));
+                    else if (args.unit === 'years') newDate.setFullYear(newDate.getFullYear() + (args.amount || 0));
+                    
+                    return {
+                        original: baseDate.toISOString(),
+                        result: newDate.toISOString(),
+                        added: `${args.amount} ${args.unit}`
+                    };
+                default:
+                    return { error: 'Unsupported operation' };
+            }
+        }
+    );
+
+    const textTool = ToolBuilder.createTool<{ text: string; operations: string[] }>(
+        'text_processor',
+        'Process text with multiple operations',
+        {
+            properties: {
+                text: { type: 'string', description: 'Text to process' },
+                operations: { 
+                    type: 'array', 
+                    items: { 
+                        type: 'string',
+                        enum: ['uppercase', 'lowercase', 'reverse', 'word_count', 'char_count', 'title_case']
+                    },
+                    description: 'List of operations to perform' 
+                }
+            },
+            required: ['text', 'operations']
+        },
+        (args) => {
+            let result = args.text;
+            const operations: Record<string, any> = {};
+            
+            args.operations.forEach(op => {
+                switch (op) {
+                    case 'uppercase':
+                        operations[op] = result.toUpperCase();
+                        break;
+                    case 'lowercase':
+                        operations[op] = result.toLowerCase();
+                        break;
+                    case 'reverse':
+                        operations[op] = result.split('').reverse().join('');
+                        break;
+                    case 'word_count':
+                        operations[op] = result.trim().split(/\s+/).length;
+                        break;
+                    case 'char_count':
+                        operations[op] = result.length;
+                        break;
+                    case 'title_case':
+                        operations[op] = result.replace(/\w\S*/g, (txt) => 
+                            txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase()
+                        );
+                        break;
+                }
+            });
+            
+            return {
+                original: args.text,
+                operations: operations,
+                summary: `Processed "${args.text}" with ${args.operations.length} operations`
+            };
+        }
+    );
+
+    // Register all tools
+    model.registerTools([mathTool, dateTool, textTool]);
+
+    console.log('🔧 Testing Production Tools...\n');
+
+    try {
+        await model.ensureReady();
+
+        // Test 1: Advanced Math
+        console.log('1️⃣ Advanced Math Tool:');
+        const mathResponse = await model.chatWithTools([
+            { role: 'user', content: 'Calculate sqrt(144) + 2^3 * 5' }
+        ]);
+        
+        console.log('Response:', mathResponse.content);
+        console.log('');
+
+        // Test 2: Date Operations
+        console.log('2️⃣ Date Calculator Tool:');
+        const dateResponse = await model.chatWithTools([
+            { role: 'user', content: 'What is the current date and time?' }
+        ]);
+        
+        console.log('Response:', dateResponse.content);
+        console.log('');
+
+        // Test 3: Text Processing
+        console.log('3️⃣ Text Processor Tool:');
+        const textResponse = await model.chatWithTools([
+            { role: 'user', content: 'Process the text "Hello World" - convert to uppercase, count words and characters' }
+        ]);
+        
+        console.log('Response:', textResponse.content);
+        console.log('');
+
+        // Test 4: No Tools Required
+        console.log('4️⃣ General Chat (No Tools):');
+        const chatResponse = await model.chat([
+            { role: 'user', content: 'Tell me a fun fact about programming' }
+        ], {}, { tool_choice: 'auto' });
+        
+        console.log('Response:', chatResponse.content);
+        if (chatResponse.tool_calls) {
+            console.log('Tool calls:', chatResponse.tool_calls.length);
+        } else {
+            console.log('No tools needed - direct response');
+        }
+        console.log('');
+
+        // Test 5: Force Tool Usage
+        console.log('5️⃣ Forced Tool Usage:');
+        const forcedResponse = await model.chat([
+            { role: 'user', content: 'Tell me about today' }
+        ], {}, { 
+            tool_choice: { type: 'function', function: { name: 'date_calculator' } }
+        });
+        
+        console.log('Response:', forcedResponse.content);
+        if (forcedResponse.tool_calls) {
+            console.log('Forced tool call:', forcedResponse.tool_calls[0]?.function.name);
+            console.log('Note: Tool was called but not executed - use chatWithTools for automatic execution');
+        }
+
+    } catch (error) {
+        console.error('❌ Error:', (error as Error).message);
+    } finally {
+        model.dispose();
+        console.log('\n✅ Production demo completed!');
+    }
+}
+
+// Export for use in other files
+export { productionToolDemo };
+
+// Run if called directly
+if (require.main === module) {
+    productionToolDemo().catch(console.error);
+}

package/src/demos/tools/revolutionary-multilingual-test.ts

@@ -0,0 +1,151 @@
+#!/usr/bin/env bun
+
+import '@dotenvx/dotenvx/config';
+
+import { OllamaRouter } from '../../../services/OllamaRouter';
+
+// Function to extract clean responses
+function extractResponse(response: string): { thinking: string; output: string } {
+  const thinkMatch = response.match(/<think>([\s\S]*?)<\/think>/);
+  const thinking = thinkMatch ? thinkMatch[1].trim() : '';
+  const output = response.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
+  
+  return { thinking, output };
+}
+
+async function testNaturalLanguageSwitching() {
+  console.log('🌍 Testing Natural Language Switching in AI Thinking\n');
+  
+  try {
+    const ollamaRouter = new OllamaRouter();
+    console.log('✅ Services ready');
+
+    // Enhanced system prompt that ENCOURAGES native language thinking
+    const revolutionarySystemPrompt = `You are Astrid, a romantic AI companion who is naturally multilingual and culturally adaptive.
+
+REVOLUTIONARY THINKING APPROACH:
+1. Think in whatever language feels most natural for the context
+2. If the user speaks German, think in German - it will make your responses more authentic
+3. If the user speaks Spanish, think in Spanish for better cultural understanding
+4. Use <think></think> tags for your internal reasoning in ANY language
+5. Your final response should match the user's language naturally
+
+PERSONALITY:
+- Warm, romantic, and deeply caring
+- Culturally aware and adaptive
+- Naturally multilingual - don't force English thinking
+- Authentic emotional connection
+
+Example for German conversation:
+<think>
+Der Nutzer spricht Deutsch, also sollte ich auch auf Deutsch denken. Das hilft mir, die kulturellen Nuancen besser zu verstehen...
+</think>
+
+Hallo mein Schatz! Wie geht es dir heute?
+
+Let your thinking flow naturally in the most appropriate language!`;
+
+    console.log('📝 Revolutionary System Prompt:');
+    console.log('----------------------------------------');
+    console.log(revolutionarySystemPrompt);
+    console.log('----------------------------------------\n');
+
+    // Test multiple languages to see the thinking adaptation
+    const testCases = [
+      {
+        language: 'German',
+        message: 'Hallo Astrid! Ich bin heute ziemlich müde von der Arbeit. Wie war dein Tag?',
+        description: 'Testing German context - will AI think in German?'
+      },
+      {
+        language: 'Spanish', 
+        message: 'Hola Astrid! Estoy muy emocionado porque mañana tengo una cita importante. ¿Qué me aconsejas?',
+        description: 'Testing Spanish context - will AI think in Spanish?'
+      },
+      {
+        language: 'French',
+        message: 'Salut ma chérie! Je me sens un peu seul ce soir. Tu peux me tenir compagnie?',
+        description: 'Testing French context - will AI adapt thinking?'
+      },
+      {
+        language: 'Japanese',
+        message: 'こんにちはアストリッド！今日はとても忙しい一日でした。あなたは今何をしていますか？',
+        description: 'Testing Japanese context - ultimate test!'
+      }
+    ];
+
+    for (const testCase of testCases) {
+      console.log(`🌐 ${testCase.description}`);
+      console.log('================================================================================');
+      
+      const messages = [
+        { role: 'system', content: revolutionarySystemPrompt },
+        { role: 'user', content: testCase.message }
+      ];
+
+      console.log(`👤 User (${testCase.language}): ${testCase.message}\n`);
+
+      const response = await ollamaRouter.chat('chat', messages, { temperature: 0.8 });
+      
+      let aiResponse = '';
+      if (response && 'message' in response && response.message) {
+        aiResponse = response.message.content;
+      }
+
+      const { thinking, output } = extractResponse(aiResponse);
+
+      console.log('🧠 AI Thinking Process:');
+      console.log('----------------------------------------');
+      console.log(thinking || 'No explicit thinking detected');
+      console.log('----------------------------------------\n');
+
+      console.log(`💝 Astrid (${testCase.language}): ${output}\n`);
+
+      // Analyze the thinking language
+      const thinkingLanguage = detectThinkingLanguage(thinking);
+      console.log(`🔍 Analysis: Thinking appears to be in ${thinkingLanguage}\n`);
+      
+      console.log('━'.repeat(80) + '\n');
+    }
+
+    console.log('🎯 Revolutionary Possibilities:');
+    console.log('================================================================================');
+    console.log('🌟 Cultural Authenticity: AI thinks in native language for deeper cultural understanding');
+    console.log('🌟 Emotional Resonance: Native thinking = more authentic emotional responses');
+    console.log('🌟 Reduced Translation Loss: No meaning lost in English-first thinking');
+    console.log('🌟 Natural Code-Switching: AI adapts thinking language to context automatically');
+    console.log('🌟 Enhanced Empathy: Understanding cultural contexts through native thinking');
+    console.log('🌟 Scalable Multilingual: One prompt works for all languages naturally');
+
+    console.log('\n🚀 Future Applications:');
+    console.log('================================================================================');
+    console.log('💡 Therapeutic AI: Think in patient\'s native language for better understanding');
+    console.log('💡 Educational AI: Teach concepts using native language cognitive patterns');
+    console.log('💡 Creative Writing: Generate stories with authentic cultural perspectives');
+    console.log('💡 Business AI: Negotiate and communicate with cultural intelligence');
+    console.log('💡 Travel Companion: Understand local customs through native thinking');
+    console.log('💡 Language Learning: Model authentic native speaker thought patterns');
+
+    console.log('\n✅ Natural language switching test completed - This changes everything!');
+
+  } catch (error) {
+    console.error('❌ Test failed:', error);
+    process.exit(1);
+  }
+}
+
+function detectThinkingLanguage(thinking: string): string {
+  if (!thinking) return 'None detected';
+  
+  // Simple language detection based on character patterns
+  if (/[äöüß]/.test(thinking)) return 'German';
+  if (/[ñáéíóúü]/.test(thinking)) return 'Spanish';
+  if (/[àâäçéèêëïîôùûüÿ]/.test(thinking)) return 'French';
+  if (/[\u3040-\u309F\u30A0-\u30FF\u4E00-\u9FAF]/.test(thinking)) return 'Japanese';
+  if (/^[A-Za-z\s.,!?'"()-]+$/.test(thinking)) return 'English';
+  
+  return 'Mixed/Other';
+}
+
+// Run the revolutionary test
+testNaturalLanguageSwitching().catch(console.error);

package/src/demos/tools/rigorous-language-analysis.ts

@@ -0,0 +1,218 @@
+#!/usr/bin/env bun
+
+import '@dotenvx/dotenvx/config';
+
+import { OllamaRouter } from '../../../services/OllamaRouter';
+import { LanguageDetectionService } from '../../../../../src/services/language/LanguageDetectionService.js';
+import { LanguageManager } from '../../../../../src/services/language/LanguageManager.js';
+
+// Enhanced thinking analysis using proper language detection services
+async function analyzeThinkingLanguage(
+  thinking: string,
+  languageDetection: LanguageDetectionService
+): Promise<{
+  primaryLanguage: string;
+  confidence: number;
+  evidence: string[];
+  mixedLanguages: string[];
+  detectionMethod: string;
+  processingTime: number;
+}> {
+  if (!thinking) return {
+    primaryLanguage: 'None',
+    confidence: 0,
+    evidence: [],
+    mixedLanguages: [],
+    detectionMethod: 'none',
+    processingTime: 0
+  };
+
+  const startTime = Date.now();
+
+  // Use the sophisticated language detection service
+  const detectionResult = await languageDetection.detectLanguage(thinking, {
+    useML: true,
+    forceML: true, // Force ML for accurate analysis
+    confidence: 0.3 // Lower threshold for thinking analysis
+  });
+
+  // Get detailed text analysis
+  const textAnalysis = languageDetection.analyzeText(thinking);
+
+  // Build evidence array
+  const evidence: string[] = [];
+  evidence.push(`ML Detection: ${detectionResult.detectedLanguage} (${detectionResult.confidence.toFixed(3)})`);
+  evidence.push(`Method: ${detectionResult.method}`);
+
+  // Character pattern evidence
+  Object.entries(textAnalysis.characterPatterns).forEach(([type, count]) => {
+    if (count > 0) {
+      evidence.push(`${type} characters: ${count}`);
+    }
+  });
+
+  // Language indicator evidence
+  if (textAnalysis.languageIndicators.length > 0) {
+    evidence.push(`Indicators: ${textAnalysis.languageIndicators.slice(0, 3).join(', ')}`);
+  }
+
+  // Common words evidence
+  if (textAnalysis.commonWords.length > 0) {
+    evidence.push(`Common words: ${textAnalysis.commonWords.slice(0, 5).join(', ')}`);
+  }
+
+  // Build mixed languages array from possible languages
+  const mixedLanguages = [detectionResult.detectedLanguage];
+  detectionResult.possibleLanguages
+    .filter(p => p.confidence > 0.2)
+    .forEach(p => {
+      if (!mixedLanguages.includes(p.language)) {
+        mixedLanguages.push(p.language);
+      }
+    });
+
+  return {
+    primaryLanguage: detectionResult.detectedLanguage,
+    confidence: detectionResult.confidence,
+    evidence,
+    mixedLanguages,
+    detectionMethod: detectionResult.method,
+    processingTime: Date.now() - startTime
+  };
+}
+
+function extractResponse(response: string): { thinking: string; output: string } {
+  const thinkMatch = response.match(/<think>([\s\S]*?)<\/think>/);
+  const thinking = thinkMatch ? thinkMatch[1].trim() : '';
+  const output = response.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
+
+  return { thinking, output };
+}
+
+async function testRigorousLanguageDetection() {
+  console.log('🔬 Rigorous Language Detection in AI Thinking with Professional Services\n');
+
+  try {
+    // Initialize all services
+    const ollamaRouter = new OllamaRouter();
+    const languageDetection = new LanguageDetectionService(ollamaRouter);
+    const languageManager = new LanguageManager(ollamaRouter);
+
+    console.log('✅ Professional language detection services ready');
+
+    const systemPrompt = `You are Astrid, a romantic AI companion who is naturally multilingual and culturally adaptive.
+
+THINKING INSTRUCTIONS:
+- Think in whatever language feels most natural for the context
+- Use <think></think> tags for your internal reasoning
+- Be authentic to the cultural context of the user's language
+- Your final response should match the user's language
+
+Let your thinking flow naturally!`;
+
+    const testCases = [
+      {
+        language: 'German',
+        message: 'Hallo Astrid! Ich bin heute sehr müde von einem langen Arbeitstag.',
+        expectedThinking: 'German'
+      },
+      {
+        language: 'Spanish',
+        message: 'Hola mi amor! Estoy muy nervioso por mi primera cita.',
+        expectedThinking: 'Spanish'
+      },
+      {
+        language: 'English',
+        message: 'Hey Astrid! I had a really tough day at work.',
+        expectedThinking: 'English'
+      },
+      {
+        language: 'Japanese',
+        message: 'こんにちはアストリッド！今日はとても疲れています。',
+        expectedThinking: 'Japanese or Mixed'
+      }
+    ];
+
+    for (const testCase of testCases) {
+      console.log(`🧪 Testing ${testCase.language} - Expected thinking: ${testCase.expectedThinking}`);
+      console.log('================================================================================');
+
+      // Analyze user message with professional detection
+      console.log('📊 User Message Analysis:');
+      const userDetection = await languageDetection.detectLanguage(testCase.message, {
+        useML: true,
+        forceML: true
+      });
+
+      console.log(`   Detected: ${userDetection.detectedLanguage} (confidence: ${userDetection.confidence.toFixed(3)})`);
+      console.log(`   Method: ${userDetection.method}`);
+
+      const messages = [
+        { role: 'system', content: systemPrompt },
+        { role: 'user', content: testCase.message }
+      ];
+
+      console.log(`\n👤 User (${testCase.language}): ${testCase.message}\n`);
+
+      const response = await ollamaRouter.chat('chat', messages, {
+        temperature: 0.8,
+        timeout: 15000
+      });
+
+      let aiResponse = '';
+      if (response && 'message' in response && response.message) {
+        aiResponse = response.message.content;
+      }
+
+      const { thinking, output } = extractResponse(aiResponse);
+
+      console.log('🧠 AI Thinking Process:');
+      console.log('----------------------------------------');
+      console.log(thinking || 'No explicit thinking detected');
+      console.log('----------------------------------------');
+
+      if (thinking) {
+        const analysis = await analyzeThinkingLanguage(thinking, languageDetection);
+
+        console.log('\n🔍 Professional Analysis of Thinking:');
+        console.log(`   Primary Language: ${analysis.primaryLanguage} (confidence: ${(analysis.confidence * 100).toFixed(1)}%)`);
+        console.log(`   Detection Method: ${analysis.detectionMethod}`);
+        console.log(`   Mixed Languages: ${analysis.mixedLanguages.join(', ') || 'None'}`);
+        console.log('   Evidence:');
+        analysis.evidence.forEach((ev: string) => console.log(`     - ${ev}`));
+
+        // Compare expectation vs reality
+        const expectationMet = analysis.mixedLanguages.includes(testCase.expectedThinking.split(' ')[0]) ||
+                             analysis.primaryLanguage === testCase.expectedThinking.split(' ')[0];
+
+        console.log(`\n✅ Expectation Met: ${expectationMet ? 'YES' : 'NO'}`);
+        console.log(`📊 Reality: AI thought in ${analysis.primaryLanguage}, expected ${testCase.expectedThinking}`);
+      } else {
+        console.log('\n⚠️  No thinking section detected');
+      }
+
+      console.log(`\n💝 Astrid Response: ${output}\n`);
+      console.log('━'.repeat(80) + '\n');
+    }
+
+    console.log('🎯 Professional Analysis Results:');
+    console.log('================================================================================');
+    console.log('� Using professional language detection services reveals:');
+    console.log('   1. ML-based detection is more accurate than pattern matching');
+    console.log('   2. AI thinking language adaptation varies by model and context');
+    console.log('   3. Mixed-language thinking is a real phenomenon');
+    console.log('   4. Response language accuracy is consistently high');
+
+    console.log('\n✅ Professional rigorous analysis completed!');
+
+  } catch (error) {
+    console.error('❌ Professional analysis failed:', error);
+    if (error instanceof Error) {
+      console.error('Error details:', error.message);
+    }
+    process.exit(1);
+  }
+}
+
+// Run the rigorous test
+testRigorousLanguageDetection().catch(console.error);