@xmanrui/dsh-im 4.23.0 → 4.24.1

package/src/channels/feishu/step-push-mode.mjs

@@ -1,6 +1,7 @@
 export const FEISHU_STEP_PUSH_MODES = Object.freeze({
   POST: 'post',
   STREAMING_CARD: 'streaming_card',
+  LIVE_COT: 'live_cot',
 });
 
 /** New connections explicitly opt into the process-card presentation. */
@@ -8,12 +9,17 @@ export const DEFAULT_FEISHU_STEP_PUSH_MODE = FEISHU_STEP_PUSH_MODES.STREAMING_CA
 
 export function normalizeFeishuStepPushMode(value) {
   // Bots created before modes existed used posts when step push was enabled.
-  return value === FEISHU_STEP_PUSH_MODES.STREAMING_CARD
-    ? FEISHU_STEP_PUSH_MODES.STREAMING_CARD
-    : FEISHU_STEP_PUSH_MODES.POST;
+  if (value === FEISHU_STEP_PUSH_MODES.STREAMING_CARD) {
+    return FEISHU_STEP_PUSH_MODES.STREAMING_CARD;
+  }
+  if (value === FEISHU_STEP_PUSH_MODES.LIVE_COT) {
+    return FEISHU_STEP_PUSH_MODES.LIVE_COT;
+  }
+  return FEISHU_STEP_PUSH_MODES.POST;
 }
 
 export function isFeishuStepPushMode(value) {
   return value === FEISHU_STEP_PUSH_MODES.POST
-    || value === FEISHU_STEP_PUSH_MODES.STREAMING_CARD;
+    || value === FEISHU_STEP_PUSH_MODES.STREAMING_CARD
+    || value === FEISHU_STEP_PUSH_MODES.LIVE_COT;
 }

package/src/channels/shared/harness-client.mjs

@@ -356,10 +356,23 @@ export function textFromHarnessContent(content) {
     .trim();
 }
 
+/** Join only reasoning blocks from one Harness message payload. */
+export function reasoningFromHarnessContent(content) {
+  return (Array.isArray(content) ? content : [])
+    .filter((part) => part?.type === 'reasoning' && typeof part.text === 'string')
+    .map((part) => part.text)
+    .join('\n')
+    .trim();
+}
+
 function assistantMessageText(event) {
   return textFromHarnessContent(event?.data?.message?.content);
 }
 
