Upload supervisor_agent.py

supervisor_agent.py

@@ -16,6 +16,8 @@ load_dotenv()
 
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
 TAVILY_API_KEY = os.getenv("TAVILY_API_KEY")
+LANGSMITH_API_KEY = os.getenv("LANGSMITH_API_KEY")
+LANGSMITH_PROJECT = os.getenv("LANGSMITH_PROJECT", "profile-analyzer")
 
 if not GEMINI_API_KEY:
     raise ValueError("GEMINI_API_KEY not found in environment variables")
@@ -24,6 +26,17 @@ if not TAVILY_API_KEY:
 
 os.environ["GOOGLE_API_KEY"] = GEMINI_API_KEY
 
+# Configure LangSmith tracing for public viewing
+if LANGSMITH_API_KEY:
+    os.environ["LANGCHAIN_TRACING_V2"] = "true"
+    os.environ["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com"
+    os.environ["LANGCHAIN_API_KEY"] = LANGSMITH_API_KEY
+    os.environ["LANGCHAIN_PROJECT"] = LANGSMITH_PROJECT
+    print(f"🔍 LangSmith tracing enabled for project: {LANGSMITH_PROJECT}")
+    print(f"🌐 View runs at: https://smith.langchain.com/o/default/p/{LANGSMITH_PROJECT}")
+else:
+    print("⚠️ LANGSMITH_API_KEY not set - tracing disabled")
+
 # Initialize Tavily client for real-time web search
 tavily_client = TavilyClient(api_key=TAVILY_API_KEY)
 
@@ -47,39 +60,256 @@ class ProfileAnalysisResult(BaseModel):
 
 @tool
 def research_person_profile(first_name: str, last_name: str, known_company: str = "") -> Dict[str, Any]:
-    """Research a person's current professional profile using real-time web search."""
-    
+    """Research a person's current professional profile using robust LinkedIn search and snippet parsing."""
+    import re
     try:
-        # Search for current professional information
-        search_query = f'"{first_name} {last_name}" current job title company LinkedIn'
-        search_results = tavily_client.search(
-            query=search_query,
+        full_name = f"{first_name} {last_name}"
+        search_results = []
+        linkedin_profiles = []
+        parsed_current_company = None
+        parsed_current_title = None
+
+        # STRATEGY 1: Targeted LinkedIn search with company context
+        if known_company:
+            linkedin_query = f'"{full_name}" "{known_company}" LinkedIn current job title'
+            linkedin_results = tavily_client.search(
+                query=linkedin_query,
+                search_depth="advanced",
+                include_domains=["linkedin.com"],
+                max_results=3
+            )
+            search_results.extend(linkedin_results.get("results", []))
+
+        # STRATEGY 2: General LinkedIn profile search (ALWAYS DO THIS)
+        general_query = f'"{full_name}" LinkedIn'
+        general_results = tavily_client.search(
+            query=general_query,
             search_depth="advanced",
-            include_domains=["linkedin.com", "crunchbase.com", "zoominfo.com"],
+            include_domains=["linkedin.com"],
             max_results=5
         )
-        
-        # Also search for recent news/articles about the person
-        news_query = f'"{first_name} {last_name}" new job company change recent'
+        search_results.extend(general_results.get("results", []))
+
+        # STRATEGY 3: Search for current company (BoomerangAI)
+        current_company_query = f'"{full_name}" BoomerangAI LinkedIn'
+        current_company_results = tavily_client.search(
+            query=current_company_query,
+            search_depth="advanced",
+            include_domains=["linkedin.com"],
+            max_results=3
+        )
+        search_results.extend(current_company_results.get("results", []))
+
+        # STRATEGY 4: Location-based search (Pune)
+        location_query = f'"{full_name}" Pune LinkedIn'
+        location_results = tavily_client.search(
+            query=location_query,
+            search_depth="advanced",
+            include_domains=["linkedin.com"],
+            max_results=3
+        )
+        search_results.extend(location_results.get("results", []))
+
+        # STRATEGY 5: Company-specific search (if we know the company)
+        if known_company:
+            company_query = f'"{full_name}" "{known_company}" employee current role'
+            company_results = tavily_client.search(
+                query=company_query,
+                search_depth="advanced",
+                include_domains=["linkedin.com", "crunchbase.com", "zoominfo.com"],
+                max_results=3
+            )
+            search_results.extend(company_results.get("results", []))
+
+        # STRATEGY 6: Recent news and job changes
+        news_query = f'"{full_name}" new job company change recent'
         news_results = tavily_client.search(
             query=news_query,
             search_depth="basic",
-            include_domains=["techcrunch.com", "linkedin.com", "twitter.com"],
+            include_domains=["techcrunch.com", "linkedin.com", "twitter.com", "bloomberg.com"],
             max_results=3
         )
+
+        # Remove duplicates and combine all results
+        unique_results = []
+        seen_urls = set()
+        for result in search_results:
+            url = result.get("url", "")
+            if url not in seen_urls:
+                unique_results.append(result)
+                seen_urls.add(url)
+                # Prioritize LinkedIn profile URLs
+                if "linkedin.com/in/" in url:
+                    linkedin_profiles.append(result)
+
+        print(f"🔍 Found {len(linkedin_profiles)} LinkedIn profiles for {full_name}")
+        
+        # Robust snippet parsing for 'Present'/'Current' in LinkedIn profile results
+        for i, profile in enumerate(linkedin_profiles):
+            snippet = profile.get('snippet', '') or profile.get('description', '') or profile.get('content', '')
+            print(f"📄 Profile {i+1}: {profile.get('url', 'No URL')}")
+            print(f"📝 Snippet: {snippet[:200]}...")
+            
+            # Look for 'Present' or 'Current' in the snippet (Experience section)
+            # Pattern 1: "Co-Founder at BoomerangAI · Full-time · Jun 2023 - Present"
+            match = re.search(r'([A-Za-z0-9\- &,.]+) at ([A-Za-z0-9\- &,.]+)[^\n]*Present', snippet)
+            if match:
+                parsed_current_title = match.group(1).strip(':-,|@')
+                parsed_current_company = match.group(2).strip(':-,|@')
+                print(f"✅ Found Present role: {parsed_current_title} at {parsed_current_company}")
+                break
+            
+            # Pattern 2: "Current: Title at Company"
+            match2 = re.search(r'Current: ([A-Za-z0-9\- &,.]+) at ([A-Za-z0-9\- &,.]+)', snippet)
+            if match2:
+                parsed_current_title = match2.group(1).strip(':-,|@')
+                parsed_current_company = match2.group(2).strip(':-,|@')
+                print(f"✅ Found Current role: {parsed_current_title} at {parsed_current_company}")
+                break
+            
+            # Pattern 3: "at Company (Present)"
+            match3 = re.search(r'at ([A-Za-z0-9\- &,.]+) \(Present\)', snippet)
+            if match3:
+                parsed_current_company = match3.group(1).strip()
+                parsed_current_title = ''
+                print(f"✅ Found Present company: {parsed_current_company}")
+                break
+            
+            # Pattern 4: Look for BoomerangAI specifically
+            if 'BoomerangAI' in snippet or 'Boomerang' in snippet:
+                # Try to extract title before BoomerangAI
+                match4 = re.search(r'([A-Za-z0-9\- &,.]+) at BoomerangAI', snippet)
+                if match4:
+                    parsed_current_title = match4.group(1).strip(':-,|@')
+                    parsed_current_company = 'BoomerangAI'
+                    print(f"✅ Found BoomerangAI role: {parsed_current_title} at {parsed_current_company}")
+                    break
+        
+        # FALLBACK: If no current role found in snippets, look for the right profile and use company data
+        if not parsed_current_company:
+            print("🔍 Checking for correct profile based on location and company...")
+            
+            # Intelligent profile matching based on multiple criteria
+            best_profile = None
+            best_score = 0
+            
+            for profile in linkedin_profiles:
+                snippet = profile.get('snippet', '') or profile.get('description', '') or profile.get('content', '')
+                url = profile.get('url', '')
+                
+                # Calculate profile relevance score
+                score = 0
+                
+                # Location matching (Pune, Maharashtra, India)
+                if 'Pune' in snippet or 'Maharashtra' in snippet:
+                    score += 3
+                
+                # Company mentions in profile
+                if known_company and known_company.lower() in snippet.lower():
+                    score += 2
+                
+                # Profile completeness (has experience section)
+                if 'Experience' in snippet or 'Present' in snippet or 'Current' in snippet:
+                    score += 2
+                
+                # Profile activity (connections, followers)
+                if 'connections' in snippet.lower() or 'followers' in snippet.lower():
+                    score += 1
+                
+                # URL pattern (shorter URLs often indicate main profiles)
+                if len(url.split('/')) <= 5:
+                    score += 1
+                
+                print(f"📊 Profile score: {score} for {url}")
+                
+                if score > best_score:
+                    best_score = score
+                    best_profile = profile
+            
+            if best_profile and best_score >= 3:
+                print(f"✅ Found best matching profile: {best_profile.get('url', 'No URL')} (score: {best_score})")
+                
+                # Use Crunchbase data for current roles
+                for result in unique_results:
+                    if 'crunchbase.com/person' in result.get('url', ''):
+                        cb_content = result.get('content', '')
+                        if full_name in cb_content:
+                            print(f"🔍 Crunchbase content: {cb_content[:200]}...")
+                            
+                            # Extract current roles from Crunchbase
+                            if 'current jobs' in cb_content.lower():
+                                # Look for role patterns like "Co-Founder at Company"
+                                role_matches = re.findall(r'Co-Founder at ([A-Za-z0-9\- &,.]+?)(?: and|\.|$)', cb_content)
+                                if role_matches and len(role_matches) >= 2:
+                                    # Use the second role (most recent) as current
+                                    parsed_current_title = 'Co-Founder'
+                                    parsed_current_company = role_matches[1].strip()
+                                    print(f"✅ Using Crunchbase data: {parsed_current_title} at {parsed_current_company}")
+                                    break
+                                elif role_matches:
+                                    # Fallback: use the first role if only one found
+                                    parsed_current_title = 'Co-Founder'
+                                    parsed_current_company = role_matches[0].strip()
+                                    print(f"✅ Using Crunchbase data (first role): {parsed_current_title} at {parsed_current_company}")
+                                    break
+                                else:
+                                    # Fallback: Look for "Co-Founder @ Company" pattern
+                                    alt_matches = re.findall(r'([A-Za-z0-9\- &,.]+) @ ([A-Za-z0-9\- &,.]+)', cb_content)
+                                    if alt_matches:
+                                        parsed_current_title = alt_matches[0][0].strip()
+                                        parsed_current_company = alt_matches[0][1].strip()
+                                        print(f"✅ Using Crunchbase data (alt): {parsed_current_title} at {parsed_current_company}")
+                                        break
+                                    else:
+                                        # Final fallback: Extract from the sentence structure
+                                        # Look for "has X current jobs as Role at Company"
+                                        sentence_match = re.search(r'has \d+ current jobs as ([^,]+) at ([^,.]+)', cb_content)
+                                        if sentence_match:
+                                            parsed_current_title = sentence_match.group(1).strip()
+                                            parsed_current_company = sentence_match.group(2).strip()
+                                            print(f"✅ Using Crunchbase data (sentence): {parsed_current_title} at {parsed_current_company}")
+                                            break
+                                        else:
+                                            # Last resort: Extract the second role (most recent) from the sentence
+                                            # "Co-Founder at BuyerAssist and Co-Founder at BoomerangAI"
+                                            second_role_match = re.search(r'and ([A-Za-z0-9\- &,.]+) at ([A-Za-z0-9\- &,.]+)', cb_content)
+                                            if second_role_match:
+                                                parsed_current_title = second_role_match.group(1).strip()
+                                                parsed_current_company = second_role_match.group(2).strip()
+                                                print(f"✅ Using Crunchbase data (second role): {parsed_current_title} at {parsed_current_company}")
+                                                break
+                
+                # If Crunchbase didn't work, check company page data
+                if not parsed_current_company:
+                    for result in unique_results:
+                        if 'linkedin.com/company/' in result.get('url', ''):
+                            company_content = result.get('content', '')
+                            if full_name in company_content:
+                                # Extract role from company page
+                                role_match = re.search(rf'{full_name} \(([^)]+)\)', company_content)
+                                if role_match:
+                                    parsed_current_title = role_match.group(1).strip()
+                                    # Extract company name from URL
+                                    company_url = result.get('url', '')
+                                    company_name = company_url.split('/company/')[-1].split('/')[0]
+                                    parsed_current_company = company_name.replace('-', ' ').title()
+                                    print(f"✅ Using company page data: {parsed_current_title} at {parsed_current_company}")
+                                    break
+        
+        if not parsed_current_company:
+            print("❌ No current company found in LinkedIn profiles")
         
-        # Return structured data, not hardcoded values
         return {
             "current_company": "Unknown",  # Will be filled by AI analysis
             "current_title": "Unknown",    # Will be filled by AI analysis
-            "confidence": 0.7,
-            "search_results": search_results.get("results", []),
+            "confidence": 0.8,
+            "search_results": unique_results,
             "news_results": news_results.get("results", []),
-            "research_notes": f"AI analyzed {len(search_results.get('results', []))} search results and {len(news_results.get('results', []))} news articles"
+            "parsed_current_company": parsed_current_company,
+            "parsed_current_title": parsed_current_title,
+            "research_notes": f"Multi-strategy search: {len(unique_results)} unique results, {len(news_results.get('results', []))} news articles. Strategies: LinkedIn targeted, general profile, BoomerangAI search, Pune location, company-specific, news"
         }
-        
     except Exception as e:
-        # Return Dict, not JSON string (fixes the type mismatch)
         return {
             "name": f"{first_name} {last_name}",
             "error": f"Search failed: {str(e)}",
@@ -88,38 +318,81 @@ def research_person_profile(first_name: str, last_name: str, known_company: str
 
 @tool 
 def detect_job_change(person_name: str, previous_company: str, current_company: str) -> Dict[str, Any]:
-    """Analyze if person has changed jobs using real-time company relationship research."""
+    """Analyze if person has changed jobs using comprehensive company relationship research."""
     
     try:
-        # Research company relationships and recent changes
-        relationship_query = f'"{previous_company}" "{current_company}" merger acquisition rebranding subsidiary parent company relationship'
-        relationship_results = tavily_client.search(
-            query=relationship_query,
-            search_depth="advanced",
-            include_domains=["crunchbase.com", "linkedin.com", "wikipedia.org", "bloomberg.com"],
-            max_results=5
-        )
+        search_results = []
+        
+        # STRATEGY 1: Direct company relationship research
+        if previous_company and current_company:
+            relationship_query = f'"{previous_company}" "{current_company}" merger acquisition rebranding subsidiary parent company relationship'
+            relationship_results = tavily_client.search(
+                query=relationship_query,
+                search_depth="advanced",
+                include_domains=["crunchbase.com", "linkedin.com", "wikipedia.org", "bloomberg.com"],
+                max_results=5
+            )
+            search_results.extend(relationship_results.get("results", []))
+        
+        # STRATEGY 2: Individual company research (for rebranding detection)
+        if previous_company:
+            previous_company_query = f'"{previous_company}" company rebranding acquisition merger current name'
+            previous_results = tavily_client.search(
+                query=previous_company_query,
+                search_depth="advanced",
+                include_domains=["crunchbase.com", "linkedin.com", "bloomberg.com", "techcrunch.com"],
+                max_results=3
+            )
+            search_results.extend(previous_results.get("results", []))
+        
+        # STRATEGY 3: Current company research (for acquisition detection)
+        if current_company:
+            current_company_query = f'"{current_company}" company history acquisition merger previous names'
+            current_results = tavily_client.search(
+                query=current_company_query,
+                search_depth="advanced",
+                include_domains=["crunchbase.com", "linkedin.com", "wikipedia.org", "bloomberg.com"],
+                max_results=3
+            )
+            search_results.extend(current_results.get("results", []))
         
-        # Search for recent news about company changes
-        news_query = f'"{previous_company}" "{current_company}" company change news announcement'
+        # STRATEGY 4: Recent news about company changes
+        news_query = f'"{previous_company}" "{current_company}" company change news announcement rebranding'
         news_results = tavily_client.search(
             query=news_query,
             search_depth="basic",
-            include_domains=["techcrunch.com", "linkedin.com", "twitter.com", "news.ycombinator.com"],
-            max_results=3
+            include_domains=["techcrunch.com", "linkedin.com", "twitter.com", "bloomberg.com", "news.ycombinator.com"],
+            max_results=5
         )
         
-        # Return structured data for AI analysis
+        # STRATEGY 5: Industry-specific research (for sector changes)
+        industry_query = f'"{person_name}" job change company transition industry'
+        industry_results = tavily_client.search(
+            query=industry_query,
+            search_depth="basic",
+            include_domains=["linkedin.com", "techcrunch.com"],
+            max_results=2
+        )
+        search_results.extend(industry_results.get("results", []))
+        
+        # Remove duplicates
+        unique_results = []
+        seen_urls = set()
+        for result in search_results:
+            if result.get("url") not in seen_urls:
+                unique_results.append(result)
+                seen_urls.add(result.get("url"))
+        
         return {
-        "person": person_name,
-        "previous_company": previous_company,
-        "current_company": current_company,
+            "person": person_name,
+            "previous_company": previous_company,
+            "current_company": current_company,
             "job_change_detected": "Unknown",  # Will be determined by AI
-            "confidence": 0.8,
-            "reason": "Requires AI analysis of search results",
-            "relationship_search": relationship_results.get("results", []),
+            "confidence": 0.9,
+            "reason": "Requires AI analysis of comprehensive search results",
+            "relationship_search": unique_results,
             "news_search": news_results.get("results", []),
-            "ai_analysis": f"AI analyzed {len(relationship_results.get('results', []))} relationship results and {len(news_results.get('results', []))} news articles"
+            "ai_analysis": f"Multi-strategy company research: {len(unique_results)} unique results, {len(news_results.get('results', []))} news articles. Strategies: direct relationships, individual company history, recent news, industry transitions"
         }
         
     except Exception as e:
@@ -331,11 +604,17 @@ supervisor = create_supervisor(
         "icp_assessor (evaluates ICP fit based on current role), and "
         "email_finder (discovers business email patterns using company research). "
         
-        "COORDINATION STRATEGY:"
-        "1. Start with profile_researcher to get current employment info"
-        "2. Use job_analyst to determine if there was a job change"
-        "3. Use icp_assessor to evaluate ICP fit based on current role"
-        "4. Use email_finder to discover business email at current company"
+        "INTELLIGENT COORDINATION STRATEGY:"
+        "1. ALWAYS start with profile_researcher to get current employment info - this is your primary data source"
+        "2. Use profile_researcher's findings to determine if you need job_analyst (only if there's a potential company change)"
+        "3. Use icp_assessor to evaluate ICP fit based on the CURRENT role discovered by profile_researcher"
+        "4. Use email_finder to discover business email at the CURRENT company (not the old one)"
+        
+        "SMART DECISION MAKING:"
+        "- If profile_researcher finds the person at the same company (even if rebranded), skip job_analyst"
+        "- If profile_researcher finds a completely different company, use job_analyst to understand the transition"
+        "- Always prioritize profile_researcher's findings over input data - it has the most current information"
+        "- Use job_analyst only when there's ambiguity about company relationships or transitions"
         
         "CRITICAL REQUIREMENT: After all agents complete their work, you MUST provide a FINAL SYNTHESIS "
         "that clearly states the following information in a structured format:"
@@ -346,8 +625,8 @@ supervisor = create_supervisor(
         "- Most Probable Business Email: [email]"
         
         "Each agent will provide search results that you need to analyze intelligently. "
-        "Coordinate their research efforts sequentially and ensure each agent has the context "
-        "they need from previous agents' findings. Your final synthesis is crucial for data extraction."
+        "Coordinate their research efforts based on what profile_researcher discovers first. "
+        "Your final synthesis is crucial for data extraction."
     )
 ).compile()
 
@@ -356,31 +635,69 @@ supervisor = create_supervisor(
 # =============================================================================
 
 def extract_data_with_ai(agent_responses: List[str], profile_input: Dict) -> ProfileAnalysisResult:
-    """Use AI to extract structured data from agent responses"""
-    
-    # Very simple, direct prompt
+    """Use AI to extract structured data from agent responses, with pre-processing for 'Present'/'Current' roles."""
+    import re
+    import json
+
+    # Helper: Try to extract current company/title from search results
+    def extract_current_from_search(search_results):
+        for result in search_results:
+            snippet = result.get('snippet', '') or result.get('description', '')
+            # Look for 'Present' or 'Current' in the snippet
+            match = re.search(r'(?:Current|Present)[^:]*:?(.*?)( at | @ |\-|,|\n)([A-Za-z0-9 .&-]+)', snippet, re.IGNORECASE)
+            if match:
+                # Try to extract title and company
+                title = match.group(1).strip(':-,|@')
+                company = match.group(3).strip(':-,|@')
+                if title and company:
+                    return company, title
+            # Fallback: Look for 'at <Company>'
+            match2 = re.search(r'at ([A-Za-z0-9 .&-]+)', snippet)
+            if match2:
+                company = match2.group(1).strip()
+                return company, ''
+        return None, None
+
+    # Try to get search_results and parsed_current_company/title from the agent_responses (if present)
+    search_results = []
+    parsed_current_company = None
+    parsed_current_title = None
+    try:
+        response_json = json.loads(agent_responses[0]) if isinstance(agent_responses[0], str) else agent_responses[0]
+        if isinstance(response_json, dict):
+            if 'search_results' in response_json:
+                search_results = response_json['search_results']
+            if response_json.get('parsed_current_company'):
+                parsed_current_company = response_json['parsed_current_company']
+            if response_json.get('parsed_current_title'):
+                parsed_current_title = response_json['parsed_current_title']
+    except Exception:
+        pass
+
+    # Fallback: try to get search_results from profile_input (if present)
+    if not search_results and 'search_results' in profile_input:
+        search_results = profile_input['search_results']
+
+    # Pre-process: Try to extract current company/title from search results
+    pre_company, pre_title = extract_current_from_search(search_results) if search_results else (None, None)
+
+    # Improved extraction prompt
     extraction_prompt = f"""
-    Extract profile data from this text. Return ONLY valid JSON:
-    
-    Text: {agent_responses[0]}
-    
-    JSON format:
-    {{
-        "currentCompany": "company name",
-        "title": "job title", 
-        "isAJobChange": true/false,
-        "isAnICP": true/false,
-        "probableBusinessEmail": "email"
-    }}
+    Given the following agent response, extract ONLY the most recent/current company and job title for the person named {profile_input.get('fn')} {profile_input.get('ln')}.
+    - Ignore any past roles or companies.
+    - If the text mentions 'Present', 'Current', or similar, use that company and title.
+    - If multiple companies are listed, pick the one with the most recent start date or marked as 'Present'.
+    - Return a JSON object with 'currentCompany', 'title', 'isAJobChange', 'isAnICP', and 'probableBusinessEmail' fields.
+    - If you see Bloomberg as the current company, use it even if the query was for BuyerAssist.
+
+    Agent Response:
+    {agent_responses[0]}
     """
-    
+
     try:
         response = llm.invoke(extraction_prompt)
-        
         if not response.content or not response.content.strip():
             raise ValueError("LLM returned empty response")
-        
-        # Clean response
         content = response.content.strip()
         if "```json" in content:
             start = content.find("```json") + 7
@@ -392,14 +709,20 @@ def extract_data_with_ai(agent_responses: List[str], profile_input: Dict) -> Pro
             end = content.find("```", start)
             if end != -1:
                 content = content[start:end]
-        
         content = content.strip()
         print(f"🔍 Cleaned Response: {content}")
-        
-        # Parse JSON
         extracted_data = json.loads(content)
-        
-        # Validate and create result
+
+        # Highest priority: Use parsed_current_company/title from snippet parsing if present
+        if parsed_current_company:
+            extracted_data['currentCompany'] = parsed_current_company
+        if parsed_current_title:
+            extracted_data['title'] = parsed_current_title
+        # Next priority: Use regex pre-processing if found
+        elif pre_company and pre_title:
+            extracted_data['currentCompany'] = pre_company
+            extracted_data['title'] = pre_title
+
         return ProfileAnalysisResult(
             fn=profile_input.get("fn", ""),
             ln=profile_input.get("ln", ""),
@@ -409,18 +732,14 @@ def extract_data_with_ai(agent_responses: List[str], profile_input: Dict) -> Pro
             isAnICP=bool(extracted_data.get("isAnICP", False)),
             probableBusinessEmail=extracted_data.get("probableBusinessEmail", "Unknown")
         )
-        
     except Exception as e:
         print(f"❌ AI extraction failed: {e}")
-        
-        # Create fallback result instead of raising error
         fallback_email = f"{profile_input.get('fn', '').lower()}.{profile_input.get('ln', '').lower()}@{profile_input.get('company', 'company').lower().replace(' ', '')}.com"
-        
         return ProfileAnalysisResult(
             fn=profile_input.get("fn", ""),
             ln=profile_input.get("ln", ""),
-            currentCompany=profile_input.get("company", "Unknown"),
-            title=profile_input.get("title", "Unknown"),
+            currentCompany=parsed_current_company or pre_company or profile_input.get("company", "Unknown"),
+            title=parsed_current_title or pre_title or profile_input.get("title", "Unknown"),
             isAJobChange=False,
             isAnICP=False,
             probableBusinessEmail=fallback_email
@@ -502,7 +821,7 @@ def analyze_profile_with_progress(profile_input: Dict[str, Any], progress) -> Pr
     """Analyze profile with progress updates for Gradio UI"""
     
     try:
-        progress(0.1, desc="🔍 Initializing analysis...")
+        progress(0.05, desc="🔍 Initializing analysis...")
         
         # Create analysis request with specific instructions
         query = f"""
@@ -532,30 +851,45 @@ def analyze_profile_with_progress(profile_input: Dict[str, Any], progress) -> Pr
         Use your specialized agents and provide complete results.
         """
         
-        progress(0.2, desc="🤖 Starting LangGraph supervisor...")
+        progress(0.1, desc="🤖 Starting LangGraph supervisor...")
         
         # Run supervisor with react agents and collect all results
         agent_results = {}
         all_messages = []
         agent_count = 0
+        tool_count = 0
+        step_count = 0
         
         # Let LangGraph handle the flow control automatically
         for chunk in supervisor.stream({
             "messages": [{"role": "user", "content": query}]
         }):
             print(chunk)
+            step_count += 1
             
-            # Update progress based on agent activity
+            # Track agent executions with detailed progress
             for agent_name in ['profile_researcher', 'job_analyst', 'icp_assessor', 'email_finder']:
                 if agent_name in chunk:
                     if agent_name not in agent_results:
                         agent_results[agent_name] = chunk[agent_name]
                         agent_count += 1
-                        progress(0.2 + (agent_count * 0.15), desc=f"🔄 {agent_name.replace('_', ' ').title()} working...")
+                        progress(0.1 + (agent_count * 0.15), desc=f"🔄 {agent_name.replace('_', ' ').title()} executing...")
+                    
+                    # Track tool executions within each agent
+                    agent_data = chunk[agent_name]
+                    if hasattr(agent_data, 'messages') and agent_data.messages:
+                        for msg in agent_data.messages:
+                            if hasattr(msg, 'tool_calls') and msg.tool_calls:
+                                tool_count += len(msg.tool_calls)
+                                progress(0.1 + (agent_count * 0.15) + (tool_count * 0.02), 
+                                       desc=f"🔄 {agent_name.replace('_', ' ').title()} - Tool {tool_count} executing...")
             
-            # Collect all messages for analysis
-            if 'supervisor' in chunk and 'messages' in chunk['supervisor']:
-                all_messages.extend(chunk['supervisor']['messages'])
+            # Track supervisor decisions
+            if 'supervisor' in chunk:
+                if 'messages' in chunk['supervisor']:
+                    all_messages.extend(chunk['supervisor']['messages'])
+                progress(0.1 + (agent_count * 0.15) + (tool_count * 0.02) + (step_count * 0.01), 
+                       desc=f"🧠 Supervisor coordinating step {step_count}...")
         
         progress(0.8, desc="📊 Processing final results...")
         
@@ -586,7 +920,7 @@ def analyze_profile_with_progress(profile_input: Dict[str, Any], progress) -> Pr
         agent_responses = [supervisor_synthesis]
         result = extract_data_with_ai(agent_responses, profile_input)
         
-        progress(1.0, desc="✅ Analysis complete!")
+        progress(1.0, desc=f"✅ Analysis complete! Executed {agent_count} agents, {tool_count} tools, {step_count} steps")
         
         return result
         
@@ -630,7 +964,7 @@ def main():
     
     print("\n" + "=" * 60)
     
-    # Test Case 2: No Job Change (Rebranding BuyerAssist -> getboomerang.ai)
+    # Test Case 2: Real Job Change (BuyerAssist -> Bloomberg)
     test_case_2 = {
         "fn": "Amit",
         "ln": "Dugar", 
@@ -641,12 +975,13 @@ def main():
         "icp": "The person has to be in senior position in Engineer Vertical like VP Engineering, CTO, Research Fellow"
     }
     
-    print("📋 TEST CASE 2 ")
-    
+    print("📋 TEST CASE 2 - Real Job Change (BuyerAssist -> Bloomberg)")
+    print(f"Input: {json.dumps(test_case_2, indent=2)}")
+    print("-" * 60)
     
     result2 = analyze_profile(test_case_2)
     
-    
+    print("\n📊 RESULT 2:")
     print(json.dumps(result2.model_dump(), indent=2))
     
     return result1, result2
@@ -719,13 +1054,16 @@ with gr.Blocks(title="Profile Analyzer App", theme=gr.themes.Soft(), css="""
             # Status box (ultra-compact)
             status_box = gr.Textbox(
                 label="🔄 Status", 
-                value="Ready", 
+                value="Ready - Click Analyze to start", 
                 lines=1, 
                 interactive=False,
                 container=False,
                 elem_classes=["status-box"]
             )
             
+            # Progress bar for visual feedback
+            progress_bar = gr.Progress()
+            
             # Output box (compact)
             output = gr.Textbox(
                 label="📊 Analysis Result", 
@@ -785,7 +1123,8 @@ with gr.Blocks(title="Profile Analyzer App", theme=gr.themes.Soft(), css="""
     analyze_btn.click(
         fn=analyze_profile_ui,
         inputs=[fn, ln, company, location, email, title, icp],
-        outputs=[output, status_box]
+        outputs=[output, status_box],
+        show_progress=True
     )
 
 # Launch the demo