Treat str in an output_type list the same as in a union

Author: DouweM

pydantic_ai_slim/pydantic_ai/_output.py

@@ -173,17 +173,25 @@ def build(
             return None
 
         multiple = False
+        allow_text_output = False
 
         output_types_or_markers: Sequence[SimpleOutputTypeOrMarker[OutputDataT]]
         if isinstance(output_type, Sequence):
             output_types_or_markers = output_type
-            multiple = True
+            if str in output_types_or_markers:
+                allow_text_output = True
+                output_types_or_markers = [t for t in output_types_or_markers if t is not str]
+            if len(output_types_or_markers) > 1:
+                multiple = True
         else:
             output_types_or_markers = [output_type]
 
-        allow_text_output = False
         tools: dict[str, OutputTool[OutputDataT]] = {}
         for output_type_or_marker in output_types_or_markers:
+            if output_type_or_marker is str:
+                allow_text_output = True
+                continue
+
             tool_name = name
             tool_description = description
             tool_strict = strict
@@ -293,6 +301,7 @@ def __init__(
             self.function_schema = _function_schema.function_schema(output_type, GenerateToolJsonSchema)
             self.validator = self.function_schema.validator
             json_schema = self.function_schema.json_schema
+            json_schema['description'] = self.function_schema.description
         else:
             type_adapter: TypeAdapter[Any]
             if _utils.is_model_like(output_type):

tests/test_agent.py

@@ -390,8 +390,8 @@ def test_response_tuple():
 
 @pytest.mark.parametrize(
     'input_union_callable',
-    [lambda: Union[str, Foo], lambda: Union[Foo, str], lambda: str | Foo, lambda: Foo | str],
-    ids=['Union[str, Foo]', 'Union[Foo, str]', 'str | Foo', 'Foo | str'],
+    [lambda: Union[str, Foo], lambda: Union[Foo, str], lambda: str | Foo, lambda: Foo | str, lambda: [Foo, str]],
+    ids=['Union[str, Foo]', 'Union[Foo, str]', 'str | Foo', 'Foo | str', '[Foo, str]'],
 )
 def test_response_union_allow_str(input_union_callable: Callable[[], Any]):
     try: