lcode-cli 0.21.0__py3-none-any.whl → 0.23.0__py3-none-any.whl

lcode/__init__.py

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

lcode/acp.py

@@ -48,7 +48,12 @@ KINDS = {
     "bash": "execute", "web_search": "fetch", "web_fetch": "fetch", "agent": "think", "todo_write": "think",
     "present_plan": "switch_mode", "bash_output": "read", "bash_stop": "execute",
 }  # fmt: skip
-STOP = {"success": "end_turn", "max_steps": "max_turn_requests", "interrupted": "cancelled"}
+STOP = {
+    "success": "end_turn",
+    "max_steps": "max_turn_requests",
+    "loop": "max_turn_requests",
+    "interrupted": "cancelled",
+}
 MAX_INLINE = 200_000  # bytes of a file the editor attaches that go into the prompt
 METHOD_NOT_FOUND, INVALID_PARAMS, INTERNAL_ERROR, NOT_FOUND = -32601, -32602, -32603, -32002
 

lcode/action.py

@@ -297,7 +297,7 @@ def answer(hub: GitHub, task: Task, inputs: Inputs, cwd: Path) -> None:
     )
     with open_session(inputs, cwd) as session:
         result = session.run(prompt)
-        if result.status not in ("success", "max_steps"):
+        if result.status not in ("success", "max_steps", "loop"):
             raise ActionError(result.error or result.status)
         reply = result.text.strip() or "(no answer)"
         changed = git(cwd, "status", "--porcelain").strip()
@@ -336,6 +336,8 @@ def answer(hub: GitHub, task: Task, inputs: Inputs, cwd: Path) -> None:
             reply += f"\n\n{link}"
         if result.status == "max_steps":
             reply += f"\n\n(Stopped after {inputs.max_steps} steps.)"
+        elif result.status == "loop":
+            reply += "\n\n(Stopped: the model kept repeating the same call.)"
         hub.comment(task.number, reply[:MAX_COMMENT] + footer(result))
 
 
@@ -349,7 +351,7 @@ def review(hub: GitHub, task: Task, inputs: Inputs, cwd: Path) -> None:
         prompt = gitflow.review_prompt(session.agent, base)
         session.agent.no_changes = "This is a review, so nothing can be changed: report what should change instead."
         result = session.run(prompt)
-    if result.status not in ("success", "max_steps"):
+    if result.status not in ("success", "max_steps", "loop"):
         raise ActionError(result.error or result.status)
     hub.comment(task.number, f"**lcode review**\n\n{result.text.strip()[:MAX_COMMENT]}{footer(result)}")
 

lcode/agent.py

@@ -32,6 +32,7 @@ from lcode.mcp import McpManager
 from lcode.ollama import Ollama, OllamaError
 from lcode.permissions import Permissions
 from lcode.render import MarkdownStreamer
+from lcode.repeats import Repeats
 from lcode.sandbox import Sandbox, SandboxError, project_root
 from lcode.tools import (
     LSP_SCHEMA,
@@ -57,7 +58,9 @@ MAX_STEPS_PER_TURN = 150
 EVENT_OUTPUT = 4000  # characters of a tool's output in an event
 # How a tool result starts when the call failed or wasn't allowed (an "error" in events and results).
 REFUSED = ("Error:", "A deny rule", "The user denied", "This needs the user's permission")
-MAX_MALFORMED_CALL_RETRIES = 2  # Ollama rejects tool calls whose arguments aren't valid JSON  # safety cap on tool-call iterations for one request
+MAX_MALFORMED_CALL_RETRIES = 2  # Ollama rejects tool calls whose arguments aren't valid JSON
+# How Ollama reports a tool call it couldn't parse (Qwen3.6's calls are XML)
+MALFORMED_CALL = ("error parsing tool call", "XML syntax error")
 AUTO_COMPACT_RATIO = 0.85  # summarize the history when the context is this full
 PRUNED_ENOUGH = 0.6  # after pruning old tool output, summarize only if the context is still this full
 PROJECT_FILES = ("AGENTS.md", "LCODE.md", "CLAUDE.md")
@@ -216,6 +219,7 @@ class Settings:
     notify: bool = False  # desktop notifications after long requests (lcode.notify)
     notify_after: int = 30  # seconds: a request this long notifies when it's done or waits for an answer
     max_parallel_agents: int = 1
+    repeat_limit: int = 3  # identical calls with identical results before the model is told (lcode.repeats)
 
 
 class Agent:
@@ -267,7 +271,8 @@ class Agent:
         # Decides on a presented plan instead of asking in the terminal: "ask", "auto-edit", or why not.
         self.plan_review: Callable[[str, str], str] | None = None
         self.max_steps = MAX_STEPS_PER_TURN
-        self.turn_status = ""  # how the last request ended: success, max_steps
+        self.turn_status = ""  # how the last request ended: success, max_steps, loop
+        self.repeats = Repeats(settings.repeat_limit)  # notices when the model repeats itself
         self.response = None  # the streaming response, so another thread can abort it
         self.ctx_used = 0
         self.last_speed = 0.0
@@ -809,7 +814,9 @@ class Agent:
         self.turn_status = "running"
         note = planning.NOTE if self.planning() and self.allowed_tools is None else ""
         self.messages.append({"role": "user", "content": self.expand_mentions(user_text) + note})
+        self.repeats.reset()
         malformed = 0
+        looping = ""  # the call the model kept repeating, when lcode stopped the request for it
         for step in range(self.max_steps):
             if self.cancel is not None and self.cancel.is_set():
                 raise KeyboardInterrupt
@@ -834,17 +841,22 @@ class Agent:
                     }
                 )
             except OllamaError as e:
