Merge branch 'main' into claude/sync-upstream-release-J7S7H

Author: patrick-chinchill

src/chat_sdk/__init__.py

@@ -67,9 +67,12 @@
 from chat_sdk.logger import ConsoleLogger, Logger, LogLevel
 from chat_sdk.message_history import MessageHistoryCache, MessageHistoryConfig
 from chat_sdk.modals import (
+    ExternalSelect,
+    ExternalSelectElement,
     Modal,
     ModalChild,
     ModalElement,
+    OptionsLoadGroup,
     RadioSelect,
     RadioSelectElement,
     Select,
@@ -78,6 +81,7 @@
     SelectOptionElement,
     TextInput,
     TextInputElement,
+    external_select,
     filter_modal_children,
     is_modal_element,
     modal,
@@ -158,6 +162,7 @@
     ModalResponse,
     ModalSubmitEvent,
     OptionsLoadEvent,
+    OptionsLoadResult,
     PlanUpdateChunk,
     Postable,
     PostableAst,
@@ -296,6 +301,7 @@
     "MessageHistoryCache",
     "MessageHistoryConfig",
     # Modal builders (PascalCase primary — matches source TS SDK)
+    "ExternalSelect",
     "Modal",
     "RadioSelect",
     "Select",
@@ -305,11 +311,14 @@
     "modal",
     "text_input",
     "select",
+    "external_select",
     "select_option",
     "radio_select",
     # Modal types
+    "ExternalSelectElement",
     "ModalChild",
     "ModalElement",
+    "OptionsLoadGroup",
     "RadioSelectElement",
     "SelectElement",
     "SelectOptionElement",
@@ -363,6 +372,7 @@
     "ModalSubmitEvent",
     "OptionsLoadEvent",
     "OptionsLoadHandler",
+    "OptionsLoadResult",
     "PlanUpdateChunk",
     "Postable",
     "PostableAst",

src/chat_sdk/adapters/google_chat/cards.py

@@ -10,6 +10,7 @@
 
 from typing import Any, cast
 
+from chat_sdk.adapters.google_chat.format_converter import GoogleChatFormatConverter
 from chat_sdk.cards import (
     CardChild,
     CardElement,
@@ -18,10 +19,18 @@
 )
 from chat_sdk.shared import card_to_fallback_text as shared_card_to_fallback_text
 from chat_sdk.shared import create_emoji_converter
+from chat_sdk.shared.base_format_converter import parse_markdown
 
 # Convert emoji placeholders in text to GChat format (Unicode).
 convert_emoji = create_emoji_converter("gchat")
 
+_gchat_converter = GoogleChatFormatConverter()
+
+
+def _render_markdown_as_gchat(text: str) -> str:
+    """Parse standard markdown and render as Google Chat formatted text."""
+    return _gchat_converter.from_ast(parse_markdown(text))
+
 
 def card_to_google_card(
     card: CardElement,
@@ -148,25 +157,13 @@ def _convert_child_to_widgets(
         return []
 
 
-def _markdown_to_gchat(text: str) -> str:
-    """Convert standard Markdown formatting to Google Chat formatting.
-
-    **bold** -> *bold*
-    """
-    import re
-
-    return re.sub(r"\*\*(.+?)\*\*", r"*\1*", text)
-
-
 def _convert_text_to_widget(element: dict[str, Any]) -> dict[str, Any]:
     """Convert a text element to a widget."""
-    text = _markdown_to_gchat(convert_emoji(element.get("content", "")))
+    text = _render_markdown_as_gchat(convert_emoji(element.get("content", "")))
 
-    style = element.get("style")
-    if style == "bold":
+    if element.get("style") == "bold":
         text = f"*{text}*"
-    elif style == "muted":
-        # GChat doesn't have muted, use regular text
+    elif element.get("style") == "muted":
         text = convert_emoji(element.get("content", ""))
 
     return {"textParagraph": {"text": text}}
@@ -302,8 +299,8 @@ def _convert_fields_to_widgets(
     return [
         {
             "decoratedText": {
-                "topLabel": _markdown_to_gchat(convert_emoji(field.get("label", ""))),
-                "text": _markdown_to_gchat(convert_emoji(field.get("value", ""))),
+                "topLabel": _render_markdown_as_gchat(convert_emoji(field.get("label", ""))),
+                "text": _render_markdown_as_gchat(convert_emoji(field.get("value", ""))),
             },
         }
         for field in element.get("children", [])

src/chat_sdk/adapters/slack/adapter.py

@@ -52,7 +52,7 @@
 )
 from chat_sdk.emoji import convert_emoji_placeholders, emoji_to_slack, resolve_emoji_from_slack
 from chat_sdk.logger import ConsoleLogger, Logger
-from chat_sdk.modals import ModalElement, SelectOptionElement
+from chat_sdk.modals import ModalElement, OptionsLoadGroup, SelectOptionElement
 from chat_sdk.shared.adapter_utils import extract_card, extract_files
 from chat_sdk.shared.errors import AdapterRateLimitError, AuthenticationError, ValidationError
 from chat_sdk.types import (
@@ -1098,24 +1098,70 @@ def _late_error(t: asyncio.Task[Any]) -> None:
 
         return self._options_load_response(result if result is not None else [])
 
-    def _options_load_response(self, options_list: list[SelectOptionElement]) -> dict[str, Any]:
-        """Serialize ``SelectOptionElement`` entries to a Slack JSON response."""
-        slack_options: list[dict[str, Any]] = []
-        for opt in options_list[:100]:
-            entry: dict[str, Any] = {
-                "text": {"type": "plain_text", "text": opt.get("label", "")},
-                "value": opt.get("value", ""),
+    def _options_load_response(
+        self,
+        result: list[SelectOptionElement] | list[OptionsLoadGroup],
+    ) -> dict[str, Any]:
+        """Serialize a flat option list or grouped option list to a Slack JSON response.
+
+        Mirrors upstream ``optionsLoadResponse``: when the first entry has an
+        ``options`` key it is treated as a list of :class:`OptionsLoadGroup`
+        and rendered as ``option_groups``; otherwise it's a flat list of
+        :class:`SelectOptionElement` rendered as ``options``. Slack's spec is
+        explicit that the two are mutually exclusive (only one may appear in
+        the response body).
+        """
+        # Detect grouped form (TS: ``"options" in result[0]``). A grouped
+        # entry is a dict with an ``options`` list inside it; a flat entry is
+        # a dict with ``label``/``value`` keys.
+        is_groups = (
+            len(result) > 0
+            and isinstance(result[0], dict)
+            and "options" in result[0]
+            and isinstance(result[0].get("options"), list)
+        )
+
+        if is_groups:
+            groups_in = cast("list[OptionsLoadGroup]", result)[:100]
+            slack_groups: list[dict[str, Any]] = []
+            for group in groups_in:
+                group_options = group.get("options", [])[:100]
+                slack_groups.append(
+                    {
+                        # Slack spec: group label is plain_text, max 75 chars.
+                        "label": {"type": "plain_text", "text": group.get("label", "")[:75]},
+                        "options": [self._select_option_to_slack(opt) for opt in group_options],
+                    }
+                )
+            return {
+                "body": json.dumps({"option_groups": slack_groups}),
+                "status": 200,
+                "headers": {"Content-Type": "application/json"},
             }
-            desc = opt.get("description")
-            if desc:
-                entry["description"] = {"type": "plain_text", "text": desc}
-            slack_options.append(entry)
+
+        flat = cast("list[SelectOptionElement]", result)[:100]
         return {
-            "body": json.dumps({"options": slack_options}),
+            "body": json.dumps({"options": [self._select_option_to_slack(opt) for opt in flat]}),
             "status": 200,
             "headers": {"Content-Type": "application/json"},
         }
 
+    @staticmethod
+    def _select_option_to_slack(opt: SelectOptionElement) -> dict[str, Any]:
+        """Convert a :class:`SelectOptionElement` to Slack's option object shape.
+
+        Mirrors upstream ``selectOptionToSlackOption`` — the ``description``
+        key is omitted (not set to ``null``) when not provided.
+        """
+        entry: dict[str, Any] = {
+            "text": {"type": "plain_text", "text": opt.get("label", "")},
+            "value": opt.get("value", ""),
+        }
+        desc = opt.get("description")
+        if desc:
+            entry["description"] = {"type": "plain_text", "text": desc}
+        return entry
+
     # ==================================================================
     # View submission / close
     # ==================================================================
@@ -1605,7 +1651,7 @@ async def _resolve_outgoing_mentions(self, text: str, thread_id: str) -> str:
             return text
         state = self._chat.get_state()
 
-        mention_pattern = re.compile(r"@(\w+)")
+        mention_pattern = re.compile(r"(?<![\w<])@(\w+)")
         mentions: dict[str, list[str]] = {}
 
         for match in mention_pattern.finditer(text):

src/chat_sdk/adapters/slack/format_converter.py

@@ -200,7 +200,7 @@ def flush_text() -> None:
 
     def _convert_mentions_to_slack(self, text: str) -> str:
         """Convert @mentions to Slack format: @name -> <@name>."""
-        return re.sub(r"(?<!<)@(\w+)", r"<@\1>", text)
+        return re.sub(r"(?<![\w<])@(\w+)", r"<@\1>", text)
 
     def _node_to_mrkdwn(self, node: Content) -> str:
         """Convert a single AST node to Slack mrkdwn."""
@@ -215,7 +215,7 @@ def _node_to_mrkdwn(self, node: Content) -> str:
 
         if node_type == "text":
             value = node.get("value", "")
-            return re.sub(r"(?<!<)@(\w+)", r"<@\1>", value)
+            return re.sub(r"(?<![\w<])@(\w+)", r"<@\1>", value)
 
         if node_type == "strong":
             content = "".join(self._node_to_mrkdwn(c) for c in children)

src/chat_sdk/adapters/slack/modals.py

@@ -102,6 +102,8 @@ def _modal_child_to_block(child: ModalChild) -> SlackBlock:
         return _text_input_to_block(child)  # type: ignore[arg-type]
     if child_type == "select":
         return _select_to_block(child)  # type: ignore[arg-type]
+    if child_type == "external_select":
+        return _external_select_to_block(child)  # type: ignore[arg-type]
     if child_type == "radio_select":
         return _radio_select_to_block(child)  # type: ignore[arg-type]
     if child_type == "text":
@@ -179,6 +181,58 @@ def _select_to_block(select: dict[str, Any]) -> SlackBlock:
     }
 
 
+def _external_select_to_block(select: dict[str, Any]) -> SlackBlock:
+    """Convert an :class:`ExternalSelectElement` to a Slack input block with external_select.
+
+    Mirrors upstream ``externalSelectToBlock``. Options are loaded at runtime
+    by an ``onOptionsLoad`` handler — this just emits the placeholder element.
+    Optional fields (``placeholder``, ``min_query_length``, ``initial_option``)
+    are omitted from the output when not set, matching upstream behavior.
+    """
+    element: dict[str, Any] = {
+        "type": "external_select",
+        "action_id": select.get("id", ""),
+    }
+
+    placeholder = select.get("placeholder")
+    if placeholder:
+        element["placeholder"] = {"type": "plain_text", "text": placeholder}
+
+    min_query_length = select.get("min_query_length")
+    # Use ``is not None`` (hazard #1): ``0`` is a valid Slack value meaning
+    # "fire on every keystroke" and must not silently fall back to omitting
+    # the key (which would default to Slack's 3-character minimum).
+    if min_query_length is not None:
+        element["min_query_length"] = min_query_length
+
+    initial_option = select.get("initial_option")
+    if initial_option is not None:
+        # Hazard #1: ``is not None`` (not truthiness) so a hand-constructed
+        # empty dict ``{}`` doesn't silently render as no initial_option,
+        # matching the TS ``if (select.initialOption)`` semantics where
+        # ``{}`` is truthy. Also keeps consistency with the
+        # ``min_query_length is not None`` check above.
+        # Unlike static select, ``initial_option`` is the full
+        # ``{label, value}`` object — the loader hasn't run yet so a value
+        # string would be ambiguous. Mirrors selectOptionToSlackOption.
+        slack_initial: dict[str, Any] = {
+            "text": {"type": "plain_text", "text": initial_option.get("label", "")},
+            "value": initial_option.get("value", ""),
+        }
+        desc = initial_option.get("description")
+        if desc:
+            slack_initial["description"] = {"type": "plain_text", "text": desc}
+        element["initial_option"] = slack_initial
+
+    return {
+        "type": "input",
+        "block_id": select.get("id", ""),
+        "optional": select.get("optional", False),
+        "label": {"type": "plain_text", "text": select.get("label", "")},
+        "element": element,
+    }
+
+
 def _radio_select_to_block(radio_select: dict[str, Any]) -> SlackBlock:
     """Convert a RadioSelectElement to a Slack input block with radio_buttons."""
     limited_options = radio_select.get("options", [])[:10]

src/chat_sdk/chat.py

@@ -21,7 +21,6 @@
 from chat_sdk.channel import ChannelImpl, _ChannelImplConfigWithAdapter
 from chat_sdk.errors import ChatError, LockError
 from chat_sdk.logger import ConsoleLogger, Logger
-from chat_sdk.modals import SelectOptionElement
 from chat_sdk.thread import (
     ThreadImpl,
     _active_chat,
@@ -56,6 +55,7 @@
     ModalSubmitEvent,
     OnLockConflict,
     OptionsLoadEvent,
+    OptionsLoadResult,
     QueueEntry,
     ReactionEvent,
     SlashCommandEvent,
@@ -87,7 +87,7 @@
 ActionHandler = Callable[[ActionEvent], Any]
 OptionsLoadHandler = Callable[
     [OptionsLoadEvent],
-    Awaitable[list[SelectOptionElement] | None] | list[SelectOptionElement] | None,
+    Awaitable[OptionsLoadResult | None] | OptionsLoadResult | None,
 ]
 ModalSubmitHandler = Callable[[ModalSubmitEvent], Any]
 ModalCloseHandler = Callable[[ModalCloseEvent], Any]
@@ -953,7 +953,7 @@ async def process_options_load(
         self,
         event: OptionsLoadEvent,
         options: WebhookOptions | None = None,  # noqa: ARG002 (match upstream signature)
-    ) -> list[SelectOptionElement] | None:
+    ) -> OptionsLoadResult | None:
         """Process an options-load event (external-select suggestion lookup).
 
         Runs specific-action-ID handlers before catch-all handlers and returns