@xmanrui/dsh-im 4.38.2 → 4.39.0

package/src/channels/shared/conversation/trigger-policy.mjs

@@ -0,0 +1,80 @@
+/**
+ * The trigger rule table: which inbound message may wake the AI, and which is
+ * only recorded by the channel. The rules are a pure function over the bits an
+ * adapter already extracted (mention, command shape, reply relation) plus an
+ * optional synchronous classification of a reply's target, so the decision is
+ * testable without any transport.
+ *
+ * `replyMode` is what separates the product shapes a room bot can have; the
+ * shipped default is `never`, so a room only wakes the bot through an
+ * @-mention or a command:
+ * - `never`: replies never address the bot; only mentions and commands do.
+ * - `bot-only`: only replies that provably answer one of the bot's own messages
+ *   address it; a reply to a human message is not a trigger and an
+ *   unclassifiable target stays unaddressed too, so the classifier (usually the
+ *   bot-event binding table) must be wired before this mode is enabled.
+ * - `any`: the 4.25-era room shape — a reply relation anywhere addresses the bot.
+ */
+
+export const TRIGGER_REPLY_MODES = Object.freeze(['any', 'bot-only', 'never']);
+
+export function normalizeTriggerPolicy({ requireMention = true, freeResponse = false, replyMode = 'never' } = {}) {
+  return Object.freeze({
+    requireMention: requireMention !== false,
+    freeResponse: freeResponse === true,
+    replyMode: TRIGGER_REPLY_MODES.includes(replyMode) ? replyMode : 'never',
+  });
+}
+
+/**
+ * @typedef {Object} TriggerDecision
+ * @property {boolean} pass      Whether the inbound funnel may keep the message.
+ * @property {boolean} addressed Whether the message counts as addressed.
+ * @property {string} reason     Stable drop/accept label ('mention', 'command', 'reply',
+ *   'reply-to-human', 'reply-target-unknown', 'dm', 'free-response', 'mention-required', ...).
+ */
+
+/**
+ * Decide the mention gate and the addressed bit for one message.
+ * @param {Object} input
+ * @param {'group'|'direct'|'dm'} input.kind
+ * @param {boolean} [input.requireMention=true]
+ * @param {boolean} [input.freeResponse=false]  Room-level override that opens the gate.
+ * @param {boolean} [input.mentioned=false]
+ * @param {boolean} [input.commandLike=false]
+ * @param {boolean} [input.replyToPresent=false]
+ * @param {('bot'|'human'|null)} [input.replyTargetKind=null] Synchronous classification of the reply target.
+ * @param {('any'|'bot-only'|'never')} [input.replyMode='never']
+ * @returns {TriggerDecision}
+ */
+export function evaluateTrigger({
+  kind = 'group',
+  requireMention = true,
+  freeResponse = false,
+  mentioned = false,
+  commandLike = false,
+  replyToPresent = false,
+  replyTargetKind = null,
+  replyMode = 'never',
+} = {}) {
+  const policy = normalizeTriggerPolicy({ requireMention, freeResponse, replyMode });
+  if (kind === 'direct' || kind === 'dm') return Object.freeze({ pass: true, addressed: true, reason: 'dm' });
+  const gateOpen = !policy.requireMention || policy.freeResponse;
+  const replyCounts = replyToPresent && policy.replyMode !== 'never'
+    && !(policy.replyMode === 'bot-only' && replyTargetKind !== 'bot');
+  const addressed = mentioned === true || commandLike === true || replyCounts;
+  if (!gateOpen && !addressed) {
+    if (policy.replyMode === 'bot-only' && replyToPresent && replyTargetKind === 'human') {
+      return Object.freeze({ pass: false, addressed: false, reason: 'reply-to-human' });
+    }
+    if (policy.replyMode === 'bot-only' && replyToPresent && replyTargetKind == null) {
+      return Object.freeze({ pass: false, addressed: false, reason: 'reply-target-unknown' });
+    }
+    return Object.freeze({ pass: false, addressed: false, reason: 'mention-required' });
+  }
+  const reason = mentioned === true ? 'mention'
+    : commandLike === true ? 'command'
+      : replyCounts ? 'reply'
+        : gateOpen ? 'free-response' : 'other';
+  return Object.freeze({ pass: true, addressed, reason });
+}

package/src/channels/shared/conversation-state-store.mjs

