lcode-cli 0.5.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

lcode/__init__.py

@@ -1,3 +1,3 @@
 """lcode — a local-first terminal coding agent powered by open-weight models via Ollama."""
 
-__version__ = "0.5.0"
+__version__ = "0.6.1"

lcode/agent.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import base64
 import datetime as dt
 import json
 import platform
@@ -19,7 +20,7 @@ from rich.markup import escape
 from rich.panel import Panel
 from rich.text import Text
 
-from lcode import catalog, limits, sessions, web
+from lcode import catalog, limits, sessions, vision, web
 from lcode.checkpoints import Checkpoints
 from lcode.config import format_tokens
 from lcode.mcp import McpManager
@@ -29,9 +30,11 @@ from lcode.render import MarkdownStreamer
 from lcode.sandbox import Sandbox, SandboxError, project_root
 from lcode.tools import (
     SCHEMAS,
+    VIEW_IMAGE_SCHEMA,
     WEB_FETCH_SCHEMA,
     WEB_SEARCH_SCHEMA,
     Toolbox,
+    ToolError,
     is_binary,
     parse_text_tool_calls,
     tree,
@@ -144,6 +147,7 @@ class Settings:
     sandbox: str = "off"  # off, docker or podman: where the model's shell commands run
     sandbox_image: str | None = None
     sandbox_network: bool = False
+    vision_model: str = "auto"  # auto, off or an Ollama model that can see images
 
 
 class Agent:
@@ -163,6 +167,7 @@ class Agent:
             else None
         )
         self._mcp_prompt = ""  # the MCP part at the end of the system prompt
+        self._vision: str | bool | None = False  # the model that looks at images; False = not decided yet
         self.session_name = ""
         self.session_title = ""
         self.ctx_used = 0
@@ -204,10 +209,65 @@ class Agent:
         schemas = list(SCHEMAS)
         if self.settings.web != "off":
             schemas += [*([WEB_SEARCH_SCHEMA] if self.search_backend() else []), WEB_FETCH_SCHEMA]
+        if self.vision_model():
+            schemas.append(VIEW_IMAGE_SCHEMA)
         if self.mcp:
             schemas += self.mcp.schemas(self.settings.context)
         return schemas
 
+    def vision_model(self) -> str | None:
+        """The model that looks at images for this session, if any (see lcode.vision)."""
+        if self._vision is False:
+            self._vision = vision.pick_model(self.ollama, self.settings.model, self.settings.vision_model)
+        return self._vision or None
+
+    def free_gpu(self) -> list[str]:
+        """Unload lcode's models from Ollama so another program can use the GPU; the next request reloads.
+
+        Only lcode's own models: the session's and the one that looks at images.
+        """
+        mine = {self.settings.model, *([self._vision] if isinstance(self._vision, str) else [])}
+        freed = []
+        for entry in self.ollama.running():
+            name = entry.get("name") or entry.get("model") or ""
+            if name in mine or name.removesuffix(":latest") in mine:
+                try:
+                    self.ollama.unload(name)
+                    freed.append(name.removesuffix(":latest"))
+                except OllamaError:
+                    pass
+        return freed
+
+    def look(self, path: Path, question: str = "") -> str:
+        """Describe an image with the vision model. Raises ToolError if it can't."""
+        model = self.vision_model()
+        if not model:
+            raise ToolError(f"can't look at {path.name}: {vision.INSTALL_HINT}")
+        try:
+            image = vision.read_image(path)
+            # The session's own model keeps its settings, so Ollama doesn't reload it.
+            options = self.options() if model == self.settings.model else None
+            loading = "" if model == self.settings.model else " (loads it; the next request reloads the main model)"
+            with self.console.status(f"Looking at {path.name} with {model}{loading}…", spinner="dots"):
+                return vision.describe(self.ollama, model, image, question, options, self.settings.keep_alive)
+        except vision.VisionError as e:
+            raise ToolError(str(e)) from e
+
+    def describe_image_data(self, data: str, mime: str) -> str:
+        """For images that tools return (e.g. an MCP browser's screenshots): a description, or a note."""
+        model = self.vision_model()
+        if not model:
+            return f"[{mime} image not shown: {vision.INSTALL_HINT}]"
+        options = self.options() if model == self.settings.model else None
+        try:
+            with self.console.status(f"Looking at the {mime} image with {model}…", spinner="dots"):
+                text = vision.describe(
+                    self.ollama, model, base64.b64decode(data), "", options, self.settings.keep_alive
+                )
+        except (vision.VisionError, ValueError) as e:
+            return f"[{mime} image not shown: {e}]"
+        return f"[{mime} image, as described by {model}]\n{text}"
+
     def prepare_mcp(self) -> None:
         """Before a request: wait for MCP servers still starting and describe them in the system prompt."""
         if not self.mcp:
