lcode-cli 0.38.0__tar.gz → 0.39.0__tar.gz

{lcode_cli-0.38.0 → lcode_cli-0.39.0}/CHANGELOG.md

@@ -6,6 +6,27 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.39.0] - 2026-10-23
+
+### Added
+
+- **Modes: code, image and video** (#148). `/mode image`, `/mode video` and `/mode code` switch
+  what lcode makes. `lcode --mode` starts in one, and the `mode` setting is the default. The
+  banner, status bar and prompt show the mode, and sessions keep theirs.
+  - **The GPU goes to one model at a time:** switching to image or video mode unloads the coding
+    model, and switching back asks ComfyUI to free its memory.
+  - **Image and video mode don't generate yet:** they say what's coming (#149–#157) instead of
+    sending your words to the coding model. See [Modes](https://nasser1941.github.io/lcode/modes/).
+
+### Changed
+
+- **Code mode makes code only.** The MCP servers that generated images and videos (`comfyui`,
+  `xai`) are out of the MCP catalog, and lcode doesn't load them in code mode even if they're
+  still in `mcp.json` (it says so once). Image and video generation are moving to their own modes.
+- **`/mode` switches code, image and video.** The permission mode is set with `/permissions` now;
+  `/mode yolo` and the like still work, with a note. Shift+Tab cycles the permission mode as
+  before.
+
 ## [0.38.0] - 2026-10-21
 
 ### Added
@@ -855,7 +876,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.38.0...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.39.0...HEAD
+[0.39.0]: https://github.com/nasser1941/lcode/compare/v0.38.0...v0.39.0
 [0.38.0]: https://github.com/nasser1941/lcode/compare/v0.37.0...v0.38.0
 [0.37.0]: https://github.com/nasser1941/lcode/compare/v0.36.0...v0.37.0
 [0.36.0]: https://github.com/nasser1941/lcode/compare/v0.35.1...v0.36.0

{lcode_cli-0.38.0 → lcode_cli-0.39.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.38.0
+Version: 0.39.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.38.0 → lcode_cli-0.39.0}/docs/configuration.md

@@ -23,6 +23,8 @@ lcode config path                      # print the file location
 | `backend` | `ollama` | The model server: `ollama`, `lmstudio`, `llama.cpp`, `vllm`, `mlx` or `openai` (any OpenAI-compatible API); see [Other model servers](servers.md) |
 | `base_url` | the backend's | The server's OpenAI-compatible address, e.g. `http://localhost:1234/v1` |
 | `permission_mode` | `ask` | `ask`, `plan`, `auto-edit` or `yolo` |
+| `mode` | `code` | What lcode makes when it starts: `code`, `image` or `video` ([modes](modes.md)) |
+| `comfyui_url` | `http://127.0.0.1:8188` | ComfyUI's address, for image and video mode |
 | `think` | `true` | Let the model reason before answering |
 | `web` | `on` | Web search and page fetching: `on`, `ask` (before each search/website) or `off` |
 | `search_backend` | `auto` | `auto`, `ollama`, `brave`, `tavily` or `searxng`; `auto` uses the first one configured |

{lcode_cli-0.38.0 → lcode_cli-0.39.0}/docs/mcp.md

@@ -28,8 +28,6 @@ and find the code for the top one."*
 | `gcp` | `gcloud` commands on your Google Cloud projects | `npx` and the `gcloud` CLI, signed in |
 | `github` | Repositories, issues, pull requests, Actions | a GitHub token (or the GitHub CLI) |
 | `playwright` | A real (headless) browser: open pages, click, fill forms | `npx` |
-| `comfyui` | Generate and edit images with local models (FLUX, SDXL, SD 1.5, Qwen-Image) | `uvx` and [ComfyUI](#images-with-comfyui) running locally |
-| `xai` | Generate and edit images, and generate videos and speech, with xAI's Grok Imagine (paid, in the cloud) | `uvx`, an xAI API key ([below](#images-videos-and-speech-with-xai)) |
 | `context7` | Up-to-date docs and examples for thousands of libraries | nothing (an API key is optional) |
 | `sentry` | Errors, issues, traces and releases | a Sentry account (browser sign-in) |
 | `postgres` | Schemas, read-only queries, query performance | `uvx`, a connection URL |
@@ -87,86 +85,12 @@ Google Cloud project:
 See [Google's guide](https://developers.google.com/workspace/guides/configure-mcp-servers) for
 details.
 
-### Images with ComfyUI
+### Images and videos
 
-[ComfyUI](https://github.com/comfyanonymous/ComfyUI) runs image generation and editing models
-locally; its official MCP server lets lcode use it, for app icons, illustrations, mockups or
-placeholder art.
-
-```bash
-uv tool install comfy-cli && comfy install                 # ComfyUI, once
-comfy launch --background -- --disable-smart-memory          # start it (http://127.0.0.1:8188)
-lcode mcp add comfyui
-```
-
-Then add models in ComfyUI (its model manager, or ask lcode: *"download FLUX.2 Klein 4B in
-ComfyUI"*), and ask for images: *"make a 512×512 app icon of a paper plane and save it in
-assets/"*. To edit an image, ask lcode to upload it and run an editing workflow (Kontext or
-Qwen-Image-Edit).
-
-| Model | Good for | On a 12 GB GPU |
-|---|---|---|
-| FLUX.2 Klein 4B | Generation and editing, fast | Fits (about 8 GB) |
-| SDXL and its community models | Generation, inpainting | Fits |
-| Stable Diffusion 1.5 and its community models | Light generation, inpainting | Fits easily |
-| FLUX.1 Dev and finetunes | High-quality generation | Needs an fp8 or GGUF version; slower |
-| FLUX.1 Kontext Dev | Editing an image from instructions | Needs an fp8 or GGUF version; slower |
-| Qwen-Image / Qwen-Image-Edit | Generation and editing, good text in images | Heavy: a GGUF version and RAM offloading |
-
-Only ComfyUI's local tools are turned on; Comfy Cloud's partner tools are left out, so prompts and
-images stay on your machine.
-
-**Sharing one GPU.** A GPU rarely holds a coding model and an image model at the same time, so the
-two take turns: before ComfyUI generates, lcode unloads its own model (the `free_gpu` setting), and
-ComfyUI started with `--disable-smart-memory` gives the GPU back after each image. lcode's model
-then reloads for the next step, which adds a few seconds to half a minute per image request. With
-enough GPU memory for both (or on a Mac with plenty of memory), remove `free_gpu` from the server's
-settings in `mcp.json`. lcode can also look at the results ([Images](usage.md#images)).
-
-Measured on an RTX 4080 Laptop GPU (12 GB) with qwen3.6-35b at 64K context and FLUX.2 Klein Base 4B
-(fp8, 512×512, 20 steps):
-
-| | |
-|---|---|
-| Generating while lcode's model is loaded | Fails: ComfyUI runs out of GPU memory |
-| Freeing the GPU (lcode unloads its model) | 0.2 s |
-| Generating one image | about 12 s |
-| Reloading lcode's model afterwards | about 20 s |
-
-The first time, the model has to find the right template and fill in its settings (model file names,
-size, prompt), which can take several minutes of trial and error. Once an image comes out right, ask
-lcode to save that workflow in your project (for example `assets/icon.workflow.json`) and reuse it:
-later images are a single `run_workflow` call.
-
-### Images, videos and speech with xAI
-
-xAI's [Grok Imagine](https://docs.x.ai/developers/model-capabilities/imagine) and
-[text to speech](https://docs.x.ai/developers/models/text-to-speech) APIs make images, videos and
-speech in the cloud: no GPU needed, but each call is billed to your xAI account. lcode ships an MCP
-server for them, `lcode-mcp-xai`.
-
-```bash
-lcode mcp add xai             # asks for your xAI API key (create one at https://console.x.ai)
-```
-
-The key is typed hidden and kept in `~/.config/lcode/mcp.json`, readable only by you. If
-`XAI_API_KEY` is already set in your environment, lcode uses that and doesn't store the key.
-
-| Tool | | Costs |
-|---|---|---|
-| `generate_image` | Images from a description: 1–10 at a time, aspect ratio, 1k or 2k | $0.02–0.05 an image |
-| `edit_image` | Change a local image as described | the same |
-| `generate_video` | A 1–15 second MP4 from a description, optionally starting from a local image, up to 1080p. Waits for it (a minute or more) | $0.02–0.08 a second |
-| `video_status` | Fetch a video that wasn't ready within 10 minutes | |
-| `text_to_speech` | Speech in one of 26 voices and 20 languages, as MP3 or WAV | per character |
-
-Files are saved in `generated/` in the project, or where you ask (*"generate an app icon and save
-it as assets/icon.png"*). xAI has no music generation API.
-
-Your prompts, and the images you edit or animate, go to xAI. lcode asks before each call, since each
-one costs money. To stop asking for some tools, list them under `"allow"` for the server in
-`mcp.json`, for example `"allow": ["generate_image", "text_to_speech"]`. xAI applies its own usage
-policies to what it generates; when it refuses a prompt, lcode passes its message to the model.
+Code mode makes code only, so the servers that generated images and videos in earlier versions
+(`comfyui`, `xai`) aren't in the catalog any more, and lcode doesn't load them in code mode if
+they're still in your `mcp.json`. Image and video generation get their own [modes](modes.md),
+with their own models and controls.
 
 ### Metabase
 

lcode_cli-0.39.0/docs/modes.md

@@ -0,0 +1,58 @@
+# Modes: code, image and video
+
+lcode makes three kinds of things, each in its own mode with its own models:
+
+| Mode | What it makes | The model doing the work |
+|---|---|---|
+| **code** (default) | Code: it reads, writes, runs and checks your project | A coding language model in Ollama (or another server) |
+| **image** | Images from a description and reference images | An image model, run by ComfyUI on your GPU |
+| **video** | Videos from a description, a start image or references | A video model, run by ComfyUI on your GPU |
+
+```text
+❯ /mode image
+Mode: image (local image generation).
+Unloaded qwen3.6-35b to free the GPU for images.
+image ❯
+```
+
+- **Switching:** `/mode code`, `/mode image` and `/mode video` switch in a session. `lcode --mode image`
+  starts in one, and `lcode config set mode video` makes it the default. `/mode` alone shows
+  the current one.
+- **Where it shows:** the banner, the status bar and the prompt (`image ❯`) show the mode.
+- **Sessions:** a session keeps the mode it was made in, and resuming it brings that mode back.
+
+## Code mode makes code only
+
+Code mode is the coding agent, as before, and it no longer generates images or videos. The MCP
+servers that did (`comfyui` and `xai`) are gone from the MCP catalog, and lcode doesn't load them
+in code mode even if they're still in your `mcp.json`. It says so once.
+
+## One model on the GPU at a time
+
+Image and video modes don't need the big coding model: the image or video model does the work. A
+small optional model will help with prompts later. Image and video models need the GPU to
+themselves:
+
+- **Into image or video mode:** lcode unloads its coding model from Ollama.
+- **Back to code mode:** lcode asks ComfyUI to free its memory (at `comfyui_url`, by default
+  `http://127.0.0.1:8188`), then loads the coding model again in the background.
+
+## Coming next
+
+Image and video modes don't generate yet. Until the items below arrive, a request in those modes
+says what's coming instead of going anywhere.
+
+- **#149 Local generation engine:** lcode drives ComfyUI itself: finding or installing it, jobs,
+  progress, cancelling, and saving outputs with their settings.
+- **#150 Media model catalog:** image and video models that fit your machine, installed on
+  demand.
+- **#151, #152 Image mode:** generating, variations, sizes and seeds, a gallery, editing,
+  references, inpainting, upscaling.
+- **#153, #154 Video mode:** from text or a start image, first and last frames, several
+  references, camera moves, longer clips, 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).
+
+The permission mode (`ask`, `plan`, `auto-edit`, `yolo`) is a different setting: `/permissions`
+sets it, and Shift+Tab cycles it as before.

{lcode_cli-0.38.0 → lcode_cli-0.39.0}/docs/quickstart.md

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

{lcode_cli-0.38.0 → lcode_cli-0.39.0}/docs/usage.md

@@ -79,7 +79,8 @@ reasoning is on.
 | `/models`, `/model [number or name]` | List the models and how they fit this machine, numbered: type a number to switch, or `/model 2`, `/model qwen3.5-9b` |
 | `/think [on\|off]` | Toggle reasoning |
 | `/verbose` | Toggle showing the reasoning text |
-| `/mode [ask\|plan\|auto-edit\|yolo]` | Set the permission mode |
+| `/mode [code\|image\|video]` | Switch what lcode makes: [code, images or videos](modes.md) |
+| `/permissions [ask\|plan\|auto-edit\|yolo]` | Set the permission mode |
 | `/cd DIR` | Change the working directory |
 | `/todos` | Show the model's task list |
 | `/status` | The task sheet: your latest requests, the plan and the model's notes, files changed, the last check |
@@ -315,7 +316,7 @@ stays loaded:
 | The model was loaded | `◆ Loaded qwen3.6-35b in 15s: 22.3 GB, 45% on the GPU and the rest in system RAM.`, and a warning when less of it is on the GPU than usual, because another program or model is using GPU memory |
 | A dense model doesn't fit on the GPU (at startup and on `/model`) | `⚠ qwen3.8-27b is a dense model: all 27B parameters work on every token. It's capable, but slow here. Only about 61% of it fits in the 12 GB of GPU memory…`, with what to do instead |
 | The model that looks at images needs the memory | `Loading the vision model … to look at bug.png; qwen3.6-35b makes room and reloads afterwards`, then `◆ qwen3.6-35b was unloaded to make room…`, and the next step says `Reloading qwen3.6-35b into memory (it made room for the vision model …)` |
-| A tool needs the GPU to itself, such as image generation | `◆ Unloaded qwen3.6-35b so comfyui can use the GPU; it reloads afterwards.` |
+| A tool needs the GPU to itself (an MCP server with `free_gpu`) | `◆ Unloaded qwen3.6-35b so the server can use the GPU; it reloads afterwards.` |
 | Ollama ran out of memory | `⚠` what ran out (the prompt batch, or the context next to the model), what lcode retries with, and what it remembers for next time |
 
 While the model loads in the background at startup, the status bar says
@@ -470,7 +471,7 @@ a screen and sees what you would, measured:
 | `auto-edit` | automatic | ask, except read-only commands |
 | `yolo` | automatic | automatic |
 
-++shift+tab++ cycles through them in this order, `/mode` sets one, and `--plan`, `--auto-edit` and
+++shift+tab++ cycles through them in this order, `/permissions` sets one, and `--plan`, `--auto-edit` and
 `--yolo` start in one.
 
 Read-only commands run without asking: `ls`, `cat`, `head`, `tail`, `grep`, `rg`, `find`, `tree`,

{lcode_cli-0.38.0 → lcode_cli-0.39.0}/mkdocs.yml

@@ -92,6 +92,7 @@ nav:
       - Quickstart: quickstart.md
   - Guide:
       - Using lcode: usage.md
+      - Modes (code, image, video): modes.md
       - Memory: memory.md
       - Subagents: agents.md
       - Commands and skills: commands.md

{lcode_cli-0.38.0 → lcode_cli-0.39.0}/src/lcode/__init__.py

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

{lcode_cli-0.38.0 → lcode_cli-0.39.0}/src/lcode/agent.py

@@ -304,6 +304,8 @@ class Progress:
 class Settings:
     model: str  # Ollama model name to call
     context: int
+    mode: str = "code"  # what lcode makes: code, image or video (lcode.modes)
+    comfyui_url: str = "http://127.0.0.1:8188"
     num_batch: int | None = None
     keep_alive: str = "30m"
     think: bool = True
@@ -680,6 +682,7 @@ class Agent:
         data = {
             "cwd": str(self.workspace),  # where `lcode -c` there finds it, wherever the shell moved
             "model": self.settings.model,
+            "mode": self.settings.mode,
             "name": self.session_name,
             "title": self.session_title,
             "messages": self.messages,
@@ -726,6 +729,8 @@ class Agent:
         self.session_id = info.id
         self.checkpoints.load(info.id, data.get("checkpoints") or [])
         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
         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_cli-0.38.0 → lcode_cli-0.39.0}/src/lcode/api.py

@@ -54,6 +54,7 @@ class Options:
     model: str | None = None
     context: int | str | None = None
     permission_mode: str | None = None  # ask, plan, auto-edit or yolo
+    mode: str | None = None  # code, image or video
     allowed_tools: list[str] | None = None  # only these tools (default: all)
     max_steps: int | None = None  # model steps per request
     think: bool | None = None
@@ -179,6 +180,8 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
         think=cfg["think"] if options.think is None else options.think,
         show_thinking=options.show_thinking,
         permission_mode=options.permission_mode or cfg["permission_mode"],
+        mode=options.mode or cfg["mode"],
+        comfyui_url=cfg["comfyui_url"],
         web=switch(options.web, cfg["web"], "on"),
         search_backend=cfg["search_backend"],
         searxng_url=cfg["searxng_url"],

{lcode_cli-0.38.0 → lcode_cli-0.39.0}/src/lcode/cli.py

@@ -714,6 +714,7 @@ def cmd_chat(args) -> None:
         model=args.model,
         context=args.context,
         permission_mode=mode,
+        mode=args.mode,
         allowed_tools=tools,
         max_steps=args.max_steps,
         think=False if args.no_think else None,
@@ -733,6 +734,16 @@ def cmd_chat(args) -> None:
             sys.exit(1)
         fail(str(e))
     exit_code = 0
+    if args.prompt and agent.settings.mode != "code":
+        from lcode import modes
+
+        message = modes.COMING[agent.settings.mode]
+        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)
     if args.escalate and args.prompt:
         agent.escalate_approved = True  # the flag is the user's OK for this run
     try:
@@ -798,6 +809,7 @@ def build_parser() -> argparse.ArgumentParser:
         help="work in a git worktree of its own, on branch NAME (new, or continue one); removed if nothing changed",
     )
     parser.add_argument("--plan", action="store_true", help="start in plan mode: agree on a plan before any change")
+    parser.add_argument("--mode", choices=config.WORK_MODES, help="what lcode makes: code (default), image or video")
     parser.add_argument("--auto-edit", action="store_true", help="apply file edits without asking")
     parser.add_argument("--yolo", action="store_true", help="never ask for permission (edits and commands)")
     parser.add_argument(

{lcode_cli-0.38.0 → lcode_cli-0.39.0}/src/lcode/config.py

@@ -23,6 +23,7 @@ else:
 
 DEFAULT_MODEL = "qwen3.6-35b"
 PERMISSION_MODES = ("ask", "plan", "auto-edit", "yolo")  # Shift+Tab cycles in this order
+WORK_MODES = ("code", "image", "video")  # what lcode makes (lcode.modes)
 WEB_MODES = ("on", "ask", "off")
 SEARCH_BACKENDS = ("auto", "ollama", "brave", "tavily", "searxng")
 MCP_TOOL_MODES = ("auto", "direct", "search")
@@ -40,6 +41,8 @@ SETTINGS: dict[str, tuple[object, type, str]] = {
     "backend": ("ollama", str, "model server: ollama | lmstudio | llama.cpp | vllm | mlx | openai (any OpenAI API)"),
     "base_url": (None, str, "OpenAI-compatible server address, e.g. http://localhost:1234/v1 (default: the backend's)"),
     "permission_mode": ("ask", str, "ask | plan | auto-edit | yolo"),
+    "mode": ("code", str, "what lcode makes when it starts: code | image | video"),
+    "comfyui_url": ("http://127.0.0.1:8188", str, "ComfyUI, for image and video mode"),
     "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)"),
@@ -203,6 +206,8 @@ def coerce(key: str, value: object) -> object:
         raise ConfigError(f"search_backend must be one of {', '.join(SEARCH_BACKENDS)}")
     if key == "permission_mode" and value not in PERMISSION_MODES:
         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 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_cli-0.38.0 → lcode_cli-0.39.0}/src/lcode/mcp/catalog.toml

@@ -130,34 +130,6 @@ requires = ["npx"]
 setup = "Runs a headless browser; the first use may download it."
 server = { command = "npx", args = ["-y", "@playwright/mcp@latest", "--headless"] }
 
-[comfyui]
-name = "ComfyUI"
-description = "Generate and edit images with models you run locally in ComfyUI: FLUX, SDXL, SD 1.5, Qwen-Image"
-homepage = "https://github.com/Comfy-Org/comfy-mcp"
-requires = ["uvx"]
-setup = """Needs ComfyUI on this machine (http://127.0.0.1:8188) with at least one image model:
-  uv tool install comfy-cli && comfy install
-  comfy launch --background -- --disable-smart-memory
---disable-smart-memory makes ComfyUI give the GPU back after each image. Before generating, lcode
-unloads its own model so ComfyUI has the GPU; it reloads afterwards. Only the local tools are on;
-Comfy Cloud's partner tools are left out, so nothing leaves this machine."""
-
-[comfyui.server]
-command = "uvx"
-args = ["--python", "3.12", "--from", "comfy-mcp", "--with", "comfy-cli>=1.14.0", "comfy-mcp"]
-env = { COMFYUI_URL = "${COMFYUI_URL}" }
-tools = [
-  "server_info", "generate_image", "run_workflow", "run_template", "search_templates", "get_template", "fetch_template",
-  "list_workflow_slots", "set_workflow_slot", "job", "fetch_outputs", "upload_file", "search_models",
-  "download_model", "system_stats", "free_memory", "launch_comfyui",
-]
-free_gpu = ["generate_image", "run_workflow", "run_template"]
-
-[[comfyui.inputs]]
-var = "COMFYUI_URL"
-prompt = "ComfyUI address (Enter for this machine, 127.0.0.1:8188)"
-optional = true
-
 [context7]
 name = "Context7"
 description = "Current documentation and code examples for thousands of libraries"
@@ -282,23 +254,3 @@ var = "VALOHAI_HOST"
 prompt = "Valohai address (Enter for app.valohai.com; for a self-hosted installation, its URL)"
 optional = true
 
-[xai]
-name = "xAI Grok Imagine"
-description = "Generate and edit images, and generate videos and speech, with xAI's Grok Imagine and voice API (paid, in the cloud)"
-homepage = "https://nasser1941.github.io/lcode/mcp/#xai"
-requires = ["uvx"]
-setup = """Uses xAI's API: your prompts, and images you edit or animate, go to xAI, and every call is billed to your xAI
-account (an image $0.02-0.05, video $0.02-0.08 a second, speech per character). Create an API key at https://console.x.ai.
-Files are saved in generated/ in the project. lcode asks before each call; to stop asking for some tools, list them
-under "allow" for this server in mcp.json. xAI has no music generation."""
-
-[xai.server]
-command = "uvx"
-args = ["--isolated", "--python", "3.12", "--from", "lcode-cli", "lcode-mcp-xai"]
-env = { XAI_API_KEY = "${XAI_API_KEY}" }
-timeout = 900  # a video takes minutes
-
-[[xai.inputs]]
-var = "XAI_API_KEY"
-prompt = "xAI API key (create one at https://console.x.ai)"
-secret = true

{lcode_cli-0.38.0 → lcode_cli-0.39.0}/src/lcode/mcp/commands.py

@@ -60,6 +60,12 @@ def start_session(cwd: Path, tool_mode: str, console: Console, interactive: bool
     servers, problems = mcp_config.load_all(cwd, include_project=use_project)
     for problem in problems:
         console.print(f"[yellow]MCP: {escape(problem)}[/]")
+    from lcode import modes
+
+    servers, left_out = modes.code_mode_servers(servers)  # images and videos have their own modes
+    note = modes.note_once(left_out)
+    if note and interactive:
+        console.print(f"[dim]{escape(note)}[/]")
     if not servers:
         return None
     manager = McpManager(cwd, servers, tool_mode)

lcode_cli-0.39.0/src/lcode/modes.py

@@ -0,0 +1,102 @@
+"""What lcode makes: code, images or videos.
+
+- **code** is the coding agent: a language model with tools, and nothing else. It doesn't generate images or
+  videos: the MCP servers that do (`comfyui`, `xai`) aren't loaded in code mode.
+- **image** and **video** generate media on the GPU with image and video models (through ComfyUI, #149). They
+  don't need the big coding model: lcode unloads it when you switch to them, and frees ComfyUI's memory when you
+  switch back, so one model has the GPU at a time.
+
+Until the generation engine lands, image and video mode say what's coming instead of sending the prompt anywhere.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING
+
+import requests
+
+from lcode import config
+
+if TYPE_CHECKING:
+    from lcode.agent import Agent
+    from lcode.mcp.config import ServerConfig
+
+MODES = ("code", "image", "video")
+TITLES = {"code": "local coding agent", "image": "local image generation", "video": "local video generation"}
+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 = {
+    "image": (
+        "Image mode doesn't generate yet: lcode's own ComfyUI engine (#149), the image models (#150) and "
+        "generation (#151) come next. /mode code switches back."
+    ),
+    "video": (
+        "Video mode doesn't generate yet: lcode's own ComfyUI engine (#149), the video models (#150) and "
+        "generation (#153) come next. /mode code switches back."
+    ),
+}
+
+
+def is_media_server(server: ServerConfig) -> bool:
+    """An MCP server that generates images or videos: those belong to image and video mode, not code mode."""
+    if server.name.lower() in MEDIA_SERVERS:
+        return True
+    target = " ".join(str(part) for part in [*server.command, server.url])
+    return any(name in target for name in MEDIA_COMMANDS)
+
+
+def code_mode_servers(servers: list[ServerConfig]) -> tuple[list[ServerConfig], list[str]]:
+    """The servers code mode loads, and the names of the media servers it leaves out."""
+    kept = [s for s in servers if not is_media_server(s)]
+    return kept, [s.name for s in servers if is_media_server(s)]
+
+
+def note_once(left_out: list[str]) -> str:
+    """The note about media servers left out of code mode, the first time only."""
+    if not left_out:
+        return ""
+    marker = config.STATE_DIR / NOTED_FILE
+    if marker.exists():
+        return ""
+    try:
+        marker.parent.mkdir(parents=True, exist_ok=True)
+        marker.write_text(json.dumps(sorted(left_out)) + "\n")
+    except OSError:
+        pass
+    names = ", ".join(left_out)
+    return (
+        f"Code mode makes code only, so the MCP servers that make images and videos ({names}) aren't loaded "
+        "here any more. Image and video generation move to their own modes: /mode image, /mode video."
+    )
+
+
+def free_comfyui(url: str) -> bool:
+    """Ask ComfyUI at `url` to give the GPU back (unload its models, free its memory). Whether it answered."""
+    try:
+        r = requests.post(url.rstrip("/") + "/free", json={"unload_models": True, "free_memory": True}, timeout=3)
+    except requests.RequestException:
+        return False
+    return r.status_code == 200
+
+
+def switch(agent: Agent, new: str) -> list[str]:
+    """Switch the agent to another mode, handing the GPU over. The lines to show."""
+    old = agent.settings.mode
+    if new == old:
+        return [f"Already in {new} mode."]
+    lines = []
+    if old == "code" and getattr(agent.ollama, "kind", "ollama") == "ollama":
+        try:
+            agent.ollama.unload(agent.settings.model)  # the image or video model needs the GPU
+            lines.append(f"Unloaded {agent.settings.model} to free the GPU for {new}s.")
+        except Exception:  # not loaded, or Ollama gone: nothing to free
+            pass
+    if new == "code" and free_comfyui(agent.settings.comfyui_url):
+        lines.append("ComfyUI gave the GPU back.")
+    agent.settings.mode = new
+    lines.insert(0, f"Mode: {new} ({TITLES[new]}).")
+    if new != "code":
+        lines.append(COMING[new])
+    return lines