@xmanrui/dsh-im 0.11.0 → 0.12.0

package/src/channels/qq/qq-bridge.mjs

@@ -1,5 +1,9 @@
 import { runWorkspaceCommand } from '../shared/workspace-command.mjs';
 import { runCompactCommand } from '../shared/compact-command.mjs';
+import {
+  isControlCommand,
+  runControlCommand,
+} from '../shared/control-command.mjs';
 import { rememberConnectionTestTarget } from '../shared/connection-test.mjs';
 import {
   harnessAnswerForQuestion,
@@ -7,6 +11,10 @@ import {
   validHarnessQuestion,
 } from '../shared/harness-question.mjs';
 import { HarnessApprovalQueue } from '../shared/harness-approval.mjs';
+import {
+  isModelCommand,
+  runModelCommand,
+} from '../shared/model-command.mjs';
 import { askInWorkspaceSession } from '../shared/workspace-session.mjs';
 import {
   fetchImageBuffer,
@@ -38,6 +46,10 @@ const HELP_TEXT = [
   '/workspacelist  列出工作区绝对路径',
   '/sessionlist [工作区序号或绝对路径]  列出会话 ID 和标题',
   '/session Session ID 或当前工作区序号  将当前聊天绑定到指定会话',
+  '/models  列出所有可用模型',
+  '/model [模型ID]  查看或切换当前会话模型',
+  '/stop  停止当前任务',
+  '/steer 补充指令  纠偏当前任务',
   '/status  检查连接状态',
   '/help  显示本帮助',
 ].join('\n');
@@ -134,6 +146,7 @@ export class QqHarnessBridge {
   #interactionKeys = new Map();
   #acceptedMessageIds = new Set();
   #approvalTasks = new Set();
+  #commandTasks = new Set();
   #approvals;
 
   constructor({
@@ -184,6 +197,34 @@ export class QqHarnessBridge {
       rememberConnectionTestTarget(this.#state, message.replyTarget);
     }
     const pending = this.#pendingInteractions.get(key);
+    const commandText = safeText(message);
+    const commandRunner = isControlCommand(commandText)
+      ? runControlCommand
+      : (isModelCommand(commandText) ? runModelCommand : null);
+    const allowed = this.#ownerUserOpenid === '*' || sender === this.#ownerUserOpenid;
+    const addressed = message.kind !== 'group'
+      || message.rawEventType === 'GROUP_AT_MESSAGE_CREATE';
+    if (commandRunner && allowed && addressed) {
+      let task;
+      task = this.#processFastCommand(
+        message,
+        messageId,
+        key,
+        commandText,
+        commandRunner,
+      ).catch((error) => {
+        if (error?.code === 'turn-stopped' || this.#signal?.aborted) return;
+        this.#status.lastError = error?.message ?? String(error);
+        this.#logger.error?.('[dsh-im:qq] failed to process a command:', error);
+        return this.#bot.sendText(message.replyTarget, '消息处理失败，请稍后重试。')
+          .catch(() => undefined);
+      }).finally(() => {
+        this.#acceptedMessageIds.delete(messageId);
+        this.#commandTasks.delete(task);
+      });
+      this.#commandTasks.add(task);
+      return task;
+    }
     const approval = this.#approvals.claimReply({
       key,
       actor: sender,
@@ -262,9 +303,35 @@ export class QqHarnessBridge {
         pending.queue ? [pending.queue] : []
       )),
       ...this.#approvalTasks,
+      ...this.#commandTasks,
     ]);
   }
 
+  async #processFastCommand(message, messageId, key, text, runner) {
+    this.#signal?.throwIfAborted();
+    if (this.#state.hasSeen(messageId)) return;
+    await this.#state.markSeen(messageId);
+    this.#status.messagesReceived += 1;
+    this.#status.lastMessageAt = new Date().toISOString();
+    const result = await runner(text, this.#harness, this.#state, key, {
+      signal: this.#signal,
+      hasImages: hasQqImageAttachments(message),
+      pendingInteraction: this.#pendingInteractions.has(key)
+        || this.#approvals.hasPending(key),
+      control: { owner: this, key },
+    });
+    if (result?.stopped) {
+      await Promise.allSettled([
+        this.#cancelPendingInteraction(key),
+        this.#approvals.closeRoute(key),
+      ]);
+    }
+    for (const reply of result?.messages ?? [result?.message]) {
+      if (reply) await this.#bot.sendText(message.replyTarget, reply);
+    }
+    this.#status.lastError = null;
+  }
+
   async #process(message, key, { alreadyRecorded = false } = {}) {
     if (this.#signal?.aborted) return;
     const messageId = nonEmptyString(message?.messageId);
@@ -360,6 +427,7 @@ export class QqHarnessBridge {
           askOptions: {
             timeoutMs: this.#replyTimeoutMs,
             signal: this.#signal,
+            control: { owner: this, key },
             onUpdate: stream ? async (update) => {
               const progress = update.type === 'text'
                 ? update.text
@@ -399,6 +467,22 @@ export class QqHarnessBridge {
       this.#status.lastReplyAt = new Date().toISOString();
       this.#status.lastError = null;
     } catch (error) {
+      if (error?.code === 'turn-stopped') {
+        if (stream) {
+          try {
+            await stream.cancel?.();
+          } catch (streamError) {
+            this.#logger.warn?.('[dsh-im:qq] unable to cancel a stopped QQ stream:', streamError);
+          }
+          try {
+            await this.#bot.sendText(target, '已停止。');
+          } catch (sendError) {
+            this.#logger.warn?.('[dsh-im:qq] unable to announce a stopped QQ turn:', sendError);
+          }
+        }
+        await this.#state.markSeen(messageId);
+        return;
+      }
       stream?.cancel?.();
       if (this.#signal?.aborted) return;
       this.#status.lastError = error?.message ?? String(error);

package/src/channels/shared/bot-workspace-store.mjs

@@ -511,7 +511,9 @@ export function createBotWorkspaceScope(harness, { botId, workspaces, state }) {
           }
         };
       }
-      if ((property === 'listWorkspaces' || property === 'listWorkspaceSessions')
+      if ((property === 'listWorkspaces'
+        || property === 'listWorkspaceSessions'
+        || property === 'listModels')
         && typeof target[property] === 'function') {
         return async (...args) => {
           if (!isCurrentScope()) {
@@ -627,6 +629,30 @@ export function createBotWorkspaceScope(harness, { botId, workspaces, state }) {
           sessionGenerations.delete(sessionId);
           const isCurrentSession = () => isCurrentScope()
             && generation === workspaces.generationFor(botId);
+          const invokeCurrentSession = async (method, args, action) => {
+            if (!isCurrentSession()) {
+              throw workspaceSessionStale(
+                `The bot workspace changed before this ${action} started.`,
+              );
+            }
+            const result = await target[method](sessionId, ...args);
+            if (!isCurrentSession()) {
+              throw workspaceSessionStale(
+                `The bot workspace changed while this ${action} was running.`,
+              );
+            }
+            return result;
+          };
+          const invokeStartedSessionMutation = async (method, args, action) => {
+            if (!isCurrentSession()) {
+              throw workspaceSessionStale(
+                `The bot workspace changed before this ${action} started.`,
+              );
+            }
+            // Once an irreversible control mutation has started, preserve its
+            // actual outcome even if a workspace switch commits concurrently.
+            return target[method](sessionId, ...args);
+          };
           return Object.freeze({
             sessionId,
             async sessionExists(...args) {
@@ -634,6 +660,24 @@ export function createBotWorkspaceScope(harness, { botId, workspaces, state }) {
               const exists = await target.sessionExists(sessionId, ...args);
               return isCurrentSession() && exists;
             },
+            models(...args) {
+              return invokeCurrentSession('getSessionModels', args, 'model listing');
+            },
+            selectModel(...args) {
+              return invokeCurrentSession('selectSessionModel', args, 'model selection');
+            },
+            isRunning(...args) {
+              return invokeCurrentSession('isSessionRunning', args, 'run-state check');
+            },
+            hasActiveTurn(...args) {
+              return invokeCurrentSession('hasActiveTurn', args, 'turn ownership check');
+            },
+            stopActiveTurn(...args) {
+              return invokeStartedSessionMutation('stopActiveTurn', args, 'turn stop');
+            },
+            steerActiveTurn(...args) {
+              return invokeStartedSessionMutation('steerActiveTurn', args, 'turn steering');
+            },
             ask(...args) {
               if (!isCurrentSession()) {
                 throw workspaceSessionStale(

package/src/channels/shared/control-command.mjs

@@ -0,0 +1,84 @@
+const CONTROL_COMMAND = /^\/(?:stop|steer)(?=$|\s)/iu;
+const STOP_COMMAND = /^\/stop(?=$|\s)/iu;
+const STOP_USAGE = '用法：/stop（不带参数）';
+const STEER_USAGE = '用法：/steer <补充指令>';
+const TEXT_ONLY = '控制命令仅支持纯文字，请移除图片后重试。';
+
+function commandResult(message, extra = {}) {
+  return { message, ...extra };
+}
+
+function requestOptions(signal) {
+  return signal ? { signal } : {};
+}
+
+function boundSession(harness, state, key) {
+  if (typeof state?.sessionFor !== 'function') return null;
+  const sessionId = state.sessionFor(key);
+  if (typeof sessionId !== 'string' || !sessionId) return null;
+  if (typeof harness?.workspaceSession !== 'function') {
+    throw new TypeError('Harness does not support workspace sessions');
+  }
+  const session = harness.workspaceSession(sessionId);
+  if (!session || typeof session !== 'object') {
+    throw new TypeError('Harness returned an invalid workspace session');
+  }
+  return session;
+}
+
+export function isControlCommand(text) {
+  return typeof text === 'string' && CONTROL_COMMAND.test(text.trim());
+}
+
+export async function runControlCommand(text, harness, state, key, {
+  signal,
+  hasImages = false,
+  pendingInteraction = false,
+  control,
+} = {}) {
+  if (!isControlCommand(text)) return null;
+  const command = text.trim();
+  const stop = STOP_COMMAND.test(command);
+
+  if (hasImages) return commandResult(TEXT_ONLY);
+
+  if (stop) {
+    if (!/^\/stop$/iu.test(command)) return commandResult(STOP_USAGE);
+    const session = boundSession(harness, state, key);
+    if (!session) return commandResult('当前聊天没有正在运行的任务。');
+    if (typeof session.stopActiveTurn !== 'function') {
+      throw new TypeError('Harness session does not support stopping active turns');
+    }
+    const stopped = await session.stopActiveTurn(control, requestOptions(signal));
+    return stopped
+      ? commandResult('已请求停止当前任务。', { stopped: true })
+      : commandResult('当前聊天没有正在运行的任务。');
+  }
+
+  const match = /^\/steer(?:\s+([\s\S]*))?$/iu.exec(command);
+  const instruction = match?.[1]?.trim() ?? '';
+  if (!instruction) return commandResult(STEER_USAGE);
+  if (pendingInteraction) {
+    return commandResult([
+      '当前任务正在等待你的回答或审批。',
+      '',
+      '请先处理当前请求，或者发送 /stop 停止任务。',
+    ].join('\n'));
+  }
+
+  const session = boundSession(harness, state, key);
+  if (!session) {
+    return commandResult('当前聊天没有正在运行的任务，请直接发送普通消息。');
+  }
+  if (typeof session.steerActiveTurn !== 'function') {
+    throw new TypeError('Harness session does not support steering active turns');
+  }
+  const steered = await session.steerActiveTurn(
+    instruction,
+    control,
+    requestOptions(signal),
+  );
+  return steered
+    ? commandResult('已提交补充指令，Agent 会在下一步读取。')
+    : commandResult('当前聊天没有正在运行的任务，请直接发送普通消息。');
+}

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

@@ -110,6 +110,10 @@ export class HarnessApprovalQueue {
     this.#logger = logger;
   }
 
+  hasPending(key) {
+    return this.#routes.get(key)?.items.some((pending) => !pending.inactive) === true;
+  }
+
   claimReply({
     key,
     actor,