Merge pull request #16 from Gonna-AI/claude/peaceful-tereshkova

feat: Implement AI-powered caller name extraction via Groq tool calls…

Author: amethystani

src/components/DemoCall/CallHistoryList.tsx

@@ -365,6 +365,7 @@ export default function CallHistoryList({ isDark = true, showFilters = true }: C
                                   )}
 
                                   {/* AI Suggestions */}
+                                  {item.summary.suggestions && item.summary.suggestions.length > 0 && (
                                   <div>
                                     <h4 className={cn("text-xs uppercase mb-2 font-semibold tracking-wider flex items-center gap-2", isDark ? "text-white/40" : "text-black/40")}>
                                       <TrendingUp className="w-3 h-3" /> AI Suggestions
@@ -374,22 +375,22 @@ export default function CallHistoryList({ isDark = true, showFilters = true }: C
                                       isDark ? "bg-black/20 border-white/10" : "bg-white border-black/5"
                                     )}>
                                       <div className="absolute top-0 right-0 w-32 h-32 bg-purple-500/10 blur-[40px] rounded-full pointer-events-none" />
-                                      <div className="relative z-10 space-y-4"> {/* Increased spacing */}
-                                        <div className={cn("flex items-start gap-3 text-sm min-w-0", isDark ? "text-white/70" : "text-gray-600")}>
-                                          <div className="w-6 h-6 rounded-lg bg-purple-500/10 flex items-center justify-center flex-shrink-0 text-purple-400">
-                                            <Smile className="w-3 h-3" />
-                                          </div>
-                                          <p className="flex-1 break-words">Consider offering a follow-up consultation to address the client's specific concerns mentioned.</p>
-                                        </div>
-                                        <div className={cn("flex items-start gap-3 text-sm min-w-0", isDark ? "text-white/70" : "text-gray-600")}>
-                                          <div className="w-6 h-6 rounded-lg bg-blue-500/10 flex items-center justify-center flex-shrink-0 text-blue-400">
-                                            <ListTodo className="w-3 h-3" />
+                                      <div className="relative z-10 space-y-4">
+                                        {item.summary.suggestions.map((suggestion, i) => (
+                                          <div key={i} className={cn("flex items-start gap-3 text-sm min-w-0", isDark ? "text-white/70" : "text-gray-600")}>
+                                            <div className={cn(
+                                              "w-6 h-6 rounded-lg flex items-center justify-center flex-shrink-0",
+                                              i % 2 === 0 ? "bg-purple-500/10 text-purple-400" : "bg-blue-500/10 text-blue-400"
+                                            )}>
+                                              {i % 2 === 0 ? <Smile className="w-3 h-3" /> : <ListTodo className="w-3 h-3" />}
+                                            </div>
+                                            <p className="flex-1 break-words">{suggestion}</p>
                                           </div>
-                                          <p className="flex-1 break-words">Update the user's profile with the new contact preferences.</p>
-                                        </div>
+                                        ))}
                                       </div>
                                     </div>
                                   </div>
+                                  )}
                                 </div>
 
                                 {/* Action Items - Moved to full width or separate grid if needed, keeping here for flow */}

src/contexts/DemoCallContext.tsx

@@ -853,73 +853,17 @@ export function DemoCallProvider({ children, initialAgentId }: { children: React
     return () => window.removeEventListener('beforeunload', handleBeforeUnload);
   }, [currentCall?.id, currentCall?.status, cachedToken]);
 
