Handle short drag paths safely in CUA templates.

Normalize drag paths before calling Kernel drag APIs so zero/one-point model outputs do not 400 entire batches, padding single-point paths and no-oping empty drags in both TypeScript and Python.

Made-with: Cursor

Author: rgarcia

pkg/templates/python/openai-computer-use/computers/kernel_computer.py

@@ -121,6 +121,33 @@ def _normalize_button(button) -> str:
     return str(button)
 
 
+def _normalize_drag_path(path: Any) -> List[List[int]]:
+    points: List[List[int]] = []
+    if isinstance(path, list):
+        for point in path:
+            if not isinstance(point, dict):
+                continue
+            x = point.get("x")
+            y = point.get("y")
+            if (
+                isinstance(x, (int, float))
+                and not isinstance(x, bool)
+                and isinstance(y, (int, float))
+                and not isinstance(y, bool)
+            ):
+                points.append([int(x), int(y)])
+    if not points:
+        return []
+    if len(points) == 1:
+        x, y = points[0]
+        return [[x, y], [x + 1, y]]
+    return points
+
+
+def _drag_noop_action() -> Dict[str, Any]:
+    return {"type": "sleep", "sleep": {"duration_ms": 1}}
+
+
 def _translate_cua_action(action: Dict[str, Any]) -> Dict[str, Any]:
     action_type = action.get("type", "")
     if action_type == "click":
@@ -185,7 +212,9 @@ def _translate_cua_action(action: Dict[str, Any]) -> Dict[str, Any]:
     elif action_type == "move":
         return {"type": "move_mouse", "move_mouse": {"x": action.get("x", 0), "y": action.get("y", 0)}}
     elif action_type == "drag":
-        path = [[p["x"], p["y"]] for p in action.get("path", [])]
+        path = _normalize_drag_path(action.get("path", []))
+        if len(path) < 2:
+            return _drag_noop_action()
         return {"type": "drag_mouse", "drag_mouse": {"path": path}}
     elif action_type == "wait":
         return {"type": "sleep", "sleep": {"duration_ms": action.get("ms", 1000)}}
@@ -546,8 +575,11 @@ def drag(self, path: List[Dict[str, int]]) -> None:
         op = _describe_action("drag", {"path": path})
 
         def _do() -> None:
-            p = [[pt["x"], pt["y"]] for pt in path]
-            self.client.browsers.computer.drag_mouse(self.session_id, path=p)
+            normalized_path = _normalize_drag_path(path)
+            if len(normalized_path) < 2:
+                time.sleep(0.001)
+                return
+            self.client.browsers.computer.drag_mouse(self.session_id, path=normalized_path)
 
         self._trace_backend(op, _do)
 

pkg/templates/typescript/openai-computer-use/lib/kernel-computer.ts

@@ -165,6 +165,28 @@ function normalizeButton(button?: string | number): string {
   return button;
 }
 
+function normalizeDragPath(path: Array<{ x: number; y: number }> | undefined): number[][] {
+  const points: Array<[number, number]> = (path ?? [])
+    .filter(
+      (point): point is { x: number; y: number } =>
+        typeof point?.x === 'number' &&
+        Number.isFinite(point.x) &&
+        typeof point?.y === 'number' &&
+        Number.isFinite(point.y),
+    )
+    .map((point): [number, number] => [Math.trunc(point.x), Math.trunc(point.y)]);
+  if (points.length === 0) return [];
+  if (points.length === 1) {
+    const [x, y] = points[0]!;
+    return [[x, y], [x + 1, y]];
+  }
+  return points;
+}
+
+function dragNoopAction(): BatchAction {
+  return { type: 'sleep', sleep: { duration_ms: 1 } };
+}
+
 function translateCuaAction(action: CuaAction): BatchAction {
   switch (action.type) {
     case 'click': {
@@ -220,7 +242,8 @@ function translateCuaAction(action: CuaAction): BatchAction {
     case 'move':
       return { type: 'move_mouse', move_mouse: { x: action.x ?? 0, y: action.y ?? 0 } };
     case 'drag': {
-      const path = (action.path ?? []).map((p) => [p.x, p.y]);
+      const path = normalizeDragPath(action.path);
+      if (path.length < 2) return dragNoopAction();
       return { type: 'drag_mouse', drag_mouse: { path } };
     }
     case 'wait':
@@ -483,8 +506,12 @@ export class KernelComputer {
   async drag(path: Array<{ x: number; y: number }>): Promise<void> {
     const op = describeAction('drag', { path });
     await this.traceCall(op, async () => {
-      const p = path.map((pt) => [pt.x, pt.y]);
-      await this.client.browsers.computer.dragMouse(this.sessionId, { path: p });
+      const normalizedPath = normalizeDragPath(path);
+      if (normalizedPath.length < 2) {
+        await new Promise((resolve) => setTimeout(resolve, 1));
+        return;
+      }
+      await this.client.browsers.computer.dragMouse(this.sessionId, { path: normalizedPath });
     });
   }