fix(teams): scope file delivery to post_message only (upstream fidelity)

The initial port wired filesToAttachments into both post_message AND
edit_message. Upstream vercel/chat wires it into postMessage +
postChannelMessage only — editMessage never carries files. And chinchill
delivers execution artifacts via a fresh post(), never by editing files
into an existing message. Carrying files in edit_message was an
unrequested divergence (and an edit_message+files test has no upstream
counterpart, which the repo's verify_test_fidelity gate would flag).

Revert edit_message to file-free, mirroring upstream. Replace the
edit_message+file test with a fidelity guard asserting edit_message
carries no file attachments. post_message file delivery (the actual
parity fix) is unchanged.

Full suite: 4052 passed. pyrefly clean.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: patrick-chinchill

CHANGELOG.md

@@ -6,11 +6,11 @@ Python-only feature port. No upstream version change.
 
 ### Features
 
-- **Teams now delivers outbound files via base64 data-URI activity attachments** — the Teams adapter previously dropped a `Postable`'s `.files` entirely: `post_message`/`edit_message` never called `extract_files`, so execution artifacts (CSVs, charts, etc.) silently vanished. This ports upstream `vercel/chat`'s `filesToAttachments` (`packages/adapter-teams/src/index.ts` lines ~1006-1035) to Python. A new `TeamsAdapter._files_to_attachments` resolves each `FileUpload`'s bytes via `to_buffer(..., throw_on_unsupported=False)`, base64-encodes them, and builds a Bot Framework attachment `{"contentType", "contentUrl": "data:<mime>;base64,<b64>", "name"}` (mime defaults to `application/octet-stream`); files whose data can't be resolved to bytes are skipped with a debug log (mirrors upstream's `if (!buffer) continue`). `post_message` and `edit_message` now call `extract_files` and attach the results: the adaptive-card branch appends file attachments after the card attachment, and the text branch sets `attachments` to the file attachments when present. This is the Teams half of outbound artifact parity and unblocks chinchill routing execution artifacts to Teams. **Caveat (inherited from upstream's design):** data-URI attachments inline the full file payload base64-encoded in the activity, so large files inflate the Bot Framework payload — the same size constraint upstream carries.
+- **Teams now delivers outbound files via base64 data-URI activity attachments** — the Teams adapter previously dropped a `Postable`'s `.files` entirely: `post_message`/`edit_message` never called `extract_files`, so execution artifacts (CSVs, charts, etc.) silently vanished. This ports upstream `vercel/chat`'s `filesToAttachments` (`packages/adapter-teams/src/index.ts` lines ~1006-1035) to Python. A new `TeamsAdapter._files_to_attachments` resolves each `FileUpload`'s bytes via `to_buffer(..., throw_on_unsupported=False)`, base64-encodes them, and builds a Bot Framework attachment `{"contentType", "contentUrl": "data:<mime>;base64,<b64>", "name"}` (mime defaults to `application/octet-stream`); files whose data can't be resolved to bytes are skipped with a debug log (mirrors upstream's `if (!buffer) continue`). `post_message` now calls `extract_files` and attaches the results: the adaptive-card branch appends file attachments after the card attachment, and the text branch sets `attachments` to the file attachments when present. **Scoped to `post_message` only** — upstream wires `filesToAttachments` into `postMessage`/`postChannelMessage`, NOT `editMessage`, so `edit_message` stays file-free for fidelity (and chinchill delivers artifacts via a fresh `post`, never an edit). This is the Teams half of outbound artifact parity and unblocks chinchill routing execution artifacts to Teams. **Caveat (inherited from upstream's design):** data-URI attachments inline the full file payload base64-encoded in the activity, so large files inflate the Bot Framework payload — the same size constraint upstream carries.
 
 ### Test quality
 
-- Added 5 tests in `tests/test_teams_adapter.py` (`TestFileAttachments`): text+file, adaptive-card+file (both attachments present), `edit_message`+file, mime-type default to `application/octet-stream`, and the skip-unresolvable-bytes branch. Each delivery test round-trips or asserts the `data:<mime>;base64,...` `contentUrl`, `contentType`, and `name`.
+- Added 5 tests in `tests/test_teams_adapter.py` (`TestFileAttachments`): text+file, adaptive-card+file (both attachments present), mime-type default to `application/octet-stream`, the skip-unresolvable-bytes branch, and a fidelity guard that `edit_message` carries NO file attachments. Each delivery test asserts the `data:<mime>;base64,...` `contentUrl`, `contentType`, and `name`.
 
 ## 0.4.29a2 (2026-05-28)
 

src/chat_sdk/adapters/teams/adapter.py

@@ -1171,14 +1171,18 @@ async def edit_message(
         message_id: str,
         message: AdapterPostableMessage,
     ) -> RawMessage:
-        """Edit an existing Teams message."""
+        """Edit an existing Teams message.
+
+        Note: file delivery is intentionally NOT wired here. Upstream
+        ``vercel/chat`` ports ``filesToAttachments`` into ``postMessage`` and
+        ``postChannelMessage`` only — ``editMessage`` does not carry files — and
+        chinchill delivers execution artifacts via a fresh ``post`` (never by
+        editing files into an existing message). Keeping ``edit_message``
+        file-free preserves upstream fidelity.
+        """
         decoded = self.decode_thread_id(thread_id)
 
-        files = extract_files(message)
-        file_attachments = await self._files_to_attachments(files) if files else []
-
         card = extract_card(message)
-        activity_payload: dict[str, Any]
         if card:
             adaptive_card = card_to_adaptive_card(card)
             activity_payload = {
@@ -1188,7 +1192,6 @@ async def edit_message(
                         "contentType": "application/vnd.microsoft.card.adaptive",
                         "content": adaptive_card,
                     },
-                    *file_attachments,
                 ],
             }
         else:
