feat(teams): native streaming for DMs via emit (vercel/chat#416)

[patrick-chinchill]

Summary

Ports upstream vercel/chat#416 (commit ed46bae) — feat(adapter-teams): native streaming for DMs via emit — into the Python Teams adapter.

DM threads now dispatch chunks through the Bot Framework streaming protocol (typing activities with channelData.streamType=streaming + streamSequence, then a final message activity with streamType=final) instead of routing through Thread._fallback_stream. Group chats / channels accumulate the stream and post a single message — matching upstream's post-#416 behavior of avoiding the post+edit flicker where Teams doesn't support native streaming.

Wire format

• First chunk: typing activity with channelData.streamType=streaming + channelData.streamSequence=1. streamId is omitted from both channelData and the streaminfo entity (server hasn't assigned one yet).
• Subsequent chunks: streamId (captured from the first send's REST response) appears on BOTH channelData and the streaminfo entity, per the Bot Framework streaming contract.
• Final activity: message (not typing), streamType=final, with streamId on both channelData and the streaminfo entity.

Throttling

Teams' streaming endpoint enforces ~1 request/second; Microsoft recommends 1.5-2s buffering. The emit loop gates per-chunk sends on a configurable throttle window:

• New TeamsAdapterConfig.native_stream_min_emit_interval_ms (default 1500ms)
• Honors StreamOptions.update_interval_ms per-call (e.g. from a StreamingPlan)
• Chunks within the window are accumulated locally; the next eligible chunk ships the cumulative text snapshot
• End-of-stream flush: when the iterator ends, any buffered text that wasn't shipped in an intermediate emit is force-flushed via one final typing activity. Without this, buffered text would only ship in the close-path message activity and a close-path failure would leave Thread.stream recording text Teams never accepted.

Send-failure contract (re-raise)

A _teams_send failure mid-stream (429, network error) cancels the session, logs at warn, and re-raises. Thread.stream's outer accumulator builds the SentMessage from each chunk before yielding to the adapter — re-raising short-circuits the post-stream history append so the SDK's record matches what the user actually saw via prior accepted typing activities. Same contract applies to the end-of-stream flush.

The close-path final message activity is allowed to fail-soft: by the time it runs, every byte of session.text was confirmed-accepted via the flush, so a failure here is a stale-streaming-UI cost (until client timeout) rather than a recording inconsistency.

Lifecycle (hazard #5: async task lifecycle)

• _handle_message_activity registers a _TeamsStreamSession for DMs and awaits the chat handler so the session stays alive through stream(). The handler is fire-and-forget for non-DM threads.
• _stream_via_emit emits cumulative text per chunk; streamId is captured from the first send and threaded through all subsequent activities.
• _close_stream_session posts the final activity. Skipped on cancellation or zero-chunk streams (no orphan finalizers).
• Iterator and send exceptions cancel the session and propagate to the caller.

Documentation

docs/UPSTREAM_SYNC.md:

• Scoped existing "Fallback streaming" rows to non-Teams adapters (Teams no longer routes through _fallback_stream after feat(adapter-teams): native streaming for DMs via emit vercel/chat#416).
• New row: hand-rolled Bot Framework streaming wire format is transitional; tracked migration to microsoft-teams-apps (Python SDK, GA 2026-05-01) where IStreamer.emit() handles the wire format internally.
• New row: streamId placement on both channelData and the streaminfo entity (Bot Framework REST contract).
• Group-chat accumulate-and-post divergence row updated.

Migration tracking issue: #93 — Migrate Teams adapter to microsoft-teams-apps. Headlines a 0.4.28 / point release; out of scope for 4.27.0 (SDK only 2 weeks GA, requires Python 3.12 floor bump).

Tests

tests/test_teams_native_streaming.py (33 tests):

• Wire format: first-chunk omits streamId everywhere; subsequent chunks carry streamSequence increments and streamId on channelData; final close activity ships streamType=final.
• streamInfo entity contract: subsequent chunks AND the final activity carry streamId on the streaminfo entity (not just channelData).
• Throttle: in-window chunks coalesce; out-of-window chunks emit individually; StreamOptions.update_interval_ms overrides the adapter default.
• End-of-stream flush: buffered text flushed before return; flush failure propagates; no redundant flush when each chunk already had an emit; cancellation skips the flush.
• Dispatch: DM with active session uses native; DM with no session falls through to accumulate-and-post; channel threads always accumulate-and-post.
• Cancellation: canceled session skips remaining chunks AND the final close activity; close on a never-emitted session is a no-op; close still ships final when first chunk's REST id was empty.
• Errors: iterator exception cancels and re-raises; in-loop send failure cancels and re-raises; flush failure cancels and re-raises.
• Lifecycle: end-to-end webhook → process_message → stream() → _close_stream_session; handler exception with prior partial stream still drops session and ships close.
• Pass-interaction: distinct DM threads each have isolated session state; same-thread overlap test exercises the per-handler isolation deferred-as-out-of-scope path (tracked as Python-only follow-up).

Existing TestStream cases in test_teams_coverage.py and test_teams_extended.py updated for accumulate-and-post on group chats.

Test plan

• uv run ruff check src/ tests/ scripts/
• uv run ruff format --check src/ tests/ scripts/
• uv run python scripts/audit_test_quality.py
• uv run pytest tests/ --tb=short -q — 3,701 pass, 1 pre-existing failure (unrelated to this PR), 2 skipped

Review history (resolved)

Codex P1: streamInfo.streamId placement (subsequent + final activities) → fixed in b29efe0
Codex P1: throttle native emits (Bot Framework 1 req/sec quota) → fixed in b29efe0
Codex P2: re-raise on send failure (was silently corrupting Thread.stream history) → fixed in 86c95db
Codex P2: end-of-stream flush for throttle-buffered text (close-path failure variant of the above) → fixed in 114edde
CodeRabbit nitpick: duplicate final-streaminfo test → consolidated in b9f018e

Deferred Python-only follow-ups (tracked, out of scope for parity sync):

• Per-handler stream session isolation (ContextVar instead of _active_streams[thread_id])
• wait_until callable raising synchronously edge case
• Migration to microsoft-teams-apps SDK (issue Migrate Teams adapter to microsoft-teams-apps (official MS Python SDK) #93)

Upstream ref: vercel/chat#416 (commit ed46bae)

https://claude.ai/code/session_01FyMxQn2BEAzmwKS1GZczKj

---

Generated by Claude Code

Summary by CodeRabbit

• New Features

  • Teams direct message streaming now uses native Bot Framework support with configurable throttling interval
  • Teams group chats now accumulate and send streamed text in optimized batches

• Documentation

  • Updated streaming behavior documentation clarifying Teams DM and group chat streaming differences and implementation details

• Tests

  • Added comprehensive tests for Teams streaming behavior including throttling, edge cases, and session lifecycle

[coderabbitai]

Note

Reviews paused

It looks like this branch is under active development. To avoid overwhelming you with review comments due to an influx of new commits, CodeRabbit has automatically paused this review. You can configure this behavior by changing the reviews.auto_review.auto_pause_after_reviewed_commits setting.

Use the following commands to manage reviews:

• @coderabbitai resume to resume automatic reviews.
• @coderabbitai review to trigger a single review.

Use the checkboxes below for quick actions:

• ▶️ Resume reviews
• 🔍 Trigger review

📝 Walkthrough

Walkthrough

Adds native Bot Framework streaming for Teams DMs with per-thread _TeamsStreamSession state; DM webhooks register and keep sessions alive during handler execution; stream() uses native typing emits when a DM session is active and falls back to accumulate-and-post otherwise. Includes finalization, cancellation/error semantics, tests, and docs updates.

Changes

Teams Native Streaming Implementation

Layer / File(s)	Summary
Session State & Data Structure src/chat_sdk/adapters/teams/adapter.py, src/chat_sdk/adapters/teams/types.py	Introduces _TeamsStreamSession, TeamsAdapter._active_streams, and TeamsAdapterConfig.native_stream_min_emit_interval_ms to track per-thread streaming metadata and configure emit throttling.
Stream Dispatch & Webhook Integration src/chat_sdk/adapters/teams/adapter.py	_handle_message_activity registers DM sessions, wraps the caller wait_until with a local completion gate to keep sessions alive without deadlock, ensures cleanup, and stream() now selects native emit when an active uncanceled session exists (group chats stay accumulate-and-post).
Native Streaming Implementation src/chat_sdk/adapters/teams/adapter.py	Adds _stream_via_emit to emit throttled Bot Framework typing activities per chunk with streamSequence and conditional streamId, soft-cancels on send failures, records committed accumulated text after success, and _close_stream_session sends the final message activity (channelData.streamType = "final").
Accumulate-and-Post Fallback src/chat_sdk/adapters/teams/adapter.py	Concatenates non-empty chunk text for non-DM or no-session flows and sends a single markdown message activity (returns empty-text RawMessage for empty streams).
Test Suite: Wire Format, Throttling, Lifecycle & Errors tests/test_teams_native_streaming.py	New tests pin typing-chunk wire format (first chunk omits streamId, subsequent include it), cumulative text behavior, throttling/coalescing, final-message semantics, session lifecycle via webhooks, cancellation and error propagation, and concurrency/registry semantics.
Test Updates: Existing Coverage tests/test_teams_coverage.py, tests/test_teams_extended.py	Strengthened assertions that group-chat streaming accumulates into a single _teams_send (no _teams_update) with concatenated text, and that empty streams skip sending and return empty messages.
Documentation: Streaming Non-Parities docs/UPSTREAM_SYNC.md	Clarified non-Teams whitespace-only fallback behavior (final edit_message(" ") placeholder clear), refined fallback exception/cleanup and final content generation (_remend-repaired final_content), and added Teams-specific rows for group-chat accumulate-and-post, DM native streaming wire-format/throttle/re-raise, streamId placement, and final-send when first chunk id is empty.

Sequence Diagram(s)

sequenceDiagram
  participant Client
  participant Adapter as TeamsAdapter
  participant Bot as BotFramework
  participant Session as _TeamsStreamSession
  Client->>Adapter: stream() / emits chunks
  Adapter->>Bot: send typing activity (first chunk without streamId)
  Bot-->>Adapter: accepted (id)
  Adapter->>Session: record streamId & cumulative text
  Adapter->>Bot: send subsequent typing (include streamId, increment streamSequence)
  Bot-->>Adapter: accepted
  Adapter->>Adapter: _close_stream_session -> send final message (streamType="final")
  Bot-->>Adapter: final accepted

Loading

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~45 minutes

Possibly related issues

• Migrate Teams adapter to microsoft-teams-apps (official MS Python SDK) #93: The PR adds a hand‑rolled native Teams DM streaming implementation which matches the functionality discussed in that issue and may affect plans to migrate to an external Teams streaming solution.

Poem

🐰 I hopped through chunks with a tiny drum beat,

typing lights flickered until the text was complete,
DMs trickled in while groups posted as one,
canceled streams paused, final messages done,
sessions slept softly when the handler was done.

🚥 Pre-merge checks | ✅ 4 | ❌ 1

❌ Failed checks (1 warning)

Check name	Status	Explanation	Resolution
Docstring Coverage	⚠️ Warning	Docstring coverage is 42.86% which is insufficient. The required threshold is 80.00%.	Write docstrings for the functions missing them to satisfy the coverage threshold.

✅ Passed checks (4 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title accurately describes the main change: adding native streaming for Teams DMs via emit mechanism, and includes the upstream reference (vercel/chat#416).
Linked Issues check	✅ Passed	Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check	✅ Passed	Check skipped because no linked issues were found for this pull request.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[gemini-code-assist]

Code Review

This pull request implements native streaming for Microsoft Teams DMs using the Bot Framework protocol, while transitioning group chats and channels to an accumulate-and-post strategy to eliminate UI flicker. It introduces a session management system for tracking in-flight DM streams and includes comprehensive test coverage for the new streaming lifecycle. Feedback suggests simplifying the stream finalization logic by removing a redundant check for empty content, as the presence of a stream ID already implies that content was sent.

[gemini-code-assist]

The check not session._text is redundant here. session.stream_id is only set when a chunk with content is sent, which also guarantees session._text will be non-empty. Therefore, checking for session.stream_id is None is sufficient.

Suggested change

	if session.stream_id is None or not session._text: # noqa: SLF001
	if session.stream_id is None:

[patrick-chinchill]

Code review — feat(teams): native streaming for DMs via emit (vercel/chat#416)

Compared HEAD (58b7fc7, including the follow-up _text-check refactor) to upstream ed46bae at f55378a (packages/adapter-teams/src/index.ts). Walked the porting hazards (especially #5/#7) and the SELF_REVIEW adversarial checks (pass-interaction, emit/parse symmetry, sentinels).

✅ Looks good

• Hazard #7 (omit vs None) is honored: the first chunk's channelData is constructed without a streamId key (if session.stream_id is not None: channel_data["streamId"] = ...), and test_first_chunk_omits_stream_id pins the wire shape with assert "streamId" not in first_payload["channelData"].
• streamSequence starts at 1 and increments per emitted chunk (session.sequence += 1 before building the payload, after the empty-skip), matching the Bot Framework protocol and pinned by test_subsequent_chunks_carry_stream_id_and_increment_sequence.
• DM detection matches upstream byte-for-byte — both Python is_dm and TS isDM use not conversationId.startsWith("19:") (not conversationType == "personal" as the brief implied). Group-chat IDs (19:...@thread.skype) correctly fall through to accumulate-and-post.
• Invariant in the follow-up refactor holds: stream_id is only set after a successful _teams_send AND only when result.get("id") is non-empty (line 1174–1178); empty chunks are skipped before accumulated += text. So stream_id is not None ⇒ _text non-empty. The not session._text check was indeed redundant.
• Cleanup-path safety: the finally in _handle_message_activity uses if current is session before popping (so a concurrent re-registration on the same DM thread isn't clobbered), and _close_stream_session is wrapped in try/except so its failure can't leak the registry entry. Cancel/iterator-exception paths both call session.cancel() before re-raising, so _close_stream_session correctly skips the final activity.
• Soft-cancel-on-send-failure divergence is documented in docs/UPSTREAM_SYNC.md non-parity table with rationale and tested by test_emit_send_failure_cancels_session (verifies no exception bubbles, result.raw["text"] carries pre-failure content).
• Group-chat accumulate-and-post is a parity behavior with upstream post-#416, not a divergence — the doc table row marks it "no divergence at the adapter level" for clarity, which is the right framing.

🟡 Medium

• Concurrent-DM test doesn't exercise _active_streams race — test_two_concurrent_dm_streams_have_independent_sessions constructs two sessions for two distinct thread IDs and calls _stream_via_emit directly with explicit session args, bypassing _active_streams entirely. The realistic race (two near-simultaneous webhooks for the same DM thread overwriting _active_streams[tid]) isn't covered. This race exists in upstream too (activeStreams.set(threadId, ctx.stream) overwrites identically), so it's parity behavior — but the test name oversells what's being verified. Suggest renaming or adding a same-thread test that drives two _handle_message_activity calls under asyncio.gather.
• First-chunk send returns id="": if Teams accepts the typing activity but returns an empty id, session.stream_id stays None (line 1177 guard), _text becomes non-empty, and _close_stream_session skips because of the (now-tightened) stream_id is None check. Net effect: user sees streamed chunks but no final message activity — the streaming UI stays running until Teams times it out client-side. Upstream has the same shape (messageId = "") but would still attempt the final send. Worth a one-line comment at the close-skip site explaining this, and ideally a test pinning the empty-id behavior.

🔵 Nit

• _chained_wait_until invokes upstream_wait_until(task) before _resolve_processing(task). If the caller-supplied wait_until raises, the exception propagates back through process_message, hits the adapter's outer try, and falls into finally (no hang — await processing_done isn't reached). That's fine, but reversing the order — resolve first, then call upstream — would make the deadlock-immunity argument trivially obvious to a future reader.
• _TeamsStreamSession._text is read from outside the class via session._text with # noqa: SLF001 — a public text attribute (or method) would be cleaner since the leading underscore isn't really enforcing privacy.

---

Posted by an automated reviewer agent. https://claude.ai/code/session_01FyMxQn2BEAzmwKS1GZczKj

---

Generated by Claude Code

[patrick-chinchill]

Re-review of fixes in 2e96fbb

Verified the four fixes against ed46bae (vercel/chat#416) and the broader adapter surface.

Verified — fixes land cleanly

1. test_same_thread_concurrent_handlers_clobber_active_stream (tests/test_teams_native_streaming.py:722) — drives two _handle_message_activity tasks for the same thread under a barrier, snapshots the registry post-overlap, and pins [second_session, second_session]. Matches upstream's Map clobber semantics. The renamed test_distinct_dm_threads_each_have_isolated_session_state makes the isolation-vs-race split explicit.
2. Empty-id final-send (adapter.py:1239–1271, test 317–362) — _close_stream_session now ships the final message when text is non-empty even if stream_id is None, omitting streamId from channelData (rather than serializing None — Hazard #7). Regression test asserts "streamId" not in final_payload["channelData"]. Non-parity row at UPSTREAM_SYNC.md:492 is accurate.
3. _chained_wait_until order (adapter.py:462–471) — _resolve_processing(task) runs before upstream_wait_until(task), with a comment explaining the deadlock-immunity argument.
4. Public text property (adapter.py:95–103, 1243, 1260) — read-only text accessor exposed; reads in _close_stream_session go through it; only the canonical mutator at adapter.py:1216 retains # noqa: SLF001. Tests still poke _text directly (lines 176, 300) — fine, they're inside the test module's own laxer scope and lint-clean.

Findings

Nit (parity gap, pre-existing across multiple adapters)
_stream_via_emit and the accumulate-and-post fallback both check isinstance(chunk, dict) and chunk.get("type") == "markdown_text" (adapter.py:1081, 1139). A real MarkdownTextChunk dataclass instance silently drops to "" because isinstance(MarkdownTextChunk(...), dict) is False. Other adapters (google_chat, whatsapp, slack, github) use hasattr(chunk, "type") for this. Same gap exists in discord/linear, so out of scope here, but worth a follow-up issue — the StreamChunk union in types.py:798 is dataclass-typed.

Nit (divergence not in UPSTREAM_SYNC.md)
_chained_wait_until resolves the internal gate before invoking the caller-supplied wait_until. Upstream TS does the opposite (baseOptions?.waitUntil?.(task) first, then task.then(...)). Functionally equivalent (both register callbacks; neither blocks), but it IS a deliberate ordering divergence and the commit message frames it as a hardening defense — consider a one-line entry in the non-parity table so future syncs don't "correct" it back.

Nit (forward-looking)
chained_options = WebhookOptions(wait_until=_chained_wait_until) (adapter.py:473) drops any other fields that may exist on the inbound options. Today WebhookOptions only has wait_until, so no observable bug — but upstream uses {...baseOptions, waitUntil: ...} for a reason. A replace(options, wait_until=...) (or explicit comment "WebhookOptions has only wait_until — re-spread if it grows") would future-proof.

Hunt results — no other issues

• Wire format: streamSequence (1-indexed, ++ per emit), streamType ("streaming"/"final"), streamId (omitted on first chunk + when server returned empty id), parallel streaminfo entity — all match the Bot Framework streaming protocol that upstream's IStreamer emits under the hood.
• Cleanup: try/finally in _handle_message_activity mirrors upstream's try { await processingDone } finally { activeStreams.delete }; asyncio.CancelledError cancels the session and re-raises (covered by test_cancelled_error_propagates_and_marks_session_canceled).
• DM detection: is_dm checks only not conversationId.startswith("19:") — matches thread-id.ts:30 exactly.
• Test fidelity: upstream PR #416 added zero new it() blocks in index.test.ts; only assertion swaps in replay-streaming.test.ts. Python's 23 native-streaming tests + 159 teams-streaming-related tests all pass; no missing TS coverage.
• Hazard #5: no untracked tasks in the new code. process_message tracks via _active_tasks, _chained_wait_until only calls add_done_callback, no bare create_task / ensure_future.

Re-review verdict: PASS

The three nits are real but non-blocking (one is pre-existing, one is hardening with no observable behavior change, one is forward-looking). Fixes for the previous round all landed correctly.

Posted by an automated re-reviewer agent. https://claude.ai/code/session_01FyMxQn2BEAzmwKS1GZczKj

---

Generated by Claude Code

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 2e96fbb242

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 07df4b778b

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[coderabbitai]

Actionable comments posted: 2

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/chat_sdk/adapters/teams/adapter.py`:
- Around line 437-493: _active_streams is keyed only by thread_id causing
concurrent handlers on the same thread to overwrite each other's
_TeamsStreamSession; instead of registering the session in the shared dict and
re-resolving by thread_id, keep the session in handler-local context (e.g. a
ContextVar) or pass the session explicitly into stream-related calls so each
webhook handler uses its own _TeamsStreamSession instance; update code paths
that access _active_streams (creation in this block, stream() consumer, and
cleanup via _close_stream_session) to use the handler-local session, ensure
_chained_wait_until / processing_done still wire to that session, and remove or
restrict shared lookups by thread_id to avoid stale/overwritten sessions.
- Around line 442-478: The webhook can deadlock if Chat.process_message never
creates a task (so _chained_wait_until is never called) because processing_done
remains unresolved; after the call to self._chat.process_message(self,
thread_id, message, chained_options) ensure processing_done is always unblocked
by adding a finally block that (1) catches asyncio.CancelledError around the
await processing_done to call session.cancel() and re-raise, and (2) after the
try/except/cleanup, checks if processing_done.done() is False and calls
processing_done.set_result(None) to guarantee resolution; reference
_resolve_processing, _chained_wait_until, WebhookOptions.wait_until,
processing_done, and self._chat.process_message when applying this change.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro Plus

Run ID: c107c5b6-a50f-47f3-8e14-0ee87262958c

📥 Commits

Reviewing files that changed from the base of the PR and between 04c0658 and 07df4b7.

📒 Files selected for processing (5)

• docs/UPSTREAM_SYNC.md
• src/chat_sdk/adapters/teams/adapter.py
• tests/test_teams_coverage.py
• tests/test_teams_extended.py
• tests/test_teams_native_streaming.py

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 6acc796ae3

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[coderabbitai]

Actionable comments posted: 2

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@tests/test_teams_native_streaming.py`:
- Around line 694-727: The test
test_handler_exception_still_drops_session_and_closes only asserts the session
is removed and never verifies that _close_stream_session (or the final "close"
activity sent via adapter._teams_send) is invoked; update the test to actually
stream at least one chunk before the handler raises and then assert that the
close behavior occurred (e.g., inspect adapter._teams_send calls for a final
close activity or assert a call to _close_stream_session) while still keeping
the check that tid is removed from adapter._active_streams after
adapter._handle_message_activity finishes.
- Around line 607-658: The DM lifecycle block beginning at the comment needs to
be split into its own async pytest test so it doesn't run inside
test_caller_wait_until_raise_does_not_kill_native_streaming; extract the whole
scenario (adapter setup, _dm_thread_id usage, chat/process_message mock,
activity creation, await adapter._handle_message_activity, and assertions) into
a new function decorated with `@pytest.mark.asyncio` and named e.g.
test_dm_session_register_and_finalize (or similar), ensuring you copy the
adapter/_chat setup and AsyncMocking of _teams_send exactly so the new test is
independent and verifies that the session is removed and final stream message is
sent.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro Plus

Run ID: 6f529b35-d50e-4f29-ac4e-834638e406ca

📥 Commits

Reviewing files that changed from the base of the PR and between 6acc796 and 86c95db.

📒 Files selected for processing (2)

• src/chat_sdk/adapters/teams/adapter.py
• tests/test_teams_native_streaming.py

🚧 Files skipped from review as they are similar to previous changes (1)

• src/chat_sdk/adapters/teams/adapter.py

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 86c95dbde8

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Throttle native Teams emits to Teams' quota

For normal LLM/token streams that yield more than once per second, this loop sends one Bot Framework streaming request per chunk. Microsoft’s Teams REST streaming docs state the streaming throttle is 1 request/second and recommend buffering tokens for about 1.5–2 seconds, so native DM streams will quickly hit 429 and cancel mid-response unless chunks are coalesced/throttled before _teams_send (e.g. honoring StreamOptions.update_interval_ms). See https://learn.microsoft.com/microsoftteams/platform/bots/streaming-ux#switch-to-streaming-response.

Useful? React with 👍 / 👎.

[patrick-chinchill]

Fixed in commit b29efe0. The emit loop now gates per-chunk sends on a configurable throttle window:

• New TeamsAdapterConfig.native_stream_min_emit_interval_ms (default 1500ms per Microsoft's 1.5-2s recommendation)
• Honors StreamOptions.update_interval_ms when the caller passes one (e.g. from a StreamingPlan)
• Chunks arriving within the window are accumulated locally and shipped together on the next eligible emit
• Text is never lost: session.text accumulates every chunk regardless of coalescing, and the final message activity ships the full cumulative text — so even if the iterator ends inside a throttle window, the user sees the complete response

Tests in TestNativeStreamingThrottle pin the behavior with a deterministic injectable clock (no real sleeps):

• test_chunks_within_throttle_interval_are_coalesced — fast LLM streams collapse to one emit
• test_chunks_beyond_throttle_interval_emit_individually — slow streams still emit per chunk
• test_caller_update_interval_ms_overrides_default — StreamOptions override works
• test_coalesced_text_ships_in_final_close_activity — regression test that buffered chunks survive in the close path

Long-term: this hand-rolled throttle is documented as transitional in UPSTREAM_SYNC.md. microsoft-teams-apps (Python SDK, GA 2026-05-01) provides IStreamer.emit() which handles throttling internally; migration is planned for 0.4.28 / future Python-only.

---

Generated by Claude Code

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: c18154740c

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: cbf3461225

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Return only emitted text when flush is canceled

When a cancellation arrives during the throttle wait after some chunks were coalesced, this branch skips the flush and the close path also skips the final message because session.canceled is true, so Teams has only seen last_committed_text. Returning accumulated here lets Thread.stream record buffered text that was deliberately not emitted; in this scenario return the last committed text or propagate cancellation instead of committing the unsent suffix.

Useful? React with 👍 / 👎.

[patrick-chinchill]

Good catch — and the same defect existed in the in-loop cancellation path too (the if session.canceled: break at the top of the loop falls through to the same bottom return, so a coalesced chunk that buffered before cancellation would also be returned as RawMessage.raw["text"]).

Fixed in commit 52dc032 with a unified return-text selection at the bottom of _stream_via_emit:

final_text = last_committed_text if session.canceled else accumulated
session._text = final_text
return RawMessage(..., raw={"text": final_text})

Happy-path streams (no cancellation) collapse to accumulated because the flush above commits the final batch, setting last_committed_text == accumulated. Canceled paths surface only what Teams actually accepted, regardless of whether cancellation arrived in-loop or during the flush throttle wait.

Also removed the early-return I'd added in the during-wait branch — the flush just skips the emit on canceled, falls through to the unified return, and the bottom does the right thing.

Tests updated:

• test_flush_skips_emit_if_session_canceled_during_wait now asserts result.raw["text"] == "Hello" (was "Hello world") to pin Codex's contract for the during-wait variant.
• New test_in_loop_cancellation_returns_only_committed_text pins the in-loop variant: yields a chunk, coalesces a second, cancels, then breaks on the next iter's cancel-check; the return must carry only the first emit's text.

Tests: 37 streaming (was 36, +1 new), 218 in the full Teams sweep. Lint + format clean.

---

Generated by Claude Code

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 52dc032cef

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Trim Thread.stream history on canceled native streams

When cancellation happens after a coalesced chunk was yielded, setting final_text to last_committed_text here does not keep normal Thread.stream callers consistent: Thread._handle_stream accumulates each chunk before yielding it to the adapter and then creates the SentMessage from its own accumulated buffer instead of raw_result.raw (src/chat_sdk/thread.py:635-650). Fresh evidence for re-raising this issue: those Thread lines are unchanged, so this new RawMessage text is ignored and a canceled buffered suffix can still be recorded even though Teams never received it.

Useful? React with 👍 / 👎.

[patrick-chinchill]

Right — my prior fix only corrected the adapter-level state. The actual SentMessage body comes from Thread._handle_stream's local accumulated buffer in _wrapped_stream (src/chat_sdk/thread.py:633-654), not from the RawMessage returned by the adapter. Without plumbing the corrected text through, the cancellation defect persisted at the SDK boundary.

Fixed in commit 7809b7e with a two-layer change:

1. RawMessage gains an optional text: str | None = None field — adapter-authoritative override for the recorded text. Adapters whose internal state (cancellation, throttling, partial commits) makes their local-accumulator view diverge from what the platform actually accepted set this; adapters that don't need it leave the default None and Thread.stream falls back to its local accumulator. Backward-compatible by construction.

2. Thread._handle_stream (native-streaming branch) prefers raw_result.text when not None, else uses the local accumulator:

recorded_text = raw_result.text if raw_result.text is not None else accumulated
sent = self._create_sent_message(
    raw_result.id,
    PostableMarkdown(markdown=recorded_text),
    raw_result.thread_id,
)

3. Teams _stream_via_emit sets text=final_text on every returned RawMessage (where final_text = last_committed_text if session.canceled else accumulated). Happy path: override == accumulated, no behavior change. Cancellation paths: override carries only what Teams shipped, Thread.stream records that, the SentMessage and message history match the user's view.

Tests added (4 net new):

• Teams: test_canceled_stream_sets_raw_message_text_override — adapter populates the override on cancellation
• Teams: test_happy_path_stream_also_sets_raw_message_text — symmetry, adapter always sets it
• Thread: test_should_prefer_raw_message_text_override_over_local_accumulator — Thread.stream uses the override when set
• Thread: test_should_fall_back_to_local_accumulator_when_text_override_is_none — backward compatibility for adapters that don't set it

Tests: 39 streaming, 199 in the streaming + thread file pair, 3,709 in the full suite. 1 pre-existing GitHub-adapter failure unrelated. Lint + format clean.

---

Generated by Claude Code

[patrick-chinchill]

Replying to the latest Codex review-summary on 52dc032cef.

Ran a self-review pass over the cancellation-text patch chain (86c95db through 7809b7e) per the adversarial checks in docs/SELF_REVIEW.md. Self-review pass found 2 additional issues; addressed in commits 6964685 and 22a1b7e.

Findings

1. P1 — flush-wait CancelledError leaks past the in-loop guard (src/chat_sdk/adapters/teams/adapter.py:1295-1323 pre-fix). The end-of-stream flush block (_stream_sleep_ms throttle wait + _emit_streaming_activity) sits outside the in-loop try/except (CancelledError, ...) shape that the rest of _stream_via_emit uses. A supervisor-initiated task cancellation that fires while _stream_sleep_ms is awaiting would propagate CancelledError out of the method while session.canceled remained False, violating the invariant the close path relies on ("any exception leaving _stream_via_emit implies session.canceled"). The finally-block close path could then ship a final message activity that the in-loop guard would otherwise have suppressed. Fixed in 6964685 by mirroring the in-loop except (CancelledError, KeyboardInterrupt, SystemExit, GeneratorExit) / except Exception shape around the flush block. Two new regression tests pin both the CancelledError and the generic-exception cases (test_flush_wait_cancelled_error_cancels_session, test_flush_wait_generic_exception_cancels_session).

2. P1 — RawMessage.text divergence not in docs/UPSTREAM_SYNC.md (docs/SELF_REVIEW.md principle 5 — Divergence budget). The new optional text field added to RawMessage in 7809b7e is a Python-only addition (upstream's RawMessage interface at packages/chat/src/types.ts:1285 has only id, raw, threadId). Per the divergence-budget rule, every divergence needs a row in the non-parity table AND a breadcrumb at the code site. Fixed in 22a1b7e by adding the table row under the Teams native streaming cluster (references the existing regression tests at test_should_prefer_raw_message_text_override_over_local_accumulator and test_canceled_stream_sets_raw_message_text_override that would fail if someone "fixes" Thread.stream back to upstream's local-accumulator-only behavior) and a # Divergence from upstream — see docs/UPSTREAM_SYNC.md comment at the field definition.

No defect on the other adversarial checks

• Input sweeps (empty stream / single chunk / iterator-raised CancelledError / update_interval_ms=0 / _stream_clock_ms raising): no leaks beyond the one fixed above.
• Pass-interaction (concurrent streams sharing _stream_clock_ms/_stream_sleep_ms): clock and sleep callables are stateless reads of loop.time() / asyncio.sleep; no cross-stream state.
• Rebind/state coherence: after a successful flush, last_committed_text == accumulated == session._text == RawMessage.text == RawMessage.raw["text"]. After a flush-emit failure _emit_streaming_activity cancels-and-reraises, leaving last_committed_text as the prior accepted text.
• Emit/parse symmetry on RawMessage: dataclass with the new field is optional + kwargs-only at every call site (no 4-arg positional ambiguity); no JSON/pickle/asdict path serializes it.
• Unforgeable sentinels: Thread._handle_stream's raw_result.text if raw_result.text is not None else accumulated correctly distinguishes "" (use empty override) from None (fall back to local accumulator); the all-empty-stream case returns RawMessage(text="") symmetrically with accumulated="".

Validation

uv run ruff format src/ tests/ scripts/    # 194 files unchanged
uv run ruff check src/ tests/ scripts/     # All checks passed
uv run pytest tests/ --tb=short -q         # 3711 passed, 2 skipped, 1 failed

The single failure is the pre-existing tests/test_github_webhook.py::TestGitHubAdapterConstructor::test_throws_when_no_auth that also fails on main (out of scope for this PR).

Pushed as 6964685 (fix) and 22a1b7e (docs) on claude/port-teams-native-dm-streaming-J7S7H.

Posted by an automated self-reviewer agent. https://claude.ai/code/session_01FyMxQn2BEAzmwKS1GZczKj

---

Generated by Claude Code

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 22a1b7e336

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Throttle the final stream activity

For short DM streams, the last successful typing emit can happen immediately before this final message send (for example, a one-chunk response emits in _stream_via_emit, then _handle_message_activity closes the session right away). The Teams streaming REST contract treats the final message as the next streaming API request and documents a 1 request/second quota, so this immediate final call can 429 under the default 1500 ms throttle; because the exception is swallowed below, Teams may never receive the final message while the SDK records the response as sent. Track the last emit time and wait the remaining interval before sending the final activity.

Useful? React with 👍 / 👎.

[patrick-chinchill]

Good catch — same root cause as the in-stream flush throttle (1 req/sec quota), just shifted to the close path. For short DM streams (one chunk emitted at t=0, then immediate close), the final message activity would land within the throttle window of the last typing and 429.

Fixed in commit 0509b3d by plumbing the timestamp + interval through to the close path:

1. _TeamsStreamSession gains two fields:

   • last_emit_at_ms: float = float("-inf") — mirror of the in-loop local, written after each successful emit (in-loop AND flush) so the close path can compute elapsed against it.
   • emit_interval_ms: int | None = None — cache of the per-stream interval set at the top of _stream_via_emit. Honors caller-supplied StreamOptions.update_interval_ms overrides without _close_stream_session needing access to options. None falls back to the adapter default for defensive paths (e.g. sessions constructed manually in tests).

2. _stream_via_emit writes both fields: emit_interval_ms once at the top; last_emit_at_ms after each successful in-loop emit (using now_ms) and after the flush emit (re-reading the clock since the wait may have elapsed real time).

3. _close_stream_session computes elapsed_ms = clock_now - session.last_emit_at_ms and, if less than the interval, awaits _stream_sleep_ms(remaining) before sending the final activity. Supervisor-initiated cancellation during the wait is honored (mark session.canceled + re-raise); session.cancel() arriving from another task is re-checked after the sleep returns and skips the final emit.

6 new regression tests in TestCloseStreamThrottle:

• test_close_waits_for_throttle_window_when_emit_was_recent — pins the wait when last_emit_at_ms is fresh
• test_close_does_not_throttle_when_window_already_elapsed — pins no-wait when window has passed
• test_close_honors_session_interval_override — update_interval_ms=0 propagates through
• test_close_falls_back_to_adapter_default_when_session_interval_unset — defensive: manual sessions
• test_close_does_not_throttle_when_no_emit_happened — defensive: last_emit_at_ms == -inf
• test_close_cancellation_during_wait_skips_final_emit — cancellation invariant during wait

Tests: 47 streaming (was 39, +8 — 6 new close-throttle + 2 from the self-review's earlier flush-wait CancelledError pair), 3,715 in the full suite, 1 pre-existing GitHub-adapter failure unrelated. Lint + format clean.

This closes out the throttle story: in-loop emits, end-of-stream flush, AND the close-path final activity all honor the same 1 req/sec quota.

---

Generated by Claude Code

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 0509b3dd34

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Create a fresh native stream for each DM stream() call

stream() always reuses the thread-scoped _TeamsStreamSession when one is present, so if a single DM handler calls thread.stream() (or thread.post() with a stream) more than once, the second call is sent on the same Teams stream state instead of starting a new message. In this path _stream_via_emit overwrites session._text and returns the original session.first_chunk_id, so later calls can overwrite what the user saw from the first streamed reply while the SDK still records multiple sent messages; this is a behavior regression from the previous per-call post/edit flow.

Useful? React with 👍 / 👎.

[patrick-chinchill]

@codex review

5 commits since the last Codex review (52dc032cef):

• 7809b7e — RawMessage.text override + Thread.stream plumbing
• 6964685 — flush-wait CancelledError/exception cancels session (caught by formal self-review)
• 22a1b7e — RawMessage.text divergence row + code-site breadcrumb
• 0509b3d — close-path final activity throttled against the 1 req/sec quota

Worth fresh eyes on the cancellation-text chain end-to-end (in-loop break, flush throttle wait, close-path throttle wait) and the new RawMessage.text SDK-wide override field — particularly whether anything outside the Teams adapter could legitimately set text="" in a way that diverges from the local accumulator fallback.

---

Generated by Claude Code

[chatgpt-codex-connector]

Codex Review: Didn't find any major issues. Chef's kiss.

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".