fix(chat): enforce ConcurrencyConfig.max_concurrent + release 0.4.26.1

Fixes #51. Upstream TS accepts the config field but never enforces it
(3 writes, 0 reads). Python now uses an asyncio.Semaphore so a consumer
setting `concurrency=ConcurrencyConfig(strategy="concurrent",
max_concurrent=N)` actually gets an N-way cap on in-flight handlers.

Divergence from upstream — Python leads here. The upstream behavior is
documented ("Default: Infinity") but not implemented; our enforcement
matches the documented contract.

Changes:
- `Chat.__init__` constructs `asyncio.Semaphore(max_concurrent)` when the
  value is set and positive, leaves it `None` otherwise (unbounded).
- `_handle_concurrent` acquires the semaphore around `_dispatch_to_handlers`
  when present; falls through to direct dispatch when `None`.
- 2 new tests in `TestConcurrencyConcurrent`:
  - `test_max_concurrent_bounds_in_flight_handlers`: 5 messages with
    `max_concurrent=2`; verifies `max_observed == 2` at any time.
  - `test_max_concurrent_none_allows_unbounded`: 5 concurrent handlers
    without a bound all run in parallel (regression guard for the default).

Release prep for 0.4.26.1:
- Version bump `0.4.26` → `0.4.26.1` in pyproject.toml
- `UPSTREAM_PARITY` stays `4.26.0` (still synced to 4.26.0 upstream;
  no new upstream sync in this release)
- CHANGELOG entry with Fixes / Python-specific / New public APIs /
  Internals / Known gaps sections
- CONTRIBUTING.md version-scheme wording: `.patch` bumps during alpha can
  be additive (fixes + features). Tightens to "fixes-only" once we hit 1.0.

Test plan:
- `uv run ruff check src/ tests/ scripts/` — clean
- `uv run ruff format --check src/ tests/ scripts/` — clean
- `uv run python scripts/audit_test_quality.py` — 0 hard failures
- `uv run pytest tests/ --tb=short -q` — 3471 passed, 2 skipped

Author: patrick-chinchill

CHANGELOG.md

@@ -1,5 +1,75 @@
 # Changelog
 