-  // Helper to find caller name from various sources
+  // Helper to find caller name — extracted fields only, no regex.
+  // Actual name extraction from the transcript is handled by Groq tool call in summarizeCall.
   const findCallerName = (call: CallSession): string => {
-    // First try extracted fields (most reliable)
     const nameField = call.extractedFields.find(f =>
       f.id === 'name' ||
       f.label.toLowerCase().includes('name') ||
       f.label.toLowerCase().includes('caller')
     );
     if (nameField?.value && nameField.value.trim() && nameField.value !== 'Unknown Caller') {
-      console.log('✅ Found caller name from extracted fields:', nameField.value);
       return nameField.value.trim();
     }
-
-    // Common words to filter out as false positives
-    const commonWords = ['hello', 'hi', 'hey', 'yes', 'no', 'okay', 'sure', 'thanks', 'thank', 'you', 'the', 'a', 'an', 'how', 'can', 'help', 'may', 'please', 'need', 'want', 'have', 'for', 'reaching', 'out', 'your', 'this', 'that', 'with', 'about', 'today', 'there', 'got', 'it'];
-
-    // Try to find name in messages where user introduced themselves
-    const userMessages = call.messages.filter(m => m.speaker === 'user');
-    for (const msg of userMessages) {
-      // Common patterns: "My name is X", "I'm X", "This is X", "I am X", "Hi, I'm X", "Hello, this is X"
-      const patterns = [
-        /(?:my name is|i'?m|this is|i am|call me|hi,?\s*i'?m|hello,?\s*this is)\s+([A-Z][a-z]+(?:\s+[A-Z][a-z]+)?)/i,
-        /^([A-Z][a-z]+(?:\s+[A-Z][a-z]+)?)\s+(?:here|calling|speaking)/i,
-        /(?:hi|hello),?\s*([A-Z][a-z]+)/i,
-        // Pattern for just stating name directly like "Animesh Mishra" or "Animesh Mishra 9650848339"
-        /^([A-Z][a-z]+\s+[A-Z][a-z]+)(?:\s+\d+)?$/i,
-        // Pattern for "im Animesh" or "its Animesh"
-        /(?:im|its|it's)\s+([A-Z][a-z]+(?:\s+[A-Z][a-z]+)?)/i,
-      ];
-
-      for (const pattern of patterns) {
-        const match = msg.text.match(pattern);
-        if (match?.[1]) {
-          const name = match[1].trim();
-          // Filter out common false positives
-          if (!commonWords.includes(name.toLowerCase()) && name.length > 2) {
-            console.log('✅ Found caller name from message pattern:', name);
-            return name;
-          }
-        }
-      }
-    }
-
-    // Try agent messages that might reference the caller's name
-    const agentMessages = call.messages.filter(m => m.speaker === 'agent');
-    for (const msg of agentMessages) {
-      const patterns = [
-        /(?:hi|hello),?\s+([A-Z][a-z]+(?:\s+[A-Z][a-z]+)?)/i,
-        /(?:thanks|thank you),?\s+([A-Z][a-z]+)/i,
-        // Pattern for "Mr./Ms./Mrs. X" - common in formal responses
-        /(?:Mr\.?|Ms\.?|Mrs\.?)\s+([A-Z][a-z]+)/i,
-        // Pattern for "Hello, Mr. Mishra" style
-        /(?:hello|hi),?\s+(?:Mr\.?|Ms\.?|Mrs\.?)\s+([A-Z][a-z]+)/i,
-      ];
-      for (const pattern of patterns) {
-        const match = msg.text.match(pattern);
-        if (match?.[1]) {
-          const name = match[1].trim();
-          if (!commonWords.includes(name.toLowerCase()) && name.length > 2) {
-            console.log('✅ Found caller name from agent message:', name);
-            return name;
-          }
-        }
-      }
-    }
-
-    console.log('⚠️ Could not find caller name, using "Unknown Caller"');
     return 'Unknown Caller';
   };
 
@@ -1056,7 +1000,8 @@ export function DemoCallProvider({ children, initialAgentId }: { children: React
               finalSummary = summaryResponse.summary;
               tags = summaryResponse.tags;
 
-              if (summaryResponse.callerName && callerName === 'Unknown Caller') {
+              // Always prefer the AI-extracted name (Groq tool call result)
+              if (summaryResponse.callerName && summaryResponse.callerName !== 'Unknown Caller') {
                 callerName = summaryResponse.callerName;
               }
               console.log('✅ AI summary generated successfully');
@@ -1070,10 +1015,6 @@ export function DemoCallProvider({ children, initialAgentId }: { children: React
             };
           }
 
-          if (callerName === 'Unknown Caller') {
-            callerName = findCallerName(endedCall);
-          }
-
           // Create the final history item with real summary
           const finalHistoryItem: CallHistoryItem = {
             id: historyId,

src/services/localLLMService.ts

@@ -902,6 +902,79 @@ class GroqLLMService {
   }
 
 
+  /**
+   * Extract caller name from transcript using a forced Groq tool call.
+   * No regex, no fallback — if the model can't find a name, returns null.
+   */
+  async extractCallerName(messages: CallMessage[]): Promise<string | null> {
+    if (!this.groqAvailable) return null;
+
+    const settings = getCurrentGroqSettings();
+    const transcript = messages
+      .map(m => `${m.speaker === 'agent' ? 'Agent' : 'Caller'}: ${m.text}`)
+      .join('\n');
+
+    const callerInfoTool = {
+      type: 'function' as const,
+      function: {
+        name: 'extract_caller_info',
+        description: 'Extract the caller\'s name from the conversation transcript.',
+        parameters: {
+          type: 'object',
+          properties: {
+            caller_name: {
+              type: 'string',
+              description:
+                'Full name of the caller exactly as they stated it. Return null if the caller never explicitly introduced themselves by name.',
+            },
+          },
+          required: ['caller_name'],
+        },
+      },
+    };
+
+    try {
+      const response = await proxyJSON<GroqResponse>(
+        ProxyRoutes.COMPLETIONS,
+        {
+          model: settings.model,
+          messages: [
+            {
+              role: 'system',
+              content:
+                'You extract the caller\'s name from a conversation transcript. ' +
+                'Only return a name if the caller explicitly stated it (e.g. "my name is …", "I\'m …", "this is …"). ' +
+                'Do NOT infer names from greetings like "good afternoon" or generic words. ' +
+                'If the caller never introduced themselves, set caller_name to null.',
+            },
+            {
+              role: 'user',
+              content: `Extract the caller's name from this transcript:\n\n${transcript}`,
+            },
+          ],
+          tools: [callerInfoTool],
+          tool_choice: { type: 'function', function: { name: 'extract_caller_info' } },
+          temperature: 0,
+          max_tokens: 64,
+        },
+        { timeout: 10000 }
+      );
+
+      const toolCall = response?.choices?.[0]?.message?.tool_calls?.[0];
+      if (toolCall?.function?.name === 'extract_caller_info') {
+        const args = JSON.parse(toolCall.function.arguments) as { caller_name?: string | null };
+        const name = args.caller_name;
+        if (name && name !== 'null' && name.toLowerCase() !== 'unknown' && name.trim().length > 1) {
+          return name.trim();
+        }
+      }
+    } catch (e) {
+      log.warn('⚠️ extractCallerName tool call failed:', e);
+    }
+
+    return null;
+  }
+
   /**
    * Generate comprehensive call summary using function calling approach
    * Based on Groq API function calling pattern for structured data extraction
@@ -957,34 +1030,11 @@ class GroqLLMService {
     const categoryHint = category ? `\nCategory Hint: ${category.name} (${category.id})` : '';
     const priorityHint = priority ? `\nPriority Hint: ${priority}` : '';
 
-    // Try to find caller name from extracted fields first
-    let callerName = extractedFields.find(f => f.id === 'name')?.value;
-
-    // If no name in fields, try to extract from messages
-    if (!callerName) {
-      for (const msg of messages) {
-        if (msg.speaker === 'user') {
-          // Look for name patterns - enhanced for all cultures
-          const patterns = [
-            /(?:my name is|i'?m|this is|i am)\s+([A-Za-z][A-Za-z]+(?:\s+[A-Za-z][A-Za-z]+)?)/i,
-            /^([A-Za-z][A-Za-z]+(?:\s+[A-Za-z][A-Za-z]+)?)\s+(?:here|calling|speaking)/i,
-            /(?:im|its|it's)\s+([A-Za-z][A-Za-z]+(?:\s+[A-Za-z][A-Za-z]+)?)/i,
-          ];
-          for (const pattern of patterns) {
-            const match = msg.text.match(pattern);
-            if (match?.[1] && match[1].length > 2) {
-              const name = match[1].trim();
-              const commonWords = ['hello', 'hi', 'hey', 'yes', 'no', 'okay', 'sure', 'thanks', 'thank', 'you', 'the', 'help', 'need', 'want', 'thing', 'calling', 'good', 'fine', 'here'];
-              if (!commonWords.includes(name.toLowerCase())) {
-                callerName = name;
-                break;
-              }
-            }
-          }
-          if (callerName) break;
-        }
-      }
-    }
+    // Extract caller name: extracted fields first, then Groq tool call — no regex
+    const callerName =
+      extractedFields.find(f => f.id === 'name')?.value?.trim() ||
+      (await this.extractCallerName(messages)) ||
+      null;
 
     // Enhanced prompt for detailed summary with comprehensive analysis
     const prompt = `Analyze this call transcript thoroughly and provide a comprehensive summary.