weio-cli 0.4.0__tar.gz → 0.5.0__tar.gz

{weio_cli-0.4.0/src/weio_cli.egg-info → weio_cli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weio-cli
-Version: 0.4.0
+Version: 0.5.0
 Summary: Weio — an agentic coding assistant that routes inference through your Weio account.
 Author: We I/O Labs
 License: MIT
@@ -60,10 +60,11 @@ weio usage            # tier, tokens used today, remaining, reset time
 
 ## Use
 
-### Interactive TUI (default)
+### Interactive agent (default)
 
-Run `weio` with no arguments to drop into an interactive coding session — like a
-local pair-programmer in your terminal:
+Run `weio` with no arguments to start an autonomous coding agent in your terminal —
+like Claude Code / Codex. It reads files, searches, edits, and runs commands to
+complete your task, showing each step:
 
 ```bash
 cd my-project
@@ -71,38 +72,62 @@ weio
 ```
 
 ```
-weio › add a /health route to app.py that returns {"ok": true}
-
-weio: I'll add a health check route…
-  ● edit app.py
-  --- a/app.py
-  +++ b/app.py
-  @@ …
-  Apply 1 change(s)? [y/N] y
-  ✓ applied 1 change(s). (/undo to revert)
+weio › add a /health route to app.py and run the tests
+
+● Let me look at the app first.
+  📖 read_file app.py
+● Adding the route.
+  ✎ edit_file app.py
+  │ + @app.get("/health")
+  │ + def health(): return {"ok": True}
+  apply edit_file to app.py? [y/N] y
+● Verifying.
+  ❯ run_command pytest -q
+  │ exit=0  …  5 passed
+✔ Added /health and confirmed tests pass.
 ```
 
-Slash commands: `/add <file>`, `/drop <file>`, `/files`, `/auto` (auto-apply),
-`/model <id>`, `/undo`, `/clear`, `/cwd`, `/help`, `/exit`. Arrow-up recalls
-history. Files you mention or `/add` are kept in context and re-read each turn.
+The agent uses tools: **read_file, list_dir, search, edit_file, write_file,
+run_command**. File paths are confined to the project directory.
+
+Slash commands: `/model <id>`, `/approval <mode>`, `/steps <n>`, `/settings`,
+`/undo`, `/clear`, `/cwd`, `/help`, `/exit`.
+
+### Approval modes
+
+Control how much the agent does without asking (`/approval` or `weio config approval`):
+
+| Mode | Edits | Shell commands |
+|---|---|---|
+| `suggest` (default) | ask each time | ask each time |
+| `auto-edit` | auto-apply | ask each time |
+| `full-auto` | auto-apply | auto-run |
+
+### Settings
+
+```bash
+weio config                      # show all settings
+weio config approval auto-edit   # set a value
+weio config model pro            # auto | low | mid | pro
+weio config max_steps 40
+```
+
+Settings live in `~/.weio/settings.json`. The agent uses the most capable model
+your plan allows.
 
 ### One-shot & other commands
 
 ```bash
-# Run a single coding task non-interactively (reads & edits files):
+# Run a coding task non-interactively (auto-applies edits; add --auto to also run commands):
 weio "add error handling to the fetch() in api.py"
+weio code "refactor db.py to async" --auto
 
-# Add specific files to the context:
-weio code "refactor to async" -f server.py -f db.py
-
-# One-shot question (no file edits):
+# Quick question (no file edits):
 weio ask "what does a 502 from nginx usually mean?"
 
-# Interactive chat:
-weio chat
-
-# Check connectivity and your key:
-weio ping
+weio chat        # plain interactive chat
+weio usage       # tokens used / limits
+weio ping        # connectivity + key check
 ```
 
 Edits are shown as a diff and require confirmation before anything is written

{weio_cli-0.4.0 → weio_cli-0.5.0}/README.md

@@ -38,10 +38,11 @@ weio usage            # tier, tokens used today, remaining, reset time
 
 ## Use
 
-### Interactive TUI (default)
+### Interactive agent (default)
 
-Run `weio` with no arguments to drop into an interactive coding session — like a
-local pair-programmer in your terminal:
+Run `weio` with no arguments to start an autonomous coding agent in your terminal —
+like Claude Code / Codex. It reads files, searches, edits, and runs commands to
+complete your task, showing each step:
 
 ```bash
 cd my-project
@@ -49,38 +50,62 @@ weio
 ```
 
 ```
-weio › add a /health route to app.py that returns {"ok": true}
-
-weio: I'll add a health check route…
-  ● edit app.py
-  --- a/app.py
-  +++ b/app.py
-  @@ …
-  Apply 1 change(s)? [y/N] y
-  ✓ applied 1 change(s). (/undo to revert)
+weio › add a /health route to app.py and run the tests
+
+● Let me look at the app first.
+  📖 read_file app.py
+● Adding the route.
+  ✎ edit_file app.py
+  │ + @app.get("/health")
+  │ + def health(): return {"ok": True}
+  apply edit_file to app.py? [y/N] y
+● Verifying.
+  ❯ run_command pytest -q
+  │ exit=0  …  5 passed
+✔ Added /health and confirmed tests pass.
 ```
 
-Slash commands: `/add <file>`, `/drop <file>`, `/files`, `/auto` (auto-apply),
-`/model <id>`, `/undo`, `/clear`, `/cwd`, `/help`, `/exit`. Arrow-up recalls
-history. Files you mention or `/add` are kept in context and re-read each turn.
+The agent uses tools: **read_file, list_dir, search, edit_file, write_file,
+run_command**. File paths are confined to the project directory.
+
+Slash commands: `/model <id>`, `/approval <mode>`, `/steps <n>`, `/settings`,
+`/undo`, `/clear`, `/cwd`, `/help`, `/exit`.
+
+### Approval modes
+
+Control how much the agent does without asking (`/approval` or `weio config approval`):
+
+| Mode | Edits | Shell commands |
+|---|---|---|
+| `suggest` (default) | ask each time | ask each time |
+| `auto-edit` | auto-apply | ask each time |
+| `full-auto` | auto-apply | auto-run |
+
+### Settings
+
+```bash
+weio config                      # show all settings
+weio config approval auto-edit   # set a value
+weio config model pro            # auto | low | mid | pro
+weio config max_steps 40
+```
+
+Settings live in `~/.weio/settings.json`. The agent uses the most capable model
+your plan allows.
 
 ### One-shot & other commands
 
 ```bash
-# Run a single coding task non-interactively (reads & edits files):
+# Run a coding task non-interactively (auto-applies edits; add --auto to also run commands):
 weio "add error handling to the fetch() in api.py"
+weio code "refactor db.py to async" --auto
 
-# Add specific files to the context:
-weio code "refactor to async" -f server.py -f db.py
-
-# One-shot question (no file edits):
+# Quick question (no file edits):
 weio ask "what does a 502 from nginx usually mean?"
 
-# Interactive chat:
-weio chat
-
-# Check connectivity and your key:
-weio ping
+weio chat        # plain interactive chat
+weio usage       # tokens used / limits
+weio ping        # connectivity + key check
 ```
 
 Edits are shown as a diff and require confirmation before anything is written

{weio_cli-0.4.0 → weio_cli-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "weio-cli"
-version = "0.4.0"
+version = "0.5.0"
 description = "Weio — an agentic coding assistant that routes inference through your Weio account."
 readme = "README.md"
 requires-python = ">=3.9"

{weio_cli-0.4.0 → weio_cli-0.5.0}/src/weio_cli/__init__.py

@@ -1,3 +1,3 @@
 """Weio CLI — an agentic coding assistant that routes inference through your Weio account."""
 
-__version__ = "0.4.0"
+__version__ = "0.5.0"

weio_cli-0.5.0/src/weio_cli/agent.py

@@ -0,0 +1,237 @@
+"""The Weio coding agent: an autonomous tool-use loop, like Claude Code / Codex.
+
+The model works step by step, emitting tool calls as fenced JSON ```action blocks.
+The agent executes them (gated by the approval mode), feeds back observations, and
+loops until the model calls `finish` or the step budget is exhausted.
+
+UI is injected via callbacks so the TUI and one-shot runner share this engine.
+"""
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable, Optional
+
+from . import tools
+from .client import WeioClient, WeioError
+from .tools import ToolResult
+
+_FENCE_RE = re.compile(r"```(?:action|json)?\s*\n(.*?)```", re.DOTALL)
+_BARE_RE = re.compile(r'\{[^{}]*"tool"\s*:\s*"[a-z_]+".*?\}', re.DOTALL)
+
+READONLY_TOOLS = {"read_file", "list_dir", "search"}
+WRITE_TOOLS = {"write_file", "edit_file"}
+ALL_TOOLS = READONLY_TOOLS | WRITE_TOOLS | {"run_command", "finish"}
+
+
+def system_prompt(root: Path) -> str:
+    return f"""You are Weio, an autonomous coding agent working in the user's project directory:
+{root}
+
+You complete the user's task by using TOOLS, one step at a time. On each turn, briefly
+state what you are about to do (one or two sentences), then emit one or more tool calls
+as fenced JSON blocks exactly like this:
+
+```action
+{{"tool": "read_file", "args": {{"path": "src/app.py"}}}}
+```
+
+TOOLS:
+- read_file   {{"path": "..."}}                      read a file
+- list_dir    {{"path": "."}}                        list a directory
+- search      {{"query": "...", "path": "."}}        search file contents
+- write_file  {{"path": "...", "content": "..."}}    create/overwrite a file
+- edit_file   {{"path": "...", "search": "...", "replace": "..."}}  replace an exact snippet
+- run_command {{"command": "..."}}                   run a shell command in the project
+- finish      {{"summary": "..."}}                   call when the task is fully done
+
+RULES:
+- Explore before you edit: read_file / list_dir / search to understand the code first.
+- Take ONE logical step, then STOP and wait for the OBSERVATIONS before the next step.
+- edit_file "search" must match the current file contents EXACTLY (whitespace included).
+- Prefer edit_file for small changes; write_file for new files or full rewrites.
+- After making changes, verify (e.g. run tests or the file) when reasonable.
+- When the task is complete, call finish with a short summary. Never call finish early.
+- DO NOT just describe what you would do — emit the ```action block and DO it now.
+- Every reply must contain exactly one ```action block (until you call finish).
+
+EXAMPLE turn:
+Let me look at the file before changing it.
+```action
+{{"tool": "read_file", "args": {{"path": "math_utils.py"}}}}
+```"""
+
+
+@dataclass
+class Callbacks:
+    on_text: Callable[[str], None]                       # model narration
+    on_action: Callable[[str, dict], None]               # about to run a tool
+    on_result: Callable[[str, ToolResult], None]         # tool finished
+    approve: Callable[[str, dict, Optional[ToolResult]], bool]  # ask user (writes/cmds)
+    on_status: Callable[[str], None]                     # spinner/status text
+    on_finish: Callable[[str], None]                     # final summary
+
+
+def parse_actions(text: str) -> list[dict]:
+    """Extract tool calls. Accepts ```action / ```json fences, and bare JSON
+    objects containing a "tool" key (robust to weaker models' formatting)."""
+    actions = []
+    seen = set()
+    for m in _FENCE_RE.finditer(text):
+        raw = m.group(1).strip()
+        try:
+            obj = json.loads(raw)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(obj, dict) and "tool" in obj:
+            key = json.dumps(obj, sort_keys=True)
+            if key not in seen:
+                seen.add(key)
+                actions.append(obj)
+    if not actions:
+        for m in _BARE_RE.finditer(text):
+            try:
+                obj = json.loads(m.group(0))
+            except json.JSONDecodeError:
+                continue
+            if isinstance(obj, dict) and "tool" in obj:
+                key = json.dumps(obj, sort_keys=True)
+                if key not in seen:
+                    seen.add(key)
+                    actions.append(obj)
+    return actions
+
+
+def strip_actions(text: str) -> str:
+    return _BARE_RE.sub("", _FENCE_RE.sub("", text)).strip()
+
+
+class Agent:
+    def __init__(self, client: WeioClient, root: Path, settings: dict, cb: Callbacks):
+        self.client = client
+        self.root = root
+        self.settings = settings
+        self.cb = cb
+        self.messages: list[dict] = [{"role": "system", "content": system_prompt(root)}]
+        self.approval = settings.get("approval", "suggest")
+        self.max_steps = int(settings.get("max_steps", 25))
+        self.max_tokens = int(settings.get("max_tokens", 4096))
+
+    # -- model call --
+    def _complete(self) -> str:
+        return self.client.chat(self.messages, max_tokens=self.max_tokens, temperature=0.1)
+
+    # -- approval policy --
+    def _needs_approval(self, tool: str) -> bool:
+        if self.approval == "full-auto":
+            return False
+        if tool in WRITE_TOOLS:
+            return self.approval == "suggest"
+        if tool == "run_command":
+            return True  # commands always confirmed unless full-auto
+        return False
+
+    # -- execute one tool, return observation string --
+    def _execute(self, tool: str, args: dict) -> str:
+        self.cb.on_action(tool, args)
+
+        if tool == "read_file":
+            r = tools.read_file(self.root, args.get("path", ""))
+        elif tool == "list_dir":
+            r = tools.list_dir(self.root, args.get("path", "."))
+        elif tool == "search":
+            r = tools.search_files(self.root, args.get("query", ""), args.get("path", "."))
+        elif tool == "write_file":
+            r = tools.write_file(self.root, args.get("path", ""), args.get("content", ""))
+            r = self._maybe_commit(tool, args, r)
+        elif tool == "edit_file":
+            r = tools.edit_file(self.root, args.get("path", ""),
+                                args.get("search", ""), args.get("replace", ""))
+            r = self._maybe_commit(tool, args, r)
+        elif tool == "run_command":
+            cmd = args.get("command", "")
+            if self._needs_approval(tool) and not self.cb.approve(tool, args, None):
+                r = ToolResult(False, "Command declined by user.", display=f"$ {cmd} (declined)")
+            else:
+                r = tools.run_command(self.root, cmd)
+        else:
+            r = ToolResult(False, f"Unknown tool: {tool}")
+
+        self.cb.on_result(tool, r)
+        return f"[{tool} {args.get('path') or args.get('command') or args.get('query') or ''}]\n{r.output}"
+
+    def _maybe_commit(self, tool: str, args: dict, r: ToolResult) -> ToolResult:
+        if not r.ok:
+            return r
+        if self._needs_approval(tool) and not self.cb.approve(tool, args, r):
+            return ToolResult(False, f"{tool} on {r.path} declined by user.",
+                              display=f"{tool} {r.path} (declined)")
+        if tools.commit_write(self.root, r.path, r.new_text):
+            return r
+        return ToolResult(False, f"Failed to write {r.path}")
+
+    # -- main loop --
+    _CLAIM_WORDS = ("added", "created", "edited", "wrote", "updated", "modified",
+                    "implemented", "changed", "inserted", "removed", "deleted")
+
+    def run_task(self, task: str) -> str:
+        self.messages.append({"role": "user", "content": task})
+        nudges = 0
+        for step in range(self.max_steps):
+            self.cb.on_status("thinking")
+            try:
+                response = self._complete()
+            except WeioError as e:
+                self.cb.on_text(f"[error] {e}")
+                return f"error: {e}"
+
+            narration = strip_actions(response)
+            if narration:
+                self.cb.on_text(narration)
+
+            actions = parse_actions(response)
+            self.messages.append({"role": "assistant", "content": response})
+
+            if not actions:
+                # The model replied without a tool call. If it sounds like it
+                # claimed to make a change (but didn't actually act), push back
+                # hard. Allow up to 2 nudges before accepting the reply as final.
+                claims_edit = any(w in narration.lower() for w in self._CLAIM_WORDS)
+                if nudges < 2:
+                    nudges += 1
+                    msg = ("You did NOT emit a tool call — nothing changed on disk. "
+                           "Nothing happens until you emit a ```action block. "
+                           "If you intended to edit a file, emit the edit_file (or write_file) "
+                           "action now with the exact content. Otherwise call finish.")
+                    if not claims_edit:
+                        msg = ("Take the next step now as a ```action block, "
+                               "or call finish if the task is already complete.")
+                    self.messages.append({"role": "user", "content": msg})
+                    continue
+                self.cb.on_finish(narration or "(done)")
+                return narration
+            nudges = 0
+
+            observations = []
+            finished = None
+            for act in actions:
+                tool = act.get("tool")
+                args = act.get("args", {}) if isinstance(act.get("args"), dict) else {}
+                if tool == "finish":
+                    finished = args.get("summary", "Done.")
+                    break
+                if tool not in ALL_TOOLS:
+                    observations.append(f"[{tool}] Unknown tool. Use only the listed tools.")
+                    continue
+                observations.append(self._execute(tool, args))
+
+            if finished is not None:
+                self.cb.on_finish(finished)
+                return finished
+
+            self.messages.append({"role": "user", "content": "OBSERVATIONS:\n" + "\n\n".join(observations)})
+
+        self.cb.on_finish("Reached the step limit before finishing. Re-run to continue.")
+        return "step-limit"

{weio_cli-0.4.0 → weio_cli-0.5.0}/src/weio_cli/cli.py

@@ -16,7 +16,6 @@ from pathlib import Path
 
 from . import __version__, config
 from .client import WeioClient, WeioError
-from . import coder
 
 
 def _make_client(args) -> WeioClient:
@@ -198,74 +197,41 @@ def cmd_tui(args) -> int:
 
 
 def cmd_code(args) -> int:
+    """One-shot agent run: `weio "do X"` (non-interactive)."""
     try:
         client = _make_client(args)
     except WeioError as e:
         print(_c(str(e), "31"), file=sys.stderr)
         return 2
-    root = Path(args.dir).resolve()
+    root = Path(getattr(args, "dir", ".") or ".").resolve()
     if not root.is_dir():
         print(_c(f"Not a directory: {root}", "31"), file=sys.stderr)
         return 2
+    # Non-interactive: auto-apply edits; run commands only in full-auto.
+    approval = "full-auto" if getattr(args, "auto", False) else "auto-edit"
+    from .tui import run_once
+    return run_once(client, root, args.message, approval=approval, max_tokens=_max_tokens(args))
 
-    print(_c(f"weio coding in {root}", "36"))
-    print("Thinking…", flush=True)
-    try:
-        raw, edits = coder.run_coding_task(
-            client, args.message, root=root, files=args.file or [], max_tokens=_max_tokens(args)
-        )
-    except WeioError as e:
-        print(_c(str(e), "31"), file=sys.stderr)
-        return 1
 
-    if not edits:
-        # No edits — show the model's reply (it may be asking for files or explaining)
-        print(raw)
+def cmd_config(args) -> int:
+    from . import settings as settings_mod
+    key = getattr(args, "key_", None)
+    value = getattr(args, "value", None)
+    if not key:
+        st = settings_mod.load()
+        print(_c("weio settings:", "1"))
+        for k in ("model", "approval", "max_steps", "max_tokens", "stream"):
+            print(f"  {k:11} {st.get(k)}")
+        print(_c(f"\nfile: {settings_mod._file()}", "2"))
+        print(_c("set with: weio config <key> <value>  (e.g. weio config approval auto-edit)", "2"))
         return 0
-
-    # Apply edits (preview + confirm unless --yes)
-    results, errors = [], []
-    for e in edits:
-        res, err = coder.apply_edit(e, root)
-        if err:
-            errors.append(err)
-        elif res:
-            results.append(res)
-
-    for res in results:
-        tag = _c("NEW", "32") if res.created else _c("EDIT", "33")
-        print(f"\n{tag} {res.path}")
-        if res.created:
-            preview = res.new_text if len(res.new_text) < 1500 else res.new_text[:1500] + "\n… [truncated preview]"
-            print(preview)
-        else:
-            print(coder.unified_diff(res.path, res.old_text, res.new_text) or "(no textual diff)")
-
-    for err in errors:
-        print(_c("SKIP " + err, "31"))
-
-    if not results:
-        print(_c("\nNo applicable edits.", "33"))
-        return 1
-
-    if not args.yes:
-        try:
-            ans = input(_c(f"\nApply {len(results)} change(s)? [y/N] ", "36")).strip().lower()
-        except (EOFError, KeyboardInterrupt):
-            print()
-            ans = "n"
-        if ans not in ("y", "yes"):
-            print("Aborted. No files written.")
-            return 0
-
-    written = 0
-    for res in results:
-        fp = root / res.path
-        fp.parent.mkdir(parents=True, exist_ok=True)
-        fp.write_text(res.new_text, encoding="utf-8")
-        written += 1
-    print(_c(f"\nApplied {written} change(s).", "32"))
-    return 0
+    if value is None:
+        st = settings_mod.load()
+        print(f"{key} = {st.get(key)}")
+        return 0
+    ok, msg = settings_mod.set_value(key, value)
+    print(_c(msg, "32" if ok else "31"))
+    return 0 if ok else 1
 
 
 # --------------------------------------------------------------------------- #
@@ -321,13 +287,19 @@ def build_parser() -> argparse.ArgumentParser:
     sp = sub.add_parser("update", parents=[common], help="Update weio-cli to the latest version")
     sp.set_defaults(func=cmd_update)
 
-    sp = sub.add_parser("code", parents=[common], help="Run a coding task in a directory")
+    sp = sub.add_parser("code", parents=[common], help="Run an agent task non-interactively")
     sp.add_argument("message")
-    sp.add_argument("--file", "-f", action="append", help="Add a file to the context (repeatable)")
     sp.add_argument("--dir", "-C", default=".", help="Project directory (default: cwd)")
-    sp.add_argument("--yes", "-y", action="store_true", help="Apply edits without confirmation")
+    sp.add_argument("--auto", action="store_true",
+                    help="Full-auto: also run shell commands without asking")
     sp.set_defaults(func=cmd_code)
 
+    sp = sub.add_parser("config", parents=[common], help="View or change CLI settings")
+    sp.add_argument("key_", metavar="key", nargs="?",
+                    help="Setting: model | approval | max_steps | max_tokens | stream")
+    sp.add_argument("value", nargs="?", help="New value")
+    sp.set_defaults(func=cmd_config)
+
     return p
 
 
@@ -335,7 +307,7 @@ def main(argv=None) -> int:
     argv = list(sys.argv[1:] if argv is None else argv)
     parser = build_parser()
 
-    known = {"login", "ping", "ask", "chat", "code", "tui", "update", "usage"}
+    known = {"login", "ping", "ask", "chat", "code", "tui", "update", "usage", "config"}
     # Bare `weio` (no args) → interactive coding TUI, like Claude Code.
     if not argv:
         argv = ["tui"]

weio_cli-0.5.0/src/weio_cli/settings.py

@@ -0,0 +1,69 @@
+"""Persistent CLI settings (~/.weio/settings.json).
+
+Separate from config.py (which holds the API key/base). These are behavior
+preferences for the coding agent.
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+APPROVAL_MODES = ("suggest", "auto-edit", "full-auto")
+
+DEFAULTS = {
+    "model": "auto",            # auto | low | mid | pro
+    "approval": "suggest",      # suggest | auto-edit | full-auto
+    "max_steps": 25,            # max agent tool-steps per task
+    "max_tokens": 4096,
+    "stream": True,
+}
+
+_VALID_KEYS = set(DEFAULTS)
+
+
+def _dir() -> Path:
+    return Path(os.environ.get("WEIO_CONFIG_DIR", str(Path.home() / ".weio")))
+
+
+def _file() -> Path:
+    return _dir() / "settings.json"
+
+
+def load() -> dict:
+    data = dict(DEFAULTS)
+    try:
+        if _file().exists():
+            data.update({k: v for k, v in json.loads(_file().read_text()).items() if k in _VALID_KEYS})
+    except Exception:
+        pass
+    return data
+
+
+def save(data: dict) -> Path:
+    _dir().mkdir(parents=True, exist_ok=True)
+    clean = {k: v for k, v in data.items() if k in _VALID_KEYS}
+    _file().write_text(json.dumps(clean, indent=2))
+    return _file()
+
+
+def set_value(key: str, value: str) -> tuple[bool, str]:
+    """Set one setting from a string value. Returns (ok, message)."""
+    if key not in _VALID_KEYS:
+        return False, f"Unknown setting '{key}'. Valid: {', '.join(sorted(_VALID_KEYS))}"
+    data = load()
+    if key == "approval":
+        if value not in APPROVAL_MODES:
+            return False, f"approval must be one of: {', '.join(APPROVAL_MODES)}"
+        data[key] = value
+    elif key in ("max_steps", "max_tokens"):
+        try:
+            data[key] = max(1, int(value))
+        except ValueError:
+            return False, f"{key} must be an integer"
+    elif key == "stream":
+        data[key] = value.lower() in ("1", "true", "yes", "on")
+    else:  # model
+        data[key] = value
+    save(data)
+    return True, f"{key} = {data[key]}"