@@ -1201,8 +1204,6 @@ async def edit_message(
                 "text": text,
                 "textFormat": "markdown",
             }
-            if file_attachments:
-                activity_payload["attachments"] = file_attachments
 
         self._logger.debug(
             "Teams API: updateActivity",

tests/test_teams_adapter.py

@@ -764,7 +764,13 @@ async def test_card_message_with_file(self):
         assert file_att["contentUrl"].startswith("data:image/png;base64,")
 
     @pytest.mark.asyncio
-    async def test_edit_message_with_file(self):
+    async def test_edit_message_does_not_carry_files(self):
+        """Upstream fidelity: ``editMessage`` never delivers files (upstream wires
+        ``filesToAttachments`` into ``postMessage``/``postChannelMessage`` only), and
+        chinchill delivers execution artifacts via a fresh ``post`` — never by editing
+        files into an existing message. A ``PostableMarkdown`` carrying files must edit
+        the text only, with no file attachments on the activity.
+        """
         from chat_sdk.types import FileUpload, PostableMarkdown
 
         adapter = _make_adapter(app_id="test-app-id", logger=_make_logger())
@@ -777,11 +783,11 @@ async def test_edit_message_with_file(self):
         result = await adapter.edit_message(self._thread_id(adapter), "edit-1", message)
 
         payload = adapter._teams_update.call_args.args[2]
-        attachments = payload["attachments"]
-        assert len(attachments) == 1
-        assert attachments[0]["contentType"] == "text/plain"
-        assert attachments[0]["name"] == "note.txt"
-        assert attachments[0]["contentUrl"].startswith("data:text/plain;base64,")
+        assert "attachments" not in payload, (
+            "edit_message must not carry file attachments — outbound file delivery is "
+            f"post_message-only (upstream fidelity); got attachments={payload.get('attachments')!r}"
+        )
+        assert payload["text"] == "updated"
         assert result.id == "edit-1"
 
     @pytest.mark.asyncio