dsh-bot-team 1.1.0 → 1.3.0

package/host/background-interactions.js

@@ -0,0 +1,213 @@
+/** Bot-specific answerers for the public Host human-interaction waterfalls. */
+import { newId } from './util.js';
+import { currentConversationId, isCurrentMemberSession } from './conversations.js';
+
+const questionError = (code) => Object.assign(new Error(code), { name: 'UserQuestionError', code });
+const invalid = (message) => Object.assign(new Error(message), { code: 'invalid-interaction' });
+const clone = (value) => JSON.parse(JSON.stringify(value));
+
+/** Validate complete native QuestionAnswer batches; empty selections explicitly skip a question. */
+export function validateBackgroundAnswer(questions, answer) {
+  if (!answer || !Array.isArray(answer.answers) || answer.answers.length !== questions.length) throw invalid('请提交每个问题的答案。');
+  const remaining = new Map(questions.map(question => [question.id, question]));
+  const answers = answer.answers.map(item => {
+    const question = item && remaining.get(item.id);
+    if (!question || !Array.isArray(item.selected) || item.selected.some(label => typeof label !== 'string')) throw invalid('问题或答案格式不正确。');
+    remaining.delete(item.id);
+    const labels = new Set((question.options || []).map(option => option.label));
+    if (new Set(item.selected).size !== item.selected.length || item.selected.some(label => !labels.has(label))) throw invalid('答案包含无效或重复的选项。');
+    if (question.multiSelect !== true && item.selected.length > 1) throw invalid('此问题只能选择一个选项。');
+    if (item.custom !== undefined && typeof item.custom !== 'string') throw invalid('补充答案格式不正确。');
+    return { id: item.id, selected: [...item.selected], ...(item.custom === undefined ? {} : { custom: item.custom }) };
+  });
+  if (remaining.size) throw invalid('请提交每个问题的答案。');
+  return { answers };
+}
+
+export class BackgroundInteractions {
+  constructor({ ctx, repo, bus }) {
+    this.ctx = ctx;
+    this.repo = repo;
+    this.bus = bus;
+    this.entries = new Map();
+    this.revisions = new Map();
+    this.epoch = newId('interactions');
+    this.disposed = false;
+    this.responding = new Set();
+    const options = { global: true, prepend: true };
+    this.off = [
+      ctx.on('approval/request', (request, next) => this.receive('approval', request, next), options),
+      ctx.on('user-questions/request', (request, next) => this.receive('question', request, next), options),
+      ctx.on('session/event', session => {
+        if ([...repo.members.values()].some(member => member.sessionId === session.id)) this.reconcile();
+      }, { global: true }),
+    ];
+    // Membership removal and Agent disposal need not append a Session event.
+    this.timer = setInterval(() => this.reconcile(), 1000);
+    this.timer.unref?.();
+  }
+
+  memberFor(agent) {
+    const agents = this.ctx.agents;
+    if (!agent || !agents || agents.get(agent.id) !== agent || !agents.roots().includes(agent) || agent.session?.id !== agent.id) return;
+    const members = [...this.repo.members.values()].filter(member => isCurrentMemberSession(this.repo, member, agent.id) && this.repo.groups.has(member.groupId));
+    return members.length === 1 ? members[0] : undefined;
+  }
+
+  owns(entry) {
+    const member = this.memberFor(entry.agent);
+    return member?.membershipId === entry.view.membershipId && member.groupId === entry.view.groupId && member.botId === entry.view.botId && currentConversationId(this.repo, member.groupId) === entry.view.conversationId;
+  }
+
+  projection(agent) {
+    return this.ctx.get('sessionProjections')?.stateOf(agent.session, 'userQuestions')?.questions;
+  }
+
+  make(kind, agent, member, fields) {
+    const entry = { agent, view: {
+      interactionId: newId('interaction'), groupId: member.groupId, sessionId: agent.id,
+      membershipId: member.membershipId, botId: member.botId, conversationId: currentConversationId(this.repo, member.groupId),
+      botName: this.repo.bots?.get(member.botId)?.name || 'Bot',
+      kind, state: 'pending', createdAt: Date.now(), ...fields,
+    } };
+    this.entries.set(entry.view.interactionId, entry);
+    return entry;
+  }
+
+  receive(kind, request, next) {
+    const member = !this.disposed && this.memberFor(request.agent);
+    if (!member) return next();
+    const fields = kind === 'approval'
+      ? { toolName: request.toolName, reason: request.reason || '', ...(request.callId ? { callId: request.callId } : {}) }
+      : { questions: clone(request.questions), timed: request.wait?.timed === true, ...(request.wait?.callId ? { callId: request.wait.callId } : {}) };
+    const entry = this.make(kind, request.agent, member, fields);
+    return new Promise((resolve, reject) => {
+      entry.resolve = resolve;
+      entry.reject = reject;
+      const abort = () => {
+        if (kind === 'question' && entry.view.timed && request.signal?.reason?.code === 'ASK_TIMED_OUT') this.finish(entry, 'continue');
+        else this.finish(entry, 'abort');
+      };
+      entry.cleanup = () => request.signal?.removeEventListener('abort', abort);
+      request.signal?.addEventListener('abort', abort, { once: true });
+      if (request.signal?.aborted) abort();
+      else this.publish(member.groupId);
+    });
+  }
+
+  finish(entry, operation, value) {
+    if (!this.entries.has(entry.view.interactionId)) return;
+    const { resolve, reject } = entry;
+    entry.cleanup?.();
+    entry.cleanup = entry.resolve = entry.reject = undefined;
+    if (operation === 'continue') {
+      entry.view.state = 'continuing';
+      entry.transitionAt = Date.now();
+      reject?.(questionError('ASK_TIMED_OUT'));
+    } else {
+      this.entries.delete(entry.view.interactionId);
+      if (entry.view.kind === 'approval') resolve?.(operation === 'answer' ? value : 'cancelled');
+      else if (operation === 'answer') resolve?.(value);
+      else reject?.(questionError(operation === 'cancel' ? 'ASK_CANCELLED' : 'ASK_ABORTED'));
+    }
+    this.publish(entry.view.groupId);
+  }
+
+  /** Reconcile against public Session projections, including late questions after a reload. */
+  reconcile() {
+    if (this.disposed || this.reconciling) return;
+    this.reconciling = true;
+    const changed = new Set();
+    try {
+      for (const entry of [...this.entries.values()]) {
+        if (!this.owns(entry)) { this.finish(entry, 'abort'); continue; }
+        if (entry.view.kind !== 'question' || entry.view.state === 'pending') continue;
+        const projection = this.projection(entry.agent);
+        const active = projection?.active?.find(question => question.callId === entry.view.callId);
+        if (active?.state === 'continued') {
+          if (entry.view.state === 'continuing') { entry.view.state = 'continued'; changed.add(entry.view.groupId); }
+        } else if (entry.view.state !== 'continuing' || projection?.settled?.some(question => question.callId === entry.view.callId) || Date.now() - entry.transitionAt > 30000) {
+          this.entries.delete(entry.view.interactionId);
+          changed.add(entry.view.groupId);
+        }
+      }
+      for (const member of this.repo.members.values()) {
+        const agent = this.ctx.agents?.get(member.sessionId);
+        if (this.memberFor(agent)?.membershipId !== member.membershipId) continue;
+        for (const question of this.projection(agent)?.active || []) {
+          if (question.state !== 'continued' || [...this.entries.values()].some(entry => entry.agent === agent && entry.view.callId === question.callId)) continue;
+          this.make('question', agent, member, { questions: clone(question.questions), callId: question.callId, timed: true, state: 'continued' });
+          changed.add(member.groupId);
+        }
+      }
+    } finally { this.reconciling = false; }
+    for (const groupId of changed) this.publish(groupId);
+  }
+
+  view(groupId) {
+    return { groupId, epoch: this.epoch, revision: this.revisions.get(groupId) || 0,
+      interactions: [...this.entries.values()].filter(entry => entry.view.groupId === groupId && this.owns(entry)).map(entry => clone(entry.view)) };
+  }
+
+  publish(groupId) {
+    this.revisions.set(groupId, (this.revisions.get(groupId) || 0) + 1);
+    this.bus.emit(groupId, { type: 'interaction.updated', ...this.view(groupId) });
+  }
+
+  snapshot(groupId) {
+    if (typeof groupId !== 'string' || !this.repo.groups.has(groupId)) throw invalid('群聊不存在。');
+    this.reconcile();
+    return this.view(groupId);
+  }
+
+  async respond(input = {}) {
+    this.reconcile();
+    const entry = this.entries.get(input.interactionId);
+    if (this.disposed || !entry || !this.owns(entry) || entry.view.groupId !== input.groupId || entry.view.sessionId !== input.sessionId) throw invalid('此交互已失效或不属于当前会话。');
+    const { view } = entry;
+    if (input.expectedConversationId !== undefined && input.expectedConversationId !== view.conversationId) throw invalid('此交互已失效或不属于当前会话。');
+    this.assertAdmission?.(view.groupId);
+    if (entry.busy || view.state === 'continuing' || view.state === 'queued') throw invalid('此答案正在处理，请稍后刷新。');
+    if (input.operation === 'continue') {
+      if (view.kind !== 'question' || !view.timed || view.state !== 'pending') throw invalid('此交互不能稍后回答。');
+      this.finish(entry, 'continue');
+    } else if (input.operation === 'cancel') {
+      if (view.state !== 'pending') throw invalid('此问题已继续执行，请提交答案或跳过。');
+      this.finish(entry, 'cancel');
+    } else if (input.operation === 'answer') {
+      if (view.kind === 'approval') {
+        if (!['allowed-once', 'rejected'].includes(input.outcome)) throw invalid('审批决定无效。');
+        this.finish(entry, 'answer', input.outcome);
+      } else {
+        const answer = validateBackgroundAnswer(view.questions, input.answer);
+        if (view.state === 'pending') this.finish(entry, 'answer', answer);
+        else {
+          entry.busy = true;
+          this.responding.add(entry);
+          try {
+            const questions = this.ctx.get('userQuestions');
+            if (typeof questions?.answer !== 'function') throw invalid('提问服务暂不可用，请稍后重试。');
+            const accepted = await questions.answer(entry.agent, view.callId, answer);
+            if (!this.owns(entry)) throw invalid('此交互已失效或不属于当前会话。');
+            if (!accepted) { this.entries.delete(view.interactionId); throw invalid('此问题已失效，请刷新。'); }
+            view.state = 'queued';
+          } catch (error) {
+            if (error?.code !== 'REPLY_QUEUED') throw error;
+            if (!this.owns(entry)) throw invalid('此交互已失效或不属于当前会话。');
+            view.state = 'queued';
+          } finally { entry.busy = false; this.responding.delete(entry); this.publish(view.groupId); }
+        }
+      }
+    } else throw invalid('未知的交互操作。');
+    return { accepted: true, ...this.snapshot(view.groupId) };
+  }
+
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    clearInterval(this.timer);
+    for (const off of this.off) off?.();
+    for (const entry of [...this.entries.values()]) this.finish(entry, 'abort');
+    this.entries.clear();
+  }
+}

