fix(teams): commit accumulated text only after successful _teams_send

Address Codex P2 finding on PR #88. The previous flow updated
``accumulated`` and ``session.sequence`` BEFORE awaiting ``_teams_send``,
so a 429/network failure mid-stream would leave the partial RawMessage
returned to the caller (and ``session._text`` feeding the final close-
activity) carrying text that Teams never displayed to the user.

Fix:
- Build ``candidate_accumulated = accumulated + text`` and
  ``next_sequence = session.sequence + 1`` as candidates.
- Send the activity with the candidate values.
- Commit ``accumulated`` and ``session.sequence`` only after the send
  succeeds.

The soft-cancel path (logged warn + session.cancel + break) now
genuinely returns the high-water mark of successfully-sent text. Matches
the documented "RawMessage carries pre-failure content" guarantee in
``docs/UPSTREAM_SYNC.md`` non-parity table.

Updated test_emit_send_failure_cancels_session: previously asserted
``result.raw["text"] == "helloworld"`` (which contained the rejected
"world" chunk); now asserts ``"hello"`` and ``session.sequence == 1``.

Skipped Codex P2 #2 (active_streams clobber timing) — matches upstream
TS behavior; deferring fix as a Python-only improvement would be a
divergence and is design-significant. File as follow-up if desired.

23 native-streaming tests pass.

https://claude.ai/code/session_01FyMxQn2BEAzmwKS1GZczKj

Author: claude

src/chat_sdk/adapters/teams/adapter.py

@@ -1141,16 +1141,22 @@ async def _stream_via_emit(
                 if not text:
                     continue
 
-                accumulated += text
+                # Build a CANDIDATE accumulated value — only commit to
+                # ``accumulated`` after a successful ``_teams_send``. If the
+                # send raises (429, network error, etc.) we treat it as a
+                # soft cancel below; the partial ``RawMessage`` returned to
+                # the caller and ``session._text`` (which feeds the final
+                # close-activity) must NOT contain text Teams rejected.
+                candidate_accumulated = accumulated + text
                 # Emit each chunk as an incremental typing activity. We send
                 # the cumulative text (not deltas) — Teams clients render the
                 # latest text on every streaming activity. Matches upstream's
                 # ``stream.emit(text)`` semantics where the SDK accumulates
                 # under the hood and ships the latest snapshot.
-                session.sequence += 1
+                next_sequence = session.sequence + 1
                 channel_data: dict[str, Any] = {
                     "streamType": _STREAM_TYPE_STREAMING,
-                    "streamSequence": session.sequence,
+                    "streamSequence": next_sequence,
                 }
                 # Hazard #7 — only include ``streamId`` once the server has
                 # assigned one. Sending ``"streamId": None`` on the first
@@ -1160,13 +1166,13 @@ async def _stream_via_emit(
 
                 activity_payload: dict[str, Any] = {
                     "type": "typing",
-                    "text": accumulated,
+                    "text": candidate_accumulated,
                     "channelData": channel_data,
                     "entities": [
                         {
                             "type": "streaminfo",
                             "streamType": _STREAM_TYPE_STREAMING,
-                            "streamSequence": session.sequence,
+                            "streamSequence": next_sequence,
                         }
                     ],
                 }
@@ -1177,16 +1183,22 @@ async def _stream_via_emit(
                     # 429 mid-stream is the most common transient — treat
                     # any send failure as a soft cancel: stop emitting,
                     # leave the session canceled so close() won't try to
-                    # finalize, and log. The caller still gets a
-                    # RawMessage with whatever text was already accepted
-                    # so SentMessage history is consistent.
+                    # finalize, and log. ``accumulated`` and
+                    # ``session.sequence`` are NOT updated, so the partial
+                    # RawMessage returned to the caller (and the final
+                    # close activity, if any) only carry text Teams
+                    # actually accepted.
                     self._logger.warn(
                         "Teams stream emit failed; canceling stream",
                         {"threadId": thread_id, "error": str(exc)},
                     )
                     session.cancel()
                     break
 
+                # Send succeeded — commit the accumulated state.
+                accumulated = candidate_accumulated
+                session.sequence = next_sequence
+
                 if session.stream_id is None:
                     chunk_id = result.get("id") or ""
                     session.first_chunk_id = chunk_id

tests/test_teams_native_streaming.py

@@ -394,7 +394,17 @@ async def text_gen():
 
     @pytest.mark.asyncio
     async def test_emit_send_failure_cancels_session(self):
-        """A 429 / network error mid-stream cancels the session, no exception."""
+        """A 429 / network error mid-stream cancels the session, no exception.
+
+        What to fix if this fails: ``_stream_via_emit`` must update
+        ``accumulated`` ONLY after a successful ``_teams_send``. If the send
+        raises, ``accumulated`` (and the partial ``RawMessage`` returned to
+        the caller + ``session._text`` feeding the final close-activity)
+        must NOT contain the rejected chunk's text — Teams never displayed
+        it to the user. See ``src/chat_sdk/adapters/teams/adapter.py``
+        around line 1144 (build ``candidate_accumulated`` first, commit
+        only on success).
+        """
         adapter = _make_adapter()
         adapter._teams_send = AsyncMock(
             side_effect=[
@@ -416,9 +426,18 @@ async def text_gen():
         assert session.canceled is True
         # Two attempted sends (first ok, second failed); no third.
         assert adapter._teams_send.await_count == 2
-        # RawMessage carries the accumulated text including the failed-send chunk
-        # (which the user already saw rendered locally).
-        assert result.raw["text"] == "helloworld"
+        # The rejected "world" chunk MUST NOT appear in the partial
+        # RawMessage. Teams never accepted it, so SentMessage history must
+        # match what the user actually saw.
+        assert result.raw["text"] == "hello", (
+            "Partial RawMessage on send failure must contain only "
+            "successfully-sent text. Found 'world' (rejected by Teams) "
+            "in the result, indicating accumulated was updated before "
+            "the send confirmed."
+        )
+        # session.sequence stays at 1 (first send incremented it; second
+        # didn't because it failed before commit).
+        assert session.sequence == 1
 
     @pytest.mark.asyncio
     async def test_cancelled_error_propagates_and_marks_session_canceled(self):