@xmanrui/dsh-im 4.38.2 → 4.39.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmanrui/dsh-im",
-  "version": "4.38.2",
+  "version": "4.39.0",
   "icon": "./assets/logo-plugin-message-link-gradient.webp",
   "description": "把微信、飞书、企微、钉钉、QQ、Telegram、WhatsApp、Slack、Discord、Matrix接入DSH。 Connect Telegram, WhatsApp, Slack, Discord, Matrix, WeChat, Feishu, WeCom, DingTalk, and QQ to DSH.",
   "keywords": [

package/plugin-src/host/injected-context.mjs

@@ -12,6 +12,9 @@ const REPLY_LABELS = Object.freeze({ zh: '\u5f15\u7528', en: 'Quoted' });
 /** Row label for a source block that names no readable field of its own. */
 const SOURCE_LABELS = Object.freeze({ zh: '\u6765\u6e90', en: 'Source' });
 
+/** Row label prefix for one collected conversation-context block. */
+const CONTEXT_LABELS = Object.freeze({ zh: '\u4e0a\u4e0b\u4e0b', en: 'Context' });
+
 /** Read the current reply-row label; an unknown language falls back to English. */
 function replyLabel() {
   try {
@@ -30,6 +33,15 @@ function sourceLabel() {
   }
 }
 
+/** Read the current context-row label; unknown languages fall back. */
+function contextLabel() {
+  try {
+    return getImHostLanguage() === 'en' ? CONTEXT_LABELS.en : CONTEXT_LABELS.zh;
+  } catch {
+    return CONTEXT_LABELS.en;
+  }
+}
+
 /**
  * Pair every injected context block with the user message that carried it, and
  * materialize the source guidance as session-level prompt context.
@@ -85,7 +97,7 @@ export function installInjectedContext(ctx, { logger, registry = imSourceGuidanc
     }
     try {
       const rewritten = rewriteInjectedContextMessages(decision.messages, {
-        labels: { reply: replyLabel(), source: sourceLabel() },
+        labels: { reply: replyLabel(), source: sourceLabel(), context: contextLabel() },
         ownedGuidance: registry.get(agent?.session?.id),
       });
       return rewritten === null ? decision : { ...decision, messages: rewritten };

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

@@ -250,6 +250,24 @@ export class MatrixApi {
     return await this.#request('whoami', { path: '/account/whoami', signal: options.signal });
   }
 
+  /**
+   * Reads one member's display name from the room state. The Matrix profile
+   * field is optional, so a homeserver without the member or without a name
+   * reads as null rather than an error.
+   * @param roomId - the room whose state to read.
+   * @param userId - the member's fully-qualified Matrix user id.
+   * @param options - `{ signal }` forwarding options.
+   * @returns {Promise<string|null>} the trimmed display name, or null when absent.
+   */
+  async getRoomMemberDisplayName(roomId, userId, options = {}) {
+    const event = await this.#request(`room member ${userId}`, {
+      path: `/rooms/${encodeURIComponent(roomId)}/state/members/${encodeURIComponent(userId)}`,
+      signal: options.signal,
+    }).catch(() => null);
+    const name = cleanString(event?.content?.displayname);
+    return name && name.length <= 256 ? name : null;
+  }
+
   async login({ identifier, password, deviceId, displayName }, options = {}) {
     const body = {
       type: 'm.login.password',
@@ -336,6 +354,22 @@ export class MatrixApi {
     });
   }
 
