feat(remote-control): 优化 Web 展示、状态同步与桥接控制流程 (#288)

Co-authored-by: chengzifeng <chengzifeng@meituan.com>

packages/builtin-tools/src/tools/SleepTool/SleepTool.ts

@@ -3,8 +3,11 @@ import { z } from 'zod/v4'
 import type { ToolResultBlockParam } from 'src/Tool.js'
 import { buildTool } from 'src/Tool.js'
 import { lazySchema } from 'src/utils/lazySchema.js'
+import { notifyAutomationStateChanged } from 'src/utils/sessionState.js'
 import { SLEEP_TOOL_NAME, DESCRIPTION, SLEEP_TOOL_PROMPT } from './prompt.js'
 
+const SLEEP_WAKE_CHECK_INTERVAL_MS = 500
+
 const inputSchema = lazySchema(() =>
   z.strictObject({
     duration_seconds: z
@@ -19,6 +22,36 @@ type SleepInput = z.infer<InputSchema>
 
 type SleepOutput = { slept_seconds: number; interrupted: boolean }
 
+function isProactiveAutomationEnabled(): boolean {
+  if (!(feature('PROACTIVE') || feature('KAIROS'))) {
+    return false
+  }
+
+  const mod =
+    require('src/proactive/index.js') as typeof import('src/proactive/index.js')
+  return mod.isProactiveActive()
+}
+
+function isProactiveSleepAllowed(): boolean {
+  if (!(feature('PROACTIVE') || feature('KAIROS'))) {
+    return true
+  }
+
+  const mod =
+    require('src/proactive/index.js') as typeof import('src/proactive/index.js')
+  return mod.isProactiveActive()
+}
+
+function hasQueuedWakeSignal(): boolean {
+  const queue =
+    require('src/utils/messageQueueManager.js') as typeof import('src/utils/messageQueueManager.js')
+  return queue.hasCommandsInQueue()
+}
+
+function shouldInterruptSleep(): boolean {
+  return !isProactiveSleepAllowed() || hasQueuedWakeSignal()
+}
+
 export const SleepTool = buildTool({
   name: SLEEP_TOOL_NAME,
   searchHint: 'wait pause sleep rest idle duration timer',
@@ -42,6 +75,9 @@ export const SleepTool = buildTool({
   isReadOnly() {
     return true
   },
+  interruptBehavior() {
+    return 'cancel'
+  },
 
   userFacingName() {
     return SLEEP_TOOL_NAME
@@ -67,53 +103,84 @@ export const SleepTool = buildTool({
   },
 
   async call(input: SleepInput, context) {
-    // Refuse to sleep when proactive mode is off — prevents the model from
-    // re-issuing Sleep after an interruption caused by /proactive disable.
-    if (feature('PROACTIVE') || feature('KAIROS')) {
-      const mod =
-        require('src/proactive/index.js') as typeof import('src/proactive/index.js')
-      if (!mod.isProactiveActive()) {
-        return {
-          data: {
-            slept_seconds: 0,
-            interrupted: true,
-          },
-        }
+    // Don't enter sleep if proactive was disabled or new work arrived while
+    // the model was deciding to wait.
+    if (shouldInterruptSleep()) {
+      return {
+        data: {
+          slept_seconds: 0,
+          interrupted: true,
+        },
       }
     }
 
     const { duration_seconds } = input
     const startTime = Date.now()
+    const sleepUntil = startTime + duration_seconds * 1000
+
+    if (isProactiveAutomationEnabled()) {
+      notifyAutomationStateChanged({
+        enabled: true,
+        phase: 'sleeping',
+        next_tick_at: null,
+        sleep_until: sleepUntil,
+      })
+    }
 
     try {
       await new Promise<void>((resolve, reject) => {
-        const timer = setTimeout(resolve, duration_seconds * 1000)
+        let timer: ReturnType<typeof setTimeout> | null = null
+        let wakeCheck: ReturnType<typeof setInterval> | null = null
+        let settled = false
+
+        const cleanup = () => {
+          if (timer !== null) {
+            clearTimeout(timer)
+            timer = null
+          }
+          if (wakeCheck !== null) {
+            clearInterval(wakeCheck)
+            wakeCheck = null
+          }
+          context.abortController.signal.removeEventListener('abort', onAbort)
+        }
+
+        const finish = () => {
+          if (settled) return
+          settled = true
+          cleanup()
+          resolve()
+        }
+
+        const interrupt = () => {
+          if (settled) return
+          settled = true
+          cleanup()
+          reject(new Error('interrupted'))
+        }
+
+        const onAbort = () => {
+          interrupt()
+        }
+
+        timer = setTimeout(finish, duration_seconds * 1000)
 
         // Abort via user interrupt
-        context.abortController.signal.addEventListener(
-          'abort',
-          () => {
-            clearTimeout(timer)
-            clearInterval(proactiveCheck)
-            reject(new Error('interrupted'))
-          },
-          { once: true },
-        )
+        if (context.abortController.signal.aborted) {
+          interrupt()
+          return
+        }
+        context.abortController.signal.addEventListener('abort', onAbort, {
+          once: true,
+        })
 
-        // Poll proactive state — if deactivated mid-sleep, interrupt early
-        // so the user doesn't have to wait for the full duration.
-        const proactiveCheck =
-          feature('PROACTIVE') || feature('KAIROS')
-            ? setInterval(() => {
-                const mod =
-                  require('src/proactive/index.js') as typeof import('src/proactive/index.js')
-                if (!mod.isProactiveActive()) {
-                  clearTimeout(timer)
-                  clearInterval(proactiveCheck)
-                  reject(new Error('interrupted'))
-                }
-              }, 500)
-            : (null as unknown as ReturnType<typeof setInterval>)
+        // Poll proactive state and the shared command queue so new work can
+        // wake Sleep without waiting for the full duration.
+        wakeCheck = setInterval(() => {
+          if (shouldInterruptSleep()) {
+            interrupt()
+          }
+        }, SLEEP_WAKE_CHECK_INTERVAL_MS)
       })
       return {
         data: {
@@ -129,6 +196,17 @@ export const SleepTool = buildTool({
           interrupted: true,
         },
       }
+    } finally {
+      notifyAutomationStateChanged(
+        isProactiveAutomationEnabled()
+          ? {
+              enabled: true,
+              phase: null,
+              next_tick_at: null,
+              sleep_until: null,
+            }
+          : null,
+      )
     }
   },
 })

packages/builtin-tools/src/tools/SleepTool/__tests__/SleepTool.test.ts

@@ -0,0 +1,41 @@
+import { beforeEach, describe, expect, test } from 'bun:test'
+import { SleepTool } from '../SleepTool'
+import {
+  enqueue,
+  getCommandQueue,
+  resetCommandQueue,
+} from 'src/utils/messageQueueManager.js'
+
+describe('SleepTool', () => {
+  beforeEach(() => {
+    resetCommandQueue()
+  })
+
+  test('declares cancel interrupt behavior', () => {
+    expect(SleepTool.interruptBehavior()).toBe('cancel')
+  })
+
+  test('wakes early when queued work arrives', async () => {
+    const sleepPromise = SleepTool.call(
+      { duration_seconds: 10 },
+      { abortController: new AbortController() } as any,
+    )
+
+    setTimeout(() => {
+      enqueue({
+        value: 'wake up',
+        mode: 'prompt',
+      })
+    }, 20)
+
+    const result = await sleepPromise
+
+    expect(result.data.interrupted).toBe(true)
+    expect(result.data.slept_seconds).toBeLessThan(10)
+    expect(getCommandQueue()).toHaveLength(1)
+    expect(getCommandQueue()[0]).toMatchObject({
+      value: 'wake up',
+      mode: 'prompt',
+    })
+  })
+})