@causyne/agent 1.10.20 → 1.10.21

package/docs/THIRD_PARTY_NOTICES.md

@@ -61,6 +61,50 @@ adapted from the MIT-licensed Camofox Browser project at source commit
 > OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 > SOFTWARE.
 
+The computer-use action parser and coordinate grounding engine in `src/computerUse/visionGrounding.ts`
+and `src/tools/computerUse.ts` power **Causyne Vision Desktop** (`computer_use`). Algorithms for coordinate
+grounding and action grammar contain adaptations from upstream open-source work:
+
+> Copyright (c) 2025 Bytedance, Inc. and its affiliates.
+> Licensed under the Apache License, Version 2.0 (the "License");
+> you may not use this file except in compliance with the License.
+> You may obtain a copy of the License at
+>
+>     http://www.apache.org/licenses/LICENSE-2.0
+>
+> Unless required by applicable law or agreed to in writing, software
+> distributed under the License is distributed on an "AS IS" BASIS,
+> WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+> See the License for the specific language governing permissions and
+> limitations under the License.
+
+The generative UI component and preview engine in `src/uiEngine/uiForge.ts` and
+`src/tools/uiForge.ts` power **Causyne UI Forge** (`ui_forge`). Code generation algorithms
+contain adaptations from upstream open-source work:
+
+> MIT License
+>
+> Copyright (c) 2011-2024 Thesys Inc.
+>
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+>
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+
+
 Repository scanning found no third-party copyright header or license marker in
 the project-authored source and skill files. That negative scan alone cannot
 establish authorship or permission. On 2026-10-19, the licensor confirmed that

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@causyne/agent",
-  "version": "1.10.20",
+  "version": "1.10.21",
   "description": "Agentic AI for software, tools, and computer workflows",
   "main": "bin/causyne.js",
   "type": "module",

package/src/computerUse/visionGrounding.js