+## 0.4.26.1 (2026-04-23)
+
+Python-only follow-up on `0.4.26`. Still alpha — APIs may change.
+
+### Fixes
+
+- **Slack native streaming**: `SlackAdapter.stream()` no longer calls
+  `AsyncWebClient.chat_stream(...)` without `await`. The unawaited coroutine
+  returned a truthy object, and the first `streamer.append(...)` raised
+  `AttributeError`, breaking native Slack streaming for any consumer using
+  the default adapter. Issue #44.
+- **Teams divider renders at non-zero height**: empty `Container` with
+  `separator: True` rendered as zero-height in the Teams UI. Dividers
+  between siblings now hoist `separator: True` onto the following element;
+  a trailing divider emits a minimal non-empty Container. Issue #45.
+- **`ConcurrencyConfig.max_concurrent` is now enforced**: consumers setting
+  `concurrency=ConcurrencyConfig(strategy="concurrent", max_concurrent=N)`
+  now actually get an `asyncio.Semaphore(N)` cap on in-flight handlers.
+  Previously the field was accepted and ignored (upstream TS has the same
+  gap). `None` / unset keeps the unbounded default. Issue #51.
+
+### Python-specific (divergence from upstream 4.26)
+
+- **Fallback streaming runtime robustness** (cluster of fixes): framework-
+  agnostic `request.text()` handling now tolerates sync Flask-style
+  requests (was raising `TypeError: object is not awaitable`). Handlers
+  typed `Callable[..., Awaitable[None] | None]` may return sync (`None`) —
+  the dispatcher now `await`s only when `inspect.isawaitable()` confirms,
+  preventing runtime crashes on sync handlers.
+- **`max_concurrent` enforcement** (see above) — upstream accepts the
+  config field but never enforces it; we do.
+
+### New public APIs
+
+- **`Chat.thread(thread_id, *, current_message=None)`**: new worker-
+  reconstruction factory mirroring TS `chat.thread(threadId)`. Adapter is
+  inferred from the thread-ID prefix; state and message history come from
+  the Chat instance. `current_message` is preserved so Slack native
+  streaming still works post-reconstruction. Issue #46.
+- **`SlackAdapter.current_token` / `current_client`**: public `@property`
+  accessors for the request-context-bound bot token and a preconfigured
+  `AsyncWebClient`. Replaces underscore access from consumer code making
+  direct Slack Web API calls inside a handler (email resolution, user
+  profile fetches, etc.). Issue #47.
+
+### Internals
+
+- **Pyrefly: 213 → 0 type errors**; baseline file removed. CI now enforces
+  zero errors. Root causes fixed: 8-adapter `lock_scope: LockScope | None`
+  protocol conformance; `_ChatSingleton` as `Protocol`; submodule-aware
+  `replace-imports-with-any`; `NoReturn` on error re-raisers;
+  `inspect.isawaitable` guards for duck-typed request handling and
+  sync-or-async handler dispatch. No `Any` widening, no new `# type:
+  ignore` lines beyond 10 at adapter event-construction sites where
+  `thread=None`/`channel=None` get re-wrapped by `Chat` before handler
+  dispatch (matches upstream TS's `Omit<>` partial-event pattern).
+- Test count: **3471 passed**, 2 skipped.
+
+### Known gaps (not fixed in this release)
+
+- `onOptionsLoad` handler for dynamic select dropdowns — issue #50
+- `Thread.getParticipants()` method — issue #54
+- `rehydrate_attachment` adapter hook for queue/debounce + attachments —
+  issue #52
+- 40 upstream tests without Python equivalents (Options Load, Plan variants,
+  StreamingPlan options, getParticipants) — issue #53
+- Discord native Gateway WebSocket (HTTP-only today) — issue #57
+- Teams certificate-based mTLS auth — issue #58
+- Google Chat file uploads (TODO upstream too) — issue #59
+
 ## 0.4.26 (2026-04-16)
 
 Synced to [Vercel Chat 4.26.0](https://github.com/vercel/chat).

CONTRIBUTING.md

@@ -58,13 +58,20 @@ All PRs must pass `ruff check` with zero errors.
 Vercel Chat version. See [UPSTREAM_SYNC.md](docs/UPSTREAM_SYNC.md#version-mapping).
 
 - `0.4.25` = synced to upstream `4.25.0`
-- `0.4.25.1` = Python-only fix on top of `4.25.0`
+- `0.4.25.1` = Python-only changes (fixes, and additive features during
+  alpha) between upstream sync points
 - `0.4.26a1` = alpha while porting upstream `4.26.0`
 
+> **Additive changes in `.patch` bumps are OK during alpha**. The package
+> is marked `Development Status :: 3 - Alpha` and the `0.x.y` prefix signals
+> pre-1.0 per semver convention, so new public APIs can land in `.patch`
+> bumps without a version-scheme violation. Once we hit `1.0`, `.patch`
+> should be fixes-only.
+>
 > **Upstream patch releases**: Vercel Chat has historically gone straight to
 > minor bumps, but if upstream ships a patch (e.g. `4.25.1`) we sync it by
 > bumping to the next minor (`0.4.26`). We don't reuse the `.patch` slot for
-> upstream patches — it's reserved for Python-only fixes so the two can't
+> upstream patches — it's reserved for Python-only changes so the two can't
 > collide.
 
 ### Steps

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "chat-sdk"
-version = "0.4.26"
+version = "0.4.26.1"
 description = "Multi-platform async chat SDK for Python — port of Vercel Chat"
 readme = "README.md"
 license = {text = "MIT"}

src/chat_sdk/chat.py

@@ -296,6 +296,19 @@ def __init__(self, config: ChatConfig | None = None, **kwargs: Any) -> None:
             self._concurrency_on_queue_full = concurrency.on_queue_full
             self._concurrency_queue_entry_ttl_ms = concurrency.queue_entry_ttl_ms
 
+        # -- Concurrent-strategy semaphore ------------------------------------
+        # `max_concurrent` bounds in-flight handler dispatches when using the
+        # `"concurrent"` strategy. `None` means unbounded (matches the upstream
+        # TS default of `Infinity`). A non-None value caps parallel handler
+        # runs at that number — useful for rate-limit hygiene and bounded
+        # resource use. Divergence from upstream: upstream accepts the config
+        # field but doesn't enforce it; we do.
+        self._concurrent_semaphore: asyncio.Semaphore | None = (
+            asyncio.Semaphore(self._concurrency_max_concurrent)
+            if self._concurrency_max_concurrent is not None and self._concurrency_max_concurrent > 0
+            else None
+        )
+
         # -- Message history (placeholder -- real impl would use MessageHistoryCache)
         self._message_history = _MessageHistoryCache(self._state_adapter, config.message_history)
 
@@ -1756,7 +1769,15 @@ async def _handle_concurrent(
         thread_id: str,
         message: Message,
     ) -> None:
-        await self._dispatch_to_handlers(adapter, thread_id, message)
+        # Enforce `max_concurrent` bound when configured. Upstream TS
+        # accepts the config field but never enforces it; we do, so that
+        # consumers setting `ConcurrencyConfig(strategy="concurrent",
+        # max_concurrent=N)` actually get a bound of N in-flight handlers.
+        if self._concurrent_semaphore is None:
+            await self._dispatch_to_handlers(adapter, thread_id, message)
+            return
+        async with self._concurrent_semaphore:
+            await self._dispatch_to_handlers(adapter, thread_id, message)
 
     # ========================================================================
     # Dispatch to handlers

tests/test_chat_faithful.py

@@ -2263,6 +2263,102 @@ async def handler(thread, message, context=None):
         assert len(calls) == 1
         assert calls[0] == "Hey @slack-bot concurrent"
 
+    # Python-specific: upstream accepts max_concurrent but doesn't enforce
+    # it. We do. Bound should cap in-flight handlers at N; the (N+1)th
+    # message has to wait until one of the first N releases.
+    async def test_max_concurrent_bounds_in_flight_handlers(self):
+        import asyncio
+
+        state = create_mock_state()
+        adapter = create_mock_adapter("slack")
+
+        chat, _, _ = await _init_chat(
+            adapter=adapter,
+            state=state,
+            concurrency=ConcurrencyConfig(strategy="concurrent", max_concurrent=2),
+        )
+
+        in_flight = 0
+        max_observed = 0
+        gate = asyncio.Event()
+        finished = 0
+
+        @chat.on_mention
+        async def handler(thread, message, context=None):
+            nonlocal in_flight, max_observed, finished
+            in_flight += 1
+            max_observed = max(max_observed, in_flight)
+            await gate.wait()
+            in_flight -= 1
+            finished += 1
+
+        # Dispatch 5 messages concurrently — at most 2 should be in flight
+        # at any time while the gate is closed.
+        tasks = [
+            asyncio.create_task(
+                chat.handle_incoming_message(
+                    adapter,
+                    f"slack:C123:{i}",
+                    create_test_message(f"msg-{i}", "Hey @slack-bot"),
+                )
+            )
+            for i in range(5)
+        ]
+
+        # Let the first two handlers enter and block on the gate.
+        for _ in range(20):
+            await asyncio.sleep(0)
+        assert in_flight == 2
+        assert max_observed == 2
+
+        # Release the gate; all 5 should drain.
+        gate.set()
+        await asyncio.gather(*tasks)
+
+        assert finished == 5
+        # The bound was never exceeded.
+        assert max_observed == 2
+
+    # Python-specific: None / missing max_concurrent must keep the
+    # unbounded behavior (matches upstream TS default of Infinity).
+    async def test_max_concurrent_none_allows_unbounded(self):
+        import asyncio
+
+        state = create_mock_state()
+        adapter = create_mock_adapter("slack")
+
+        chat, _, _ = await _init_chat(adapter=adapter, state=state, concurrency="concurrent")
+
+        in_flight = 0
+        max_observed = 0
+        gate = asyncio.Event()
+
+        @chat.on_mention
+        async def handler(thread, message, context=None):
+            nonlocal in_flight, max_observed
+            in_flight += 1
+            max_observed = max(max_observed, in_flight)
+            await gate.wait()
+            in_flight -= 1
+
+        tasks = [
+            asyncio.create_task(
+                chat.handle_incoming_message(
+                    adapter,
+                    f"slack:C123:{i}",
+                    create_test_message(f"msg-{i}", "Hey @slack-bot"),
+                )
+            )
+            for i in range(5)
+        ]
+        for _ in range(20):
+            await asyncio.sleep(0)
+        # All 5 should be in flight simultaneously (no bound).
+        assert in_flight == 5
+        gate.set()
+        await asyncio.gather(*tasks)
+        assert max_observed == 5
+
 
 # ============================================================================
 # 22. lockScope (tests 87-91)