-                if "error parsing tool call" not in str(e) or malformed >= MAX_MALFORMED_CALL_RETRIES:
+                if not any(m in str(e) for m in MALFORMED_CALL) or malformed >= MAX_MALFORMED_CALL_RETRIES:
                     raise
                 malformed += 1
-                reason = str(e).rsplit("err=", 1)[-1].strip() if "err=" in str(e) else "invalid JSON"
+                if "err=" in str(e):
+                    reason = str(e).rsplit("err=", 1)[-1].strip()
+                elif "XML syntax error" in str(e):
+                    reason = str(e).split("XML syntax error", 1)[1].strip(" :") or "invalid XML"
+                else:
+                    reason = "invalid JSON"
                 self.console.print("[yellow]The model wrote a malformed tool call; asking it to try again.[/]")
                 self.messages.append(
                     {
                         "role": "user",
-                        "content": f"[lcode] Your last tool call could not be parsed ({reason}): its arguments "
-                        "must be one complete, valid JSON object. Make the call again. If it writes a file, "
-                        "make sure the whole content is included and properly escaped.",
+                        "content": f"[lcode] Your last tool call could not be parsed ({reason}): it must be "
+                        "complete and well-formed, with every argument closed. Make the call again. If it writes "
+                        "a file, make sure the whole content is included and properly escaped.",
                     }
                 )
                 continue
@@ -892,6 +904,15 @@ class Agent:
                     self.console.print(Text(f"  {result[:300]}", style="red"))
                 elif name in ("read_file", "grep", "glob", "list_dir"):
                     self.console.print(Text(f"  ⎿ {result.count(chr(10)) + 1} line(s)", style="dim"))
+                verdict = self.repeats.check(name, args, result)
+                if verdict.note:
+                    result += verdict.note
+                    what = "stopping the request" if verdict.stop else "told the model"
+                    self.console.print(
+                        Text(f"  ⎿ same call, same result, {verdict.count} times: {what}", style="yellow")
+                    )
+                    if verdict.stop:
+                        looping = self.describe_call(name, args)
                 tool_msg = {"role": "tool", "tool_name": name, "content": result}
                 if call.get("id"):
                     tool_msg["tool_call_id"] = call["id"]
@@ -905,6 +926,27 @@ class Agent:
                         "output": result[:EVENT_OUTPUT] + ("…" if len(result) > EVENT_OUTPUT else ""),
                     }
                 )
+                if looping:
+                    for rest in calls[i + 1 :]:
+                        skipped = {
+                            "role": "tool",
+                            "tool_name": rest.get("function", {}).get("name", ""),
+                            "content": "Not run: lcode stopped the request before this call.",
+                        }
+                        if rest.get("id"):
+                            skipped["tool_call_id"] = rest["id"]
+                        self.messages.append(skipped)
+                    break
+            if looping:
+                self.turn_status = "loop"
+                self.console.print(
+                    Text(
+                        f"Stopped: the model kept making the same call with the same result: {looping}. Tell it "
+                        "what to do differently, or try again.",
+                        style="yellow",
+                    )
+                )
+                return
         else:
             self.turn_status = "max_steps"
             self.console.print(f"[yellow]Stopped after {self.max_steps} steps.[/]")

lcode/api.py

@@ -35,8 +35,8 @@ if TYPE_CHECKING:
     from lcode.hardware import Hardware
 
 SCHEMA_VERSION = 1
-STATUSES = ("success", "error", "max_steps", "interrupted")
-EXIT_CODES = {"success": 0, "error": 1, "max_steps": 3, "interrupted": 130}
+STATUSES = ("success", "error", "max_steps", "loop", "interrupted")
+EXIT_CODES = {"success": 0, "error": 1, "max_steps": 3, "loop": 4, "interrupted": 130}
 OLLAMA_INSTALL = {
     "linux": "curl -fsSL https://ollama.com/install.sh | sh",
     "darwin": "brew install ollama   (or download it from https://ollama.com/download)",
@@ -69,7 +69,7 @@ class Options:
 class Result:
     """How a request went. `to_json()` is what `lcode -p --output json` prints."""
 
-    status: str  # success, error, max_steps or interrupted
+    status: str  # success, error, max_steps, loop (stopped: the model kept repeating itself) or interrupted
     text: str  # the model's final answer
     session_id: str
     model: str
@@ -194,6 +194,7 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
         embed_model=cfg["embed_model"],
         notify=cfg["notify"],
         notify_after=cfg["notify_after"],
+        repeat_limit=cfg["repeat_limit"],
     )
     agent = Agent(ollama, settings, cwd, console=console)
     agent.interactive = options.interactive
