fix: handle Optional[list[str]] in elicitation validation

Fix bug where Union types containing string sequences (like list[str] | None)
were incorrectly rejected by elicitation schema validation.

Changes:
- Updated _is_primitive_field() to check for string sequences in Union types
- Added try-except wrapper to _is_string_sequence() to handle non-class origins
- Added test case for Optional[list[str]] validation

This ensures that optional multi-select enum fields work correctly with the
SEP-1330 implementation.

Author: felixweinberger

src/mcp/server/elicitation.py

@@ -63,10 +63,15 @@ def _is_string_sequence(annotation: type) -> bool:
     """Check if annotation is a sequence of strings (list[str], Sequence[str], etc)."""
     origin = get_origin(annotation)
     # Check if it's a sequence-like type with str elements
-    if origin and issubclass(origin, Sequence):
-        args = get_args(annotation)
-        # Should have single str type arg
-        return len(args) == 1 and args[0] is str
+    if origin:
+        try:
+            if issubclass(origin, Sequence):
+                args = get_args(annotation)
+                # Should have single str type arg
+                return len(args) == 1 and args[0] is str
+        except TypeError:
+            # origin is not a class, so it can't be a subclass of Sequence
+            pass
     return False
 
 
@@ -80,8 +85,10 @@ def _is_primitive_field(annotation: type) -> bool:
     origin = get_origin(annotation)
     if origin is Union or origin is types.UnionType:
         args = get_args(annotation)
-        # All args must be primitive types or None
-        return all(arg is types.NoneType or arg in _ELICITATION_PRIMITIVE_TYPES for arg in args)
+        # All args must be primitive types, None, or string sequences
+        return all(
+            arg is types.NoneType or arg in _ELICITATION_PRIMITIVE_TYPES or _is_string_sequence(arg) for arg in args
+        )
 
     return False
 

tests/server/fastmcp/test_elicitation.py

@@ -233,6 +233,28 @@ async def multiselect_callback(context: RequestContext[ClientSession, Any], para
 
     await call_tool_and_assert(mcp, multiselect_callback, "valid_multiselect_tool", {}, "Name: Test, Tags: tag1, tag2")
 
+    # Test Optional[list[str]] for optional multi-select enum
+    class OptionalMultiSelectSchema(BaseModel):
+        name: str = Field(description="Name")
+        tags: list[str] | None = Field(default=None, description="Optional tags")
+
+    @mcp.tool(description="Tool with optional list[str] field")
+    async def optional_multiselect_tool(ctx: Context[ServerSession, None]) -> str:
+        result = await ctx.elicit(message="Please provide optional tags", schema=OptionalMultiSelectSchema)
+        if result.action == "accept" and result.data:
+            tags_str = ", ".join(result.data.tags) if result.data.tags else "none"
+            return f"Name: {result.data.name}, Tags: {tags_str}"
+        return f"User {result.action}"
+
+    async def optional_multiselect_callback(context: RequestContext[ClientSession, Any], params: ElicitRequestParams):
+        if "Please provide optional tags" in params.message:
+            return ElicitResult(action="accept", content={"name": "Test", "tags": ["tag1", "tag2"]})
+        return ElicitResult(action="decline")
+
+    await call_tool_and_assert(
+        mcp, optional_multiselect_callback, "optional_multiselect_tool", {}, "Name: Test, Tags: tag1, tag2"
+    )
+
 
 @pytest.mark.anyio
 async def test_elicitation_with_default_values():