dsh-plugin-subagent-bridge 0.11.1 → 0.12.1

package/README.md

@@ -63,7 +63,8 @@ DSH 的 prompt 有两种投递模式，桥把它们交给调用方选：
 | `mode` | 行为 |
 | --- | --- |
 | `queue`（默认） | 等当前回合跑完再处理这条消息 |
-| `steer` | **立刻打断**当前回合，把这条消息插进去 |
+| `steer` | 把消息**插进当前回合**（当前那一步仍会跑完） |
+| `interrupt` | **先取消当前回合**，再发送，真正立刻停下 |
 
 `dsh_task`、`dsh_spawn`、`dsh_followup` 都支持：
 
@@ -74,7 +75,12 @@ dsh_task({ sessionId: "session-…", prompt: "停一下，改成只跑单测", m
 
 和 `dsh_dispatch` 的关系：`dsh_dispatch` 一直有 `mode`，但它只投递、不等待；`dsh_task` 会阻塞到回合结束，所以以前对正在运行的会话直接拒绝。现在传 `mode: "steer"` 就允许插进运行中的会话——**它会先打断当前回合**，然后等这一轮结束才返回。
 
-一个容易踩的细节：`steer` 的消息会被**当前回合直接吸收**（不会新开一轮），所以等待条件不能是"下一个回合结束"。早期实现就是这么写的，结果答案已经回来了、调用却一直等到 120 秒超时才知道。现在 steer 等的是「当前回合结束」。
+两个实测出来的细节：
+
+1. **`steer` 不会打断正在执行的工具**。实测：worker 正在跑 `sleep 90`，`steer` 进去后消息被**并入当前回合**，但要等那一步工具调用结束才会被模型看到——整整等了 70 秒。原因是 `steer` 只是投递，`cancel` 才是中止。
+2. **`steer` 不新开回合**，所以等待条件不能是"下一个回合结束"。早期实现那样写，答案已经回来了、调用还在等，最后 120 秒超时。现在 steer 等的是「当前回合结束」。
+
+所以真要"按下就停"，用 `interrupt`：它先 `cancel` 掉当前回合（最多等 15 秒确认），再以普通排队模式发消息，开启新回合。
 
 返回里带 `mode` 字段，方便确认这次是排队还是打断。
 

package/index.js

@@ -117,9 +117,9 @@ const TOOLS = [
         },
         mode: {
           type: 'string',
-          enum: ['queue', 'steer'],
+          enum: ['queue', 'steer', 'interrupt'],
           description:
-            'delivery: "queue" (default) waits for the running turn to finish, "steer" interrupts it and inserts this message now.',
+            'delivery: "queue" (default) waits for the running turn to finish; "steer" inserts the message into that turn (its current step still completes); "interrupt" cancels the running turn first, then sends.',
         },
 
         reasoningEffort: {
@@ -160,9 +160,9 @@ const TOOLS = [
         },
         mode: {
           type: 'string',
-          enum: ['queue', 'steer'],
+          enum: ['queue', 'steer', 'interrupt'],
           description:
-            'delivery: "queue" (default) waits for the running turn to finish, "steer" interrupts it and inserts this message now.',
+            'delivery: "queue" (default) waits for the running turn to finish; "steer" inserts the message into that turn (its current step still completes); "interrupt" cancels the running turn first, then sends.',
         },
 
         reasoningEffort: { type: 'string', description: 'Reasoning level for `model`, when that model offers levels.' },
@@ -187,9 +187,9 @@ const TOOLS = [
         reasoningEffort: { type: 'string', description: 'Reasoning level for `model`, when that model offers levels.' },
         mode: {
           type: 'string',
-          enum: ['queue', 'steer'],
+          enum: ['queue', 'steer', 'interrupt'],
           description:
-            'delivery: "queue" (default) waits for the running turn to finish, "steer" interrupts it and inserts this message now.',
+            'delivery: "queue" (default) waits for the running turn to finish; "steer" inserts the message into that turn (its current step still completes); "interrupt" cancels the running turn first, then sends.',
         },
       },
       required: ['worker', 'message'],
@@ -610,7 +610,7 @@ async function callTool(id, params, api, signal) {
               from: args.from,
               cwd: args.cwd,
               workspace: args.workspace === true || (typeof args.workspace === 'string' && args.workspace !== '') ? args.workspace : undefined,
-              mode: args.mode === 'steer' ? 'steer' : undefined,
+              mode: args.mode === 'steer' || args.mode === 'interrupt' ? args.mode : undefined,
               model: typeof args.model === 'string' && args.model !== '' ? args.model : undefined,
               reasoningEffort:
                 typeof args.reasoningEffort === 'string' && args.reasoningEffort !== '' ? args.reasoningEffort : undefined,
@@ -627,7 +627,7 @@ async function callTool(id, params, api, signal) {
             await api.followup({
               worker,
               message,
-              mode: args.mode === 'steer' ? 'steer' : undefined,
+              mode: args.mode === 'steer' || args.mode === 'interrupt' ? args.mode : undefined,
               model: typeof args.model === 'string' && args.model !== '' ? args.model : undefined,
               reasoningEffort:
                 typeof args.reasoningEffort === 'string' && args.reasoningEffort !== '' ? args.reasoningEffort : undefined,
@@ -666,7 +666,7 @@ async function callTool(id, params, api, signal) {
               sessionId,
               agentPreset: typeof args.agentPreset === 'string' && args.agentPreset !== '' ? args.agentPreset : undefined,
               workspace: args.workspace === true || (typeof args.workspace === 'string' && args.workspace !== '') ? args.workspace : undefined,
-              mode: args.mode === 'steer' ? 'steer' : undefined,
+              mode: args.mode === 'steer' || args.mode === 'interrupt' ? args.mode : undefined,
               model: typeof args.model === 'string' && args.model !== '' ? args.model : undefined,
               reasoningEffort:
                 typeof args.reasoningEffort === 'string' && args.reasoningEffort !== '' ? args.reasoningEffort : undefined,
@@ -869,15 +869,30 @@ export function createApi(ctx, state, settings) {
         }
         if (typeof targetId !== 'string' || targetId === '') throw new Error('session controller did not return a session id')
         created = true
-      } else if (mode !== 'steer' && ctx.get('agents')?.get?.(targetId)?.status === 'running') {
+      } else if (mode !== 'steer' && mode !== 'interrupt' && ctx.get('agents')?.get?.(targetId)?.status === 'running') {
         /* Steering exists precisely to reach a running session; queueing into one would
          * silently wait for a turn this call is not tracking. */
-        throw new Error('that session is running; pass mode:"steer" to interrupt it, or use dsh_dispatch plus dsh_read_result')
+        throw new Error('that session is running; pass mode:"steer" (insert into the turn) or mode:"interrupt" (cancel it first), or use dsh_dispatch plus dsh_read_result')
       }
 
       const appliedModel = await applyModelSpec(ctx, targetId, model, reasoningEffort)
-      const deliveryMode = mode === 'steer' ? 'steer' : 'queue'
+      const deliveryMode = mode === 'steer' ? 'steer' : mode === 'interrupt' ? 'interrupt' : 'queue'
       const turnBefore = lastTurn(ctx, targetId)
+
+      /* `steer` inserts the message into the running turn, but that turn still finishes its
+       * current step first — an in-flight tool call keeps running. `interrupt` is the hard
+       * stop: cancel the turn, then send, so the worker drops what it was doing. */
+      if (deliveryMode === 'interrupt' && ctx.get('agents')?.get?.(targetId)?.status === 'running') {
+        try {
+          await service.cancel({ sessionId: targetId })
+        } catch {
+          /* Cancelling is best effort: the send below still delivers the message. */
+        }
+        /* The abort closes the *current* turn, so accept that number: waiting for a
+         * strictly newer turn burned the whole grace period before every send. */
+        await waitForTurnEnd(ctx, targetId, Math.max(0, turnBefore - 1), 15000)
+      }
+
       /* A steered message is absorbed by the turn that is already running, so waiting for
        * a strictly newer turn would hang until the timeout even after the answer landed. */
       const waitAfter = deliveryMode === 'steer' ? Math.max(0, turnBefore - 1) : turnBefore
@@ -885,7 +900,7 @@ export function createApi(ctx, state, settings) {
       const finished = waitForTurnEnd(ctx, targetId, waitAfter, seconds * 1000)
       const requestId = randomUUID()
       const accepted = await service.prompt(
-        { sessionId: targetId, requestId, mode: deliveryMode, content: [{ type: 'text', text: prompt }] },
+        { sessionId: targetId, requestId, mode: deliveryMode === 'steer' ? 'steer' : 'queue', content: [{ type: 'text', text: prompt }] },
         AbortSignal.timeout(30000),
       )
       state.dispatched.add(targetId)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-subagent-bridge",
-  "version": "0.11.1",
+  "version": "0.12.1",
   "type": "module",
   "description": "Subagent bridge: lets Codex delegate a task to DeepSeek Harness the way it would spawn a subagent (one call, waits for the answer), plus a codex_dispatch tool for the reverse direction.",
   "keywords": [