@jiggai/recipes 0.4.30 → 0.4.32

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "recipes",
   "name": "Recipes",
   "description": "Markdown recipes that scaffold agents and teams (workspace-local).",
-  "version": "0.4.30",
+  "version": "0.4.32",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jiggai/recipes",
-  "version": "0.4.30",
+  "version": "0.4.32",
   "description": "ClawRecipes plugin for OpenClaw (markdown recipes -> scaffold agents/teams)",
   "main": "index.ts",
   "type": "commonjs",
@@ -10,6 +10,9 @@
     ],
     "compat": {
       "pluginApi": "2026.3"
+    },
+    "build": {
+      "openclawVersion": "2026.3.28"
     }
   },
   "publishConfig": {

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

@@ -47,6 +47,8 @@ export function normalizeWorkflow(raw: unknown): Workflow {
       // LLM: allow either promptTemplatePath (preferred) or inline promptTemplate string
       ...(config['promptTemplate'] != null ? { promptTemplate: asString(config['promptTemplate']) } : {}),
       ...(config['promptTemplatePath'] != null ? { promptTemplatePath: asString(config['promptTemplatePath']) } : {}),
+      ...(config['model'] != null ? { model: asString(config['model']) } : {}),
+      ...(config['provider'] != null ? { provider: asString(config['provider']) } : {}),
 
       // Tool
       ...(config['tool'] != null ? { tool: asString(config['tool']) } : {}),

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

@@ -418,6 +418,19 @@ export async function runWorkflowWorkerTick(api: OpenClawPluginApi, opts: {
 
         const timeoutMsRaw = Number(asString(action['timeoutMs'] ?? (node as unknown as { config?: unknown })?.config?.['timeoutMs'] ?? '120000'));
         const timeoutMs = Number.isFinite(timeoutMsRaw) && timeoutMsRaw > 0 ? timeoutMsRaw : 120000;
+        const configuredModel = asString(action['model'] ?? (node as unknown as { config?: unknown })?.config?.['model']).trim();
+        const configuredProvider = asString(action['provider'] ?? (node as unknown as { config?: unknown })?.config?.['provider']).trim();
+        let provider = configuredProvider;
+        let model = configuredModel;
+        if (model) {
+          const slash = model.indexOf('/');
+          if (slash > 0 && slash < model.length - 1) {
+            const modelProvider = model.slice(0, slash).trim();
+            const bareModel = model.slice(slash + 1).trim();
+            if (!provider) provider = modelProvider;
+            if (provider === modelProvider) model = bareModel;
+          }
+        }
 
         // Inject team memory context for LLM nodes
         const memoryContext = await buildMemoryContext(teamDir);
@@ -430,6 +443,8 @@ export async function runWorkflowWorkerTick(api: OpenClawPluginApi, opts: {
             prompt: promptWithMemory,
             input: { teamId, runId, nodeId: node.id, agentId, ...priorInput },
             timeoutMs,
+            ...(provider ? { provider } : {}),
+            ...(model ? { model } : {}),
           },
         });
 
@@ -438,16 +453,34 @@ export async function runWorkflowWorkerTick(api: OpenClawPluginApi, opts: {
         const payload = details['json'] ?? (Object.keys(details).length ? details : llmRes) ?? null;
         text = JSON.stringify(payload, null, 2);
       } catch (e) {
-        // Record the error on the run so it doesn't stay stuck in waiting_workers.
-        const errMsg = `LLM execution failed for node ${nodeLabel(node)}: ${e instanceof Error ? e.message : String(e)}`;
+        const eRec = asRecord(e);
+        const errorDetails = {
+          message: e instanceof Error ? e.message : String(e),
+          name: e instanceof Error ? e.name : undefined,
+          stack: e instanceof Error ? e.stack : undefined,
+          error: eRec['error'],
+          details: eRec['details'],
+          data: eRec['data'],
+          cause: e instanceof Error && 'cause' in e ? (e as Error & { cause?: unknown }).cause : undefined,
+        };
+        const errMsg = `LLM execution failed for node ${nodeLabel(node)}: ${errorDetails.message}`;
         const errorTs = new Date().toISOString();
         await appendRunLog(runPath, (cur) => ({
           ...cur,
           status: 'error',
           updatedAt: errorTs,
-          nodeStates: { ...(cur.nodeStates ?? {}), [node.id]: { status: 'error', ts: errorTs, error: errMsg } },
-          events: [...cur.events, { ts: errorTs, type: 'node.error', nodeId: node.id, kind: node.kind, message: errMsg }],
-          nodeResults: [...(cur.nodeResults ?? []), { nodeId: node.id, kind: node.kind, agentId: agentIdExec, error: errMsg }],
+          nodeStates: {
+            ...(cur.nodeStates ?? {}),
+            [node.id]: { status: 'error', ts: errorTs, error: errMsg, details: errorDetails },
+          },
+          events: [
+            ...cur.events,
+            { ts: errorTs, type: 'node.error', nodeId: node.id, kind: node.kind, message: errMsg, details: errorDetails },
+          ],
+          nodeResults: [
+            ...(cur.nodeResults ?? []),
+            { nodeId: node.id, kind: node.kind, agentId: agentIdExec, error: errMsg, details: errorDetails },
+          ],
         }));
         results.push({ taskId: task.id, runId: task.runId, nodeId: task.nodeId, status: 'error' });
         continue;
@@ -923,63 +956,127 @@ 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: LLM refines the prompt ──────────────────────────────
-        const step1Text = [
-          `You are a media prompt engineer for teamId=${teamId}.`,
-          `Workflow: ${workflow.name ?? workflow.id ?? workflowFile}`,
-          `Node: ${nodeLabel(node)} | Media type: ${mediaType}`,
-          `Size: ${size} | Quality: ${quality} | Style: ${style}`,
-          `\n---\nINPUT PROMPT\n---\n`,
-          prompt.trim(),
-          `\n---\nINSTRUCTIONS\n---\n`,
-          `Refine the input into a detailed, production-ready ${mediaType} generation prompt.`,
-          `Return JSON with exactly one key: "${promptKey}" containing the refined prompt string.`,
-          `Example: {"${promptKey}": "A detailed description..."}`,
-        ].filter(Boolean).join('\n');
-
-        const step1Prompt = memoryContext ? `${memoryContext}\n\n${step1Text}` : step1Text;
-
-        const step1Res = await toolsInvoke<unknown>(api, {
-          tool: 'llm-task',
-          action: 'json',
-          args: { prompt: step1Prompt, timeoutMs: 60000 },
-        });
+        // ── Step 1: Prompt refinement (optional — skip for images, use llm-task for video) ──
+        let refinedPrompt = prompt.trim();
+
+        if (mediaType !== 'image') {
+          // Only use llm-task refinement for non-image media (video/audio)
+          const step1Text = [
+            `You are a media prompt engineer for teamId=${teamId}.`,
+            `Workflow: ${workflow.name ?? workflow.id ?? workflowFile}`,
+            `Node: ${nodeLabel(node)} | Media type: ${mediaType}`,
+            `Size: ${size} | Quality: ${quality} | Style: ${style}`,
+            `\n---\nINPUT PROMPT\n---\n`,
+            prompt.trim(),
+            `\n---\nINSTRUCTIONS\n---\n`,
+            `Refine the input into a detailed, production-ready ${mediaType} generation prompt.`,
+            `Return JSON with exactly one key: "${promptKey}" containing the refined prompt string.`,
+            `Example: {"${promptKey}": "A detailed description..."}`,
+          ].filter(Boolean).join('\n');
+
+          const step1Prompt = memoryContext ? `${memoryContext}\n\n${step1Text}` : step1Text;
 
-        // Extract the refined prompt
-        const step1Rec = asRecord(step1Res);
-        const step1Details = asRecord(step1Rec['details']);
-        const step1Json = (step1Details['json'] ?? step1Details ?? step1Res) as Record<string, unknown>;
-        const refinedPrompt = asString(
-          step1Json[promptKey] ?? step1Json['image_prompt'] ?? step1Json['video_prompt'] ?? step1Json['prompt'] ?? prompt
-        ).trim();
+          try {
+            const step1Res = await toolsInvoke<unknown>(api, {
+              tool: 'llm-task',
+              action: 'json',
+              args: { prompt: step1Prompt, timeoutMs: 60000 },
+            });
+            const step1Rec = asRecord(step1Res);
+            const step1Details = asRecord(step1Rec['details']);
+            const step1Json = (step1Details['json'] ?? step1Details ?? step1Res) as Record<string, unknown>;
+            const extracted = asString(
+              step1Json[promptKey] ?? step1Json['image_prompt'] ?? step1Json['video_prompt'] ?? step1Json['prompt']
+            ).trim();
+            if (extracted) refinedPrompt = extracted;
+          } catch {
+            // Prompt refinement failed — fall through with original prompt
+          }
+        }
+
+        if (!refinedPrompt) throw new Error('Empty prompt for media generation');
 
-        if (!refinedPrompt) throw new Error('LLM returned empty refined prompt');
+        // Truncate prompt to stay within DALL-E 3's 4000 char limit
+        const MAX_IMAGE_PROMPT_LEN = 3800; // leave headroom
+        if (mediaType === 'image' && refinedPrompt.length > MAX_IMAGE_PROMPT_LEN) {
+          refinedPrompt = refinedPrompt.slice(0, MAX_IMAGE_PROMPT_LEN).replace(/\s+\S*$/, '') + '...';
+        }
 
         // ── Step 2: Invoke the skill script to generate actual media ─────
-        const skillName = provider.replace(/^skill-/, '');
         const homedir = process.env.HOME || '/home/control';
-
-        // Search for the skill's executable script
-        const skillSearchDirs = [
-          path.join(homedir, '.openclaw', 'skills', skillName),
-          path.join(homedir, '.openclaw', 'workspace', 'skills', skillName),
+        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 = '';
-        for (const dir of skillSearchDirs) {
-          const candidates = [`generate_image.sh`, `generate_video.sh`, `generate.sh`];
-          for (const c of candidates) {
-            const p = path.join(dir, c);
-            try { await fs.access(p); scriptPath = p; break; } catch { /* skip */ }
+        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;
+          }
+        }
+
+        // 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;
           }
-          if (scriptPath) break;
         }
 
+        const skillSearchDirs = providerSkill
+          ? skillRoots.map(r => path.join(r, providerSkill))
+          : skillRoots;
+
         let payload: Record<string, unknown>;
         if (scriptPath) {
-          // Run the skill script directly with the refined prompt
+          // 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);
+            if (cfgParsed?.env && typeof cfgParsed.env === 'object') {
+              configEnv = Object.fromEntries(
+                Object.entries(cfgParsed.env).filter(([, v]) => typeof v === 'string')
+              ) as Record<string, string>;
+            }
+          } catch { /* config read failed — proceed with process.env only */ }
+
+          const runner = scriptPath.endsWith('.py') ? 'python3' : 'bash';
           const scriptOutput = execSync(
-            `bash ${JSON.stringify(scriptPath)} ${JSON.stringify(refinedPrompt)}`,
-            { cwd: mediaDir, timeout: timeoutMs, encoding: 'utf8', env: { ...process.env, HOME: homedir } }
+            `${runner} ${JSON.stringify(scriptPath)}`,
+            { cwd: mediaDir, timeout: timeoutMs, encoding: 'utf8', input: refinedPrompt, env: { ...process.env, ...configEnv, HOME: homedir } }
           ).trim();
 
           // Parse the output — skill scripts print "MEDIA:/path/to/file"
@@ -1006,7 +1103,10 @@ export async function runWorkflowWorkerTick(api: OpenClawPluginApi, opts: {
         }
         text = JSON.stringify(payload, null, 2);
       } catch (e) {
-        const errMsg = `Media generation failed for node ${nodeLabel(node)}: ${e instanceof Error ? e.message : String(e)}`;
+        const errDetails = e instanceof Error
+          ? { message: e.message, name: e.name, stack: e.stack?.split('\n').slice(0, 5).join(' | ') }
+          : { message: String(e) };
+        const errMsg = `Media generation failed for node ${nodeLabel(node)}: ${JSON.stringify(errDetails)}`;
         const errorTs = new Date().toISOString();
         await appendRunLog(runPath, (cur) => ({
           ...cur,