euron-code 0.1.0__py3-none-any.whl

euron_code/repl.py

@@ -0,0 +1,425 @@
+"""Interactive session: prompt, slash commands, status line."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional
+
+from rich.markup import escape
+
+from euron_code import __version__, api, auth, config, memory, prompts, sessions
+from euron_code.agent import Agent, TurnResult
+from euron_code.usage_view import render_account, render_usage, short, status_line
+
+SLASH_COMMANDS = {
+    "/help": "Show this help",
+    "/login": "Log in again (device flow in the browser)",
+    "/logout": "Remove the saved key from this computer",
+    "/usage": "Plan, tokens today, limits and last 30 days",
+    "/model": "Show or switch the model: /model [id]",
+    "/compact": "Summarise the conversation to free context: /compact [focus]",
+    "/clear": "Start a fresh conversation (new session)",
+    "/memory": "Show memory files; /memory edit opens EURON.md",
+    "/init": "Explore the repo and write EURON.md",
+    "/cost": "Tokens used in this session",
+    "/permissions": "Show rules; /permissions mode <default|acceptEdits|yolo>, allow|deny <rule>",
+    "/thinking": "Reasoning display: /thinking show|collapse|hide",
+    "/todos": "Show the current todo list",
+    "/doctor": "Check setup and connectivity",
+    "/exit": "Quit (also /quit, Ctrl-D)",
+}
+
+
+class Repl:
+    def __init__(self, agent: Agent, client: api.Client, ui, me: Optional[Dict[str, Any]],
+                 session: sessions.SessionWriter, pt_io: Optional[tuple] = None):
+        self.agent = agent
+        self.pt_io = pt_io  # (input, output) for prompt_toolkit; tests only
+        self.client = client
+        self.ui = ui
+        self.me = me
+        self.session = session
+        self.me_base_tokens = 0
+        self._prompt = None
+        agent.on_usage = self._usage_changed
+
+    # ---------------------------------------------------------- status
+    def _usage_changed(self) -> None:
+        pass
+
+    def remaining_today(self) -> Optional[int]:
+        if not self.me:
+            return None
+        rem = (self.me.get("quota") or {}).get("remainingToday")
+        if rem is None:
+            return None
+        return max(0, int(rem) - (self.agent.tokens.session_total - self.me_base_tokens))
+
+    def refresh_me(self, force: bool = False) -> None:
+        try:
+            before = self.client.me_fetched_at
+            me = self.client.me(use_cache=not force)
+            if self.client.me_fetched_at != before or force:
+                self.me_base_tokens = self.agent.tokens.session_total
+            self.me = me
+        except api.EuronError:
+            pass
+
+    def status(self) -> str:
+        me = None
+        if self.me:
+            me = dict(self.me)
+            q = dict(me.get("quota") or {})
+            if self.remaining_today() is not None:
+                q["remainingToday"] = self.remaining_today()
+            me["quota"] = q
+        pct = self.agent.context_usage() * 100 // max(1, self.agent.window)
+        return status_line(self.agent.model, self.agent.tokens.session_total, me, self.agent.permissions.mode, pct)
+
+    # ---------------------------------------------------------- input
+    def _make_prompt(self):
+        if self.pt_io is None and not (sys.stdin.isatty() and sys.stdout.isatty()):
+            return None
+        try:
+            from prompt_toolkit import PromptSession
+            from prompt_toolkit.completion import WordCompleter
+            from prompt_toolkit.history import FileHistory
+            from prompt_toolkit.key_binding import KeyBindings
+
+            kb = KeyBindings()
+
+            @kb.add("escape", "enter")
+            def _(event):
+                event.current_buffer.insert_text("\n")
+
+            hist = config.ensure_home() / "history"
+            return PromptSession(
+                history=FileHistory(str(hist)),
+                completer=WordCompleter(list(SLASH_COMMANDS) + ["/quit"], sentence=True),
+                complete_while_typing=False,
+                key_bindings=kb,
+                bottom_toolbar=lambda: " " + self.status() + "   (Esc+Enter: newline, Esc: interrupt)",
+                **({"input": self.pt_io[0], "output": self.pt_io[1]} if self.pt_io else {}),
+            )
+        except Exception:
+            return None
+
+    def read_input(self) -> Optional[str]:
+        if self._prompt is None:
+            self._prompt = self._make_prompt() or False
+        if self._prompt:
+            try:
+                return self._prompt.prompt("> ")
+            except KeyboardInterrupt:
+                return ""
+            except EOFError:
+                return None
+        try:
+            self.ui.dim(self.status())
+            return input("> ")
+        except KeyboardInterrupt:
+            print()
+            return ""
+        except EOFError:
+            return None
+
+    # ---------------------------------------------------------- main loop
+    def run(self, initial: Optional[str] = None) -> int:
+        self.banner()
+        pending = initial
+        while True:
+            text = pending if pending is not None else self.read_input()
+            pending = None
+            if text is None:
+                self.ui.dim("Bye.")
+                return 0
+            text = text.strip()
+            if not text:
+                continue
+            if text.endswith("\\") and self._prompt is False:
+                # simple multi-line for plain input(): end a line with backslash
+                lines = [text[:-1]]
+                while True:
+                    try:
+                        more = input("... ")
+                    except EOFError:
+                        break
+                    if more.endswith("\\"):
+                        lines.append(more[:-1])
+                        continue
+                    lines.append(more)
+                    break
+                text = "\n".join(lines)
+            if text.startswith("/"):
+                try:
+                    if self.slash(text) == "exit":
+                        return 0
+                except api.NotEntitledError:
+                    self.ui.exact(api.NO_PLUS_MESSAGE)
+                    return 3
+                except api.EuronError as e:
+                    self.ui.error(e.message)
+                continue
+            if text.startswith("#") and len(text) > 1:
+                self.add_memory(text[1:].strip())
+                continue
+            try:
+                code = self.turn(text)
+            except KeyboardInterrupt:
+                self.ui.warn("Interrupted.")
+                continue
+            if code is not None:
+                return code
+
+    def banner(self) -> None:
+        self.ui.info(f"[bold]Euron Code[/bold] {__version__}  [dim]{escape(str(self.agent.root))}[/dim]")
+        if self.me:
+            access = self.me.get("access") or {}
+            q = self.me.get("quota") or {}
+            totals = self.me.get("totals") or {}
+            self.ui.dim(f"{api.plan_label(access)} | today {short(q.get('usedToday'))} / {short(q.get('dailyTokenLimit'))} tokens"
+                        f" | all time {short(totals.get('allTimeTokens'))} tokens | model {self.agent.model}")
+        if self.agent.memory_files:
+            self.ui.dim("Memory: " + ", ".join(f.path.name + f" ({f.scope})" for f in self.agent.memory_files))
+        if self.agent.permissions.mode == "yolo":
+            self.ui.warn("Permission prompts are OFF (--yolo). Commands and edits run without asking.")
+        self.ui.dim("Type /help for commands. Esc or Ctrl-C interrupts a reply; Ctrl-D exits.")
+
+    def turn(self, text: str) -> Optional[int]:
+        res: TurnResult = self.agent.run_turn(text)
+        self.refresh_me()
+        if res.error is not None:
+            return self.handle_error(res.error)
+        if res.stop_reason == "max_turns":
+            self.ui.warn("Stopped at the step limit.")
+        return None
+
+    def handle_error(self, e: api.EuronError) -> Optional[int]:
+        if isinstance(e, api.NotEntitledError):
+            self.ui.exact(api.NO_PLUS_MESSAGE)
+            return 3
+        if isinstance(e, api.AuthError):
+            self.ui.error(f"{e.message}. Your key is missing, revoked or expired. Run /login (or `euron login`).")
+            return None
+        if isinstance(e, api.QuotaExceededError):
+            self.refresh_me(force=True)
+            from euron_code.usage_view import local_time
+            resets = local_time(((self.me or {}).get("quota") or {}).get("resetsAt"))
+            self.ui.error(f"You have used today's Euron Code token allowance. It resets at {resets}.")
+            return None
+        self.ui.error(e.message)
+        return None
+
+    # ---------------------------------------------------------- memory
+    def add_memory(self, note: str) -> None:
+        if not note:
+            return
+        ans = self.ui.ask_text("Save to (p)roject EURON.md or (u)ser ~/.euron/EURON.md? [p] ").strip().lower()
+        scope = "user" if ans.startswith("u") else "project"
+        path = memory.append_note(note, self.agent.root, scope)
+        self.agent.reload_system()
+        self.ui.dim(f"Saved to {path}")
+
+    # ---------------------------------------------------------- slash commands
+    def slash(self, line: str) -> Optional[str]:
+        parts = line.split(maxsplit=1)
+        cmd, arg = parts[0].lower(), (parts[1].strip() if len(parts) > 1 else "")
+        if cmd in ("/exit", "/quit"):
+            return "exit"
+        if cmd == "/help":
+            for k, v in SLASH_COMMANDS.items():
+                self.ui.info(f"  [bold]{k:<13}[/bold] {escape(v)}")
+            self.ui.info("  [bold]# note[/bold]        Add a note to memory (EURON.md)")
+            self.ui.dim("  Esc / Ctrl-C interrupts a reply. Esc+Enter inserts a newline.")
+            return None
+        if cmd == "/usage":
+            me = self.client.me(use_cache=False)
+            self.me = me
+            self.me_base_tokens = self.agent.tokens.session_total
+            usage = None
+            try:
+                usage = self.client.usage(30)
+            except api.EuronError as e:
+                self.ui.warn(f"Could not load daily usage: {e.message}")
+            render_usage(self.ui, me, usage)
+            self.ui.dim(f"This session: {self.agent.tokens.session_total:,} tokens")
+            return None
+        if cmd == "/cost":
+            t = self.agent.tokens
+            self.ui.info(f"Session tokens: {t.session_total:,} (prompt {t.session_prompt:,}, completion "
+                         f"{t.session_completion:,}) over {t.requests} requests")
+            if t.session_cached:
+                self.ui.info(f"Prompt tokens served from the gateway's prefix cache: {t.session_cached:,}")
+            self.ui.info(f"Context now: ~{self.agent.context_usage():,} of {self.agent.window:,} tokens")
+            rem = self.remaining_today()
+            if rem is not None:
+                self.ui.info(f"Remaining today: ~{rem:,} tokens")
+            self.ui.dim("Euron Code is included with your plan; tokens count toward the daily allowance only.")
+            return None
+        if cmd == "/model":
+            return self._model(arg)
+        if cmd == "/compact":
+            self.agent.compact(force=True, instructions=arg or None, manual=True)
+            return None
+        if cmd == "/clear":
+            self.agent.clear()
+            self.session = sessions.SessionWriter(self.agent.root, model=self.agent.model)
+            self.agent.session = self.session
+            self.ui.dim(f"Started a new conversation (session {self.session.id}).")
+            return None
+        if cmd == "/memory":
+            return self._memory(arg)
+        if cmd == "/init":
+            self.turn(prompts.INIT_PROMPT)
+            self.agent.reload_system()
+            return None
+        if cmd == "/permissions":
+            return self._permissions(arg)
+        if cmd == "/thinking":
+            if arg in ("show", "collapse", "hide"):
+                self.ui.reasoning_mode = arg
+                config.config_set("reasoning", arg)
+            else:
+                order = ["collapse", "show", "hide"]
+                self.ui.reasoning_mode = order[(order.index(self.ui.reasoning_mode) + 1) % 3] \
+                    if self.ui.reasoning_mode in order else "collapse"
+            self.ui.dim(f"Reasoning display: {self.ui.reasoning_mode}")
+            return None
+        if cmd == "/todos":
+            self.ui.show_todos(self.agent.ctx.todos)
+            return None
+        if cmd == "/doctor":
+            from euron_code.doctor import doctor
+            doctor(self.ui)
+            return None
+        if cmd == "/login":
+            me = auth.login(self.ui, self.client.base_url)
+            from euron_code import credentials
+            cred = credentials.load(self.client.base_url)
+            if cred:
+                self.client.api_key = cred.api_key
+            self.me = me
+            return None
+        if cmd == "/logout":
+            auth.logout(self.ui, self.client.base_url)
+            self.ui.dim("Run /login to sign in again, or /exit.")
+            self.client.api_key = None
+            return None
+        self.ui.warn(f"Unknown command {cmd}. Type /help.")
+        return None
+
+    def _model(self, arg: str) -> None:
+        models = []
+        try:
+            models = self.client.models()
+        except api.EuronError as e:
+            self.ui.warn(f"Could not list models: {e.message}")
+        if not arg:
+            self.ui.info(f"Current model: [bold]{self.agent.model}[/bold]")
+            for m in models:
+                mark = "*" if m.get("id") == self.agent.model else " "
+                extra = []
+                for k in ("context_length", "max_model_len", "contextWindow"):
+                    if m.get(k):
+                        extra.append(f"context {m[k]}")
+                        break
+                self.ui.info(f"  {mark} {m.get('id')}  [dim]{' '.join(extra)}[/dim]")
+            self.ui.dim("Switch with /model <id>.")
+            return None
+        ids = [m.get("id") for m in models]
+        if ids and arg not in ids:
+            self.ui.warn(f"Unknown model {arg!r}. Available: {', '.join(i for i in ids if i)}")
+            return None
+        self.agent.model = arg
+        self.ui.info(f"Model set to [bold]{escape(arg)}[/bold] for this session "
+                     f"(make it the default with `euron config set model {escape(arg)}`).")
+        return None
+
+    def _memory(self, arg: str) -> None:
+        if arg.startswith("edit"):
+            scope = "user" if "user" in arg else "project"
+            path = memory.user_file() if scope == "user" else memory.project_file(self.agent.root)
+            if not path.exists():
+                path.parent.mkdir(parents=True, exist_ok=True)
+                path.write_text("# Notes for Euron Code\n\n", encoding="utf-8")
+            open_in_editor(path, self.ui)
+            self.agent.reload_system()
+            self.ui.dim("Memory reloaded.")
+            return None
+        files = memory.load(self.agent.root)
+        if not files:
+            self.ui.info("No memory files yet. Add a note with `# <note>`, run /init, or /memory edit.")
+        for f in files:
+            self.ui.info(f"[bold]{escape(str(f.path))}[/bold] ({f.scope})")
+            self.ui.plain(f.text[:3000])
+            self.ui.info("")
+        self.ui.dim("Edit with /memory edit (project) or /memory edit user.")
+        return None
+
+    def _permissions(self, arg: str) -> None:
+        p = self.agent.permissions
+        bits = arg.split(maxsplit=1)
+        if bits and bits[0] == "mode" and len(bits) > 1:
+            if bits[1] not in ("default", "acceptEdits", "yolo"):
+                self.ui.warn("Modes: default, acceptEdits, yolo")
+                return None
+            p.mode = bits[1]
+            self.ui.info(f"Permission mode: {p.mode}")
+            return None
+        if bits and bits[0] in ("allow", "deny") and len(bits) > 1:
+            path = config.add_permission_rule(self.agent.root, bits[0], bits[1])
+            (p.allow if bits[0] == "allow" else p.deny).append(bits[1])
+            self.ui.info(f"Added {bits[0]} rule {escape(bits[1])} ({path})")
+            return None
+        self.ui.info(f"Mode: [bold]{p.mode}[/bold]  (project root {escape(str(p.root))})")
+        self.ui.info("Allow rules: " + (escape(", ".join(p.allow)) or "(none)"))
+        self.ui.info("Deny rules:  " + (escape(", ".join(p.deny)) or "(none)"))
+        self.ui.info("Session:     " + (escape(", ".join(p.session_allow)) or "(none)"))
+        self.ui.dim("Defaults: reads inside the project are allowed; edits, commands and web fetches ask.")
+        self.ui.dim("Change: /permissions mode <default|acceptEdits|yolo>, /permissions allow 'Bash(npm test:*)'")
+        return None
+
+
+def open_in_editor(path: Path, ui) -> None:
+    editor = os.environ.get("VISUAL") or os.environ.get("EDITOR")
+    if not editor:
+        if shutil.which("code"):
+            editor = "code --wait"
+        elif os.name == "nt":
+            editor = "notepad"
+        else:
+            editor = shutil.which("nano") and "nano" or "vi"
+    try:
+        import shlex
+        argv = shlex.split(editor, posix=(os.name != "nt")) + [str(path)]
+        subprocess.run(argv, shell=(os.name == "nt" and editor.startswith("code")))
+    except Exception as e:
+        ui.warn(f"Could not open an editor ({e}). Edit {path} yourself.")
+
+
+def pick_session(root: Path, ui) -> Optional[sessions.SessionInfo]:
+    items = sessions.list_sessions(root)[:20]
+    if not items:
+        ui.warn("No saved sessions for this project.")
+        return None
+    for i, s in enumerate(items, 1):
+        when = time.strftime("%Y-%m-%d %H:%M", time.localtime(s.modified))
+        ui.info(f"  [bold]{i:>2}[/bold]  {when}  [dim]{s.messages:>3} msgs[/dim]  {escape(s.first_prompt or '(empty)')}")
+    ans = ui.ask_text("Resume which session? [1] ").strip()
+    if not ans:
+        return items[0]
+    try:
+        n = int(ans)
+        if 1 <= n <= len(items):
+            return items[n - 1]
+    except ValueError:
+        found = sessions.find(root, ans)
+        if found:
+            return found
+    ui.warn("No such session.")
+    return None

euron_code/sessions.py

@@ -0,0 +1,186 @@
+"""Session transcripts: ~/.euron/sessions/<project-hash>/<id>.jsonl
+
+Records (one JSON object per line):
+  {"type": "meta", "id", "root", "created", "model", "version"}
+  {"type": "message", "message": {...OpenAI chat message...}}
+  {"type": "compact", "messages": [...full replacement history, without system...]}
+  {"type": "todos", "todos": [...]}
+The system prompt is never stored (it is rebuilt on resume, so memory changes apply).
+"""
+
+from __future__ import annotations
+
+import datetime as _dt
+import hashlib
+import json
+import os
+import uuid
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from euron_code import __version__, config
+
+
+def project_hash(root: Path) -> str:
+    s = str(root.resolve())
+    if os.name == "nt":
+        s = s.lower()
+    return hashlib.sha256(s.encode("utf-8")).hexdigest()[:16]
+
+
+def sessions_dir(root: Path) -> Path:
+    return config.euron_home() / "sessions" / project_hash(root)
+
+
+def new_id() -> str:
+    ts = _dt.datetime.now().strftime("%Y%m%d-%H%M%S")
+    return f"{ts}-{uuid.uuid4().hex[:6]}"
+
+
+@dataclass
+class SessionInfo:
+    id: str
+    path: Path
+    modified: float
+    first_prompt: str
+    messages: int
+
+
+@dataclass
+class LoadedSession:
+    id: str
+    messages: List[Dict[str, Any]] = field(default_factory=list)
+    todos: List[Dict[str, Any]] = field(default_factory=list)
+    model: Optional[str] = None
+
+
+class SessionWriter:
+    def __init__(self, root: Path, session_id: Optional[str] = None, model: Optional[str] = None):
+        self.root = root
+        self.id = session_id or new_id()
+        self.path = sessions_dir(root) / f"{self.id}.jsonl"
+        self._started = self.path.exists()
+        self.model = model
+
+    def _write(self, rec: Dict[str, Any]) -> None:
+        try:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            if not self._started:
+                self._started = True
+                meta = {"type": "meta", "id": self.id, "root": str(self.root), "version": __version__,
+                        "created": _dt.datetime.now().isoformat(timespec="seconds"), "model": self.model}
+                with open(self.path, "a", encoding="utf-8") as f:
+                    f.write(json.dumps(meta, ensure_ascii=False) + "\n")
+            with open(self.path, "a", encoding="utf-8") as f:
+                f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+        except OSError:
+            pass  # a transcript problem must never break the session
+
+    def message(self, msg: Dict[str, Any]) -> None:
+        self._write({"type": "message", "message": msg})
+
+    def compact(self, messages: List[Dict[str, Any]]) -> None:
+        self._write({"type": "compact", "messages": messages})
+
+    def todos(self, todos: List[Dict[str, Any]]) -> None:
+        self._write({"type": "todos", "todos": todos})
+
+
+def load_session(path: Path) -> LoadedSession:
+    sess = LoadedSession(id=path.stem)
+    with open(path, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                rec = json.loads(line)
+            except ValueError:
+                continue  # tolerate a torn last line after a crash
+            t = rec.get("type")
+            if t == "meta":
+                sess.model = rec.get("model")
+            elif t == "message" and isinstance(rec.get("message"), dict):
+                sess.messages.append(rec["message"])
+            elif t == "compact" and isinstance(rec.get("messages"), list):
+                sess.messages = list(rec["messages"])
+            elif t == "todos" and isinstance(rec.get("todos"), list):
+                sess.todos = rec["todos"]
+    sess.messages = _repair(sess.messages)
+    return sess
+
+
+def _repair(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """Drop a trailing assistant tool-call message whose results were never recorded (crash or
+    interrupt mid-turn), so the resumed conversation is valid."""
+    out = list(messages)
+    while out:
+        last = out[-1]
+        if last.get("role") == "assistant" and last.get("tool_calls"):
+            out.pop()
+            continue
+        break
+    # also ensure every assistant tool_call has results
+    fixed: List[Dict[str, Any]] = []
+    i = 0
+    while i < len(out):
+        m = out[i]
+        fixed.append(m)
+        if m.get("role") == "assistant" and m.get("tool_calls"):
+            ids = [tc.get("id") for tc in m["tool_calls"]]
+            j = i + 1
+            seen = set()
+            while j < len(out) and out[j].get("role") == "tool":
+                seen.add(out[j].get("tool_call_id"))
+                fixed.append(out[j])
+                j += 1
+            for tid in ids:
+                if tid not in seen:
+                    fixed.append({"role": "tool", "tool_call_id": tid, "content": "[no result recorded]"})
+            i = j
+            continue
+        i += 1
+    return fixed
+
+
+def list_sessions(root: Path) -> List[SessionInfo]:
+    d = sessions_dir(root)
+    if not d.is_dir():
+        return []
+    infos = []
+    for p in d.glob("*.jsonl"):
+        first = ""
+        count = 0
+        try:
+            with open(p, "r", encoding="utf-8") as f:
+                for line in f:
+                    try:
+                        rec = json.loads(line)
+                    except ValueError:
+                        continue
+                    if rec.get("type") == "message":
+                        count += 1
+                        m = rec["message"]
+                        if not first and m.get("role") == "user":
+                            c = str(m.get("content") or "")
+                            if "</context>" in c:
+                                c = c.split("</context>", 1)[1]
+                            first = " ".join(c.split())[:80]
+            infos.append(SessionInfo(p.stem, p, p.stat().st_mtime, first, count))
+        except OSError:
+            continue
+    infos.sort(key=lambda s: -s.modified)
+    return [s for s in infos if s.messages > 0]
+
+
+def latest(root: Path) -> Optional[SessionInfo]:
+    items = list_sessions(root)
+    return items[0] if items else None
+
+
+def find(root: Path, session_id: str) -> Optional[SessionInfo]:
+    for s in list_sessions(root):
+        if s.id == session_id or s.id.startswith(session_id):
+            return s
+    return None

euron_code/tools/__init__.py

@@ -0,0 +1,33 @@
+"""Tool registry. The order here is the order sent to the model; keep it stable for the
+gateway's prefix cache."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from euron_code.tools.base import Tool, ToolContext, ToolError, ToolResult, truncate
+from euron_code.tools.db import DbQuery
+from euron_code.tools.fs import EditFile, ListDir, MultiEdit, ReadFile, WriteFile
+from euron_code.tools.search import Glob, Grep
+from euron_code.tools.shell import Bash
+from euron_code.tools.task import Task
+from euron_code.tools.todo import TodoWrite
+from euron_code.tools.web import WebFetch
+
+__all__ = ["Tool", "ToolContext", "ToolError", "ToolResult", "truncate", "default_tools", "read_only_tools"]
+
+
+def default_tools(settings: Dict[str, Any], subagents: bool = True) -> List[Tool]:
+    tools: List[Tool] = [
+        ReadFile(), WriteFile(), EditFile(), MultiEdit(), ListDir(), Glob(), Grep(), Bash(),
+        TodoWrite(), DbQuery(),
+    ]
+    if settings.get("webFetch", True):
+        tools.append(WebFetch())
+    if subagents:
+        tools.append(Task())
+    return tools
+
+
+def read_only_tools() -> List[Tool]:
+    return [ReadFile(), ListDir(), Glob(), Grep()]