+  /**
+   * Single-event lookup used by the conversation context collectors to resolve a
+   * reply or thread root outside the retained sync window. The homeserver answers
+   * 404 for an unknown event, so a miss travels as null instead of an exception;
+   * an E2EE room returns the still-encrypted event and the caller decrypts it.
+   */
+  async getEvent(roomId, eventId, options = {}) {
+    if (!isMatrixRoomId(roomId) || !isMatrixEventId(eventId)) throw new TypeError('Matrix event lookup target is invalid');
+    return await this.#request('event', {
+      path: `/rooms/${encodeURIComponent(roomId)}/event/${encodeURIComponent(eventId)}`,
+      timeoutMs: 10_000,
+      signal: options.signal,
+    }).catch(() => null);
+  }
+
+
   async listRelations(roomId, eventId, relationType, options = {}) {
     if (!isMatrixRoomId(roomId) || !isMatrixEventId(eventId)) throw new TypeError('Matrix relation query target is invalid');
     if (!/^[m]?[A-Za-z0-9._-]{1,128}$/.test(String(relationType ?? ''))) throw new TypeError('Matrix relation type is invalid');

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

@@ -16,6 +16,18 @@ const MAX_MEDIA_BYTES_CEILING = 104_857_600;
 const ROOM_CONTEXT_LIMIT_BOUNDS = Object.freeze({ min: 1, max: 500 });
 const ROOM_CONTEXT_CHARS_BOUNDS = Object.freeze({ min: 200, max: 200_000 });
 const ROOM_CONTEXT_TZ_BOUNDS = Object.freeze({ min: -840, max: 840 });
+const CONTEXT_CHARS_BOUNDS = Object.freeze({ min: 200, max: 200_000 });
+const REPLY_DEPTH_BOUNDS = Object.freeze({ min: 1, max: 10 });
+const AMBIENT_GAP_BOUNDS = Object.freeze({ min: 5_000, max: 3_600_000 });
+const AMBIENT_WINDOW_BOUNDS = Object.freeze({ min: 10_000, max: 86_400_000 });
+const AMBIENT_COUNT_BOUNDS = Object.freeze({ min: 1, max: 200 });
+const VISIBLE_CONTEXT_WINDOW_BOUNDS = Object.freeze({ min: 0, max: 86_400_000 });
+const VISIBLE_CONTEXT_LIMIT_BOUNDS = Object.freeze({ min: 0, max: 500 });
+const VISIBLE_CONTEXT_CHARS_BOUNDS = Object.freeze({ min: 200, max: 200_000 });
+const COALESCE_WINDOW_BOUNDS = Object.freeze({ min: 0, max: 60_000 });
+const AUTO_STEER_LIMIT_BOUNDS = Object.freeze({ min: 0, max: 100 });
+const THREADS_MODES = Object.freeze(['inherit', 'isolate', 'auto']);
+const TRIGGER_ON_REPLY_MODES = Object.freeze(['any', 'bot-only', 'never']);
 
 function cleanString(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;
@@ -185,12 +197,31 @@ export class MatrixConfigStore {
     const roomContextLimit = boundedInteger(value.roomContextLimit, ROOM_CONTEXT_LIMIT_BOUNDS);
     const roomContextMaxChars = boundedInteger(value.roomContextMaxChars, ROOM_CONTEXT_CHARS_BOUNDS);
     const roomContextTzOffsetMinutes = boundedInteger(value.roomContextTzOffsetMinutes, ROOM_CONTEXT_TZ_BOUNDS);
+    const threadsMode = cleanString(value.threadsMode) ?? 'inherit';
+    const triggerOnReply = cleanString(value.triggerOnReply) ?? 'never';
+    const contextMaxChars = boundedInteger(value.contextMaxChars, CONTEXT_CHARS_BOUNDS);
+    const replyMaxDepth = boundedInteger(value.replyMaxDepth, REPLY_DEPTH_BOUNDS);
+    const ambientBurstGapMs = boundedInteger(value.ambientBurstGapMs, AMBIENT_GAP_BOUNDS);
+    const ambientRecentWindowMs = boundedInteger(value.ambientRecentWindowMs, AMBIENT_WINDOW_BOUNDS);
+    const ambientRecentCount = boundedInteger(value.ambientRecentCount, AMBIENT_COUNT_BOUNDS);
+    const visibleContextWindowMs = boundedInteger(value.visibleContextWindowMs, VISIBLE_CONTEXT_WINDOW_BOUNDS);
+    const visibleContextLimit = boundedInteger(value.visibleContextLimit, VISIBLE_CONTEXT_LIMIT_BOUNDS);
+    const visibleContextChars = boundedInteger(value.visibleContextChars, VISIBLE_CONTEXT_CHARS_BOUNDS);
+    const coalesceWindowMs = boundedInteger(value.coalesceWindowMs, COALESCE_WINDOW_BOUNDS);
+    const autoSteerLimit = boundedInteger(value.autoSteerLimit, AUTO_STEER_LIMIT_BOUNDS);
     if (!E2EE_MODES.has(e2eeMode) || !AUTO_JOIN_MODES.has(autoJoinInvites)
       || maxMessageLength === null || maxMediaBytes === null
       || allowedRooms === null || freeResponseRooms === null || ignoreUserPatterns === null
       || roomContextLimit === null || roomContextMaxChars === null
-      || roomContextTzOffsetMinutes === null) return null;
-    for (const key of ['requireMention', 'processNotices', 'allowRoomMentions', 'reactions', 'roomContextEnabled']) {
+      || roomContextTzOffsetMinutes === null
+      || !THREADS_MODES.includes(threadsMode) || !TRIGGER_ON_REPLY_MODES.includes(triggerOnReply)
+      || contextMaxChars === null || replyMaxDepth === null
+      || ambientBurstGapMs === null || ambientRecentWindowMs === null || ambientRecentCount === null
+      || visibleContextWindowMs === null || visibleContextLimit === null || visibleContextChars === null
+      || coalesceWindowMs === null || autoSteerLimit === null) return null;
+    for (const key of ['requireMention', 'processNotices', 'allowRoomMentions', 'reactions', 'roomContextEnabled',
+      'rootContextOnceEnabled', 'replyContextEnabled', 'ambientContextEnabled',
+      'visibleContextEnabled', 'autoSteerSameSender']) {
       if (value?.[key] !== undefined && typeof value[key] !== 'boolean') return null;
     }
     return Object.freeze({
@@ -220,6 +251,23 @@ export class MatrixConfigStore {
       ...(roomContextLimit !== undefined ? { roomContextLimit } : {}),
       ...(roomContextMaxChars !== undefined ? { roomContextMaxChars } : {}),
       ...(roomContextTzOffsetMinutes !== undefined ? { roomContextTzOffsetMinutes } : {}),
+      ...(threadsMode !== 'inherit' ? { threadsMode } : {}),
+      ...(triggerOnReply !== 'never' ? { triggerOnReply } : {}),
+      ...(typeof value.rootContextOnceEnabled === 'boolean' ? { rootContextOnceEnabled: value.rootContextOnceEnabled } : {}),
+      ...(typeof value.replyContextEnabled === 'boolean' ? { replyContextEnabled: value.replyContextEnabled } : {}),
+      ...(typeof value.ambientContextEnabled === 'boolean' ? { ambientContextEnabled: value.ambientContextEnabled } : {}),
+      ...(contextMaxChars !== undefined ? { contextMaxChars } : {}),
+      ...(replyMaxDepth !== undefined ? { replyMaxDepth } : {}),
+      ...(ambientBurstGapMs !== undefined ? { ambientBurstGapMs } : {}),
+      ...(ambientRecentWindowMs !== undefined ? { ambientRecentWindowMs } : {}),
+      ...(ambientRecentCount !== undefined ? { ambientRecentCount } : {}),
+      ...(typeof value.visibleContextEnabled === 'boolean' ? { visibleContextEnabled: value.visibleContextEnabled } : {}),
+      ...(visibleContextWindowMs !== undefined ? { visibleContextWindowMs } : {}),
+      ...(visibleContextLimit !== undefined ? { visibleContextLimit } : {}),
+      ...(visibleContextChars !== undefined ? { visibleContextChars } : {}),
+      ...(coalesceWindowMs !== undefined ? { coalesceWindowMs } : {}),
+      ...(typeof value.autoSteerSameSender === 'boolean' ? { autoSteerSameSender: value.autoSteerSameSender } : {}),
+      ...(autoSteerLimit !== undefined ? { autoSteerLimit } : {}),
     });
   }
 

package/src/channels/matrix/matrix-normalize.mjs

@@ -7,6 +7,8 @@
  */
 
 import { isMatrixEventId, isMatrixRoomId, isMatrixUserId } from './matrix-api.mjs';
+import { buildConversationRoute, encodeConversationRouteKey } from '../shared/conversation/route.mjs';
+import { evaluateTrigger } from '../shared/conversation/trigger-policy.mjs';
 
 const GRACE_MS = 5_000;
 const SKEW_OBSERVE_AFTER_MS = 30_000;
@@ -219,7 +221,8 @@ function eventOriginTs(event) {
   return Number.isSafeInteger(ts) && ts > 0 ? (ts < 1e12 ? ts * 1_000 : ts) : null;
 }
 
-function threadIdOf(content) {
+/** The thread root a timeline event belongs to, from its MSC3402 relations. */
+export function threadIdOf(content) {
   const relates = content?.['m.relates_to'];
   if (!relates || typeof relates !== 'object') return null;
   const chain = Array.isArray(relates.chain) ? relates.chain : [];
@@ -228,12 +231,39 @@ function threadIdOf(content) {
   return eventId && isMatrixEventId(eventId) ? eventId : null;
 }
 
-function replyEventIdOf(content) {
-  const inReplyTo = content?.['m.relates_to']?.['m.in_reply_to'];
-  const eventId = typeof inReplyTo?.event_id === 'string' ? inReplyTo.event_id : null;
+function cleanEventId(value) {
+  const eventId = typeof value === 'string' ? value.trim() : '';
   return eventId && isMatrixEventId(eventId) ? eventId : null;
 }
 
+/**
+ * The target of a genuine reply relation, in either relation form the Matrix
+ * spec permits: the new form names it under `m.relates_to` with
+ * `rel_type: "m.reply"`, the legacy form under the top-level `m.in_reply_to`,
+ * and this plugin's own writer nests it under `m.relates_to` for the events it
+ * sends itself. The `is_falling_back` marker — at `m.relates_to`, at the
+ * legacy `m.in_reply_to`, or on the nested form — demotes the declaration to
+ * the thread-membership statement clients attach automatically when sending
+ * inside a thread; per the spec that is not a human reply, so it must not
+ * drive reply context collection, reply classification, recorded reply targets,
+ * or the thread fork decision.
+ */
+export function replyEventIdOf(content) {
+  const relates = content?.['m.relates_to'];
+  const legacy = content?.['m.in_reply_to'];
+  const nested = relates?.['m.in_reply_to'];
+  if (relates?.is_falling_back === true || legacy?.is_falling_back === true || nested?.is_falling_back === true) return null;
+  if (relates?.rel_type === 'm.reply') {
+    const target = cleanEventId(relates.event_id);
+    if (target) return target;
+  }
+  for (const candidate of [legacy?.event_id, nested?.event_id]) {
+    const target = cleanEventId(candidate);
+    if (target) return target;
+  }
+  return null;
+}
+
 /**
  * Project one timeline event into the normalized bridge message, or into a
  * typed drop reason. The order of gates is fixed: self, bridge/system,
@@ -281,10 +311,28 @@ export function normalizeMatrixTimelineEvent({
   const rawText = typeof content.body === 'string' ? content.body : '';
   const mentioned = detectMatrixMention(content, botUserId);
   const commandLike = isMatrixCommandLike(rawText);
-  const requiresMention = kind === 'group'
-    && config.requireMention !== false
-    && !(config.freeResponseRooms instanceof Set && config.freeResponseRooms.has(roomId));
-  if (requiresMention && !mentioned && !commandLike && replyToEventId === null) return { drop: 'mention-required' };
+  // One table decides the mention gate and the addressed bit, shared with other
+  // channels through the trigger policy. `triggerOnReply` defaults to 'never' —
+  // a room message wakes the bot only through an @-mention or a command, so an
+  // unaddressed reply on the room timeline or in a thread stays a recorded fact.
+  // 'any' restores the 4.25-era shape where every reply relation addresses the
+  // bot; 'bot-only' requires the channel's classifier (usually the bot-event
+  // binding table) to prove the reply answers one of the bot's own messages.
+  const replyTargetKind = kind === 'group' && replyToEventId !== null
+    && typeof deps.classifyReplyTarget === 'function'
+    ? deps.classifyReplyTarget(replyToEventId) ?? null
+    : null;
+  const gate = evaluateTrigger({
+    kind,
+    requireMention: config.requireMention,
+    freeResponse: config.freeResponseRooms instanceof Set && config.freeResponseRooms.has(roomId),
+    mentioned,
+    commandLike,
+    replyToPresent: replyToEventId !== null,
+    replyTargetKind,
+    replyMode: config.triggerOnReply,
+  });
+  if (!gate.pass) return { drop: gate.reason };
 
   const text = stripMatrixMentions(rawText, botUserId);
   const media = MEDIA_MSGTYPES.has(msgtype)
@@ -293,9 +341,42 @@ export function normalizeMatrixTimelineEvent({
   if (MEDIA_MSGTYPES.has(msgtype) && !media) return { drop: 'media-unusable' };
   if (msgtype !== 'm.text' && msgtype !== 'm.notice' && !MEDIA_MSGTYPES.has(msgtype)) return { drop: 'type' };
 
-  const conversationId = kind === 'direct'
-    ? `dm:${senderId.toLowerCase()}`
-    : `room:${roomId}${threadId ? `$${threadId}` : ''}`;
+  // Thread conversation fork policy. A genuine reply whose thread root equals
+  // its reply target says "answer this message" — the client started a thread at
+  // the replied-to event — so it inherits the conversation its target belongs to
+  // (the room's main conversation) instead of forking a fresh session. The
+  // thread-membership declaration clients attach automatically (a falling-back
+  // relation) is not a human reply and never selects a conversation: posts made
+  // inside a thread fork that thread's own conversation. A reply to a root the
+  // bot itself authored does the same — the panel under a bot answer is read as
+  // its own message list, not as a continuation of the mainline turn the answer
+  // once replied to. `isolate` restores fork-always; `auto` prefers the
+  // bot-event binding table when the channel supplies one for the reply target.
+  const threadsMode = config.threadsMode === 'isolate' || config.threadsMode === 'auto'
+    ? config.threadsMode
+    : 'inherit';
+  const rootIsBotAuthored = kind === 'group' && threadId !== null
+    && ((typeof deps.classifyReplyTarget === 'function' && deps.classifyReplyTarget(threadId) === 'bot')
+      || (typeof deps.isBotRoomEvent === 'function' && deps.isBotRoomEvent(roomId, threadId) === true));
+  const inheritsThreadTarget = kind === 'group' && threadId !== null
+    && threadsMode !== 'isolate' && replyToEventId === threadId && !rootIsBotAuthored;
+  const routeThreadId = kind === 'group' && threadId !== null && !inheritsThreadTarget ? threadId : null;
+  const boundRouteKey = threadsMode === 'auto' && kind === 'group' && replyToEventId !== null
+    && typeof deps.routeOverrideForReply === 'function'
+    ? deps.routeOverrideForReply(replyToEventId)
+    : null;
+  const routeKey = typeof boundRouteKey === 'string' && boundRouteKey
+    ? boundRouteKey
+    : encodeConversationRouteKey(buildConversationRoute({
+      channel: 'matrix',
+      botId: config.botId ?? null,
+      chatId: roomId,
+      senderId,
+      threadId: routeThreadId,
+      kind,
+    }));
+  const keyPrefix = kind === 'direct' ? 'direct:' : 'group:';
+  const conversationId = routeKey.startsWith(keyPrefix) ? routeKey.slice(keyPrefix.length) : routeKey;
 
   return {
     message: {
@@ -310,7 +391,7 @@ export function normalizeMatrixTimelineEvent({
       plainText: msgtype === 'm.text' && content.format !== 'org.matrix.custom.html',
       images: media?.images ?? [],
       files: media?.files ?? [],
-      addressed: kind === 'direct' || mentioned || commandLike || replyToEventId !== null,
+      addressed: gate.addressed,
       mentioned,
       threadId,
       replyToEventId,
@@ -352,6 +433,17 @@ export function normalizeMatrixDeliveryTarget({ kind, route } = {}) {
 
 export function matrixConversationKeyFromTarget(target) {
   if (!target) return null;
-  if (target.kind === 'dm') return `dm:${target.userId.toLowerCase()}`;
-  return `room:${target.roomId}${'threadId' in target && target.threadId ? `$${target.threadId}` : ''}`;
+  if (target.kind === 'dm') {
+    return encodeConversationRouteKey(buildConversationRoute({
+      channel: 'matrix',
+      chatId: target.userId,
+      senderId: target.userId,
+      kind: 'dm',
+    })).slice('direct:'.length);
+  }
+  return encodeConversationRouteKey(buildConversationRoute({
+    channel: 'matrix',
+    chatId: target.roomId,
+    threadId: 'threadId' in target ? target.threadId : null,
+  })).slice('group:'.length);
 }