ai_co_discuss 0.2.36 → 0.2.37

package/docs/workflow.md

@@ -43,7 +43,7 @@
 新建讨论时可选“点名追问”，默认关闭；之前创建的房间视为开启，保持原有方式。
 
 - **开启**：每轮结束后主持人读完回答，给每位专家写针对性的追问。
-- **关闭**：首轮仍由主持人拆题出题；之后专家统一按“先读上一轮回答、回应不同意或需补充的观点、可 @ 彼此提问”发言，主持人用自己的主持说明引导方向。同时开启“智能调度”时，每轮结束由决策模型判断：还有分歧就自动开下一轮（先请最需要回应的专家，不是上一轮最后发言者），可以收束、跑偏或卡住才唤醒主持人。自动开轮受轮次与时长上限约束，到限照常交给主持人处理。
+- **关闭**：首轮仍由主持人拆题出题；之后专家统一按“先读上一轮回答、回应不同意或需补充的观点、可 @ 彼此提问”发言，主持人用自己的主持说明引导方向。同时开启“智能调度”时，每轮结束由决策模型判断：还有分歧就自动开下一轮（先请最需要回应的专家，不是上一轮最后发言者），可以收束、跑偏或卡住才唤醒主持人。决策模型每次只安排一位发言人，那位答完后再判断下一位（含点“跳过”、邀请或成员变动后队列为空的情况）；手动接入的专家不由它安排。自动开轮受轮次与时长上限约束，到限照常交给主持人处理。
 
 ## 讨论上限
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai_co_discuss",
-  "version": "0.2.36",
+  "version": "0.2.37",
   "bin": {
     "codiscuss": "runner/codiscuss.mjs"
   },

package/runner/api_participant.mjs

@@ -11,6 +11,7 @@ const MAX_MODEL_TURNS = 24;
 // API participants follow the same skills that local software loads, read fresh for every execution.
 const SKILLS = fileURLToPath(new URL('../.agents/skills/', import.meta.url));
 const SITE_TIMEOUT_MS = 10_000;
+const REPLY_EXCERPT_CHARS = 300;
 const MODEL_RETRIES = 2;
 const MODEL_RETRY_DELAY_MS = 3000;
 const NO_TOOL_REMINDER = '普通文本不会被保存。请调用写入工具提交真实结果；确实无法继续才不调用工具直接结束。';
@@ -154,6 +155,13 @@ export function system_prompt(context) {
   return [environment, skill_text('discuss-participant'), ...(host && context.mode !== 'free' ? [skill_text('discuss-host')] : [])].join('\n\n---\n\n');
 }
 
+/** Plain text of the model's latest reply, so a stop without a write can show its stated reason. */
+function last_reply_text(history) {
+  const item = history.at(-1) || {};
+  const parts = item.parts || (Array.isArray(item.content) ? item.content : [{ text: item.content }]);
+  return parts.map(part => (typeof part === 'string' ? part : part.text || '')).join('').trim().slice(0, REPLY_EXCERPT_CHARS);
+}
+
 /** Retry a model request that failed before any room write; history is only extended on success. */
 async function generate_with_retry(profile, key, state, signal) {
   for (let attempt = 0; ; attempt++) {
@@ -174,15 +182,21 @@ async function run_participant(profile, key, context) {
     ...(context.scheduler_suggestions?.length ? { scheduler_suggestions: context.scheduler_suggestions } : {}) } });
   const state = { system: system_prompt(context), history: api_history(profile, prompt), tools: definitions };
   let reminded = false;