@@ -559,7 +619,17 @@ class Agent:
         attached = []
         for ref in re.findall(r"(?<!\S)@([\w./~\-]+)", text):
             p = self.tools.resolve(ref)
-            if p.is_file() and not is_binary(p) and p.stat().st_size < 200_000:
+            if p.is_file() and vision.is_image(p):
+                try:
+                    description = self.look(p, re.sub(r"(?<!\S)@[\w./~\-]+", "", text))
+                    who = f' described_by="{self.vision_model()}"'
+                except ToolError as e:
+                    description, who = f"(lcode couldn't look at this image: {e})", ""
+                    self.console.print(Text(f"  ⎿ {e}", style="yellow"))
+                else:
+                    self.console.print(Text(f"  ⎿ looked at {self.tools.rel(p)}", style="dim"))
+                attached.append(f'<image path="{self.tools.rel(p)}"{who}>\n{description}\n</image>')
+            elif p.is_file() and not is_binary(p) and p.stat().st_size < 200_000:
                 attached.append(f'<file path="{self.tools.rel(p)}">\n{p.read_text(errors="replace")}\n</file>')
                 self.tools.read_mtimes[str(p)] = p.stat().st_mtime
                 self.console.print(Text(f"  ⎿ attached {self.tools.rel(p)}", style="dim"))

lcode/cli.py

@@ -273,6 +273,17 @@ def cmd_doctor(args) -> None:
         if spec:
             detail += f" · ~{spec.memory_gib(ctx):.0f} GB needed, ~{hw.budget_gib:.0f} GB available"
         line("Context", detail + (f" ({note})" if note else ""), None if note else True)
+        from lcode import vision
+
+        seer = vision.pick_model(ollama, model, cfg["vision_model"])
+        if seer:
+            line(
+                "Vision",
+                f"{seer} looks at screenshots and images" + ("" if seer == model else " (loaded when needed)"),
+                True,
+            )
+        else:
+            line("Vision", "off" if cfg["vision_model"] == "off" else vision.INSTALL_HINT, None)
         if limits.get(model):
             line(
                 "Limit",
@@ -497,6 +508,7 @@ def cmd_chat(args) -> None:
         sandbox=(cfg["sandbox"] if cfg["sandbox"] != "off" else "docker") if args.sandbox else cfg["sandbox"],
         sandbox_image=cfg["sandbox_image"],
         sandbox_network=cfg["sandbox_network"],
+        vision_model=cfg["vision_model"],
     )
     agent = Agent(ollama, settings, cwd, console=console)
     if agent.sandbox:

lcode/config.py

