lcode-cli 0.43.0__py3-none-any.whl → 0.45.0__py3-none-any.whl

lcode/__init__.py

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

lcode/agent.py

@@ -309,6 +309,7 @@ class Settings:
     comfyui_path: str | None = None  # a ComfyUI install lcode doesn't find by itself (lcode.comfy)
     media_dir: str = ".lcode/media"  # where image and video mode save their files (lcode.media)
     image_model: str = "flux2-klein-4b"  # the media catalog's model image mode uses (lcode.media_catalog)
+    video_model: str = "wan22-ti2v-5b"  # and video mode's
     preview: str = "auto"  # images in the terminal: auto, kitty, iterm, blocks or off (lcode.preview)
     num_batch: int | None = None
     keep_alive: str = "30m"
@@ -698,6 +699,7 @@ class Agent:
             "model": self.settings.model,
             "mode": self.settings.mode,
             "image_model": self.settings.image_model,
+            "video_model": self.settings.video_model,
             "media": {"results": self.media_results, "options": self.image_options.to_json(), "refs": self.image_refs},
             "name": self.session_name,
             "title": self.session_title,
@@ -749,6 +751,8 @@ class Agent:
             self.settings.mode = data["mode"]  # a session belongs to the mode it was made in
         if isinstance(data.get("image_model"), str):
             self.settings.image_model = data["image_model"]
+        if isinstance(data.get("video_model"), str):
+            self.settings.video_model = data["video_model"]
         media = data.get("media") or {}
         self.media_results = [r for r in media.get("results") or [] if isinstance(r, dict) and "path" in r]
         self.image_options = type(self.image_options).from_json(media.get("options") or {})

lcode/api.py

@@ -201,6 +201,7 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
         comfyui_path=cfg["comfyui_path"],
         media_dir=cfg["media_dir"],
         image_model=cfg["image_model"],
+        video_model=cfg["video_model"],
         preview=cfg["preview"],
         web=switch(options.web, cfg["web"], "on"),
         search_backend=cfg["search_backend"],

lcode/cli.py

@@ -801,16 +801,8 @@ def media_request(agent, prompt: str, out: Console, quiet: bool) -> None:
     """`lcode --mode image -p "…"`: make the image, say where it went (or, with --output json, a result object)."""
     import json
 
-    from lcode import api, media, modes
+    from lcode import api, media
 
-    if agent.settings.mode == "video":
-        message = modes.COMING["video"]
-        if quiet:
-            print(json.dumps({"type": "result", "status": "error", "error": message}), flush=True)
-        else:
-            out.print(f"[yellow]{escape(message)}[/]")
-        api.close_agent(agent)
-        sys.exit(2)
     try:
         made = media.request(agent, prompt)
     except (media.MediaError, KeyboardInterrupt) as e:
@@ -825,7 +817,7 @@ def media_request(agent, prompt: str, out: Console, quiet: bool) -> None:
         result = {
             "type": "result",
             "status": "success",
-            "mode": "image",
+            "mode": agent.settings.mode,
             "files": [str(path) for one in made for path in one.files],
             "model": made[0].model,
             "seed": made[0].seed,
@@ -1106,7 +1098,7 @@ def cmd_media(args) -> None:
     where = (
         f"ComfyUI at {server.url}" if running else (f"{install.path} (not running)" if install else "no ComfyUI found")
     )
-    console.print(f"[dim]{hw.describe()} · {where} · image model: {cfg['image_model']}[/]\n")
+    console.print(f"[dim]{hw.describe()} · {where} · image: {cfg['image_model']} · video: {cfg['video_model']}[/]\n")
     for mode in ("image", "video", "tool"):
         models = cat.for_mode(mode)
         console.print(

lcode/config.py

@@ -46,6 +46,7 @@ SETTINGS: dict[str, tuple[object, type, str]] = {
     "comfyui_path": (None, str, "your ComfyUI folder, if lcode doesn't find it (lcode starts it when needed)"),
     "media_dir": (".lcode/media", str, "where images and videos go: a folder in the project, or an absolute path"),
     "image_model": ("flux2-klein-4b", str, "the model image mode uses: a key from `lcode media`"),
+    "video_model": ("wan22-ti2v-5b", str, "the model video mode uses: a key from `lcode media`"),
     "preview": ("auto", str, "images in the terminal: auto | kitty | iterm | blocks (colour text) | off"),
     "think": (True, bool, "let the model reason before answering (slower, better)"),
     "web": ("on", str, "web search and page fetching for the model: on | ask | off"),
@@ -217,12 +218,12 @@ def coerce(key: str, value: object) -> object:
 
         if value not in PROTOCOLS:
             raise ConfigError(f"preview must be one of {', '.join(PROTOCOLS)}")
-    if key == "image_model":
+    if key in ("image_model", "video_model"):
         from lcode import media_catalog
 
-        keys = [m.key for m in media_catalog.load().for_mode("image")]
+        keys = [m.key for m in media_catalog.load().for_mode(key.removesuffix("_model"))]
         if value not in keys:
-            raise ConfigError(f"image_model must be one of {', '.join(keys)} (see lcode media)")
+            raise ConfigError(f"{key} must be one of {', '.join(keys)} (see lcode media)")
     if typ is bool and isinstance(value, str):
         if value.lower() not in ("true", "false", "1", "0", "yes", "no", "on", "off"):
             raise ConfigError(f"{key} must be true or false")

lcode/imageopts.py

@@ -13,6 +13,7 @@ from dataclasses import asdict, dataclass, replace
 
 QUALITIES = ("fast", "balanced", "best")
 MAX_COUNT = 8
+MAX_SECONDS = 8  # video: longer clips need more memory than a laptop GPU has, and models drift
 SIZES = {  # names for aspect ratios
     "square": "1:1",
     "portrait": "3:4",
@@ -34,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",
@@ -46,6 +62,9 @@ ALIASES = {
     "no": "negative",
     "negative": "negative",
     "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})$")
@@ -64,10 +83,16 @@ class Options:
     quality: str = "balanced"
     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) -> str:
+    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:
@@ -92,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 or no")
+            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:
@@ -120,6 +147,21 @@ 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"))
+            except ValueError:
+                seconds = 0
+            if not 1 <= seconds <= MAX_SECONDS:
+                raise OptionError(f"seconds is how long a video is: 1 to {MAX_SECONDS}")
+            out.seconds = seconds
     return out
 
 
@@ -203,5 +245,10 @@ def replace_seed(options: Options, n: int | None = None) -> Options:
     return replace(options, seed=None, n=n or options.n)
 
 
+def frames(seconds: float, fps: int) -> int:
+    """Frames for a clip: a multiple of 4 plus 1, as video models that compress time 4 to 1 need."""
+    return max(1, round(seconds * fps / 4)) * 4 + 1
+
+
 def styled(prompt: str, style: str) -> str:
     return f"{prompt}, {STYLES[style]}" if style else prompt

lcode/media.py

@@ -27,7 +27,7 @@ from lcode import media_catalog as catalog
 if TYPE_CHECKING:
     from lcode.agent import Agent
 
-SOON = {"video": "Video models come with video generation (#153)."}
+SOON: dict[str, str] = {}
 IGNORED = "# lcode's images and videos: not part of the project unless you add them\n*\n"
 
 
@@ -44,9 +44,11 @@ def installed_lister(agent: Agent) -> catalog.Installed | None:
     return catalog.lister(install=install) if install else None
 
 
-def current(agent: Agent) -> catalog.MediaModel:
-    """The image model the agent uses (the image_model setting, or /model in image mode)."""
+def current(agent: Agent, mode: str | None = None) -> catalog.MediaModel:
+    """The model the agent uses in image or video mode (image_model, video_model, or /model there)."""
     cat = catalog.load()
+    if (mode or agent.settings.mode) == "video":
+        return cat.find(agent.settings.video_model) or cat.models[catalog.DEFAULT_VIDEO]
     return cat.find(agent.settings.image_model) or cat.models[catalog.DEFAULT_IMAGE]
 
 
@@ -61,6 +63,7 @@ class Made:
     prompt: str = ""
     numbers: list[int] = field(default_factory=list)  # in the session's gallery
     thumbnail: bytes = b""  # a small PNG, for the half-block preview
+    poster: bytes = b""  # a video's first frame, for terminals that show pictures
 
 
 # ----------------------------------------------------------------------------- ComfyUI, started and stopped
@@ -227,25 +230,36 @@ def ensure_installed(
 
 
 THUMB_NODES = ("9001", "9002")  # the thumbnail lcode adds to a workflow, for the half-block preview
+POSTER_NODES = ("9003", "9004")  # a video's first frame, picked and kept (not saved) for the preview
 
 
 def add_thumbnail(graph: dict, width: int, height: int) -> None:
-    """Have ComfyUI also make a small copy of the image (not saved, a preview), for the half-block preview."""
+    """Have ComfyUI also make a small copy of the image, or of a video's first frame (not saved, a preview)."""
     save = next((nid for nid, node in graph.items() if node.get("class_type") == "SaveImage"), None)
-    if save is None:
+    video = next((nid for nid, node in graph.items() if node.get("class_type") == "CreateVideo"), None)
+    if save is not None:
+        frames = graph[save]["inputs"]["images"]
+    elif video is not None:
+        first, keep = POSTER_NODES
+        graph[first] = {
+            "class_type": "ImageFromBatch",
+            "inputs": {"image": graph[video]["inputs"]["images"], "batch_index": 0, "length": 1},
+        }
+        graph[keep] = {"class_type": "PreviewImage", "inputs": {"images": [first, 0]}}
+        frames = [first, 0]
+    else:
         return
     tw, th = preview.thumbnail_size(width, height)
     scale, show = THUMB_NODES
     graph[scale] = {
         "class_type": "ImageScale",
-        "inputs": {"image": graph[save]["inputs"]["images"], "upscale_method": "area", "width": tw, "height": th,
-                   "crop": "disabled"},
-    }  # fmt: skip
+        "inputs": {"image": frames, "upscale_method": "area", "width": tw, "height": th, "crop": "disabled"},
+    }
     graph[show] = {"class_type": "PreviewImage", "inputs": {"images": [scale, 0]}}
 
 
-def thumbnail(server: comfy.Server, outputs: dict) -> bytes:
-    for item in (outputs.get(THUMB_NODES[1]) or {}).get("images", []):
+def thumbnail(server: comfy.Server, outputs: dict, node: str = THUMB_NODES[1]) -> bytes:
+    for item in (outputs.get(node) or {}).get("images", []):
         try:
             return server.fetch(item)
         except (comfy.ComfyError, OSError, requests.RequestException):
@@ -275,6 +289,12 @@ def request(
     sources = [resolve(agent, ref) for ref in refs] + [Path(p) for p in agent.image_refs if Path(p).exists()]
     if mask and not sources:
         raise MediaError("--mask needs the image it masks: @photo.png --mask mask.png make the sky purple")
+    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[: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,
            "sources": [str(p) for p in sources], "mask": str(mask) if mask else None, "pads": None,
            "keep_shape": not SIZE_FLAG.search(text)}  # fmt: skip
@@ -286,9 +306,10 @@ def redo(
 ) -> list[Made]:
     """Make what `job` describes (also what /again and /vary repeat): images, or edits of its sources."""
     prompt, options = job["prompt"], job["options"]
-    if not prompt.strip() and job["kind"] in ("image", "edit") and not job.get("pads"):
-        raise MediaError("Describe the image you want." if job["kind"] == "image" else "Say what to change.")
-    model = current(agent)
+    if not prompt.strip() and job["kind"] in ("image", "edit", "video") and not job.get("pads"):
+        what = {"image": "Describe the image you want.", "edit": "Say what to change."}
+        raise MediaError(what.get(job["kind"], "Describe the video you want."))
+    model = current(agent, "video" if job["kind"] == "video" else "image")
     if options.negative and not model.negative:
         agent.say(f"{model.name} doesn't use a negative prompt: describe what you want instead (--no is ignored).")
     agent.last_request = job
@@ -299,6 +320,8 @@ def redo(
         one = replace(options, seed=seed, n=1)
         if job["kind"] == "image":
             made.append(generate_image(agent, prompt, cancelled, ask, one, label))
+        elif job["kind"] == "video":
+            made.append(generate_video(agent, job, one, cancelled, ask, label))
         else:
             made.append(edit_image(agent, job, one, cancelled, ask, label))
     return made
@@ -368,7 +391,7 @@ def generate_image(
         raise MediaError("Describe the image you want.")
     options = options or imageopts.Options()
     server = prepare(agent, ask, cancelled)
-    model = current(agent)
+    model = current(agent, "image")
     files = ensure_installed(agent, model, server, ask)
     workflow = comfy.load_workflow(model.workflow)
     seed = options.seed if options.seed is not None else random.randrange(2**32)
@@ -397,7 +420,7 @@ def edit_image(
     """An edit of the job's source images: by instruction, through a mask (inpainting), or on a bigger canvas
     (outpainting). The first source sets the shape unless the request gave one."""
     server = prepare(agent, ask, cancelled)
-    chosen = current(agent)
+    chosen = current(agent, "image")
     model = catalog.load().editor(chosen)
     if model is None:
         raise MediaError("None of lcode's image models edits pictures yet.")
@@ -453,6 +476,112 @@ def edit_image(
     return run_plan(agent, server, plan, cancelled, label)
 
 
+def generate_video(
+    agent: Agent,
+    job: dict,
+    options: imageopts.Options,
+    cancelled: Callable[[], bool] = lambda: False,
+    ask: Callable[[str], bool] | None = None,
+    label: str = "",
+) -> Made:
+    """One video: from the prompt, or starting from the job's image. Its shape is 16:9, or 9:16 for an upright start
+    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)
+    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)
+    seed = options.seed if options.seed is not None else random.randrange(2**32)
+    steps, megapixels = model.preset(options.quality)
+    ratio = options.size
+    if job.get("keep_shape", True) and options.size == imageopts.Options().size:  # no shape asked for
+        ratio = "16:9"
+        if start is not None:
+            try:
+                w, h = edits.image_size(start)
+                ratio = "9:16" if h > w else "16:9"  # a square or odd shape breaks up; this crops it
+            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,
+              "length": imageopts.frames(options.seconds, fps), "fps": fps}  # fmt: skip
+    if steps:
+        values["steps"] = steps
+    if options.negative:
+        values["negative"] = options.negative
+    values["camera"] = imageopts.CAMERA[options.camera or "static"]
+    graph = comfy.fill(workflow.graph, values)
+    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 "", "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,
@@ -580,6 +709,8 @@ def run_plan(agent: Agent, server: comfy.Server, plan: Plan, cancelled, label: s
             pass
     made = Made(saved, plan.model.name, plan.seed, width, height, time.monotonic() - line.started, plan.prompt)
     made.thumbnail = thumbnail(server, outputs)
+    if plan.kind == "video":
+        made.poster = thumbnail(server, outputs, POSTER_NODES[1])
     made.numbers = record(agent, made, plan)
     show(agent, made)
     return made
@@ -626,18 +757,21 @@ def show(agent: Agent, made: Made) -> None:
             + Text(f"  {made.width}×{made.height} · {made.model}{seed} · {made.seconds:.1f} s", style="dim")
         )
     if made.files:
-        show_preview(agent, made.files[0], made.thumbnail)
+        show_preview(agent, made.files[0], made.thumbnail, made.poster)
 
 
-def show_preview(agent: Agent, path: Path, thumb: bytes = b"") -> None:
-    """The image in the terminal: itself where the terminal can show pictures, else a half-block preview."""
+def show_preview(agent: Agent, path: Path, thumb: bytes = b"", poster: bytes = b"") -> None:
+    """The image (or a video's first frame) in the terminal: itself where the terminal can show pictures, else a
+    half-block preview."""
     setting = agent.settings.preview
     how = preview.protocol(setting)
     if how == "off" or (setting == "auto" and not agent.console.is_terminal):
         return
     try:
         if how in ("kitty", "iterm"):
-            data = path.read_bytes()
+            data = path.read_bytes() if edits.is_image(path) else poster
+            if not data:
+                return
             sequence = preview.kitty(data) if how == "kitty" else preview.iterm(data)
             agent.console.file.write(sequence)
             agent.console.file.flush()

lcode/media.toml

@@ -113,3 +113,86 @@ tasks = ["remove-background"]
 workflow = "remove-background"
 files = { model = "birefnet" }
 notes = "/nobg: a transparent PNG"
+
+[files.wan22-ti2v-5b]
+folder = "diffusion_models"
+name = "wan2.2_ti2v_5B_fp16.safetensors"
+url = "https://huggingface.co/Comfy-Org/Wan_2.2_ComfyUI_Repackaged/resolve/main/split_files/diffusion_models/wan2.2_ti2v_5B_fp16.safetensors"
+gb = 10.00
+
+[files.umt5-xxl-fp8]
+folder = "text_encoders"
+name = "umt5_xxl_fp8_e4m3fn_scaled.safetensors"
+url = "https://huggingface.co/Comfy-Org/Wan_2.1_ComfyUI_repackaged/resolve/main/split_files/text_encoders/umt5_xxl_fp8_e4m3fn_scaled.safetensors"
+gb = 6.74
+alternatives = ["umt5_xxl_fp16.safetensors"]
+
+[files.wan22-vae]
+folder = "vae"
+name = "wan2.2_vae.safetensors"
+url = "https://huggingface.co/Comfy-Org/Wan_2.2_ComfyUI_Repackaged/resolve/main/split_files/vae/wan2.2_vae.safetensors"
+gb = 1.41
+
+[models.wan22-ti2v-5b]
+name = "Wan 2.2 TI2V 5B"
+mode = "video"
+publisher = "Wan-AI (Alibaba)"
+license = "Apache 2.0"
+tasks = ["text-to-video", "image-to-video"]
+workflow = "wan22-ti2v-5b"
+files = { model = "wan22-ti2v-5b", text_encoder = "umt5-xxl-fp8", vae = "wan22-vae" }
+gpu_gb = 0.0
+measured = "5 s clip: 100 s fast, 150 s balanced (864×480), 10.5 min best (1280×704) on an RTX 4080 Laptop, 12 GB"
+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/media_catalog.py

@@ -29,6 +29,7 @@ else:  # pragma: no cover
     import tomli as tomllib
 
 DEFAULT_IMAGE = "flux2-klein-4b"
+DEFAULT_VIDEO = "wan22-ti2v-5b"
 DISK_MARGIN_GB = 2.0  # left free after a download
 GPU_MARGIN_GIB = 0.5
 WORKING_GB = 1.5  # activations and buffers on top of the largest file, for models not measured yet
@@ -111,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/modes.py

@@ -27,23 +27,23 @@ TITLES = {"code": "local coding agent", "image": "local image generation", "vide
 MEDIA_SERVERS = frozenset({"comfyui", "xai"})  # the MCP catalog's image and video servers
 MEDIA_COMMANDS = ("comfy-mcp", "lcode-mcp-xai")  # the same servers, under any name
 NOTED_FILE = "media-servers-noted"
-COMING = {
-    "video": (
-        "Video mode doesn't generate yet: the video models (#150) and video generation (#153) come next. "
-        "/mode image makes images now; /mode code switches back."
-    ),
-}
+COMING: dict[str, str] = {}
 
 
 def ready(agent: Agent) -> str:
     """What to do in the agent's mode, said on entering it."""
-    if agent.settings.mode == "image":
-        from lcode import media
+    from lcode import media
 
+    if agent.settings.mode == "image":
         return (
             f"Describe an image and press Enter: {media.current(agent).name} makes it on your GPU, into "
             f"{agent.settings.media_dir}. /mode code switches back."
         )
+    if agent.settings.mode == "video":
+        return (
+            f"Describe a video and press Enter (@photo.png starts it from a picture): {media.current(agent).name} "
+            f"makes it on your GPU, into {agent.settings.media_dir}. /mode code switches back."
+        )
     return COMING.get(agent.settings.mode, "")
 
 
@@ -113,7 +113,7 @@ def switch(agent: Agent, new: str) -> list[str]:
     if new == "code" and agent.no_coding_model:
         reason = agent.no_coding_model.strip().splitlines()[0]
         lines.append(f"lcode started without its coding model ({reason}). Fix that, then restart lcode.")
-    if new == "image":
+    if new in ("image", "video"):
         from lcode import media
 
         warming = media.warm(agent)