lcode-cli 0.34.0__py3-none-any.whl → 0.35.0__py3-none-any.whl

lcode/__init__.py

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

lcode/agent.py

@@ -29,6 +29,7 @@ from lcode import (
     catalog,
     checks,
     codesearch,
+    escalate,
     extensions,
     limits,
     notify,
@@ -307,6 +308,9 @@ class Settings:
     repeat_limit: int = 3  # identical calls with identical results before the model is told (lcode.repeats)
     checks: str = "off"  # the project's checks after a change (lcode.checks): auto, off or a command
     review: str = "off"  # check a change against the request before the answer (lcode.review): auto or off
+    escalate_model: str | None = None  # a stronger model to ask when stuck (lcode.escalate): provider/model
+    escalate_url: str | None = None  # its server, when not the provider's usual one
+    escalate_price: str | None = None  # dollars per million tokens in/out, e.g. "3/15", for the cost estimate
 
 
 class Agent:
@@ -369,6 +373,8 @@ class Agent:
         self._check: tuple[Path, checks.Check | None] | None = None
         self.check_results: list[dict] = []  # the checks of the last request: command, exit code, who ran them
         self.review_results: list[str] | None = None  # what the last request's review found (None: no review)
+        self.escalations: list[dict] = []  # the stronger model asked in the last request (lcode.escalate)
+        self.escalate_approved: bool | None = None  # decided in advance (lcode -p --escalate, the benchmark)
         self.sent_chars = 0  # characters of the conversation the model had already read
         self.counted_chars: int | None = None  # characters that ctx_used covers (None: all of them)
         self.turn_status = ""  # how the last request ended: success, max_steps, loop
@@ -952,9 +958,8 @@ class Agent:
             )
             return None
         if round_ >= checks.MAX_ROUNDS:
-            self.say(
-                f"Checks still fail ({check.command}, exit code {code}): the model will say what's left.", warning=True
-            )
+            then = "" if self.can_escalate() else ": the model will say what's left"
+            self.say(f"Checks still fail ({check.command}, exit code {code}){then}.", warning=True)
         else:
             self.say(
                 f"Checks fail ({check.command}, exit code {code}): the model gets the output to fix it.", warning=True
@@ -1103,6 +1108,8 @@ class Agent:
         self.repeats.reset()
         self.check_results = []
         self.review_results = None
+        self.escalations = []
+        escalated = False  # the stronger model is asked at most once per request
         self.tools.before = {}
         reviewed = False
         changed = verified = False  # files changed in this request; the checks passed since
@@ -1166,6 +1173,15 @@ class Agent:
                     check_rounds += 1
                     feedback = self.run_check(check, check_rounds)
                     if feedback:
+                        if check_rounds >= checks.MAX_ROUNDS and not escalated and self.can_escalate():
+                            escalated = True
+                            why = f"the project's checks (`{check.command}`) failed {check_rounds} times in a row"
+                            advice = escalate.run(self, why, failure=feedback)
+                            if advice:
+                                self.messages.append({"role": "user", "content": advice})
+                                check_rounds -= 1  # the checks run once more after the advice
+                                changed = False
+                                continue
                         self.messages.append({"role": "user", "content": feedback})
                         changed = False  # run them again only if the model changes something more
                         continue
@@ -1259,6 +1275,14 @@ class Agent:
                             skipped["tool_call_id"] = rest["id"]
                         self.messages.append(skipped)
                     break
+            if looping and not escalated and self.can_escalate():
+                escalated = True
+                advice = escalate.run(self, f"it kept making the same call with the same result: {looping}")
+                if advice:
+                    self.messages.append({"role": "user", "content": advice})
+                    self.repeats.reset()
+                    looping = ""
+                    continue
             if looping:
                 self.turn_status = "loop"
                 self.console.print(
@@ -1276,6 +1300,11 @@ class Agent:
         self.turn_status = "success"
         self.print_stats()
 
+    def can_escalate(self) -> bool:
+        """Whether a stronger model may be asked here: one is set, and this isn't a subagent or plan mode."""
+        model = (self.settings.escalate_model or "").strip().lower()
+        return bool(model) and model != "off" and self.allowed_tools is None and not self.planning()
+
     def steer(self) -> None:
         """Between two steps: pause if the user pressed Esc, then hand the model the notes typed meanwhile."""
         steering = self.steering

lcode/api.py

@@ -78,6 +78,7 @@ class Result:
     usage: dict = field(default_factory=dict)  # requests, prompt_tokens, output_tokens
     checks: list[dict] = field(default_factory=list)  # {"command", "exit_code", "by": "lcode" | "model"}
     review: list[str] | None = None  # problems the review sent back ([] when it found none; None: no review)
+    escalations: list[dict] = field(default_factory=list)  # a stronger model asked: model, why, tokens, seconds
     seconds: float = 0.0
     error: str = ""
 
@@ -200,6 +201,9 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
         repeat_limit=cfg["repeat_limit"],
         checks=cfg["checks"],
         review=cfg["review"],
+        escalate_model=cfg["escalate_model"],
+        escalate_url=cfg["escalate_url"],
+        escalate_price=cfg["escalate_price"],
         compact_at=cfg["compact_at"],
     )
     agent = Agent(ollama, settings, cwd, console=console)
@@ -309,6 +313,7 @@ def run_request(agent: Agent, prompt: str) -> Result:
         usage=usage,
         checks=list(agent.check_results),
         review=agent.review_results,
+        escalations=list(agent.escalations),
         seconds=round(time.monotonic() - started, 2),
         error=error,
     )

lcode/backends.py

@@ -265,11 +265,16 @@ class OpenAICompatible:
             return self.chat({k: v for k, v in payload.items() if k not in ("format", "tools")}, timeout)
         if r.status_code != 200:
             raise self._failed(r.status_code, r.text)
-        choice = (r.json().get("choices") or [{}])[0].get("message") or {}
+        data = r.json()
+        choice = (data.get("choices") or [{}])[0].get("message") or {}
         message: dict = {"role": "assistant", "content": strip_thinking(choice.get("content") or "")}
         if choice.get("tool_calls"):
             message["tool_calls"] = [self._ollama_call(c) for c in choice["tool_calls"]]
-        return {"message": message}
+        reply: dict = {"message": message}
+        usage = data.get("usage") or {}
+        if usage.get("prompt_tokens") is not None:  # as Ollama counts them
+            reply["prompt_eval_count"], reply["eval_count"] = usage["prompt_tokens"], usage.get("completion_tokens")
+        return reply
 
     @staticmethod
     def _ollama_call(call: dict) -> dict:

lcode/bench.py

@@ -29,7 +29,7 @@ from rich.markup import escape
 from rich.table import Table
 from rich.text import Text
 
-from lcode import __version__
+from lcode import __version__, escalate
 from lcode.agent import Agent, Settings
 from lcode.config import format_tokens
 from lcode.hardware import Hardware
@@ -790,6 +790,8 @@ class TaskResult:
     tool_errors: int = 0  # failed tool calls, including malformed ones
     error: str | None = None  # why the run stopped early: a timeout or an Ollama error
     errors_by_tool: dict[str, int] = field(default_factory=dict)  # which tools failed, "malformed" for unreadable calls
+    first_passed: bool | None = None  # with --retry: whether the first try passed (None: no retry was needed)
+    escalations: int = 0  # times the stronger model was asked (--escalate)
 
 
 @dataclass
@@ -887,8 +889,13 @@ def run_task(
     keep: bool,
     usage: dict,
     agent: Agent | None = None,
+    retry: bool = False,
 ) -> TaskResult:
-    """Run one task in a new folder: in a new conversation, or continuing `agent`'s (--session)."""
+    """Run one task in a new folder: in a new conversation, or continuing `agent`'s (--session).
+
+    With `retry`, a failed task gets one more try, as a user would ask: "That didn't fix it. Look again." With a
+    stronger model set (--escalate), its advice goes along, as with /escalate.
+    """
     folder = Path(tempfile.mkdtemp(prefix=f"lcode-bench-{task.id}-"))
     try:
         for rel, content in task.files.items():