@@ -0,0 +1,249 @@
+/*
+ * Copyright (c) 2025 Bytedance, Inc. and its affiliates.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Adapted for Causyne Vision Desktop & Coordinate Grounding Engine.
+ */
+const DEFAULT_FACTOR = [1000, 1000];
+/**
+ * Extract numbers from a coordinate string like "(250, 400)" or "[100, 200, 300, 400]"
+ */
+export function extractCoordinateNumbers(raw) {
+    const clean = String(raw || '').replace(/[()[\]]/g, ' ').trim();
+    if (!clean)
+        return [];
+    return clean
+        .split(/[\s,]+/)
+        .map((s) => Number.parseFloat(s))
+        .filter((n) => Number.isFinite(n));
+}
+/**
+ * Ground normalized coordinates (0-1000) to actual screen pixels.
+ */
+export function groundPoint(nums, screen = { width: 1920, height: 1080, scaleFactor: 1 }, factor = DEFAULT_FACTOR) {
+    if (nums.length < 2)
+        return null;
+    const rawX = nums[0] ?? 0;
+    const rawY = nums[1] ?? 0;
+    const scale = screen.scaleFactor || 1;
+    const normX = Math.max(0, Math.min(1, rawX / factor[0]));
+    const normY = Math.max(0, Math.min(1, rawY / factor[1]));
+    return {
+        x: Math.round(normX * screen.width * scale),
+        y: Math.round(normY * screen.height * scale)
+    };
+}
+/**
+ * Ground a bounding box (x1, y1, x2, y2) into its midpoint (center click).
+ */
+export function groundBoxCenter(nums, screen = { width: 1920, height: 1080, scaleFactor: 1 }, factor = DEFAULT_FACTOR) {
+    if (nums.length < 2)
+        return null;
+    if (nums.length === 2) {
+        return groundPoint(nums, screen, factor);
+    }
+    const x1 = nums[0] ?? 0;
+    const y1 = nums[1] ?? 0;
+    const x2 = nums[2] ?? x1;
+    const y2 = nums[3] ?? y1;
+    const midX = (x1 + x2) / 2;
+    const midY = (y1 + y2) / 2;
+    return groundPoint([midX, midY], screen, factor);
+}
+/**
+ * Parse vision grounding action format:
+ * E.g. Action: click(start_box='(240, 500)')
+ */
+export function parseSingleAction(rawAction, screenContext = { width: 1920, height: 1080, scaleFactor: 1 }) {
+    const line = rawAction.trim();
+    if (!line)
+        return null;
+    const callMatch = line.match(/^([a-zA-Z_0-9]+)\s*\((.*)\)$/);
+    if (!callMatch) {
+        if (/finished/i.test(line)) {
+            return { action: 'finished', rawStr: line };
+        }
+        return null;
+    }
+    const funcName = callMatch[1]?.toLowerCase();
+    const argsRaw = callMatch[2] || '';
+    const argsMap = {};
+    const kvRegex = /([a-zA-Z_0-9]+)\s*=\s*['"]([^'"]+)['"]/g;
+    let match;
+    while ((match = kvRegex.exec(argsRaw)) !== null) {
+        const key = match[1];
+        const val = match[2];
+        if (key && val) {
+            argsMap[key] = val;
+        }
+    }
+    if (Object.keys(argsMap).length === 0) {
+        const boxMatch = argsRaw.match(/['"]?(\([0-9\s,.]+\)|\[[0-9\s,.]+\])['"]?/);
+        if (boxMatch && boxMatch[1]) {
+            argsMap['start_box'] = boxMatch[1];
+        }
+    }
+    const actionObj = {
+        action: funcName,
+        rawStr: line
+    };
+    const startBox = argsMap['start_box'] || argsMap['point'] || argsMap['box'];
+    if (startBox) {
+        const nums = extractCoordinateNumbers(startBox);
+        const center = groundBoxCenter(nums, screenContext);
+        if (center) {
+            actionObj.coordinates = center;
+            actionObj.startCoordinates = center;
+        }
+    }
+    const endBox = argsMap['end_box'];
+    if (endBox) {
+        const nums = extractCoordinateNumbers(endBox);
+        const center = groundBoxCenter(nums, screenContext);
+        if (center) {
+            actionObj.endCoordinates = center;
+        }
+    }
+    if (argsMap['content']) {
+        actionObj.text = argsMap['content'];
+    }
+    if (argsMap['text']) {
+        actionObj.text = argsMap['text'];
+    }
+    if (argsMap['key']) {
+        actionObj.key = argsMap['key'];
+    }
+    if (argsMap['direction']) {
+        const dir = argsMap['direction'].toLowerCase();
+        if (dir === 'up' || dir === 'down' || dir === 'left' || dir === 'right') {
+            actionObj.direction = dir;
+        }
+    }
+    if (argsMap['time'] || argsMap['seconds']) {
+        const sec = Number.parseFloat(argsMap['time'] || argsMap['seconds'] || '1');
+        actionObj.seconds = Number.isFinite(sec) ? sec : 1;
+    }
+    return actionObj;
+}
+/**
+ * Parse complete vision grounding prediction text with Thought and Action blocks.
+ */
+export function parseVisionGroundingPrediction(predictionText, screenContext = { width: 1920, height: 1080, scaleFactor: 1 }) {
+    let thought;
+    let reflection;
+    const text = (predictionText || '').trim();
+    if (text.includes('Thought:')) {
+        const tMatch = text.match(/Thought:\s*([\s\S]+?)(?=\s*Action[:：]|$)/i);
+        if (tMatch && tMatch[1]) {
+            thought = tMatch[1].trim();
+        }
+    }
+    if (text.includes('Reflection:')) {
+        const rMatch = text.match(/Reflection:\s*([\s\S]+?)(?=\s*(?:Action_Summary|Action)[:：]|$)/i);
+        if (rMatch && rMatch[1]) {
+            reflection = rMatch[1].trim();
+        }
+    }
+    const actionLines = [];
+    if (/Action[:：]/i.test(text)) {
+        const parts = text.split(/Action[:：]/i);
+        for (let i = 1; i < parts.length; i++) {
+            const seg = parts[i] || '';
+            const lines = seg.split(/\n+/).map((l) => l.trim()).filter(Boolean);
+            actionLines.push(...lines);
+        }
+    }
+    else {
+        actionLines.push(...text.split(/\n+/).map((l) => l.trim()).filter(Boolean));
+    }
+    const actions = [];
+    for (const line of actionLines) {
+        const parsed = parseSingleAction(line, screenContext);
+        if (parsed) {
+            if (thought && !parsed.thought)
+                parsed.thought = thought;
+            if (reflection && !parsed.reflection)
+                parsed.reflection = reflection;
+            actions.push(parsed);
+        }
+    }
+    return { thought, reflection, actions };
+}
+const MAC_KEY_CODES = {
+    return: 36,
+    enter: 36,
+    tab: 48,
+    space: 49,
+    backspace: 51,
+    escape: 53,
+    esc: 53,
+    up: 126,
+    down: 125,
+    left: 123,
+    right: 124
+};
+/**
+ * Convert parsed vision grounding actions into Causyne desktop_act equivalent instructions.
+ */
+export function visionGroundingToDesktopAct(actions) {
+    const result = [];
+    for (const act of actions) {
+        switch (act.action) {
+            case 'click':
+            case 'left_click':
+            case 'double_click':
+            case 'triple_click': {
+                const point = act.coordinates;
+                if (point) {
+                    result.push({
+                        verb: 'clickxy',
+                        x: point.x,
+                        y: point.y
+                    });
+                    if (act.action === 'double_click') {
+                        result.push({ verb: 'clickxy', x: point.x, y: point.y });
+                    }
+                }
+                break;
+            }
+            case 'type': {
+                if (act.coordinates) {
+                    result.push({ verb: 'clickxy', x: act.coordinates.x, y: act.coordinates.y });
+                }
+                if (act.text) {
+                    result.push({ verb: 'type', text: act.text });
+                }
+                break;
+            }
+            case 'press_key':
+            case 'hotkey': {
+                const keyName = (act.key || '').toLowerCase().trim();
+                const code = MAC_KEY_CODES[keyName];
+                if (code !== undefined) {
+                    result.push({ verb: 'key', keyCode: code });
+                }
+                else if (keyName) {
+                    result.push({ verb: 'type', text: keyName });
+                }
+                break;
+            }
+            case 'wait': {
+                result.push({ verb: 'wait', seconds: act.seconds || 1 });
+                break;
+            }
+            case 'drag': {
+                if (act.startCoordinates) {
+                    result.push({ verb: 'clickxy', x: act.startCoordinates.x, y: act.startCoordinates.y });
+                }
+                if (act.endCoordinates) {
+                    result.push({ verb: 'clickxy', x: act.endCoordinates.x, y: act.endCoordinates.y });
+                }
+                break;
+            }
+            case 'finished':
+            default:
+                break;
+        }
+    }
+    return result;
+}

package/src/computerUse/visionGrounding.ts

@@ -0,0 +1,331 @@
+/*
+ * Copyright (c) 2025 Bytedance, Inc. and its affiliates.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Adapted for Causyne Vision Desktop & Coordinate Grounding Engine.
+ */
+
+export interface ScreenContext {
+  width: number;
+  height: number;
+  scaleFactor?: number;
+}
+
+export type ActionVerb =
+  | 'click'
+  | 'left_click'
+  | 'right_click'
+  | 'double_click'
+  | 'triple_click'
+  | 'middle_click'
+  | 'mouse_down'
+  | 'mouse_up'
+  | 'drag'
+  | 'move'
+  | 'type'
+  | 'press_key'
+  | 'hotkey'
+  | 'scroll'
+  | 'wait'
+  | 'finished';
+
+export interface VisionAction {
+  action: ActionVerb;
+  thought?: string;
+  reflection?: string;
+  coordinates?: { x: number; y: number };
+  startCoordinates?: { x: number; y: number };
+  endCoordinates?: { x: number; y: number };
+  text?: string;
+  key?: string;
+  direction?: 'up' | 'down' | 'left' | 'right';
+  seconds?: number;
+  rawStr?: string;
+}
+
+export interface DesktopActEquivalent {
+  verb: 'press' | 'clickxy' | 'type' | 'key' | 'wait';
+  x?: number;
+  y?: number;
+  text?: string;
+  keyCode?: number;
+  target?: string;
+  seconds?: number;
+}
+
+const DEFAULT_FACTOR: [number, number] = [1000, 1000];
+
+/**
+ * Extract numbers from a coordinate string like "(250, 400)" or "[100, 200, 300, 400]"
+ */
+export function extractCoordinateNumbers(raw: string): number[] {
+  const clean = String(raw || '').replace(/[()[\]]/g, ' ').trim();
+  if (!clean) return [];
+  return clean
+    .split(/[\s,]+/)
+    .map((s) => Number.parseFloat(s))
+    .filter((n) => Number.isFinite(n));
+}
+
+/**
+ * Ground normalized coordinates (0-1000) to actual screen pixels.
+ */
+export function groundPoint(
+  nums: number[],
+  screen: ScreenContext = { width: 1920, height: 1080, scaleFactor: 1 },
+  factor: [number, number] = DEFAULT_FACTOR
+): { x: number; y: number } | null {
+  if (nums.length < 2) return null;
+  const rawX = nums[0] ?? 0;
+  const rawY = nums[1] ?? 0;
+  const scale = screen.scaleFactor || 1;
+
+  const normX = Math.max(0, Math.min(1, rawX / factor[0]));
+  const normY = Math.max(0, Math.min(1, rawY / factor[1]));
+
+  return {
+    x: Math.round(normX * screen.width * scale),
+    y: Math.round(normY * screen.height * scale)
+  };
+}
+
+/**
+ * Ground a bounding box (x1, y1, x2, y2) into its midpoint (center click).
+ */
+export function groundBoxCenter(
+  nums: number[],
+  screen: ScreenContext = { width: 1920, height: 1080, scaleFactor: 1 },
+  factor: [number, number] = DEFAULT_FACTOR
+): { x: number; y: number } | null {
+  if (nums.length < 2) return null;
+  if (nums.length === 2) {
+    return groundPoint(nums, screen, factor);
+  }
+  const x1 = nums[0] ?? 0;
+  const y1 = nums[1] ?? 0;
+  const x2 = nums[2] ?? x1;
+  const y2 = nums[3] ?? y1;
+
+  const midX = (x1 + x2) / 2;
+  const midY = (y1 + y2) / 2;
+  return groundPoint([midX, midY], screen, factor);
+}
+
+/**
+ * Parse vision grounding action format:
+ * E.g. Action: click(start_box='(240, 500)')
+ */
+export function parseSingleAction(
+  rawAction: string,
+  screenContext: ScreenContext = { width: 1920, height: 1080, scaleFactor: 1 }
+): VisionAction | null {
+  const line = rawAction.trim();
+  if (!line) return null;
+
+  const callMatch = line.match(/^([a-zA-Z_0-9]+)\s*\((.*)\)$/);
+  if (!callMatch) {
+    if (/finished/i.test(line)) {
+      return { action: 'finished', rawStr: line };
+    }
+    return null;
+  }
+
+  const funcName = callMatch[1]?.toLowerCase() as ActionVerb;
+  const argsRaw = callMatch[2] || '';
+
+  const argsMap: Record<string, string> = {};
+  const kvRegex = /([a-zA-Z_0-9]+)\s*=\s*['"]([^'"]+)['"]/g;
+  let match: RegExpExecArray | null;
+  while ((match = kvRegex.exec(argsRaw)) !== null) {
+    const key = match[1];
+    const val = match[2];
+    if (key && val) {
+      argsMap[key] = val;
+    }
+  }
+
+  if (Object.keys(argsMap).length === 0) {
+    const boxMatch = argsRaw.match(/['"]?(\([0-9\s,.]+\)|\[[0-9\s,.]+\])['"]?/);
+    if (boxMatch && boxMatch[1]) {
+      argsMap['start_box'] = boxMatch[1];
+    }
+  }
+
+  const actionObj: VisionAction = {
+    action: funcName,
+    rawStr: line
+  };
+
+  const startBox = argsMap['start_box'] || argsMap['point'] || argsMap['box'];
+  if (startBox) {
+    const nums = extractCoordinateNumbers(startBox);
+    const center = groundBoxCenter(nums, screenContext);
+    if (center) {
+      actionObj.coordinates = center;
+      actionObj.startCoordinates = center;
+    }
+  }
+
+  const endBox = argsMap['end_box'];
+  if (endBox) {
+    const nums = extractCoordinateNumbers(endBox);
+    const center = groundBoxCenter(nums, screenContext);
+    if (center) {
+      actionObj.endCoordinates = center;
+    }
+  }
+
+  if (argsMap['content']) {
+    actionObj.text = argsMap['content'];
+  }
+  if (argsMap['text']) {
+    actionObj.text = argsMap['text'];
+  }
+  if (argsMap['key']) {
+    actionObj.key = argsMap['key'];
+  }
+  if (argsMap['direction']) {
+    const dir = argsMap['direction'].toLowerCase();
+    if (dir === 'up' || dir === 'down' || dir === 'left' || dir === 'right') {
+      actionObj.direction = dir;
+    }
+  }
+  if (argsMap['time'] || argsMap['seconds']) {
+    const sec = Number.parseFloat(argsMap['time'] || argsMap['seconds'] || '1');
+    actionObj.seconds = Number.isFinite(sec) ? sec : 1;
+  }
+
+  return actionObj;
+}
+
+/**
+ * Parse complete vision grounding prediction text with Thought and Action blocks.
+ */
+export function parseVisionGroundingPrediction(
+  predictionText: string,
+  screenContext: ScreenContext = { width: 1920, height: 1080, scaleFactor: 1 }
+): { thought?: string | undefined; reflection?: string | undefined; actions: VisionAction[] } {
+  let thought: string | undefined;
+  let reflection: string | undefined;
+
+  const text = (predictionText || '').trim();
+
+  if (text.includes('Thought:')) {
+    const tMatch = text.match(/Thought:\s*([\s\S]+?)(?=\s*Action[:：]|$)/i);
+    if (tMatch && tMatch[1]) {
+      thought = tMatch[1].trim();
+    }
+  }
+  if (text.includes('Reflection:')) {
+    const rMatch = text.match(/Reflection:\s*([\s\S]+?)(?=\s*(?:Action_Summary|Action)[:：]|$)/i);
+    if (rMatch && rMatch[1]) {
+      reflection = rMatch[1].trim();
+    }
+  }
+
+  const actionLines: string[] = [];
+  if (/Action[:：]/i.test(text)) {
+    const parts = text.split(/Action[:：]/i);
+    for (let i = 1; i < parts.length; i++) {
+      const seg = parts[i] || '';
+      const lines = seg.split(/\n+/).map((l) => l.trim()).filter(Boolean);
+      actionLines.push(...lines);
+    }
+  } else {
+    actionLines.push(...text.split(/\n+/).map((l) => l.trim()).filter(Boolean));
+  }
+
+  const actions: VisionAction[] = [];
+
+  for (const line of actionLines) {
+    const parsed = parseSingleAction(line, screenContext);
+    if (parsed) {
+      if (thought && !parsed.thought) parsed.thought = thought;
+      if (reflection && !parsed.reflection) parsed.reflection = reflection;
+      actions.push(parsed);
+    }
+  }
+
+  return { thought, reflection, actions };
+}
+
+const MAC_KEY_CODES: Record<string, number> = {
+  return: 36,
+  enter: 36,
+  tab: 48,
+  space: 49,
+  backspace: 51,
+  escape: 53,
+  esc: 53,
+  up: 126,
+  down: 125,
+  left: 123,
+  right: 124
+};
+
+/**
+ * Convert parsed vision grounding actions into Causyne desktop_act equivalent instructions.
+ */
+export function visionGroundingToDesktopAct(actions: VisionAction[]): DesktopActEquivalent[] {
+  const result: DesktopActEquivalent[] = [];
+
+  for (const act of actions) {
+    switch (act.action) {
+      case 'click':
+      case 'left_click':
+      case 'double_click':
+      case 'triple_click': {
+        const point = act.coordinates;
+        if (point) {
+          result.push({
+            verb: 'clickxy',
+            x: point.x,
+            y: point.y
+          });
+          if (act.action === 'double_click') {
+            result.push({ verb: 'clickxy', x: point.x, y: point.y });
+          }
+        }
+        break;
+      }
+      case 'type': {
+        if (act.coordinates) {
+          result.push({ verb: 'clickxy', x: act.coordinates.x, y: act.coordinates.y });
+        }
+        if (act.text) {
+          result.push({ verb: 'type', text: act.text });
+        }
+        break;
+      }
+      case 'press_key':
+      case 'hotkey': {
+        const keyName = (act.key || '').toLowerCase().trim();
+        const code = MAC_KEY_CODES[keyName];
+        if (code !== undefined) {
+          result.push({ verb: 'key', keyCode: code });
+        } else if (keyName) {
+          result.push({ verb: 'type', text: keyName });
+        }
+        break;
+      }
+      case 'wait': {
+        result.push({ verb: 'wait', seconds: act.seconds || 1 });
+        break;
+      }
+      case 'drag': {
+        if (act.startCoordinates) {
+          result.push({ verb: 'clickxy', x: act.startCoordinates.x, y: act.startCoordinates.y });
+        }
+        if (act.endCoordinates) {
+          result.push({ verb: 'clickxy', x: act.endCoordinates.x, y: act.endCoordinates.y });
+        }
+        break;
+      }
+      case 'finished':
+      default:
+        break;
+    }
+  }
+
+  return result;
+}

package/src/sandbox.js

@@ -357,9 +357,12 @@ export class Sandbox {
     
     // Mode C. Section 4 says gated, not walled — the capability is real, the
     // human just says yes first.
-    if (toolName === 'desktop_act') {
+    if (toolName === 'desktop_act' || toolName === 'computer_use') {
       return { allowed: true, risk: 'extreme' };
     }
+    if (toolName === 'ui_forge') {
+      return { allowed: true, risk: 'safe' };
+    }
     if (toolName === 'fs_write' || toolName === 'fs_move' || toolName === 'fs_edit' || toolName === 'MultiEdit') {
       return { allowed: true, risk: 'moderate' };
     }

package/src/toolPacks.js

@@ -76,7 +76,8 @@ export const PACKS = {
     'screenshot',
     'vision_inspect_ui',
     'view_image',
-    'astryx_oracle'
+    'astryx_oracle',
+    'ui_forge'
   ],
   media: [
     'generate_media_via_api',
@@ -96,6 +97,7 @@ export const PACKS = {
     // Channel C. Ships beside its observer on purpose: acting on a screen you
     // have not read is how an agent clicks the wrong button confidently.
     'desktop_act',
+    'computer_use',
     'process_list',
     'proc_term',
     'archive',
@@ -362,11 +364,11 @@ When the user asks you to build, create, test, expand, or develop ANY game, you
 
 const GAME_INTENT = /\b(game|games|gamedev|permainan|godot|unity|unreal|rpg|platformer|roguelike|arcade|sprite|spritesheet|tilemap|voxel|minecraft|aetheria|voxellia|nes|snes|gameplay|player character|level design|boss fight)\b|\.(tscn|gd)\b/i;
 
-const WEB_INTENT = /\b(web|webpage|website|situs|frontend|front-end|landing page|homepage|dashboard|portfolio|html|css|scss|tailwind|bootstrap|react|vue|svelte|angular|next\.?js|nuxt|astro|ui|ux|user interface|web app|webapp|spa|dom|responsive)\b/i;
+const WEB_INTENT = /\b(web|webpage|website|situs|frontend|front-end|landing page|homepage|dashboard|portfolio|html|css|scss|tailwind|bootstrap|react|vue|svelte|angular|next\.?js|nuxt|astro|ui|ux|user interface|web app|webapp|spa|dom|responsive|ui forge|component forge|component generation|ui component)\b/i;
 
 const MEDIA_INTENT = /\b(image|images|picture|photo|gambar|render|3d model|blender|animation|animate|video|movie|film|klip|audio|sound|sfx|music|musik|song|lagu|voice|suara|tts|text.to.speech|narration|podcast|thumbnail|poster|illustration|logo)\b/i;
 
-const SYSTEM_INTENT = /\b(process|processes|pid|kill|port|zip|unzip|tar|archive|compress|extract|clipboard|copy to clipboard|print|printer|cetak|open in browser|launch app)\b/i;
+const SYSTEM_INTENT = /\b(process|processes|pid|kill|port|zip|unzip|tar|archive|compress|extract|clipboard|copy to clipboard|print|printer|cetak|open in browser|launch app|computer use|vision grounding|desktop vision|gui agent|coordinate click|desktop control)\b/i;
 
 const ADVANCED_INTENT = /\b(pdf|forge a tool|custom tool|new tool|plugin|plugins|custom plugin|subagent|sub-agent|parallel agent|swarm|ast|symbols|refactor across)\b/i;