Media Generation Setup

openclaw recipes workflows media-drivers

┌─────────────────────────────────────────────────────┐
│  ClawKitchen (UI)                                   │
│  GET /api/teams/:id/media-providers                 │
│       │                                             │
│       ├─ CLI call → ClawRecipes driver registry     │
│       ├─ Auto-discover unknown skills (fallback)    │
│       └─ HTTP probes (Stable Diffusion, ComfyUI)    │
└─────────────────────────────────────────────────────┘
         │
         ▼
┌─────────────────────────────────────────────────────┐
│  ClawRecipes (Runtime)                              │
│  media-drivers/registry.ts                          │
│       │                                             │
│       ├─ NanoBananaPro   (GEMINI_API_KEY)           │
│       ├─ OpenAIImageGen  (OPENAI_API_KEY)           │
│       ├─ RunwayVideo     (RUNWAYML_API_SECRET)      │
│       ├─ KlingVideo      (KLING_API_KEY)            │
│       ├─ LumaVideo       (LUMAAI_API_KEY)           │
│       └─ GenericDriver   (auto-discover fallback)   │
└─────────────────────────────────────────────────────┘

{
  "env": {
    "vars": {
      "GEMINI_API_KEY": "AIza...",
      "OPENAI_API_KEY": "sk-...",
      "RUNWAYML_API_SECRET": "runway-secret",
      "KLING_API_KEY": "kling-key",
      "LUMAAI_API_KEY": "luma-key"
    }
  }
}

Create a marketing image for: {{draft_assets.image_brief}}

~/.openclaw/workspace/skills/my-provider/
├── _meta.json
├── SKILL.md
├── generate_image.py      # or generate_video.py / generate_audio.py
└── .venv/                  # Python venv with dependencies

{
  "name": "my-provider",
  "version": "1.0.0",
  "description": "My custom image generator"
}

# My Provider

## Requirements
- `MY_PROVIDER_API_KEY` — API key from my-provider.com

#!/usr/bin/env python3
"""Media generation script for my-provider."""
import os
import sys

def main():
    # Read prompt from stdin
    prompt = sys.stdin.read().strip()
    if not prompt:
        print("No prompt provided", file=sys.stderr)
        sys.exit(1)

    # Get API key from environment
    api_key = os.environ.get("MY_PROVIDER_API_KEY")
    if not api_key:
        print("MY_PROVIDER_API_KEY not set", file=sys.stderr)
        sys.exit(1)

    # Get output directory (set by workflow worker)
    output_dir = os.environ.get("MEDIA_OUTPUT_DIR", os.getcwd())
    output_path = os.path.join(output_dir, "output.png")

    # --- Your generation logic here ---
    # Call your API, download the image, save to output_path
    # ...

    # Print the MEDIA: path — this is how the worker finds the file
    print(f"MEDIA:{output_path}")

if __name__ == "__main__":
    main()

cd ~/.openclaw/workspace/skills/my-provider
uv venv
uv pip install your-sdk-package
chmod +x generate_image.py

#!/path/to/skill/.venv/bin/python

ClawRecipes/src/lib/workflows/media-drivers/my-provider.driver.ts

import * as path from 'path';
import { MediaDriver, MediaDriverInvokeOpts, MediaDriverResult } from './types';
import { findSkillDir, findVenvPython, runScript, parseMediaOutput } from './utils';

export class MyProvider implements MediaDriver {
  slug = 'my-provider';
  mediaType = 'image' as const;                // 'image' | 'video' | 'audio'
  displayName = 'My Provider (Custom)';
  requiredEnvVars = ['MY_PROVIDER_API_KEY'];    // checked for dropdown availability

  async invoke(opts: MediaDriverInvokeOpts): Promise<MediaDriverResult> {
    const { prompt, outputDir, env, timeout } = opts;

    const skillDir = await findSkillDir(this.slug);
    if (!skillDir) throw new Error(`Skill dir not found for ${this.slug}`);

    const scriptPath = path.join(skillDir, 'generate_image.py');
    const runner = await findVenvPython(skillDir);

    const scriptOutput = runScript({
      runner,
      script: scriptPath,
      stdin: prompt,          // or use args: ['--prompt', prompt]
      env: { ...env, HOME: process.env.HOME || '/home/control' },
      cwd: outputDir,
      timeout,
    });

    const filePath = parseMediaOutput(scriptOutput);
    if (!filePath) throw new Error(`No MEDIA: path in output: ${scriptOutput}`);

    return { filePath, metadata: { skill: this.slug, prompt } };
  }
}

import { MyProvider } from './my-provider.driver';

const knownDrivers: MediaDriver[] = [
  new NanoBananaPro(),
  new OpenAIImageGen(),
  // ...existing drivers...
  new MyProvider(),   // ← add here
];

{ "env": { "vars": { "MY_PROVIDER_API_KEY": "..." } } }

interface MediaDriver {
  slug: string;                        // Skill folder name
  mediaType: 'image' | 'video' | 'audio';
  displayName: string;                 // Shown in UI dropdown
  requiredEnvVars: string[];           // Checked for availability

  invoke(opts: MediaDriverInvokeOpts): Promise<MediaDriverResult>;
}

interface MediaDriverInvokeOpts {
  prompt: string;                      // The generation prompt
  outputDir: string;                   // Where to write output files
  env: Record<string, string>;         // Merged env vars
  timeout: number;                     // Max execution time (ms)
  config?: Record<string, unknown>;    // Node-level config overrides
}

interface MediaDriverResult {
  filePath: string;                    // Path to generated file
  metadata?: Record<string, unknown>;  // Optional debug/tracking info
}