+function assistantReasoningText(event) {
+  return reasoningFromHarnessContent(event?.data?.message?.content);
+}
+
 /** Aggregate assistant text in stable step/index order for one Harness Turn. */
 export class AssistantTextAccumulator {
   #steps = new Map();
@@ -415,6 +428,29 @@ function toolResultErrorText(error) {
   return null;
 }
 
+/** Join the visible text carried by a Harness tool result. */
+function toolResultText(data) {
+  const blocks = Array.isArray(data?.message?.content) ? data.message.content : [];
+  const nested = blocks.flatMap((block) => (
+    Array.isArray(block?.content) ? block.content : [block]
+  ));
+  const text = nested
+    .filter((block) => block?.type === 'text' && typeof block.text === 'string')
+    .map((block) => block.text)
+    .join('');
+  return text || nonEmptyText(data?.text) || toolResultErrorText(data?.error) || '';
+}
+
+function toolResultCallId(data) {
+  const blocks = Array.isArray(data?.message?.content) ? data.message.content : [];
+  return blocks
+    .map((block) => nonEmptyText(block?.toolCallId))
+    .find(Boolean)
+    ?? nonEmptyText(data?.message?.source?.callId)
+    ?? nonEmptyText(data?.callId)
+    ?? nonEmptyText(data?.subCallId);
+}
+
 function consumeInteractionOwnership(ownership, entries) {
   const ordered = [...entries]
     .map((entry) => entry?.event ?? entry)
@@ -505,10 +541,18 @@ export class HarnessReplyTracker {
   #reason = null;
   #toolNames = new Map();
   #lastToolName = null;
+  #transientSeqs = new Set();
+  #pendingReasoning = new Map();
+  #pendingReasoningChars = 0;
+  #reasoning = false;
 
-  constructor({ promptRpcId, afterSeq = -1 }) {
+  constructor({ promptRpcId, afterSeq = -1, reasoning = false }) {
     this.#promptRpcId = promptRpcId;
     this.#lastSeq = afterSeq;
+    // Reasoning updates are opt-in per consumer: only channels that surface
+    // thinking traces (Telegram thinking mode) subscribe; every other channel
+    // keeps its pre-thinking-traces update stream untouched.
+    this.#reasoning = reasoning === true;
   }
 
   get finished() {
@@ -542,7 +586,35 @@ export class HarnessReplyTracker {
     pushUpdate({ type: 'text', text });
   }
 
-  consumeAll(entries) {
+  #bufferReasoning(event) {
+    const text = event.data?.chunk?.text;
+    if (typeof text !== 'string' || !text || text.length > 65536
+      || this.#pendingReasoning.has(event.seq)) return;
+    this.#pendingReasoning.set(event.seq, event);
+    this.#pendingReasoningChars += text.length;
+    while (this.#pendingReasoning.size > 256 || this.#pendingReasoningChars > 65536) {
+      const [seq, oldest] = this.#pendingReasoning.entries().next().value;
+      this.#pendingReasoning.delete(seq);
+      this.#pendingReasoningChars -= oldest.data.chunk.text.length;
+    }
+  }
+
+  #takePendingReasoning() {
+    const events = [...this.#pendingReasoning.values()];
+    this.#pendingReasoning.clear();
+    this.#pendingReasoningChars = 0;
+    return events;
+  }
+
+  #emitReasoning(event, pushUpdate) {
+    const text = event.data?.chunk?.text;
+    if (event.data?.turn !== this.#targetTurn || this.#transientSeqs.has(event.seq)
+      || typeof text !== 'string' || !text) return;
+    this.#transientSeqs.add(event.seq);
+    pushUpdate({ type: 'reasoning', turn: this.#targetTurn, text });
+  }
+
+  consumeAll(entries, { live = false, fromMux = false } = {}) {
     const updates = [];
     // 同一批轮询内的 text 帧只保留最新累积，其余事件逐帧透出，
     // 让消费方能按顺序看到每个工具调用与结果。
@@ -556,20 +628,53 @@ export class HarnessReplyTracker {
       }
       updates.push(update);
     };
-    const ordered = [...entries]
+    const ordered = [...(fromMux ? [] : this.#takePendingReasoning()), ...entries]
       .map((entry) => entry?.event ?? entry)
       .filter(Boolean)
       .sort((left, right) => (left.seq ?? -1) - (right.seq ?? -1));
 
     for (const event of ordered) {
+      if (this.#finished) break;
       const seq = event.seq ?? -1;
+      const isReasoning = event.type === 'assistant/chunk'
+        && event.data?.chunk?.type === 'reasoning-delta';
+      // The mux is lossy across reconnects. Only history may advance the
+      // durable cursor or finish the reply; the mux supplements reasoning.
+      if (fromMux && !isReasoning) continue;
+      if (isReasoning) {
+        if (!live || !Number.isFinite(seq)) continue;
+        if (this.#targetTurn === null) this.#bufferReasoning(event);
+        else this.#emitReasoning(event, pushUpdate);
+        continue;
+      }
+      if (this.#targetTurn === null) {
+        if (seq <= this.#lastSeq) continue;
+        if (event.type === 'turn/start') {
+          this.#openTurn = event.data?.turn ?? null;
+          continue;
+        }
+        if (event.type === 'user/message' && event.data?.source?.rpcId === this.#promptRpcId) {
+          this.#lastSeq = seq;
+          this.#targetTurn = event.data?.turn ?? this.#openTurn;
+          if (live && this.#targetTurn !== null) {
+            pushUpdate({ type: 'turn-start', turn: this.#targetTurn });
+            // Only earlier fragments flush here. Later steps remain in the
+            // sorted batch, interleaved with their tool calls and results.
+            for (const pending of this.#takePendingReasoning()) {
+              this.#emitReasoning(pending, pushUpdate);
+            }
+          }
+        }
+        continue;
+      }
       if (seq <= this.#lastSeq) continue;
       this.#lastSeq = seq;
 
       if (event.type === 'turn/start') this.#openTurn = event.data?.turn ?? null;
 
       if (event.type === 'user/message' && event.data?.source?.rpcId === this.#promptRpcId) {
-        this.#targetTurn = this.#openTurn;
+        this.#targetTurn = event.data?.turn ?? this.#openTurn;
+        if (live) pushUpdate({ type: 'turn-start', turn: this.#targetTurn });
         continue;
       }
       if (this.#targetTurn === null) continue;
@@ -579,6 +684,13 @@ export class HarnessReplyTracker {
         this.#finished = true;
         this.#reason = event.data?.reason ?? null;
         this.#openTurn = null;
+        if (live) {
+          pushUpdate({
+            type: 'turn-end',
+            turn: this.#targetTurn,
+            reason: this.#reason,
+          });
+        }
         continue;
       }
       if (event.data?.turn !== this.#targetTurn) continue;
@@ -597,7 +709,22 @@ export class HarnessReplyTracker {
         this.#assistantText.setCanonical(step, text);
         // canonical 定稿且非空时按 step 透出，供分步推送消费方使用；
         // 先于 commitText 透出，保持 text 更新作为批次末尾的既有语义。
-        if (text) pushUpdate({ type: 'assistant-message', step, text });
+        if (text) {
+          pushUpdate({
+            type: 'assistant-message',
+            step,
+            text,
+            ...(live ? { turn: this.#targetTurn } : {}),
+          });
+        }
+        // Thinking-trace channels consume this as the 💭 line that precedes the
+        // tool call it explains; only consumers that explicitly subscribed
+        // (reasoning: true) see these updates, so default-mode channels keep
+        // their pre-thinking-traces progress stream.
+        if (this.#reasoning) {
+          const reasoning = assistantReasoningText(event);
+          if (reasoning) pushUpdate({ type: 'reasoning', step, text: reasoning });
+        }
         this.#commitText(this.#assistantText.text, pushUpdate);
         continue;
       }
@@ -620,20 +747,38 @@ export class HarnessReplyTracker {
             }
           }
         }
-        pushUpdate({ type: 'tool', name, ...(argsText ? { arguments: argsText } : {}), ...(callId ? { callId } : {}) });
+        pushUpdate({
+          type: 'tool',
+          name,
+          ...(argsText ? { arguments: argsText } : {}),
+          ...(callId ? { callId } : {}),
+          ...(live ? { turn: this.#targetTurn } : {}),
+        });
       } else if (event.type === 'tool/result') {
-        const callId = nonEmptyText(event.data?.message?.source?.callId)
-          ?? nonEmptyText(event.data?.callId)
-          ?? nonEmptyText(event.data?.subCallId);
+        const callId = toolResultCallId(event.data);
         const toolName = (callId ? this.#toolNames.get(callId) : null)
           ?? this.#lastToolName;
         const error = toolResultErrorText(event.data?.error);
-        pushUpdate({
-          type: 'status',
-          text: t('正在整理结果…'),
-          ...(toolName ? { toolName } : {}),
-          ...(error ? { error } : {}),
-        });
+        if (live) {
+          const providerErrorCode = event.data?.error?.code;
+          pushUpdate({
+            type: 'tool-result',
+            turn: this.#targetTurn,
+            ...(callId ? { callId } : {}),
+            ...(toolName ? { toolName } : {}),
+            text: toolResultText(event.data),
+            ...(providerErrorCode !== undefined && providerErrorCode !== null
+              ? { errorCode: String(providerErrorCode) }
+              : {}),
+          });
+        } else {
+          pushUpdate({
+            type: 'status',
+            text: t('正在整理结果…'),
+            ...(toolName ? { toolName } : {}),
+            ...(error ? { error } : {}),
+          });
+        }
       }
     }
     return updates;
@@ -644,6 +789,19 @@ export class HarnessReplyTracker {
   }
 }
 
+/**
+ * Progress updates an ask() consumer actually receives. latest 模式只投递一条
+ * 最新进展；assistant-message 是分步推送专用更新，且 canonical 去重后可能成为
+ * 批次唯一变化，绝不能冒充进度投给全部渠道。reasoning 同为思考留痕渠道专用，
+ * 默认模式下不得冒充进度（钉钉、企微等会展示其 text）。
+ */
+export function visibleProgressUpdates(updates, progressMode) {
+  if (progressMode === 'all') return updates;
+  return updates
+    .filter((update) => update.type !== 'assistant-message' && update.type !== 'reasoning')
+    .slice(-1);
+}
+
 export class HarnessRpcError extends Error {
   constructor(method, error) {
     super(`${method}: ${error?.message ?? 'unknown Harness RPC error'}`);
@@ -1146,6 +1304,7 @@ export class HarnessClient {
     signal,
     onInteraction,
     onResolved,
+    onSessionEvent,
     onOpen,
     ownership,
   } = {}) {
@@ -1159,6 +1318,9 @@ export class HarnessClient {
     if (onResolved !== undefined && typeof onResolved !== 'function') {
       throw new TypeError('onResolved must be a function');
     }
+    if (onSessionEvent !== undefined && typeof onSessionEvent !== 'function') {
+      throw new TypeError('onSessionEvent must be a function');
+    }
     if (onOpen !== undefined && typeof onOpen !== 'function') {
       throw new TypeError('onOpen must be a function');
     }
@@ -1169,6 +1331,7 @@ export class HarnessClient {
           signal,
           onInteraction,
           onResolved,
+          onSessionEvent,
           onOpen,
           ownership,
         });
@@ -1449,7 +1612,12 @@ export class HarnessClient {
     const timeoutMs = options.timeoutMs ?? 600_000;
     const signal = options.signal;
     const onUpdate = typeof options.onUpdate === 'function' ? options.onUpdate : null;
-    const progressMode = options.progressMode === 'all' ? 'all' : 'latest';
+    const progressMode = options.progressMode === 'live'
+      ? 'live'
+      : options.progressMode === 'all' ? 'all' : 'latest';
+    // Reasoning updates only exist for consumers that opt in (thinking-trace
+    // mode); default ask() consumers keep the pre-thinking-traces stream.
+    const reasoning = options.reasoning === true;
     const onArtifact = typeof options.onArtifact === 'function' ? options.onArtifact : null;
     const onInteraction = typeof options.onInteraction === 'function'
       ? options.onInteraction
@@ -1470,8 +1638,39 @@ export class HarnessClient {
     const baselineSeq = Math.max(-1, ...(before.events ?? []).map(({ event }) => event.seq ?? -1));
     const promptRpcId = `${this.#rpcIdPrefix}-${randomUUID()}`;
     const releasePromptInputOrigin = registerImInputOrigin(this.#interactionRegistry, promptRpcId);
-    const tracker = new HarnessReplyTracker({ promptRpcId, afterSeq: baselineSeq });
+    const tracker = new HarnessReplyTracker({ promptRpcId, afterSeq: baselineSeq, reasoning });
+    let lastProgressAt = Date.now();
+    let lastPollSeq = tracker.lastSeq;
+    let progressTail = Promise.resolve();
+    const consumeProgress = (entries, { fromMux = false } = {}) => {
+      const updates = tracker.consumeAll(entries, {
+        live: progressMode === 'live',
+        fromMux,
+      });
+      const seqAdvanced = tracker.lastSeq > lastPollSeq;
+      lastPollSeq = tracker.lastSeq;
+      if (seqAdvanced) lastProgressAt = Date.now();
+      if (!onUpdate) return progressTail;
+      const visibleUpdates = progressMode === 'all' || progressMode === 'live'
+        ? updates
+        : updates
+            .filter((update) => update.type !== 'assistant-message' && update.type !== 'reasoning')
+            .slice(-1);
+      for (const update of visibleUpdates) {
+        progressTail = progressTail
+          .then(() => onUpdate(update))
+          .catch((error) => {
+            console.warn(
+              '[dsh-im] ignored a progress update failure:',
+              this.#logPrefix,
+              error.message,
+            );
+          });
+      }
+      return progressTail;
+    };
     const interactionController = onInteraction || onInteractionResolved
+      || (progressMode === 'live' && onUpdate)
       ? new AbortController()
       : null;
     const interactionSignal = interactionController
@@ -1568,6 +1767,9 @@ export class HarnessClient {
           signal: interactionSignal,
           onInteraction,
           onResolved: onInteractionResolved,
+          onSessionEvent: progressMode === 'live'
+            ? (event) => { consumeProgress([event], { fromMux: true }); }
+            : undefined,
           onOpen: markOpen,
           ownership,
         });
@@ -1645,8 +1847,6 @@ export class HarnessClient {
         // confirm the Session is still running before renewing the wait.
         // Interaction ownership is intentionally not a liveness signal: it stays
         // active until turn/end and can therefore outlive a stalled turn.
-        let lastProgressAt = Date.now();
-        let lastPollSeq = tracker.lastSeq;
         while (true) {
           await sleep(300, signal);
           const history = await this.rpc(
@@ -1660,24 +1860,7 @@ export class HarnessClient {
             this.#consumeInteractionOwnerships(sessionId, history.events ?? []);
             if (!wasActive && ownership.active) ownership.reconnect?.();
           }
-          const updates = tracker.consumeAll(history.events ?? []);
-          const seqAdvanced = tracker.lastSeq > lastPollSeq;
-          lastPollSeq = tracker.lastSeq;
-          if (seqAdvanced) lastProgressAt = Date.now();
-          if (onUpdate) {
-            // latest 模式只投递一条最新进展；assistant-message 是分步推送专用更新，
-            // 且 canonical 去重后可能成为批次唯一变化，绝不能冒充进度投给全部渠道。
-            const visibleUpdates = progressMode === 'all'
-              ? updates
-              : updates.filter((update) => update.type !== 'assistant-message').slice(-1);
-            for (const update of visibleUpdates) {
-              try {
-                await onUpdate(update);
-              } catch (error) {
-                console.warn('[dsh-im] ignored a progress update failure:', this.#logPrefix, error.message);
-              }
-            }
-          }
+          await consumeProgress(history.events ?? []);
           if (tracker.finished) {
             turnFinished = true;
             if (!ownership?.stopRequested && !harnessTurnSucceeded(tracker.reason)) {
@@ -1761,6 +1944,7 @@ export class HarnessClient {
     signal,
     onInteraction,
     onResolved,
+    onSessionEvent,
     onOpen,
     ownership,
   }) {
@@ -1800,8 +1984,9 @@ export class HarnessClient {
     };
     const processEnvelope = (envelope) => {
       const payload = envelope.payload;
-      if (ownership && payload.type === 'session/event') {
-        this.#consumeInteractionOwnerships(sessionId, [payload.event]);
+      if (payload.type === 'session/event') {
+        if (ownership) this.#consumeInteractionOwnerships(sessionId, [payload.event]);
+        dispatch(onSessionEvent, payload.event);
         return;
       }
       if (payload.type === 'question/requested' || payload.type === 'approval/requested') {

package/src/channels/shared/text-harness-bridge.mjs

@@ -168,6 +168,7 @@ export class TextHarnessBridge {
   #deferred;
   #contextEnhancement;
   #accessPolicy;
+  #thinkingTraces;
   #status;
   #logger;
   #replyTimeoutMs;
@@ -195,6 +196,7 @@ export class TextHarnessBridge {
     state,
     contextEnhancement,
     accessPolicy,
+    thinkingTraces = false,
     status = createTextBridgeStatus(),
     logger = console,
     replyTimeoutMs = 600_000,
@@ -211,6 +213,7 @@ export class TextHarnessBridge {
     this.#state = state;
     this.#contextEnhancement = contextEnhancement;
     this.#accessPolicy = accessPolicy;
+    this.#thinkingTraces = thinkingTraces;
     this.#status = status;
     this.#logger = logger;
     this.#replyTimeoutMs = replyTimeoutMs;
@@ -654,6 +657,10 @@ export class TextHarnessBridge {
     const batchSubmission = message.batchSubmission;
     let stream = null;
     let semanticStream = false;
+    // Thinking streams accept the same delivery-block contract as semantic
+    // streams: finish() must receive { text, format } so a markdown answer
+    // renders rich instead of falling back to plain text.
+    let thinkingStream = false;
     // A keepalive heartbeat keeps short-lived carriers (e.g. Telegram's
     // private-chat Rich Draft) visible during long silent stretches such as a
     // running tool call. Declared outside the try so every exit path (including
@@ -724,29 +731,51 @@ export class TextHarnessBridge {
         this.#logger.warn?.(`[dsh-im:${this.#descriptor.key}] typing indicator failed:`, error);
       });
       let streamFinished = false;
-      if (typeof this.#bot.openDeliveryStream === 'function') {
+      if (this.#thinkingTraces && typeof this.#bot.openThinkingStream === 'function') {
         try {
-          stream = await this.#bot.openDeliveryStream(target);
-          semanticStream = true;
+          stream = await this.#bot.openThinkingStream(target);
+          thinkingStream = true;
         } catch (error) {
+          stream = null;
           this.#logger.warn?.(
-            `[dsh-im:${this.#descriptor.key}] unable to start a semantic reply stream; using final delivery:`,
+            `[dsh-im:${this.#descriptor.key}] unable to start a thinking stream; using final delivery:`,
             error,
           );
         }
-      } else if (typeof this.#bot.openStream === 'function') {
-        try {
-          stream = await this.#bot.openStream(target);
-        } catch (error) {
-          this.#logger.warn?.(
-            `[dsh-im:${this.#descriptor.key}] unable to start a streamed reply; using text:`,
-            error,
-          );
+      }
+      if (!stream) {
+        if (typeof this.#bot.openDeliveryStream === 'function') {
+          try {
+            stream = await this.#bot.openDeliveryStream(target);
+            semanticStream = true;
+          } catch (error) {
+            this.#logger.warn?.(
+              `[dsh-im:${this.#descriptor.key}] unable to start a semantic reply stream; using final delivery:`,
+              error,
+            );
+          }
+        } else if (typeof this.#bot.openStream === 'function') {
+          try {
+            stream = await this.#bot.openStream(target);
+          } catch (error) {
+            this.#logger.warn?.(
+              `[dsh-im:${this.#descriptor.key}] unable to start a streamed reply; using text:`,
+              error,
+            );
+          }
         }
       }
+      const thinkingMode = Boolean(stream
+        && this.#thinkingTraces
+        && typeof stream.sendToolTrace === 'function');
+      // What the model sees. A message may carry two texts: `controlText`, the
+      // plain body the parsers read, and `content`, the same body decorated for
+      // the model — the email channel prefixes the mail headers there, so a
+      // subject-only instruction is not silently dropped. Falling back to the
+      // parsed text kept commands working but lost that decoration entirely.
       let content = hasImages || hasReply
         ? await promptContentForInboundMessage(message, { signal: this.#signal, deferImages: true })
-        : undefined;
+        : cleanText(message.content) || undefined;
       const snapshot = this.#acceptedMessageIds.get(messageId);
       let contextEnhanced = false;
       if (snapshot) {
@@ -801,7 +830,24 @@ export class TextHarnessBridge {
           timeoutMs: this.#replyTimeoutMs,
           signal: this.#signal,
           control: { owner: this, key: conversationKey },
+          // Thinking mode needs every update (reasoning + tool calls) in
+          // order; latest mode filters as before. Only thinking mode subscribes
+          // to reasoning updates, so default-mode consumers on other channels
+          // never see them (their progress handlers would render update.text).
+          progressMode: thinkingMode ? 'all' : undefined,
+          reasoning: thinkingMode,
           onUpdate: stream ? async (update) => {
+            if (thinkingMode) {
+              // Only the 💭 and 🔧 lines are surfaced; status/text updates
+              // and the assistant-message canonical text are not.
+              if (update.type === 'reasoning') {
+                await stream.sendThinking(update.text);
+              } else if (update.type === 'tool') {
+                await stream.sendToolTrace(update.name, update.arguments);
+              }
+              return;
+            }
+            if (update.type === 'reasoning') return;
             const progress = update.type === 'text' ? update.text
               : update.type === 'tool' ? t('正在使用{name}…', { name: update.name }) : update.text;
             if (progress) {
@@ -841,7 +887,7 @@ export class TextHarnessBridge {
       let textReceipt = null;
       if (stream) {
         try {
-          const result = await stream.finish(semanticStream
+          const result = await stream.finish(semanticStream || thinkingStream
             ? createTextDeliveryBlock(visibleAnswer, answerFormat)
             : visibleAnswer);
           streamFinished = true;

package/src/channels/shared/workspace-session.mjs

@@ -94,6 +94,7 @@ export async function askInWorkspaceSession({
   key,
   text,
   content,
+  prepareContent,
   titleText,
   sourceGuidance,
   contextEnhanced = false,
@@ -165,8 +166,13 @@ export async function askInWorkspaceSession({
         await originalOnArtifact?.(artifact);
       };
       let answer;
+      // Prepare session-dependent context after binding, outside the binding
+      // lock. A stale-workspace retry must prepare it for the new session too.
+      const prompt = prepareContent
+        ? await prepareContent({ sessionId: binding.sessionId, content, text })
+        : content ?? text;
       try {
-        answer = await binding.session.ask(content ?? text, artifactOptions);
+        answer = await binding.session.ask(prompt, artifactOptions);
       } catch (error) {
         if (error?.code === 'harness-reply-timeout' && deferredDelivery) {
           try {

package/src/channels/telegram/config-store.mjs

@@ -50,12 +50,15 @@ export function normalizeTelegramAccessPolicy(value = {}) {
 function normalizeTelegramBotExtension(value) {
   const hasAccessMode = Object.hasOwn(value, 'accessMode');
   const hasAllowedUsers = Object.hasOwn(value, 'allowedUsers');
-  if (!hasAccessMode && !hasAllowedUsers) return {};
+  const hasThinkingTraces = Object.hasOwn(value, 'thinkingTraces');
+  if (!hasAccessMode && !hasAllowedUsers && !hasThinkingTraces) return {};
   try {
     const policy = normalizeTelegramAccessPolicy(value);
     return {
       ...(hasAccessMode ? { accessMode: policy.accessMode } : {}),
       ...(hasAllowedUsers || hasAccessMode ? { allowedUsers: policy.allowedUsers } : {}),
+      // Explicit field is kept; an absent field stays absent.
+      ...(hasThinkingTraces ? { thinkingTraces: value.thinkingTraces === true } : {}),
     };
   } catch {
     return null;

package/src/channels/telegram/telegram-controller.mjs

@@ -28,7 +28,12 @@ export class TelegramController extends TokenBotController {
       bots: snapshot.bots.map((bot) => {
         const config = this.#configStore.get(bot.botId);
         const accessPolicy = normalizeTelegramAccessPolicy(config ?? {});
-        return { ...bot, accessPolicy };
+        return {
+          ...bot,
+          accessPolicy,
+          // Default ON; only an explicit false in the config opts out.
+          thinkingTraces: config?.thinkingTraces !== false,
+        };
       }),
     };
   }
@@ -37,4 +42,11 @@ export class TelegramController extends TokenBotController {
     const accessPolicy = normalizeTelegramAccessPolicy(value);
     return this.updateBotConfig(botId, (config) => ({ ...config, ...accessPolicy }));
   }
+
+  async setThinkingTraces(botId, value) {
+    return this.updateBotConfig(botId, (config) => ({
+      ...config,
+      thinkingTraces: value === true,
+    }));
+  }
 }