package/host/conversations.js

@@ -0,0 +1,45 @@
+/** Pure conversation checks shared by execution, history, and service code. */
+const groupOf = (repo, groupId) => repo?.getGroup?.(groupId) ?? repo?.groups?.get?.(groupId);
+const memberOf = (repo, memberId) => repo?.getMember?.(memberId) ?? repo?.members?.get?.(memberId);
+
+export function currentConversationId(repo, groupId) {
+  if (typeof repo?.activeConversation === 'function') return repo.activeConversation(groupId)?.conversationId ?? null;
+  return groupOf(repo, groupId)?.activeConversationId ?? null;
+}
+
+export function conversationFloor(repo, groupId) {
+  const group = groupOf(repo, groupId);
+  if (typeof repo?.activeConversation === 'function') {
+    const conversation = repo.activeConversation(groupId);
+    if ((!conversation && group) || (conversation && (!Number.isSafeInteger(conversation.afterSeq) || conversation.afterSeq < 0 ||
+        (group?.activeConversationId && group.activeConversationId !== conversation.conversationId)))) {
+      throw Object.assign(new Error('聊天会话边界不可用'), { code: 'conversation-corrupt' });
+    }
+    return conversation?.afterSeq ?? 0;
+  }
+  // Only legacy doubles with no generation pointer can use the legacy floor.
+  if (group?.activeConversationId) throw Object.assign(new Error('聊天会话边界不可用'), { code: 'conversation-corrupt' });
+  return 0;
+}
+
+export function conversationIdOf(repo, record) {
+  if (!record) return null;
+  if (typeof repo?.conversationFor === 'function') return repo.conversationFor(record)?.conversationId ?? null;
+  // An untagged record is legacy history, never implicitly the new current turn.
+  return record.conversationId ?? null;
+}
+
+export function isCurrentMemberSession(repo, member, sessionId = member?.sessionId) {
+  if (!member || !sessionId || member.sessionId !== sessionId) return false;
+  const latest = memberOf(repo, member.membershipId);
+  if ((typeof repo?.getMember === 'function' || typeof repo?.members?.get === 'function') &&
+      (!latest || latest.groupId !== member.groupId || latest.botId !== member.botId || latest.sessionId !== sessionId)) return false;
+  const conversationId = currentConversationId(repo, member.groupId);
+  const strict = typeof repo?.activeConversation === 'function' || Boolean(groupOf(repo, member.groupId)?.activeConversationId);
+  if (strict && (!conversationId || member.sessionConversationId !== conversationId || (latest && latest.sessionConversationId !== conversationId))) return false;
+  if (typeof repo?.sessionBindingFor === 'function') {
+    const binding = repo.sessionBindingFor(sessionId);
+    if (!binding || binding.groupId !== member.groupId || binding.membershipId !== member.membershipId || binding.botId !== member.botId || binding.conversationId !== conversationId) return false;
+  }
+  return true;
+}