@@ -906,25 +913,28 @@ def run_task(
             if model:
                 codesearch.Index(folder, model).update(ollama)  # on the CPU: lcode's model stays loaded
             agent._code_index = None
+        agent.escalate_approved = True if settings.escalate_model else None  # the --escalate flag is the OK
         before = dict(agent.usage)
         first = len(agent.messages)
-        error = None
         started = time.monotonic()
-        try:
-            with time_limit(timeout):
-                agent.run_turn(task.prompt)
-        except TaskTimeout:
-            error = f"timed out after {timeout:.0f}s"
-        except OllamaError as e:
-            error = str(e).splitlines()[0][:200]
+        escalations = 0
+        error = attempt(agent, task.prompt, timeout)
+        escalations += len(agent.escalations)
+        check = checked(task, folder, agent)
+        first_passed = None
+        if retry and not (check.passed and error is None):
+            first_passed = False
+            text = RETRY
+            if error is None and agent.can_escalate():
+                advice = escalate.run(agent, "the user says the fix didn't work")
+                escalations += 1 if advice else 0
+                text = f"{RETRY}\n\n{advice}" if advice else RETRY
+            error = attempt(agent, text, timeout)
+            escalations += len(agent.escalations)
+            check = checked(task, folder, agent)
         seconds = time.monotonic() - started
         for key, value in agent.usage.items():
             usage[key] = usage.get(key, 0) + value - before.get(key, 0)
-        answer = next((m.get("content", "") for m in reversed(agent.messages) if m.get("role") == "assistant"), "")
-        try:
-            check = task.check(folder, answer)
-        except Exception as e:  # a check must never crash the benchmark
-            check = Check(False, f"check failed: {type(e).__name__}: {e}")
     finally:  # also when Ctrl+C stops the task
         from lcode.codesearch import index_dir
 
@@ -942,9 +952,34 @@ def run_task(
         tool_errors=count_tool_errors(agent.messages[first:] if len(agent.messages) > first else agent.messages),
         errors_by_tool=errors_by_tool(agent.messages[first:] if len(agent.messages) > first else agent.messages),
         error=error,
+        first_passed=first_passed,
+        escalations=escalations,
     )
 
 
+RETRY = "That didn't fix it: it still doesn't work right. Look again."
+
+
+def attempt(agent: Agent, text: str, timeout: float) -> str | None:
+    """One request of a task; why it stopped early, if it did."""
+    try:
+        with time_limit(timeout):
+            agent.run_turn(text)
+    except TaskTimeout:
+        return f"timed out after {timeout:.0f}s"
+    except OllamaError as e:
+        return str(e).splitlines()[0][:200]
+    return None
+
+
+def checked(task: Task, folder: Path, agent: Agent) -> Check:
+    answer = next((m.get("content", "") for m in reversed(agent.messages) if m.get("role") == "assistant"), "")
+    try:
+        return task.check(folder, answer)
+    except Exception as e:  # a check must never crash the benchmark
+        return Check(False, f"check failed: {type(e).__name__}: {e}")
+
+
 def prompt_speed(ollama: Ollama, settings: Settings, options: dict) -> float | None:
     """Prompt tokens per second for prompts the model hasn't seen: the faster of two readings.
 
@@ -998,6 +1033,7 @@ def run_model(
     keep: bool = False,
     verbose: bool = False,
     session: bool = False,
+    retry: bool = False,
 ) -> ModelRun:
     run = ModelRun(name, settings.model, settings.context, settings.num_batch, settings.think, session=session)
     shared: Agent | None = None  # with --session, one conversation for all tasks
@@ -1038,10 +1074,10 @@ def run_model(
         try:
             if verbose:
                 console.rule(f"{task.id}: {task.title}")
-                result = run_task(ollama, settings, task, timeout, log, keep, run.usage, shared)
+                result = run_task(ollama, settings, task, timeout, log, keep, run.usage, shared, retry)
             else:
                 with console.status(Elapsed(f"  {task.id:<13} {task.title}")):
-                    result = run_task(ollama, settings, task, timeout, log, keep, run.usage, shared)
+                    result = run_task(ollama, settings, task, timeout, log, keep, run.usage, shared, retry)
         except KeyboardInterrupt:
             console.print("  [yellow]Stopped.[/]")
             run.interrupted = True

lcode/cli.py

@@ -582,11 +582,14 @@ def cmd_bench(args) -> None:
             compact_at=cfg["compact_at"] if args.compact_at is None else args.compact_at,
             checks=cfg["checks"] if args.checks is None else args.checks,
             review=cfg["review"] if args.review is None else args.review,
+            escalate_model=args.escalate_model,
+            escalate_url=cfg["escalate_url"],
+            escalate_price=cfg["escalate_price"],
             repo_map=args.repo_map,
             embed_model=cfg["embed_model"] if args.code_search else "off",
         )
         run = bench.run_model(
-            ollama, name, settings, tasks, console, args.timeout, args.keep, args.verbose, args.session
+            ollama, name, settings, tasks, console, args.timeout, args.keep, args.verbose, args.session, args.retry
         )
         runs.append(run)
         if run.interrupted:
@@ -662,6 +665,8 @@ def cmd_chat(args) -> None:
             sys.exit(1)
         fail(str(e))
     exit_code = 0
+    if args.escalate and args.prompt:
+        agent.escalate_approved = True  # the flag is the user's OK for this run
     try:
         if quiet:
             agent.perms.approve = lambda request: False  # nobody to ask: refuse what needs permission
@@ -727,6 +732,11 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--plan", action="store_true", help="start in plan mode: agree on a plan before any change")
     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(
+        "--escalate",
+        action="store_true",
+        help="with -p: let lcode ask escalate_model for help when stuck, without asking you (it costs money)",
+    )
     parser.add_argument("--no-think", action="store_true", help="disable model reasoning (faster, less accurate)")
     parser.add_argument("--no-web", action="store_true", help="don't let the model search or fetch web pages")
     parser.add_argument("--no-mcp", action="store_true", help="don't start MCP servers in this session")
@@ -779,6 +789,17 @@ def build_subparsers() -> dict[str, argparse.ArgumentParser]:
     p.add_argument(
         "--review", choices=["auto", "off"], help="review each change before it counts (default: the setting)"
     )
+    p.add_argument(
+        "--retry",
+        action="store_true",
+        help='give a failed task one more try, as a user would: "That didn\'t fix it. Look again."',
+    )
+    p.add_argument(
+        "--escalate",
+        dest="escalate_model",
+        metavar="MODEL",
+        help="a stronger model to ask when stuck and on --retry, e.g. ollama/qwen3.8-27b (no questions asked)",
+    )
     p.add_argument(
         "--checks",
         metavar="auto|off|COMMAND",

lcode/config.py

@@ -61,6 +61,14 @@ SETTINGS: dict[str, tuple[object, type, str]] = {
     "notify_after": (30, int, "seconds a request runs before it notifies (with notify on)"),
     "review": ("off", str, "before the answer, check a change against the request and send problems back: auto | off"),
     "checks": ("auto", str, "run the project's checks before calling work done: auto | off | a command"),
+    "escalate_model": (
+        None,
+        str,
+        "a stronger model to ask, with your OK, when the model is stuck: anthropic/…, openai/…, xai/… (key from "
+        "ANTHROPIC_API_KEY, OPENAI_API_KEY, XAI_API_KEY) or ollama/<model> (local or at escalate_url)",
+    ),
+    "escalate_url": (None, str, "the stronger model's server, if not its provider's (another Ollama, any OpenAI API)"),
+    "escalate_price": (None, str, "its price in dollars per million tokens in/out, e.g. 3/15, for the cost shown"),
     "repeat_limit": (3, int, "identical tool calls with identical results before lcode steps in (0: never)"),
     "secret_check": (True, bool, "before git commit and git push, look for passwords, keys and tokens they'd add"),
     "compact_at": (65536, int, "summarize at this many tokens even when the window is larger (0: only at 85%)"),
@@ -165,6 +173,22 @@ def coerce(key: str, value: object) -> object:
         if value not in MEMORY_MODES:
             raise ConfigError(f"memory must be one of {', '.join(MEMORY_MODES)}")
         return value
+    if key in ("escalate_model", "escalate_url", "escalate_price"):
+        from lcode import escalate
+
+        text = str(value).strip()
+        if key == "escalate_url":
+            return normalize_host(text)
+        if key == "escalate_model":
+            provider = text.partition("/")[0].lower()
+            if "/" in text and provider not in escalate.PROVIDERS:
+                raise ConfigError(f"escalate_model's provider must be one of {', '.join(escalate.PROVIDERS)}")
+            return text
+        try:
+            escalate.parse_price(text)
+        except escalate.EscalateError as e:
+            raise ConfigError(str(e)) from e
+        return text
     if key == "lsp" and str(value).lower() not in ("auto", "off"):
         raise ConfigError("lsp must be auto or off")
     if key == "lsp":

lcode/context.py

@@ -41,6 +41,8 @@ ERROR_LINE = re.compile(
 )
 MAX_ERROR_LINES = 40
 OUTPUT_DAYS = 7  # saved full outputs are deleted after this
+MAX_SAVED = 20_000_000  # characters of one saved output: a runaway command doesn't fill the disk
+MAX_SAVED_TOTAL = 200_000_000  # bytes of saved outputs in all, the oldest go first
 
 
 # ----------------------------------------------------------------------------- the user's requests
@@ -262,17 +264,38 @@ def save_output(text: str, label: str) -> Path | None:
     folder = outputs_dir()
     try:
         folder.mkdir(parents=True, exist_ok=True)
-        cutoff = time.time() - OUTPUT_DAYS * 86400
-        for old in folder.glob("*.txt"):
-            if old.stat().st_mtime < cutoff:
-                old.unlink(missing_ok=True)
+        clean_outputs(folder, room=min(len(text), MAX_SAVED))
         path = folder / f"{time.strftime('%Y%m%d-%H%M%S')}-{re.sub(r'[^a-z0-9]+', '-', label.lower())[:30]}.txt"
-        path.write_text(text)
+        path.write_text(text if len(text) <= MAX_SAVED else text[:MAX_SAVED] + CUT_SAVED)
         return path
     except OSError:
         return None
 
 
+CUT_SAVED = "\n[lcode stopped saving here: the output went on, but a saved output is kept to 20 MB]\n"
+
+
+def clean_outputs(folder: Path, room: int = 0) -> None:
+    """Delete saved outputs older than OUTPUT_DAYS, then the oldest until they take MAX_SAVED_TOTAL with `room`."""
+    cutoff = time.time() - OUTPUT_DAYS * 86400
+    files = []
+    for old in folder.glob("*.txt"):
+        try:
+            info = old.stat()
+        except OSError:
+            continue
+        if info.st_mtime < cutoff:
+            old.unlink(missing_ok=True)
+        else:
+            files.append((info.st_mtime, info.st_size, old))
+    total = sum(size for _, size, _ in files) + room
+    for _, size, old in sorted(files):
+        if total <= MAX_SAVED_TOTAL:
+            break
+        old.unlink(missing_ok=True)
+        total -= size
+
+
 def shorten(text: str, limit: int, label: str = "output") -> str:
     """Head, tail and the error-looking lines in between; the full text goes to a file."""
     if len(text) <= limit:
@@ -315,6 +338,7 @@ class OutputSpool:
         self.chars = 0
         self.file = None
         self.path: Path | None = None
+        self.saved = 0  # characters written to the file
 
     def add(self, line: str) -> None:
         self.chars += len(line)
@@ -323,10 +347,12 @@ class OutputSpool:
             if self.chars > self.limit * 2:
                 self._spool()
             return
-        try:
-            self.file.write(line)
-        except OSError:
-            pass
+        if self.saved <= MAX_SAVED:  # past it, only the end and the error lines are kept (in memory)
+            try:
+                self.file.write(line if self.saved + len(line) <= MAX_SAVED else CUT_SAVED)
+            except OSError:
+                pass
+            self.saved += len(line)
         if ERROR_LINE.search(line) and len(self.errors) < MAX_ERROR_LINES:
             self.errors.append(line.strip()[:300])
         self.tail.append(line)
@@ -337,6 +363,7 @@ class OutputSpool:
     def _spool(self) -> None:
         text = "".join(self.head)
         self.path = save_output(text, self.label)
+        self.saved = len(text)
         if self.path is not None:
             try:
                 self.file = self.path.open("a")
@@ -359,12 +386,10 @@ class OutputSpool:
             note += "\n[...]\n\n"
         else:
             note += "] ...\n\n"
-        where = (
-            f"\n[The full {self.label} ({self.chars} characters) is in {self.path}: read parts of it with read_file "
-            "if you need them.]"
-            if self.path
-            else ""
-        )
+        whole = f"The full {self.label} ({self.chars} characters)"
+        if self.saved > MAX_SAVED:
+            whole = f"The first {MAX_SAVED // 1_000_000} MB of the {self.label} ({self.chars} characters in all)"
+        where = f"\n[{whole} is in {self.path}: read parts of it with read_file if you need them.]" if self.path else ""
         return f"{head}{note}{tail}{where}"
 
 

lcode/escalate.py

@@ -0,0 +1,315 @@
+"""Ask a stronger model when the local one is stuck (opt-in, asked each time, with the cost shown).
+
+Some problems are beyond a small local model: it loops, or the same check keeps failing. With `escalate_model`
+set, lcode can then ask a stronger model, in the cloud (OpenAI, Anthropic, xAI, with the user's key) or a
+bigger local one (Ollama, here or on another server), for one piece of advice. The local model gets the advice
+and carries on with its own tools.
+
+Nothing is sent without asking: the user sees why, what goes (the requests, the task sheet, the failure, the
+files in question) and its size and price, and can read all of it first. Only that goes, never the whole
+session, and API keys come from environment variables, read when needed and sent only to their own provider.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import time
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from rich.markup import escape
+from rich.panel import Panel
+from rich.text import Text
+
+from lcode import context as context_tools
+from lcode.ollama import Ollama, OllamaError, redact
+
+if TYPE_CHECKING:
+    from lcode.agent import Agent
+
+# provider -> (API address, the environment variable with its key, its name)
+PROVIDERS = {
+    "openai": ("https://api.openai.com/v1", "OPENAI_API_KEY", "OpenAI"),
+    "anthropic": ("https://api.anthropic.com/v1", "ANTHROPIC_API_KEY", "Anthropic"),
+    "xai": ("https://api.x.ai/v1", "XAI_API_KEY", "xAI"),
+    "ollama": ("", "", "Ollama"),  # lcode's own Ollama, or another one at escalate_url
+    "custom": ("", "LCODE_ESCALATE_API_KEY", "OpenAI-compatible server"),  # any OpenAI API at escalate_url
+}
+BUDGET = 60_000  # characters sent at most (about 15K tokens)
+FILE_CHARS = 16_000  # of one file
+MAX_OUTPUT = 4096  # tokens the advice may take (thinking included, for local models)
+RECENT_STEPS = 8  # the last tool calls and results that go along
+TIMEOUT = 1800  # seconds: a big local model is slow
+
+ADVISOR = """You are a senior engineer helping a smaller coding model that is stuck on a task in the user's repository. You can't run anything: you get the user's request, the model's notes, why it's stuck, the files in question and its last steps. Find the real cause and say exactly what to change.
+
+Answer in this order:
+1. What's wrong: the root cause in a few sentences, pointing at file:line.
+2. The fix: unified diffs, or edits precise enough to apply (file, the exact code to replace, the new code). Fix the cause, not the symptom: no special cases for a test.
+3. How to check it: the command to run and what it should show.
+Be brief. If something you need is missing, say what to look at."""
+
+ADVICE = """[lcode] You were stuck ({why}), so lcode asked a stronger model, {model}, for advice. It saw your notes, the failure, the files involved and your last steps, but couldn't run anything:
+
+{advice}
+
+Check its advice against the code, apply what's right with your tools, run the checks, and carry on."""
+
+
+class EscalateError(Exception):
+    """The stronger model can't be asked; the message says why and what to do."""
+
+
+@dataclass
+class Target:
+    provider: str
+    model: str
+    url: str  # where the request goes ("" for lcode's own Ollama)
+    key_env: str  # the environment variable with the key ("" when none is needed)
+    label: str  # e.g. "claude-sonnet-4-5 (Anthropic)"
+
+    @property
+    def local(self) -> bool:
+        return not self.url or bool(re.match(r"^https?://(localhost|127\.0\.0\.1|\[::1\])(:|/|$)", self.url))
+
+    @property
+    def cloud(self) -> bool:
+        """Paid per token: a cloud provider, or an OpenAI-compatible API elsewhere."""
+        return self.provider in ("openai", "anthropic", "xai") or (self.provider == "custom" and not self.local)
+
+    @property
+    def where(self) -> str:
+        if self.url:
+            return re.sub(r"^https?://", "", redact(self.url)).split("/")[0]
+        return "this machine"
+
+
+def target(setting: str | None, url: str | None = None) -> Target | None:
+    """The stronger model from the settings (None: escalation is off). Raises EscalateError for a bad setting."""
+    setting = (setting or "").strip()
+    if not setting or setting.lower() == "off":
+        return None
+    provider, sep, model = setting.partition("/")
+    if not sep or provider.lower() not in PROVIDERS:
+        if url:  # a model name with its own server
+            provider, model = ("ollama" if ":11434" in url else "custom"), setting
+        else:
+            raise EscalateError(
+                f"escalate_model {setting!r} needs a provider: openai/…, anthropic/…, xai/…, ollama/… or custom/… "
+                "(with escalate_url)"
+            )
+    provider = provider.lower()
+    base, key_env, name = PROVIDERS[provider]
+    if not model.strip():
+        raise EscalateError(f"escalate_model {setting!r} names no model")
+    if provider == "custom" and not url:
+        raise EscalateError("a custom/… escalate_model needs escalate_url, the server's OpenAI-compatible address")
+    return Target(provider, model.strip(), (url or base).rstrip("/"), key_env, f"{model.strip()} ({name})")
+
+
+def client(t: Target, ollama):
+    """The client that talks to the stronger model. The key is read now and only goes to its provider."""
+    if t.provider == "ollama":
+        if t.url:
+            return Ollama(t.url)
+        # lcode's own Ollama, unless lcode talks to another kind of server: then the usual address
+        return ollama if getattr(ollama, "kind", "ollama") == "ollama" else Ollama("http://localhost:11434")
+    from lcode.backends import OpenAICompatible
+
+    key = os.environ.get(t.key_env, "") if t.key_env else ""
+    if t.provider != "custom" and not key:
+        raise EscalateError(f"{t.label} needs an API key: set {t.key_env} in your environment (lcode never stores it)")
+    return OpenAICompatible(t.url, api_key=key, name=t.label)
+
+
+def parse_price(text: str | None) -> tuple[float, float] | None:
+    """`escalate_price` "3/15": dollars per million input and output tokens."""
+    if not text:
+        return None
+    m = re.fullmatch(r"\s*\$?(\d+(?:\.\d+)?)\s*/\s*\$?(\d+(?:\.\d+)?)\s*", str(text))
+    if not m:
+        raise EscalateError(f"escalate_price must look like 3/15 (dollars per million tokens in/out), not {text!r}")
+    return float(m.group(1)), float(m.group(2))
+
+
+def tokens(text: str) -> int:
+    return max(1, len(text) // 4)
+
+
+def cost_line(t: Target, sent: int, price: tuple[float, float] | None) -> str:
+    if not t.cloud:
+        return "free: it runs on " + ("this machine" if not t.url else t.where)
+    if price is None:
+        return "unknown: set escalate_price to see it (dollars per million tokens in/out, e.g. lcode config set escalate_price 3/15)"
+    low = sent * price[0] / 1e6
+    high = low + MAX_OUTPUT * price[1] / 1e6
+    return f"about ${low:.3f} to ${high:.3f} ({format_k(sent)} tokens in at ${price[0]:g}/M, up to {format_k(MAX_OUTPUT)} out at ${price[1]:g}/M)"
+
+
+def format_k(n: int) -> str:
+    return f"{n / 1000:.1f}K" if n >= 1000 else str(n)
+
+
+# --------------------------------------------------------------------------------------------- what's sent
+
+
+def brief(agent: Agent, why: str, failure: str = "") -> tuple[str, list[str]]:
+    """What the stronger model gets, and the names of the files in it."""
+    parts = []
+    requests = context_tools.user_requests(agent.messages)[-3:]
+    parts.append("# What the user asked (latest last)\n" + "\n---\n".join(r[:3000] for r in requests))
+    sheet = context_tools.task_sheet(agent)
+    if sheet:
+        parts.append("# The model's task sheet\n" + sheet)
+    parts.append(f"# Why it's stuck\n{why}" + (f"\n\n{failure[-6000:]}" if failure else ""))
+    steps = recent_steps(agent.messages)
+    if steps:
+        parts.append("# Its last steps\n" + steps)
+    used = sum(len(p) for p in parts)
+    files, names = [], []
+    for path in relevant_files(agent):
+        text = agent.current_text(path)
+        if text is None:
+            continue
+        if len(text) > FILE_CHARS:
+            text = text[:FILE_CHARS] + f"\n[… {len(text) - FILE_CHARS} more characters]"
+        block = f"## {agent.tools.rel(agent.tools.resolve(path))}\n```\n{text}\n```"
+        if used + len(block) > BUDGET:
+            break
+        used += len(block)
+        files.append(block)
+        names.append(agent.tools.rel(agent.tools.resolve(path)))
+    if files:
+        parts.append("# The files involved (as they are now)\n" + "\n\n".join(files))
+    return "\n\n".join(parts), names
+
+
+def relevant_files(agent: Agent) -> list[str]:
+    """The files changed in this request, then the ones read most recently."""
+    seen: dict[str, None] = dict.fromkeys(agent.tools.before)
+    for message in reversed(agent.messages):
+        for call in message.get("tool_calls") or []:
+            fn = call.get("function") or {}
+            args = fn.get("arguments") or {}
+            if (
+                isinstance(args, dict)
+                and fn.get("name") in ("read_file", "edit_file", "write_file")
+                and args.get("path")
+            ):
+                seen.setdefault(str(args["path"]), None)
+        if len(seen) >= 12:
+            break
+    return list(seen)
+
+
+def recent_steps(messages: list[dict]) -> str:
+    lines = []
+    for message in messages[-40:]:
+        for call in message.get("tool_calls") or []:
+            fn = call.get("function") or {}
+            args = fn.get("arguments") or {}
+            shown = ", ".join(f"{k}={str(v)[:120]!r}" for k, v in args.items()) if isinstance(args, dict) else ""
+            lines.append(f"- {fn.get('name', '?')}({shown})")
+        if message.get("role") == "tool":
+            result = str(message.get("content") or "").strip()
+            lines.append("  → " + (result[:400] + " …" if len(result) > 400 else result).replace("\n", "\n    "))
+    return "\n".join(lines[-RECENT_STEPS * 2 :])
+
+
+# --------------------------------------------------------------------------------------------- asking
+
+
+def ask_user(agent: Agent, t: Target, why: str, text: str, names: list[str], price) -> bool:
+    """Show what would go where, at what cost, and ask. Always asked, whatever the permission mode."""
+    if agent.escalate_approved is not None:  # a program decides (lcode -p --escalate, the benchmark)
+        return agent.escalate_approved
+    if not agent.interactive:
+        agent.say("A stronger model could help, but nobody can be asked in this run (lcode -p --escalate allows it).")
+        return False
+    sent = tokens(ADVISOR) + tokens(text)
+    files = ", ".join(names[:6]) + (f" and {len(names) - 6} more" if len(names) > 6 else "") if names else "none"
+    body = Text.from_markup(
+        f"[bold]Why:[/] {escape(why)}\n"
+        f"[bold]What goes:[/] your requests, the task sheet, the failure, the last steps and these files: "
+        f"{escape(files)} ({format_k(sent)} tokens)\n"
+        f"[bold]Where:[/] {escape(t.label)}, {'on' if t.where == 'this machine' else 'at'} {escape(t.where)}\n"
+        f"[bold]Cost:[/] {escape(cost_line(t, sent, price))}"
+    )
+    agent.console.print(Panel(body, title=f"Ask {t.model} for help?", title_align="left", border_style="magenta"))
+    agent.waiting(f"ask {t.model} for help?")
+    read = agent.perms.read_line or input
+    while True:
+        try:
+            answer = read("  Send it? [y]es / [n]o / [s]how what's sent: ").strip().lower()
+        except EOFError:
+            return False
+        if answer in ("s", "show"):
+            agent.console.print(Panel(Text(text), title="What would be sent", title_align="left", border_style="dim"))
+            continue
+        return answer in ("y", "yes")
+
+
+def advise(agent: Agent, t: Target, text: str) -> tuple[str, dict]:
+    """The stronger model's advice, and its token counts."""
+    talk = client(t, agent.ollama)
+    payload: dict = {
+        "model": t.model,
+        "messages": [{"role": "system", "content": ADVISOR}, {"role": "user", "content": text}],
+        "options": {"num_predict": MAX_OUTPUT},
+    }
+    if t.provider == "ollama":
+        from lcode.cli import NotInstalled, resolve_model
+
+        try:
+            payload["model"], _ = resolve_model(talk, t.model)  # a catalog key (qwen3.8-27b) or an Ollama tag
+        except (NotInstalled, OllamaError) as e:
+            raise EscalateError(str(e)) from e
+        payload["think"] = agent.settings.think
+        payload["keep_alive"] = "5m"  # it gives way to lcode's model soon after
+        payload["options"]["num_ctx"] = max(16384, min(65536, (tokens(text) + MAX_OUTPUT) * 5 // 4))
+    try:
+        reply = talk.chat(payload, timeout=TIMEOUT)
+    except OllamaError as e:
+        raise EscalateError(str(e).splitlines()[0][:300]) from e
+    advice = ((reply.get("message") or {}).get("content") or "").strip()
+    if not advice:
+        raise EscalateError(f"{t.model} gave no answer")
+    usage = {"in": reply.get("prompt_eval_count") or tokens(text), "out": reply.get("eval_count") or tokens(advice)}
+    return advice, usage
+
+
+def run(agent: Agent, why: str, failure: str = "") -> str | None:
+    """Ask the stronger model, if one is set and the user agrees; the message for the local model, or None."""
+    try:
+        t = target(agent.settings.escalate_model, agent.settings.escalate_url)
+        price = parse_price(agent.settings.escalate_price)
+    except EscalateError as e:
+        agent.say(str(e), warning=True)
+        return None
+    if t is None:
+        return None
+    text, names = brief(agent, why, failure)
+    if not ask_user(agent, t, why, text, names, price):
+        return None
+    started = time.monotonic()
+    try:
+        with agent.console.status(f"Asking {t.label} for help…", spinner="dots"):
+            advice, usage = advise(agent, t, text)
+    except EscalateError as e:
+        agent.say(f"Asking {t.model} failed: {e}", warning=True)
+        return None
+    seconds = time.monotonic() - started
+    cost = ""
+    if t.cloud and price:
+        cost = f", ${usage['in'] * price[0] / 1e6 + usage['out'] * price[1] / 1e6:.3f}"
+    agent.escalations.append(
+        {"model": t.label, "why": why, "tokens_in": usage["in"], "tokens_out": usage["out"], "seconds": round(seconds)}
+    )
+    agent.say(
+        f"{t.model} answered in {seconds:.0f}s ({format_k(usage['in'])} tokens in, {format_k(usage['out'])} out"
+        f"{cost}). Its advice goes to the model."
+    )
+    first = next((line.strip() for line in advice.splitlines() if line.strip()), "")
+    agent.console.print(Text(f"  ⎿ {first[:200]}", style="dim"))
+    return ADVICE.format(why=why, model=t.label, advice=advice)

lcode/repl.py

@@ -27,7 +27,19 @@ from rich.rule import Rule
 from rich.table import Table
 from rich.text import Text
 
-from lcode import __version__, backends, catalog, clipboard, extensions, gitflow, limits, residency, sessions, web
+from lcode import (
+    __version__,
+    backends,
+    catalog,
+    clipboard,
+    escalate,
+    extensions,
+    gitflow,
+    limits,
+    residency,
+    sessions,
+    web,
+)
 from lcode import context as context_tools
 from lcode import memory as memory_notes
 from lcode.agent import AUTO_COMPACT_RATIO, INIT_PROMPT, Agent
@@ -65,6 +77,7 @@ COMMANDS = {
     "/cd": "Change the working directory",
     "/todos": "Show the current todo list",
     "/status": "The task sheet: your requests, the plan and notes, files changed, the last check",
+    "/escalate": "Ask the stronger model (escalate_model) for advice, with your OK: /escalate [what's wrong]",
     "/jobs": "Background commands the model started: /jobs, /jobs stop <id>",
     "/commit": "Commit the changes with a message in the repository's style, after you approve it",
     "/review": "Review the uncommitted changes, or the branch against a base: /review [base]",
@@ -910,6 +923,28 @@ def stop_steering(agent: Agent, reader: KeyReader) -> None:
         agent.console.print(Text("✎ What you typed didn't reach the model; it's in the prompt below.", style="cyan"))
 
 
+def escalate_command(agent: Agent, arg: str) -> None:
+    """Ask the stronger model about the work so far, then let the model carry on with its advice."""
+    if agent.planning():
+        agent.console.print("[yellow]Leave plan mode first (Shift+Tab): the advice is for changing the code.[/]")
+        return
+    if not agent.can_escalate():
+        agent.console.print(
+            "[yellow]No stronger model is set.[/] Set one, for example:\n"
+            "  lcode config set escalate_model anthropic/<model>   (with ANTHROPIC_API_KEY in your environment)\n"
+            "  lcode config set escalate_model ollama/qwen3.8-27b  (a bigger local model)\n"
+            "See https://nasser1941.github.io/lcode/usage/#a-stronger-model-when-stuck"
+        )
+        return
+    if not context_tools.user_requests(agent.messages):
+        agent.console.print("[dim]Nothing to ask about yet: make a request first.[/]")
+        return
+    why = f"the user says: {arg}" if arg else "the user asked for a second opinion on the work so far"
+    advice = escalate.run(agent, why)
+    if advice:
+        run_safely(agent, f"{arg}\n\n{advice}" if arg else advice)
+
+
 def session_start(agent: Agent) -> None:
     """session_start hooks: their output is shown, and with feedback = true also given to the model."""
     for outcome in agent.hooks.run("session_start", {"cwd": str(agent.cwd), "session": agent.session_id}, agent.cwd):
@@ -1037,6 +1072,8 @@ def handle_command(agent: Agent, line: str, hardware: Hardware) -> bool:
         jobs_command(agent, arg)
     elif cmd == "/init":
         run_safely(agent, INIT_PROMPT)
+    elif cmd == "/escalate":
+        escalate_command(agent, arg)
     elif cmd in REPLACEABLE and cmd[1:] not in agent.extensions().commands:
         git_command(agent, cmd, arg)
     elif cmd[1:] in agent.extensions().commands:

lcode/screenshots.py

@@ -786,23 +786,32 @@ def is_local(url: str) -> bool:
     )
 
 
+def answers(url: str) -> bool:
+    """Whether something answers at the URL (an HTTP error is an answer: the page shows it)."""
+    if url.startswith("file:"):
+        return True
+    try:
+        with urllib.request.urlopen(url, timeout=2):
+            return True
+    except urllib.error.HTTPError:
+        return True
+    except (urllib.error.URLError, OSError, ValueError):
+        return False
+
+
 def wait_for_server(url: str, proc: subprocess.Popen, timeout: int, log: Path, cancel=None) -> None:
     deadline = time.time() + timeout
     while time.time() < deadline:
         if cancel is not None and cancel():
             raise KeyboardInterrupt
+        if answers(url):  # first: a command that hands off to a server and exits is fine too
+            return
         if proc.poll() is not None:
             raise ShotError(
                 f"the server command exited (exit code {proc.returncode}) before {url} answered"
                 + (f"\nWhat it printed:\n{printed(log)}" if printed(log) else "")
             )
-        try:
-            with urllib.request.urlopen(url, timeout=2):
-                return
-        except urllib.error.HTTPError:
-            return  # it answers, even if with an error: the page shows it
-        except (urllib.error.URLError, OSError, ValueError):
-            time.sleep(0.5)
+        time.sleep(0.5)
     raise ShotError(
         f"{url} didn't answer within {timeout}s of starting the server"
         + (f"\nWhat it printed:\n{printed(log)}" if printed(log) else "")
@@ -1060,14 +1069,17 @@ def take(
             url = normalize_url(url, cwd)
             server = None
             log = tmp / "server.txt"
+            running = bool(command) and answers(url)  # a server is up already (one the model started, say)
             try:
-                if command:
+                if command and not running:
                     server = run_program(command, cwd, dict(os.environ), log)
                     wait_for_server(url, server, SERVER_TIMEOUT, log, cancel)
                 shot = web(url, screen, wait, full_page, path, tmp)
             finally:
                 stop(server)
-            if command:
+            if running:
+                shot.report.append(f"({url} already answered, so `{command}` wasn't started: a server is running.)")
+            elif command:
                 shot.output = printed(log)
             return shot
         if not command:

lcode/tools.py

@@ -191,7 +191,8 @@ SCHEMAS = [
         "page), saves a screenshot in .lcode/screenshots/ and returns what it shows, with the sizes of windows and "
         "widgets (Qt) or of the page, and the browser's console errors. Use it to check GUI and layout work instead "
         "of guessing. Python Qt programs run offscreen; other desktop programs on a virtual display (Linux); web pages "
-        "in a headless browser. For a web app, give the command that starts its server and the url.",
+        "in a headless browser. For a web app, give the command that starts its server and the url (lcode starts and "
+        "stops it); if a server is already running, or for an .html file, give only the url.",
         {
             "command": {"type": "string", "description": "Command that starts the program, or the web server"},
             "url": {"type": "string", "description": "Page to open: a URL, localhost:PORT/path or an .html file"},

{lcode_cli-0.34.0.dist-info → lcode_cli-0.35.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.34.0
+Version: 0.35.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.34.0.dist-info → lcode_cli-0.35.0.dist-info}/RECORD

@@ -1,21 +1,22 @@
-lcode/__init__.py,sha256=y26TUBtLfL6QX-n4WMFUb_G6KZloeo7oYdUzb2UBFvU,473
+lcode/__init__.py,sha256=gk-TBYXXl_EmM4X0Si03ubfRw1OFZ-QjmkNP_Rj4jfc,473
 lcode/__main__.py,sha256=s5N5pryX2FAu93GGZ3FxUrIXHWGzxz66lKUoaV_h8Ws,35
 lcode/acp.py,sha256=d97VV3sbqXdWKhPQQNbYRaDTm8WrUk0mGbDLiOyX7jE,29058
 lcode/action.py,sha256=wuT5F9EJCdEligPeytzmEi8FpahWBhXer528tpuTj_k,16711
-lcode/agent.py,sha256=Vd0sEVlaa1sjUf_yIWmPYo5lLnnJapf_KG7wN7H_E9w,76155
-lcode/api.py,sha256=YTfXVMSYSp1EC3tNI_fW-JcNBgrdFTN7V57HNIzB7Kc,15861
-lcode/backends.py,sha256=dtJHrC6ys73bRDg64z0tQz1PavmeAkiODZu1fOO9ExQ,20635
-lcode/bench.py,sha256=KDgPnkceZOS3gDDEl5j6-k8Ser2es4-IuV_S8p_46Zo,41517
+lcode/agent.py,sha256=hLnVWTzXjqgXMn5JgkR-VXPZj4GDri1lIU7xYB5YBBs,78221
+lcode/api.py,sha256=FahtmNRjdgrVbImGFZhnKjMyeHHXGAMHv6-7NR9vm9I,16153
+lcode/backends.py,sha256=Tq8B1XzZflb56N-j7qtzgIws4lodWXIyWJkIqB1wSO4,20916
+lcode/bench.py,sha256=cBchBoDIqq5iA8Otevbf9BKF6mi6BzTEmmdxdG6MpCI,43078
 lcode/bench_backend.py,sha256=X2fo-zRX92Xp3KMxSsFlWioc2vRupBTtowj5kLME8mw,14287
 lcode/bench_runtime.py,sha256=EjzNgIvUkdbT8cbSy1TpmlyeIk6e-ipjlDFpM7Dnqx0,6835
 lcode/catalog.py,sha256=pZ1azX9OH2r4JE2c6E5OfwywpgS39-W2oXzoCHJhmtM,4141
 lcode/checkpoints.py,sha256=eqPtmPe44-aweWqc2H21ROogwzIt3NpvcUobsaCHoGY,18354
 lcode/checks.py,sha256=FOD8DOxPWXY1RMtrL9ONJsOxsV10BLgzPvzIJMK5NrU,6582
-lcode/cli.py,sha256=pB8gnPuVkqanm9amuLKWanH3_0onpn8oS8botxl-DSw,41292
+lcode/cli.py,sha256=nPvGnL0gZiUkbTniCoTAAyItiPEXZ-f6rHLYYUOKSiU,42151
 lcode/clipboard.py,sha256=nTSdJyCXPdtjH947RjvB3QvRqnL5HZsS9KB8EkC42cc,5138
 lcode/codesearch.py,sha256=Io8leN1nb_Y-Dvlm9xaGtwUWYXX-ooswuznJV6dGU1s,10766
-lcode/config.py,sha256=CujFZiUPsbZERjPw2j_uTBnZqUfCgYz1hvcvQSSMCu0,11421
-lcode/context.py,sha256=0YYLrC7gI164HqDjW_jrgHSnfrAilrRUoTLhvw54VI8,19082
+lcode/config.py,sha256=hAjuHg7plRxwFgdD4gOGnDH8-FwyT7NRV0YI5grd0qE,12604
+lcode/context.py,sha256=wgK16ZcNNnq4ngHx0EmtyKHDFTImciGEmtC5NP8tKJQ,20435
+lcode/escalate.py,sha256=6amspekybujPn0BfbVsNDYkB-I_pu6jJB45YJgFv0yc,14638
 lcode/extensions.py,sha256=W0HFDl0BvROzr7i_qtabHdIbacBgP5o5qIJLzoM2oNE,16806
 lcode/frontmatter.py,sha256=Bx0n4vLPhp7ZCWx-g7xqzqNy5VoKBxyeeikh5UFB_gA,2441
 lcode/gitflow.py,sha256=6j_nnCBZXkX1qhTI7K4CyZ5D0NAZLpH96weFEo64AkQ,27913
@@ -33,17 +34,17 @@ lcode/permissions.py,sha256=q7CjDsc_Xrblw7t3_BbxA5LUjxFSswGs1RiJmtMi0po,12288
 lcode/planning.py,sha256=Q2upaoZPnXDMQT2F-ETxX1lk_wDntTzhSKNVYIQSoQA,6540
 lcode/render.py,sha256=gMvf4W3qkLUJ4Vot3az_hP_zRDAItJC9pP-68dHFkfA,1375
 lcode/repeats.py,sha256=-vcbj363nFcIyso7yFJgsbHz9C6VOu2EOg3Svs4eFyE,4091
-lcode/repl.py,sha256=_krcqKqHKsGUKo4JfQS9KQNBxA47qE1k__TAkDTusRc,53242
+lcode/repl.py,sha256=zEXyfmIW-V8NqvfXmoqqeiMiM8Il4jb8bUFAA1SnF94,54628
 lcode/repomap.py,sha256=1GRJgEUjBl9XHSXsF7tSGXBCEgsY-3CzwMohaTudZ_M,13969
 lcode/residency.py,sha256=bDB2J0SZULDOz6wYuMCnkjacYk7pWi5f75iY83ycAXQ,6912
 lcode/review.py,sha256=0QBIS-R1B2b3zqx5TcC1qZptpKBbrDhYvMKSNCaDAUo,4686
 lcode/sandbox.py,sha256=u_pkrVRXhCGhh-wFDPwuZ3jGG7UeXxXRAeBNsm37ZvE,8608
-lcode/screenshots.py,sha256=t0jhiQdHULpFcFXNF-NVAjric1K_nkroNf8HkdqqQXo,45897
+lcode/screenshots.py,sha256=bcWSXS4xTsBk8HhpjBy5jvu705uH9qV8bXANr--Mf2M,46405
 lcode/secretscan.py,sha256=6Euvfk2gCtK7lZbuQD84zgWuSECi6OnSw8V5rFu1tfU,13575
 lcode/sessions.py,sha256=ojkpP453JyIll8_iFeJgW4BG4Zz2FKMRsLiij6spiTo,4185
 lcode/steer.py,sha256=0vaqLxgRKgC0yGp8xoQfV1f9VEOzH3U4rCIb74eFnZ8,12127
 lcode/subagents.py,sha256=GGn2E7QUwEsShJEHXaMhG53leyGFUZwJku_n33gJguU,29157
-lcode/tools.py,sha256=xHW6EJRJsoBYYK7P5ihS07DbFJybQObFgR-V2b4-ZBs,67474
+lcode/tools.py,sha256=2aZtQ1dot9p6Y6pcympP8nyiCdlba8gMbCqREwPMtPI,67586
 lcode/update.py,sha256=i92bnW252VneYh0vD6djxmXsDOa5MXP20bjlLZUue_c,25236
 lcode/vision.py,sha256=w33QPmdGwP33wM4mvmAH4amFDZ1xzeXhEsSLJ-STSHY,4243
 lcode/web.py,sha256=vyxKbSRJTl1Lj3hj7Yd_NwTgbv0Xi6dup2YfUXjqp-Y,14579
@@ -63,8 +64,8 @@ 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/servers/xai.py,sha256=h2emAvHSnkuB9WmJInlynsDhvxJwNVD2AHFX7vqMXNc,13627
-lcode_cli-0.34.0.dist-info/METADATA,sha256=IQC9qmYY9gtrhxkwRUc9M4iq60gxQrwpqLi80GgB6lY,13141
-lcode_cli-0.34.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-lcode_cli-0.34.0.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
-lcode_cli-0.34.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
-lcode_cli-0.34.0.dist-info/RECORD,,
+lcode_cli-0.35.0.dist-info/METADATA,sha256=FanOqu5FsF_g3lvnsVZ9ciVjq11BOHYFeBYTFkqm4G4,13141
+lcode_cli-0.35.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lcode_cli-0.35.0.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
+lcode_cli-0.35.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
+lcode_cli-0.35.0.dist-info/RECORD,,