canvas-core

name	canvas-core
description	Build, edit, and run Lumen Studio workflows on the canvas.
trigger	workflow, canvas, video generation, write_canvas, run_canvas_node

Lumen Workflow Core

Use this skill before creating, editing, or running a Lumen Studio canvas.

Canvas Model

A canvas is a JSON object:

{
  "nodes": [
    {
      "id": "text-unique-id",
      "type": "lumenNode",
      "position": { "x": 0, "y": 0 },
      "data": {
        "kind": "text",
        "title": "Script",
        "prompt": "Write a short UGC script...",
        "output": null,
        "modelId": "gemini-3.5-flash",
        "settings": {},
        "status": "idle",
        "error": null,
        "progress": 0
      }
    }
  ],
  "edges": [
    { "id": "edge-id", "source": "text-unique-id", "target": "image-unique-id", "type": "lumenSmooth", "data": {} }
  ]
}

Supported node kinds: text, image, video, audio, composition.

Default production-backed models:

• text: gemini-3.5-flash
• image: nano-banana2
• video: veo-3.1 or seedance-1.5-pro (Volcengine Ark; supports first/last frame i2v)
• audio: fish-tts
• composition: lumen-composition (timeline stitch / trim / split / BGM export)

Video model selection:

• veo-3.1: Google Veo; best for high-fidelity cinematic shots. Settings: aspectRatio in 1:1|4:5|16:9|9:16, duration in 4|6|8, resolution in 720p|1080p|4k (1080p/4k require 8s). Optional first/last frame via settings.inputImage / settings.inputLastFrameImage or upstream image nodes.
• seedance-1.5-pro: ByteDance Seedance via Volcengine Ark; strong prompt following and camera control. Settings: aspectRatio in 16:9|9:16|1:1|4:3|3:4|21:9, duration in 4-12, resolution in 480p|720p|1080p (default 1080p). Supports first/last frame i2v the same way as Veo. Typical run time ~30-120s.

Audio node models:

• fish-tts (default): voiceover / narration / spoken text-to-speech.
• suno-music: full music / song generation (KIE Suno). Use this when the user asks for background music, a song, a jingle, a soundtrack, or BGM. The node prompt describes the music (style, mood, genre, optional lyrics). Set settings.instrumental: true for an instrumental track with no vocals. A music run takes roughly 60–180s. The output is an audio URL, same as TTS.

Avoid placeholder / non-production models such as doubao-seed-2.0-pro, doubao-seedream-3.0, and doubao-tts unless the user explicitly asks for them. seedance-1.5-pro is production-ready (Volcengine Ark).

For video stitching, trimming, splitting, reordering, or BGM, use a composition node with modelId: lumen-composition and settings.timeline. Load the composition-editing skill before writing or running composition workflows.

Editing Rules

• Use write_canvas for structural changes and pass the complete canvas JSON.
• Preserve nodes and edges that the user did not ask to delete.
• Keep ids stable when modifying existing nodes.
• Use readable ids with kind prefixes, for example text-script-..., image-storyboard-..., video-final-....
• Do not create dangling edges.
• Do not create cycles.
• Use left-to-right positions: strategy/script nodes on the left, image nodes in the middle, video/audio nodes on the right.
• For a one-sentence video request, build a practical pipeline rather than only answering with a script.

Complex Workflow Design

For complex user goals, build a runnable DAG instead of a single long prompt.

Typical layers:

1. Input / source nodes: product brief, URL notes, reference media summary.
2. Strategy nodes: audience, pain points, selling angles, offer.
3. Script nodes: hook, short spoken script, captions, CTA.
4. Visual nodes: one or more image nodes for key frames or scenes.
5. Motion nodes: one video node per important scene or final video output.
6. Audio nodes: voiceover (fish-tts) for spoken script, or music (suno-music) for background music / songs / BGM when needed.
7. Final composition node: for multi-clip output, add one rightmost composition node with modelId: "lumen-composition", connect every source video clip to it, and write settings.timeline.

Rules:

• Split work when intermediate outputs are useful to inspect or reuse.
• Connect every node through explicit edges so downstream nodes receive upstream output.
• Give image/video nodes concise direct prompts. Upstream text is useful context, but the media node prompt must still stand on its own.
• Do not create orphan nodes unless they are deliberate alternatives and clearly titled.
• Prefer 6-12 nodes for a complex product-video workflow; use more only when the user asks for variants, multiple scenes, or batch output.
• Put related nodes on the same horizontal band and use readable titles, for example 卖点策略, 15秒口播, 镜头1主视觉, 镜头1视频.

Multi-scene shot template (required for 2+ clips / composition workflows)

When the deliverable is a stitched multi-scene video (e.g. 15s with 3 beats), repeat this per-scene chain for every clip — do not use one global script for all videos:

text-script-scene-1 ──> image-keyframe-scene-1 ──> video-scene-1 ──┐
text-script-scene-2 ──> image-keyframe-scene-2 ──> video-scene-2 ──┼──> composition-final
text-script-scene-3 ──> image-keyframe-scene-3 ──> video-scene-3 ──┘

Rules for each scene:

1. One text script node per video clip — title like 镜头1脚本 / Scene 1 Script. Edge: text → image and optionally text → video.
2. One image keyframe / reference node per video clip — title like 镜头1参考图. Edge: image → video (required for i2v product shots).
3. One video node per clip — receives edges from its scene's text and image nodes, plus an edge to composition.
4. Optional shared strategy/brief text node at the far left may fan out to each scene script node — never leave that strategy node as the only script with no edges into scene videos.
5. Before write_canvas, verify: every video scene node has at least one incoming edge from a text or image node in the same scene band; zero orphan text/image nodes.

Single-scene videos (no composition) still use text → image → video as one chain.

Single-Node Running

Use run_canvas_node to execute exactly one node.

Important:

• use_skill is only preparation. It never satisfies a run request.
• For every run request, call read_canvas after loading this skill and inspect the current canvas.
• Run upstream nodes first. A node can only run if all direct upstream nodes already have data.output.
• After a node succeeds, its output is saved back to the canvas by the tool.
• If a node fails, summarize the failure and decide whether to edit the node or ask the user.
• Do not call run_canvas_node for a downstream video node until its image/text inputs are ready.
• For a complex workflow, run nodes in topological order. After each successful run, treat the saved canvas output as the source of truth before choosing the next node.
• If a node fails, stop the run plan, explain the failed node, and either edit that node or ask the user for the missing input.
• Do not claim a node has run unless run_canvas_node returned success for that node in the current request.
• If the user says "run until node X", run all missing upstream dependencies for X first, one node per tool call, then run X.

Typical order for a product video:

1. text node: product strategy or short script.
2. image node: key visual / storyboard frame.
3. video node(s): one clip per scene or animate the image.
4. Optional audio node: voiceover or music (BGM).
5. composition node: when there are 2+ scene videos, stitch them into the final MP4. Load composition-editing before writing settings.timeline or running composition.

For a single-scene video with no editing, step 5 is optional.

Tool Use Pattern

Before editing an existing project:

1. Call read_canvas.
2. Build the full updated canvas JSON.
3. Call write_canvas.
4. If the user asked to generate assets, call run_canvas_node one node at a time.

When the user asks for "一句话产出视频", create a small but runnable canvas and run nodes in order.

When the user asks for a complex end-to-end workflow, create the canvas first, then run one ready node at a time until the requested stopping point is reached.