finta-aurora-mcp 1.0.0__py3-none-any.whl

tools/editInvestorTool.py

@@ -0,0 +1,653 @@
+from langchain_core.tools import StructuredTool, ToolException
+import requests
+from pydantic.v1 import BaseModel, Field, ValidationError
+from typing import Optional, List, Dict, Any
+import os
+from langchain_core.runnables.config import RunnableConfig
+import logging
+
+logger = logging.getLogger(__name__)
+
+API_BASE_URL = os.environ.get('API_BASE_URL', '')
+# API_BASE_URL = "https://us-central1-equity-token-1.cloudfunctions.net/"
+
+class EditTargetInvestorInput(BaseModel):
+    id: Optional[str] = Field(default="", description="Target investor document ID. If not provided, use investorName or investorEmail to search for the investor first.")
+    investorName: Optional[str] = Field(default="", description="Investor's full name (e.g., 'John Smith') or first/last name. Use this if you don't have the investor ID. The tool will search for the investor by name.")
+    investorEmail: Optional[str] = Field(default="", description="Investor's email address. Use this if you don't have the investor ID. The tool will search for the investor by email.")
+    firstName: Optional[str] = Field(default="", description="Investor first name")
+    lastName: Optional[str] = Field(default="", description="Investor last name")
+    email: Optional[str] = Field(default="", description="Investor email")
+    phone: Optional[str] = Field(default="", description="Phone")
+    location: Optional[str] = Field(default="", description="Location")
+    status: Optional[str] = Field(default="", description="Tracker status (target, emailed, viewed, interested, diligence, committed, invested, passed)")
+    grade: Optional[str] = Field(default="", description="Investor grade (e.g., 'A', 'B', 'C'). This is DIFFERENT from tags - grade is a single rating value, not a tag.")
+    amount: Optional[str] = Field(default="", description="Amount (string or number)")
+    paymentMethod: Optional[str] = Field(default="", description="Transfer method")
+    dealId: Optional[str] = Field(default="", description="Deal document ID. If not provided, use dealName to search for the deal first.")
+    dealUuid: Optional[str] = Field(default="", description="Deal UUID")
+    dealName: Optional[str] = Field(default="", description="Deal name, round, or nickname (e.g., 'Seed', 'Series B', 'Custom Terms', or deal nickname). Use this if you don't have the deal ID. The tool will search for the deal by matching against the full deal title (round, name, and nickname), same as the deal selector in Aurora.")
+    collectionType: Optional[str] = Field(default="target_investors", description="Collection type: 'target_investors' (manually added investors) or 'investor_tracker' (contacts created when viewing deals). Defaults to 'target_investors'. Use 'investor_tracker' when updating contacts that viewed a deal.")
+    potentialIntroductionName: Optional[str] = Field(default="", description="Introduction Path Name (legacy field - will be auto-converted to introductionPaths). Use this when user says 'add [name] as introduction pathway' or 'add [name] as warm intro'. Example: 'Megan'")
+    potentialIntroduction: Optional[str] = Field(default="", description="Introduction Path Email or Name (legacy field - will be auto-converted to introductionPaths). Can be either an email address or a name. If email is provided separately in notes, this can be the name. Example: 'Megan' or 'megan@example.com'")
+    potentialIntroductionLinkedin: Optional[str] = Field(default="", description="Introduction Path LinkedIn URL (legacy field - will be auto-converted to introductionPaths)")
+    introductionPaths: Optional[List[Dict[str, Any]]] = Field(default=None, description="List of introduction/connection paths, each with name, email, linkedin, and optional primary flag. These are people who can introduce you to this investor. PREFERRED method for adding introductions. Only set primary: true if user explicitly says 'primary' or 'main' introduction. Example: [{'name': 'Megan', 'email': 'megan@example.com', 'linkedin': '...', 'primary': false}]")
+    setAsPrimaryIntroduction: Optional[bool] = Field(default=None, description="Set to true if the user wants this introduction pathway to be the primary one. Only set if user explicitly says 'primary' or 'main' introduction.")
+    noConnections: Optional[bool] = Field(default=None, description="Set to true if you don't have any mutual connections to this investor")
+    notes: Optional[str] = Field(default="", description="Notes")
+    feedback: Optional[str] = Field(default="", description="Feedback")
+    sourceUserId: Optional[str] = Field(default="", description="Source user ID - who on the team owns the relationship with the contact")
+    type: Optional[str] = Field(default="", description="Type of investor")
+    title: Optional[str] = Field(default="", description="Title")
+    organizationName: Optional[str] = Field(default="", description="Organization")
+    organizationWebsite: Optional[str] = Field(default="", description="Organization website")
+    linkedIn: Optional[str] = Field(default="", description="LinkedIn")
+    twitter: Optional[str] = Field(default="", description="Twitter")
+    crunchbase: Optional[str] = Field(default="", description="Crunchbase")
+    angelList: Optional[str] = Field(default="", description="AngelList")
+    investmentRangeFrom: Optional[str] = Field(default="", description="Investment range min")
+    investmentRangeTo: Optional[str] = Field(default="", description="Investment range max")
+    investmentSweetSpot: Optional[str] = Field(default="", description="Investment sweet spot")
+    fundSize: Optional[str] = Field(default="", description="Fund size")
+    leadsInvestments: Optional[bool] = Field(default=None, description="Leads investments")
+    preferredAssetClass: Optional[str] = Field(default="", description="Preferred asset class")
+    focusStages: Optional[List[str]] = Field(default=None, description="Focus stages")
+    prefferedCompanyTraction: Optional[str] = Field(default="", description="Preferred company traction")
+    industriesOfInterest: Optional[List[str]] = Field(default=None, description="Industries of interest")
+    industriesNotInterestedIn: Optional[List[str]] = Field(default=None, description="Industries not interested in")
+    preferredGeographicInvestmentFocus: Optional[str] = Field(default="", description="Geographic focus")
+    gender: Optional[str] = Field(default="", description="Gender")
+    bio: Optional[str] = Field(default="", description="Bio")
+    relevantPortfolioCompanies: Optional[str] = Field(default="", description="Relevant portfolio companies")
+    tags: Optional[List[str]] = Field(default=None, description="List of tags to add or replace. Tags are labels/categories like 'Series A', 'Seed', 'Super Angel', 'Big ups'. If provided, replaces all existing tags. Use this when user says 'tag [name] as [tag]' or 'add tag [tag] to [name]'. Example: ['Super Angel', 'Series A']. IMPORTANT: This is DIFFERENT from 'grade' - tags are multiple labels, grade is a single rating.")
+
+def call_edit_target_investor_any_fields(
+    config: RunnableConfig,
+    id: Optional[str] = "",
+    investorName: Optional[str] = "",
+    investorEmail: Optional[str] = "",
+    firstName: Optional[str] = "",
+    lastName: Optional[str] = "",
+    email: Optional[str] = "",
+    phone: Optional[str] = "",
+    location: Optional[str] = "",
+    status: Optional[str] = "",
+    grade: Optional[str] = "",
+    amount: Optional[str] = "",
+    paymentMethod: Optional[str] = "",
+    dealId: Optional[str] = "",
+    dealUuid: Optional[str] = "",
+    dealName: Optional[str] = "",
+    collectionType: Optional[str] = "target_investors",
+    potentialIntroductionName: Optional[str] = "",
+    potentialIntroduction: Optional[str] = "",
+    potentialIntroductionLinkedin: Optional[str] = "",
+    introductionPaths: Optional[List[Dict[str, Any]]] = None,
+    setAsPrimaryIntroduction: Optional[bool] = None,
+    noConnections: Optional[bool] = None,
+    notes: Optional[str] = "",
+    feedback: Optional[str] = "",
+    sourceUserId: Optional[str] = "",
+    type: Optional[str] = "",
+    title: Optional[str] = "",
+    organizationName: Optional[str] = "",
+    organizationWebsite: Optional[str] = "",
+    linkedIn: Optional[str] = "",
+    twitter: Optional[str] = "",
+    crunchbase: Optional[str] = "",
+    angelList: Optional[str] = "",
+    investmentRangeFrom: Optional[str] = "",
+    investmentRangeTo: Optional[str] = "",
+    investmentSweetSpot: Optional[str] = "",
+    fundSize: Optional[str] = "",
+    leadsInvestments: Optional[bool] = None,
+    preferredAssetClass: Optional[str] = "",
+    focusStages: Optional[List[str]] = None,
+    prefferedCompanyTraction: Optional[str] = "",
+    industriesOfInterest: Optional[List[str]] = None,
+    industriesNotInterestedIn: Optional[List[str]] = None,
+    preferredGeographicInvestmentFocus: Optional[str] = "",
+    gender: Optional[str] = "",
+    bio: Optional[str] = "",
+    relevantPortfolioCompanies: Optional[str] = "",
+    tags: Optional[List[str]] = None,
+):
+    """
+    Update any fields on a target investor document, including nested investor fields.
+    Only provided fields are updated.
+    If investor ID is not provided, the tool will search for the investor by name or email first.
+    """
+    try:
+        org_info = config.get('configurable', {}).get("org_info", {})
+        handle = org_info.get("handle")
+        sourceUserId = org_info.get("founderId")
+        
+        if not handle:
+            raise ToolException("Trouble with that request - organization handle not found in config")
+        if not sourceUserId:
+            raise ToolException("Trouble with that request - founder ID not found in config")
+        
+        # Track if we had multiple matches (for user notification)
+        multiple_matches_info = None
+        
+        # Determine which collection to use
+        use_tracker = collectionType and collectionType.lower() == "investor_tracker"
+        
+        # If ID not provided, search for investor by name or email
+        if not id or id == "":
+            if not investorName and not investorEmail:
+                raise ToolException("Trouble with that request - either id, investorName, or investorEmail must be provided")
+            
+            # If collectionType not specified, search both collections (target_investors first, then tracker)
+            found_investor = False
+            search_result = None
+            
+            # First, try target_investors (unless explicitly told to use tracker)
+            if not use_tracker:
+                try:
+                    search_url = API_BASE_URL + "fintaAI/tools/search-investor"
+                    search_params = {
+                        "organizationHandle": handle,
+                    }
+                    if investorEmail:
+                        search_params["email"] = investorEmail
+                    elif investorName:
+                        search_params["name"] = investorName
+                    
+                    search_response = requests.get(search_url, params=search_params, timeout=10)
+                    search_response.raise_for_status()
+                    search_result = search_response.json()
+                    
+                    investors = search_result.get("investors", [])
+                    if investors and len(investors) > 0:
+                        found_investor = True
+                        use_tracker = False
+                except requests.exceptions.RequestException:
+                    # If search fails, continue to try tracker collection
+                    pass
+            
+            # If not found in target_investors, try investor_tracker
+            if not found_investor:
+                try:
+                    search_url = API_BASE_URL + "fintaAI/tools/search-tracker-entry"
+                    search_params = {
+                        "organizationHandle": handle,
+                    }
+                    if investorEmail:
+                        search_params["email"] = investorEmail
+                    elif investorName:
+                        search_params["name"] = investorName
+                    
+                    search_response = requests.get(search_url, params=search_params, timeout=10)
+                    search_response.raise_for_status()
+                    search_result = search_response.json()
+                    
+                    entries = search_result.get("entries", [])
+                    if entries and len(entries) > 0:
+                        found_investor = True
+                        use_tracker = True
+                except requests.exceptions.Timeout:
+                    raise ToolException("Trouble with that request - the search timed out. Please try again.")
+                except requests.exceptions.HTTPError as e:
+                    error_msg = "Trouble with that request"
+                    try:
+                        error_data = e.response.json()
+                        if error_data.get('error'):
+                            error_msg += f": {error_data['error']}"
+                    except:
+                        error_msg += f" - server error (status {e.response.status_code})"
+                    raise ToolException(error_msg)
+                except requests.exceptions.RequestException as e:
+                    raise ToolException(f"Trouble with that request - network error: {str(e)}")
+            
+            # If still not found in either collection, raise error
+            if not found_investor or not search_result:
+                raise ToolException(f"Trouble with that request - no investor found with {'email: ' + investorEmail if investorEmail else 'name: ' + investorName} in either collection")
+            
+            # Handle results based on collection type
+            if use_tracker:
+                entries = search_result.get("entries", [])
+                # entries should already be validated above, but double-check
+                if not entries or len(entries) == 0:
+                    # This shouldn't happen if found_investor is True, but handle it anyway
+                    raise ToolException(f"Trouble with that request - no tracker entry found with {'email: ' + investorEmail if investorEmail else 'name: ' + investorName}")
+                
+                if len(entries) > 1:
+                    # Multiple matches - try to narrow down by dealId or dealName
+                    matched_entries = entries
+                    multiple_matches_info = None
+                    
+                    # Strategy 1: If dealId was provided, filter by dealId
+                    if dealId:
+                        deal_matches = [e for e in matched_entries if e.get('dealId') == dealId]
+                        if len(deal_matches) == 1:
+                            id = deal_matches[0]["id"]
+                            matched_entries = deal_matches
+                        elif len(deal_matches) > 1:
+                            matched_entries = deal_matches
+                    
+                    # Strategy 2: If dealName was provided, search for deal and filter by dealId
+                    if dealName and len(matched_entries) > 1:
+                        try:
+                            search_deal_url = API_BASE_URL + "fintaAI/tools/search-deal"
+                            search_deal_params = {
+                                "organizationHandle": handle,
+                                "dealName": dealName,  # Use dealName parameter (searches both round and name fields)
+                            }
+                            search_deal_response = requests.get(search_deal_url, params=search_deal_params, timeout=10)
+                            search_deal_response.raise_for_status()
+                            search_deal_result = search_deal_response.json()
+                            
+                            if search_deal_result.get("deals") and len(search_deal_result["deals"]) > 0:
+                                deal_id_to_match = search_deal_result["deals"][0]["id"]
+                                deal_matches = [e for e in matched_entries if e.get('dealId') == deal_id_to_match]
+                                if len(deal_matches) == 1:
+                                    id = deal_matches[0]["id"]
+                                    matched_entries = deal_matches
+                                elif len(deal_matches) > 1:
+                                    matched_entries = deal_matches
+                        except:
+                            # If deal search fails, continue with existing matches
+                            pass
+                    
+                    # Strategy 3: If still multiple matches, pick the most recently modified one
+                    if len(matched_entries) > 1:
+                        # Simple approach: just pick the most recently updated entry
+                        def get_updated_time(entry):
+                            updated = entry.get('updated')
+                            if hasattr(updated, 'timestamp'):
+                                return updated.timestamp()
+                            elif isinstance(updated, str):
+                                from datetime import datetime
+                                try:
+                                    return datetime.fromisoformat(updated.replace('Z', '+00:00')).timestamp()
+                                except:
+                                    return 0
+                            return 0
+                        
+                        matched_entries.sort(key=get_updated_time, reverse=True)
+                        id = matched_entries[0]["id"]
+                    else:
+                        # Only one match after filtering
+                        id = matched_entries[0]["id"]
+                else:
+                    id = entries[0]["id"]
+            else:
+                investors = search_result.get("investors", [])
+                if not investors or len(investors) == 0:
+                    raise ToolException(f"Trouble with that request - no investor found with {'email: ' + investorEmail if investorEmail else 'name: ' + investorName}")
+                
+                if len(investors) > 1:
+                    # Multiple matches - try to narrow down intelligently
+                    matched_investors = investors
+                    
+                    # Strategy 1: If email was provided in the update, try to match by email
+                    if email:
+                        email_matches = [
+                            inv for inv in matched_investors
+                            if inv.get('investor', {}).get('email', '').lower() == email.lower()
+                        ]
+                        if len(email_matches) == 1:
+                            # Found exact email match - use it
+                            id = email_matches[0]["id"]
+                        elif len(email_matches) > 1:
+                            # Still multiple matches even with email - pick most recent
+                            matched_investors = email_matches
+                    
+                    # Strategy 2: If still multiple, pick the most recently modified one
+                    if len(matched_investors) > 1:
+                        # Simple approach: just pick the most recently updated investor
+                        def get_updated_time(inv):
+                            updated = inv.get('updated')
+                            if hasattr(updated, 'timestamp'):
+                                return updated.timestamp()
+                            elif isinstance(updated, str):
+                                from datetime import datetime
+                                try:
+                                    return datetime.fromisoformat(updated.replace('Z', '+00:00')).timestamp()
+                                except:
+                                    return 0
+                            return 0
+                        
+                        matched_investors.sort(key=get_updated_time, reverse=True)
+                        id = matched_investors[0]["id"]
+                    else:
+                        # Only one match after email filtering
+                        id = matched_investors[0]["id"]
+                else:
+                    # Found exactly one match
+                    id = investors[0]["id"]
+        
+        # If dealId not provided but dealName is, search for deal by name
+        resolved_deal_id = dealId
+        resolved_deal_uuid = dealUuid
+        if (not dealId or dealId == "") and dealName:
+            try:
+                search_deal_url = API_BASE_URL + "fintaAI/tools/search-deal"
+                # Use dealName parameter (searches both round and name fields) instead of round
+                search_deal_params = {
+                    "organizationHandle": handle,
+                    "dealName": dealName,  # Search by deal name (searches both round and custom name fields)
+                }
+                search_deal_response = requests.get(search_deal_url, params=search_deal_params, timeout=10)
+                search_deal_response.raise_for_status()
+                search_deal_result = search_deal_response.json()
+                
+                if not search_deal_result.get("deals") or len(search_deal_result["deals"]) == 0:
+                    # Return user-friendly message instead of raising exception
+                    return f"Trouble with that request - no deal found with name '{dealName}'. Please check the deal name and try again, or provide the deal ID if you have it."
+                
+                if len(search_deal_result["deals"]) > 1:
+                    # Multiple matches - use the first one (should be sorted by match score)
+                    deal_list = "\n".join([
+                        f"- {deal.get('name') or deal.get('terms', {}).get('round', 'Unknown')} (ID: {deal['id']}, Score: {deal.get('matchScore', 0)})"
+                        for deal in search_deal_result["deals"][:5]
+                    ])
+                    # Use the first match (should be highest score)
+                    resolved_deal_id = search_deal_result["deals"][0]["id"]
+                    resolved_deal_uuid = search_deal_result["deals"][0].get("uuid", "")
+                    first_deal = search_deal_result["deals"][0]
+                    logger.debug(f"DEBUG: Found {len(search_deal_result['deals'])} deals matching '{dealName}'. Using first match (ID: {resolved_deal_id}, Round: {first_deal.get('round', 'N/A')}, Name: {first_deal.get('name', 'N/A')}, Nickname: {first_deal.get('dealNickname', 'N/A')}, Score: {first_deal.get('matchScore', 0)})")
+                else:
+                    # Found exactly one match
+                    resolved_deal_id = search_deal_result["deals"][0]["id"]
+                    resolved_deal_uuid = search_deal_result["deals"][0].get("uuid", "")
+                    first_deal = search_deal_result["deals"][0]
+                    logger.debug(f"DEBUG: Found exact match for '{dealName}' (ID: {resolved_deal_id}, Round: {first_deal.get('round', 'N/A')}, Name: {first_deal.get('name', 'N/A')}, Nickname: {first_deal.get('dealNickname', 'N/A')})")
+            except requests.exceptions.Timeout:
+                return "Trouble with that request - the deal search timed out. Please try again."
+            except requests.exceptions.HTTPError as e:
+                error_msg = "Trouble with that request"
+                try:
+                    error_data = e.response.json()
+                    if error_data.get('error'):
+                        error_msg += f": {error_data['error']}"
+                except:
+                    error_msg += f" - server error (status {e.response.status_code})"
+                return error_msg
+            except requests.exceptions.RequestException as e:
+                return f"Trouble with that request - network error: {str(e)}"
+        
+        investorFields = {}
+        fields = {}
+        
+        # Map user-friendly status names to database values
+        status_mapping = {
+            'target investor': 'target',
+            'target': 'target',
+            'in contact': 'emailed',
+            'emailed': 'emailed',
+            'viewed deal': 'viewed',
+            'viewed': 'viewed',
+            'interested': 'interested',
+            'diligence': 'diligence',
+            'committed': 'committed',
+            'money in the bank': 'invested',
+            'invested': 'invested',
+            'passed': 'passed',
+        }
+        
+        # Normalize status if provided
+        if status:
+            status_lower = status.lower().strip()
+            normalized_status = status_mapping.get(status_lower, status_lower)
+            status = normalized_status
+        
+        # Investor (nested) fields
+        for key, value in [
+            ("firstName", firstName),
+            ("lastName", lastName),
+            ("email", email),
+            ("phone", phone),
+            ("location", location),
+            ("type", type),
+            ("title", title),
+            ("organizationName", organizationName),
+            ("organizationWebsite", organizationWebsite),
+            ("linkedIn", linkedIn),
+            ("twitter", twitter),
+            ("crunchbase", crunchbase),
+            ("angelList", angelList),
+            ("investmentRangeFrom", investmentRangeFrom),
+            ("investmentRangeTo", investmentRangeTo),
+            ("investmentSweetSpot", investmentSweetSpot),
+            ("fundSize", fundSize),
+            ("preferredAssetClass", preferredAssetClass),
+            ("prefferedCompanyTraction", prefferedCompanyTraction),
+            ("preferredGeographicInvestmentFocus", preferredGeographicInvestmentFocus),
+            ("gender", gender),
+            ("bio", bio),
+            ("relevantPortfolioCompanies", relevantPortfolioCompanies),
+        ]:
+            if value not in (None, ""):
+                investorFields[key] = value
+        
+        if leadsInvestments is not None:
+            investorFields["leadsInvestments"] = leadsInvestments
+        if focusStages is not None:
+            investorFields["focusStages"] = focusStages
+        if industriesOfInterest is not None:
+            investorFields["industriesOfInterest"] = industriesOfInterest
+        if industriesNotInterestedIn is not None:
+            investorFields["industriesNotInterestedIn"] = industriesNotInterestedIn
+        if tags is not None:
+            # Tags are stored as a top-level field on the target investor document.
+            # Ensure we only send valid, non-empty string tags
+            if isinstance(tags, list):
+                cleaned_tags = []
+                for tag in tags:
+                    if tag is None:
+                        continue
+                    if isinstance(tag, str):
+                        stripped = tag.strip()
+                        if stripped:
+                            cleaned_tags.append(stripped)
+                    else:
+                        # If tag is not a string, convert to string
+                        stripped = str(tag).strip()
+                        if stripped:
+                            cleaned_tags.append(stripped)
+                fields["tags"] = cleaned_tags
+            else:
+                # If single string provided by mistake, wrap it
+                fields["tags"] = [str(tags).strip()] if str(tags).strip() else []
+        
+        # Top-level fields
+        # Status is already normalized above, use it directly
+        # IMPORTANT: Always set dealId/dealUuid if resolved, even if empty string (to clear existing deal)
+        if resolved_deal_id:
+            fields["dealId"] = resolved_deal_id
+        elif dealId:
+            fields["dealId"] = dealId
+        
+        if resolved_deal_uuid:
+            fields["dealUuid"] = resolved_deal_uuid
+        elif dealUuid:
+            fields["dealUuid"] = dealUuid
+        
+        # Other top-level fields
+        for key, value in [
+            ("status", status),
+            ("grade", grade),
+            ("amount", amount),
+            ("paymentMethod", paymentMethod),
+            ("potentialIntroductionName", potentialIntroductionName),
+            ("potentialIntroduction", potentialIntroduction),
+            ("potentialIntroductionLinkedin", potentialIntroductionLinkedin),
+            ("notes", notes),
+            ("feedback", feedback),
+            ("sourceUserId", sourceUserId),
+        ]:
+            if value not in (None, ""):
+                fields[key] = value
+        
+        # Handle introductionPaths array (takes precedence over individual fields)
+        if introductionPaths is not None:
+            # Validate and clean introduction paths
+            cleaned_paths = []
+            for path in introductionPaths:
+                cleaned_path = {}
+                if isinstance(path, dict):
+                    if path.get("name"):
+                        cleaned_path["name"] = path["name"]
+                    if path.get("email"):
+                        cleaned_path["email"] = path["email"]
+                    if path.get("linkedin"):
+                        cleaned_path["linkedin"] = path["linkedin"]
+                    # Respect primary flag from path dict, or use setAsPrimaryIntroduction if provided
+                    if path.get("primary") is not None:
+                        cleaned_path["primary"] = bool(path["primary"])
+                    elif setAsPrimaryIntroduction is not None and len(cleaned_paths) == 0:
+                        # Only apply setAsPrimaryIntroduction to first path if not already set
+                        cleaned_path["primary"] = bool(setAsPrimaryIntroduction)
+                    if cleaned_path:  # Only add if path has at least one field
+                        cleaned_paths.append(cleaned_path)
+            if cleaned_paths:
+                fields["introductionPaths"] = cleaned_paths
+        # Auto-convert legacy introduction fields to introductionPaths if not already set
+        elif (potentialIntroductionName or potentialIntroduction or potentialIntroductionLinkedin):
+            # Build introduction path from legacy fields
+            intro_path = {}
+            
+            # Clean and handle potentialIntroductionName (strip whitespace, non-breaking spaces, etc.)
+            if potentialIntroductionName:
+                cleaned_name = potentialIntroductionName.strip().replace('\xa0', ' ').strip()
+                if cleaned_name:
+                    intro_path["name"] = cleaned_name
+            
+            # Handle potentialIntroduction - could be name or email
+            if potentialIntroduction:
+                cleaned_intro = potentialIntroduction.strip().replace('\xa0', ' ').strip()
+                if cleaned_intro:
+                    # Check if it looks like an email
+                    if '@' in cleaned_intro:
+                        intro_path["email"] = cleaned_intro
+                    else:
+                        # If no name set yet, use this as name
+                        if not intro_path.get("name"):
+                            intro_path["name"] = cleaned_intro
+                        else:
+                            # If name already set, assume this is email
+                            intro_path["email"] = cleaned_intro
+            
+            # Extract email from notes if present (e.g., "Email: megan@googl.com")
+            if notes and not intro_path.get("email"):
+                import re
+                email_match = re.search(r'[Ee]mail:\s*([^\s,]+@[^\s,]+)', notes)
+                if email_match:
+                    intro_path["email"] = email_match.group(1).strip()
+            
+            if potentialIntroductionLinkedin:
+                cleaned_linkedin = potentialIntroductionLinkedin.strip().replace('\xa0', ' ').strip()
+                if cleaned_linkedin:
+                    intro_path["linkedin"] = cleaned_linkedin
+            
+            # Only set primary if user explicitly requested it
+            # Otherwise, let the system decide (first path becomes primary by default)
+            if setAsPrimaryIntroduction is True:
+                intro_path["primary"] = True
+            elif setAsPrimaryIntroduction is False:
+                intro_path["primary"] = False
+            # If setAsPrimaryIntroduction is None, don't set primary field - let system default
+            
+            # Only add if we have at least a name or email
+            if intro_path.get("name") or intro_path.get("email"):
+                fields["introductionPaths"] = [intro_path]
+                logger.info(f"Auto-converted legacy intro fields to introductionPaths: {fields['introductionPaths']}")
+        
+        # Handle noConnections flag
+        if noConnections is not None:
+            fields["noConnections"] = noConnections
+        
+        # Ensure we have something to update
+        if not investorFields and not fields:
+            raise ToolException("Trouble with that request - no fields provided to update")
+        
+        # Use appropriate update endpoint based on collection type
+        if use_tracker:
+            # Update tracker entry - investorFields go to INVESTOR_TRACKER_INVESTORS collection
+            url = API_BASE_URL + "fintaAI/tools/update-tracker-entry"
+            payload = {
+                "data": {
+                    "id": id,
+                    "organizationId": handle,
+                    "sourceUserId": sourceUserId,
+                    "investorFields": investorFields,  # These update INVESTOR_TRACKER_INVESTORS
+                    "fields": fields,  # These update the tracker entry itself
+                }
+            }
+        else:
+            # Update target investor (has nested investorFields)
+            url = API_BASE_URL + "fintaAI/tools/update-target-investor"
+            payload = {
+                "data": {
+                    "id": id,
+                    "organizationId": handle,
+                    "sourceUserId": sourceUserId,
+                    "investorFields": investorFields,
+                    "fields": fields,
+                }
+            }
+        
+        try:
+            # Debug: Log what we're sending
+            if resolved_deal_id:
+                logger.debug(f"DEBUG: Updating dealId to: {resolved_deal_id} (from dealName: {dealName})")
+            elif dealId:
+                logger.debug(f"DEBUG: Updating dealId to: {dealId} (provided directly)")
+            
+            response = requests.post(url, json=payload, timeout=10)
+            response.raise_for_status()
+            result = response.json()
+            
+            collection_name = "tracker entry" if use_tracker else "investor"
+            success_msg = f"Success! {collection_name.capitalize()} updated."
+            if result.get('message'):
+                success_msg += f" {result.get('message')}"
+            
+            # Include deal info in success message if deal was updated
+            if resolved_deal_id or dealId:
+                deal_info = resolved_deal_id if resolved_deal_id else dealId
+                success_msg += f" Deal ID set to: {deal_info}"
+            
+            return success_msg
+        except requests.exceptions.Timeout:
+            raise ToolException("Trouble with that request - the update timed out. Please try again.")
+        except requests.exceptions.HTTPError as e:
+            error_msg = "Trouble with that request"
+            try:
+                error_data = e.response.json()
+                if error_data.get('error'):
+                    error_msg += f": {error_data['error']}"
+            except:
+                if e.response.status_code == 404:
+                    error_msg += " - the contact was not found"
+                elif e.response.status_code == 403:
+                    error_msg += " - not authorized to update this contact"
+                elif e.response.status_code == 400:
+                    error_msg += " - invalid request data"
+                else:
+                    error_msg += f" - server error (status {e.response.status_code})"
+            raise ToolException(error_msg)
+        except requests.exceptions.RequestException as e:
+            raise ToolException(f"Trouble with that request - network error: {str(e)}")
+    
+    except ToolException:
+        # Re-raise ToolException as-is (already has user-friendly message)
+        raise
+    except Exception as e:
+        # Catch any unexpected errors and format them nicely
+        import traceback
+        logger.error(f"Unexpected error in editInvestorTool: {str(e)}", exc_info=True)
+        logger.error(traceback.format_exc())
+        raise ToolException(f"Trouble with that request - unexpected error: {str(e)}")
+
+edit_target_investor_any_fields_tool = StructuredTool.from_function(
+    func=call_edit_target_investor_any_fields,
+    name="EditTargetInvestorAnyFields",
+    description="Given an input of investor information to update, this function updates any fields on a target investor document or tracker entry. Can search by investorName or investorEmail if ID is not provided. Can search for deals by dealName (e.g., 'Seed', 'Series B', 'Custom Terms', or deal nickname) if dealId is not provided. The deal search matches against the full deal title (round, name, and nickname), same as the deal selector in Aurora. Works with both 'target_investors' (manually added investors) and 'investor_tracker' (contacts created when viewing deals) collections. Use investorName parameter (e.g., 'Kevin Siskar') to search if ID unknown. Use dealName parameter (e.g., 'Seed', 'Custom Terms', or deal nickname) when user says 'update deal to Seed' or 'assign to Custom Terms deal'. Use collectionType='investor_tracker' when updating contacts that viewed a deal. IMPORTANT: When there are multiple tracker entries for the same investor (e.g., same person viewed multiple deals), you MUST specify dealName to target a specific entry. If dealName is not specified and multiple entries exist, the tool will ask the user to specify which deal. Note: Investor details (name, organization, email) are stored in a shared document, so updating these fields affects ALL tracker entries for that investor. When user says 'tag [name] as [tag]' or 'add tag [tag]', use the 'tags' parameter with an array (e.g., tags=['Super Angel']). Tags are labels/categories, NOT the same as 'grade' (which is a single rating). Required: investorName or investorEmail or id, plus fields to update (status, email, notes, tags, dealName, etc.).",
+    args_schema=EditTargetInvestorInput,
+    return_direct=False,
+    verbose=True,
+)
+