@causyne/agent 1.10.19 → 1.10.21

package/src/dynamicCatalogue.ts

@@ -0,0 +1,283 @@
+// Sovereign Dynamic Model Architecture & Live Discovery
+//
+// WHY THIS EXISTS:
+// AI providers release and update models continuously. Hardcoded static
+// catalogues freeze models at build time. This module gives Causyne a dual-layer
+// model architecture:
+//   1. Curated baseline: Instant offline availability with zero latency and verified pricing/capability tiers.
+//   2. Dynamic discovery: Live discovery via provider APIs (Ollama, OpenAI, Gemini, Anthropic, DeepSeek, etc.)
+//      with resilient local caching in ~/.causyne/models_cache.json.
+//
+// ZERO-MALWARE: Pure TypeScript/ESM. Strictly respects timeouts, no secret leakage, no unprompted background calls.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { causyneHome } from './utils/paths.js';
+import { MODEL_CATALOGUE, DEFAULT_MODEL_BY_PROVIDER } from './modelCatalogue.js';
+
+export interface DynamicCatalogueCache {
+  version: 1;
+  updatedAt: string;
+  providers: Record<string, {
+    timestamp: number;
+    models: string[];
+  }>;
+}
+
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const REQUEST_TIMEOUT_MS = 3500; // Fast timeout to never block user interaction
+
+export function cacheFilePath(): string {
+  return path.join(causyneHome(), 'models_cache.json');
+}
+
+export function normalizeProviderKey(provider: string): string {
+  const p = (provider || '').toLowerCase().trim();
+  if (p === 'dashscope' || p === 'dashscope-byok' || p === 'alibaba') return 'dashscope-byok';
+  if (p === 'ollama') return 'ollama';
+  if (p === 'openai') return 'openai';
+  if (p === 'anthropic' || p === 'claude') return 'anthropic';
+  if (p === 'gemini' || p === 'google') return 'gemini';
+  if (p === 'deepseek') return 'deepseek';
+  if (p === 'xai' || p === 'grok') return 'xai';
+  if (p === 'moonshot' || p === 'kimi') return 'moonshot';
+  if (p === 'muse' || p === 'meta') return 'muse';
+  if (p === 'openai-compatible' || p === 'custom') return 'openai-compatible';
+  return p;
+}
+
+/** Get the static curated models for a provider id. */
+export function getCuratedModels(provider: string): string[] {
+  const norm = normalizeProviderKey(provider);
+  const mapping: Record<string, keyof typeof MODEL_CATALOGUE> = {
+    'deepseek': 'DeepSeek',
+    'qwen': 'Qwen',
+    'dashscope-byok': 'Alibaba (DashScope)',
+    'dashscope': 'Alibaba (DashScope)',
+    'anthropic': 'Anthropic',
+    'openai': 'OpenAI',
+    'gemini': 'Gemini',
+    'muse': 'Meta (Muse)',
+    'ollama': 'Ollama (Local)',
+    'moonshot': 'Moonshot (Kimi)',
+    'xai': 'xAI (Grok)'
+  };
+  const key = mapping[norm];
+  if (key && MODEL_CATALOGUE[key]) {
+    return [...MODEL_CATALOGUE[key]];
+  }
+  return [];
+}
+
+/** Read cache safely from ~/.causyne/models_cache.json */
+export function readModelCache(): DynamicCatalogueCache | null {
+  try {
+    const file = cacheFilePath();
+    if (!fs.existsSync(file)) return null;
+    const content = fs.readFileSync(file, 'utf8');
+    const parsed = JSON.parse(content) as DynamicCatalogueCache;
+    if (parsed && parsed.version === 1 && typeof parsed.providers === 'object') {
+      return parsed;
+    }
+  } catch {
+    // Graceful fallback on corrupt or inaccessible cache
+  }
+  return null;
+}
+
+/** Save cache safely to ~/.causyne/models_cache.json */
+export function writeModelCache(cache: DynamicCatalogueCache): void {
+  try {
+    const dir = causyneHome();
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    const file = cacheFilePath();
+    fs.writeFileSync(file, JSON.stringify(cache, null, 2), { mode: 0o600 });
+  } catch {
+    // Cache failures must never crash the CLI
+  }
+}
+
+/** Get cached models for a provider if not expired */
+export function getCachedModels(provider: string): string[] | null {
+  const cache = readModelCache();
+  if (!cache) return null;
+  const norm = normalizeProviderKey(provider);
+  const entry = cache.providers[norm];
+  if (!entry) return null;
+  if (Date.now() - entry.timestamp > CACHE_TTL_MS) return null;
+  return entry.models;
+}
+
+/** Save models for a provider into the local cache */
+export function saveCachedModels(provider: string, models: string[]): void {
+  const norm = normalizeProviderKey(provider);
+  const cache: DynamicCatalogueCache = readModelCache() || {
+    version: 1,
+    updatedAt: new Date().toISOString(),
+    providers: {}
+  };
+  cache.providers[norm] = {
+    timestamp: Date.now(),
+    models: [...new Set(models)]
+  };
+  cache.updatedAt = new Date().toISOString();
+  writeModelCache(cache);
+}
+
+/** Live query provider API to discover available models */
+export async function fetchLiveModels(
+  provider: string,
+  config: { apiKey?: string; baseUrl?: string } = {}
+): Promise<string[]> {
+  const norm = normalizeProviderKey(provider);
+  const { apiKey, baseUrl } = config;
+
+  try {
+    if (norm === 'ollama') {
+      const host = (baseUrl || 'http://127.0.0.1:11434').replace(/\/+$/, '');
+      const res = await fetch(`${host}/api/tags`, {
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+      });
+      if (!res.ok) return [];
+      const data = await res.json() as { models?: Array<{ name?: string }> };
+      if (Array.isArray(data.models)) {
+        return data.models
+          .map((m) => (m.name || '').replace(/:latest$/, ''))
+          .filter(Boolean);
+      }
+    }
+
+    if (norm === 'openai') {
+      if (!apiKey) return [];
+      const host = (baseUrl || 'https://api.openai.com/v1').replace(/\/+$/, '');
+      const res = await fetch(`${host}/models`, {
+        headers: { Authorization: `Bearer ${apiKey}` },
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+      });
+      if (!res.ok) return [];
+      const data = await res.json() as { data?: Array<{ id?: string }> };
+      if (Array.isArray(data.data)) {
+        return data.data
+          .map((m) => m.id || '')
+          .filter((id) => /^(gpt|o1|o3|chatgpt)/i.test(id))
+          .sort();
+      }
+    }
+
+    if (norm === 'gemini') {
+      if (!apiKey) return [];
+      const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models?key=${encodeURIComponent(apiKey)}`, {
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+      });
+      if (!res.ok) return [];
+      const data = await res.json() as { models?: Array<{ name?: string; supportedGenerationMethods?: string[] }> };
+      if (Array.isArray(data.models)) {
+        return data.models
+          .filter((m) => m.supportedGenerationMethods?.includes('generateContent'))
+          .map((m) => (m.name || '').replace(/^models\//, ''))
+          .filter(Boolean)
+          .sort();
+      }
+    }
+
+    if (norm === 'anthropic') {
+      if (!apiKey) return [];
+      const res = await fetch('https://api.anthropic.com/v1/models', {
+        headers: {
+          'x-api-key': apiKey,
+          'anthropic-version': '2023-06-01'
+        },
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+      });
+      if (!res.ok) return [];
+      const data = await res.json() as { data?: Array<{ id?: string }> };
+      if (Array.isArray(data.data)) {
+        return data.data
+          .map((m) => m.id || '')
+          .filter(Boolean)
+          .sort();
+      }
+    }
+
+    if (norm === 'deepseek') {
+      if (!apiKey) return [];
+      const res = await fetch('https://api.deepseek.com/models', {
+        headers: { Authorization: `Bearer ${apiKey}` },
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+      });
+      if (!res.ok) return [];
+      const data = await res.json() as { data?: Array<{ id?: string }> };
+      if (Array.isArray(data.data)) {
+        return data.data.map((m) => m.id || '').filter(Boolean).sort();
+      }
+    }
+
+    if (norm === 'openai-compatible') {
+      if (!baseUrl) return [];
+      const host = baseUrl.replace(/\/+$/, '');
+      const headers: Record<string, string> = {};
+      if (apiKey) headers['Authorization'] = `Bearer ${apiKey}`;
+      const res = await fetch(`${host}/models`, {
+        headers,
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+      });
+      if (!res.ok) return [];
+      const data = await res.json() as { data?: Array<{ id?: string }> };
+      if (Array.isArray(data.data)) {
+        return data.data.map((m) => m.id || '').filter(Boolean).sort();
+      }
+    }
+  } catch {
+    // Network errors or timeouts silently fall back
+  }
+  return [];
+}
+
+export interface ModelResolutionResult {
+  models: string[];
+  source: 'live' | 'cache' | 'catalogue';
+}
+
+/**
+ * Resolve available models using dual-layer architecture:
+ * 1. Checks live query if forceRefresh is true.
+ * 2. Checks local cache if available and fresh.
+ * 3. Falls back to static curated catalogue merged with any cached items.
+ */
+export async function resolveAvailableModels(
+  provider: string,
+  config: { apiKey?: string; baseUrl?: string } = {},
+  forceRefresh = false
+): Promise<ModelResolutionResult> {
+  const norm = normalizeProviderKey(provider);
+  const curated = getCuratedModels(norm);
+
+  if (forceRefresh) {
+    const live = await fetchLiveModels(norm, config);
+    if (live.length > 0) {
+      const combined = [...new Set([...live, ...curated])];
+      saveCachedModels(norm, combined);
+      return { models: combined, source: 'live' };
+    }
+  }
+
+  const cached = getCachedModels(norm);
+  if (cached && cached.length > 0) {
+    const combined = [...new Set([...cached, ...curated])];
+    return { models: combined, source: 'cache' };
+  }
+
+  // Attempt lazy background discovery if credentials exist
+  if (config.apiKey || norm === 'ollama') {
+    const live = await fetchLiveModels(norm, config);
+    if (live.length > 0) {
+      const combined = [...new Set([...live, ...curated])];
+      saveCachedModels(norm, combined);
+      return { models: combined, source: 'live' };
+    }
+  }
+
+  return { models: curated, source: 'catalogue' };
+}

package/src/entrypoint.js

@@ -90,7 +90,8 @@ program
 
 program
   .command('config')
-  .description('Configure Direct API Provider (Interactive)')
+  .alias('setup')
+  .description('Guided provider, endpoint, model and autonomy setup')
   .option('-p, --provider <name>', 'Set LLM provider (openai, anthropic, gemini, muse, ollama, dashscope, deepseek)')
   .option('-k, --apikey <key>', 'Set API key')
   .option('-m, --model <name>', 'Set model name')

package/src/modelCatalogue.d.ts

@@ -0,0 +1,5 @@
+export const MODEL_CATALOGUE: Record<string, string[]>;
+export const PROVIDER_LABELS: string[];
+export const DEFAULT_MODEL_BY_PROVIDER: Record<string, string>;
+export const UTILITY_MODEL_BY_PROVIDER: Record<string, string>;
+export function allCatalogueModels(): string[];

package/src/modelCatalogue.js

@@ -34,22 +34,52 @@
  * The label keys are a stable configuration format, not display sugar.
  */
 export const MODEL_CATALOGUE = {
-  'DeepSeek': ['deepseek-v4-pro', 'deepseek-v4-flash'],
-  'Qwen': ['qwen3.7-max', 'qwen3.7-plus', 'qwen3.6-flash'],
+  'DeepSeek': ['deepseek-chat', 'deepseek-reasoner', 'deepseek-v4-pro', 'deepseek-v4-flash'],
+  'Qwen': [
+    'qwen2.5-coder-32b-instruct',
+    'qwen2.5-72b-instruct',
+    'qwen-max',
+    'qwen-plus',
+    'qwen-turbo',
+    'qwen3.7-max',
+    'qwen3.7-plus',
+    'qwen3.6-flash'
+  ],
   // Anthropic ids use DASHES and carry no date suffix. A dotted id here is a
   // bug, not a variant — see src/modelIds.js.
   'Anthropic': [
+    'claude-3-7-sonnet',
+    'claude-3-5-sonnet',
+    'claude-3-5-haiku',
+    'claude-3-opus',
     'claude-fable-5-1',
     'claude-opus-5',
     'claude-opus-4-8',
     'claude-sonnet-5',
     'claude-haiku-4-5'
   ],
-  // GPT-6 Astra leads: it is the current flagship and the only model in the
-  // line-up trained for computer use. It is also the priciest ($10/$50 against
-  // Sol's $5/$30), which is why it heads the list but is not the default.
-  'OpenAI': ['gpt-6-astra', 'gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna', 'gpt-5.4-mini'],
-  'Gemini': ['gemini-3.6-flash', 'gemini-3.5-flash', 'gemini-3.1-pro', 'gemini-3.1-flash-lite'],
+  'OpenAI': [
+    'gpt-4o',
+    'gpt-4o-mini',
+    'o3-mini',
+    'o1',
+    'gpt-6-astra',
+    'gpt-5.6-sol',
+    'gpt-5.6-terra',
+    'gpt-5.6-luna',
+    'gpt-5.4-mini'
+  ],
+  'Gemini': [
+    'gemini-2.5-pro',
+    'gemini-2.5-flash',
+    'gemini-2.0-flash',
+    'gemini-1.5-pro',
+    'gemini-1.5-flash',
+    'gemini-3.6-flash',
+    'gemini-3.5-flash',
+    'gemini-3.1-pro',
+    'gemini-3.1-flash-lite'
+  ],
   // Standard first. The -contributor variants are cheaper because Meta trains
   // on the user's prompts and completions, so they must be a choice made
   // deliberately, never the one at the top of the list.
@@ -60,14 +90,15 @@ export const MODEL_CATALOGUE = {
     'muse-spark-1.3-contributor',
     'muse-spark-1.2-contributor'
   ],
-  'Ollama (Local)': ['llama3', 'mistral', 'gemma2', 'custom'],
+  'Ollama (Local)': ['llama3.3', 'qwen2.5-coder', 'deepseek-r1', 'llama3', 'mistral', 'gemma2', 'custom'],
   'Alibaba (DashScope)': [
+    'qwen-max', 'qwen-plus', 'qwen-turbo', 'qwen2.5-coder-32b-instruct',
     'qwen3.7-max', 'qwen3.7-plus', 'kimi-k2.7-code', 'kimi-k2.6',
     'kimi-k2.5', 'kimi-k2-thinking', 'Moonshot-Kimi-K2-Instruct',
     'deepseek-v4-flash', 'deepseek-v4-pro'
   ],
   'Moonshot (Kimi)': ['kimi-k3', 'kimi-k2.7-code', 'kimi-k2.6'],
-  'xAI (Grok)': ['grok-4.5', 'grok-latest']
+  'xAI (Grok)': ['grok-3', 'grok-3-mini', 'grok-2-1212', 'grok-4.5', 'grok-latest']
 };
 
 /** Provider labels in picker order. */
@@ -75,17 +106,17 @@ export const PROVIDER_LABELS = Object.keys(MODEL_CATALOGUE);
 
 
 export const DEFAULT_MODEL_BY_PROVIDER = {
-  deepseek: 'deepseek-v4-pro',
-  qwen: 'qwen3.7-plus',
-  'dashscope-byok': 'qwen3.7-plus',
-  dashscope: 'qwen3.7-plus',
+  deepseek: 'deepseek-chat',
+  qwen: 'qwen2.5-coder-32b-instruct',
+  'dashscope-byok': 'qwen-plus',
+  dashscope: 'qwen-plus',
   muse: 'muse-spark-1.3',
-  anthropic: 'claude-opus-5',
-  openai: 'gpt-5.6-sol',
-  gemini: 'gemini-3.5-flash',
+  anthropic: 'claude-3-7-sonnet',
+  openai: 'gpt-4o',
+  gemini: 'gemini-2.5-pro',
   moonshot: 'kimi-k3',
-  xai: 'grok-4.5',
-  ollama: 'llama3',
+  xai: 'grok-3',
+  ollama: 'llama3.3',
   'openai-compatible': ''
 };
 

package/src/providers/anthropic.js

@@ -8,6 +8,10 @@ import { LLMProvider } from './base.js';
 // full capability, none of the token cost. Older models fall back to the
 // client-side progressive disclosure in src/toolPacks.js.
 const TOOL_SEARCH_MODELS = [
+  'claude-3-7-sonnet',
+  'claude-3-5-sonnet',
+  'claude-3-5-haiku',
+  'claude-3-opus',
   'claude-fable-5',
   'claude-mythos-5',
   'claude-opus-5',

package/src/sandbox.js

@@ -298,6 +298,10 @@ export class Sandbox {
       return { allowed: true, risk: 'safe' };
     }
 
+    if (toolName === 'creative_apps') {
+      return { allowed: true, risk: args.action === 'status' ? 'safe' : 'dangerous' };
+    }
+
     if (toolName === 'game_asset_fetch' && args.action === 'download_asset') {
       if (!args.url || this.isInternalUrl(args.url)) {
         return { allowed: false, reason: 'Cannot download from an internal or invalid URL', risk: 'forbidden' };
@@ -353,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',
@@ -84,6 +85,7 @@ export const PACKS = {
     'check_system_specs',
     'manage_local_dependencies',
     'blender_act',
+    'creative_apps',
     'resolve_act',
     'palmier_act'
   ],
@@ -95,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',
@@ -361,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;
 

package/src/tools/computerUse.js

@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2025 Bytedance, Inc. and its affiliates.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Causyne Vision Desktop & Coordinate Grounding Tool Wrapper.
+ */
+import { parseVisionGroundingPrediction, visionGroundingToDesktopAct, groundBoxCenter } from '../computerUse/visionGrounding.js';
+import { desktopAct } from './desktopAct.js';
+import { auditLog } from '../auditLog.js';
+export const computerUse = {
+    schema: {
+        name: 'computer_use',
+        description: 'Ground and execute graphical computer-use actions (click coordinates, type text, send key presses, drag, wait) derived from vision-language models and coordinate grounding predictions. Automatically translates normalized bounding boxes and coordinates against current screen dimensions with safety boundary checks. Requires explicit approval.',
+        parameters: {
+            type: 'object',
+            properties: {
+                action: {
+                    type: 'string',
+                    enum: ['execute_prediction', 'click', 'type', 'key', 'drag', 'wait'],
+                    description: 'Type of computer-use action to perform.'
+                },
+                prediction: {
+                    type: 'string',
+                    description: 'Raw prediction text from a vision-language model or coordinate grounding engine, e.g. "Thought: Click search bar. Action: click(start_box=\'(500, 200)\')".'
+                },
+                coordinates: {
+                    type: 'array',
+                    items: { type: 'number' },
+                    description: 'Coordinates as [x, y] or bounding box [x1, y1, x2, y2] normalized (0-1000) or in screen pixels.'
+                },
+                text: {
+                    type: 'string',
+                    description: 'Text to type into the active or targeted element.'
+                },
+                key: {
+                    type: 'string',
+                    description: 'Key or hotkey to press, e.g. "return", "tab", "escape".'
+                },
+                seconds: {
+                    type: 'number',
+                    description: 'Seconds to wait (0.1 to 10).'
+                },
+                app: {
+                    type: 'string',
+                    description: 'Application to focus before executing actions, e.g. "Safari".'
+                },
+                screenContext: {
+                    type: 'object',
+                    properties: {
+                        width: { type: 'number' },
+                        height: { type: 'number' },
+                        scaleFactor: { type: 'number' }
+                    },
+                    description: 'Current display dimensions and scale factor for coordinate grounding.'
+                }
+            }
+        }
+    },
+    async execute(args = {}, context = {}) {
+        const screen = args.screenContext || { width: 1920, height: 1080, scaleFactor: 1 };
+        const app = typeof args.app === 'string' ? args.app.trim() : '';
+        let desktopActions = [];
+        // Mode 1: Parse full model prediction from vision grounding engine
+        if (args.prediction || args.action === 'execute_prediction') {
+            const pred = args.prediction || '';
+            if (!pred.trim()) {
+                return { success: false, error: 'No prediction string provided for execute_prediction.' };
+            }
+            const parsed = parseVisionGroundingPrediction(pred, screen);
+            if (parsed.actions.length === 0) {
+                return { success: false, error: 'Could not parse any executable GUI actions from prediction string.' };
+            }
+            desktopActions = visionGroundingToDesktopAct(parsed.actions);
+        }
+        else {
+            // Mode 2: Direct action request
+            const actionType = args.action || 'click';
+            if (actionType === 'click') {
+                const coords = args.coordinates || [];
+                const point = groundBoxCenter(coords, screen);
+                if (!point)
+                    return { success: false, error: 'Click requires valid coordinates [x, y].' };
+                desktopActions.push({ verb: 'clickxy', x: point.x, y: point.y });
+            }
+            else if (actionType === 'type') {
+                if (args.coordinates && args.coordinates.length >= 2) {
+                    const point = groundBoxCenter(args.coordinates, screen);
+                    if (point)
+                        desktopActions.push({ verb: 'clickxy', x: point.x, y: point.y });
+                }
+                if (!args.text)
+                    return { success: false, error: 'Type action requires "text" parameter.' };
+                desktopActions.push({ verb: 'type', text: args.text });
+            }
+            else if (actionType === 'key') {
+                if (!args.key)
+                    return { success: false, error: 'Key action requires "key" parameter.' };
+                const keyMap = {
+                    return: 36, enter: 36, tab: 48, space: 49, backspace: 51, escape: 53, esc: 53
+                };
+                const keyCode = keyMap[args.key.toLowerCase()];
+                if (keyCode !== undefined) {
+                    desktopActions.push({ verb: 'key', keyCode });
+                }
+                else {
+                    desktopActions.push({ verb: 'type', text: args.key });
+                }
+            }
+            else if (actionType === 'wait') {
+                desktopActions.push({ verb: 'wait', seconds: Math.min(10, Math.max(0.1, args.seconds || 1)) });
+            }
+            else {
+                return { success: false, error: `Unsupported computer_use action: ${actionType}` };
+            }
+        }
+        if (desktopActions.length === 0) {
+            return { success: false, error: 'No actions to execute.' };
+        }
+        if (desktopActions.length > 12) {
+            return { success: false, error: `Maximum 12 actions allowed per call; got ${desktopActions.length}.` };
+        }
+        auditLog.log({
+            event: 'computer_use_actuation',
+            app,
+            actionCount: desktopActions.length,
+            verbs: desktopActions.map((a) => a.verb)
+        });
+        const execResult = await desktopAct.execute({ app, actions: desktopActions }, context);
+        const finalRes = {
+            success: Boolean(execResult.success),
+            actions: desktopActions
+        };
+        if (execResult.output)
+            finalRes.output = execResult.output;
+        if (execResult.error)
+            finalRes.error = execResult.error;
+        return finalRes;
+    }
+};