@jiggai/recipes 0.4.34 → 0.4.36

package/src/lib/workflows/media-drivers/types.ts

@@ -0,0 +1,50 @@
+export interface MediaDriverInvokeOpts {
+  prompt: string;
+  outputDir: string;
+  env: Record<string, string>;
+  timeout: number;
+  config?: Record<string, unknown>;
+}
+
+const DEFAULT_DURATION_SECONDS = 15;
+
+/** Parse duration from node config (e.g. "5s", "10", 15) → seconds as string. */
+export function parseDuration(config?: Record<string, unknown>): string {
+  const raw = config?.duration;
+  if (raw == null) return String(DEFAULT_DURATION_SECONDS);
+  const s = String(raw).replace(/s$/i, '').trim();
+  const n = parseInt(s, 10);
+  if (Number.isNaN(n) || n <= 0) return String(DEFAULT_DURATION_SECONDS);
+  return String(n);
+}
+
+export interface MediaDriverResult {
+  filePath: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface DurationConstraints {
+  /** Minimum duration in seconds */
+  minSeconds: number;
+  /** Maximum duration in seconds */
+  maxSeconds: number;
+  /** Default duration in seconds */
+  defaultSeconds: number;
+  /** Allowed step increments (null = any integer) */
+  stepSeconds?: number;
+}
+
+export interface MediaDriver {
+  /** ClawHub slug or skill folder name */
+  slug: string;
+  /** What this driver produces */
+  mediaType: 'image' | 'video' | 'audio';
+  /** Display name for UI */
+  displayName: string;
+  /** Env vars needed (checked for availability in provider dropdown) */
+  requiredEnvVars: string[];
+  /** Duration constraints for video/audio providers (null for image) */
+  durationConstraints: DurationConstraints | null;
+  /** Run the generation */
+  invoke(opts: MediaDriverInvokeOpts): Promise<MediaDriverResult>;
+}

package/src/lib/workflows/media-drivers/utils.ts

@@ -0,0 +1,149 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { execSync } from 'child_process';
+
+/**
+ * Find a skill directory by searching common skill roots
+ */
+export async function findSkillDir(slug: string): Promise<string | null> {
+  const homedir = process.env.HOME || '/home/control';
+  const skillRoots = [
+    path.join(homedir, '.openclaw', 'skills'),
+    path.join(homedir, '.openclaw', 'workspace', 'skills'),
+    path.join(homedir, '.openclaw', 'workspace'),
+  ];
+
+  for (const root of skillRoots) {
+    const skillDir = path.join(root, slug);
+    try {
+      const stat = await fs.stat(skillDir);
+      if (stat.isDirectory()) {
+        return skillDir;
+      }
+    } catch {
+      // Directory doesn't exist, continue searching
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Find the appropriate Python runner for a skill directory
+ */
+export async function findVenvPython(skillDir: string): Promise<string> {
+  const venvPython = path.join(skillDir, '.venv', 'bin', 'python');
+  
+  try {
+    await fs.access(venvPython);
+    return venvPython;
+  } catch {
+    return 'python3';
+  }
+}
+
+/**
+ * Load environment variables from OpenClaw config
+ */
+export async function loadConfigEnv(): Promise<Record<string, string>> {
+  const homedir = process.env.HOME || '/home/control';
+  const configPath = path.join(homedir, '.openclaw', 'openclaw.json');
+  
+  try {
+    const cfgRaw = await fs.readFile(configPath, 'utf8');
+    const cfgParsed = JSON.parse(cfgRaw);
+
+    // openclaw.json supports multiple shapes historically:
+    // - { env: { KEY: "..." } }
+    // - { env: { vars: { KEY: "..." } } }  (current)
+    const envBlock = (cfgParsed as any)?.env;
+    const maybeVars = envBlock && typeof envBlock === 'object' ? (envBlock as any).vars : null;
+    const rawVars = (maybeVars && typeof maybeVars === 'object') ? maybeVars : envBlock;
+
+    if (rawVars && typeof rawVars === 'object') {
+      return Object.fromEntries(
+        Object.entries(rawVars).filter(([, v]) => typeof v === 'string')
+      ) as Record<string, string>;
+    }
+
+    return {};
+  } catch {
+    // Config read failed — proceed with empty env
+    return {};
+  }
+}
+
+/**
+ * Parse media file path from script output
+ */
+export function parseMediaOutput(stdout: string): string {
+  const mediaMatch = stdout.match(/MEDIA:(.+)$/m);
+  return mediaMatch ? mediaMatch[1].trim() : '';
+}
+
+/**
+ * Execute a script with proper error handling and output capture
+ */
+export interface RunScriptOpts {
+  runner: string;
+  script: string;
+  args?: string[];
+  stdin?: string;
+  env: Record<string, string>;
+  cwd: string;
+  timeout: number;
+}
+
+export function runScript(opts: RunScriptOpts): string {
+  const { runner, script, args = [], stdin, env, cwd, timeout } = opts;
+  
+  const command = args.length > 0 
+    ? `${runner} ${JSON.stringify(script)} ${args.map(arg => JSON.stringify(arg)).join(' ')}`
+    : `${runner} ${JSON.stringify(script)}`;
+
+  try {
+    return execSync(command, {
+      cwd,
+      timeout,
+      encoding: 'utf8',
+      input: stdin,
+      env: {
+        ...process.env,
+        ...env,
+        MEDIA_OUTPUT_DIR: cwd,
+      },
+    }).trim();
+  } catch (err) {
+    // Surface stderr/stdout to make debugging skill scripts possible
+    const e = err as any;
+    const stdout = typeof e?.stdout === 'string' ? e.stdout : (Buffer.isBuffer(e?.stdout) ? e.stdout.toString('utf8') : '');
+    const stderr = typeof e?.stderr === 'string' ? e.stderr : (Buffer.isBuffer(e?.stderr) ? e.stderr.toString('utf8') : '');
+    const msg = [
+      e?.message ? String(e.message) : 'Script execution failed',
+      stdout ? `\n--- stdout ---\n${stdout.trim()}` : '',
+      stderr ? `\n--- stderr ---\n${stderr.trim()}` : '',
+    ].filter(Boolean).join('');
+    throw new Error(msg);
+  }
+}
+
+/**
+ * Search for a script file in skill directory and scripts/ subdirectory
+ */
+export async function findScriptInSkill(skillDir: string, scriptCandidates: string[]): Promise<string | null> {
+  const searchDirs = [skillDir, path.join(skillDir, 'scripts')];
+  
+  for (const dir of searchDirs) {
+    for (const candidate of scriptCandidates) {
+      const scriptPath = path.join(dir, candidate);
+      try {
+        await fs.access(scriptPath);
+        return scriptPath;
+      } catch {
+        // File doesn't exist, continue searching
+      }
+    }
+  }
+  
+  return null;
+}

package/src/lib/workflows/workflow-worker.ts

@@ -1,10 +1,12 @@
 import fs from 'node:fs/promises';
-import { execSync } from 'node:child_process';
 import path from 'node:path';
 import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
 import type { ToolTextResult } from '../../toolsInvoke';
 import { toolsInvoke } from '../../toolsInvoke';
 import { resolveTeamDir } from '../workspace';
+import { getDriver } from './media-drivers/registry';
+import { GenericDriver } from './media-drivers/generic.driver';
+import { loadConfigEnv } from './media-drivers/utils';
 import type { WorkflowLane } from './workflow-types';
 import { dequeueNextTask, enqueueTask, releaseTaskClaim, compactQueue } from './workflow-queue';
 import { loadPriorLlmInput, loadProposedPostTextFromPriorNode } from './workflow-node-output-readers';
@@ -191,6 +193,19 @@ export async function runWorkflowWorkerTick(api: OpenClawPluginApi, opts: {
 
   const results: Array<{ taskId: string; runId: string; nodeId: string; status: string }> = [];
 
+  // Default lock TTL (used when we don't know the node config yet).
+  // This must be comfortably larger than typical media generation durations.
+  const DEFAULT_LOCK_TTL_MS = 30 * 60 * 1000;
+
+  // Once we know the node config, we can set a tighter (but still safe) TTL.
+  const MIN_NODE_LOCK_TTL_MS = 10 * 60 * 1000;
+  const LOCK_TTL_BUFFER_MS = 2 * 60 * 1000;
+  const getNodeLockTtlMs = (node: WorkflowNode): number => {
+    const timeoutMsRaw = asRecord(node?.config ?? {})['timeoutMs'];
+    const timeoutMs = typeof timeoutMsRaw === 'number' && Number.isFinite(timeoutMsRaw) ? timeoutMsRaw : 0;
+    return Math.max(MIN_NODE_LOCK_TTL_MS, timeoutMs + LOCK_TTL_BUFFER_MS);
+  };
+
   for (let i = 0; i < limit; i++) {
     const dq = await dequeueNextTask(teamDir, agentId, { workerId, leaseSeconds: 120 });
     if (!dq.ok || !dq.task) break;
@@ -207,9 +222,19 @@ export async function runWorkflowWorkerTick(api: OpenClawPluginApi, opts: {
 
       await ensureDir(lockDir);
 
+      const claimedAtIso = new Date().toISOString();
+      const lockInfo = {
+        workerId,
+        pid: process.pid,
+        taskId: task.id,
+        claimedAt: claimedAtIso,
+        ttlMs: DEFAULT_LOCK_TTL_MS,
+        expiresAt: new Date(Date.now() + DEFAULT_LOCK_TTL_MS).toISOString(),
+      };
+
       // Node-level lock to prevent double execution.
       try {
-        await fs.writeFile(lockPath, JSON.stringify({ workerId, taskId: task.id, claimedAt: new Date().toISOString() }, null, 2), { encoding: 'utf8', flag: 'wx' });
+        await fs.writeFile(lockPath, JSON.stringify(lockInfo, null, 2), { encoding: 'utf8', flag: 'wx' });
         lockHeld = true;
       } catch {
         // Lock exists. Treat it as contention unless it looks stale.
@@ -217,10 +242,27 @@ export async function runWorkflowWorkerTick(api: OpenClawPluginApi, opts: {
         let unlocked = false;
         try {
           const raw = await readTextFile(lockPath);
-          const parsed = JSON.parse(raw) as { claimedAt?: string };
+          const parsed = JSON.parse(raw) as { claimedAt?: string; ttlMs?: number; expiresAt?: string };
+
+          const expiresAtMs = parsed?.expiresAt ? Date.parse(String(parsed.expiresAt)) : NaN;
           const claimedAtMs = parsed?.claimedAt ? Date.parse(String(parsed.claimedAt)) : NaN;
-          const ageMs = Number.isFinite(claimedAtMs) ? Date.now() - claimedAtMs : NaN;
-          const stale = Number.isFinite(ageMs) && ageMs > 10 * 60 * 1000;
+          const parsedTtlMs = typeof parsed?.ttlMs === 'number' && Number.isFinite(parsed.ttlMs) ? parsed.ttlMs : NaN;
+
+          const computedExpiryMs = Number.isFinite(claimedAtMs) && Number.isFinite(parsedTtlMs)
+            ? claimedAtMs + parsedTtlMs
+            : NaN;
+
+          // Prefer explicit expiresAt from the lock file; otherwise fall back to (claimedAt + ttlMs).
+          // If neither exists (older locks), fall back to DEFAULT_LOCK_TTL_MS.
+          const effectiveExpiryMs = Number.isFinite(expiresAtMs)
+            ? expiresAtMs
+            : Number.isFinite(computedExpiryMs)
+              ? computedExpiryMs
+              : Number.isFinite(claimedAtMs)
+                ? claimedAtMs + DEFAULT_LOCK_TTL_MS
+                : NaN;
+
+          const stale = Number.isFinite(effectiveExpiryMs) && Date.now() > effectiveExpiryMs;
           if (stale) {
             await fs.unlink(lockPath);
             unlocked = true;
@@ -231,7 +273,7 @@ export async function runWorkflowWorkerTick(api: OpenClawPluginApi, opts: {
 
         if (unlocked) {
           try {
-            await fs.writeFile(lockPath, JSON.stringify({ workerId, taskId: task.id, claimedAt: new Date().toISOString() }, null, 2), { encoding: 'utf8', flag: 'wx' });
+            await fs.writeFile(lockPath, JSON.stringify(lockInfo, null, 2), { encoding: 'utf8', flag: 'wx' });
             lockHeld = true;
           } catch { // intentional: lock contention, skip task
             results.push({ taskId: task.id, runId: task.runId, nodeId: task.nodeId, status: 'skipped_locked' });
@@ -253,35 +295,48 @@ export async function runWorkflowWorkerTick(api: OpenClawPluginApi, opts: {
       const runId = task.runId;
 
       const { run } = await loadRunFile(teamDir, runsDir, runId);
-    const workflowFile = String(run.workflow.file);
-    const workflowPath = path.join(workflowsDir, workflowFile);
-    const workflowRaw = await readTextFile(workflowPath);
-    const workflow = normalizeWorkflow(JSON.parse(workflowRaw));
-
-    const nodeIdx = workflow.nodes.findIndex((n) => String(n.id) === String(task.nodeId));
-    if (nodeIdx < 0) throw new Error(`Node not found in workflow: ${task.nodeId}`);
-    const node = workflow.nodes[nodeIdx]!;
-
-    // Stale-task guard: expired claim recovery can surface older queue entries from behind the
-    // cursor. Before executing a dequeued task, verify that this node is still actually runnable
-    // for the current run state. Otherwise we can resurrect pre-approval work and overwrite
-    // canonical node outputs for runs that already advanced.
-    const currentRun = (await loadRunFile(teamDir, runsDir, task.runId)).run;
-    const currentNodeStates = loadNodeStatesFromRun(currentRun);
-    const currentStatus = currentNodeStates[String(node.id)]?.status;
-    const currentlyRunnableIdx = pickNextRunnableNodeIndex({ workflow, run: currentRun });
-    if (
-      currentStatus === 'success' ||
-      currentStatus === 'error' ||
-      currentStatus === 'waiting' ||
-      currentlyRunnableIdx === null ||
-      String(workflow.nodes[currentlyRunnableIdx]?.id ?? '') !== String(node.id)
-    ) {
-      results.push({ taskId: task.id, runId: task.runId, nodeId: task.nodeId, status: 'skipped_stale' });
-      continue;
-    }
+      const workflowFile = String(run.workflow.file);
+      const workflowPath = path.join(workflowsDir, workflowFile);
+      const workflowRaw = await readTextFile(workflowPath);
+      const workflow = normalizeWorkflow(JSON.parse(workflowRaw));
+
+      const nodeIdx = workflow.nodes.findIndex((n) => String(n.id) === String(task.nodeId));
+      if (nodeIdx < 0) throw new Error(`Node not found in workflow: ${task.nodeId}`);
+      const node = workflow.nodes[nodeIdx]!;
+
+      // Now that we know the node, tighten the lock TTL based on node.config.timeoutMs.
+      try {
+        const nodeLockTtlMs = getNodeLockTtlMs(node);
+        if (nodeLockTtlMs !== lockInfo.ttlMs) {
+          await fs.writeFile(
+            lockPath,
+            JSON.stringify({ ...lockInfo, ttlMs: nodeLockTtlMs, expiresAt: new Date(Date.now() + nodeLockTtlMs).toISOString() }, null, 2),
+            { encoding: 'utf8' },
+          );
+        }
+      } catch { // intentional: best-effort lock metadata update
+        // ignore
+      }
+
+      // Stale-task guard: expired claim recovery can surface older queue entries from behind the
+      // cursor. Before executing a dequeued task, verify that this node is still actually runnable
+      // for the current run state. Otherwise we can resurrect pre-approval work and overwrite
+      // canonical node outputs for runs that already advanced.
+      const currentNodeStates = loadNodeStatesFromRun(run);
+      const currentStatus = currentNodeStates[String(node.id)]?.status;
+      const currentlyRunnableIdx = pickNextRunnableNodeIndex({ workflow, run });
+      if (
+        currentStatus === 'success' ||
+        currentStatus === 'error' ||
+        currentStatus === 'waiting' ||
+        currentlyRunnableIdx === null ||
+        String(workflow.nodes[currentlyRunnableIdx]?.id ?? '') !== String(node.id)
+      ) {
+        results.push({ taskId: task.id, runId: task.runId, nodeId: task.nodeId, status: 'skipped_stale' });
+        continue;
+      }
 
-    // Determine current lane + ticket path.
+      // Determine current lane + ticket path.
     const laneRaw = String(run.ticket.lane);
     assertLane(laneRaw);
     let curLane: WorkflowLane = laneRaw as WorkflowLane;
@@ -1012,13 +1067,13 @@ export async function runWorkflowWorkerTick(api: OpenClawPluginApi, opts: {
         const timeoutMsRaw = Number(asString(config['timeoutMs'] ?? '300000'));
         const timeoutMs = Number.isFinite(timeoutMsRaw) && timeoutMsRaw > 0 ? timeoutMsRaw : 300000;
 
-        // ── Step 1: Prompt refinement (optional) ──
-        // skipRefinement: when the upstream LLM already produced a clean brief,
-        // skip the extra llm-task call that tends to over-elaborate.
-        const skipRefinement = String(config['skipRefinement'] ?? config['skip_refinement'] ?? 'false').toLowerCase() === 'true';
+        // ── Step 1: Prompt refinement (opt-in) ──
+        // addRefinement: explicitly request an LLM refinement pass.
+        // Default is OFF — upstream LLM nodes should produce ready-to-use briefs.
+        const addRefinement = String(config['addRefinement'] ?? config['add_refinement'] ?? 'false').toLowerCase() === 'true';
         let refinedPrompt = prompt.trim();
 
-        if (!skipRefinement && mediaType !== 'image') {
+        if (addRefinement && mediaType !== 'image') {
           // Use llm-task refinement for non-image media (video/audio)
           const step1Text = [
             `You are a media prompt engineer for teamId=${teamId}.`,
@@ -1061,149 +1116,43 @@ export async function runWorkflowWorkerTick(api: OpenClawPluginApi, opts: {
           refinedPrompt = refinedPrompt.slice(0, MAX_IMAGE_PROMPT_LEN).replace(/\s+\S*$/, '') + '...';
         }
 
-        // ── Step 2: Invoke the skill script to generate actual media ─────
-        const homedir = process.env.HOME || '/home/control';
-        const scriptCandidates = mediaType === 'image'
-          ? ['generate_image.py', 'generate_image.sh', 'generate.sh']
-          : ['generate_video.py', 'generate_video.sh', 'generate.py', 'generate.sh'];
-
-        // Auto-discover: if provider specifies a skill, try that first, then scan all skills
-        const providerSkill = provider.startsWith('skill-') ? provider.replace(/^skill-/, '') : '';
-        const skillRoots = [
-          path.join(homedir, '.openclaw', 'skills'),
-          path.join(homedir, '.openclaw', 'workspace', 'skills'),
-        ];
-
-        let scriptPath = '';
-        let skillName = providerSkill;
-
-        // Helper: search a specific skill directory for matching scripts
-        const findScript = async (skillDir: string): Promise<string> => {
-          for (const c of scriptCandidates) {
-            const p = path.join(skillDir, c);
-            try { await fs.access(p); return p; } catch { /* skip */ }
-          }
-          return '';
-        };
-
-        // 1) Try the explicitly specified provider skill first
-        if (providerSkill) {
-          for (const root of skillRoots) {
-            scriptPath = await findScript(path.join(root, providerSkill));
-            if (scriptPath) break;
-          }
-        }
+        // ── Step 2: Invoke the media driver to generate actual media ─────
+        const providerSlug = provider.startsWith('skill-') ? provider.replace(/^skill-/, '') : provider;
+        const configEnv = await loadConfigEnv();
+        const mergedEnv = { ...process.env, ...configEnv } as Record<string, string>;
 
-        // 2) If not found, auto-discover any skill that has the right script
-        if (!scriptPath) {
-          for (const root of skillRoots) {
-            try {
-              const entries = await fs.readdir(root, { withFileTypes: true });
-              for (const entry of entries) {
-                if (!entry.isDirectory()) continue;
-                const found = await findScript(path.join(root, entry.name));
-                if (found) {
-                  scriptPath = found;
-                  skillName = entry.name;
-                  break;
-                }
-              }
-            } catch { /* root dir doesn't exist */ }
-            if (scriptPath) break;
-          }
+        // Find a registered driver, or fall back to auto-discovered generic driver
+        let driver = getDriver(providerSlug);
+        if (!driver) {
+          const discovered = await GenericDriver.createFromSkill(providerSlug);
+          if (discovered) driver = discovered;
         }
 
-        const skillSearchDirs = providerSkill
-          ? skillRoots.map(r => path.join(r, providerSkill))
-          : skillRoots;
-
         let payload: Record<string, unknown>;
-        if (scriptPath) {
-          // Run the skill script with the refined prompt
-          // Inject env vars from OpenClaw config (gateway doesn't expose them to process.env)
-          let configEnv: Record<string, string> = {};
-          try {
-            const cfgRaw = await fs.readFile(path.join(homedir, '.openclaw', 'openclaw.json'), 'utf8');
-            const cfgParsed = JSON.parse(cfgRaw);
-
-            // openclaw.json supports multiple shapes historically:
-            // - { env: { KEY: "..." } }
-            // - { env: { vars: { KEY: "..." } } }  (current)
-            const envBlock = (cfgParsed as any)?.env;
-            const maybeVars = envBlock && typeof envBlock === 'object' ? (envBlock as any).vars : null;
-            const rawVars = (maybeVars && typeof maybeVars === 'object') ? maybeVars : envBlock;
-
-            if (rawVars && typeof rawVars === 'object') {
-              configEnv = Object.fromEntries(
-                Object.entries(rawVars).filter(([, v]) => typeof v === 'string')
-              ) as Record<string, string>;
-            }
-          } catch { /* config read failed — proceed with process.env only */ }
-
-          // If the .py script has a venv alongside it, use that Python; otherwise system python3.
-          let runner = 'bash';
-          if (scriptPath.endsWith('.py')) {
-            const scriptDir = path.dirname(scriptPath);
-            const venvPython = path.join(scriptDir, '.venv', 'bin', 'python');
-            try {
-              await fs.access(venvPython);
-              runner = venvPython;
-            } catch {
-              runner = 'python3';
-            }
-          }
-
-          let scriptOutput = '';
-          try {
-            scriptOutput = execSync(
-              `${runner} ${JSON.stringify(scriptPath)}`,
-              {
-                cwd: mediaDir,
-                timeout: timeoutMs,
-                encoding: 'utf8',
-                input: refinedPrompt,
-                env: {
-                  ...process.env,
-                  ...configEnv,
-                  HOME: homedir,
-                  MEDIA_OUTPUT_DIR: mediaDir,
-                },
-              }
-            ).trim();
-          } catch (err) {
-            // Surface stderr/stdout to make debugging skill scripts possible.
-            // execSync throws an Error with extra fields: stdout/stderr (Buffer|string)
-            const e = err as any;
-            const stdout = typeof e?.stdout === 'string' ? e.stdout : (Buffer.isBuffer(e?.stdout) ? e.stdout.toString('utf8') : '');
-            const stderr = typeof e?.stderr === 'string' ? e.stderr : (Buffer.isBuffer(e?.stderr) ? e.stderr.toString('utf8') : '');
-            const msg = [
-              e?.message ? String(e.message) : 'Skill script failed',
-              stdout ? `\n--- stdout ---\n${stdout.trim()}` : '',
-              stderr ? `\n--- stderr ---\n${stderr.trim()}` : '',
-            ].filter(Boolean).join('');
-            throw new Error(msg);
-          }
-
-          // Parse the output — skill scripts print "MEDIA:/path/to/file"
-          const mediaMatch = scriptOutput.match(/MEDIA:(.+)$/m);
-          const filePath = mediaMatch ? mediaMatch[1].trim() : '';
+        if (driver) {
+          const result = await driver.invoke({
+            prompt: refinedPrompt,
+            outputDir: mediaDir,
+            env: mergedEnv,
+            timeout: timeoutMs,
+            config: node.config as Record<string, unknown> | undefined,
+          });
 
           payload = {
             [promptKey]: refinedPrompt,
-            file_path: filePath,
-            status: filePath ? 'success' : 'error',
-            skill: skillName,
-            script_output: scriptOutput,
-            error: filePath ? null : 'No MEDIA: path in script output',
+            file_path: result.filePath,
+            status: result.filePath ? 'success' : 'error',
+            skill: driver.slug,
+            script_output: (result.metadata as any)?.script_output ?? '',
+            error: result.filePath ? null : 'No file path returned from driver',
           };
         } else {
-          // No skill script found — fall back to prompt-only output
           payload = {
             [promptKey]: refinedPrompt,
             file_path: '',
-            status: 'no_skill_script',
-            skill: skillName,
-            error: `No executable script found for skill "${skillName}" in ${skillSearchDirs.join(', ')}`,
+            status: 'no_driver',
+            skill: providerSlug,
+            error: `No media driver found for provider "${providerSlug}"`,
           };
         }
         text = JSON.stringify(payload, null, 2);