fix(weixin): asyncio.wait_for timeout in _api_post/_api_get (+ regression tests, cluster closure)

[banditburai]

Credit: the production fix is authored by @caojiguang (#31853), carried here with their git authorship preserved. This PR adds the regression suite and resolves the broader Weixin asyncio-timeout cluster. Independent fix + test work by @ryan-flow (#32179) is acknowledged.

Problem

Cron and other non-gateway WeChat sends fail with:

RuntimeError: Timeout context manager should be used inside a task

send_message runs _api_post/_api_get in a worker thread with its own event loop (via _run_async), while the aiohttp session is bound to the gateway loop. aiohttp.ClientTimeout is implemented through async_timeout.TimerContext, whose __enter__ calls asyncio.current_task(loop=session._loop) — the gateway loop, not the worker loop — which returns None and raises. The request never reaches the wire. The long-poll path was unaffected (already inside a Task), which is why this only bit cron / out-of-band sends.

Fix

Replace the per-request aiohttp.ClientTimeout with asyncio.wait_for(coro, timeout=timeout_ms/1000), wrapping each request body in a local coroutine. wait_for ensure_future-wraps the coroutine into a real Task and enforces the deadline via loop.call_later + fut.cancel() — it never calls current_task(), so it is event-loop-context-agnostic.

This completes the migration begun in #21196, which moved the sibling helpers _upload_ciphertext / _download_bytes / _download_remote_media to the same wait_for pattern; _api_post / _api_get were the last two helpers still on per-request ClientTimeout. All five Weixin HTTP helpers now use one timeout mechanism.

Supporting context (unchanged, already on main): the send session is built with aiohttp.ClientTimeout(total=None, connect=None, sock_connect=None, sock_read=None), so the session-level aiohttp timer is fully disabled and all timeout budget is owned by the per-request wait_for.

Scope / non-goals

Two files: gateway/platforms/weixin.py, tests/gateway/test_weixin.py. This PR does not touch:

• model_tools.py loop handling — the persistent/recreated-loop residuals ([Bug]: model_tools async bridge recreates loops in running-loop contexts #16570, Bug: persistent event loops in model_tools.py never closed, resource accumulation in long-running gateway #8043) live there and are out of scope.
• Cross-loop session reuse / "Future attached to a different loop" — already fixed on main by fix(weixin): send_weixin_direct cross-loop session check #19141.
• Telegram or any non-Weixin platform; the media-handling half — see fix(gateway): unify MEDIA: extraction extension set + close the unknown-ext black hole (#34517) #34844.

Behavior / compatibility

• Timeout budget unchanged — the per-request ClientTimeout already bounded these calls by the same timeout_ms (API_TIMEOUT_MS=15s, CONFIG_TIMEOUT_MS=10s, LONG_POLL_TIMEOUT_MS=35s); wait_for enforces the identical budget. No truncation of previously-successful calls.
• On timeout, wait_for raises asyncio.TimeoutError; on Python 3.12 this is TimeoutError and is not a CancelledError subclass, so the poll loop's except CancelledError does not swallow it — real sends retry then re-raise.
• _get_updates long-poll swallow is unchanged: it still catches asyncio.TimeoutError and returns the empty-batch sentinel {"ret": 0, "msgs": [], "get_updates_buf": sync_buf}.
• On timeout, wait_for cancels the inner coroutine mid-async with session.post(...); aiohttp's response context manager releases the connection in __aexit__ — no leaked connection. Same pattern as the production sibling helpers.

Tests

python -m pytest tests/gateway/test_weixin.py tests/test_model_tools_async_bridge.py -q
# 73 passed

TestWeixinApiTimeout (7 cases):

Test	Helper	Contract
happy-path	_api_post / _api_get	returns parsed JSON; no timeout= kwarg forwarded to the session call (regression guard against reintroducing ClientTimeout)
slow response	_api_post / _api_get	wait_for actually fires and raises asyncio.TimeoutError (real timeout, not mocked)
non-2xx	_api_post / _api_get	raises RuntimeError carrying HTTP status + truncated body
long-poll	_get_updates	underlying asyncio.TimeoutError is swallowed into the empty-batch sentinel (loop survives)

Note: tests pin the observable contract (no timeout= forwarded; wait_for raises; _get_updates swallows) rather than reproducing the loop-context crash in-process, which requires real aiohttp request machinery and is impractical to unit-test.

Cluster closure

Resolves the Weixin asyncio-timeout cluster (15 active items). The eight issues below all report the timeout-context crash on the text-send path this fix removes:

Closes #13099, Closes #13281, Closes #16293, Closes #17347, Closes #18014, Closes #18836, Closes #20229, Closes #24142

Referenced, not closed by this diff:

• Refs #13365, #23371, #18437 — the cross-loop "Future attached to a different loop" half (session reuse across event loops); already fixed on main by fix(weixin): send_weixin_direct cross-loop session check #19141, not this diff.
• Refs #17595 — media/file sends failing via cross-loop session reuse (fix(weixin): send_weixin_direct cross-loop session check #19141) plus the media-handling half (fix(gateway): unify MEDIA: extraction extension set + close the unknown-ext black hole (#34517) #34844); not this diff.
• Refs #32179 — @ryan-flow's independent duplicate (closed as a duplicate of fix(weixin): replace aiohttp ClientTimeout with asyncio.wait_for in _api_post/_api_get #31853).

Supersedes:

• Supersedes #18714 — its WeChat event-loop guard and Telegram proxy are already on main in stronger form (fix(weixin): send_weixin_direct cross-loop session check #19141 + the host-scoped Telegram proxy); only its out-of-cluster rate-limit backoff is unaddressed here.
• Supersedes #31853 — carries @caojiguang's commit; close as incorporated once this merges.

Known residuals / out of scope: #16570, #8043 — their timeout paths live in model_tools.py, untouched by this diff.

Infographic

[alt-glitch]

This PR supersedes #31853 (by @caojiguang) — carries the same production fix with preserved authorship, adds regression tests, and resolves the broader Weixin asyncio-timeout cluster (#29037, #24248, #19050, #17911). Also acknowledges independent work in #32179 (by @ryan-flow, closed).