feat(pipeline): add keep-first-think-only toggle for multi-round CoT

New "仅保留第一条思维链" option under output.misc, effective only when
remove-think is enabled. When on, the first LLM round keeps its
chain-of-thought (visible to the user) while subsequent tool-call
rounds strip CoT.

- output.yaml: add keep-first-think-only boolean field
- default-pipeline-config.json: add default false
- localagent.py: pre-loop uses _strip_think_first_round (=False when
  keep-first), tool-loop uses raw remove_think (=True)
- ws_client.py: fallback_after_round + round counter to keep stream_id
  alive across rounds so the next round reuses the same stream
- respback.py: stash pipeline_config on message_event for adapter access
- wecombot.py: read config and set fallback_after_round=1 when enabled

Author: MIKAZE3

src/langbot/libs/wecom_ai_bot_api/ws_client.py

@@ -102,6 +102,11 @@ def __init__(
         self._feedback_sessions: dict[str, dict] = {}  # feedback_id -> {msg_id, user_id, chat_id, stream_id, req_id}
         # msg_id -> feedback_id (for associating feedback with message)
         self._msg_feedback_ids: dict[str, str] = {}  # msg_id -> feedback_id
+        # Round counter per msg_id for keep-first-think-only: when
+        # fallback_after_round >= 1, the stream entry is NOT cleared on
+        # end-of-round so the next round can reuse the same stream_id.
+        self._stream_rounds: dict[str, int] = {}  # msg_id -> round count
+        self.fallback_after_round: int = 0  # 0 = disabled
 
     # ── Public API ──────────────────────────────────────────────────
 
@@ -293,9 +298,20 @@ 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)
-                self._stream_last_content.pop(msg_id, None)
-                self._stream_sessions.pop(msg_id, None)
+                # When fallback_after_round is set, keep the stream entry
+                # alive across rounds so the next LLM round can reuse
+                # the same stream_id. Only clear when the round counter
+                # has crossed the threshold (final round).
+                round_idx = self._stream_rounds.get(msg_id, 0) + 1
+                self._stream_rounds[msg_id] = round_idx
+                if self.fallback_after_round > 0 and round_idx < self.fallback_after_round:
+                    # Keep stream alive for the next round
+                    pass
+                else:
+                    self._stream_ids.pop(msg_id, None)
+                    self._stream_last_content.pop(msg_id, None)
+                    self._stream_sessions.pop(msg_id, None)
+                    self._stream_rounds.pop(msg_id, None)
             return True
         except Exception:
             await self.logger.error(f'Failed to push stream chunk: {traceback.format_exc()}')

src/langbot/pkg/pipeline/respback/respback.py

@@ -46,6 +46,14 @@ async def process(self, query: pipeline_query.Query, stage_inst_name: str) -> en
         try:
             if await query.adapter.is_stream_output_supported() and has_chunks:
                 is_final = [msg.is_final for msg in query.resp_messages][0]
+                self.ap.logger.info(f'respback: calling reply_message_chunk, is_final={is_final}')
+                # Stash pipeline config on the message event so the
+                # platform adapter can read misc toggles like
+                # keep-first-think-only without threading query through.
+                try:
+                    query.message_event._langbot_pipeline_config = query.pipeline_config
+                except Exception:
+                    pass
                 await query.adapter.reply_message_chunk(
                     message_source=query.message_event,
                     bot_message=query.resp_messages[-1],

src/langbot/pkg/platform/sources/wecombot.py

@@ -368,6 +368,15 @@ async def reply_message_chunk(
         _ws_mode = not self.config.get('enable-webhook', False)
 
         if _ws_mode:
+            # Read keep-first-think-only from pipeline config stashed by respback
+            try:
+                _pipeline_cfg = getattr(message_source, '_langbot_pipeline_config', None) or {}
+                _misc = (_pipeline_cfg.get('output') or {}).get('misc') or {}
+                _keep_first = bool(_misc.get('remove-think', False) and _misc.get('keep-first-think-only', False))
+                self.bot.fallback_after_round = 1 if _keep_first else 0
+            except Exception:
+                pass
+
             success = await self.bot.push_stream_chunk(msg_id, content, is_final=is_final)
             if not success and is_final:
                 event = message_source.source_platform_object

src/langbot/pkg/provider/runners/localagent.py

@@ -471,7 +471,12 @@ async def run(
 
         # Safely resolve the "remove think blocks" toggle. ``output.misc``
         # is not guaranteed to exist on every pipeline configuration.
-        remove_think = ((query.pipeline_config.get('output') or {}).get('misc') or {}).get('remove-think', False)
+        _misc = (query.pipeline_config.get('output') or {}).get('misc') or {}
+        remove_think = _misc.get('remove-think', False)
+        # ``keep-first-think-only``: only effective when ``remove-think`` is on.
+        # Round 1 (pre-loop) keeps CoT; rounds 2+ (tool-loop) strip it.
+        keep_first_think_only = _misc.get('keep-first-think-only', False)
+        _strip_think_first_round = remove_think and not keep_first_think_only
 
         # Build ordered candidate list (primary + fallbacks)
         candidates = await self._get_model_candidates(query)
@@ -490,19 +495,19 @@ async def run(
                 candidates,
                 req_messages,
                 query.use_funcs,
-                remove_think,
+                _strip_think_first_round,
             )
             final_msg = msg
         else:
             # Streaming: invoke with fallback
-            stream_accumulator = _StreamAccumulator(msg_sequence=1, remove_think=remove_think)
+            stream_accumulator = _StreamAccumulator(msg_sequence=1, remove_think=_strip_think_first_round)
 
             stream_src, use_llm_model = await self._invoke_stream_with_fallback(
                 query,
                 candidates,
                 req_messages,
                 query.use_funcs,
-                remove_think,
+                _strip_think_first_round,
             )
             async for msg in stream_src:
                 chunk = stream_accumulator.add(msg)

src/langbot/templates/default-pipeline-config.json

@@ -107,7 +107,8 @@
             "at-sender": true,
             "quote-origin": true,
             "track-function-calls": false,
-            "remove-think": false
+            "remove-think": false,
+            "keep-first-think-only": false
         }
     }
 }

src/langbot/templates/metadata/pipeline/output.yaml

@@ -145,4 +145,14 @@ stages:
         type: boolean
         required: true
         default: false
+      - name: keep-first-think-only
+        label:
+          en_US: Keep Only First CoT
+          zh_Hans: 仅保留第一条思维链
+        description:
+          en_US: 'Only effective when "Remove CoT" is enabled. Keeps the chain-of-thought on the first LLM round but strips it from all subsequent rounds in a multi-round tool-call loop.'
+          zh_Hans: '仅在启用"删除思维链"时生效。多轮工具调用中，保留第一轮的思维链，后续轮次的思维链一律删除。'
+        type: boolean
+        required: true
+        default: false