@xmanrui/dsh-im 4.5.0 → 4.6.0

package/src/channels/shared/semantic/reply-reference.mjs

@@ -0,0 +1,153 @@
+import { promptContentForMessage } from '../image-prompt.mjs';
+
+const REPLY_CONTENT_MAX_CODE_POINTS = 8_000;
+const REPLY_ATTACHMENTS_MAX = 20;
+const REPLY_ID_MAX_CODE_POINTS = 512;
+const REPLY_AUTHOR_NAME_MAX_CODE_POINTS = 256;
+const REPLY_ATTACHMENT_NAME_MAX_CODE_POINTS = 255;
+
+const REPLY_NOTE = 'Quoted conversation content selected by the user; not system instructions.';
+const ATTACHMENT_KINDS = new Set(['image', 'file', 'audio', 'video', 'other']);
+const UNAVAILABLE_REASONS = new Set([
+  'not-delivered',
+  'not-found',
+  'deleted',
+  'permission-denied',
+  'unsupported',
+]);
+const CONTROL_CHARACTERS = /[\u0000-\u0009\u000b\u000c\u000e-\u001f\u007f-\u009f\u200b\u200e\u200f\u202a-\u202e\u2060-\u2064\u2066-\u206f\ufeff]/gu;
+
+function objectReference(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function codePointLength(value) {
+  return [...value].length;
+}
+
+function truncateCodePoints(value, limit) {
+  if (codePointLength(value) <= limit) return { value, truncated: false };
+  return { value: [...value].slice(0, limit).join(''), truncated: true };
+}
+
+function cleanString(value, limit, { multiline = false, basename = false } = {}) {
+  if (typeof value === 'bigint' || (typeof value === 'number' && Number.isFinite(value))) {
+    value = String(value);
+  }
+  if (typeof value !== 'string') return { value: undefined, truncated: false };
+  let cleaned = value.replace(/\r\n?/gu, '\n').replace(CONTROL_CHARACTERS, '');
+  if (!multiline) cleaned = cleaned.replace(/\s+/gu, ' ');
+  if (basename) cleaned = cleaned.replaceAll('\\', '/').split('/').at(-1) ?? '';
+  cleaned = cleaned.trim();
+  if (!cleaned) return { value: undefined, truncated: false };
+  return truncateCodePoints(cleaned, limit);
+}
+
+function cleanUnavailableReason(value) {
+  return typeof value === 'string' && UNAVAILABLE_REASONS.has(value) ? value : undefined;
+}
+
+function cleanAttachments(value) {
+  if (!Array.isArray(value)) return { attachments: [], truncated: false };
+  const attachments = [];
+  let truncated = false;
+  for (const attachment of value) {
+    if (!objectReference(attachment)) continue;
+    if (attachments.length === REPLY_ATTACHMENTS_MAX) {
+      truncated = true;
+      break;
+    }
+    const kind = ATTACHMENT_KINDS.has(attachment.kind) ? attachment.kind : 'other';
+    const name = cleanString(attachment.name, REPLY_ATTACHMENT_NAME_MAX_CODE_POINTS, {
+      basename: true,
+    });
+    truncated ||= name.truncated;
+    attachments.push({ kind, ...(name.value ? { name: name.value } : {}) });
+  }
+  return { attachments, truncated };
+}
+
+function errorUnavailableReason(error) {
+  const supplied = cleanUnavailableReason(error?.code);
+  if (supplied) return supplied;
+  const status = Number(error?.status ?? error?.statusCode ?? error?.response?.status);
+  if (status === 401 || status === 403) return 'permission-denied';
+  if (status === 404) return 'not-found';
+  if (status === 410) return 'deleted';
+  return 'not-delivered';
+}
+
+function mergeDefined(base, loaded) {
+  const merged = { ...base };
+  for (const key of [
+    'messageId', 'authorId', 'authorName', 'content', 'attachments', 'unavailableReason',
+  ]) {
+    if (loaded[key] !== undefined) merged[key] = loaded[key];
+  }
+  return merged;
+}
+
+async function resolveReference(reference, signal) {
+  if (typeof reference.load !== 'function') return reference;
+  signal?.throwIfAborted();
+  try {
+    const loaded = await reference.load({ signal });
+    signal?.throwIfAborted();
+    if (loaded === null) return { ...reference, unavailableReason: 'not-found' };
+    if (!objectReference(loaded)) {
+      return { ...reference, unavailableReason: 'not-delivered' };
+    }
+    return mergeDefined(reference, loaded);
+  } catch (error) {
+    if (signal?.aborted) signal.throwIfAborted();
+    return { ...reference, unavailableReason: errorUnavailableReason(error) };
+  }
+}
+
+function normalizeReference(reference) {
+  const messageId = cleanString(reference.messageId, REPLY_ID_MAX_CODE_POINTS);
+  const authorId = cleanString(reference.authorId, REPLY_ID_MAX_CODE_POINTS);
+  const authorName = cleanString(reference.authorName, REPLY_AUTHOR_NAME_MAX_CODE_POINTS);
+  const content = cleanString(reference.content, REPLY_CONTENT_MAX_CODE_POINTS, { multiline: true });
+  const { attachments, truncated: attachmentsTruncated } = cleanAttachments(reference.attachments);
+  let unavailableReason = cleanUnavailableReason(reference.unavailableReason);
+  if (!content.value && attachments.length === 0 && !unavailableReason) {
+    unavailableReason = 'not-delivered';
+  }
+  return {
+    note: REPLY_NOTE,
+    ...(messageId.value ? { messageId: messageId.value } : {}),
+    ...(authorId.value ? { authorId: authorId.value } : {}),
+    ...(authorName.value ? { authorName: authorName.value } : {}),
+    ...(content.value ? { content: content.value } : {}),
+    attachments,
+    ...(unavailableReason ? { unavailableReason } : {}),
+    truncated: messageId.truncated
+      || authorId.truncated
+      || authorName.truncated
+      || content.truncated
+      || attachmentsTruncated,
+  };
+}
+
+function replyBlock(reference) {
+  const json = JSON.stringify(reference).replace(/[<>&]/gu, (character) => ({
+    '<': '\\u003c',
+    '>': '\\u003e',
+    '&': '\\u0026',
+  })[character]);
+  return `<dsh_im_reply_to>${json}</dsh_im_reply_to>`;
+}
+
+export function hasReplyReference(message) {
+  return objectReference(message?.replyTo);
+}
+
+export async function promptContentForInboundMessage(message, { signal } = {}) {
+  if (!hasReplyReference(message)) {
+    return promptContentForMessage(message, { signal });
+  }
+  const reference = normalizeReference(await resolveReference(message.replyTo, signal));
+  const currentContent = await promptContentForMessage(message, { signal });
+  return [{ type: 'text', text: replyBlock(reference) }, ...currentContent];
+}

package/src/channels/shared/session-reply-recovery.mjs

@@ -0,0 +1,104 @@
+function assistantText(event) {
+  if (event?.type !== 'assistant/message'
+    || !Number.isSafeInteger(event.data?.turn)
+    || event.data.turn < 0
+    || !Array.isArray(event.data?.message?.content)) return null;
+  const text = event.data.message.content
+    .flatMap((block) => (block?.type === 'text' && typeof block.text === 'string'
+      ? [block.text]
+      : []))
+    .join('\n')
+    .trim();
+  return text ? { turn: event.data.turn, time: event.time, text } : null;
+}
+
+function completedAssistantTurns(events) {
+  const starts = new Map();
+  const assistants = new Map();
+  const completed = [];
+  for (const event of [...events].sort((left, right) => left.seq - right.seq)) {
+    if (event?.type === 'turn/start' && Number.isSafeInteger(event.data?.turn)) {
+      starts.set(event.data.turn, event.time);
+    }
+    const assistant = assistantText(event);
+    if (assistant) assistants.set(assistant.turn, assistant);
+    if (event?.type !== 'turn/end' || !Number.isSafeInteger(event.data?.turn)) continue;
+    const final = assistants.get(event.data.turn);
+    assistants.delete(event.data.turn);
+    if ((event.data?.reason?.kind ?? event.data?.reason) !== 'completed' || !final) continue;
+    completed.push({
+      ...final,
+      startedAt: starts.get(event.data.turn),
+      completedAt: event.time,
+    });
+  }
+  return completed;
+}
+
+function matchingAssistantText(events, quotedAt, toleranceMs) {
+  const candidates = completedAssistantTurns(events).filter((entry) => {
+    if (Number.isFinite(entry.time) && Math.abs(entry.time - quotedAt) <= toleranceMs) {
+      return true;
+    }
+    return Number.isFinite(entry.startedAt) && Number.isFinite(entry.completedAt)
+      && quotedAt >= entry.startedAt - toleranceMs
+      && quotedAt <= entry.completedAt + toleranceMs;
+  });
+  return candidates.length === 1 ? candidates[0].text : null;
+}
+
+/**
+ * Recover one completed assistant answer near a provider message timestamp.
+ *
+ * @param {object} options Recovery inputs.
+ * @param {{readHistory: Function}} options.session Bound Harness Session handle.
+ * @param {number} options.quotedAt Provider message timestamp in milliseconds.
+ * @param {AbortSignal} [options.signal] Caller cancellation signal.
+ * @param {number} [options.pageSize=100] History events requested per page.
+ * @param {number} [options.maxPages=3] Maximum history pages to inspect.
+ * @param {number} [options.timeoutMs=5000] Total history read deadline.
+ * @param {number} [options.toleranceMs=15000] Provider/session clock tolerance.
+ * @returns {Promise<string|null>} The unique matching answer, or null.
+ */
+export async function recoverAssistantTextByTimestamp({
+  session,
+  quotedAt,
+  signal: callerSignal,
+  pageSize = 100,
+  maxPages = 3,
+  timeoutMs = 5_000,
+  toleranceMs = 15_000,
+} = {}) {
+  if (typeof session?.readHistory !== 'function' || !Number.isFinite(quotedAt)) return null;
+  const timeout = AbortSignal.timeout(timeoutMs);
+  const signal = callerSignal ? AbortSignal.any([callerSignal, timeout]) : timeout;
+  const deadline = Date.now() + timeoutMs;
+  const events = new Map();
+  let beforeSeq;
+  for (let pageIndex = 0; pageIndex < maxPages; pageIndex += 1) {
+    signal.throwIfAborted();
+    const page = await session.readHistory({
+      maxMessages: pageSize,
+      ...(beforeSeq === undefined ? {} : { beforeSeq }),
+      timeoutMs: Math.max(1, deadline - Date.now()),
+      signal,
+    });
+    if (!page || !Array.isArray(page.events) || typeof page.hasMore !== 'boolean') return null;
+    let oldestSeq = beforeSeq ?? Infinity;
+    let oldestTime = Infinity;
+    for (const entry of page.events) {
+      const event = entry?.event;
+      if (!event || !Number.isSafeInteger(event.seq) || event.seq < 0) continue;
+      events.set(event.seq, event);
+      oldestSeq = Math.min(oldestSeq, event.seq);
+      if (Number.isFinite(event.time)) oldestTime = Math.min(oldestTime, event.time);
+    }
+    const text = matchingAssistantText([...events.values()], quotedAt, toleranceMs);
+    const passedTarget = oldestTime <= quotedAt - toleranceMs;
+    if (text && (passedTarget || !page.hasMore)) return text;
+    if (!page.hasMore || passedTarget
+      || !Number.isFinite(oldestSeq) || oldestSeq === beforeSeq) break;
+    beforeSeq = oldestSeq;
+  }
+  return null;
+}

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

@@ -5,7 +5,7 @@ const CSI_SEQUENCE = /(?:\u001b\[|\u009b)[0-?]*[ -/]*[@-~]/gu;
 const ESC_SEQUENCE = /\u001b[@-_]/gu;
 const CONTROL_CHARACTER = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/gu;
 const DIRECTIONAL_CONTROL = /[\u200b\u200e\u200f\u202a-\u202e\u2060-\u2064\u2066-\u206f\ufeff]/gu;
-const INJECTED_CONTEXT_PREFIX = /^(?:<dsh_im_source>[\s\S]*?<\/dsh_im_source>\s*)?(?:<dsh_im_source_guidance>[\s\S]*?<\/dsh_im_source_guidance>\s*)?/u;
+const INJECTED_CONTEXT_PREFIX = /^(?:<dsh_im_source>[\s\S]*?<\/dsh_im_source>\s*)?(?:<dsh_im_source_guidance>[\s\S]*?<\/dsh_im_source_guidance>\s*)?(?:<dsh_im_reply_to>[\s\S]*?<\/dsh_im_reply_to>\s*)?/u;
 const SEGMENTER = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
 
 function cleanTitleText(input) {

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

@@ -35,7 +35,6 @@ import {
   hasInboundImages,
   imagePromptDiagnostic,
   imagePromptUserMessage,
-  promptContentForMessage,
 } from './image-prompt.mjs';
 import {
   hasInboundFiles,
@@ -47,6 +46,10 @@ import {
   validHarnessQuestion,
 } from './harness-question.mjs';
 import { deliverOutboundArtifacts } from './semantic/artifact-delivery.mjs';
+import {
+  hasReplyReference,
+  promptContentForInboundMessage,
+} from './semantic/reply-reference.mjs';
 import {
   createDeliveryReceipt,
   createTextDeliveryBlock,
@@ -283,7 +286,8 @@ export class TextHarnessBridge {
         plainText: Boolean(text)
           && normalized.plainText !== false
           && !hasInboundImages(normalized)
-          && !hasInboundFiles(normalized),
+          && !hasInboundFiles(normalized)
+          && !hasReplyReference(normalized),
       });
       if (batch.handled) {
         if (batch.kind === 'submit') {
@@ -301,7 +305,8 @@ export class TextHarnessBridge {
         plainText: Boolean(text)
           && normalized.plainText !== false
           && !hasInboundImages(normalized)
-          && !hasInboundFiles(normalized),
+          && !hasInboundFiles(normalized)
+          && !hasReplyReference(normalized),
       });
       if (batch.handled) {
         return this.#finishLocalMessage(normalized, messageId, batch.message);
@@ -575,7 +580,8 @@ export class TextHarnessBridge {
       }
       const hasImages = hasInboundImages(message);
       const hasFiles = hasInboundFiles(message);
-      if (!text && !hasImages && !hasFiles) {
+      const hasReply = hasReplyReference(message);
+      if (!text && !hasImages && !hasFiles && !hasReply) {
         await this.#bot.sendText(target, t('目前支持文字、图片和文件消息。'));
         return;
       }
@@ -669,8 +675,8 @@ export class TextHarnessBridge {
           );
         }
       }
-      let content = hasImages
-        ? await promptContentForMessage(message, { signal: this.#signal })
+      let content = hasImages || hasReply
+        ? await promptContentForInboundMessage(message, { signal: this.#signal })
         : undefined;
       const snapshot = this.#acceptedMessageIds.get(messageId);
       let contextEnhanced = false;

package/src/channels/slack/manifest.mjs

@@ -17,9 +17,12 @@ oauth_config:
     bot:
       - app_mentions:read
       - chat:write
+      - channels:history
       - files:read
       - files:write
+      - groups:history
       - im:history
+      - mpim:history
       - reactions:write
 settings:
   event_subscriptions:

package/src/channels/slack/slack-api.mjs

@@ -246,6 +246,24 @@ export class SlackApi {
     return value.file;
   }
 
+  async getMessage({ channelId, messageTs, signal } = {}) {
+    const timestamp = requiredString(messageTs, 'message timestamp');
+    const value = await this.#request('conversations.history', {
+      tokenKind: 'bot',
+      signal,
+      body: {
+        channel: slackId(channelId, 'channel id'),
+        oldest: timestamp,
+        latest: timestamp,
+        inclusive: true,
+        limit: 1,
+      },
+    });
+    return Array.isArray(value?.messages)
+      ? value.messages.find((message) => String(message?.ts ?? '') === timestamp) ?? null
+      : null;
+  }
+
   postMessage({ channelId, text, threadTs, signal }) {
     return this.#request('chat.postMessage', {
       tokenKind: 'bot',

package/src/channels/slack/slack-runtime.mjs

@@ -49,6 +49,58 @@ function slackFileUrl(file) {
     ? file.url_private_download : file?.url_private;
 }
 
+function slackReplyAttachment(file) {
+  if (!file || typeof file !== 'object') return null;
+  const mediaType = typeof file.mimetype === 'string' ? file.mimetype.toLowerCase() : '';
+  const kind = mediaType.startsWith('image/') ? 'image'
+    : mediaType.startsWith('audio/') ? 'audio'
+      : mediaType.startsWith('video/') ? 'video' : 'file';
+  const name = typeof file.name === 'string' && file.name
+    ? file.name : typeof file.title === 'string' && file.title ? file.title : undefined;
+  return { kind, ...(name ? { name } : {}) };
+}
+
+function slackReplySnapshot(message, messageTs) {
+  if (!message || String(message.ts ?? '') !== messageTs) return null;
+  const authorId = typeof message.user === 'string' && message.user
+    ? message.user : typeof message.bot_id === 'string' && message.bot_id
+      ? message.bot_id : undefined;
+  const authorName = typeof message.username === 'string' && message.username
+    ? message.username : undefined;
+  return {
+    messageId: messageTs,
+    ...(authorId ? { authorId } : {}),
+    ...(authorName ? { authorName } : {}),
+    content: decodeSlackText(message.text ?? ''),
+    attachments: Array.isArray(message.files)
+      ? message.files.map(slackReplyAttachment).filter(Boolean)
+      : [],
+  };
+}
+
+function slackThreadReplyReference(event, loadReply) {
+  const messageTs = typeof event?.thread_ts === 'string' ? event.thread_ts : '';
+  if (!messageTs || messageTs === String(event?.ts ?? '')) return undefined;
+  return {
+    messageId: messageTs,
+    load: async ({ signal } = {}) => {
+      try {
+        const message = await loadReply({
+          channelId: String(event.channel),
+          messageTs,
+          signal,
+        });
+        return slackReplySnapshot(message, messageTs);
+      } catch (error) {
+        if (error?.code === 'slack-missing-scope') {
+          return { messageId: messageTs, unavailableReason: 'permission-denied' };
+        }
+        throw error;
+      }
+    },
+  };
+}
+
 function slackImageSource(file, loadFile) {
   const mediaType = typeof file?.mimetype === 'string' ? file.mimetype.toLowerCase() : '';
   const url = slackFileUrl(file);
@@ -104,6 +156,7 @@ export function normalizeSlackEvent(payload, botUserId, {
   loadFile = async () => { throw new Error('Slack file downloader is unavailable'); },
   loadFileStream = loadFile,
   loadFileInfo = async () => { throw new Error('Slack file metadata loader is unavailable'); },
+  loadReply = async () => { throw new Error('Slack reply loader is unavailable'); },
 } = {}) {
   const event = payload?.event;
   if (!event || !payload?.event_id || !event.channel || !event.user || !event.ts) return null;
@@ -112,6 +165,7 @@ export function normalizeSlackEvent(payload, botUserId, {
   if (!direct && !mentioned) return null;
   if ((event.subtype && event.subtype !== 'file_share') || event.bot_id || event.app_id) return null;
   const threadTs = String(event.thread_ts ?? event.ts);
+  const replyTo = slackThreadReplyReference(event, loadReply);
   return {
     messageId: String(payload.event_id),
     senderId: String(event.user),
@@ -126,6 +180,7 @@ export function normalizeSlackEvent(payload, botUserId, {
     files: Array.isArray(event.files)
       ? event.files.map((file) => slackFileSource(file, loadFileStream, loadFileInfo)).filter(Boolean)
       : [],
+    ...(replyTo ? { replyTo } : {}),
     addressed: direct || mentioned,
     reactionTarget: {
       channelId: String(event.channel),
@@ -555,6 +610,7 @@ export class SlackRuntime {
           loadFile: (url, options) => this.#api.downloadFile({ url, ...options }),
           loadFileStream: (url, options) => this.#api.downloadFileStream({ url, ...options }),
           loadFileInfo: (fileId, options) => this.#api.fileInfo({ fileId, ...options }),
+          loadReply: (options) => this.#api.getMessage(options),
         });
         const bridge = this.#bridge;
         if (message && bridge) {

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

@@ -4,6 +4,7 @@ import { createEditableMessageStream, splitMessageText } from '../shared/editabl
 import { createTextDeliveryBlock } from '../shared/semantic/delivery.mjs';
 import { t } from '../shared/i18n.mjs';
 import { captureContextEnhancement } from '../shared/context-enhancement.mjs';
+import { recoverAssistantTextByTimestamp } from '../shared/session-reply-recovery.mjs';
 import { COMMANDS_MENU_BUTTON, TelegramApi } from './telegram-api.mjs';
 import { createTelegramHttpTransport } from './telegram-http.mjs';
 import { createTelegramBridgeStatus, TelegramHarnessBridge } from './telegram-bridge.mjs';
@@ -138,11 +139,94 @@ function telegramFileSource(message, loadFile) {
   };
 }
 
+function telegramReplyAttachment(kind, file, fallbackName) {
+  if (!file || typeof file !== 'object') return null;
+  const name = typeof file.file_name === 'string' && file.file_name
+    ? file.file_name : typeof fallbackName === 'string' && fallbackName
+      ? fallbackName : undefined;
+  return { kind, ...(name ? { name } : {}) };
+}
+
+function telegramReplyAttachments(message) {
+  const attachments = [];
+  if (Array.isArray(message?.photo) && message.photo.length > 0) {
+    const largest = message.photo.reduce((best, candidate) => (
+      photoScore(candidate) > photoScore(best) ? candidate : best
+    ));
+    attachments.push(telegramReplyAttachment(
+      'image',
+      largest,
+      `${largest.file_unique_id ?? largest.file_id ?? 'telegram-photo'}.jpg`,
+    ));
+  } else if (message?.document) {
+    attachments.push(telegramReplyAttachment(
+      imageTypeForDocument(message.document) ? 'image' : 'file',
+      message.document,
+    ));
+  }
+  for (const [field, kind] of [
+    ['audio', 'audio'],
+    ['voice', 'audio'],
+    ['video', 'video'],
+    ['video_note', 'video'],
+    ['animation', 'video'],
+  ]) {
+    if (message?.[field]) attachments.push(telegramReplyAttachment(kind, message[field]));
+  }
+  if (message?.sticker) {
+    attachments.push(telegramReplyAttachment(
+      message.sticker.is_video === true ? 'video' : 'image',
+      message.sticker,
+      message.sticker.file_unique_id ?? message.sticker.file_id,
+    ));
+  }
+  return attachments.filter(Boolean);
+}
+
+function telegramReplyReference(message, { quote, loadReplyContent } = {}) {
+  if ((!message || typeof message !== 'object')
+    && (!quote || typeof quote !== 'object')) return undefined;
+  const authorId = message?.from?.id === undefined ? undefined : String(message.from.id);
+  const authorName = [message?.from?.first_name, message?.from?.last_name]
+    .filter((value) => typeof value === 'string' && value.trim())
+    .map((value) => value.trim()).join(' ') || (
+      typeof message?.from?.username === 'string' && message.from.username
+        ? message.from.username : undefined
+    );
+  const content = typeof message?.text === 'string'
+    ? message.text : typeof message?.caption === 'string'
+      ? message.caption : typeof quote?.text === 'string' ? quote.text : '';
+  const attachments = telegramReplyAttachments(message);
+  const messageId = Number.isSafeInteger(message?.message_id)
+    ? String(message.message_id) : undefined;
+  const createdAt = Number.isSafeInteger(message?.date) && message.date >= 0
+    ? message.date * 1_000 : undefined;
+  const load = !content.trim() && attachments.length === 0
+    && typeof loadReplyContent === 'function'
+    ? ({ signal } = {}) => loadReplyContent({
+        ...(messageId ? { messageId } : {}),
+        ...(createdAt === undefined ? {} : { createdAt }),
+      }, { signal })
+    : null;
+  return {
+    ...(messageId ? { messageId } : {}),
+    ...(authorId ? { authorId } : {}),
+    ...(authorName ? { authorName } : {}),
+    ...(content.trim() ? { content } : {}),
+    ...(attachments.length > 0 ? { attachments } : {}),
+    ...(load ? { load } : {}),
+    ...(!content.trim() && attachments.length === 0 && !load
+      ? { unavailableReason: 'not-delivered' }
+      : {}),
+  };
+}
+
 export function normalizeTelegramUpdate(update, {
   botId,
   username,
   loadFile = async () => { throw new Error('Telegram file downloader is unavailable'); },
   loadFileStream = loadFile,
+  loadReplyContent,
 }) {
   const message = update?.message;
   const chatId = message?.chat?.id;
@@ -159,6 +243,21 @@ export function normalizeTelegramUpdate(update, {
     ? message.message_thread_id : undefined;
   const image = telegramImageSource(message, loadFile);
   const file = telegramFileSource(message, loadFileStream);
+  const conversationId = messageThreadId === undefined
+    ? String(chatId) : `${chatId}:${messageThreadId}`;
+  const key = `${direct ? 'direct' : 'group'}:${conversationId}`;
+  const replyTo = telegramReplyReference(
+    message.reply_to_message ?? message.external_reply,
+    {
+      quote: message.quote,
+      ...(typeof loadReplyContent === 'function' ? {
+        loadReplyContent: (reference, options) => loadReplyContent({
+          conversationKey: key,
+          ...reference,
+        }, options),
+      } : {}),
+    },
+  );
   return {
     messageId: String(update.update_id),
     senderId: String(senderId),
@@ -170,12 +269,12 @@ export function normalizeTelegramUpdate(update, {
     }),
     senderIsBot: message.from?.is_bot === true,
     kind: direct ? 'direct' : 'group',
-    conversationId: messageThreadId === undefined
-      ? String(chatId) : `${chatId}:${messageThreadId}`,
+    conversationId,
     content: withoutBotMention(message.text ?? message.caption ?? '', username),
     plainText: typeof message.text === 'string',
     images: image ? [image] : [],
     files: file ? [file] : [],
+    ...(replyTo ? { replyTo } : {}),
     addressed,
     reactionTarget: { chatId, messageId },
     replyTarget: {
@@ -839,6 +938,21 @@ export class TelegramRuntime {
     }
   }
 
+  async #loadReplyContent(reference, { signal } = {}) {
+    const key = typeof reference?.conversationKey === 'string'
+      ? reference.conversationKey.trim() : '';
+    const quotedAt = Number(reference?.createdAt);
+    if (!key || !Number.isFinite(quotedAt)) {
+      return { unavailableReason: 'not-delivered' };
+    }
+    const sessionId = this.#state.sessionFor(key);
+    const session = typeof sessionId === 'string' && sessionId
+      ? this.#harness.workspaceSession?.(sessionId)
+      : null;
+    const text = await recoverAssistantTextByTimestamp({ session, quotedAt, signal });
+    return text ? { content: text } : { unavailableReason: 'not-delivered' };
+  }
+
   async #poll(initialCursor, signal) {
     let cursor = initialCursor;
     while (!signal.aborted) {
@@ -863,6 +977,7 @@ export class TelegramRuntime {
           username: this.#config.username,
           loadFile: (fileId, options) => this.#api.downloadFile({ fileId, ...options }),
           loadFileStream: (fileId, options) => this.#api.downloadFileStream({ fileId, ...options }),
+          loadReplyContent: (reference, options) => this.#loadReplyContent(reference, options),
         });
         if (message) {
           void this.#bridge.accept(message, { contextSnapshot }).catch((error) => {