@@ -272,7 +273,7 @@ def run_request(agent: Agent, prompt: str) -> Result:
 
     try:
         agent.run_turn(prompt)
-        status = "max_steps" if agent.turn_status == "max_steps" else "success"
+        status = agent.turn_status if agent.turn_status in ("max_steps", "loop") else "success"
     except KeyboardInterrupt:
         status, error = "interrupted", "interrupted before the request was done"
     except ModelError as e:

lcode/config.py

@@ -59,6 +59,7 @@ SETTINGS: dict[str, tuple[object, type, str]] = {
     "subagents": (True, bool, "let the model hand tasks to subagents that have their own context"),
     "notify": (True, bool, "desktop notification when a long request is done or waits for you"),
     "notify_after": (30, int, "seconds a request runs before it notifies (with notify on)"),
+    "repeat_limit": (3, int, "identical tool calls with identical results before lcode steps in (0: never)"),
     "max_parallel_agents": (1, int, "subagents that may run at the same time (more needs OLLAMA_NUM_PARALLEL)"),
 }
 ENV_OVERRIDES = {

lcode/mcp/catalog.toml

@@ -281,3 +281,24 @@ secret = true
 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/repeats.py

@@ -0,0 +1,104 @@
+"""Notice when the model goes round in circles.
+
+Small models sometimes fall into a loop: they make a tool call, get a result, and make the very same call
+again, and again, until the user steps in. Within one request lcode counts the calls that repeat an earlier
+one exactly: the same tool, the same arguments and the same result. At the `limit`-th one (a call that
+failed: one sooner) the result gets a note that tells the model so, and if it still goes on, lcode ends the
+request.
+
+Results that change aren't repeats: a test run again after a fix, a background job read while it runs. And
+a call that may have changed something (a file edit, a shell command that isn't read-only) starts the count
+again for every other call, so checking a build after each edit never adds up. Its own repeats still count:
+running the same failing command over and over is a loop.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass
+
+from lcode.permissions import is_read_only
+
+STOP_AFTER_NOTE = 2  # repeats after the note before the request ends
+FAILED = ("Error:", "A deny rule", "The user denied", "This needs the user's permission")
+UNCHANGING = frozenset(
+    {
+        "read_file",
+        "list_dir",
+        "glob",
+        "grep",
+        "view_image",
+        "repo_map",
+        "search_code",
+        "lsp",
+        "web_search",
+        "web_fetch",
+        "bash_output",
+        "todo_write",
+        "skill",
+        "mcp_find_tools",
+    }
+)  # tools that don't change files; anything else might
+
+
+@dataclass
+class Verdict:
+    count: int  # how often this exact call got this exact result in the request
+    note: str = ""  # to add to the tool result
+    stop: bool = False  # end the request
+
+
+class Repeats:
+    def __init__(self, limit: int = 3) -> None:
+        self.limit = limit  # 0: off
+        self.seen: dict[str, int] = {}
+
+    def reset(self) -> None:
+        """A new request."""
+        self.seen.clear()
+
+    def check(self, name: str, args: dict, result: str) -> Verdict:
+        """Count this call and its result."""
+        if self.limit <= 0:
+            return Verdict(1)
+        key = hashlib.sha256(json.dumps([name, args, result], sort_keys=True, default=str).encode()).hexdigest()
+        count = self.seen.get(key, 0) + 1
+        if changes_things(name, args, result):
+            self.seen.clear()
+        self.seen[key] = count
+        failed = result.startswith(FAILED)
+        note_at = max(2, self.limit - 1) if failed else max(2, self.limit)
+        if count < note_at:
+            return Verdict(count)
+        same = "the same error" if failed else "the same result"
+        if count >= note_at + STOP_AFTER_NOTE:
+            return Verdict(
+                count,
+                f"\n\n[lcode] You made this exact call {count} times in this request and got {same} each "
+                "time, so lcode stopped the request here. Next time, don't repeat a call that didn't help: "
+                "change your approach, or tell the user what is blocking you.",
+                stop=True,
+            )
+        hint = (
+            "If it's an edit, read the file again and copy the text exactly. "
+            if failed and name in ("edit_file", "write_file")
+            else ""
+        )
+        return Verdict(
+            count,
+            f"\n\n[lcode] You made this exact call {count} times in this request and got {same} each time. "
+            f"Making it again won't change that. Use what it returned, or try something different. {hint}"
+            "If you're stuck, stop and tell the user what is blocking you.",
+        )
+
+
+def changes_things(name: str, args: dict, result: str) -> bool:
+    """Whether the call may have changed files (or anything else a later call could see)."""
+    if name in UNCHANGING:
+        return False
+    if name in ("edit_file", "write_file"):
+        return not result.startswith(FAILED)
+    if name == "bash":
+        return not is_read_only(str(args.get("command", "")))
+    return True  # other tools (MCP, subagents…) might

lcode/servers/xai.py

@@ -0,0 +1,289 @@
+"""An MCP server for xAI's Grok Imagine and voice APIs: images, image edits, videos and speech.
+
+xAI has an HTTP API but no MCP server, so lcode ships this one. It needs an API key (XAI_API_KEY,
+from https://console.x.ai) and saves what it makes in the project, in `generated/` unless a path is
+given. The prompts, and any image it edits or animates, go to xAI, which bills per image, per
+second of video and per character of speech, and applies its own usage policies.
+
+Run: lcode-mcp-xai   (lcode mcp add xai sets it up)
+"""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import mimetypes
+import os
+import re
+import time
+from pathlib import Path
+
+import requests
+
+from lcode import __version__
+from lcode.mcp.server import Server, ToolFailure
+
+API = "https://api.x.ai/v1"
+TIMEOUT = 120
+IMAGE_MODELS = ["grok-imagine-image-2.0", "grok-imagine-image-quality", "grok-imagine-image"]
+VIDEO_MODELS = ["grok-imagine-video-1.5", "grok-imagine-video-1.5-lite", "grok-imagine-video"]
+ASPECT_RATIOS = ["auto", "1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3", "2:1", "1:2", "21:9"]
+VOICES = ["eve", "ara", "leo", "rex", "sal", "luna", "iris", "orion", "helix", "zagan", "carina", "altair", "zenith",
+          "perseus", "helios", "lux", "kepler", "rigel", "cosmo", "celeste", "ursa", "sirius", "lumen", "castor",
+          "naksh", "atlas"]  # fmt: skip
+AUDIO_FORMATS = {"mp3": ".mp3", "wav": ".wav"}
+VIDEO_WAIT = 600  # seconds generate_video waits before handing back the request id
+POLL = 5
+
+
+class XAI:
+    def __init__(self, key: str, base: str = API, output: Path | None = None):
+        self.base = base.rstrip("/")
+        self.output = output or Path("generated")
+        self.session = requests.Session()
+        self.session.headers.update({"Authorization": f"Bearer {key}", "Content-Type": "application/json"})
+
+    def request(self, method: str, path: str, **kwargs) -> requests.Response:
+        try:
+            r = self.session.request(method, f"{self.base}{path}", timeout=TIMEOUT, **kwargs)
+        except requests.RequestException as e:
+            raise ToolFailure(f"can't reach xAI: {e}") from e
+        if r.status_code in (401, 403):
+            raise ToolFailure(
+                f"xAI refused the request ({r.status_code}): {_error(r)}. Check XAI_API_KEY (console.x.ai)."
+            )
+        if r.status_code == 429:
+            raise ToolFailure(f"xAI's rate limit or credit limit was reached: {_error(r)}")
+        if r.status_code >= 400:
+            raise ToolFailure(f"xAI error {r.status_code}: {_error(r)}")
+        return r
+
+    def post(self, path: str, body: dict) -> dict:
+        return self.request("POST", path, json=body).json()
+
+    def download(self, url: str) -> bytes:
+        try:
+            r = requests.get(url, timeout=TIMEOUT)
+            r.raise_for_status()
+        except requests.RequestException as e:
+            raise ToolFailure(f"couldn't download the result from xAI: {e}") from e
+        return r.content
+
+    def target(self, path: str, stem: str, suffix: str) -> Path:
+        """Where to save: the given path, or a new file in the output folder."""
+        if path:
+            target = Path(path).expanduser()
+            if not target.suffix:
+                target = target.with_suffix(suffix)
+        else:
+            name = re.sub(r"[^a-z0-9]+", "-", stem.lower()).strip("-")[:40] or "xai"
+            target = self.output / f"{name}-{time.strftime('%Y%m%d-%H%M%S')}{suffix}"
+        target.parent.mkdir(parents=True, exist_ok=True)
+        n, unique = 2, target
+        while unique.exists():
+            unique = target.with_name(f"{target.stem}-{n}{target.suffix}")
+            n += 1
+        return unique
+
+
+def _error(r: requests.Response) -> str:
+    try:
+        data = r.json()
+    except ValueError:
+        return r.text[:300]
+    error = data.get("error") if isinstance(data, dict) else None
+    if isinstance(error, dict):
+        return str(error.get("message") or error)[:300]
+    return str(error or data)[:300]
+
+
+def data_url(path: str) -> str:
+    """A local image as a data: URL, for edits and image-to-video."""
+    file = Path(path).expanduser()
+    if not file.is_file():
+        raise ToolFailure(f"{path} doesn't exist")
+    mime = mimetypes.guess_type(file.name)[0] or "image/png"
+    if mime not in ("image/png", "image/jpeg", "image/webp"):
+        raise ToolFailure(f"{path} isn't a PNG, JPEG or WebP image")
+    return f"data:{mime};base64,{base64.b64encode(file.read_bytes()).decode()}"
+
+
+def image_suffix(data: bytes) -> str:
+    if data[:3] == b"\xff\xd8\xff":
+        return ".jpg"
+    if data[:4] == b"RIFF" and data[8:12] == b"WEBP":
+        return ".webp"
+    return ".png"
+
+
+def save_images(api: XAI, reply: dict, prompt: str, path: str) -> list[Path]:
+    saved = []
+    items = reply.get("data") or []
+    if not items:
+        raise ToolFailure(f"xAI returned no image: {str(reply)[:300]}")
+    for i, item in enumerate(items):
+        data = base64.b64decode(item["b64_json"]) if item.get("b64_json") else api.download(item["url"])
+        many = path and len(items) > 1
+        target = api.target(f"{Path(path).with_suffix('')}-{i + 1}" if many else path, prompt, image_suffix(data))
+        target.write_bytes(data)
+        saved.append(target)
+    return saved
+
+
+def build(api: XAI) -> Server:
+    server = Server(
+        "xai",
+        __version__,
+        "xAI's Grok Imagine and voice: generate and edit images, generate videos (from text or a start image) "
+        "and speech. Results are saved as files in the project; each call costs money on the user's xAI account. "
+        "xAI has no music generation.",
+    )
+    path_arg = {"type": "string", "description": "Where to save it (default: a new file in generated/)"}
+
+    @server.tool(
+        "generate_image",
+        "Generate images from a description with Grok Imagine and save them. Costs $0.02–0.05 per image.",
+        {
+            "prompt": {"type": "string", "description": "What the image shows, in detail"},
+            "n": {"type": "integer", "description": "How many images, 1–10 (default 1)"},
+            "aspect_ratio": {"type": "string", "enum": ASPECT_RATIOS, "description": "Default auto"},
+            "resolution": {"type": "string", "enum": ["1k", "2k"], "description": "Default 1k"},
+            "model": {"type": "string", "enum": IMAGE_MODELS, "description": f"Default {IMAGE_MODELS[0]}"},
+            "path": path_arg,
+        },
+        ["prompt"],
+    )
+    def generate_image(prompt: str, n: int = 1, aspect_ratio: str = "auto", resolution: str = "1k",
+                       model: str = IMAGE_MODELS[0], path: str = "") -> str:  # fmt: skip
+        body = {"model": model, "prompt": prompt, "n": max(1, min(10, int(n))), "response_format": "b64_json"}
+        if aspect_ratio and aspect_ratio != "auto":
+            body["aspect_ratio"] = aspect_ratio
+        if resolution and resolution != "1k":
+            body["resolution"] = resolution
+        saved = save_images(api, api.post("/images/generations", body), prompt, path)
+        return f"Saved {len(saved)} image(s) from {model}:\n" + "\n".join(f"- {p}" for p in saved)
+
+    @server.tool(
+        "edit_image",
+        "Change an existing image (a local file) as described, with Grok Imagine, and save the result.",
+        {
+            "image": {"type": "string", "description": "Path of the image to edit (PNG, JPEG or WebP)"},
+            "prompt": {"type": "string", "description": "What to change"},
+            "model": {"type": "string", "enum": IMAGE_MODELS, "description": f"Default {IMAGE_MODELS[0]}"},
+            "path": path_arg,
+        },
+        ["image", "prompt"],
+    )
+    def edit_image(image: str, prompt: str, model: str = IMAGE_MODELS[0], path: str = "") -> str:
+        body = {"model": model, "prompt": prompt, "image": {"url": data_url(image), "type": "image_url"},
+                "response_format": "b64_json"}  # fmt: skip
+        saved = save_images(api, api.post("/images/edits", body), prompt, path)
+        return f"Saved the edited image: {saved[0]}"
+
+    def finish_video(request_id: str, prompt: str, path: str, wait: float) -> str:
+        deadline = time.monotonic() + wait
+        while True:
+            state = api.request("GET", f"/videos/{request_id}").json()
+            status = state.get("status")
+            if status == "done":
+                video = state.get("video") or {}
+                target = api.target(path, prompt or request_id, ".mp4")
+                target.write_bytes(api.download(video["url"]))
+                return f"Saved the video ({video.get('duration', '?')} s, {state.get('model', '')}): {target}"
+            if status in ("failed", "expired"):
+                raise ToolFailure(f"xAI couldn't make the video ({status}): {state.get('error') or state}")
+            if time.monotonic() > deadline:
+                return (
+                    f"The video isn't ready yet (request {request_id}). Check later with "
+                    f'video_status(request_id="{request_id}"), which downloads it when it\'s done.'
+                )
+            time.sleep(POLL)
+
+    @server.tool(
+        "generate_video",
+        "Generate a video with Grok Imagine, from a description and optionally a start image, and save it as "
+        "MP4. Takes a minute or more. Costs $0.02–0.08 per second of video.",
+        {
+            "prompt": {"type": "string", "description": "What happens in the video"},
+            "image": {"type": "string", "description": "A local image to start from (optional)"},
+            "duration": {"type": "integer", "description": "Seconds, 1–15 (default 8)"},
+            "aspect_ratio": {
+                "type": "string",
+                "enum": [r for r in ASPECT_RATIOS if r not in ("auto", "2:1", "1:2", "21:9")],
+            },
+            "resolution": {"type": "string", "enum": ["480p", "720p", "1080p"], "description": "Default 720p"},
+            "model": {"type": "string", "enum": VIDEO_MODELS, "description": f"Default {VIDEO_MODELS[0]}"},
+            "path": path_arg,
+        },
+        ["prompt"],
+    )
+    def generate_video(prompt: str, image: str = "", duration: int = 8, aspect_ratio: str = "16:9",
+                       resolution: str = "720p", model: str = VIDEO_MODELS[0], path: str = "") -> str:  # fmt: skip
+        body: dict = {"model": model, "prompt": prompt, "duration": max(1, min(15, int(duration))),
+                      "aspect_ratio": aspect_ratio, "resolution": resolution}  # fmt: skip
+        if image:
+            body["image"] = {"url": data_url(image)}
+        request_id = api.post("/videos/generations", body).get("request_id")
+        if not request_id:
+            raise ToolFailure("xAI didn't start the video")
+        return finish_video(str(request_id), prompt, path, VIDEO_WAIT)
+
+    @server.tool(
+        "video_status",
+        "Check a video that generate_video started and that wasn't ready yet; saves it when it's done.",
+        {"request_id": {"type": "string"}, "path": path_arg},
+        ["request_id"],
+    )
+    def video_status(request_id: str, path: str = "") -> str:
+        return finish_video(request_id, "", path, 0)
+
+    @server.tool(
+        "text_to_speech",
+        "Turn text into speech with an xAI voice and save it as an audio file. Billed per character.",
+        {
+            "text": {"type": "string", "description": "What to say (up to 60,000 characters)"},
+            "voice": {"type": "string", "enum": VOICES, "description": "Default eve"},
+            "language": {"type": "string", "description": "BCP-47 code such as en, de, fr, ja, or auto (default)"},
+            "format": {"type": "string", "enum": list(AUDIO_FORMATS), "description": "Default mp3"},
+            "speed": {"type": "number", "description": "1.0 is normal"},
+            "path": path_arg,
+        },
+        ["text"],
+    )
+    def text_to_speech(text: str, voice: str = "eve", language: str = "auto", format: str = "mp3",
+                       speed: float = 1.0, path: str = "") -> str:  # fmt: skip
+        codec = format if format in AUDIO_FORMATS else "mp3"
+        body = {"text": text, "voice_id": voice.lower(), "language": language or "auto",
+                "output_format": {"codec": codec}, "speed": float(speed or 1.0)}  # fmt: skip
+        r = api.request("POST", "/tts", json=body)
+        duration = ""
+        if "json" in r.headers.get("Content-Type", ""):
+            data = r.json()
+            audio = base64.b64decode(data.get("audio", ""))
+            duration = f", {data['duration']:.1f} s" if isinstance(data.get("duration"), (int, float)) else ""
+        else:
+            audio = r.content
+        if not audio:
+            raise ToolFailure("xAI returned no audio")
+        target = api.target(path, text[:40], AUDIO_FORMATS[codec])
+        target.write_bytes(audio)
+        return f"Saved the speech ({voice}{duration}): {target}"
+
+    return server
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        prog="lcode-mcp-xai", description="MCP server for xAI's image, video and speech APIs (stdio)."
+    )
+    parser.add_argument("--output", default=os.environ.get("LCODE_XAI_OUTPUT", "generated"),
+                        help="folder for the files it makes (default: generated/ in the project)")  # fmt: skip
+    args = parser.parse_args(argv)
+    key = os.environ.get("XAI_API_KEY")
+    if not key:
+        parser.error("set XAI_API_KEY to an xAI API key (https://console.x.ai)")
+    build(XAI(key, os.environ.get("XAI_API_BASE", API), Path(args.output))).serve()
+
+
+if __name__ == "__main__":
+    main()

lcode/subagents.py

@@ -486,12 +486,17 @@ class Run:
             child._run_turn(self.task)
             last = child.messages[-1]
             if last.get("role") != "assistant" or last.get("tool_calls") or not last.get("content", "").strip():
-                # It ran out of steps: ask for what it has so far, without tools.
+                # It ran out of steps, or went round in circles: ask for what it has so far, without tools.
+                why = (
+                    "You kept making the same call, so lcode stopped you."
+                    if child.turn_status == "loop"
+                    else "You've used all your steps."
+                )
                 child.messages.append(
                     {
                         "role": "user",
-                        "content": "[lcode] You've used all your steps. Stop here and write your report: what "
-                        "you found or did so far, and what's left.",
+                        "content": f"[lcode] {why} Stop here and write your report: what you found or did so "
+                        "far, and what's left.",
                     }
                 )
                 child.allowed_tools = set()

{lcode_cli-0.21.0.dist-info → lcode_cli-0.23.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.21.0
+Version: 0.23.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/
@@ -116,7 +116,8 @@ through [Ollama](https://ollama.com), and when it needs current information it c
   (`lcode mcp add atlassian`), image generation with ComfyUI, or any other MCP server. Browser sign-in (OAuth) is built in.
 - **Sees images.** Attach a screenshot or mockup with `@path` and lcode looks at it, using the
   vision part of your model. With ComfyUI (`lcode mcp add comfyui`) it can also generate and edit
-  images with local models such as FLUX, SDXL and Qwen-Image.
+  images with local models such as FLUX, SDXL and Qwen-Image, or, in the cloud, images, videos
+  and speech with xAI's Grok Imagine (`lcode mcp add xai`).
 - **Web search when needed.** Looks up the latest versions, docs and error messages with Ollama web
   search, Brave, Tavily or your own SearXNG, and reads pages as clean text.
 - **Private.** The model runs on your machine, lcode never uploads your files and has no telemetry.

{lcode_cli-0.21.0.dist-info → lcode_cli-0.23.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-lcode/__init__.py,sha256=CcNLwxNc-qPLNMDrdZMe5h6rRYH_9ISij5uyXwc5PBA,473
+lcode/__init__.py,sha256=G36hAKq_BqNwKGr17AmtWXAKHe-_Nnbzm_VWmWBC-SI,473
 lcode/__main__.py,sha256=s5N5pryX2FAu93GGZ3FxUrIXHWGzxz66lKUoaV_h8Ws,35
-lcode/acp.py,sha256=kRD_uuDDdGXt7xwvXZ8OqePK1HprEV76wWAWkV_gcak,28987
-lcode/action.py,sha256=1r3abjheYFYQ-EUArvotls8pLmE3YjNMGHAy_iF0Z70,16198
-lcode/agent.py,sha256=FgZJpGD1a46qaa1nixZYXS3rPaFaJgnGpfoUi7ikhGY,51106
-lcode/api.py,sha256=rOpcA2-axzUj_DppH3EelanVnwd-2O4MgN91OXGJePY,15250
+lcode/acp.py,sha256=Tpc8lsvffZSYbTRI4t7X4E2chahqZIPcKeYIcL5bV3Y,29035
+lcode/action.py,sha256=W-QqdGt4VAVLq7mcIdvL9UrEOwDEWvkZ26gNDv8k1kg,16330
+lcode/agent.py,sha256=Br-L-7sLnGBG_Hw2lwi19peFZldCh4Ve7PgtVPURjTU,53254
+lcode/api.py,sha256=FQ6aVLB936Cu2XEBmuOoq0u1DfOiExmgap0Y3WxJ2mQ,15376
 lcode/backends.py,sha256=dtJHrC6ys73bRDg64z0tQz1PavmeAkiODZu1fOO9ExQ,20635
 lcode/bench.py,sha256=XVdk0hDxmRcjgROOCgwwOsExcUhIxgh0B2vnxtGnA3o,40742
 lcode/bench_backend.py,sha256=X2fo-zRX92Xp3KMxSsFlWioc2vRupBTtowj5kLME8mw,14287
@@ -11,7 +11,7 @@ lcode/catalog.py,sha256=pZ1azX9OH2r4JE2c6E5OfwywpgS39-W2oXzoCHJhmtM,4141
 lcode/checkpoints.py,sha256=eqPtmPe44-aweWqc2H21ROogwzIt3NpvcUobsaCHoGY,18354
 lcode/cli.py,sha256=ue5wsoFxraXXVu7X32S4tbKPLKYhgeI6zpK2i5nXXlU,40180
 lcode/codesearch.py,sha256=Io8leN1nb_Y-Dvlm9xaGtwUWYXX-ooswuznJV6dGU1s,10766
-lcode/config.py,sha256=eDEvOAA1plsSjvihzHEwGjNVgvcz3Pb-AR5DY5JmXnM,10255
+lcode/config.py,sha256=fGjK4fM_YRY0qDQmbIVT3FAfL2I2UxLfYEFxnAI-Xu4,10365
 lcode/context.py,sha256=qJymLE3eYeaF6qVOzlUwDURqlky__8cskl_6vXeU3AA,10701
 lcode/extensions.py,sha256=W0HFDl0BvROzr7i_qtabHdIbacBgP5o5qIJLzoM2oNE,16806
 lcode/frontmatter.py,sha256=Bx0n4vLPhp7ZCWx-g7xqzqNy5VoKBxyeeikh5UFB_gA,2441
@@ -28,11 +28,12 @@ lcode/ollama.py,sha256=u5tnvL28cfaFS4GhmiEsHhTQe6w3Ng_Tej05UUzLQTQ,7715
 lcode/permissions.py,sha256=i04YLtqYCxwApgawomPp4d35uk9HAJtpKY__gfw8j9s,6347
 lcode/planning.py,sha256=Q2upaoZPnXDMQT2F-ETxX1lk_wDntTzhSKNVYIQSoQA,6540
 lcode/render.py,sha256=gMvf4W3qkLUJ4Vot3az_hP_zRDAItJC9pP-68dHFkfA,1375
+lcode/repeats.py,sha256=uzyAewX03nJf5dKwYFH4y9ZDnh0Lvy2k0qC2vdntM5Y,4061
 lcode/repl.py,sha256=pQAPePNsBxJfcuif2Cvyxr0FSeO_DVGv_T5cL9BrWu4,48470
 lcode/repomap.py,sha256=1GRJgEUjBl9XHSXsF7tSGXBCEgsY-3CzwMohaTudZ_M,13969
 lcode/sandbox.py,sha256=u_pkrVRXhCGhh-wFDPwuZ3jGG7UeXxXRAeBNsm37ZvE,8608
 lcode/sessions.py,sha256=wOR-J0EHgJxLSPboKPHnvBcp5VTUYTj3tZWgpsa6-K4,4013
-lcode/subagents.py,sha256=rD7lnIioodirh8eVnXvRWdZx79J_rscPLssD2Gt7KIo,28914
+lcode/subagents.py,sha256=Z2RHp7an16dhOGReucVIEOAnXjxM8jx7sHvWd_Fp2V4,29142
 lcode/tools.py,sha256=pOdA4ihQHSs8yWUzfxhiLw3GajF5Dr1edxVX0Akr6CU,47257
 lcode/update.py,sha256=i92bnW252VneYh0vD6djxmXsDOa5MXP20bjlLZUue_c,25236
 lcode/vision.py,sha256=w33QPmdGwP33wM4mvmAH4amFDZ1xzeXhEsSLJ-STSHY,4243
@@ -40,7 +41,7 @@ lcode/web.py,sha256=vyxKbSRJTl1Lj3hj7Yd_NwTgbv0Xi6dup2YfUXjqp-Y,14579
 lcode/mcp/__init__.py,sha256=XujtAmRoXW9S0uq1XPf_CAeCkHh_UvA8FCmoAKP9j1Y,171
 lcode/mcp/auth.py,sha256=vyH3oolgIBNJLYabr2h5Soui99NTY1QxjQEgtczfF6A,16655
 lcode/mcp/catalog.py,sha256=I_O10N7cBl0ZW6O7x2kwKn89pvEXUXODUh8FsPXnB-E,3790
-lcode/mcp/catalog.toml,sha256=9uIcH8z2hAzaPzRNuVeSZs239uhIjroGNd76SkmK_NA,11662
+lcode/mcp/catalog.toml,sha256=N8MKyyS_FeCo-RbV3RVZ3ZODro2yk55yqUlymXsWdcQ,12641
 lcode/mcp/client.py,sha256=3Gen7zRvWehngXn_dAMOAdKqFkFkQZIQW96hQcW4N4k,7119
 lcode/mcp/commands.py,sha256=mnp0G-GW5ZsARi2tkHuT3hl883sBGFUVRAV3AapA5oU,16478
 lcode/mcp/config.py,sha256=Ej6WX2b_55a84H5WdAwSk9DzERKoq5ifUBQ9uDgSG_o,8780
@@ -52,8 +53,9 @@ lcode/mcp/stdio.py,sha256=kC6KHwzMMDjBr-yCZLmyVKS7PZXU299WpZdYRoX5eRQ,6292
 lcode/servers/__init__.py,sha256=qrIhxEodEB8cjKEQ4Cicc0GsQhE2OH-9qlVHzr3-tq8,77
 lcode/servers/encord.py,sha256=WSauawL1UKYZCUAG1oalcKL_An3DVof-JM6xIgFyQSE,12769
 lcode/servers/valohai.py,sha256=e5xZGIoa4cja4f5i85q1GpL9c7cglUjV8jN2co1CFMY,14430
-lcode_cli-0.21.0.dist-info/METADATA,sha256=5G93iKQq-92dbzpKJxamXKr9giXtXiVm0AsqhcJf4NU,12527
-lcode_cli-0.21.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-lcode_cli-0.21.0.dist-info/entry_points.txt,sha256=pMz2Byj2QRyt-ZZQYZvmWUtmKPCeE7f8iCvu-sjZPIo,133
-lcode_cli-0.21.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
-lcode_cli-0.21.0.dist-info/RECORD,,
+lcode/servers/xai.py,sha256=h2emAvHSnkuB9WmJInlynsDhvxJwNVD2AHFX7vqMXNc,13627
+lcode_cli-0.23.0.dist-info/METADATA,sha256=r2mvuIagBxzC4y5i14mZ7tYHnhy-Osy50M-wTYhkk-4,12620
+lcode_cli-0.23.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lcode_cli-0.23.0.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
+lcode_cli-0.23.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
+lcode_cli-0.23.0.dist-info/RECORD,,

{lcode_cli-0.21.0.dist-info → lcode_cli-0.23.0.dist-info}/entry_points.txt

@@ -2,3 +2,4 @@
 lcode = lcode.cli:main
 lcode-mcp-encord = lcode.servers.encord:main
 lcode-mcp-valohai = lcode.servers.valohai:main
+lcode-mcp-xai = lcode.servers.xai:main