Python: Fix structured-output corruption by joining Message.text without spaces

python/packages/core/agent_framework/_types.py

@@ -1757,9 +1757,17 @@ def text(self) -> str:
         """Returns the text content of the message.
 
         Remarks:
-            This property concatenates the text of all TextContent objects in Content.
+            Concatenates the text of every ``TextContent`` in :attr:`contents`
+            without inserting any separator. Whatever spacing or punctuation
+            the model produced is already inside the chunks, so the join must
+            not add to it — inserting a space would inject whitespace mid-token
+            (a path like ``"report_lines/sofp.json"`` becomes
+            ``"re port_ lines/sof p.jso n"``) and corrupts structured JSON
+            output downstream. This also matches the separator-free behaviour
+            of ``_coalesce_text_content`` (via ``Content.__add__``), which is
+            applied to streamed responses by ``_finalize_response``.
         """
-        return " ".join(content.text for content in self.contents if content.type == "text")  # type: ignore[misc]
+        return "".join(content.text for content in self.contents if content.type == "text")  # type: ignore[misc]
 
 
 AgentRunInputs = str | Content | Message | Sequence[str | Content | Message]

python/packages/core/tests/core/test_types.py

@@ -733,7 +733,7 @@ def test_chat_message_text():
 def test_chat_message_contents():
     """Test the Message class to ensure it initializes correctly with contents."""
     # Create a Message with a role and multiple contents
-    content1 = Content.from_text("Hello, how are you?")
+    content1 = Content.from_text("Hello, how are you? ")
     content2 = Content.from_text("I'm fine, thank you!")
     message = Message(role="user", contents=[content1, content2])
 
@@ -742,11 +742,40 @@ def test_chat_message_contents():
     assert len(message.contents) == 2
     assert message.contents[0].type == "text"
     assert message.contents[1].type == "text"
-    assert message.contents[0].text == "Hello, how are you?"
+    assert message.contents[0].text == "Hello, how are you? "
     assert message.contents[1].text == "I'm fine, thank you!"
+    # Message.text concatenates without inserting whitespace — any spacing the
+    # model emitted is already inside the chunks.
     assert message.text == "Hello, how are you? I'm fine, thank you!"
 
 
+def test_chat_message_text_concatenates_without_injecting_spaces():
+    """``Message.text`` must concatenate streamed text chunks with no separator.
+
+    When chat responses are streamed the SDK accumulates text deltas as
+    multiple ``TextContent`` blocks. Joining them with a space mid-token
+    corrupts JSON values used for structured output (a path like
+    ``"report_lines/sofp.json"`` becomes ``"re port_ lines/sof p.jso n"``)
+    and breaks any downstream consumer that compares ``message.text`` to a
+    raw model output (logging, telemetry, structured-output parsers).
+    """
+    # Simulate a JSON value split across three streaming deltas — exactly the
+    # shape ``response.value`` and ``response.text`` see when chunks have not
+    # been coalesced.
+    chunks = [
+        Content.from_text(text='{"resp'),
+        Content.from_text(text='onse": "He'),
+        Content.from_text(text='llo"}'),
+    ]
+    message = Message(role="assistant", contents=chunks)
+
+    assert message.text == '{"response": "Hello"}'
+    # And via ``ChatResponse.value``, the structured-output parse round-trips.
+    response = ChatResponse(messages=message, response_format=OutputModel)
+    assert response.value is not None
+    assert response.value.response == "Hello"
+
+
 def test_chat_message_with_chatrole_instance():
     m = Message(role="user", contents=["hi"])
     assert m.role == "user"
@@ -989,7 +1018,10 @@ def test_chat_response_updates_to_chat_response_multiple():
 
     # Check the type and content
     assert len(chat_response.messages) == 1
-    assert chat_response.text == "I'm doing well,  thank you!"
+    # Each chunk contributes its own whitespace; Message.text concatenates without
+    # injecting an extra separator, so the trailing space inside ``message1`` is
+    # the only space between the two segments.
+    assert chat_response.text == "I'm doing well, thank you!"
     assert isinstance(chat_response.messages[0], Message)
     assert len(chat_response.messages[0].contents) == 3
     assert chat_response.messages[0].message_id == "1"
@@ -1027,7 +1059,9 @@ def test_chat_response_updates_to_chat_response_multiple_multiple():
     assert chat_response.messages[0].contents[2].type == "text"
     assert chat_response.messages[0].contents[2].text == "More contextFinal part"
 
-    assert chat_response.text == "I'm doing well, thank you! More contextFinal part"
+    # Message.text skips the reasoning content and concatenates the surviving
+    # text contents directly — no extra separator is inserted between them.
+    assert chat_response.text == "I'm doing well, thank you!More contextFinal part"
 
 
 async def test_chat_response_from_async_generator():

python/packages/core/tests/workflow/test_workflow_agent.py

@@ -541,7 +541,10 @@ async def list_yielding_executor(messages: list[Message], ctx: WorkflowContext[N
         assert isinstance(result, AgentResponse)
         assert len(result.messages) == 3
         texts = [message.text for message in result.messages]
-        assert texts == ["first message", "second message", "third fourth"]
+        # Non-streaming path keeps the two TextContent blocks separate; Message.text
+        # concatenates them without inserting a separator (matching the streaming
+        # path above where coalescing produces the same "thirdfourth").
+        assert texts == ["first message", "second message", "thirdfourth"]
 
     async def test_session_conversation_history_included_in_workflow_run(self) -> None:
         """Test that messages provided to agent.run() are passed through to the workflow."""