@@ -43,6 +43,7 @@ SETTINGS: dict[str, tuple[object, type, str]] = {
     "sandbox": ("off", str, "run the model's shell commands in a container: off | docker | podman"),
     "sandbox_image": (None, str, "container image for the sandbox (default: lcode's, built on first use)"),
     "sandbox_network": (False, bool, "let commands in the sandbox use the network"),
+    "vision_model": ("auto", str, "model that looks at images: auto | off | an Ollama model with vision"),
     "mcp_tools": ("auto", str, "how MCP tools reach the model: auto | direct | search (on demand, saves context)"),
 }
 ENV_OVERRIDES = {

lcode/mcp/catalog.toml

@@ -130,6 +130,34 @@ 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"

lcode/mcp/config.py

@@ -2,7 +2,8 @@
 
 Both use the `mcpServers` format that most MCP servers document, so a snippet from a server's README
 can be pasted in as is. lcode adds a few optional keys per server: `disabled`, `tools` (only offer
-these tools to the model), `allow` (tools that don't need approval), `timeout` and `oauth`.
+these tools to the model), `allow` (tools that don't need approval), `timeout`, `oauth` and
+`free_gpu` (tools that need the GPU to themselves, so lcode unloads its model first).
 Values can refer to environment variables as ${NAME} or ${NAME:-default}.
 """
 
@@ -69,6 +70,7 @@ class ServerConfig:
     timeout: float = DEFAULT_TIMEOUT
     oauth: dict = field(default_factory=dict)
     disabled: bool = False
+    free_gpu: list[str] | bool = False  # tools (or all, if True) that need lcode's model off the GPU
     error: str = ""  # a problem with the settings; the server can't start
 
     @property
@@ -121,6 +123,8 @@ def parse(name: str, raw: dict, source: str = "user") -> ServerConfig:
         cfg.error = f"the environment variable {e} isn't set"
     tools = raw.get("tools")
     cfg.tools = [str(t) for t in tools] if isinstance(tools, list) else None
+    free_gpu = raw.get("free_gpu", False)
+    cfg.free_gpu = [str(t) for t in free_gpu] if isinstance(free_gpu, list) else bool(free_gpu)
     cfg.allow = [str(t) for t in raw.get("allow") or []] if isinstance(raw.get("allow"), list) else []
     try:
         cfg.timeout = float(raw.get("timeout", DEFAULT_TIMEOUT))

lcode/mcp/manager.py

@@ -317,15 +317,20 @@ class McpManager:
             raise McpError("`arguments` must be a JSON object")
         return found[0], found[1], arguments
 
+    def needs_gpu(self, state: ServerState, tool: dict) -> bool:
+        """Whether lcode should free the GPU (unload its model) before this tool runs."""
+        wanted = state.cfg.free_gpu
+        return wanted is True or (isinstance(wanted, list) and tool["name"] in wanted)
+
     def allowed(self, state: ServerState, tool: dict) -> bool:
         """Tools the user allowed in mcp.json run without asking."""
         return "*" in state.cfg.allow or tool["name"] in state.cfg.allow
 
-    def call(self, state: ServerState, tool: dict, arguments: dict) -> str:
+    def call(self, state: ServerState, tool: dict, arguments: dict, image_text=None) -> str:
         try:
             if state.conn is None:
                 raise TransportError("the server isn't connected")
-            return result_text(state.conn.call_tool(tool, arguments, state.cfg.timeout))
+            return result_text(state.conn.call_tool(tool, arguments, state.cfg.timeout), image_text)
         except AuthRequired:
             state.status = "login"
             state.error = f"sign-in expired: run /mcp login {state.name}"
@@ -336,7 +341,7 @@ class McpManager:
                 self.restart(state.name)
                 if state.status == "ready" and state.conn:
                     try:
-                        return result_text(state.conn.call_tool(tool, arguments, state.cfg.timeout))
+                        return result_text(state.conn.call_tool(tool, arguments, state.cfg.timeout), image_text)
                     except McpError as again:
                         return f"Error: {again}"
             return f"Error: {state.name}: {e}"

lcode/mcp/protocol.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 import base64
 import json
 import re
+from collections.abc import Callable
 
 from lcode import __version__
 
@@ -99,8 +100,8 @@ def param_headers(schema: dict, arguments: dict) -> dict[str, str] | None:
     return headers if walk(schema, arguments) else None
 
 
-def result_text(result: dict) -> str:
-    """Turn a tools/call result into text for the model."""
+def result_text(result: dict, image_text: Callable[[str, str], str] | None = None) -> str:
+    """Turn a tools/call result into text for the model. `image_text(data, mime)` describes images."""
     parts = []
     for item in result.get("content") or []:
         if not isinstance(item, dict):
@@ -108,6 +109,8 @@ def result_text(result: dict) -> str:
         kind = item.get("type")
         if kind == "text":
             parts.append(str(item.get("text", "")))
+        elif kind == "image" and image_text and item.get("data"):
+            parts.append(image_text(item["data"], item.get("mimeType", "image/png")))
         elif kind in ("image", "audio"):
             parts.append(f"[{kind} ({item.get('mimeType', 'unknown type')}) not shown]")
         elif kind == "resource_link":

lcode/ollama.py

@@ -68,6 +68,10 @@ class Ollama:
                 names.add(m["name"][: -len(":latest")])
         return names
 
+    def chat(self, payload: dict, timeout: float = 900) -> dict:
+        """One chat request without streaming."""
+        return self._post("/api/chat", {**payload, "stream": False}, timeout=timeout)
+
     def show(self, model: str) -> dict:
         return self._post("/api/show", {"model": model})
 

lcode/tools.py

@@ -25,6 +25,7 @@ from rich.text import Text
 from lcode import web
 from lcode.permissions import bash_key, is_read_only
 from lcode.sandbox import SandboxError
+from lcode.vision import is_image
 
 if TYPE_CHECKING:
     from lcode.agent import Agent
@@ -162,7 +163,17 @@ WEB_FETCH_SCHEMA = _fn(
     },
     ["url"],
 )
-TOOL_NAMES = {s["function"]["name"] for s in [*SCHEMAS, WEB_SEARCH_SCHEMA, WEB_FETCH_SCHEMA]}
+VIEW_IMAGE_SCHEMA = _fn(
+    "view_image",
+    "Look at an image file (screenshot, diagram, photo, mockup): returns a detailed description with all visible "
+    "text transcribed. Ask a specific question to focus it.",
+    {
+        "path": {"type": "string", "description": "Image file: png, jpg, webp or gif"},
+        "question": {"type": "string", "description": "What you need to know from the image (optional)"},
+    },
+    ["path"],
+)
+TOOL_NAMES = {s["function"]["name"] for s in [*SCHEMAS, WEB_SEARCH_SCHEMA, WEB_FETCH_SCHEMA, VIEW_IMAGE_SCHEMA]}
 
 
 # ----------------------------------------------------------------------------- helpers
@@ -329,6 +340,11 @@ class Toolbox:
         valid = ", ".join(p if params[p].default is inspect.Parameter.empty else f"{p} (optional)" for p in params)
         return f"{'; '.join(parts)}. Valid arguments: {valid}."
 
+    # -- images
+    def t_view_image(self, path: str, question: str = "") -> str:
+        p = self.path(path)
+        return f"[{self.rel(p)}, as described by {self.agent.vision_model()}]\n" + self.agent.look(p, question)
+
     # -- MCP servers
     def _mcp(self, name: str, args: dict) -> str:
         mcp = self.agent.mcp
@@ -348,7 +364,18 @@ class Toolbox:
             ok, feedback = self.agent.perms.request(f"mcp:{state.name}:{tool['name']}", "mcp", title, body)
             if not ok:
                 return feedback
-        result = mcp.call(state, tool, arguments)
+        if mcp.needs_gpu(state, tool):
+            # The tool must finish before lcode's model comes back: a job left running in the
+            # background would compete with it for the GPU.
+            properties = (tool.get("inputSchema") or {}).get("properties") or {}
+            if (properties.get("wait") or {}).get("type") == "boolean" and arguments.get("wait") is not True:
+                arguments = {**arguments, "wait": True}
+            freed = self.agent.free_gpu()
+            if freed:
+                self.console.print(
+                    Text(f"  ⎿ freed the GPU for {state.name} ({', '.join(freed)} reloads afterwards)", style="dim")
+                )
+        result = mcp.call(state, tool, arguments, image_text=self.agent.describe_image_data)
         if result.startswith("Error:"):
             return result
         self.console.print(Text(f"  ⎿ {result.count(chr(10)) + 1} line(s) from {state.name}", style="dim"))
@@ -361,6 +388,8 @@ class Toolbox:
             raise ToolError(f"{path} does not exist")
         if p.is_dir():
             raise ToolError(f"{path} is a directory; use list_dir")
+        if is_image(p):
+            raise ToolError(f"{path} is an image; look at it with view_image")
         if is_binary(p):
             raise ToolError(f"{path} is a binary file ({p.stat().st_size} bytes)")
         lines = p.read_text(errors="replace").splitlines()

lcode/vision.py

@@ -0,0 +1,109 @@
+"""Looking at images: screenshots, diagrams and photos the user attaches or the model opens.
+
+The model that runs the conversation often can't see: lcode's text-only variants leave out the
+vision projector to save GPU memory. So lcode asks a model that can see to describe the image in
+detail (all text transcribed, layout, colors), with the user's question in mind, and gives the
+description to the conversation. Which model looks (`vision_model = "auto"`):
+
+1. the session's model, if it has vision;
+2. otherwise the original Ollama model behind a text-only catalog variant (the same weights plus
+   the vision projector; `lcode setup` already downloaded it), e.g. qwen3.6:35b-a3b-coding;
+3. otherwise none, unless `vision_model` names one (for example qwen3-vl:8b).
+"""
+
+from __future__ import annotations
+
+import base64
+from pathlib import Path
+
+from lcode import catalog
+from lcode.ollama import Ollama, OllamaError
+
+IMAGE_TYPES = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+    ".gif": "image/gif",
+}
+MAX_IMAGE_BYTES = 20 * 1024 * 1024
+DESCRIBE_CONTEXT = 16384  # enough for one image and a long description
+
+PROMPT = """You are the eyes of a coding assistant that cannot see images. Describe this image so the \
+assistant can act on it without seeing it.
+- Transcribe all visible text exactly: code, error messages, terminal output, labels, menu items, numbers.
+- Describe the layout and every important element: what it is, where it is, its size, color and state \
+(enabled, selected, highlighted, misaligned, overlapping, cut off).
+- For diagrams, charts and architecture drawings, describe the parts and how they connect.
+- Say what looks wrong or unusual, if anything.
+Don't guess at what isn't visible.{question}"""
+
+INSTALL_HINT = (
+    "no model that can see images is available: run `ollama pull qwen3-vl:8b` and "
+    "`lcode config set vision_model qwen3-vl:8b`, or use a catalog model (lcode setup)"
+)
+
+
+class VisionError(Exception):
+    pass
+
+
+def is_image(path: Path) -> bool:
+    return path.suffix.lower() in IMAGE_TYPES
+
+
+def can_see(ollama: Ollama, model: str) -> bool:
+    try:
+        return "vision" in (ollama.show(model).get("capabilities") or [])
+    except (OllamaError, AttributeError, TypeError):
+        return False
+
+
+def pick_model(ollama: Ollama, model: str, setting: str) -> str | None:
+    """The model that looks at images for a session running `model` (see the module docstring)."""
+    if setting == "off":
+        return None
+    if setting != "auto":
+        return setting
+    if can_see(ollama, model):
+        return model
+    spec = catalog.find(model)
+    if spec and spec.tag != model and can_see(ollama, spec.tag):
+        return spec.tag
+    return None
+
+
+def read_image(path: Path) -> bytes:
+    if not path.is_file():
+        raise VisionError(f"{path} doesn't exist")
+    if not is_image(path):
+        raise VisionError(f"{path.name} isn't an image lcode can read ({', '.join(sorted(IMAGE_TYPES))})")
+    size = path.stat().st_size
+    if size > MAX_IMAGE_BYTES:
+        raise VisionError(f"{path.name} is {size // (1024 * 1024)} MB; images up to 20 MB are supported")
+    return path.read_bytes()
+
+
+def describe(ollama: Ollama, model: str, image: bytes, question: str = "", options: dict | None = None,
+             keep_alive: str = "30m") -> str:  # fmt: skip
+    """A detailed description of the image, focused on the question if there is one."""
+    focus = (
+        f"\n\nThe user asks: {question.strip()}\nPay special attention to what that needs." if question.strip() else ""
+    )
+    payload = {
+        "model": model,
+        "messages": [
+            {"role": "user", "content": PROMPT.format(question=focus), "images": [base64.b64encode(image).decode()]}
+        ],
+        "think": False,
+        "keep_alive": keep_alive,
+        "options": options or {"num_ctx": DESCRIBE_CONTEXT},
+    }
+    try:
+        reply = ollama.chat(payload)
+    except OllamaError as e:
+        raise VisionError(f"{model} couldn't look at the image: {e}") from e
+    text = ((reply.get("message") or {}).get("content") or "").strip()
+    if not text:
+        raise VisionError(f"{model} returned no description")
+    return text

{lcode_cli-0.5.0.dist-info → lcode_cli-0.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.5.0
+Version: 0.6.1
 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/
@@ -86,7 +86,10 @@ through [Ollama](https://ollama.com), and when it needs current information it c
   with tool calling.
 - **MCP servers, ready to go.** Connect Jira and Confluence, GitHub, AWS, Google Drive, Grafana,
   Google Cloud, Sentry, Linear, Notion, Postgres, Kubernetes and more with one command
-  (`lcode mcp add atlassian`), or any other MCP server. Browser sign-in (OAuth) is built in.
+  (`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.
 - **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.5.0.dist-info → lcode_cli-0.6.1.dist-info}/RECORD

@@ -1,35 +1,36 @@
-lcode/__init__.py,sha256=-nk7j2Efg9_MFgFlQo5YWln10lcT6SR31CYBoENbTLo,117
+lcode/__init__.py,sha256=FEZ3iJP_gDCy8weyeZaUXt4OwUzCoqcyUbhby34kJ30,117
 lcode/__main__.py,sha256=s5N5pryX2FAu93GGZ3FxUrIXHWGzxz66lKUoaV_h8Ws,35
-lcode/agent.py,sha256=evwGEJg8zWvA2SnP4yI_vkWba3ILICK9OzVb0cbk6bw,28478
+lcode/agent.py,sha256=AhUf1l0OEjpizU74HI7yfdRz0q_UAnqFddbyQwdmFx0,32256
 lcode/bench.py,sha256=FCn94Gs7L8bpq4hzf6ILoQG8dKrbbd5WC4BRwrTp4LM,37950
 lcode/catalog.py,sha256=pZ1azX9OH2r4JE2c6E5OfwywpgS39-W2oXzoCHJhmtM,4141
 lcode/checkpoints.py,sha256=eqPtmPe44-aweWqc2H21ROogwzIt3NpvcUobsaCHoGY,18354
-lcode/cli.py,sha256=iGP5qywc7tUFuLNpzcrlYTicFX6dAaQpeXCfElqxPdQ,27041
-lcode/config.py,sha256=1_dhAwLRZD2rEhD47rBl3W4kvW0lQ6-45TQdq1KHz58,6956
+lcode/cli.py,sha256=53MucKCHe9NreYXwDaMEwfHtPS-26kxj7Xg3Bl4yoR8,27506
+lcode/config.py,sha256=VyRHq3ElCGmTQqTdtcGRHGuselm2U8-04ZC3tnEQ6L8,7063
 lcode/hardware.py,sha256=2VbknZCxTZJwJUD8YWdQ7ryEQo_LcjtoOBOHOU9Y0fw,3085
 lcode/limits.py,sha256=oJzVQoMyTZ0_Fkpu5t3qxrf9v7Hv9S8U8BRQR5M1aKA,1237
 lcode/models.toml,sha256=lt2G64zzo_Ryxv2ISRSNZoVD_JqCqYqsM01n8WoXGs8,4098
-lcode/ollama.py,sha256=-EB_8DKh87larG7iV0neyndPRom1Hxh4y8AAfI1Ebq8,6690
+lcode/ollama.py,sha256=8zxJcMhcxKF3L0vdgrzcoXAj_4MvbybVDSRPbLek0QE,6892
 lcode/permissions.py,sha256=OcWUDLrSoohUWHDUQ3UuBE3zI2JnBnOPizLE3bIgqyU,3982
 lcode/render.py,sha256=gMvf4W3qkLUJ4Vot3az_hP_zRDAItJC9pP-68dHFkfA,1375
 lcode/repl.py,sha256=2p6UG1xCmn85YEYcWUtgfoLJc3rHLaGLb_VV-RvzYvw,30332
 lcode/sandbox.py,sha256=u_pkrVRXhCGhh-wFDPwuZ3jGG7UeXxXRAeBNsm37ZvE,8608
 lcode/sessions.py,sha256=wOR-J0EHgJxLSPboKPHnvBcp5VTUYTj3tZWgpsa6-K4,4013
-lcode/tools.py,sha256=Y23bVt7Bow72v1QJUpvSahoEep77XW8e44Mg-s9igds,29146
+lcode/tools.py,sha256=ApAmM5hRxLVWjjF7eqqQYVyMDFAJkU4mLNZNYTbuMC8,30688
+lcode/vision.py,sha256=w33QPmdGwP33wM4mvmAH4amFDZ1xzeXhEsSLJ-STSHY,4243
 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=GnIF1fyeHSut9h2y_VJNAHc2FCJT81EIhLFM40V780k,3504
-lcode/mcp/catalog.toml,sha256=rb9Q6NgenYVzlsf5Ej-8yJbFwBMLuLCMegzrU5Rs_kc,7891
+lcode/mcp/catalog.toml,sha256=_kFzKD2FD78KD2URuE5B-kcQehW9Y3Zi2xf5tu3v4Xc,9230
 lcode/mcp/client.py,sha256=3Gen7zRvWehngXn_dAMOAdKqFkFkQZIQW96hQcW4N4k,7119
 lcode/mcp/commands.py,sha256=Rlnc-LFydRjHTiW-CSxjmQqX0d2MSiEViLF9kczYIi4,16420
-lcode/mcp/config.py,sha256=iSjjucG4VuP9u7aJQrTZsPA9k9oeRyMmz4hV1GE5ljw,8454
+lcode/mcp/config.py,sha256=Ej6WX2b_55a84H5WdAwSk9DzERKoq5ifUBQ9uDgSG_o,8780
 lcode/mcp/http.py,sha256=sG9MajwU4_6sqvZhwD4WfyzRKzaR_Lc8C02jwePz18E,7380
-lcode/mcp/manager.py,sha256=UPpY97jwW_KIi2G4hR860Iq4zgfqNFHjsyeu48aEa44,14784
-lcode/mcp/protocol.py,sha256=8uhyzzDQmaXr6pdt9bWD5ccvWZ93rvxd4v3Z5J84vKw,4938
+lcode/mcp/manager.py,sha256=79nNWoT5pxgoQD_Pv4ZH0obHIm7rQ-LyB8OmJnQgc6k,15104
+lcode/mcp/protocol.py,sha256=-xwhA2Tz-vzR2zdSdbPx4IjTu29uRrXMaePg0vEz_Vc,5223
 lcode/mcp/stdio.py,sha256=kC6KHwzMMDjBr-yCZLmyVKS7PZXU299WpZdYRoX5eRQ,6292
-lcode_cli-0.5.0.dist-info/METADATA,sha256=AKzBZkJaIZLAFgClC2t3OhO36jiVaAAXB7d1EXFEV8Q,9965
-lcode_cli-0.5.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-lcode_cli-0.5.0.dist-info/entry_points.txt,sha256=pZ_uDQ98UzVAHUQeXn5HeyQWKGSH3r3T5aPHuSB89eI,41
-lcode_cli-0.5.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
-lcode_cli-0.5.0.dist-info/RECORD,,
+lcode_cli-0.6.1.dist-info/METADATA,sha256=4PLti7RbtKHi303yE3frVKOVMu5brqijn8LgZw_UXl0,10251
+lcode_cli-0.6.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lcode_cli-0.6.1.dist-info/entry_points.txt,sha256=pZ_uDQ98UzVAHUQeXn5HeyQWKGSH3r3T5aPHuSB89eI,41
+lcode_cli-0.6.1.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
+lcode_cli-0.6.1.dist-info/RECORD,,