fix(wecombot): strip chain-of-thought blocks, rotate stream per round, deliver outbox media

The WeCom AI Bot adapter was leaking <think></think> tags in two
ways: (1) the LiteLLM requester only stripped the legacy
CRETIRE_REASONING_BEGINk marker, missing the public <think>
convention used by MiniMax-M3 and similar providers; (2) the
WeCom AI Bot stream channel was being closed as soon as the first
LLM round finalised, so the second-round push (after a tool call)
silently fell back to a markdown reply_text that WeCom does not
render as a collapsible "thinking" block.

This change fixes both:

* LiteLLMRequester._process_thinking_content now strips both
  <think>…</think> and the legacy marker, with a stateful
  _ThinkStripState that handles tags split across streaming
  chunks. LocalAgentRunner._StreamAccumulator exposes the same
  strip as a final-pass safety net and the second-round
  accumulator is no longer seeded with the first round's content
  (which made every intermediate round repeat the opening line in
  the user reply).

* WecomBotWsClient.push_stream_chunk now rotates the stream_id on
  is_final=True instead of tearing down the stream channel. The
  new stream_id lets the next LLM round open a fresh streaming
  message that WeCom renders as its own "thinking" block instead
  of a raw <think> chunk.

* WecomBotMessageConverter.yiri2target no longer drops Image /
  Voice / File components -- it returns a list of per-component
  items, and the adapter routes media through a new upload_media
  (3-step aibot_upload_init / aibot_upload_chunk /
  aibot_upload_finish protocol) + reply_image / reply_file /
  reply_voice path. This unblocks the
  /workspace/outbox/<query_id>/ auto-delivery hook that was
  silently broken because Image components were dropped before
  reaching the SDK.

Tests cover public-think stripping, stream rotation across tool
rounds, and the upload-media / reply-media protocol.

Author: MIKAZE3

src/langbot/libs/wecom_ai_bot_api/ws_client.py

@@ -34,6 +34,58 @@
 CMD_RESPOND_WELCOME = 'aibot_respond_welcome_msg'
 CMD_RESPOND_UPDATE = 'aibot_respond_update_msg'
 CMD_SEND_MSG = 'aibot_send_msg'
+# Media upload protocol (3 steps: init -> chunk * N -> finish). The
+# command names below match the convention used by the official aibot
+# Python SDK (``wecom-aibot-sdk-python``). If the WeCom AI Bot rejects
+# them, the SDK logs the server ``errcode`` to aid debugging.
+CMD_UPLOAD_INIT = 'aibot_upload_init'
+CMD_UPLOAD_CHUNK = 'aibot_upload_chunk'
+CMD_UPLOAD_FINISH = 'aibot_upload_finish'
+
+# Default upload chunk size: 512 KB (matches the official SDK).
+_UPLOAD_CHUNK_SIZE = 512 * 1024
+
+# File-extension to MIME content-type mapping used by ``upload_media``.
+# The WeCom AI Bot uses ``content_type`` in the upload-init body to
+# decide whether the file is an image, voice, video, or generic
+# document.
+_UPLOAD_CONTENT_TYPE_BY_EXT: dict[str, str] = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.bmp': 'image/bmp',
+    '.webp': 'image/webp',
+    '.mp3': 'audio/mpeg',
+    '.wav': 'audio/wav',
+    '.amr': 'audio/amr',
+    '.ogg': 'audio/ogg',
+    '.mp4': 'video/mp4',
+    '.pdf': 'application/pdf',
+    '.doc': 'application/msword',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.xls': 'application/vnd.ms-excel',
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    '.txt': 'text/plain',
+    '.md': 'text/markdown',
+    '.json': 'application/json',
+}
+
+
+def _guess_content_type(filename: str) -> str:
+    """Return the MIME type for *filename* based on its extension.
+
+    Falls back to ``application/octet-stream`` when the extension is
+    not recognized, matching the WeCom AI Bot default.
+    """
+    import os as _os
+
+    if not filename:
+        return 'application/octet-stream'
+    _, ext = _os.path.splitext(str(filename).lower())
+    return _UPLOAD_CONTENT_TYPE_BY_EXT.get(
+        ext, 'application/octet-stream'
+    )
 
 
 def _generate_req_id(prefix: str) -> str:
@@ -258,6 +310,161 @@ async def send_message(self, chat_id: str, content: str, msgtype: str = 'markdow
             body['text'] = {'content': content}
         return await self._send_reply(req_id, body, cmd=CMD_SEND_MSG)
 
+    # ------------------------------------------------------------------
+    # Media upload (image / voice / file)
+    # ------------------------------------------------------------------
+
+    async def upload_media(
+        self,
+        data: bytes,
+        filename: str = 'attachment',
+    ) -> Optional[dict]:
+        """Upload *data* to the WeCom AI Bot CDN and return the parsed ACK.
+
+        Implements the three-step protocol documented for the WeCom
+        AI Bot:
+
+        1. ``aibot_upload_init`` — declare file name, size, content
+           type, MD5 and chunk count; receive ``upload_id``.
+        2. ``aibot_upload_chunk`` — send each chunk (base64-encoded
+           bytes) until done; receive per-chunk ACK.
+        3. ``aibot_upload_finish`` — finalize the upload; receive
+           ``media_id``.
+
+        Returns a dict with the final ``media_id`` (and the raw
+        ``finish`` ACK) on success, or ``None`` on any failure. The
+        caller is expected to ignore the result and continue
+        gracefully — the framework will keep working without media
+        delivery.
+        """
+        import base64 as _b64
+        import hashlib as _hl
+
+        if not data:
+            return None
+
+        file_size = len(data)
+        file_md5 = _hl.md5(data).hexdigest()
+        total_chunks = (file_size + _UPLOAD_CHUNK_SIZE - 1) // _UPLOAD_CHUNK_SIZE
+        if total_chunks == 0:
+            total_chunks = 1
+        content_type = _guess_content_type(filename)
+
+        # Step 1: init.
+        init_req_id = _generate_req_id(CMD_UPLOAD_INIT)
+        init_body = {
+            'file_name': filename,
+            'file_size': file_size,
+            'file_md5': file_md5,
+            'content_type': content_type,
+            'total_chunks': total_chunks,
+        }
+        init_ack = await self._send_reply(
+            init_req_id,
+            init_body,
+            cmd=CMD_UPLOAD_INIT,
+        )
+        if not init_ack or init_ack.get('errcode', 0) != 0:
+            await self.logger.warning(
+                f'upload_media init failed: ack={init_ack!r}'
+            )
+            return None
+        upload_id = init_ack.get('upload_id') or init_ack.get('data', {}).get('upload_id')
+        if not upload_id:
+            await self.logger.warning(
+                f'upload_media init returned no upload_id: ack={init_ack!r}'
+            )
+            return None
+
+        # Step 2: chunks.
+        for index in range(total_chunks):
+            start = index * _UPLOAD_CHUNK_SIZE
+            end = min(start + _UPLOAD_CHUNK_SIZE, file_size)
+            chunk_bytes = data[start:end]
+            chunk_req_id = _generate_req_id(CMD_UPLOAD_CHUNK)
+            chunk_body = {
+                'upload_id': upload_id,
+                'chunk_index': index,
+                'chunk_base64': _b64.b64encode(chunk_bytes).decode('ascii'),
+            }
+            chunk_ack = await self._send_reply(
+                chunk_req_id,
+                chunk_body,
+                cmd=CMD_UPLOAD_CHUNK,
+            )
+            if not chunk_ack or chunk_ack.get('errcode', 0) != 0:
+                await self.logger.warning(
+                    f'upload_media chunk {index} failed: ack={chunk_ack!r}'
+                )
+                return None
+
+        # Step 3: finish.
+        finish_req_id = _generate_req_id(CMD_UPLOAD_FINISH)
+        finish_body = {'upload_id': upload_id}
+        finish_ack = await self._send_reply(
+            finish_req_id,
+            finish_body,
+            cmd=CMD_UPLOAD_FINISH,
+        )
+        if not finish_ack or finish_ack.get('errcode', 0) != 0:
+            await self.logger.warning(
+                f'upload_media finish failed: ack={finish_ack!r}'
+            )
+            return None
+
+        media_id = (
+            finish_ack.get('media_id')
+            or finish_ack.get('data', {}).get('media_id')
+        )
+        if not media_id:
+            await self.logger.warning(
+                f'upload_media finish returned no media_id: ack={finish_ack!r}'
+            )
+            return None
+        await self.logger.info(
+            f'upload_media OK: filename={filename!r} media_id={media_id!r}'
+        )
+        return {'media_id': media_id, 'ack': finish_ack}
+
+    async def _reply_media(
+        self,
+        req_id: str,
+        media_id: str,
+        kind: str,
+    ) -> Optional[dict]:
+        """Send a media reply (image / voice / file) referencing *media_id*.
+
+        ``kind`` is one of ``'image'``, ``'voice'``, ``'file'``. Uses
+        the standard ``aibot_respond_msg`` command with a per-kind
+        body key (matches the convention documented for the WeCom
+        AI Bot SDK).
+        """
+        if kind not in {'image', 'voice', 'file'}:
+            await self.logger.warning(
+                f'_reply_media called with unknown kind={kind!r}'
+            )
+            return None
+        body = {
+            'msgtype': kind,
+            kind: {'media_id': media_id},
+        }
+        return await self._send_reply(req_id, body, cmd=CMD_RESPOND_MSG)
+
+    async def reply_image(
+        self, req_id: str, media_id: str
+    ) -> Optional[dict]:
+        return await self._reply_media(req_id, media_id, 'image')
+
+    async def reply_file(
+        self, req_id: str, media_id: str
+    ) -> Optional[dict]:
+        return await self._reply_media(req_id, media_id, 'file')
+
+    async def reply_voice(
+        self, req_id: str, media_id: str
+    ) -> Optional[dict]:
+        return await self._reply_media(req_id, media_id, 'voice')
+
     async def push_stream_chunk(self, msg_id: str, content: str, is_final: bool = False) -> bool:
         """Push a streaming chunk for a given message ID.
 
@@ -293,7 +500,18 @@ async def push_stream_chunk(self, msg_id: str, content: str, is_final: bool = Fa
             await self.reply_stream(req_id, stream_id, content, finish=is_final, feedback_id=feedback_id)
             self._stream_last_content[msg_id] = content
             if is_final:
-                self._stream_ids.pop(msg_id, None)
+                # End-of-round: keep the stream entry but rotate the
+                # stream_id so the next LLM round (e.g. after a tool
+                # call) opens a *new* stream message. Without this, the
+                # stream channel stays mapped to the same stream_id,
+                # the next push reuses it, and WeCom — which closes the
+                # stream when it sees ``finish=true`` — would never render
+                # the next round as its own streaming message (so the
+                # chain-of-thought tag would fall back to the markdown
+                # path and be shown as raw text instead of a
+                # collapsible "thinking" block).
+                new_stream_id = _generate_req_id('stream')
+                self._stream_ids[msg_id] = f'{req_id}|{new_stream_id}'
                 self._stream_last_content.pop(msg_id, None)
                 self._stream_sessions.pop(msg_id, None)
             return True