feat(chat): add People API sender resolution, rich links, threads, and reactions

Resolves several gaps in the Google Chat tools:

**Sender resolution via People API:**
- Chat API doesn't return displayName for service account access
- New `_resolve_sender()` uses People API to look up user IDs
- In-memory cache avoids repeated lookups
- get_messages and search_messages now use `require_multiple_services`
  to inject both chat and people services

**Rich link (smart chip) extraction:**
- When users paste Workspace URLs that render as smart chips, the URL
  is stripped from the `text` field and only available in annotations
- New `_extract_rich_links()` extracts RICH_LINK annotation URIs
- Surfaced as `[linked: <url>]` in get_messages and search_messages

**Thread support:**
- get_messages shows `[thread: ...]` for threaded replies
- send_message gains `thread_name` param for replying in existing threads
  using `messageReplyOption=REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD`
- Fixes existing `thread_key` param which was missing messageReplyOption

**Emoji reactions:**
- get_messages shows `[reactions: 👍x3, 🎉x1]` from emojiReactionSummaries
- New `create_reaction` tool to add emoji reactions to messages

Author: drewgillson

gchat/chat_tools.py

@@ -6,17 +6,87 @@
 
 import logging
 import asyncio
-from typing import Optional
+from typing import Dict, List, Optional
 
 from googleapiclient.errors import HttpError
 
 # Auth & server utilities
-from auth.service_decorator import require_google_service
+from auth.service_decorator import require_google_service, require_multiple_services
 from core.server import server
 from core.utils import handle_http_errors
 
 logger = logging.getLogger(__name__)
 
+# In-memory cache for user ID → display name (persists for the process lifetime)
+_sender_name_cache: Dict[str, str] = {}
+
+
+async def _resolve_sender(people_service, sender_obj: dict) -> str:
+    """Resolve a Chat message sender to a display name.
+
+    Fast path: use displayName if the API already provided it.
+    Slow path: look up the user via the People API directory and cache the result.
+    """
+    # Fast path — Chat API sometimes provides displayName directly
+    display_name = sender_obj.get("displayName")
+    if display_name:
+        return display_name
+
+    user_id = sender_obj.get("name", "")  # e.g. "users/123456789"
+    if not user_id:
+        return "Unknown Sender"
+
+    # Check cache
+    if user_id in _sender_name_cache:
+        return _sender_name_cache[user_id]
+
+    # Try People API directory lookup
+    # Chat API uses "users/ID" but People API expects "people/ID"
+    people_resource = user_id.replace("users/", "people/", 1)
+    if people_service:
+        try:
+            person = await asyncio.to_thread(
+                people_service.people()
+                .get(resourceName=people_resource, personFields="names,emailAddresses")
+                .execute
+            )
+            names = person.get("names", [])
+            if names:
+                resolved = names[0].get("displayName", user_id)
+                _sender_name_cache[user_id] = resolved
+                return resolved
+            # Fall back to email if no name
+            emails = person.get("emailAddresses", [])
+            if emails:
+                resolved = emails[0].get("value", user_id)
+                _sender_name_cache[user_id] = resolved
+                return resolved
+        except HttpError as e:
+            logger.debug(f"People API lookup failed for {user_id}: {e}")
+        except Exception as e:
+            logger.debug(f"Unexpected error resolving {user_id}: {e}")
+
+    # Final fallback
+    _sender_name_cache[user_id] = user_id
+    return user_id
+
+
+def _extract_rich_links(msg: dict) -> List[str]:
+    """Extract URLs from RICH_LINK annotations (smart chips).
+
+    When a user pastes a Google Workspace URL in Chat and it renders as a
+    smart chip, the URL is NOT in the text field — it's only available in
+    the annotations array as a RICH_LINK with richLinkMetadata.uri.
+    """
+    text = msg.get("text", "")
+    urls = []
+    for ann in msg.get("annotations", []):
+        if ann.get("type") == "RICH_LINK":
+            uri = ann.get("richLinkMetadata", {}).get("uri", "")
+            if uri and uri not in text:
+                urls.append(uri)
+    return urls
+
 
 @server.tool()
 @require_google_service("chat", "chat_read")
