lcode-cli 0.40.0__py3-none-any.whl → 0.41.0__py3-none-any.whl

lcode/__init__.py

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

lcode/agent.py

@@ -308,6 +308,7 @@ class Settings:
     comfyui_url: str = "http://127.0.0.1:8188"
     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)
     num_batch: int | None = None
     keep_alive: str = "30m"
     think: bool = True
@@ -687,6 +688,7 @@ class Agent:
             "cwd": str(self.workspace),  # where `lcode -c` there finds it, wherever the shell moved
             "model": self.settings.model,
             "mode": self.settings.mode,
+            "image_model": self.settings.image_model,
             "name": self.session_name,
             "title": self.session_title,
             "messages": self.messages,
@@ -735,6 +737,8 @@ class Agent:
         self.session_name = data.get("name", "")
         if data.get("mode") in ("code", "image", "video"):
             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"]
         self.session_title = data.get("title") or sessions.title_from(self.messages)
         self.tools.read_mtimes.clear()  # files may have changed since; the model must read them again
         self.tools.todos = list(data.get("todos") or [])

lcode/api.py

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

lcode/cli.py

@@ -777,9 +777,10 @@ def exit_on_hangup() -> None:
 
 def comfyui_status(cfg: dict) -> tuple[str, bool | None]:
     """lcode doctor's ComfyUI line: running or found, and whether the image model is there."""
-    from lcode import comfy, media
+    from lcode import comfy
+    from lcode import media_catalog as catalog
 
-    workflow = comfy.load_workflow(media.IMAGE_WORKFLOW)
+    model = catalog.load().find(cfg.get("image_model") or "") or catalog.load().models[catalog.DEFAULT_IMAGE]
     server = comfy.Server(cfg["comfyui_url"])
     stats = server.stats()
     install = None if stats else comfy.find_install(cfg["comfyui_path"])
@@ -787,14 +788,13 @@ def comfyui_status(cfg: dict) -> tuple[str, bool | None]:
         return "not found: image mode offers to install it (or lcode config set comfyui_path <folder>)", None
     if stats:
         where = f"{(stats.get('system') or {}).get('comfyui_version', '?')} running at {server.url}"
-        installed = {folder: set(server.models(folder)) for folder in workflow.models}
     else:
         where = f"{install.path} (lcode starts it in image mode)"
-        installed = {folder: set(comfy.local_models(install, folder)) for folder in workflow.models}
-    missing = [f"{f}/{names[0]}" for f, names in workflow.models.items() if not installed[f] & set(names)]
+    _, missing = catalog.chosen_files(model, catalog.lister(server if stats else None, install))
     if missing:
-        return f"{where} · {workflow.name} not installed (missing {', '.join(missing)})", None
-    return f"{where} · image model: {workflow.name}", True
+        size = sum(f.gb for f in missing)
+        return f"{where} · {model.name} not installed: lcode media install {model.key} ({size:.1f} GB)", None
+    return f"{where} · image model: {model.name}", True
 
 
 def media_request(agent, prompt: str, out: Console, quiet: bool) -> None:
@@ -909,6 +909,13 @@ def build_subparsers() -> dict[str, argparse.ArgumentParser]:
     subs["setup"] = p
     subs["models"] = argparse.ArgumentParser(prog="lcode models", description="List models and how they fit here.")
     subs["doctor"] = argparse.ArgumentParser(prog="lcode doctor", description="Check the installation.")
+    p = argparse.ArgumentParser(
+        prog="lcode media", description="Image and video models: list them, with how they fit here, or install one."
+    )
+    p.add_argument("action", nargs="?", choices=["list", "install"], default="list")
+    p.add_argument("model", nargs="?", help="with install: a model key from the list, e.g. z-image-turbo")
+    p.add_argument("-y", "--yes", action="store_true", help="don't ask before downloading")
+    subs["media"] = p
     p = argparse.ArgumentParser(prog="lcode config", description="Show or change settings.")
     p.add_argument("action", nargs="?", choices=["show", "set", "unset", "path"], default="show")
     p.add_argument("key", nargs="?", choices=list(config.SETTINGS))
@@ -1065,6 +1072,55 @@ def cmd_index(args) -> None:
     )
 
 
+def cmd_media(args) -> None:
+    """lcode media [list] | install <model>: the media catalog, what's installed in ComfyUI, downloads."""
+    from rich.prompt import Confirm
+
+    from lcode import comfy, media
+    from lcode import media_catalog as catalog
+
+    try:
+        cfg = config.load()
+    except ConfigError as e:
+        fail(str(e))
+    cat, hw = catalog.load(), detect()
+    server = comfy.Server(cfg["comfyui_url"])
+    install = comfy.find_install(cfg["comfyui_path"])
+    running = server.stats() is not None
+    installed = catalog.lister(server if running else None, install) if running or install else None
+    if args.action == "install":
+        model = cat.find(args.model or "")
+        if model is None:
+            fail(f"no media model {args.model!r}: lcode media lists them")
+        if not running and install is None:
+            fail(f"lcode needs ComfyUI to install models into. {comfy.install_hint()}")
+        ask = None if args.yes else (lambda q: Confirm.ask(q, default=True, console=console))
+        try:
+            saved = catalog.install(model, server if running else None, install, console, ask)
+        except catalog.CatalogError as e:
+            fail(str(e))
+        how = f" ({len(saved)} file(s) downloaded)." if saved else "."
+        console.print(f"[green]{model.name} is installed[/]{how}")
+        return
+    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")
+    for mode in ("image", "video"):
+        models = cat.for_mode(mode)
+        console.print(f"[bold]{mode.capitalize()} models[/]")
+        if not models:
+            console.print(f"  [dim]{media.SOON[mode]}[/]\n")
+            continue
+        for m in models:
+            line = escape(catalog.describe(m, hw, installed))
+            console.print(f"  [bold]{m.key:<16}[/] {escape(m.name)} [dim]· {line}[/]")
+            if m.measured:
+                console.print(f"  {'':<16} [dim]{escape(m.measured)}[/]")
+        console.print()
+    console.print("[dim]Install one: lcode media install <model> · choose in image mode: /model <model>[/]")
+
+
 def cmd_mcp(args) -> None:
     from lcode.mcp.commands import run
 