+  let used_tools = false;
   for (let index = 0; index < MAX_MODEL_TURNS; index++) {
     const calls = await generate_with_retry(profile, key, state, context.signal);
     if (!calls.length) {
       // Some models answer in plain text mid-run; one reminder avoids pausing on a recoverable slip.
-      if (reminded) throw new Error('模型未调用房间工具保存结果，请核对模型是否支持工具调用');
+      if (reminded) {
+        const reply = last_reply_text(state.history);
+        throw new Error(used_tools ? `模型未提交结果就结束了本次执行，可能在等你决定或补充${reply ? `。模型说明：${reply}` : ''}`
+          : `模型未调用房间工具保存结果，请核对模型是否支持工具调用${reply ? `（其回复：${reply}）` : ''}`);
+      }
       reminded = true;
       state.history.push(profile.api_protocol === 'gemini' ? { role: 'user', parts: [{ text: NO_TOOL_REMINDER }] } : { role: 'user', content: NO_TOOL_REMINDER });
       continue;
     }
+    used_tools = true;
     const results = [];
     for (const call of calls) {
       context.signal.throwIfAborted();

package/runner/discussion_runner.mjs

@@ -9,7 +9,7 @@ import { parseArgs } from 'node:util';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { atomic_json, deliver_task, remove_agy_projects, setup_sidecar, sidecar_receipt, TASK_SUBCOMMANDS } from './discussion_adapters.mjs';
 import { read_api_key } from './discussion_api.mjs';
-import { decide_interjection, decide_round, validate_scheduler } from './scheduler.mjs';
+import { decide_interjection, decide_next_speaker, decide_round, validate_scheduler } from './scheduler.mjs';
 
 const POLL_MS = 2000;
 /** Headless CLIs know their session at start, so the runner enters the execution instead of spending model turns on it. */
@@ -41,6 +41,11 @@ export function peer_round_question(round) {
   return `第 ${round} 轮：先读取上一轮其他专家的最新回答，回应你不同意或需要补充的观点；被其他专家 @ 提问时优先回答，也可以 @ 某位专家提出问题。`;
 }
 
+/** The prompt for an expert speaking for the first time, such as a newly invited one. */
+function opening_question(phase) {
+  return phase === 'initial' ? '欢迎加入：请先读取议题，独立给出你的开场观点。' : '欢迎加入：请先读取议题和已有回答，给出你的观点。';
+}
+
 /** Ask one expert to answer a user's interjection before the rest of the plan continues. */
 function interjection_question(message) {
   const text = String(message.text || '').replace(/\s+/g, ' ').trim();
@@ -356,6 +361,8 @@ export class DiscussionRunner {
     if (room.limits?.reached) return skip('round', '已到讨论上限');
     const page = await api(this.config, `/messages?after=${Math.max(0, room.latest_id - CONTEXT_MESSAGES)}`);
     const experts = Object.keys(room.experts || {});
+    // Only experts the runner can wake are offered to the decision model; manual ones wait for the host.
+    const automatic = experts.filter(name => this.config.participants[name]);
     const context = { title: room.title, goal: room.goal, user_request: room.user_request, context: page.messages, host: room.host };
     if (room.held_since) {
       const pending = page.messages.filter(item => item.id >= room.held_since && item.author === '用户');
@@ -363,7 +370,7 @@ export class DiscussionRunner {
       if (pending.length !== 1) return skip('interjection', pending.length ? '同时有多条留言' : '话题设置有修改');
       const message = pending[0];
       const decision = await decide_interjection(this.config.api_home, this.config.scheduler,
-        { ...context, message, experts: experts.filter(name => name !== room.host) }, this.fetch);
+        { ...context, message, experts: automatic.filter(name => name !== room.host) }, this.fetch);
       const plan = { ...decision, kind: 'interjection', message_id: message.id, after_message_id: anchor };
       if (decision.action === 'ask') {
         return { ...plan, turns: [{ expert: decision.expert, question: interjection_question(message) },
@@ -377,17 +384,33 @@ export class DiscussionRunner {
     const round_open = !room.rounds?.at(-1)?.completed;
     if (round_open) {
       const restored = await this.restore_voided_plan(room, experts, anchor);
-      return restored || skip('round', '本轮还有专家未发言但没有后续安排');
+      if (restored) return restored;
+      const spoken = new Set(room.rounds?.at(-1)?.speakers || []);
+      // Experts without local software cannot be woken by the runner, so only automatic ones are candidates.
+      const waiting = experts.filter(name => name !== room.host && !spoken.has(name) && this.config.participants[name]);
+      if (!waiting.length) return skip('round', '本轮未发言的专家都是手动接入，无法自动安排');
+      // An expert the user just skipped is not picked again unless nobody else is left.
+      const skipped = room.current_turn?.status === 'cancelled' ? room.current_turn.expert : null;
+      const candidates = waiting.filter(name => name !== skipped);
+      return this.next_speaker_plan(room, context, candidates.length ? candidates : waiting, anchor);
     }
     if (room.named_followup) return skip('round', '点名追问已开启，由主持人安排下一轮');
     const decision = await decide_round(this.config.api_home, this.config.scheduler,
-      { ...context, experts, last_speaker: room.current_turn?.expert }, this.fetch);
+      { ...context, experts: automatic, last_speaker: room.current_turn?.expert }, this.fetch);
     const plan = { ...decision, kind: 'round', after_message_id: anchor };
     if (decision.action !== 'continue') return plan;
-    const round = room.completed_rounds + 1;
-    const order = [decision.first, ...experts.filter(name => name !== decision.first)].slice(0, MAX_PLAN_TURNS);
+    // Only the first speaker is arranged; each answer ends with an empty queue, so the next one is judged then.
     return { ...plan, phase: room.phase === 'initial' ? 'discussing' : undefined,
-      turns: order.map(expert => ({ expert, question: peer_round_question(round) })) };
+      turns: [{ expert: decision.first, question: peer_round_question(room.completed_rounds + 1) }] };
+  }
+  /** Ask the decision model for the next speaker among candidates; an expert who never spoke gets the opening prompt. */
+  async next_speaker_plan(room, context, candidates, anchor) {
+    const next = await decide_next_speaker(this.config.api_home, this.config.scheduler, { ...context, candidates }, this.fetch);
+    const plan = { ...next, kind: 'round', after_message_id: anchor };
+    if (next.action !== 'next') return plan;
+    const has_spoken = (room.rounds || []).some(round => round.speakers.includes(next.expert));
+    const question = has_spoken ? peer_round_question(room.completed_rounds + 1) : opening_question(room.phase);
+    return { ...plan, turns: [{ expert: next.expert, question }] };
   }
   /**
    * A roster change voids queued turns, leaving them skipped after the last real arrangement. Put back the ones whose
@@ -402,7 +425,7 @@ export class DiscussionRunner {
     const spoken = new Set(room.rounds?.at(-1)?.speakers || []);
     const planned = new Set(voided.map(turn => turn.expert));
     const joining = experts.filter(name => !spoken.has(name) && !planned.has(name));
-    const opening = room.phase === 'initial' ? '欢迎加入：请先读取议题，独立给出你的开场观点。' : '欢迎加入：请先读取议题和已有回答，给出你的观点。';
+    const opening = opening_question(room.phase);
     const plan_turns = [...voided.map(({ expert, question }) => ({ expert, question })), ...joining.map(expert => ({ expert, question: opening }))].slice(0, MAX_PLAN_TURNS);
     if (!plan_turns.length) return null;
     const label = `成员有变化：${voided.length ? `补回原计划（${voided.map(turn => turn.expert).join('、')}）` : '原计划成员已离开'}${joining.length ? `，请 ${joining.join('、')} 开场` : ''}`;

package/runner/scheduler.mjs

@@ -126,6 +126,25 @@ export async function decide_interjection(home, scheduler, { title, goal, user_r
   return { action: 'host', confidence, label: choice === HOST_CHOICE && sure ? '这条留言需要主持人处理' : '拿不准这条留言如何处理，交给主持人' };
 }
 
+/**
+ * Mid-round with no queued turn left: pick the next speaker among the experts who can be woken and have not spoken
+ * this round, or hand back to the host when unsure or when the discussion needs steering.
+ */
+export async function decide_next_speaker(home, scheduler, { title, goal, user_request, context, host, candidates }, fetch_impl) {
+  const recent = context.slice(-CONTEXT_MESSAGES).map(excerpt);
+  const state = [topic_lines(title, goal, user_request), recent.length ? `本轮及最近发言（旧→新）：\n${recent.join('\n')}` : '还没有发言。'].join('\n\n');
+  const choices = [...candidates.map(name => ({ value: name, description: `请 ${name} 接着发言` })),
+    { value: HOST_CHOICE, description: `交给主持人 ${host}：讨论偏离目标、卡住，或需要主持人调整安排` }];
+  const answers = await decide(home, scheduler, state, [{ type: 'choice', name: 'speaker',
+    instructions: '本轮还有专家没发言，安排被取消或用完。结合已有发言判断下一位应请谁发言：优先选被点名追问、最能回应当前焦点的人。', choices }], fetch_impl);
+  const choice = answers.speaker?.choice;
+  const confidence = certainty(answers.speaker);
+  if (candidates.includes(choice) && confidence !== null && confidence >= ROUTE_CONFIDENCE) {
+    return { action: 'next', expert: choice, confidence, label: `本轮继续，请 ${choice} 接着发言` };
+  }
+  return { action: 'host', confidence, label: '拿不准下一位该请谁发言，交给主持人' };
+}
+
 /**
  * At the end of a round without named follow-ups: continue with another peer round, or wake the host
  * (to conclude, or because the discussion drifted, repeats itself or is stuck). The first speaker is never the last one.

package/web/app.js

@@ -2236,7 +2236,7 @@ async function copy_member_join(name, with_credential = false) {
   let instruction;
   if (member.access === "online") instruction = "你是在线只读成员，请在原聊天回答，由用户或授权主持人代发；不要尝试直接写入房间。模型与思考强度在原网页设置。";
   else if (member.access === "runner") instruction = `${skills}等待本机程序交付有效任务，按 task 中的 access_file 和 execution 凭据操作${room.mode === "free" ? "；自由协作的回答必须绑定本次有效 execution_id" : ""}。不要另建定时任务；只处理本次有效执行，失效或撤销后停止提交。下载的持久成员私有文件不能替代自动执行凭据。`;
-  else if (with_credential) instruction = `${skills}凭证文本在下方：原样设为环境变量 DISCUSS_ACCESS（不要回显，不要写进命令行参数），命令省略 --access-file；先执行 codiscuss room view ${room.id} --site ${location.origin} --as ${name}，后续命令保持本站点、房间和身份。模型与思考强度在原软件中设置。${manual_trigger_instruction(room)}${workspace_instruction()}`;
+  else if (with_credential) instruction = `${skills}凭证文本在下方：每条 codiscuss 命令都在同一命令内把它原样设为环境变量 DISCUSS_ACCESS（不回显；首条 room view 也要带，否则无法识别你），命令省略 --access-file；先执行 codiscuss room view ${room.id} --site ${location.origin} --as ${name}，后续命令保持本站点、房间和身份。模型与思考强度在原软件中设置。${manual_trigger_instruction(room)}${workspace_instruction()}`;
   else instruction = `${skills}使用属于你的私有文件 member-${room.id}-${name}.json，由用户提供它在本机的实际完整路径；先执行 codiscuss room view ${room.id} --site ${location.origin} --as ${name} --access-file "实际完整路径"，后续命令保持本站点、房间和身份。不要读取或公开文件中的 token；若用户给的是凭证文本而非文件，把它设为环境变量 DISCUSS_ACCESS（不要回显）并省略 --access-file。模型与思考强度在原软件中设置。${manual_trigger_instruction(room)}${workspace_instruction()}`;
   const credential = with_credential ? `
 凭证文本（含 token，仅限你使用）：${JSON.stringify({ site: location.origin, room: room.id, token: member_credentials(room.id)[name].token })}` : "";