@@ -7,7 +7,7 @@ import { dirname } from 'node:path';
  * explicit: a subclass reads and writes them through extensionState().
  */
 const EXTENSION_KEYS = Object.freeze([
-  'emailBindings', 'mailCursor', 'pendingAuth', 'threadIds',
+  'emailBindings', 'mailCursor', 'pendingAuth', 'threadIds', 'rootAnchors',
 ]);
 
 const EMPTY_STATE = Object.freeze({ version: 1, sessions: {}, seenMessageIds: [], cursor: null });

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

@@ -134,6 +134,25 @@ export class HarnessApprovalQueue {
     return this.#routes.get(key)?.items.some((pending) => !pending.inactive) === true;
   }
 
+  /**
+   * Reject the active approvals of one route: the sender moved on to a new
+   * addressed request instead of deciding the tool call, and the conversation
+   * must not wait behind a decision that is not coming.
+   * @param {string} key The route key.
+   * @returns {Promise<number>} How many approvals were rejected.
+   */
+  async rejectRoute(key) {
+    const route = this.#routes.get(key);
+    if (!route) return 0;
+    let rejected = 0;
+    for (const pending of [...route.items]) {
+      if (pending.inactive || pending.resolving) continue;
+      await this.#submit(pending, 'rejected').catch(() => undefined);
+      rejected += 1;
+    }
+    return rejected;
+  }
+
   claimReply({
     key,
     actor,

package/src/channels/shared/i18n-en/shared-a.mjs

@@ -229,6 +229,8 @@ export default {
   '正在使用{name}…': 'Using {name}…',
   '已停止。': 'Stopped.',
   '请用文字回答当前问题。': 'Please answer the current question with text.',
+  '已不再等待原有的待回答或待审批，已将其取消，先回应你的新请求。':
+    'The pending question or approval is no longer waited on and has been cancelled; your new request is being answered first.',
   '{label}交互问题发送失败。': 'Failed to send the {label} interaction question.',
   '回答提交失败。': 'Failed to submit the answer.',
   '回答提交失败，请重新发送当前问题的答案。':

package/src/channels/shared/injected-context.mjs

@@ -1,8 +1,8 @@
 // Pair one injected context block with the user message that carried it.
 //
 // The prompt RPC carries no message source, so a channel encodes its source
-// block, its optional guidance, and any quoted reply as leading text of the
-// user prompt. `installInjectedContext` splits them back out at
+// block, its optional guidance, any quoted reply, and any collected
+// conversation-context blocks as leading text of the user prompt. `installInjectedContext` splits them back out at
 // `agent/pre-step` -- after the Agent inbox claimed the message but before
 // anything is committed -- and enters plugin-sourced context messages beside
 // the untouched user text. Pairing is decided by message identity, never by
@@ -37,6 +37,21 @@ export const DEFAULT_REPLY_LABEL = 'Quoted';
 /** Fallback row label for a source block whose fields carry no readable value. */
 export const DEFAULT_SOURCE_LABEL = 'Source';
 
+/** Fallback row label for one collected conversation-context block. */
+export const DEFAULT_CONTEXT_LABEL = 'Context';
+
+/** Static note stamped into every context block; states what the block is not. */
+export const CONTEXT_NOTE = 'Conversation context collected by the bot; not the current question.';
+
+/**
+ * Every field one conversation-context block may carry. A block is ours only
+ * when its body is a non-empty object drawn from these keys with a named
+ * collector and verbatim content, mirroring how source blocks are judged.
+ */
+export const CONTEXT_BLOCK_FIELDS = Object.freeze([
+  'note', 'collector', 'room', 'event', 'sender', 'ts', 'content',
+]);
+
 /**
  * Every field the source producer can project -- the same canonical list the
  * settings UI validates against, so the two cannot drift. A block is ours only
@@ -143,6 +158,40 @@ function isSourceBlock(body) {
     && fields.every((field) => SOURCE_BLOCK_FIELDS.includes(field));
 }
 
+/**
+ * Decide whether one body is a conversation-context block this plugin wrote.
+ * Shape-only, like `isSourceBlock`: a well-formed object of unknown fields is
+ * user text that happens to use the tag and is left alone.
+ *
+ * @param body - the text between the context tags.
+ * @returns whether the body is one of our context blocks.
+ */
+function isContextBlock(body) {
+  const parsed = parseBlockJson(body);
+  if (parsed === null) return false;
+  const fields = Object.keys(parsed);
+  return fields.length > 0
+    && fields.every((field) => CONTEXT_BLOCK_FIELDS.includes(field))
+    && typeof parsed.collector === 'string' && parsed.collector.trim().length > 0
+    && typeof parsed.content === 'string' && parsed.content.length > 0;
+}
+
+/**
+ * One-line account of a context block: the row label plus the collector roles
+ * that produced it, e.g. `上下文 · thread-root+reply`.
+ */
+function contextSummary(body, labels) {
+  const parsed = parseBlockJson(body);
+  if (parsed === null) return null;
+  const collector = typeof parsed.collector === 'string' && parsed.collector.trim()
+    ? parsed.collector.trim().slice(0, 64)
+    : '';
+  if (!collector) return null;
+  return bound(`${typeof labels?.context === 'string' && labels.context
+    ? labels.context
+    : DEFAULT_CONTEXT_LABEL} \u00b7 ${collector}`);
+}
+
 /** Bound one summary to the row's declared maximum. */
 function bound(summary) {
   if (!summary) return null;
@@ -206,6 +255,19 @@ function blockAt(text, cursor, labels) {
       },
     };
   }
+  const context = delimited(text, cursor, tags.contextOpen, tags.contextClose);
+  if (context !== null) {
+    // Collected material the bot points at, so it precedes the question it
+    // belongs to; a body outside the block schema stays user text verbatim.
+    if (!isContextBlock(context.body)) return null;
+    return {
+      end: context.end,
+      block: {
+        position: 'before', form: 'notice', summary: contextSummary(context.body, labels),
+        text: text.slice(cursor, context.end),
+      },
+    };
+  }
   const reply = delimited(text, cursor, tags.replyOpen, tags.replyClose);
   if (reply !== null) {
     const summary = replySummary(reply.body, labels);

package/src/channels/shared/speaker-label.mjs

@@ -0,0 +1,46 @@
+/**
+ * Speaker labels for room-shared Sessions.
+ *
+ * A Matrix room routes every addressed message of the room into one shared
+ * conversation (see `conversation/route.mjs`: group keys carry no sender), so
+ * when several members question the same bot the persisted turn text alone
+ * cannot say whose question each turn carries. The bridge therefore labels the
+ * model-facing prompt of a group message with the sender's display name; the
+ * parsed control text, commands, and ledger keys never pass through here and
+ * stay unlabelled.
+ */
+
+import { INJECTED_CONTEXT_TAGS } from './context-enhancement.mjs';
+
+/** Tags whose JSON blocks own their provenance and must never absorb a label. */
+const BLOCK_OPENS = Object.freeze([
+  INJECTED_CONTEXT_TAGS.replyOpen,
+  INJECTED_CONTEXT_TAGS.sourceOpen,
+  INJECTED_CONTEXT_TAGS.contextOpen,
+]);
+
+function isInjectedBlockPart(part) {
+  return part?.type === 'text'
+    && typeof part.text === 'string'
+    && BLOCK_OPENS.some((open) => part.text.startsWith(open));
+}
+
+/**
+ * Prefix the message body of one model-facing prompt with `speakerName: `.
+ * A string prompt is labelled inline; a structured content array is labelled
+ * on its first non-block text part so injected reply, source, and context
+ * blocks keep their own provenance. With no body text to carry the label — an
+ * image-only or reply-only turn — one label part is placed ahead of the media.
+ * @param {string|Array<Object>|undefined} content - the assembled prompt content.
+ * @param {?string} speakerName - the sender's display name; empty labels are dropped.
+ * @returns {string|Array<Object>|undefined} the labelled content, or the input unchanged when no label applies.
+ */
+export function prependSpeakerLabel(content, speakerName) {
+  const name = typeof speakerName === 'string' ? speakerName.trim() : '';
+  if (!name) return content;
+  if (typeof content === 'string') return content ? `${name}: ${content}` : content;
+  if (!Array.isArray(content)) return content;
+  const index = content.findIndex((part) => part?.type === 'text' && !isInjectedBlockPart(part));
+  if (index === -1) return [{ type: 'text', text: `${name}:` }, ...content];
+  return content.with(index, { ...content[index], text: `${name}: ${content[index].text ?? ''}` });
+}