package/host/discussion-flow.js

@@ -0,0 +1,179 @@
+/** Pure validation and step planning for version 2 discussions. */
+export const MAX_DISCUSSION_ROUNDS = 20;
+
+export const DISCUSSION_ACTIVE_STATUSES = Object.freeze([
+  'running', 'pausing', 'paused', 'finalizing', 'stopping',
+]);
+
+export function isDiscussionActive(record) {
+  return Boolean(record && DISCUSSION_ACTIVE_STATUSES.includes(record.status));
+}
+
+function invalid(message) {
+  throw Object.assign(new Error(message), { code: 'invalid-input' });
+}
+
+function plainObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value) &&
+    (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+
+function text(value, name, { required = false, max = Infinity } = {}) {
+  if (value === undefined && !required) return '';
+  if (typeof value !== 'string') invalid(name + ' 必须是字符串');
+  const result = value.trim();
+  if (required && !result) invalid(name + ' 不能为空');
+  if (value.length > max) invalid(name + ' 不能超过 ' + max + ' 字');
+  return result;
+}
+
+function choice(value, name, values, fallback) {
+  if (value === undefined) return fallback;
+  if (!values.includes(value)) invalid(name + ' 无效');
+  return value;
+}
+
+function ids(value, name) {
+  if (!Array.isArray(value)) invalid(name + ' 必须是数组');
+  const result = value.map(item => text(item, name, { required: true }));
+  if (new Set(result).size !== result.length) invalid(name + ' 不能重复');
+  return result;
+}
+
+/**
+ * Validate start input without mutating repository state or capturing attachments.
+ * memberIds includes every assigned participant; speakerIds contains only speakers
+ * in the regular rounds. The engine captures contextMessageIds via captureQuote.
+ */
+export function normalizeDiscussionInput(repo, input) {
+  if (!plainObject(input)) invalid('讨论参数必须是对象');
+  const groupId = text(input.groupId, 'groupId', { required: true });
+  const group = repo.getGroup(groupId);
+  if (!group) throw Object.assign(new Error('群不存在'), { code: 'not-found' });
+  if (group.kind === 'direct') invalid('单聊不能开始多人讨论或辩论');
+
+  const mode = choice(input.mode, 'mode', ['discussion', 'debate'], 'discussion');
+  const format = choice(input.format, 'format', ['classic', 'structured'], 'classic');
+  const topic = text(input.topic, '议题', { required: true, max: 2000 });
+  const background = text(input.background, '背景', { max: 12000 });
+  const goal = text(input.goal, '目标', { max: 2000 });
+  const responseLength = choice(input.responseLength, 'responseLength', ['short', 'standard', 'detailed'], 'standard');
+  const language = choice(input.language, 'language', ['auto', 'zh', 'en'], 'auto');
+  if (input.summarize !== undefined && typeof input.summarize !== 'boolean') invalid('summarize 必须是布尔值');
+  const summarize = input.summarize === undefined ? mode === 'discussion' && format === 'structured' : input.summarize;
+  const minRounds = mode === 'discussion' && format === 'structured' ? 2 : 1;
+  const rounds = input.rounds === undefined ? (minRounds === 2 ? 3 : 2) : input.rounds;
+  if (!Number.isInteger(rounds) || rounds < minRounds || rounds > MAX_DISCUSSION_ROUNDS) {
+    invalid('rounds 必须是 ' + minRounds + ' 到 ' + MAX_DISCUSSION_ROUNDS + ' 之间的整数');
+  }
+  const expectedConversationId = input.expectedConversationId === undefined ? undefined
+    : text(input.expectedConversationId, 'expectedConversationId', { required: true });
+
+  const eligible = member => member && member.groupId === groupId && member.enabled !== false && repo.getBot(member.botId);
+  const requireMember = membershipId => {
+    const member = repo.getMember(membershipId);
+    if (!eligible(member)) invalid('成员不存在、不属于本群、已停用或其 Bot 已删除：' + membershipId);
+    return member;
+  };
+  const role = name => input[name] === undefined || input[name] === null || input[name] === '' ? null
+    : text(input[name], name, { required: true });
+  let summaryMembershipId = role('summaryMembershipId');
+  const proMembershipId = role('proMembershipId');
+  const conMembershipId = role('conMembershipId');
+  const judgeMembershipId = role('judgeMembershipId');
+  const proPosition = text(input.proPosition, '正方立场', { max: 2000 });
+  const conPosition = text(input.conPosition, '反方立场', { max: 2000 });
+  let speakerIds;
+
+  if (mode === 'debate') {
+    if (!proMembershipId || !conMembershipId || proMembershipId === conMembershipId) invalid('辩论必须选择不同的正方和反方成员');
+    if (judgeMembershipId === proMembershipId || judgeMembershipId === conMembershipId) invalid('裁判必须独立于正方和反方');
+    if (summaryMembershipId) invalid('辩论请使用 judgeMembershipId 指定裁判');
+    speakerIds = [proMembershipId, conMembershipId];
+    if (input.membershipIds !== undefined) {
+      const selected = ids(input.membershipIds, 'membershipIds');
+      if (selected.some(id => !speakerIds.includes(id) && id !== judgeMembershipId) ||
+          speakerIds.some(id => !selected.includes(id))) invalid('辩论成员必须包含正反双方，且只能额外包含指定裁判');
+    }
+  } else {
+    if (proMembershipId || conMembershipId || judgeMembershipId || proPosition || conPosition) invalid('正反方和裁判配置仅适用于辩论');
+    speakerIds = input.membershipIds === undefined
+      ? repo.membersOf(groupId).filter(eligible).map(member => member.membershipId)
+      : ids(input.membershipIds, 'membershipIds');
+    if (speakerIds.length < (format === 'structured' ? 2 : 1)) invalid(format === 'structured' ? '结构化讨论至少需要两名成员' : '请选择至少一个讨论成员');
+    summaryMembershipId ??= speakerIds[0];
+  }
+  if (new Set(speakerIds).size !== speakerIds.length) invalid('讨论成员不能重复');
+  const memberIds = [...new Set([...speakerIds, summaryMembershipId, judgeMembershipId].filter(Boolean))];
+  const participants = memberIds.map(membershipId => {
+    const member = requireMember(membershipId);
+    const bot = repo.getBot(member.botId);
+    return { membershipId, botId: member.botId, name: bot.name };
+  });
+  if (new Set(participants.map(participant => participant.botId)).size !== participants.length) invalid('同一个 Bot 不能承担多个参与者身份');
+
+  const contextMessageIds = input.contextMessageIds === undefined ? [] : ids(input.contextMessageIds, 'contextMessageIds');
+  if (contextMessageIds.length > 20) invalid('引用消息最多 20 条');
+  for (const messageId of contextMessageIds) {
+    const message = repo.getMessage(messageId);
+    if (!message || message.groupId !== groupId) invalid('引用消息不存在或不属于本群：' + messageId);
+  }
+  const perspectiveInput = input.perspectives === undefined ? {} : input.perspectives;
+  if (!plainObject(perspectiveInput)) invalid('perspectives 必须是成员到视角文本的对象');
+  const perspectives = Object.fromEntries(Object.entries(perspectiveInput).map(([membershipId, value]) => {
+    if (!memberIds.includes(membershipId)) invalid('视角只能分配给本次参与者：' + membershipId);
+    return [membershipId, text(value, '成员视角', { max: 500 })];
+  }));
+
+  return {
+    protocolVersion: 2, groupId, topic, mode, format, goal, background, rounds, summarize,
+    memberIds, speakerIds, participants, summaryMembershipId,
+    proMembershipId, conMembershipId, judgeMembershipId, proPosition, conPosition,
+    responseLength, language, perspectives, contextMessageIds, expectedConversationId,
+  };
+}
+
+/** Build a deterministic plan; every call returns fresh mutable step state. */
+export function createDiscussionPlan(config) {
+  const steps = [];
+  const add = (phase, membershipId, round, side = null, targetStepId) => {
+    const step = {
+      stepId: 'step-' + (steps.length + 1), phase, membershipId, side, round,
+      ...(targetStepId ? { targetStepId } : {}),
+      status: 'pending', attempts: [], messageIds: [],
+    };
+    steps.push(step);
+    return step;
+  };
+  if (config.mode === 'debate') {
+    const members = { pro: config.proMembershipId, con: config.conMembershipId };
+    const latestStatement = {
+      pro: add('opening', members.pro, 1, 'pro'),
+      con: add('opening', members.con, 1, 'con'),
+    };
+    for (let round = 1; round <= config.rounds; round += 1) {
+      const order = round % 2 === 1 ? ['pro', 'con'] : ['con', 'pro'];
+      for (const side of order) {
+        const other = side === 'pro' ? 'con' : 'pro';
+        const question = add('question', members[side], round, side, latestStatement[other].stepId);
+        latestStatement[other] = add('answer', members[other], round, other, question.stepId);
+      }
+    }
+    add('closing', members.pro, config.rounds, 'pro');
+    add('closing', members.con, config.rounds, 'con');
+    if (config.judgeMembershipId) add('judgement', config.judgeMembershipId, config.rounds);
+    return steps;
+  }
+
+  const speakerIds = config.speakerIds;
+  for (let round = 1; round <= config.rounds; round += 1) {
+    const phase = config.format !== 'structured' ? 'discussion'
+      : round === 1 ? 'viewpoint' : round === config.rounds ? 'converge' : 'challenge';
+    for (const membershipId of speakerIds) add(phase, membershipId, round);
+    if (config.format === 'structured' && round < config.rounds) {
+      add('checkpoint', config.summaryMembershipId, round);
+    }
+  }
+  if (config.summarize) add('summary', config.summaryMembershipId, config.rounds);
+  return steps;
+}