lcode-cli 0.44.0__tar.gz → 0.45.0__tar.gz

{lcode_cli-0.44.0 → lcode_cli-0.45.0}/CHANGELOG.md

@@ -6,6 +6,19 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.45.0] - 2026-10-24
+
+### Added
+
+- **Video mode: first and last frames, camera moves, longer clips** (#154, part 1). See
+  [Video mode](https://nasser1941.github.io/lcode/modes/#video-mode).
+  - **`@start.png @end.png …`** makes a clip from one picture to the other (Wan 2.2 Fun InP 5B).
+  - **`--camera pan-left`** and twelve other moves (pan, tilt, zoom, dolly, rotate), from a
+    description or a start picture (Wan 2.1 Fun Camera 1.3B, 16 fps).
+  - **`/extend 4 --seconds 3 …`** in video mode continues a clip from its last frame into one
+    longer clip.
+  - lcode picks the model a job needs, installs it when you agree, and says so.
+
 ## [0.44.0] - 2026-10-24
 
 ### Added
@@ -969,7 +982,8 @@ First public release.
 - `AGENTS.md` project instructions and `/init` to generate them.
 - One-line installer for Linux and macOS.
 
-[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.44.0...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.45.0...HEAD
+[0.45.0]: https://github.com/nasser1941/lcode/compare/v0.44.0...v0.45.0
 [0.44.0]: https://github.com/nasser1941/lcode/compare/v0.43.0...v0.44.0
 [0.43.0]: https://github.com/nasser1941/lcode/compare/v0.42.0...v0.43.0
 [0.42.0]: https://github.com/nasser1941/lcode/compare/v0.41.0...v0.42.0

{lcode_cli-0.44.0 → lcode_cli-0.45.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.44.0
+Version: 0.45.0
 Summary: A local-first terminal coding agent powered by open-weight models on your own GPU or Mac, via Ollama.
 Project-URL: Homepage, https://nasser1941.github.io/lcode/
 Project-URL: Documentation, https://nasser1941.github.io/lcode/

{lcode_cli-0.44.0 → lcode_cli-0.45.0}/docs/modes.md

@@ -167,6 +167,18 @@ video ❯ /play
   description and start image.
 - **Measured** on the RTX 4080 Laptop GPU (12 GB), a 5-second clip (121 frames): `fast` 100 s,
   `balanced` 150 s (the same from a start image), `best` 10.5 minutes.
+- **First and last frame:** two pictures, `@start.png @end.png the flower opens`, make a clip that
+  goes from the first to the last. Wan 2.2 Fun InP 5B makes these (a 3 s clip in 62 s at `fast`;
+  `fast` can change abruptly halfway, `balanced` moves more smoothly).
+- **Camera moves:** `--camera pan-left` (also `pan-right`, `pan-up`, `pan-down`, `tilt-up`,
+  `tilt-down`, `zoom-in`, `zoom-out`, `dolly-in`, `dolly-out`, `rotate-left`, `rotate-right`,
+  `static`), from a description or a start picture. Wan 2.1 Fun Camera 1.3B makes these, at 832×480
+  and 16 frames per second: a 3 s move takes about 2 minutes.
+- **Extend a clip:** `/extend 4 --seconds 3 it flies away` continues clip #4 from its last frame
+  and joins the new part after it, as one longer clip (`…-extended.mp4`; 3 s more in about a
+  minute at `fast`).
+- **Which model:** the one you chose (`/models`) makes ordinary clips. For first and last frames or a
+  camera move, lcode uses the model that can, installs it when you agree, and says so.
 - **Long renders:** progress shows the step and the time left. With `notify` on, lcode sends a
   desktop notification when a clip that took longer than `notify_after` seconds is done.
 
@@ -266,8 +278,8 @@ themselves:
 
 ## Coming next
 
-- **#154 More video:** first and last frames, several references, camera moves, longer clips,
-  sound, and more video models in the catalog.
+- **#154 More video:** several reference images, smoother and bigger clips (frame interpolation,
+  upscaling), restyling a video, and sound.
 - **#155 Movies:** storyboards with a consistent cast, shots stitched into one film.
 - **#156 Prompt assistant:** a small local model for prompts and follow-ups.
 - **#157 Cloud generation**, with costs shown (Grok Imagine first).

{lcode_cli-0.44.0 → lcode_cli-0.45.0}/docs/quickstart.md

@@ -12,7 +12,7 @@ lcode
 
 ```text
 ╭──────────────────────────────────────────────╮
-│ lcode v0.44.0 — local coding agent           │
+│ lcode v0.45.0 — local coding agent           │
 │                                              │
 │ model    lcode-qwen3.6-35b                   │
 │ context  256K tokens                         │

{lcode_cli-0.44.0 → lcode_cli-0.45.0}/src/lcode/__init__.py

@@ -3,7 +3,7 @@
 From a program: `from lcode import Session` (see lcode.api).
 """
 
-__version__ = "0.44.0"
+__version__ = "0.45.0"
 
 API = ("Session", "Result", "Options", "SetupError")
 

{lcode_cli-0.44.0 → lcode_cli-0.45.0}/src/lcode/imageopts.py

@@ -35,6 +35,21 @@ STYLES = {
     "comic": "comic book art, bold ink outlines, halftone shading",
     "flat": "flat vector illustration, minimal, bold shapes",
 }
+CAMERA = {  # video: --camera name -> the camera model's pose
+    "static": "Static",
+    "pan-left": "Pan Left",
+    "pan-right": "Pan Right",
+    "pan-up": "Pan Up",
+    "pan-down": "Pan Down",
+    "tilt-up": "Pan Up",
+    "tilt-down": "Pan Down",
+    "zoom-in": "Zoom In",
+    "zoom-out": "Zoom Out",
+    "dolly-in": "Zoom In",
+    "dolly-out": "Zoom Out",
+    "rotate-left": "Anti Clockwise (ACW)",
+    "rotate-right": "ClockWise (CW)",
+}
 ALIASES = {
     "n": "n",
     "count": "n",
@@ -49,6 +64,7 @@ ALIASES = {
     "style": "style",
     "seconds": "seconds",
     "duration": "seconds",
+    "camera": "camera",
 }
 FLAG = re.compile(r"(?:^|\s)--?(" + "|".join(sorted(ALIASES, key=len, reverse=True)) + r")\b(?=[\s=]|$)")
 DIMENSIONS = re.compile(r"^(\d{2,4})\s*[x×]\s*(\d{2,4})$")
@@ -68,12 +84,15 @@ class Options:
     negative: str = ""
     style: str = ""
     seconds: float = 5.0  # video only
+    camera: str = ""  # video only: a move from CAMERA, made by a camera-control model
 
     def describe(self, video: bool = False) -> str:
         seed = "random" if self.seed is None else str(self.seed)
         parts = [f"n={self.n}", f"size={self.size}", f"seed={seed}", f"quality={self.quality}"]
         if video:
             parts.append(f"seconds={self.seconds:g}")
+            if self.camera:
+                parts.append(f"camera={self.camera}")
         if self.style:
             parts.append(f"style={self.style}")
         if self.negative:
@@ -98,7 +117,9 @@ def set_values(options: Options, values: dict[str, object]) -> Options:
     for raw_key, raw in values.items():
         key = ALIASES.get(str(raw_key).lower().lstrip("-"))
         if key is None:
-            raise OptionError(f"unknown option {raw_key!r}: use n, ar (or size), seed, quality, style, no or seconds")
+            raise OptionError(
+                f"unknown option {raw_key!r}: use n, ar (or size), seed, quality, style, no, seconds or camera"
+            )
         value = str(raw).strip() if raw is not None else ""
         if key == "n":
             if not value.isdigit() or not 1 <= int(value) <= MAX_COUNT:
@@ -126,6 +147,13 @@ def set_values(options: Options, values: dict[str, object]) -> Options:
                 raise OptionError(f"style is one of {', '.join(STYLES)} (or none)")
         elif key == "negative":
             out.negative = "" if value.lower() in ("none", "off") else value
+        elif key == "camera":
+            if value.lower() in ("none", "off", ""):
+                out.camera = ""
+            elif value.lower() in CAMERA:
+                out.camera = value.lower()
+            else:
+                raise OptionError(f"camera is one of {', '.join(CAMERA)} (or none)")
         elif key == "seconds":
             try:
                 seconds = float(value.rstrip("s"))

{lcode_cli-0.44.0 → lcode_cli-0.45.0}/src/lcode/media.py

@@ -292,7 +292,7 @@ def request(
     if agent.settings.mode == "video":
         if mask:
             raise MediaError("Video mode doesn't take a mask: @photo.png starts a video from a picture.")
-        job = {"kind": "video", "prompt": prompt, "options": options, "sources": [str(p) for p in sources[:1]],
+        job = {"kind": "video", "prompt": prompt, "options": options, "sources": [str(p) for p in sources[:2]],
                "mask": None, "pads": None, "keep_shape": not SIZE_FLAG.search(text)}  # fmt: skip
         return redo(agent, job, cancelled, ask)
     job = {"kind": "edit" if sources else "image", "prompt": prompt, "options": options,
@@ -488,10 +488,14 @@ def generate_video(
     image (the shapes video models know best; the image is cropped to it), unless the request gives one."""
     prompt = job["prompt"].strip()
     server = prepare(agent, ask, cancelled)
-    model = current(agent, "video")
+    sources = [Path(p) for p in job.get("sources") or []]
+    start = sources[0] if sources else None
+    end = sources[1] if len(sources) > 1 else None
+    clip = Path(job["extend"]) if job.get("extend") else None
+    model = video_model(agent, "first-last-frame" if end else ("camera" if options.camera else
+                        ("image-to-video" if clip else "")))  # fmt: skip
     files = ensure_installed(agent, model, server, ask)
     workflow = comfy.load_workflow(model.workflow)
-    start = Path(job["sources"][0]) if job.get("sources") else None
     seed = options.seed if options.seed is not None else random.randrange(2**32)
     steps, megapixels = model.preset(options.quality)
     ratio = options.size
@@ -504,6 +508,8 @@ def generate_video(
             except (OSError, edits.EditError):
                 pass
     width, height = imageopts.dimensions(imageopts.SIZES.get(ratio, ratio), megapixels, multiple=32)
+    if clip is not None:  # the new part continues the clip, so it has its size
+        width, height = job["size"]
     fps = int(workflow.defaults.get("fps", 24))
     text = imageopts.styled(prompt, options.style)
     values = {**workflow.defaults, **files, "prompt": text, "seed": seed, "width": width, "height": height,
@@ -512,26 +518,70 @@ def generate_video(
         values["steps"] = steps
     if options.negative:
         values["negative"] = options.negative
+    values["camera"] = imageopts.CAMERA[options.camera or "static"]
     graph = comfy.fill(workflow.graph, values)
-    if start is not None:
-        try:
-            name = server.upload(start)
-        except (comfy.ComfyError, OSError) as e:
-            raise MediaError(f"Couldn't hand the image to ComfyUI: {e}") from e
-        latent = edits.node_of(graph, "Wan22ImageToVideoLatent")
-        if latent is None:
-            raise MediaError(f"{model.name} can't start from an image.")
-        graph["8100"] = {"class_type": "LoadImage", "inputs": {"image": name}}
-        graph[latent]["inputs"]["start_image"] = ["8100", 0]
+    latent = next((edits.node_of(graph, c) for c in VIDEO_LATENTS if edits.node_of(graph, c)), None)
+    try:
+        if start is not None:
+            graph["8100"] = {"class_type": "LoadImage", "inputs": {"image": server.upload(start)}}
+            graph[latent]["inputs"]["start_image"] = ["8100", 0]
+            loader = edits.node_of(graph, "CLIPVisionLoader")
+            if loader is not None:  # the camera model also looks at the start image
+                look = {"clip_vision": [loader, 0], "image": ["8100", 0], "crop": "none"}
+                graph["8102"] = {"class_type": "CLIPVisionEncode", "inputs": look}
+                graph[latent]["inputs"]["clip_vision_output"] = ["8102", 0]
+        if end is not None:
+            graph["8101"] = {"class_type": "LoadImage", "inputs": {"image": server.upload(end)}}
+            graph[latent]["inputs"]["end_image"] = ["8101", 0]
+        if clip is not None:
+            continue_clip(graph, latent, server.upload(clip), values["length"])
+    except (comfy.ComfyError, OSError) as e:
+        raise MediaError(f"Couldn't hand the files to ComfyUI: {e}") from e
     add_thumbnail(graph, width, height)
     meta = describe_job(model, workflow, prompt, text, seed, values, options, files)
     meta.update({"seconds": round((values["length"] - 1) / fps, 2), "fps": fps, "frames": values["length"],
-                 "start_image": shown(agent, start) if start else ""})  # fmt: skip
-    remembered = {k: job.get(k) for k in ("kind", "prompt", "sources", "mask", "pads", "keep_shape")}
-    plan = Plan(model, workflow, graph, meta, prompt, seed, options, "video", job.get("sources") or [], remembered)
+                 "start_image": shown(agent, start) if start else "", "end_image": shown(agent, end) if end else "",
+                 "camera": options.camera, "extends": shown(agent, clip) if clip else ""})  # fmt: skip
+    remembered = {k: job.get(k) for k in ("kind", "prompt", "sources", "mask", "pads", "keep_shape", "extend", "size")}
+    stem = f"{clip.stem}-extended" if clip else ""
+    plan = Plan(model, workflow, graph, meta, prompt, seed, options, "video", job.get("sources") or [], remembered,
+                stem)  # fmt: skip
     return run_plan(agent, server, plan, cancelled, label)
 
 
+VIDEO_LATENTS = ("Wan22ImageToVideoLatent", "WanFunInpaintToVideo", "WanCameraImageToVideo")
+WHY = {
+    "first-last-frame": "a clip between two frames",
+    "camera": "a camera move",
+    "image-to-video": "continuing a clip",
+}
+
+
+def video_model(agent: Agent, task: str) -> catalog.MediaModel:
+    """The video model for a job: the chosen one, or the first that does what the job needs."""
+    chosen = current(agent, "video")
+    if not task or task in chosen.tasks:
+        return chosen
+    model = catalog.load().for_task("video", task)
+    if model is None:
+        raise MediaError(f"None of lcode's video models does {WHY.get(task, task)} yet.")
+    agent.say(f"{model.name} makes this one ({WHY.get(task, task)}).")
+    return model
+
+
+def continue_clip(graph: dict, latent: str, clip_name: str, length: int) -> None:
+    """Extending a clip: start from its last frame, and join the new frames (without that first one) after it."""
+    graph["8200"] = {"class_type": "LoadVideo", "inputs": {"file": clip_name}}
+    graph["8201"] = {"class_type": "GetVideoComponents", "inputs": {"video": ["8200", 0]}}
+    graph["8202"] = {"class_type": "ImageFromBatch", "inputs": {"image": ["8201", 0], "batch_index": -1, "length": 1}}
+    graph[latent]["inputs"]["start_image"] = ["8202", 0]
+    video = edits.node_of(graph, "CreateVideo")
+    decoded = graph[video]["inputs"]["images"]
+    graph["8203"] = {"class_type": "ImageFromBatch", "inputs": {"image": decoded, "batch_index": 1, "length": length}}
+    graph["8204"] = {"class_type": "ImageBatch", "inputs": {"image1": ["8201", 0], "image2": ["8203", 0]}}
+    graph[video]["inputs"]["images"] = ["8204", 0]
+
+
 def apply_tool(
     agent: Agent,
     task: str,

{lcode_cli-0.44.0 → lcode_cli-0.45.0}/src/lcode/media.toml

@@ -146,3 +146,53 @@ measured = "5 s clip: 100 s fast, 150 s balanced (864×480), 10.5 min best (1280
 notes = "5 s at 24 fps, up to 1280×704; text or a start image"
 quality = { fast = [12, 0.4], balanced = [20, 0.4], best = [30, 0.859] }
 negative = true
+
+[files.wan22-fun-inp-5b]
+folder = "diffusion_models"
+name = "wan2.2_fun_inpaint_5B_bf16.safetensors"
+url = "https://huggingface.co/Comfy-Org/Wan_2.2_ComfyUI_Repackaged/resolve/main/split_files/diffusion_models/wan2.2_fun_inpaint_5B_bf16.safetensors"
+gb = 10.00
+
+[files.wan21-fun-camera-1-3b]
+folder = "diffusion_models"
+name = "wan2.1_fun_camera_v1.1_1.3B_bf16.safetensors"
+url = "https://huggingface.co/Comfy-Org/Wan_2.1_ComfyUI_repackaged/resolve/main/split_files/diffusion_models/wan2.1_fun_camera_v1.1_1.3B_bf16.safetensors"
+gb = 3.23
+
+[files.clip-vision-h]
+folder = "clip_vision"
+name = "clip_vision_h.safetensors"
+url = "https://huggingface.co/Comfy-Org/Wan_2.1_ComfyUI_repackaged/resolve/main/split_files/clip_vision/clip_vision_h.safetensors"
+gb = 1.26
+
+[files.wan21-vae]
+folder = "vae"
+name = "wan_2.1_vae.safetensors"
+url = "https://huggingface.co/Comfy-Org/Wan_2.1_ComfyUI_repackaged/resolve/main/split_files/vae/wan_2.1_vae.safetensors"
+gb = 0.25
+
+[models.wan22-fun-inp-5b]
+name = "Wan 2.2 Fun InP 5B"
+mode = "video"
+publisher = "Alibaba PAI"
+license = "Apache 2.0"
+tasks = ["first-last-frame"]
+workflow = "wan22-fun-inp-5b"
+files = { model = "wan22-fun-inp-5b", text_encoder = "umt5-xxl-fp8", vae = "wan22-vae" }
+measured = "3 s clip, fast: 62 s (864×480) on an RTX 4080 Laptop, 12 GB"
+notes = "a clip from a first frame to a last frame: @start.png @end.png"
+quality = { fast = [12, 0.4], balanced = [20, 0.4], best = [30, 0.859] }
+negative = true
+
+[models.wan21-fun-camera-1-3b]
+name = "Wan 2.1 Fun Camera 1.3B"
+mode = "video"
+publisher = "Alibaba PAI"
+license = "Apache 2.0"
+tasks = ["camera"]
+workflow = "wan21-fun-camera"
+files = { model = "wan21-fun-camera-1-3b", text_encoder = "umt5-xxl-fp8", vae = "wan21-vae", clip_vision = "clip-vision-h" }
+measured = "3 s clip (49 frames, 832×480): 115 s on an RTX 4080 Laptop, 12 GB"
+notes = "camera moves (--camera pan-left, zoom-in, …), small and fast, 16 fps"
+quality = { fast = [12, 0.38], balanced = [20, 0.38], best = [30, 0.38] }
+negative = true

{lcode_cli-0.44.0 → lcode_cli-0.45.0}/src/lcode/media_catalog.py

@@ -112,6 +112,10 @@ class Catalog:
     def for_mode(self, mode: str) -> list[MediaModel]:
         return [m for m in self.models.values() if m.mode == mode]
 
+    def for_task(self, mode: str, task: str) -> MediaModel | None:
+        """The first model of a mode that does a task (first-last-frame, camera, image-to-video…)."""
+        return next((m for m in self.for_mode(mode) if task in m.tasks), None)
+
     def tool(self, task: str) -> MediaModel:
         """The tool for a task (upscale, remove-background)."""
         return next(m for m in self.models.values() if m.mode == "tool" and task in m.tasks)

{lcode_cli-0.44.0 → lcode_cli-0.45.0}/src/lcode/repl.py

@@ -86,7 +86,7 @@ COMMANDS = {
     "/open": "Open an image in your viewer, e.g. /open 3 (default: the last)",
     "/edit": "Image mode: change an image by instruction, e.g. /edit 3 make the sky purple (@photo.png: references)",
     "/use": "Image mode: images the next requests follow, e.g. /use 3 or /use photo.png (/use off)",
-    "/extend": "Image mode: outpaint an image to a shape or by sides, e.g. /extend 3 --ar 16:9 (or --left 256)",
+    "/extend": "Outpaint an image (/extend 3 --ar 16:9), or continue a clip in video mode (/extend 4 --seconds 3)",
     "/upscale": "Image mode: 2 or 4 times the pixels, e.g. /upscale 3 4",
     "/nobg": "Image mode: remove the background (a transparent PNG), e.g. /nobg 3",
     "/animate": "Image mode: make a video starting from an image, e.g. /animate 3 the waves roll in (video mode)",
@@ -1406,7 +1406,7 @@ IMAGE_COMMANDS = (
     "/options", "/again", "/vary", "/gallery", "/open", "/play", "/edit", "/use", "/extend", "/upscale", "/nobg",
     "/animate",
 )  # fmt: skip
-VIDEO_TOO = ("/options", "/again", "/vary", "/gallery", "/open", "/play", "/use")  # what video mode shares
+VIDEO_TOO = ("/options", "/again", "/vary", "/gallery", "/open", "/play", "/use", "/extend")  # video mode has these
 NUMBER = re.compile(r"^#?(\d+)$")
 
 
@@ -1495,6 +1495,17 @@ def image_command(agent: Agent, cmd: str, arg: str) -> None:
                    "pads": None, "keep_shape": "--ar" not in rest and "--size" not in rest}  # fmt: skip
             make_image(agent, run=lambda cancel, ask: media.redo(agent, job, cancel, ask))
             return
+        if cmd == "/extend" and video:
+            if edits.is_image(source):
+                c.print(f"[yellow]#{entry['n']} is a picture: /animate it, or /extend a clip.[/]")
+                return
+            text, options = imageopts.parse(rest, imageopts.replace_seed(agent.image_options, n=1))
+            job = {"kind": "video", "prompt": text or entry["prompt"], "options": options, "sources": [],
+                   "mask": None, "pads": None, "keep_shape": True, "extend": str(source),
+                   "size": [entry["width"], entry["height"]]}  # fmt: skip
+            c.print(f"[dim]Continuing #{entry['n']} from its last frame, {options.seconds:g} s more.[/]")
+            make_image(agent, run=lambda cancel, ask: media.redo(agent, job, cancel, ask))
+            return
         if cmd == "/extend":
             width, height = edits.image_size(source)
             pads, text = edits.parse_extend(rest, width, height)

lcode_cli-0.45.0/src/lcode/workflows/wan21-fun-camera.json

@@ -0,0 +1,186 @@
+{
+  "source": "ComfyUI's template video_wan2.1_fun_camera_v1.1_1.3B, in API format (lcode adds a start image when given)",
+  "defaults": {
+    "width": 832,
+    "height": 480,
+    "length": 81,
+    "fps": 16,
+    "steps": 20,
+    "negative": "色调艳丽，过曝，静态，细节模糊不清，字幕，风格，作品，画作，画面，静止，整体发灰，最差质量，低质量，JPEG压缩残留，丑陋的，残缺的，多余的手指，画得不好的手部，画得不好的脸部，畸形的，毁容的，形态畸形的肢体，手指融合，静止不动的画面，杂乱的背景，三条腿，背景人很多，倒着走",
+    "camera": "Static",
+    "speed": 1.0
+  },
+  "labels": {
+    "1": "loading the model",
+    "2": "loading the text encoder",
+    "3": "loading the VAE",
+    "5": "reading the prompt",
+    "6": "reading the prompt",
+    "7": "planning the camera move",
+    "8": "preparing the frames",
+    "9": "drawing the frames",
+    "10": "decoding the frames",
+    "11": "making the video",
+    "12": "saving"
+  },
+  "graph": {
+    "1": {
+      "class_type": "UNETLoader",
+      "inputs": {
+        "unet_name": "$model",
+        "weight_dtype": "default"
+      }
+    },
+    "2": {
+      "class_type": "CLIPLoader",
+      "inputs": {
+        "clip_name": "$text_encoder",
+        "type": "wan",
+        "device": "default"
+      }
+    },
+    "3": {
+      "class_type": "VAELoader",
+      "inputs": {
+        "vae_name": "$vae"
+      }
+    },
+    "4": {
+      "class_type": "ModelSamplingSD3",
+      "inputs": {
+        "model": [
+          "1",
+          0
+        ],
+        "shift": 8
+      }
+    },
+    "5": {
+      "class_type": "CLIPTextEncode",
+      "inputs": {
+        "text": "$prompt",
+        "clip": [
+          "2",
+          0
+        ]
+      }
+    },
+    "6": {
+      "class_type": "CLIPTextEncode",
+      "inputs": {
+        "text": "$negative",
+        "clip": [
+          "2",
+          0
+        ]
+      }
+    },
+    "7": {
+      "class_type": "WanCameraEmbedding",
+      "inputs": {
+        "camera_pose": "$camera",
+        "width": "$width",
+        "height": "$height",
+        "length": "$length",
+        "speed": "$speed",
+        "fx": 0.5,
+        "fy": 0.5,
+        "cx": 0.5,
+        "cy": 0.5
+      }
+    },
+    "8": {
+      "class_type": "WanCameraImageToVideo",
+      "inputs": {
+        "positive": [
+          "5",
+          0
+        ],
+        "negative": [
+          "6",
+          0
+        ],
+        "vae": [
+          "3",
+          0
+        ],
+        "width": "$width",
+        "height": "$height",
+        "length": "$length",
+        "batch_size": 1,
+        "camera_conditions": [
+          "7",
+          0
+        ]
+      }
+    },
+    "9": {
+      "class_type": "KSampler",
+      "inputs": {
+        "model": [
+          "4",
+          0
+        ],
+        "seed": "$seed",
+        "steps": "$steps",
+        "cfg": 6,
+        "sampler_name": "uni_pc",
+        "scheduler": "simple",
+        "positive": [
+          "8",
+          0
+        ],
+        "negative": [
+          "8",
+          1
+        ],
+        "latent_image": [
+          "8",
+          2
+        ],
+        "denoise": 1
+      }
+    },
+    "10": {
+      "class_type": "VAEDecode",
+      "inputs": {
+        "samples": [
+          "9",
+          0
+        ],
+        "vae": [
+          "3",
+          0
+        ]
+      }
+    },
+    "11": {
+      "class_type": "CreateVideo",
+      "inputs": {
+        "images": [
+          "10",
+          0
+        ],
+        "fps": "$fps"
+      }
+    },
+    "12": {
+      "class_type": "SaveVideo",
+      "inputs": {
+        "video": [
+          "11",
+          0
+        ],
+        "filename_prefix": "lcode/video",
+        "format": "mp4",
+        "codec": "auto"
+      }
+    },
+    "13": {
+      "class_type": "CLIPVisionLoader",
+      "inputs": {
+        "clip_name": "$clip_vision"
+      }
+    }
+  }
+}