@@ -1075,6 +1131,7 @@ COMMANDS = {
     "setup": cmd_setup,
     "models": cmd_models,
     "doctor": cmd_doctor,
+    "media": cmd_media,
     "config": cmd_config,
     "bench": cmd_bench,
     "mcp": cmd_mcp,

lcode/comfy.py

@@ -254,6 +254,14 @@ class Server:
         except (requests.RequestException, ValueError):
             return []
 
+    def folder_paths(self) -> dict[str, list[str]]:
+        """Where ComfyUI keeps each kind of model (its own folders and extra_model_paths.yaml's)."""
+        try:
+            r = requests.get(self.url + "/internal/folder_paths", timeout=10)
+            return r.json() if r.status_code == 200 else {}
+        except (requests.RequestException, ValueError):
+            return {}
+
     def upload(self, path: Path) -> str:
         """Upload an input image; the name to use in a workflow."""
         with path.open("rb") as f:
@@ -420,32 +428,18 @@ class Events:
 
 @dataclass
 class Workflow:
+    """A graph in ComfyUI's API format with `$name` placeholders: the model's files (by role, from media.toml),
+    the prompt, the seed and the settings in `defaults`."""
+
     key: str
-    name: str
-    task: str
-    models: dict[str, list[str]]  # ComfyUI folder -> file names it can use, preferred first
-    defaults: dict
     graph: dict
+    defaults: dict = field(default_factory=dict)
     labels: dict[str, str] = field(default_factory=dict)  # node id -> what it does, for progress
 
 
 def load_workflow(key: str) -> Workflow:
     data = json.loads(resources.files("lcode.workflows").joinpath(f"{key}.json").read_text())
-    return Workflow(key, data["name"], data["task"], data["models"], data.get("defaults", {}), data["graph"],
-                    data.get("labels", {}))  # fmt: skip
-
-
-def choose_files(server: Server, workflow: Workflow) -> tuple[dict[str, str], list[str]]:
-    """For each model the workflow needs, the installed file to use; and the folders where none is installed."""
-    chosen, missing = {}, []
-    for folder, names in workflow.models.items():
-        installed = set(server.models(folder))
-        found = next((n for n in names if n in installed), None)
-        if found:
-            chosen[folder] = found
-        else:
-            missing.append(f"{folder}/{names[0]}")
-    return chosen, missing
+    return Workflow(key, data["graph"], data.get("defaults", {}), data.get("labels", {}))
 
 
 PLACEHOLDER = re.compile(r"^\$([a-z_]+)$")

lcode/config.py

@@ -45,6 +45,7 @@ SETTINGS: dict[str, tuple[object, type, str]] = {
     "comfyui_url": ("http://127.0.0.1:8188", str, "ComfyUI, for image and video mode"),
     "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`"),
     "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"),
     "search_backend": ("auto", str, "auto | ollama | brave | tavily | searxng (keys come from environment variables)"),
@@ -210,6 +211,12 @@ def coerce(key: str, value: object) -> object:
         raise ConfigError(f"permission_mode must be one of {', '.join(PERMISSION_MODES)}")
     if key == "mode" and value not in WORK_MODES:
         raise ConfigError(f"mode must be one of {', '.join(WORK_MODES)}")
+    if key == "image_model":
+        from lcode import media_catalog
+
+        keys = [m.key for m in media_catalog.load().for_mode("image")]
+        if value not in keys:
+            raise ConfigError(f"image_model 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/media.py

@@ -1,7 +1,7 @@
 """Image and video mode: a request becomes media, made by ComfyUI (lcode.comfy) with no language model in between.
 
-For now image mode makes one image per request with FLUX.2 klein 4B, the engine's first workflow; models, sizes,
-variations and a gallery come with #150 and #151, video with #153.
+Image mode makes one image per request with the image model chosen from the media catalog (lcode.media_catalog);
+sizes, variations and a gallery come with #151, video with #153.
 """
 
 from __future__ import annotations
@@ -16,11 +16,12 @@ from typing import TYPE_CHECKING
 from rich.text import Text
 
 from lcode import comfy
+from lcode import media_catalog as catalog
 
 if TYPE_CHECKING:
     from lcode.agent import Agent
 
-IMAGE_WORKFLOW = "flux2-klein-4b-t2i"
+SOON = {"video": "Video models come with video generation (#153)."}
 IGNORED = "# lcode's images and videos: not part of the project unless you add them\n*\n"
 
 
@@ -28,8 +29,19 @@ class MediaError(Exception):
     pass
 
 
-def image_model() -> str:
-    return comfy.load_workflow(IMAGE_WORKFLOW).name
+def installed_lister(agent: Agent) -> catalog.Installed | None:
+    """What ComfyUI has installed: asked from it when it's running, else read from its folders; None: unknown."""
+    server = comfy.Server(agent.settings.comfyui_url)
+    if server.stats():
+        return catalog.lister(server)
+    install = comfy.find_install(agent.settings.comfyui_path)
+    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)."""
+    cat = catalog.load()
+    return cat.find(agent.settings.image_model) or cat.models[catalog.DEFAULT_IMAGE]
 
 
 @dataclass
@@ -183,6 +195,28 @@ class Line:
         return text
 
 
+def ensure_installed(
+    agent: Agent, model: catalog.MediaModel, server: comfy.Server, ask: Callable[[str], bool] | None
+) -> dict[str, str]:
+    """The model's files (role -> installed name), downloading the missing ones first when the user agrees."""
+    files, missing = catalog.chosen_files(model, catalog.lister(server))
+    if not missing:
+        return files
+    size = sum(f.gb for f in missing)
+    if ask is None:
+        raise MediaError(f"{model.name} isn't installed ({size:.1f} GB to download): lcode media install {model.key}")
+    install = comfy.find_install(agent.settings.comfyui_path)
+    try:
+        catalog.install(model, server=server, install=install, console=agent.console, ask=ask)
+    except catalog.CatalogError as e:
+        raise MediaError(str(e)) from e
+    files, missing = catalog.chosen_files(model, catalog.lister(server))
+    if missing:
+        raise MediaError(f"ComfyUI doesn't see {', '.join(f.name for f in missing)} yet: restart it and try again")
+    agent.say(f"Installed {model.name}.")
+    return files
+
+
 def generate_image(
     agent: Agent, prompt: str, cancelled: Callable[[], bool] = lambda: False, ask: Callable[[str], bool] | None = None
 ) -> Made:
@@ -193,20 +227,17 @@ def generate_image(
     server = engine(agent, ask, cancelled)
     for path in comfy.collect(server):
         agent.say(f"Saved {shown(agent, path)}: it finished while lcode wasn't watching.")
-    workflow = comfy.load_workflow(IMAGE_WORKFLOW)
-    files, missing = comfy.choose_files(server, workflow)
-    if missing:
-        raise MediaError(
-            f"{workflow.name} isn't installed in ComfyUI (missing {', '.join(missing)}). lcode installs image "
-            "models from #150 on; until then put the files in ComfyUI's models folder."
-        )
+    model = current(agent)
+    files = ensure_installed(agent, model, server, ask)
+    workflow = comfy.load_workflow(model.workflow)
     free_gpu(agent)
     seed = random.randrange(2**32)
     values = {**workflow.defaults, **files, "prompt": prompt, "seed": seed}
     graph = comfy.fill(workflow.graph, values)
     meta = {
         "prompt": prompt,
-        "model": workflow.name,
+        "model": model.name,
+        "model_key": model.key,
         "workflow": workflow.key,
         "seed": seed,
         "width": values["width"],
@@ -217,7 +248,7 @@ def generate_image(
     }
     out = folder(agent)
     stem = f"{time.strftime('%Y%m%d-%H%M%S')}-{comfy.slug(prompt)}"
-    line = Line(workflow.name, "Esc or Ctrl+C cancels" if agent.interactive else "")
+    line = Line(model.name, "Esc or Ctrl+C cancels" if agent.interactive else "")
     job = {"id": ""}
 
     def on_event(event: comfy.Event) -> None:
@@ -252,7 +283,7 @@ def generate_image(
     comfy.forget(prompt_id)
     if not saved:
         raise MediaError("ComfyUI finished but returned no image.")
-    made = Made(saved, workflow.name, seed, values["width"], values["height"], time.monotonic() - line.started)
+    made = Made(saved, model.name, seed, values["width"], values["height"], time.monotonic() - line.started)
     for path in saved:
         agent.console.print(
             Text("◆ ", style="green")

lcode/media.toml

@@ -0,0 +1,74 @@
+# Image and video models lcode can run through ComfyUI (lcode.media_catalog).
+#
+# [files.<key>]  one file in ComfyUI's model folders, listed once: models share text encoders and VAEs.
+#   folder        ComfyUI's model folder (diffusion_models, text_encoders, vae, loras, …)
+#   name          the file name there
+#   url           where lcode downloads it from (Hugging Face; HF_TOKEN is used for gated files)
+#   gb            its size in GB (10^9 bytes)
+#   alternatives  other file names that do the same job: an installed one is used instead of downloading
+#
+# [models.<key>]  one model.
+#   mode          image or video
+#   tasks         text-to-image, edit, inpaint, text-to-video, image-to-video, first-last-frame, reference-to-video, audio
+#   workflow      lcode's workflow for it (lcode/workflows/<workflow>.json)
+#   files         role -> file key; the workflow's $role placeholders get the file names
+#   gpu_gb        GPU memory it needs, when known better than lcode's estimate (the largest file + 1.5 GB); ComfyUI
+#                 fills whatever is free with cached models, so nvidia-smi's peak doesn't tell
+#   measured      what it did on real hardware; models without it haven't been run yet
+
+[files.flux-2-klein-4b-fp8]
+folder = "diffusion_models"
+name = "flux-2-klein-4b-fp8.safetensors"
+url = "https://huggingface.co/black-forest-labs/FLUX.2-klein-4b-fp8/resolve/main/flux-2-klein-4b-fp8.safetensors"
+gb = 4.07
+alternatives = ["flux-2-klein-4b.safetensors"]
+
+[files.qwen-3-4b]
+folder = "text_encoders"
+name = "qwen_3_4b.safetensors"
+url = "https://huggingface.co/Comfy-Org/flux2-klein/resolve/main/split_files/text_encoders/qwen_3_4b.safetensors"
+gb = 8.04
+alternatives = ["qwen_3_4b_fp8_mixed.safetensors"]
+
+[files.flux2-vae]
+folder = "vae"
+name = "flux2-vae.safetensors"
+url = "https://huggingface.co/Comfy-Org/flux2-dev/resolve/main/split_files/vae/flux2-vae.safetensors"
+gb = 0.34
+
+[files.z-image-turbo-int8]
+folder = "diffusion_models"
+name = "z_image_turbo_int8_convrot.safetensors"
+url = "https://huggingface.co/Comfy-Org/z_image_turbo/resolve/main/split_files/diffusion_models/z_image_turbo_int8_convrot.safetensors"
+gb = 6.20
+alternatives = ["z_image_turbo_bf16.safetensors"]
+
+[files.flux-ae]
+folder = "vae"
+name = "ae.safetensors"
+url = "https://huggingface.co/Comfy-Org/z_image_turbo/resolve/main/split_files/vae/ae.safetensors"
+gb = 0.34
+
+[models.flux2-klein-4b]
+name = "FLUX.2 klein 4B"
+mode = "image"
+publisher = "Black Forest Labs"
+license = "Apache 2.0"
+tasks = ["text-to-image"]
+workflow = "flux2-klein-4b-t2i"
+files = { model = "flux-2-klein-4b-fp8", text_encoder = "qwen-3-4b", vae = "flux2-vae" }
+gpu_gb = 0.0
+measured = "1024×1024: 3.5 s per image, 14 s for the first with ComfyUI starting (RTX 4080 Laptop, 12 GB)"
+notes = "fast and small: 4 steps"
+
+[models.z-image-turbo]
+name = "Z-Image Turbo"
+mode = "image"
+publisher = "Tongyi-MAI (Alibaba)"
+license = "Apache 2.0"
+tasks = ["text-to-image"]
+workflow = "z-image-turbo-t2i"
+files = { model = "z-image-turbo-int8", text_encoder = "qwen-3-4b", vae = "flux-ae" }
+gpu_gb = 0.0
+measured = "1024×1024: 17 s per image (1.9 s per step), 23 s for the first (RTX 4080 Laptop, 12 GB)"
+notes = "photorealistic, writes text well: 8 steps"

lcode/media_catalog.py

@@ -0,0 +1,331 @@
+"""The image and video models lcode can run (media.toml): what they need, whether they fit, installing them.
+
+A model is a workflow plus the files it uses in ComfyUI's model folders. Files are listed once, because models share
+text encoders and VAEs, and a file counts as installed under its own name or one of its alternatives (an fp8 or a
+full-precision build of the same weights). Installing downloads the missing files into ComfyUI's model folders:
+resumably (a `.part` file grows until it's complete), checked against Hugging Face's SHA-256, after a disk check.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import shutil
+import sys
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from functools import cache
+from importlib import resources
+from pathlib import Path
+from urllib.parse import urlsplit
+
+import requests
+
+from lcode.hardware import GIB, Hardware
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:  # pragma: no cover
+    import tomli as tomllib
+
+DEFAULT_IMAGE = "flux2-klein-4b"
+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
+CHUNK = 1 << 20
+http_get = requests.get  # what downloads use (tests replace it)
+
+
+class CatalogError(Exception):
+    pass
+
+
+@dataclass(frozen=True)
+class File:
+    key: str
+    folder: str  # ComfyUI's model folder
+    name: str
+    url: str
+    gb: float
+    alternatives: tuple[str, ...] = ()
+
+    @property
+    def names(self) -> tuple[str, ...]:
+        return (self.name, *self.alternatives)
+
+
+@dataclass(frozen=True)
+class MediaModel:
+    key: str
+    name: str
+    mode: str  # image or video
+    publisher: str
+    license: str
+    tasks: tuple[str, ...]
+    workflow: str
+    files: dict[str, File] = field(hash=False)  # role -> file
+    gpu_gb: float = 0.0  # measured peak GPU memory; 0 when not measured yet
+    measured: str = ""
+    notes: str = ""
+
+    @property
+    def size_gb(self) -> float:
+        return sum(f.gb for f in {f.key: f for f in self.files.values()}.values())
+
+    @property
+    def need_gb(self) -> float:
+        """GPU memory at the peak: measured, or estimated. ComfyUI loads the text encoder, the model and the VAE
+        one after another and moves what it doesn't need off the GPU, so the largest file sets the peak."""
+        return self.gpu_gb or max(f.gb for f in self.files.values()) + WORKING_GB
+
+    def fit(self, hw: Hardware) -> tuple[str, str]:
+        """(fits | slower | too big | cpu, a short note) on this machine."""
+        weights_gib = self.size_gb * 1e9 / GIB
+        need_gib = self.need_gb * 1e9 / GIB
+        if hw.unified:
+            if need_gib <= hw.budget_gib - GPU_MARGIN_GIB:
+                return "fits", "fits in unified memory"
+            return "too big", f"needs ~{need_gib:.0f} GB, ~{hw.budget_gib:.0f} GB available"
+        if not hw.gpu or not hw.vram_gib:
+            return "cpu", "no GPU lcode can use: very slow on the CPU"
+        if need_gib <= hw.vram_gib - GPU_MARGIN_GIB:
+            return "fits", f"~{need_gib:.0f} GB of {hw.vram_gib:.0f} GB GPU memory"
+        if weights_gib <= hw.vram_gib + 0.6 * hw.ram_gib:  # ComfyUI keeps the rest in RAM and swaps it in
+            return "slower", f"part runs from RAM ({need_gib:.0f} GB needed, {hw.vram_gib:.0f} GB GPU)"
+        return "too big", f"needs ~{weights_gib:.0f} GB, more than GPU and RAM together"
+
+
+@dataclass
+class Catalog:
+    files: dict[str, File]
+    models: dict[str, MediaModel]
+
+    def for_mode(self, mode: str) -> list[MediaModel]:
+        return [m for m in self.models.values() if m.mode == mode]
+
+    def find(self, wanted: str, mode: str | None = None) -> MediaModel | None:
+        """A model by key or name (any case), or by its number in the mode's list."""
+        candidates = self.for_mode(mode) if mode else list(self.models.values())
+        if wanted.isdigit() and 1 <= int(wanted) <= len(candidates):
+            return candidates[int(wanted) - 1]
+        low = wanted.strip().lower()
+        return next((m for m in candidates if low in (m.key, m.name.lower())), None)
+
+
+@cache
+def load() -> Catalog:
+    data = tomllib.loads(resources.files("lcode").joinpath("media.toml").read_text())
+    files = {
+        key: File(key, f["folder"], f["name"], f["url"], float(f["gb"]), tuple(f.get("alternatives", ())))
+        for key, f in data.get("files", {}).items()
+    }
+    models = {}
+    for key, m in data.get("models", {}).items():
+        try:
+            roles = {role: files[ref] for role, ref in m["files"].items()}
+        except KeyError as e:
+            raise CatalogError(f"media.toml: {key} uses the file {e}, which isn't listed") from e
+        models[key] = MediaModel(
+            key,
+            m["name"],
+            m["mode"],
+            m.get("publisher", ""),
+            m.get("license", ""),
+            tuple(m.get("tasks", ())),
+            m["workflow"],
+            roles,
+            float(m.get("gpu_gb", 0.0)),
+            m.get("measured", ""),
+            m.get("notes", ""),
+        )
+    return Catalog(files, models)
+
+
+# ----------------------------------------------------------------------------- what's installed
+
+
+Installed = Callable[[str], set[str]]  # ComfyUI folder -> the file names in it
+
+
+def chosen_files(model: MediaModel, installed: Installed) -> tuple[dict[str, str], list[File]]:
+    """For each role, the installed file name to use; and the files that aren't installed."""
+    chosen, missing = {}, []
+    for role, f in model.files.items():
+        found = next((n for n in f.names if n in installed(f.folder)), None)
+        if found:
+            chosen[role] = found
+        elif f not in missing:
+            missing.append(f)
+    return chosen, missing
+
+
+def lister(server=None, install=None) -> Installed:
+    """What's in each model folder: asked from a running ComfyUI, or read from the install's folders."""
+    from lcode import comfy
+
+    seen: dict[str, set[str]] = {}
+
+    def installed(folder: str) -> set[str]:
+        if folder not in seen:
+            if server is not None:
+                seen[folder] = set(server.models(folder))
+            elif install is not None:
+                seen[folder] = set(comfy.local_models(install, folder))
+            else:
+                seen[folder] = set()
+        return seen[folder]
+
+    return installed
+
+
+def model_folder(folder: str, server=None, install=None) -> Path | None:
+    """Where ComfyUI keeps one kind of model: from the running server, or the install's models/ folder."""
+    if server is not None:
+        paths = server.folder_paths().get(folder)
+        if paths:
+            return Path(paths[0])
+    if install is not None:
+        return install.path / "models" / folder
+    return None
+
+
+# ----------------------------------------------------------------------------- downloading
+
+
+def disk_problem(folder: Path, need_gb: float) -> str:
+    """Why `need_gb` won't fit on the disk of `folder` (with a margin), or empty."""
+    probe = folder
+    while not probe.exists() and probe != probe.parent:
+        probe = probe.parent
+    free_gb = shutil.disk_usage(probe).free / 1e9
+    if need_gb + DISK_MARGIN_GB > free_gb:
+        return f"needs {need_gb:.1f} GB, and {probe} has {free_gb:.1f} GB free (lcode keeps {DISK_MARGIN_GB:.0f} GB)"
+    return ""
+
+
+def remaining_gb(f: File, folder: Path) -> float:
+    part = folder / (f.name + ".part")
+    have = part.stat().st_size / 1e9 if part.exists() else 0.0
+    return max(f.gb - have, 0.0)
+
+
+def auth_headers(url: str) -> dict[str, str]:
+    token = os.environ.get("HF_TOKEN") or os.environ.get("HUGGING_FACE_HUB_TOKEN")
+    if token and urlsplit(url).hostname == "huggingface.co":
+        return {"Authorization": f"Bearer {token}"}  # requests drops it when redirected to another host
+    return {}
+
+
+def download(
+    url: str,
+    dest: Path,
+    on_progress: Callable[[int, int], None] = lambda done, total: None,
+    get=None,
+) -> None:
+    """Download `url` to `dest`, resuming a `.part` file left by an earlier try, and check its SHA-256."""
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    part = dest.with_name(dest.name + ".part")
+    have = part.stat().st_size if part.exists() else 0
+    headers = {**auth_headers(url), **({"Range": f"bytes={have}-"} if have else {})}
+    try:
+        r = (get or http_get)(url, headers=headers, stream=True, timeout=(15, 120), allow_redirects=True)
+    except requests.RequestException as e:
+        raise CatalogError(f"can't download {dest.name}: {e}") from e
+    with r:
+        if r.status_code == 416 and have:  # nothing left to fetch: the .part is complete
+            pass
+        elif r.status_code in (401, 403):
+            raise CatalogError(
+                f"{dest.name} needs a Hugging Face login: accept its license on huggingface.co, then set HF_TOKEN"
+            )
+        elif r.status_code not in (200, 206):
+            raise CatalogError(f"can't download {dest.name}: HTTP {r.status_code}")
+        else:
+            if r.status_code == 200 and have:  # the server ignored the range: start over
+                have = 0
+            total = have + int(r.headers.get("Content-Length") or 0)
+            with part.open("ab" if have else "wb") as out:
+                done = have
+                for chunk in r.iter_content(CHUNK):
+                    out.write(chunk)
+                    done += len(chunk)
+                    on_progress(done, total)
+        expected = sha256_of(r)
+    if expected:
+        actual = file_sha256(part)
+        if actual != expected:
+            part.unlink()
+            raise CatalogError(f"{dest.name} arrived damaged (its SHA-256 doesn't match): it will download again")
+    part.replace(dest)
+
+
+def sha256_of(response) -> str:
+    """The SHA-256 Hugging Face gives for a large file (its X-Linked-Etag, on the redirect), or empty."""
+    for r in [*getattr(response, "history", []), response]:
+        tag = (r.headers.get("X-Linked-Etag") or "").strip('"')
+        if len(tag) == 64 and all(c in "0123456789abcdef" for c in tag):
+            return tag
+    return ""
+
+
+def file_sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as f:
+        for chunk in iter(lambda: f.read(CHUNK * 8), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def install(model: MediaModel, server=None, install=None, console=None, ask=None, get=None) -> list[Path]:
+    """Download the model's missing files into ComfyUI's model folders. Raises CatalogError with what to do.
+
+    `ask(question) -> bool` confirms the download (None: go ahead, for `--yes`).
+    """
+    from rich.console import Console
+    from rich.progress import BarColumn, DownloadColumn, Progress, TextColumn, TimeRemainingColumn, TransferSpeedColumn
+
+    console = console or Console()
+    _, missing = chosen_files(model, lister(server, install))
+    if not missing:
+        return []
+    folders = {}
+    for f in missing:
+        folder = model_folder(f.folder, server, install)
+        if folder is None:
+            raise CatalogError("lcode doesn't know where ComfyUI keeps its models: set comfyui_path")
+        folders[f.key] = folder
+    need = sum(remaining_gb(f, folders[f.key]) for f in missing)
+    problem = disk_problem(next(iter(folders.values())), need)
+    if problem:
+        raise CatalogError(f"not enough disk space for {model.name}: {problem}")
+    listing = ", ".join(f"{f.name} ({f.gb:.1f} GB)" for f in missing)
+    if ask is not None and not ask(
+        f"Download {model.name}: {listing}, {need:.1f} GB into {folders[missing[0].key].parent}?"
+    ):
+        raise CatalogError(f"{model.name} isn't installed (download declined)")
+    saved = []
+    columns = (TextColumn("{task.description}"), BarColumn(), DownloadColumn(), TransferSpeedColumn())
+    with Progress(*columns, TimeRemainingColumn(), console=console, transient=False) as progress:
+        for f in missing:
+            task = progress.add_task(f.name, total=int(f.gb * 1e9))
+            dest = folders[f.key] / f.name
+            try:
+                download(f.url, dest, lambda done, total, t=task: progress.update(t, completed=done, total=total), get)
+            except KeyboardInterrupt:
+                raise CatalogError(f"Paused {f.name}: install {model.key} again to resume where it stopped.") from None
+            saved.append(dest)
+    return saved
+
+
+def describe(model: MediaModel, hw: Hardware, installed: Installed | None) -> str:
+    """One line for a list: tasks, size, fit, installed."""
+    status, note = model.fit(hw)
+    parts = [", ".join(model.tasks), f"{model.size_gb:.1f} GB"]
+    if installed is not None:
+        _, missing = chosen_files(model, installed)
+        if missing:
+            parts.append(f"{sum(f.gb for f in missing):.1f} GB to download")
+        else:
+            parts.append("installed")
+    parts.append({"fits": "fits", "slower": "slower", "too big": "too big", "cpu": "CPU only"}[status] + f" ({note})")
+    return " · ".join(parts)

lcode/modes.py

@@ -41,7 +41,7 @@ def ready(agent: Agent) -> str:
         from lcode import media
 
         return (
-            f"Describe an image and press Enter: {media.image_model()} makes it on your GPU, into "
+            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."
         )
     return COMING.get(agent.settings.mode, "")

lcode/repl.py

@@ -218,9 +218,9 @@ def model_lines(agent: Agent) -> str:
     """The banner's model lines: the coding model and its context, or the mode's own model."""
     s = agent.settings
     if s.mode == "image":
-        return f"[dim]model[/]    {escape(media.image_model())} [dim]· ComfyUI · {escape(s.media_dir)}[/]\n"
+        return f"[dim]model[/]    {escape(media.current(agent).name)} [dim]· ComfyUI · {escape(s.media_dir)}[/]\n"
     if s.mode == "video":
-        return "[dim]model[/]    [dim]video models come with #150 and #153[/]\n"
+        return "[dim]model[/]    [dim]video models come with video generation (#153)[/]\n"
     server = f" [dim]· {escape(agent.ollama.describe())}[/]" if backends.is_openai(agent.ollama) else ""
     return f"[dim]model[/]    {escape(s.model)}{server}\n[dim]context[/]  {format_tokens(s.context)} tokens\n"
 
@@ -891,6 +891,45 @@ def model_command(agent: Agent, arg: str, hardware: Hardware) -> None:
     switch_model(agent, arg, hardware)
 
 
+def media_model_command(agent: Agent, arg: str, hardware: Hardware) -> None:
+    """/models and /model in image or video mode: the catalog's models for the mode, numbered; pick one."""
+    from lcode import media_catalog as catalog
+
+    c, s = agent.console, agent.settings
+    choices = catalog.load().for_mode(s.mode)
+    if not choices:
+        c.print(f"[yellow]{escape(media.SOON.get(s.mode, modes.ready(agent)))}[/]")
+        return
+    current = media.current(agent)
+    installed = media.installed_lister(agent)
+    if not arg:
+        for i, m in enumerate(choices, 1):
+            mark = "[green]●[/]" if m.key == current.key else " "
+            c.print(
+                f"  {i}. {mark} [bold]{escape(m.name)}[/] [dim]({m.key})[/]  "
+                f"{escape(catalog.describe(m, hardware, installed))}"
+            )
+            if m.measured:
+                c.print(f"        [dim]{escape(m.measured)}[/]")
+        try:
+            arg = input(f"  Switch to which model? (number or name, Enter to keep {current.name}): ").strip()
+        except EOFError:
+            return
+        if not arg:
+            return
+    model = catalog.load().find(arg, s.mode)
+    if model is None:
+        c.print(f"[red]There's no {s.mode} model {escape(arg)!r}: choose 1 to {len(choices)}, or a name.[/]")
+        return
+    s.image_model = model.key
+    c.print(f"[green]Image model: {escape(model.name)}.[/]")
+    if installed is not None:
+        _, missing = catalog.chosen_files(model, installed)
+        if missing:
+            size = sum(f.gb for f in missing)
+            c.print(f"[dim]Not installed yet: {size:.1f} GB download with your next image (you're asked first).[/]")
+
+
 def switch_model(agent: Agent, wanted: str, hardware: Hardware) -> None:
     """Switch to a catalog key or an installed model, and size the context for it."""
     from lcode.cli import NotInstalled, resolve_model
@@ -1116,13 +1155,8 @@ def handle_command(agent: Agent, line: str, hardware: Hardware) -> bool:
     elif cmd in ("/context", "/ctx"):
         context_command(agent, arg, hardware)
     elif cmd in ("/models", "/model"):
-        if s.mode == "image":
-            c.print(
-                f"Image model: [bold]{media.image_model()}[/], through ComfyUI. "
-                "[dim]More image models, and installing them from lcode, come with #150.[/]"
-            )
-        elif s.mode != "code":
-            c.print(f"[yellow]{escape(modes.ready(agent))}[/]")
+        if s.mode != "code":
+            media_model_command(agent, arg, hardware)
         else:
             model_command(agent, arg, hardware)
     elif cmd == "/think":

lcode/workflows/flux2-klein-4b-t2i.json

@@ -1,12 +1,5 @@
 {
-  "name": "FLUX.2 klein 4B",
-  "task": "text-to-image",
   "source": "ComfyUI's template image_flux2_klein_text_to_image (the distilled 4B subgraph), in API format",
-  "models": {
-    "diffusion_models": ["flux-2-klein-4b-fp8.safetensors", "flux-2-klein-4b.safetensors"],
-    "text_encoders": ["qwen_3_4b.safetensors"],
-    "vae": ["flux2-vae.safetensors"]
-  },
   "defaults": {"width": 1024, "height": 1024, "steps": 4, "batch": 1},
   "labels": {
     "1": "loading the model",
@@ -18,8 +11,8 @@
     "13": "saving"
   },
   "graph": {
-    "1": {"class_type": "UNETLoader", "inputs": {"unet_name": "$diffusion_models", "weight_dtype": "default"}},
-    "2": {"class_type": "CLIPLoader", "inputs": {"clip_name": "$text_encoders", "type": "flux2", "device": "default"}},
+    "1": {"class_type": "UNETLoader", "inputs": {"unet_name": "$model", "weight_dtype": "default"}},
+    "2": {"class_type": "CLIPLoader", "inputs": {"clip_name": "$text_encoder", "type": "flux2", "device": "default"}},
     "3": {"class_type": "VAELoader", "inputs": {"vae_name": "$vae"}},
     "4": {"class_type": "CLIPTextEncode", "inputs": {"text": "$prompt", "clip": ["2", 0]}},
     "5": {"class_type": "ConditioningZeroOut", "inputs": {"conditioning": ["4", 0]}},

lcode/workflows/z-image-turbo-t2i.json

@@ -0,0 +1,31 @@
+{
+  "source": "ComfyUI's template image_z_image_turbo_int8 (its Text to Image subgraph), in API format",
+  "defaults": {"width": 1024, "height": 1024, "steps": 8, "batch": 1},
+  "labels": {
+    "1": "loading the model",
+    "2": "loading the text encoder",
+    "3": "loading the VAE",
+    "4": "reading the prompt",
+    "8": "drawing",
+    "9": "decoding the image",
+    "10": "saving"
+  },
+  "graph": {
+    "1": {"class_type": "UNETLoader", "inputs": {"unet_name": "$model", "weight_dtype": "default"}},
+    "2": {"class_type": "CLIPLoader", "inputs": {"clip_name": "$text_encoder", "type": "lumina2", "device": "default"}},
+    "3": {"class_type": "VAELoader", "inputs": {"vae_name": "$vae"}},
+    "4": {"class_type": "CLIPTextEncode", "inputs": {"text": "$prompt", "clip": ["2", 0]}},
+    "5": {"class_type": "ConditioningZeroOut", "inputs": {"conditioning": ["4", 0]}},
+    "6": {"class_type": "ModelSamplingAuraFlow", "inputs": {"model": ["1", 0], "shift": 3}},
+    "7": {"class_type": "EmptySD3LatentImage", "inputs": {"width": "$width", "height": "$height", "batch_size": "$batch"}},
+    "8": {
+      "class_type": "KSampler",
+      "inputs": {
+        "model": ["6", 0], "seed": "$seed", "steps": "$steps", "cfg": 1, "sampler_name": "res_multistep",
+        "scheduler": "simple", "positive": ["4", 0], "negative": ["5", 0], "latent_image": ["7", 0], "denoise": 1
+      }
+    },
+    "9": {"class_type": "VAEDecode", "inputs": {"samples": ["8", 0], "vae": ["3", 0]}},
+    "10": {"class_type": "SaveImage", "inputs": {"images": ["9", 0], "filename_prefix": "lcode/image"}}
+  }
+}

{lcode_cli-0.40.0.dist-info → lcode_cli-0.41.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.40.0
+Version: 0.41.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.40.0.dist-info → lcode_cli-0.41.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-lcode/__init__.py,sha256=5OHrzT0Z3PkCU2LFU_hQ-JKJZ--Z4VVNqZ-UA5bp6xc,473
+lcode/__init__.py,sha256=cP-2ftJ2hz9SKhg5hKS4FosPfEa3qxeHu6hAb4URJQ8,473
 lcode/__main__.py,sha256=s5N5pryX2FAu93GGZ3FxUrIXHWGzxz66lKUoaV_h8Ws,35
 lcode/acp.py,sha256=d97VV3sbqXdWKhPQQNbYRaDTm8WrUk0mGbDLiOyX7jE,29058
 lcode/action.py,sha256=wuT5F9EJCdEligPeytzmEi8FpahWBhXer528tpuTj_k,16711
-lcode/agent.py,sha256=LUccXchM3_p9OBnkaz8LmZ8fnzs7nduuEHusYFF8KjE,87254
-lcode/api.py,sha256=EOxX1K0zuCcFVbS0i4o_3s-8zhSddZueABWKJZJw54g,17592
+lcode/agent.py,sha256=-RZXqheMdbwjRkwMPGBnj_kkRfrAUYkqOLMc888gXgo,87528
+lcode/api.py,sha256=jQmx-ddJC6MoNcRcaWoERs2Ci6KYzBto9GxdVBE7JkU,17632
 lcode/backends.py,sha256=343alwyDZin-bEhb5-Es4f8ek1oBQUzEvV6RFWR1VZo,21160
 lcode/bench.py,sha256=HxeUfy9Kv_0Rug1HAlDLyHYfYd9dw2bMgbXsvUy9nd4,43096
 lcode/bench_backend.py,sha256=X2fo-zRX92Xp3KMxSsFlWioc2vRupBTtowj5kLME8mw,14287
@@ -11,12 +11,12 @@ lcode/bench_runtime.py,sha256=EjzNgIvUkdbT8cbSy1TpmlyeIk6e-ipjlDFpM7Dnqx0,6835
 lcode/catalog.py,sha256=pZ1azX9OH2r4JE2c6E5OfwywpgS39-W2oXzoCHJhmtM,4141
 lcode/checkpoints.py,sha256=eqPtmPe44-aweWqc2H21ROogwzIt3NpvcUobsaCHoGY,18354
 lcode/checks.py,sha256=haYYIPhadKavGYEhh8YWAaWrPMcfzrpT2i6638f4xjQ,12933
-lcode/cli.py,sha256=svC4ipRs3n27brmBKc1vTWMM1JItP5KtV_BwTXEbfaU,48619
+lcode/cli.py,sha256=WuQW4Ao_TbJ0HKFOaFtJnyjvv-lwGYRg_tb0vI-zIg0,51296
 lcode/clipboard.py,sha256=nTSdJyCXPdtjH947RjvB3QvRqnL5HZsS9KB8EkC42cc,5138
 lcode/cloud.py,sha256=q5Dl5GuqWvKzBCIso-eh6yomvEOsnQ0LW8ZgaAGwBxc,2131
 lcode/codesearch.py,sha256=Io8leN1nb_Y-Dvlm9xaGtwUWYXX-ooswuznJV6dGU1s,10766
-lcode/comfy.py,sha256=N2yh3bem1cJ0mEwlRFkViZY3tR7l5_IBrV-OEXYhkoo,26510
-lcode/config.py,sha256=jJ0-nVAiwGR8tZPbCRbFVGH-FhsOUTHXBaclUS58Ipk,13202
+lcode/comfy.py,sha256=tCXSWH9Lk0MsU6031-a6LSOTNSZ1h9G3ZvFwh3d_LPo,26357
+lcode/config.py,sha256=EwMp3h0kHoLqHJc1sGCsXYjzj79gpg2HgMhGz1Ol1q0,13569
 lcode/context.py,sha256=wgK16ZcNNnq4ngHx0EmtyKHDFTImciGEmtC5NP8tKJQ,20435
 lcode/escalate.py,sha256=f-_6_moPaHi2kLuJw2JtkzvTkCl6DoBQgYBOCYLhunM,15120
 lcode/extensions.py,sha256=W0HFDl0BvROzr7i_qtabHdIbacBgP5o5qIJLzoM2oNE,16806
@@ -28,17 +28,19 @@ lcode/jobs.py,sha256=P1P3FqI6EqL4LgdMX9YGZwCW0Bh5BRXFA_FnQxpHNjE,5618
 lcode/limits.py,sha256=oJzVQoMyTZ0_Fkpu5t3qxrf9v7Hv9S8U8BRQR5M1aKA,1237
 lcode/lsp.py,sha256=NtSW7xapv7fg2HAQLuYK1nwIqT7nG0LK1hiTpOmla_4,26086
 lcode/matching.py,sha256=2N3_qwKJ5gd8el2m_y_egKkFM9rsF1eUhYJcRCVIp98,14015
-lcode/media.py,sha256=f_CrXKhL6UgGOlP01AhexXczT7oVbpOvM55uwCeOnJw,10352
+lcode/media.py,sha256=laRxRuBPGoOK1e2W6cjNHySps8OO9N6UiauuAtGmlyk,11870
+lcode/media.toml,sha256=8vqFwqE8ECizDkUlnWGLfhcx94vEG1WfRCpJPHTi3UQ,3225
+lcode/media_catalog.py,sha256=rtJPS3S7ZgJjaY3HIRerhf4ciqzXt4BsOikoQavzPAI,13076
 lcode/memory.py,sha256=WZEHTp-lVxAwS-yyLQR2xB3TMZ9sejmX2Ivg7T-tl3w,21949
 lcode/models.toml,sha256=lt2G64zzo_Ryxv2ISRSNZoVD_JqCqYqsM01n8WoXGs8,4098
-lcode/modes.py,sha256=RLfkWK5ColTnOd-Yp3g1rkKhNHVhxRR7HHvjSNYbZWk,4984
+lcode/modes.py,sha256=Ke_mEeYF_SskbVUXMpJMeV5d5fFEQ-Vb-MKp4SIvT0Y,4990
 lcode/notify.py,sha256=uieDeXe7XwuVHjOk4tqVyZEW_85XWkoWQmFOWEf77oc,1538
 lcode/ollama.py,sha256=xFHU2XW47ANJ34-1aeSMQVj28GhqcWiFi6zASH9FiYY,8053
 lcode/permissions.py,sha256=q7CjDsc_Xrblw7t3_BbxA5LUjxFSswGs1RiJmtMi0po,12288
 lcode/planning.py,sha256=Q2upaoZPnXDMQT2F-ETxX1lk_wDntTzhSKNVYIQSoQA,6540
 lcode/render.py,sha256=gMvf4W3qkLUJ4Vot3az_hP_zRDAItJC9pP-68dHFkfA,1375
 lcode/repeats.py,sha256=OTrPdb6BKArDLQEgHaXmJZ-tIFsY_1bk4P0wzzANKLY,5964
-lcode/repl.py,sha256=PV1vjWfGhedufacf_BK8AntXLeJWmf59_W0ZCnSsrt4,61198
+lcode/repl.py,sha256=Jjs45rvONRX2F3hx9Q-o3WkcepC_rKIqOE9okdlhNe8,62649
 lcode/repomap.py,sha256=1GRJgEUjBl9XHSXsF7tSGXBCEgsY-3CzwMohaTudZ_M,13969
 lcode/residency.py,sha256=B9pwqG6yx5aQD2M5xyQ-bMnYmhD7fv3wCVw_X6VIeAo,7012
 lcode/review.py,sha256=0QBIS-R1B2b3zqx5TcC1qZptpKBbrDhYvMKSNCaDAUo,4686
@@ -70,9 +72,10 @@ lcode/servers/encord.py,sha256=WSauawL1UKYZCUAG1oalcKL_An3DVof-JM6xIgFyQSE,12769
 lcode/servers/valohai.py,sha256=e5xZGIoa4cja4f5i85q1GpL9c7cglUjV8jN2co1CFMY,14430
 lcode/servers/xai.py,sha256=h2emAvHSnkuB9WmJInlynsDhvxJwNVD2AHFX7vqMXNc,13627
 lcode/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lcode/workflows/flux2-klein-4b-t2i.json,sha256=-ThgsKHMhEsfSUAcn51rs9SJMM64iDPpDkQI4U9B1Xk,2052
-lcode_cli-0.40.0.dist-info/METADATA,sha256=j6QWyDsxjUKhQwOhCEnYBo-1CkjZPTTO3w8KEDHGQn8,13386
-lcode_cli-0.40.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-lcode_cli-0.40.0.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
-lcode_cli-0.40.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
-lcode_cli-0.40.0.dist-info/RECORD,,
+lcode/workflows/flux2-klein-4b-t2i.json,sha256=yGrYDT8pG2bns9DS1JavhlX5fwhDgIKfAwrHrRCyE8k,1788
+lcode/workflows/z-image-turbo-t2i.json,sha256=sHsL7xnnuULOuWGYlQrDl4jOTySdAmb2T82c_cChv0s,1585
+lcode_cli-0.41.0.dist-info/METADATA,sha256=MitknSeSrdiXm2qjDMKu5eT_xBdeAcFIqxT9oEfvwhM,13386
+lcode_cli-0.41.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lcode_cli-0.41.0.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
+lcode_cli-0.41.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
+lcode_cli-0.41.0.dist-info/RECORD,,