@@ -63,10 +133,14 @@ async def list_spaces(
 
 
 @server.tool()
-@require_google_service("chat", "chat_read")
 @handle_http_errors("get_messages", service_type="chat")
+@require_multiple_services([
+    {"service_type": "chat", "scopes": "chat_read", "param_name": "chat_service"},
+    {"service_type": "people", "scopes": "contacts_read", "param_name": "people_service"},
+])
 async def get_messages(
-    service,
+    chat_service,
+    people_service,
     user_google_email: str,
     space_id: str,
     page_size: int = 50,
@@ -81,12 +155,12 @@ async def get_messages(
     logger.info(f"[get_messages] Space ID: '{space_id}' for user '{user_google_email}'")
 
     # Get space info first
-    space_info = await asyncio.to_thread(service.spaces().get(name=space_id).execute)
+    space_info = await asyncio.to_thread(chat_service.spaces().get(name=space_id).execute)
     space_name = space_info.get("displayName", "Unknown Space")
 
     # Get messages
     response = await asyncio.to_thread(
-        service.spaces()
+        chat_service.spaces()
         .messages()
         .list(parent=space_id, pageSize=page_size, orderBy=order_by)
         .execute
@@ -98,13 +172,33 @@ async def get_messages(
 
     output = [f"Messages from '{space_name}' (ID: {space_id}):\n"]
     for msg in messages:
-        sender = msg.get("sender", {}).get("displayName", "Unknown Sender")
+        sender = await _resolve_sender(people_service, msg.get("sender", {}))
         create_time = msg.get("createTime", "Unknown Time")
         text_content = msg.get("text", "No text content")
         msg_name = msg.get("name", "")
 
         output.append(f"[{create_time}] {sender}:")
         output.append(f"  {text_content}")
+        rich_links = _extract_rich_links(msg)
+        for url in rich_links:
+            output.append(f"  [linked: {url}]")
+        # Show thread info if this is a threaded reply
+        thread = msg.get("thread", {})
+        if msg.get("threadReply") and thread.get("name"):
+            output.append(f"  [thread: {thread['name']}]")
+        # Show emoji reactions
+        reactions = msg.get("emojiReactionSummaries", [])
+        if reactions:
+            parts = []
+            for r in reactions:
+                emoji = r.get("emoji", {})
+                symbol = emoji.get("unicode", "")
+                if not symbol:
+                    ce = emoji.get("customEmoji", {})
+                    symbol = f":{ce.get('uid', '?')}:"
+                count = r.get("reactionCount", 0)
+                parts.append(f"{symbol}x{count}")
+            output.append(f"  [reactions: {', '.join(parts)}]")
         output.append(f"  (Message ID: {msg_name})\n")
 
     return "\n".join(output)
@@ -119,21 +213,31 @@ async def send_message(
     space_id: str,
     message_text: str,
     thread_key: Optional[str] = None,
+    thread_name: Optional[str] = None,
 ) -> str:
     """
     Sends a message to a Google Chat space.
 
+    Args:
+        thread_name: Reply in an existing thread by its resource name (e.g. spaces/X/threads/Y).
+        thread_key: Reply in a thread by app-defined key (creates thread if not found).
+
     Returns:
         str: Confirmation message with sent message details.
     """
     logger.info(f"[send_message] Email: '{user_google_email}', Space: '{space_id}'")
 
     message_body = {"text": message_text}
 
-    # Add thread key if provided (for threaded replies)
     request_params = {"parent": space_id, "body": message_body}
-    if thread_key:
-        request_params["threadKey"] = thread_key
+
+    # Thread reply support
+    if thread_name:
+        message_body["thread"] = {"name": thread_name}
+        request_params["messageReplyOption"] = "REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD"
+    elif thread_key:
+        message_body["thread"] = {"threadKey": thread_key}
+        request_params["messageReplyOption"] = "REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD"
 
     message = await asyncio.to_thread(
         service.spaces().messages().create(**request_params).execute
@@ -150,10 +254,14 @@ async def send_message(
 
 
 @server.tool()
-@require_google_service("chat", "chat_read")
 @handle_http_errors("search_messages", service_type="chat")
+@require_multiple_services([
+    {"service_type": "chat", "scopes": "chat_read", "param_name": "chat_service"},
+    {"service_type": "people", "scopes": "contacts_read", "param_name": "people_service"},
+])
 async def search_messages(
-    service,
+    chat_service,
+    people_service,
     user_google_email: str,
     query: str,
     space_id: Optional[str] = None,
@@ -170,7 +278,7 @@ async def search_messages(
     # If specific space provided, search within that space
     if space_id:
         response = await asyncio.to_thread(
-            service.spaces()
+            chat_service.spaces()
             .messages()
             .list(parent=space_id, pageSize=page_size, filter=f'text:"{query}"')
             .execute
@@ -181,15 +289,15 @@ async def search_messages(
         # Search across all accessible spaces (this may require iterating through spaces)
         # For simplicity, we'll search the user's spaces first
         spaces_response = await asyncio.to_thread(
-            service.spaces().list(pageSize=100).execute
+            chat_service.spaces().list(pageSize=100).execute
         )
         spaces = spaces_response.get("spaces", [])
 
         messages = []
         for space in spaces[:10]:  # Limit to first 10 spaces to avoid timeout
             try:
                 space_messages = await asyncio.to_thread(
-                    service.spaces()
+                    chat_service.spaces()
                     .messages()
                     .list(
                         parent=space.get("name"), pageSize=5, filter=f'text:"{query}"'
@@ -209,7 +317,7 @@ async def search_messages(
 
     output = [f"Found {len(messages)} messages matching '{query}' in {context}:"]
     for msg in messages:
-        sender = msg.get("sender", {}).get("displayName", "Unknown Sender")
+        sender = await _resolve_sender(people_service, msg.get("sender", {}))
         create_time = msg.get("createTime", "Unknown Time")
         text_content = msg.get("text", "No text content")
         space_name = msg.get("_space_name", "Unknown Space")
@@ -218,6 +326,43 @@ async def search_messages(
         if len(text_content) > 100:
             text_content = text_content[:100] + "..."
 
-        output.append(f"- [{create_time}] {sender} in '{space_name}': {text_content}")
+        rich_links = _extract_rich_links(msg)
+        links_suffix = "".join(f" [linked: {url}]" for url in rich_links)
+        output.append(f"- [{create_time}] {sender} in '{space_name}': {text_content}{links_suffix}")
 
     return "\n".join(output)
+
+
+@server.tool()
+@require_google_service("chat", "chat_write")
+@handle_http_errors("create_reaction", service_type="chat")
+async def create_reaction(
+    service,
+    user_google_email: str,
+    message_id: str,
+    emoji_unicode: str,
+) -> str:
+    """
+    Adds an emoji reaction to a Google Chat message.
+
+    Args:
+        message_id: The message resource name (e.g. spaces/X/messages/Y).
+        emoji_unicode: The emoji character to react with (e.g. 👍).
+
+    Returns:
+        str: Confirmation message.
+    """
+    logger.info(f"[create_reaction] Message: '{message_id}', Emoji: '{emoji_unicode}'")
+
+    reaction = await asyncio.to_thread(
+        service.spaces()
+        .messages()
+        .reactions()
+        .create(
+            parent=message_id,
+            body={"emoji": {"unicode": emoji_unicode}},
+        )
+        .execute
+    )
+
+    return f"Reacted with {emoji_unicode} on message {message_id}."