@causyne/agent 1.10.18 → 1.10.20

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' };

package/src/toolPacks.js

@@ -84,6 +84,7 @@ export const PACKS = {
     'check_system_specs',
     'manage_local_dependencies',
     'blender_act',
+    'creative_apps',
     'resolve_act',
     'palmier_act'
   ],

package/src/tools/creativeApps.js

@@ -0,0 +1,106 @@
+import { runStudioEdit } from '../creative/studioScripts.js';
+import { creativeAppStatus } from '../creative/apps.js';
+import { runBlenderBatch } from '../creative/blenderBatch.js';
+import { runStudioPipeline } from '../creative/pipeline.js';
+export const creativeApps = {
+    schema: {
+        name: 'creative_apps',
+        description: 'Inspect installed creative applications, run bounded creative batches, or orchestrate multi-stage creative pipelines. Blender batch creates and edits 3D scenes (primitives, materials, lights, cameras, render) and saves a new .blend. studio_edit uses native scripting: Photo Studio (resize/rotate/layers/flatten -> PSD/PNG/JPG/WEBP), Video Studio (sequences/imports/timeline cuts/markers -> PRPROJ), Motion Studio (compositions/imports/text -> AEP). studio_pipeline executes sequential coordinated multi-host stages. Requires workspace scoping.',
+        parameters: {
+            type: 'object',
+            properties: {
+                action: { type: 'string', enum: ['status', 'blender_batch', 'studio_edit', 'studio_pipeline'] },
+                host: { type: 'string', enum: ['photoshop', 'premiere', 'after-effects', 'photo-studio', 'video-studio', 'motion-studio'] },
+                input: { type: 'string', description: 'Existing .blend, image/document, or project file inside the workspace.' },
+                output: { type: 'string', description: 'New .blend, PSD/PNG, PRPROJ, or AEP file inside the workspace; never overwrites.' },
+                stages: {
+                    type: 'array',
+                    description: 'Stages for studio_pipeline: array of { id, type: "3d_batch"|"studio_batch", config }',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            id: { type: 'string', description: 'Stage identifier' },
+                            type: { type: 'string', enum: ['3d_batch', 'studio_batch'], description: 'Stage batch execution type' },
+                            config: {
+                                type: 'object',
+                                description: 'Stage payload configuration',
+                                properties: {
+                                    host: { type: 'string' },
+                                    input: { type: 'string' },
+                                    output: { type: 'string' },
+                                    actions: {
+                                        type: 'array',
+                                        items: {
+                                            type: 'object',
+                                            properties: {
+                                                type: { type: 'string' }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        required: ['type']
+                    }
+                },
+                actions: { type: 'array', maxItems: 64, items: {
+                        type: 'object', properties: {
+                            type: { type: 'string', enum: [
+                                    'add_cube', 'add_sphere', 'add_cylinder', 'add_plane', 'add_camera', 'add_light',
+                                    'material', 'render', 'transform', 'resize', 'rotate', 'crop', 'layer', 'new_layer', 'flatten',
+                                    'composition', 'sequence', 'import', 'text', 'marker', 'cut', 'solid', 'adjust_color'
+                                ] },
+                            name: { type: 'string' },
+                            width: { type: 'number' }, height: { type: 'number' },
+                            angle: { type: 'number' }, index: { type: 'integer' },
+                            opacity: { type: 'number' }, visible: { type: 'boolean' },
+                            duration: { type: 'number' }, fps: { type: 'number' },
+                            path: { type: 'string' }, start: { type: 'number' }, text: { type: 'string' },
+                            location: { type: 'array', items: { type: 'number' }, minItems: 3, maxItems: 3 },
+                            scale: { type: 'array', items: { type: 'number' }, minItems: 3, maxItems: 3 },
+                            rotation: { type: 'array', items: { type: 'number' }, minItems: 3, maxItems: 3 },
+                            radius: { type: 'number' }, depth: { type: 'number' },
+                            lightType: { type: 'string', enum: ['POINT', 'SUN', 'SPOT', 'AREA'] },
+                            energy: { type: 'number' },
+                            color: { type: 'array', items: { type: 'number' }, minItems: 4, maxItems: 4 },
+                            outputPath: { type: 'string' },
+                            resolution: { type: 'array', items: { type: 'number' }, minItems: 2, maxItems: 2 },
+                            comment: { type: 'string' },
+                            track: { type: 'integer' },
+                            time: { type: 'number' },
+                            left: { type: 'number' },
+                            top: { type: 'number' },
+                            blendMode: { type: 'string' },
+                            size: { type: 'number' },
+                            font: { type: 'string' },
+                            x: { type: 'number' },
+                            y: { type: 'number' },
+                            brightness: { type: 'number' },
+                            contrast: { type: 'number' },
+                            roughness: { type: 'number' },
+                            metallic: { type: 'number' }
+                        }, required: ['type'], additionalProperties: false
+                    } }
+            }, required: ['action'], additionalProperties: false
+        }
+    },
+    async execute(value, context = {}) {
+        try {
+            if (!value || typeof value !== 'object')
+                throw new Error('Expected creative app arguments');
+            const args = value;
+            if (args.action === 'status')
+                return { success: true, apps: await creativeAppStatus() };
+            if (args.action === 'studio_edit')
+                return await runStudioEdit(args, process.cwd(), context.signal);
+            if (args.action === 'blender_batch')
+                return await runBlenderBatch(args, process.cwd(), context.signal);
+            if (args.action === 'studio_pipeline')
+                return await runStudioPipeline(args, process.cwd(), context.signal);
+            throw new Error('Unknown creative app action');
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+};

package/src/tools/creativeApps.ts

@@ -0,0 +1,99 @@
+import { runStudioEdit } from '../creative/studioScripts.js';
+import { creativeAppStatus } from '../creative/apps.js';
+import { runBlenderBatch } from '../creative/blenderBatch.js';
+import { runStudioPipeline } from '../creative/pipeline.js';
+
+export const creativeApps = {
+  schema: {
+    name: 'creative_apps',
+    description: 'Inspect installed creative applications, run bounded creative batches, or orchestrate multi-stage creative pipelines. Blender batch creates and edits 3D scenes (primitives, materials, lights, cameras, render) and saves a new .blend. studio_edit uses native scripting: Photo Studio (resize/rotate/layers/flatten -> PSD/PNG/JPG/WEBP), Video Studio (sequences/imports/timeline cuts/markers -> PRPROJ), Motion Studio (compositions/imports/text -> AEP). studio_pipeline executes sequential coordinated multi-host stages. Requires workspace scoping.',
+    parameters: {
+      type: 'object',
+      properties: {
+        action: { type: 'string', enum: ['status', 'blender_batch', 'studio_edit', 'studio_pipeline'] },
+        host: { type: 'string', enum: ['photoshop', 'premiere', 'after-effects', 'photo-studio', 'video-studio', 'motion-studio'] },
+        input: { type: 'string', description: 'Existing .blend, image/document, or project file inside the workspace.' },
+        output: { type: 'string', description: 'New .blend, PSD/PNG, PRPROJ, or AEP file inside the workspace; never overwrites.' },
+        stages: {
+          type: 'array',
+          description: 'Stages for studio_pipeline: array of { id, type: "3d_batch"|"studio_batch", config }',
+          items: {
+            type: 'object',
+            properties: {
+              id: { type: 'string', description: 'Stage identifier' },
+              type: { type: 'string', enum: ['3d_batch', 'studio_batch'], description: 'Stage batch execution type' },
+              config: {
+                type: 'object',
+                description: 'Stage payload configuration',
+                properties: {
+                  host: { type: 'string' },
+                  input: { type: 'string' },
+                  output: { type: 'string' },
+                  actions: {
+                    type: 'array',
+                    items: {
+                      type: 'object',
+                      properties: {
+                        type: { type: 'string' }
+                      }
+                    }
+                  }
+                }
+              }
+            },
+            required: ['type']
+          }
+        },
+        actions: { type: 'array', maxItems: 64, items: {
+          type: 'object', properties: {
+            type: { type: 'string', enum: [
+              'add_cube', 'add_sphere', 'add_cylinder', 'add_plane', 'add_camera', 'add_light',
+              'material', 'render', 'transform', 'resize', 'rotate', 'crop', 'layer', 'new_layer', 'flatten',
+              'composition', 'sequence', 'import', 'text', 'marker', 'cut', 'solid', 'adjust_color'
+            ] },
+            name: { type: 'string' },
+            width: { type: 'number' }, height: { type: 'number' },
+            angle: { type: 'number' }, index: { type: 'integer' },
+            opacity: { type: 'number' }, visible: { type: 'boolean' },
+            duration: { type: 'number' }, fps: { type: 'number' },
+            path: { type: 'string' }, start: { type: 'number' }, text: { type: 'string' },
+            location: { type: 'array', items: { type: 'number' }, minItems: 3, maxItems: 3 },
+            scale: { type: 'array', items: { type: 'number' }, minItems: 3, maxItems: 3 },
+            rotation: { type: 'array', items: { type: 'number' }, minItems: 3, maxItems: 3 },
+            radius: { type: 'number' }, depth: { type: 'number' },
+            lightType: { type: 'string', enum: ['POINT', 'SUN', 'SPOT', 'AREA'] },
+            energy: { type: 'number' },
+            color: { type: 'array', items: { type: 'number' }, minItems: 4, maxItems: 4 },
+            outputPath: { type: 'string' },
+            resolution: { type: 'array', items: { type: 'number' }, minItems: 2, maxItems: 2 },
+            comment: { type: 'string' },
+            track: { type: 'integer' },
+            time: { type: 'number' },
+            left: { type: 'number' },
+            top: { type: 'number' },
+            blendMode: { type: 'string' },
+            size: { type: 'number' },
+            font: { type: 'string' },
+            x: { type: 'number' },
+            y: { type: 'number' },
+            brightness: { type: 'number' },
+            contrast: { type: 'number' },
+            roughness: { type: 'number' },
+            metallic: { type: 'number' }
+          }, required: ['type'], additionalProperties: false
+        } }
+      }, required: ['action'], additionalProperties: false
+    }
+  },
+  async execute(value: unknown, context: { signal?: AbortSignal } = {}) {
+    try {
+      if (!value || typeof value !== 'object') throw new Error('Expected creative app arguments');
+      const args = value as Record<string, unknown>;
+      if (args.action === 'status') return { success: true, apps: await creativeAppStatus() };
+      if (args.action === 'studio_edit') return await runStudioEdit(args, process.cwd(), context.signal);
+      if (args.action === 'blender_batch') return await runBlenderBatch(args, process.cwd(), context.signal);
+      if (args.action === 'studio_pipeline') return await runStudioPipeline(args, process.cwd(), context.signal);
+      throw new Error('Unknown creative app action');
+    } catch (error) { return { success: false, error: error instanceof Error ? error.message : String(error) }; }
+  }
+};

package/src/tools/registry.js

@@ -1,3 +1,4 @@
+import { creativeApps } from './creativeApps.js';
 import { sysRun, sysRunBg } from './sysRun.js';
 import { fsRead } from './fsRead.js';
 import { fsWrite } from './fsWrite.js';
@@ -119,7 +120,7 @@ const TOOL_MODULES = [
   gameAssetHarvester, gameAudioSynth, gameVfxEmitterGen,
   gameShaderForge, gameSceneBuilder, gameEntitySpawner,
   gameTilemapGenerator, gameUiHudBuilder, gameEconomyBalancer,
-  gameDataForge, gameWebRuntimeInspector, gameCanvasAudit, readNativeSkill, createSkill
+  gameDataForge, gameWebRuntimeInspector, gameCanvasAudit, readNativeSkill, createSkill, creativeApps
 ];
 
 // Base static definitions (backwards compatible). Order is preserved from the