Meeting prep agents that act on-behalf-of your users

def get_external_meetings():
    account_id = _ensure_active_account()

    events = []
    page_token = None
    while True:
        resp = client.actions.execute_tool(
            tool_name="googlecalendar_list_events",
            identifier=USER_ID,
            connected_account_id=account_id,
            tool_input={"time_min": time_min, "time_max": time_max, "max_results": 50},
        )
        data = resp.data or {}
        events.extend(data.get("events", []))
        page_token = data.get("next_page_token")
        if not page_token:
            break

    external = []
    for e in events:
        if not _is_external_meeting(e):
            continue
        external.append({
            "title": e.get("summary", "(No title)"),
            "start": e["start"]["dateTime"],
            "external_attendees": emails,
        })
    return external

def lookup_contact(email):
    account_id = _ensure_active_account()
    domain = email.rsplit("@", 1)[-1]

    data = client.actions.execute_tool(
        tool_name="hubspot_contacts_search",
        identifier=USER_ID,
        connected_account_id=account_id,
        tool_input={
            "query": email,
            "properties": ["firstname", "lastname", "email", "company", "hs_object_id"],
        },
    ).data or {}

    if data.get("total", 0) > 0:
        props = data["results"][0].get("properties", {}) or {}
        return {
            "source": "contact",
            "firstname": props.get("firstname", ""),
            "company": props.get("company") or _company_by_domain(account_id, domain),
            "hubspot_url": f"https://app.hubspot.com/contacts/{hs_id}",
        }

    company = _company_by_domain(account_id, domain)
    if company:
        return {"source": "company", "company": company, "domain": domain}
    return {"source": "not_found", "domain": domain}

def lookup_gmail_threads(email, domain):
    account_id = _ensure_active_account()

    messages = client.actions.execute_tool(
        tool_name="gmail_fetch_mails",
        identifier=USER_ID,
        connected_account_id=account_id,
        tool_input={"query": f"from:{email} OR from:{domain}", "max_results": 10},
    ).data.get("messages", [])

    threads = []
    for msg in messages:
        thread_id = msg.get("threadId", "")
        if not thread_id or thread_id in seen:
            continue
        thread_messages = client.actions.execute_tool(
            tool_name="gmail_get_thread_by_id",
            identifier=USER_ID,
            connected_account_id=account_id,
            tool_input={"thread_id": thread_id},
        ).data.get("messages", [])
        threads.append({
            "subject": subject, "sender": sender, "date": date,
            "snippets": [m.get("snippet", "") for m in thread_messages],
        })
    return threads

def find_company_in_slack(company_name):
    if not company_name:
        return None

    account_id = _ensure_active_account()
    needle = _normalize(company_name)
    channels = client.actions.execute_tool(
        tool_name="slack_list_channels",
        identifier=USER_ID,
        connected_account_id=account_id,
        tool_input={"types": "private_channel,public_channel", "limit": 1000},
    ).data.get("channels", [])

    match = next((ch for ch in channels if needle in _normalize(ch.get("name", ""))), None)
    if not match:
        return None

    messages = client.actions.execute_tool(
        tool_name="slack_fetch_conversation_history",
        identifier=USER_ID,
        connected_account_id=account_id,
        tool_input={"channel": match["id"], "limit": 20},
    ).data.get("messages", [])

    return {
        "channel_name": match.get("name", ""),
        "messages": [_strip_user_mentions(m.get("text", "")) for m in messages],
    }

def generate_brief(context):
    client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
    prompt = PROMPT_TEMPLATE.format(
        context_json=json.dumps(context, indent=2, default=str),
    )

    message = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1500,
        messages=[{"role": "user", "content": prompt}],
    )
    return message.content[0].text

# Prompt enforces: Quick Facts · Email History · Slack Context · Talking Points

def deliver_brief(meeting_title, brief, contact_name, company_name, meeting_date):
    header = f"Brief for {company_name} - {contact_name} - {meeting_date}"
    print("\n" + divider + "\n" + header + "\n" + divider + "\n" + brief)

    account_id = _ensure_active_account()
    slack_text = (
        f"*Meeting brief:* {meeting_title} ({meeting_date})\n"
        f"_Contact: {contact_name} · Company: {company_name}_\n\n"
        f"{brief}"
    )
    client.actions.execute_tool(
        tool_name="slack_send_message",
        identifier=USER_ID,
        connected_account_id=account_id,
        tool_input={"channel": SLACK_CHANNEL_ID, "text": slack_text},
    )