@anionex/dsh-computer-use 0.2.0 → 0.3.0

package/src/providers/macos.ts

@@ -9,6 +9,8 @@ import type {} from '@deepseek-ai/dsh-user-approval'
 import type {
   BackendActionRequest,
   BackendActionResult,
+  BackendCursorActivation,
+  BackendTrackedDragResult,
   BackendCursorAction,
   BackendHealth,
   BackendObservation,
@@ -36,6 +38,11 @@ interface NativeHealth {
 
 interface NativeObservation extends BackendObservation {}
 
+interface NativeCursorActivation {
+  observation: NativeObservation
+  activation: BackendCursorActivation['activation']
+}
+
 function createBackend(ctx: Context, config: ResolvedComputerUseConfig): ComputerUseBackend {
   return process.platform === 'darwin'
     ? new MacOSBackend(ctx, config)
@@ -71,7 +78,27 @@ export class MacOSBackend implements ComputerUseBackend {
     }, signal)
   }
 
+  async activateForCursor(
+    app: ComputerAppIdentity,
+    expectedStateHash: string,
+    options: BackendObserveOptions,
+    signal: AbortSignal,
+  ): Promise<BackendCursorActivation> {
+    return await this.client.invoke<NativeCursorActivation>({
+      command: 'activate-for-cursor',
+      app,
+      expectedStateHash,
+      options,
+      actionTimeoutMs: this.config.actionTimeoutMs,
+    }, signal)
+  }
+
   async act(request: BackendActionRequest, signal: AbortSignal): Promise<BackendActionResult> {
+    if (request.action.kind === 'drag') {
+      const execution = await this.prepareNativeDrag(request, signal)
+      await execution.start()
+      return await execution.result
+    }
     return await this.client.invoke<BackendActionResult>({
       command: 'act',
       request: {
@@ -86,7 +113,58 @@ export class MacOSBackend implements ComputerUseBackend {
     }, signal)
   }
 
-  async visualizeCursor(action: BackendCursorAction, phase: 'before' | 'after', signal: AbortSignal): Promise<CursorVisibility> {
+  async actDragWithCursor(
+    request: BackendActionRequest,
+    cursor: BackendCursorAction & { kind: 'drag' },
+    signal: AbortSignal,
+  ): Promise<BackendTrackedDragResult> {
+    const execution = await this.prepareNativeDrag(request, signal)
+    let started = false
+    let cursorResult: CursorVisibility
+    try {
+      cursorResult = await this.visualizeCursorPhase(cursor, 'during', signal, async () => {
+        await execution.start()
+        started = true
+      })
+    } catch (error) {
+      if (!started) {
+        execution.cancel()
+        await execution.result.catch(() => undefined)
+        throw error
+      }
+      cursorResult = {
+        visible: false,
+        reason: `the agent cursor could not track the drag action: ${error instanceof Error ? error.message : String(error)}`,
+      }
+    }
+    return { action: await execution.result, cursor: cursorResult }
+  }
+
+  private async prepareNativeDrag(request: BackendActionRequest, signal: AbortSignal) {
+    return await this.client.prepareDrag<BackendActionResult>({
+      command: 'act',
+      request: {
+        ...request,
+        actionTimeoutMs: this.config.actionTimeoutMs,
+        limits: {
+          maxNodes: this.config.maxNodes,
+          maxDepth: this.config.maxDepth,
+          maxTextBytes: this.config.maxTextBytes,
+        },
+      },
+    }, signal, this.config.actionTimeoutMs + 2_000)
+  }
+
+  async visualizeCursor(action: BackendCursorAction, phase: 'before' | 'during' | 'after', signal: AbortSignal): Promise<CursorVisibility> {
+    return await this.visualizeCursorPhase(action, phase, signal)
+  }
+
+  private async visualizeCursorPhase(
+    action: BackendCursorAction,
+    phase: 'before' | 'during' | 'after',
+    signal: AbortSignal,
+    onMoveWritten?: () => void | Promise<void>,
+  ): Promise<CursorVisibility> {
     if (this.config.interaction.cursorVisualization !== 'visible') return { visible: false, reason: 'the agent cursor is disabled by configuration' }
     // The overlay answers per command; the least visible outcome wins, because
     // a cursor that vanished partway through is a cursor the user cannot follow.
@@ -95,17 +173,23 @@ export class MacOSBackend implements ComputerUseBackend {
       if (!response.visible && outcome.visible) outcome = response
     }
     const autoHideMs = this.config.interaction.cursorAutoHideMs
-    const move = async (point: { x: number; y: number }, durationMs: number): Promise<void> => {
-      record(await this.client.cursorCommand({
+    const move = async (point: { x: number; y: number }, onWritten?: () => void | Promise<void>): Promise<void> => {
+      const command = {
         op: 'move',
         x: point.x,
         y: point.y,
-        durationMs,
-        autoHideMs,
+        speedPxPerSecond: this.config.interaction.cursorSpeedPxPerSecond,
+        accelerationPxPerSecondSquared: this.config.interaction.cursorAccelerationPxPerSecondSquared,
+        // The after phase arms the configured timeout once native input has
+        // completed. Hiding during travel or dwell would invalidate press.
+        autoHideMs: 0,
         targetPid: action.targetPid,
         targetWindowNumber: action.targetWindowNumber,
         targetWindowFrame: action.targetWindowFrame,
-      }, signal))
+      }
+      record(await (onWritten === undefined
+        ? this.client.cursorCommand(command, signal)
+        : this.client.cursorCommand(command, signal, onWritten)))
     }
     if (phase === 'after') {
       // Every action validates the bound target after native input. Only drag
@@ -119,24 +203,28 @@ export class MacOSBackend implements ComputerUseBackend {
       }, signal))
       return outcome
     }
+    if (phase === 'during') {
+      if (action.kind !== 'drag') return { visible: false, reason: 'only drag has a during-action cursor phase' }
+      await move(action.to, onMoveWritten)
+      return outcome
+    }
     const start = action.kind === 'drag' ? action.from : action.to
     if (start === undefined) return { visible: false, reason: 'this action has no cursor position to show' }
-    await move(start, this.config.interaction.cursorMotionMs)
-    if (this.config.interaction.cursorMotionMs > 0) {
-      await delay(this.config.interaction.cursorMotionMs, undefined, { signal })
+    // A move response means the native overlay reached its destination. Keep
+    // the configurable dwell after arrival and before the visual/native press.
+    await move(start)
+    if (!outcome.visible || action.kind === 'scroll') return outcome
+    if (this.config.interaction.cursorClickDelayMs > 0) {
+      await delay(this.config.interaction.cursorClickDelayMs, undefined, { signal })
     }
-    if (action.kind === 'scroll') return outcome
     record(await this.client.cursorCommand({
       op: 'press',
-      autoHideMs,
+      autoHideMs: 0,
       targetPid: action.targetPid,
       targetWindowNumber: action.targetWindowNumber,
       targetWindowFrame: action.targetWindowFrame,
       sustainedPress: action.kind === 'drag',
     }, signal))
-    if (action.kind === 'drag') {
-      await move(action.to, Math.max(this.config.interaction.cursorMotionMs, 240))
-    }
     return outcome
   }
 

package/src/providers/native-helper.ts

@@ -5,6 +5,7 @@ import { access, chmod, lstat, readFile, realpath, stat } from 'node:fs/promises
 import { constants, type Stats } from 'node:fs'
 import type { Writable } from 'node:stream'
 import { dirname, resolve } from 'node:path'
+import { createInterface } from 'node:readline'
 import { fileURLToPath } from 'node:url'
 import type { Context } from '@deepseek-ai/cordis'
 import type { SubprocessHandle, SubprocessOutcome, SubprocessOutputReader } from '@deepseek-ai/dsh-subprocess'
@@ -39,11 +40,20 @@ interface HelperSuccess<T> {
 
 type HelperEnvelope<T> = HelperFailure | HelperSuccess<T>
 
-/** The overlay normally answers in under a millisecond; silence is a visibility failure. */
-// Keep this off the native action's critical path. A timed-out generation is
-// discarded before the next serialized command, so a late frame cannot be
-// mistaken for the next command's response.
-const CURSOR_RESPONSE_TIMEOUT_MS = 120
+export interface PreparedNativeDrag<T> {
+  readonly result: Promise<T>
+  start(): Promise<void>
+  cancel(): void
+}
+
+/**
+ * The response includes synchronous WindowServer validation, which can exceed
+ * a scheduler tick under load even though the protocol itself is local.
+ */
+// Keep the bound finite. A timed-out generation is discarded before the next
+// serialized command, so a late frame cannot satisfy a later command.
+const CURSOR_RESPONSE_TIMEOUT_MS = 1_000
+const CURSOR_MOTION_RESPONSE_TIMEOUT_MS = 4_000
 
 const CURSOR_READY_TIMEOUT_MS = 2_000
 const CURSOR_PROTOCOL_MAX_BYTES = 64 * 1024
@@ -58,7 +68,16 @@ interface CursorProcess {
   terminate: () => void
   waitForExit: SubprocessHandle['waitForExit']
   /** Next response line from this process generation, in command order. */
-  nextResponse: () => Promise<CursorProtocolFrame>
+  nextResponse: (timeoutMs: number, signal: AbortSignal) => Promise<CursorProtocolFrame>
+}
+
+function cursorResponseTimeout(command: Record<string, unknown>): number {
+  if (command.op !== 'move') return CURSOR_RESPONSE_TIMEOUT_MS
+  if (typeof command.speedPxPerSecond === 'number') return CURSOR_MOTION_RESPONSE_TIMEOUT_MS
+  if (typeof command.durationMs === 'number' && Number.isFinite(command.durationMs)) {
+    return Math.max(CURSOR_RESPONSE_TIMEOUT_MS, Math.trunc(command.durationMs) + 2 * CURSOR_RESPONSE_TIMEOUT_MS)
+  }
+  return CURSOR_RESPONSE_TIMEOUT_MS
 }
 
 function collected(reader: SubprocessOutputReader | undefined): string {
@@ -113,9 +132,13 @@ function normalizeCursorResponse(
   }
   if (response.visible === true) return { result: { visible: true }, discardGeneration: false }
   if (response.visible === false) {
+    const reasonCode = response.reasonCode === 'target-not-frontmost' || response.reasonCode === 'target-invalid'
+      ? response.reasonCode
+      : undefined
     return {
       result: {
         visible: false,
+        ...(reasonCode === undefined ? {} : { reasonCode }),
         ...(typeof response.reason === 'string' && response.reason.length > 0
           ? { reason: response.reason.slice(0, 1000) }
           : { reason: 'the native cursor overlay reported that the cursor is not visible' }),
@@ -142,6 +165,7 @@ export class NativeHelperClient {
   private cursor: CursorProcess | undefined
   private cursorStart: { promise: Promise<CursorProcess> } | undefined
   private cursorCommandTail: Promise<void> = Promise.resolve()
+  private disposed = false
 
   constructor(
     private readonly ctx: Context,
@@ -253,17 +277,179 @@ export class NativeHelperClient {
     return envelope.value
   }
 
+  /** Prepare and validate a drag, then wait for an explicit pre-mouse-down start barrier. */
+  async prepareDrag<T>(
+    request: Record<string, unknown>,
+    signal: AbortSignal,
+    readinessTimeoutMs: number,
+  ): Promise<PreparedNativeDrag<T>> {
+    const prepared = this.prepared ?? await this.prepare(signal)
+    if (signal.aborted) throw new ComputerUseError('COMPUTER_CANCELLED', 'native drag preparation was cancelled')
+    const processAbort = new AbortController()
+    const handle = this.ctx.subprocess.spawn({
+      argv: [prepared.path, '--drag-action'],
+      cwd: dirname(prepared.path),
+      stdio: {
+        stdin: 'pipe',
+        stdout: 'pipe',
+        stderr: { maxBytes: 64 * 1024 },
+      },
+      graceMs: 1000,
+      signal: processAbort.signal,
+      env: {
+        LANG: process.env.LANG ?? 'en_US.UTF-8',
+        LC_ALL: process.env.LC_ALL ?? 'en_US.UTF-8',
+      },
+    })
+    if (handle.stdin === undefined || handle.stdout === undefined) {
+      handle.terminate()
+      await handle.waitForExit()
+      throw new ComputerUseError('COMPUTER_PROVIDER_FAILURE', 'native drag barrier protocol pipes are unavailable')
+    }
+    const stdin = handle.stdin
+    stdin.on('error', () => {
+      // Write callbacks and process completion own protocol error reporting.
+    })
+    const lines = createInterface({ input: handle.stdout, crlfDelay: Infinity })
+    const iterator = lines[Symbol.asyncIterator]()
+    const readLine = async (readSignal: AbortSignal): Promise<string> => await new Promise((resolveLine, rejectLine) => {
+      const onAbort = (): void => { rejectLine(readSignal.reason) }
+      if (readSignal.aborted) {
+        onAbort()
+        return
+      }
+      readSignal.addEventListener('abort', onAbort, { once: true })
+      void iterator.next().then(next => {
+        readSignal.removeEventListener('abort', onAbort)
+        if (next.done === true) rejectLine(new Error('native drag helper closed before replying'))
+        else if (Buffer.byteLength(next.value) > 4 * 1024 * 1024) rejectLine(new Error('native drag helper response exceeded its protocol limit'))
+        else resolveLine(next.value)
+      }, error => {
+        readSignal.removeEventListener('abort', onAbort)
+        rejectLine(error)
+      })
+    })
+    const writeLine = async (line: string): Promise<void> => await new Promise((resolveWrite, rejectWrite) => {
+      stdin.write(`${line}\n`, error => {
+        if (error === undefined || error === null) resolveWrite()
+        else rejectWrite(error)
+      })
+    })
+    let started = false
+    const onCallerAbort = (): void => {
+      if (!started) processAbort.abort()
+    }
+    signal.addEventListener('abort', onCallerAbort)
+    const readinessTimeout = AbortSignal.timeout(readinessTimeoutMs)
+    try {
+      await writeLine(JSON.stringify({ protocolVersion: 1, ...request }))
+      const readySignal = AbortSignal.any([signal, readinessTimeout, processAbort.signal])
+      const ready = JSON.parse(await readLine(readySignal)) as Record<string, unknown>
+      if (ready.ok !== true || ready.event !== 'drag-ready') {
+        throw new Error('native drag helper returned an invalid ready frame')
+      }
+    } catch (error) {
+      processAbort.abort()
+      await handle.done.catch(() => undefined)
+      signal.removeEventListener('abort', onCallerAbort)
+      lines.close()
+      if (signal.aborted) throw new ComputerUseError('COMPUTER_CANCELLED', 'native drag preparation was cancelled', { cause: error })
+      if (readinessTimeout.aborted) {
+        throw new ComputerUseError('COMPUTER_TIMEOUT', `native drag preparation exceeded ${readinessTimeoutMs} milliseconds`, { cause: error })
+      }
+      throw computerUseError(error, 'native drag preparation failed')
+    }
+
+    const result = (async (): Promise<T> => {
+      try {
+        const raw = await readLine(processAbort.signal)
+        const outcome = await handle.done
+        let envelope: HelperEnvelope<T>
+        try {
+          envelope = JSON.parse(raw) as HelperEnvelope<T>
+        } catch (error) {
+          throw new ComputerUseError('COMPUTER_PROVIDER_FAILURE', 'native drag helper returned invalid JSON', { cause: error })
+        }
+        if (envelope.ok !== true) throw new ComputerUseError(envelope.error.code, envelope.error.message.slice(0, 1000))
+        if (outcome.exitCode !== 0) {
+          throw new ComputerUseError('COMPUTER_PROVIDER_FAILURE', `native drag helper exited ${String(outcome.exitCode)}`)
+        }
+        if (signal.aborted) throw new ComputerUseError('COMPUTER_CANCELLED', 'native drag action was cancelled after safe mouse release')
+        return envelope.value
+      } catch (error) {
+        if (error instanceof ComputerUseError && error.code === 'COMPUTER_CANCELLED') throw error
+        if (signal.aborted) {
+          throw new ComputerUseError('COMPUTER_CANCELLED', 'native drag action was cancelled', { cause: error })
+        }
+        throw computerUseError(error, 'native drag action failed')
+      } finally {
+        signal.removeEventListener('abort', onCallerAbort)
+        lines.close()
+      }
+    })()
+    void result.catch(() => undefined)
+    return {
+      result,
+      start: async () => {
+        if (started) return
+        if (signal.aborted) {
+          processAbort.abort()
+          throw new ComputerUseError('COMPUTER_CANCELLED', 'native drag action was cancelled before mouse-down')
+        }
+        started = true
+        signal.removeEventListener('abort', onCallerAbort)
+        // Once native mouse-down is possible, caller cancellation no longer
+        // owns this process. The bounded native motion must reach mouse-up.
+        try {
+          await writeLine('START')
+        } catch (error) {
+          processAbort.abort()
+          throw computerUseError(error, 'native drag start barrier failed')
+        }
+      },
+      cancel: () => {
+        if (!started) processAbort.abort()
+      },
+    }
+  }
+
   /** Send one serialized command to the persistent, click-through Agent cursor overlay. */
-  cursorCommand(command: Record<string, unknown>, signal: AbortSignal): Promise<CursorVisibility> {
-    const run = this.cursorCommandTail.then(async () => await this.executeCursorCommand(command, signal))
+  cursorCommand(
+    command: Record<string, unknown>,
+    signal: AbortSignal,
+    onWritten?: () => void | Promise<void>,
+  ): Promise<CursorVisibility> {
+    const run = this.cursorCommandTail.then(async () => {
+      if (signal.aborted) throw new ComputerUseError('COMPUTER_CANCELLED', 'native cursor overlay command was cancelled')
+      if (this.disposed) throw new ComputerUseError('COMPUTER_PROVIDER_FAILURE', 'native cursor overlay client is disposed')
+      return await this.executeCursorCommand(command, signal, onWritten)
+    })
     this.cursorCommandTail = run.then(() => undefined, () => undefined)
-    return run
+    return new Promise<CursorVisibility>((resolveCommand, rejectCommand) => {
+      const onAbort = (): void => {
+        rejectCommand(new ComputerUseError('COMPUTER_CANCELLED', 'native cursor overlay command was cancelled'))
+      }
+      if (signal.aborted) onAbort()
+      else signal.addEventListener('abort', onAbort, { once: true })
+      void run.then(resolveCommand, rejectCommand).finally(() => {
+        signal.removeEventListener('abort', onAbort)
+      })
+    })
   }
 
-  private async executeCursorCommand(command: Record<string, unknown>, signal: AbortSignal): Promise<CursorVisibility> {
+  private async executeCursorCommand(
+    command: Record<string, unknown>,
+    signal: AbortSignal,
+    onWritten?: () => void | Promise<void>,
+  ): Promise<CursorVisibility> {
     const prepared = this.prepared ?? await this.prepare(signal)
+    if (this.disposed) throw new ComputerUseError('COMPUTER_PROVIDER_FAILURE', 'native cursor overlay client is disposed')
     const cursor = await this.getCursor(prepared, signal)
     signal.throwIfAborted()
+    if (this.disposed) {
+      this.discardCursor(cursor)
+      throw new ComputerUseError('COMPUTER_PROVIDER_FAILURE', 'native cursor overlay client is disposed')
+    }
     try {
       await new Promise<void>((resolveWrite, rejectWrite) => {
         cursor.stdin.write(`${JSON.stringify(command)}\n`, error => {
@@ -271,7 +457,8 @@ export class NativeHelperClient {
           else rejectWrite(error)
         })
       })
-      const frame = await cursor.nextResponse()
+      await onWritten?.()
+      const frame = await cursor.nextResponse(cursorResponseTimeout(command), signal)
       if (frame.kind === 'failure') {
         this.discardCursor(cursor)
         return { visible: false, reason: frame.reason }
@@ -281,6 +468,9 @@ export class NativeHelperClient {
       return normalized.result
     } catch (error) {
       this.discardCursor(cursor)
+      if (signal.aborted) {
+        throw new ComputerUseError('COMPUTER_CANCELLED', 'native cursor overlay command was cancelled', { cause: error })
+      }
       throw computerUseError(error, 'native cursor overlay command failed')
     }
   }
@@ -292,18 +482,24 @@ export class NativeHelperClient {
 
   /** Stop the cursor process before a provider generation is replaced or disposed. */
   async dispose(): Promise<void> {
+    this.disposed = true
     const cursor = this.cursor ?? await this.cursorStart?.promise.catch(() => undefined)
     this.cursorStart = undefined
     this.cursor = undefined
-    if (cursor === undefined) return
+    if (cursor === undefined) {
+      await this.cursorCommandTail.catch(() => undefined)
+      return
+    }
     try {
       cursor.stdin.end(`${JSON.stringify({ op: 'stop' })}\n`)
     } catch {
       // A child that already closed its pipe is handled by the tree-exit wait below.
     }
-    if (await cursor.waitForExit(AbortSignal.timeout(1_000))) return
-    cursor.terminate()
-    await cursor.waitForExit()
+    if (!await cursor.waitForExit(AbortSignal.timeout(1_000))) {
+      cursor.terminate()
+      await cursor.waitForExit()
+    }
+    await this.cursorCommandTail.catch(() => undefined)
   }
 
   /** Prepared integrity facts used by provider health. */
@@ -337,8 +533,10 @@ export class NativeHelperClient {
 
   private async getCursor(prepared: PreparedNativeHelper, signal: AbortSignal): Promise<CursorProcess> {
     signal.throwIfAborted()
+    if (this.disposed) throw new ComputerUseError('COMPUTER_PROVIDER_FAILURE', 'native cursor overlay client is disposed')
     if (this.cursor !== undefined) return this.cursor
     if (this.cursorStart === undefined) {
+      if (this.disposed) throw new ComputerUseError('COMPUTER_PROVIDER_FAILURE', 'native cursor overlay client is disposed')
       const start: { promise: Promise<CursorProcess> } = { promise: Promise.resolve(undefined as never) }
       start.promise = this.spawnCursor(prepared).then(cursor => {
         this.cursor = cursor
@@ -353,6 +551,10 @@ export class NativeHelperClient {
     }
     const cursor = await this.cursorStart.promise
     signal.throwIfAborted()
+    if (this.disposed) {
+      this.discardCursor(cursor)
+      throw new ComputerUseError('COMPUTER_PROVIDER_FAILURE', 'native cursor overlay client is disposed')
+    }
     return cursor
   }
 
@@ -444,20 +646,37 @@ export class NativeHelperClient {
     return {
       stdin: handle.stdin,
       done: handle.done,
-      nextResponse: async () => {
+      nextResponse: async (timeoutMs, signal) => {
         const ready = buffered.shift()
-        if (ready !== undefined) return ready
-        return await new Promise<CursorProtocolFrame>((resolveResponse) => {
+        if (ready !== undefined) {
+          signal.throwIfAborted()
+          return ready
+        }
+        return await new Promise<CursorProtocolFrame>((resolveResponse, rejectResponse) => {
+          let timer: ReturnType<typeof setTimeout> | undefined
           const settle = (frame: CursorProtocolFrame): void => {
             const index = pending.indexOf(settle)
             if (index >= 0) pending.splice(index, 1)
-            clearTimeout(timer)
+            if (timer !== undefined) clearTimeout(timer)
+            signal.removeEventListener('abort', onAbort)
             resolveResponse(frame)
           }
-          const timer = setTimeout(() => settle({
+          const onAbort = (): void => {
+            const index = pending.indexOf(settle)
+            if (index >= 0) pending.splice(index, 1)
+            if (timer !== undefined) clearTimeout(timer)
+            signal.removeEventListener('abort', onAbort)
+            rejectResponse(signal.reason)
+          }
+          timer = setTimeout(() => settle({
             kind: 'failure',
-            reason: `the native cursor overlay did not respond within ${CURSOR_RESPONSE_TIMEOUT_MS} milliseconds`,
-          }), CURSOR_RESPONSE_TIMEOUT_MS)
+            reason: `the native cursor overlay did not respond within ${timeoutMs} milliseconds`,
+          }), timeoutMs)
+          if (signal.aborted) {
+            onAbort()
+            return
+          }
+          signal.addEventListener('abort', onAbort, { once: true })
           pending.push(settle)
         })
       },

package/src/providers/unsupported.ts

@@ -3,6 +3,8 @@
 import type {
   BackendActionRequest,
   BackendActionResult,
+  BackendCursorActivation,
+  BackendTrackedDragResult,
   BackendCursorAction,
   BackendHealth,
   BackendObservation,
@@ -51,11 +53,19 @@ export class UnsupportedPlatformBackend implements ComputerUseBackend {
     return Promise.reject(unsupported(this.platform))
   }
 
+  activateForCursor(_app: ComputerAppIdentity, _expectedStateHash: string, _options: BackendObserveOptions): Promise<BackendCursorActivation> {
+    return Promise.reject(unsupported(this.platform))
+  }
+
   act(_request: BackendActionRequest): Promise<BackendActionResult> {
     return Promise.reject(unsupported(this.platform))
   }
 
-  visualizeCursor(_action: BackendCursorAction, _phase: 'before' | 'after'): Promise<CursorVisibility> {
+  actDragWithCursor(_request: BackendActionRequest, _cursor: BackendCursorAction & { kind: 'drag' }): Promise<BackendTrackedDragResult> {
+    return Promise.reject(unsupported(this.platform))
+  }
+
+  visualizeCursor(_action: BackendCursorAction, _phase: 'before' | 'during' | 'after'): Promise<CursorVisibility> {
     return Promise.reject(unsupported(this.platform))
   }