pal-code 0.1.2__tar.gz → 0.1.3__tar.gz

{pal_code-0.1.2 → pal_code-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pal-code
-Version: 0.1.2
+Version: 0.1.3
 Summary: Pal: build and plan with AI in your terminal (pal cli) or browser (pal web), on a layer that cuts tokens and latency.
 Author: Vrushal More
 License: MIT
@@ -26,6 +26,9 @@ Requires-Dist: graphifyy>=0.9
 Requires-Dist: pypdf>=4.0
 Requires-Dist: python-pptx>=0.6.23
 Requires-Dist: openpyxl>=3.1
+Requires-Dist: sounddevice>=0.4
+Requires-Dist: numpy>=1.24
+Requires-Dist: faster-whisper>=1.0
 Provides-Extra: documents
 Requires-Dist: pymupdf4llm>=0.0.17; extra == "documents"
 Provides-Extra: graph
@@ -42,11 +45,8 @@ Provides-Extra: inprocess
 Requires-Dist: torch; extra == "inprocess"
 Requires-Dist: transformers; extra == "inprocess"
 Provides-Extra: voice
-Requires-Dist: sounddevice>=0.4; extra == "voice"
-Requires-Dist: numpy>=1.24; extra == "voice"
-Requires-Dist: faster-whisper>=1.0; extra == "voice"
 Provides-Extra: full
-Requires-Dist: pal-code[documents,voice]; extra == "full"
+Requires-Dist: pal-code[documents]; extra == "full"
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
 Requires-Dist: ruff>=0.5; extra == "dev"

{pal_code-0.1.2 → pal_code-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pal-code"
-version = "0.1.2"
+version = "0.1.3"
 description = "Pal: build and plan with AI in your terminal (pal cli) or browser (pal web), on a layer that cuts tokens and latency."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -32,6 +32,9 @@ dependencies = [
   "pypdf>=4.0",             # PDF -> markdown
   "python-pptx>=0.6.23",    # PowerPoint -> markdown
   "openpyxl>=3.1",          # Excel -> markdown
+  "sounddevice>=0.4",       # the mic: recording (PortAudio comes with it on Windows and macOS)
+  "numpy>=1.24",
+  "faster-whisper>=1.0",    # speech to text on this computer (Whisper); nothing leaves the computer
 ]
 
 [project.optional-dependencies]
@@ -42,8 +45,8 @@ litellm = []                     # kept so older install lines still work: litel
 vector = ["chromadb"]
 embeddings = ["sentence-transformers"]
 inprocess = ["torch", "transformers"]
-voice = ["sounddevice>=0.4", "numpy>=1.24", "faster-whisper>=1.0"]   # talk instead of typing (Ctrl+Space); speech-to-text on this computer
-full = ["pal-code[documents,voice]"]
+voice = []                       # kept so older install lines still work: the mic is installed by default now
+full = ["pal-code[documents]"]
 dev = ["pytest>=8", "ruff>=0.5", "mypy>=1.10", "types-requests", "types-PyYAML"]
 
 [project.scripts]

{pal_code-0.1.2 → pal_code-0.1.3}/src/pal/__init__.py

@@ -13,7 +13,7 @@ def _version() -> str:
             return version(name)
         except PackageNotFoundError:
             continue
-    return "0.1.2"           # a source checkout that is not installed
+    return "0.1.3"           # a source checkout that is not installed
 
 
 __version__ = _version()

{pal_code-0.1.2 → pal_code-0.1.3}/src/pal/cli.py

@@ -212,7 +212,8 @@ def load_dotenv(path: str | os.PathLike | None = None, env=None) -> list[str]:
     return loaded
 
 
-def _serve(settings: Settings, open_browser: bool = False, page: str = "", graph=None, documents: list | None = None, project_dir=None) -> int:
+def _serve(settings: Settings, open_browser: bool = False, page: str = "", graph=None, documents: list | None = None, project_dir=None,
+           background=None) -> int:
     from pal.chat import ChatService
     from pal.web import create_app
 
@@ -222,6 +223,9 @@ def _serve(settings: Settings, open_browser: bool = False, page: str = "", graph
     if documents:
         service.preload_docs = list(documents)
     app = create_app(service, studio={"project_dir": project_dir}) if project_dir else create_app(service)
+    if background is not None:                                   # pal web: the folder's setup runs while the page is already usable
+        import threading as _bg
+        _bg.Thread(target=background, args=(service,), daemon=True, name="pal-web-setup").start()
     if s.host not in _LOOPBACK:
         print(f"WARNING: listening on {s.host}. Pal has no login: anyone who can reach this port can use "
               "your API keys' quota and read stored memory. Put it behind an authenticating reverse proxy.",
@@ -229,23 +233,21 @@ def _serve(settings: Settings, open_browser: bool = False, page: str = "", graph
     shown = "localhost" if s.host in ("0.0.0.0", "::") else s.host  # noqa: S104
     url = f"http://{shown}:{s.port}" + ("/" + page.strip("/") if page else "")
     print(f"Pal {__version__} on {url}  (Ctrl+C to stop)")
-    from pal.chat.providers import API_PROVIDERS
-    keys = [p for p, var in API_PROVIDERS.items() if os.environ.get(var)]
-    print("API key found for: " + ", ".join(keys) if keys else
-          "No API key in the environment: paste one in the page (API key menu), or set e.g. GEMINI_API_KEY.")
-    status = service.local_status()
-    if status["ok"] is False:
-        print(f"WARNING: local model: {status['detail']}. Input reduction and local answers are off until it runs; "
-              "the app still works and sends everything to the API model.", file=sys.stderr)
-    else:
-        print(f"Local model: {status['detail']}")
-    import threading as _t
-    from pal.context_window import context_window
-    _t.Thread(target=lambda: context_window("openai", "gpt-4o"), daemon=True).start()   # loads LiteLLM's model list now, not on the first page load
+    if background is None:                                       # pal serve: say what is set up; pal web says nothing more and starts at once
+        from pal.chat.providers import API_PROVIDERS
+        keys = [p for p, var in API_PROVIDERS.items() if os.environ.get(var)]
+        print("API key found for: " + ", ".join(keys) if keys else
+              "No API key in the environment: paste one in the page (API key menu), or set e.g. GEMINI_API_KEY.")
+        status = service.local_status()
+        if status["ok"] is False:
+            print(f"WARNING: local model: {status['detail']}. Input reduction and local answers are off until it runs; "
+                  "the app still works and sends everything to the API model.", file=sys.stderr)
+        else:
+            print(f"Local model: {status['detail']}")
     if open_browser:
         import threading
         import webbrowser
-        threading.Timer(1.2, lambda: webbrowser.open(url)).start()
+        threading.Timer(0.3, lambda: webbrowser.open(url)).start()
     try:
         try:
             from waitress import serve

pal_code-0.1.3/src/pal/llm_wrapper/__init__.py

@@ -0,0 +1,34 @@
+"""The model layer. Its names are loaded on first use (PEP 562), so importing a light submodule such as pal.llm_wrapper.modes (the provider
+names and key variables) does not load the whole model stack: pal cli draws its first screen before any of it is needed."""
+from importlib import import_module
+
+_WHERE = {
+    "LLMAdapter": "pal.llm_wrapper.adapter",
+    "LLMAdapterResponse": "pal.llm_wrapper.components.adapter_types",
+    "LLMAdapterSyscall": "pal.llm_wrapper.components.adapter_types",
+    "LLMConfig": "pal.llm_wrapper.components.adapter_types",
+    "RouterStrategy": "pal.llm_wrapper.components.adapter_types",
+    "DeploymentType": "pal.llm_wrapper.components.base",
+    "LLMResponse": "pal.llm_wrapper.components.base",
+    "LLMSyscall": "pal.llm_wrapper.components.base",
+    "LLMWrapper": "pal.llm_wrapper.components.base",
+    "WrapperCapabilities": "pal.llm_wrapper.components.base",
+    "WrapperConfig": "pal.llm_wrapper.components.base",
+    "LLMWrapperPipeline": "pal.llm_wrapper.pipeline",
+    "available_backends": "pal.llm_wrapper.utils.registry",
+    "build_wrapper": "pal.llm_wrapper.utils.registry",
+}
+
+__all__ = list(_WHERE)
+
+
+def __getattr__(name: str):
+    if name in _WHERE:
+        value = getattr(import_module(_WHERE[name]), name)
+        globals()[name] = value
+        return value
+    raise AttributeError(f"module 'pal.llm_wrapper' has no attribute {name!r}")
+
+
+def __dir__():
+    return sorted(set(globals()) | set(_WHERE))

{pal_code-0.1.2 → pal_code-0.1.3}/src/pal/terminal/cli.py

@@ -239,36 +239,43 @@ def prepare_folder(args, console, core_factory: Callable | None = None, choose:
 
 
 def web(args) -> int:
-    """Start the web interface on this computer and open it in the default browser. It listens on 127.0.0.1 only, unless the settings say otherwise.
-    The helper model chosen in setup does the web interface's small jobs too."""
+    """Start the web interface on this computer and open it in the default browser, at once. It listens on 127.0.0.1 only, unless the settings
+    say otherwise. The setup (Ollama, the helper, this folder's documents, map and graph) runs in the background; the chat gets the folder's
+    documents as soon as they are ready."""
     from pal.cli import _serve, load_dotenv
     from pal.config import load_settings
     from pal.errors import ConfigError
+    from pal.terminal.project import Project, ProjectGraph
     load_dotenv()
-    console = ui.make_console()
-    local, project = prepare_folder(args, console)
-    if local:
-        ui.say(console, Text(f"Local LLM: {local}", style=theme.MUTED))
-    if project is not None:
-        r = project.report
-        ui.say(console, Text(f"This folder: {r.code_files} files \u00B7 {len(r.converted)} documents as markdown \u00B7 code graph {r.graph}", style=theme.MUTED))
     overrides: dict = {"server": {"port": args.port}} if args.port else {}
     helper = backend.load_prefs().get("helper_model")
-    if api_only(backend.hardware()):
-        overrides["local_llm"] = {"enabled": False}            # no GPU: API models only, no local helper jobs
-    elif helper:
-        overrides["local_llm"] = {"backend": "ollama", "model": helper}
+    overrides["local_llm"] = {"backend": "ollama", "model": helper} if helper else {"enabled": False}    # no helper yet: API models only
     try:
         settings = load_settings(overrides=overrides or None)
     except ConfigError as e:
         print(f"config error: {e}", file=sys.stderr)
         return 2
-    graph = None
-    if project is not None:                        # the web chat gets the folder too: its graph, documents and map
-        from pal.terminal.project import ProjectGraph
-        graph = ProjectGraph(project.root / "graph", settings.knowledge_graph)
+    folder = Path(getattr(args, "dir", ".") or ".").resolve()
+    project = None if os.environ.get("PAL_SKIP_PROJECT") else Project(folder)
+    graph = ProjectGraph(project.root / "graph", settings.knowledge_graph) if project is not None else None
+
+    def in_background(service) -> None:
+        import io
+
+        from rich.console import Console
+        from pal.terminal.setup import ensure_local
+        try:
+            host = args.host or backend.DEFAULT_HOST
+            hw = backend.hardware()
+            ensure_local(Console(file=io.StringIO()), hw, host, interactive=False, choose=False)
+            background_helper(hw, backend.local_info(host))
+            if project is not None:
+                project.prepare()
+                service.preload_docs = list(project.documents())       # new chats get the folder's documents and map
+        except Exception:  # noqa: BLE001  (the web interface works without the folder's setup)
+            pass
     return _serve(settings, open_browser=not args.no_open, page="studio" if args.page == "studio" else "", graph=graph,
-                  documents=project.documents() if project is not None else None, project_dir=Path(getattr(args, "dir", ".") or ".").resolve())
+                  project_dir=folder, background=in_background)
 
 
 def _utf8() -> None:
@@ -284,7 +291,7 @@ NO_GPU = ("No GPU on this computer, so Pal uses an API model. Choose one with:\n
           "  browse models:  pal models --free")
 
 
-def start(args, core_factory: Callable | None = None, project=None) -> PalSession | None:
+def start(args, core_factory: Callable | None = None, project=None, prompt: bool = True) -> PalSession | None:
     """The session for these arguments, or None (after saying why) when there is no model to talk to.
     On a computer without a GPU there is no local model: the session uses an API model and Pal's local helper jobs are off."""
     console = ui.make_console()
@@ -292,9 +299,11 @@ def start(args, core_factory: Callable | None = None, project=None) -> PalSessio
     prefs = backend.load_prefs()
     no_gpu = core_factory is None and api_only(backend.hardware())
     if no_gpu:
-        return _start_api_only(args, prefs, console, project)
+        return _start_api_only(args, prefs, console, project, prompt)
     want = args.provider or prefs.get("provider", "")
     if want in backend.PROVIDER_KEYS and not os.environ.get(backend.PROVIDER_KEYS[want]) and core_factory is None and sys.stdin.isatty():
+        if not prompt:
+            return None                              # the key is asked for in the foreground
         ask_key(console, want)                        # the main model is an API model: its key (never saved) for this session
     info = backend.local_info(host)
     if args.provider and args.provider != backend.LOCAL:
@@ -338,7 +347,7 @@ def ask_key(console, provider: str) -> bool:
     return bool(key)
 
 
-def _start_api_only(args, prefs: dict, console, project=None) -> PalSession | None:
+def _start_api_only(args, prefs: dict, console, project=None, prompt: bool = True) -> PalSession | None:
     from pal.terminal.setup import ask_api
     keyed = lambda p: p in backend.OPEN_PROVIDERS or (p in backend.PROVIDER_KEYS and bool(os.environ.get(backend.PROVIDER_KEYS[p])))  # noqa: E731
     if args.provider == backend.LOCAL:
@@ -347,6 +356,8 @@ def _start_api_only(args, prefs: dict, console, project=None) -> PalSession | No
     if provider == backend.LOCAL:
         provider, model = "", ""
     if not (provider and model and keyed(provider)):
+        if not prompt:
+            return None
         if sys.stdin.isatty() and sys.stdout.isatty():
             console.print(Text("\n  No GPU on this computer, so Pal uses an API model.\n", style=f"bold {theme.RED_HI}"))
             chosen = ask_api(console, backend.hardware().system)
@@ -726,12 +737,12 @@ def voice_flow(console) -> str:
 
     from pal.terminal import voice
     if not voice.can_record():
-        ui.say(console, Text('Talking needs a microphone library: pip install "pal-code[voice]"   (Linux also: sudo apt install libportaudio2). '
-                             "Dictation apps such as Wispr Flow work without it: they type into the box.", style=theme.MUTED))
+        ui.say(console, Text("The mic is not available here: no microphone was found, or (on Linux) PortAudio is missing: sudo apt install libportaudio2. "
+                             "Windows voice typing (Win+H) and apps such as Wispr Flow type into the box too.", style=theme.MUTED))
         console.print()
         return ""
     if not voice.engines():
-        ui.say(console, Text('No speech-to-text yet: pip install "pal-code[voice]" (on this computer), or set OPENAI_API_KEY or GROQ_API_KEY.', style=theme.MUTED))
+        ui.say(console, Text("Speech to text is not available: reinstall Pal (pip install -U pal-code), or set OPENAI_API_KEY or GROQ_API_KEY.", style=theme.MUTED))
         console.print()
         return ""
     stop, out, err = threading.Event(), {}, {}
@@ -757,7 +768,9 @@ def voice_flow(console) -> str:
         ui.say(console, Text(err.get("e", "Nothing was recorded."), style=theme.RED_HI))
         return ""
     try:
-        with console.status(Text("Turning speech into text…", style=theme.MUTED), spinner="dots", spinner_style=theme.RED):
+        first_time = "local" in voice.engines() and not voice._LOCAL
+        label = "Turning speech into text (the first time, the speech model is downloaded once, about 150 MB)…" if first_time else "Turning speech into text…"
+        with console.status(Text(label, style=theme.MUTED), spinner="dots", spinner_style=theme.RED):
             heard = voice.transcribe(out["wav"])
     except voice.VoiceUnavailable as e:
         ui.say(console, Text(str(e), style=theme.RED_HI))
@@ -766,60 +779,186 @@ def voice_flow(console) -> str:
     return heard.text
 
 
-def choosing(args, core_factory: Callable | None = None) -> bool:
-    """pal cli asks for its models at every start (nothing preselected), unless they were given on the command line or this is not a terminal."""
-    return (core_factory is None and not args.provider and not args.model and sys.stdin.isatty() and sys.stdout.isatty()
-            and not os.environ.get("PAL_SKIP_SETUP") and not api_only(backend.hardware()))
+def automatic(args, core_factory: Callable | None = None) -> bool:
+    """A real terminal session on a computer with a GPU: Pal gets its helper ready by itself and asks nothing at start."""
+    return (core_factory is None and sys.stdin.isatty() and sys.stdout.isatty() and not os.environ.get("PAL_SKIP_SETUP")
+            and not api_only(backend.hardware()))
 
 
 def ensure_ready_line(args) -> str:
-    """The local-model line again, after the models were chosen (and maybe downloaded)."""
+    """The local-model line again, after a model was downloaded."""
     from pal.terminal.setup import ensure_local
     return ensure_local(ui.make_console(), backend.hardware(), args.host or backend.DEFAULT_HOST, interactive=False, choose=False).detail
 
 
-def interactive(args, core_factory: Callable | None = None) -> int:
-    console = ui.make_console()
-    ask = choosing(args, core_factory)
-    local, project = prepare_folder(args, console, core_factory, choose=not ask)
-    if ask:
-        from pal.terminal.setup import choose_models
-        console.print()
-        if not choose_models(console, backend.hardware(), args.host or backend.DEFAULT_HOST):
-            console.print(Text("\nNo model chosen. Run  pal cli  again to choose one.\n", style=theme.MUTED))
-            return 1
-        if not args.mode:
-            from pal.terminal.setup import choose_agent
-            args.mode = choose_agent(console) or None
-        local = ensure_ready_line(args)
-    session = start(args, core_factory, project)
+def has_main_model(args, host: str) -> bool:
+    """Is there a model to start with: one on the command line, or the last one used (local and installed, or an API model with its key)?"""
+    if args.provider or args.model:
+        return True
+    _, model = backend.pick_default(backend.local_info(host), backend.load_prefs())
+    return bool(model)
+
+
+class Boot:
+    """What the first screen needs before the real session exists: the agent and the model from the saved settings, nothing probed.
+    It lets pal cli draw its screen at once while the setup runs in the background."""
+
+    def __init__(self, args, prefs: dict):
+        self.mode = args.mode or prefs.get("mode", "build")
+        if self.mode not in MODES:
+            self.mode = "build"
+        self.provider = args.provider or prefs.get("provider", "") or backend.LOCAL
+        self.model = args.model or prefs.get("model", "") or "choose a model"
+        self.cwd = Path(getattr(args, "dir", ".") or ".").resolve()
+        self.brand = "bench" if getattr(args, "bench_screen", False) else "cli"
+        self.pending: list = []
+        self.role_models: dict = {}
+        self.turns, self.pal_tokens, self.saved, self.budget = 0, 0, 0, 0
+        self.notice, self.helper_model, self.local, self.project, self.local_status = "", "", True, None, ""
+
+    def model_for(self, mode: str | None = None) -> tuple[str, str]:
+        return self.provider, self.model
+
+    def toggle_mode(self) -> str:
+        self.mode = MODES[(MODES.index(self.mode) + 1) % len(MODES)]
+        return self.mode
+
+
+def quiet_pull(tag: str) -> bool:
+    """`ollama pull` with no output: for the helper, downloaded in the background."""
+    import shutil
+    import subprocess
+    exe = shutil.which("ollama")
+    if not exe:
+        return False
+    try:
+        return subprocess.call([exe, "pull", tag], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) == 0
+    except OSError:
+        return False
+
+
+def background_helper(hw, info: dict) -> None:
+    """Pal's helper: the best small model for this computer. Installed: used. Missing: downloaded in a background thread (used from the next
+    start), so nothing waits for it."""
+    import threading
+
+    from pal.terminal.local_models import pick_helper
+    if api_only(hw) or not info.get("ok"):
+        return
+    best = pick_helper(hw).tag
+    if best in backend.chat_models(info):
+        backend.save_prefs(helper_model=best)
+        return
+
+    def get() -> None:
+        if quiet_pull(best):
+            backend.save_prefs(helper_model=best)
+    threading.Thread(target=get, daemon=True, name="pal-helper-download").start()
+
+
+def prepare_quietly(args, core_factory: Callable | None, out: dict) -> None:
+    """Everything a session needs, without a word on the screen: the hardware, Ollama (started if needed), the folder (documents to markdown,
+    the map, the graph), the helper, and the session itself. What needs the person (a model to choose, a key) is left to the foreground."""
+    import io
+
+    from rich.console import Console
+    from pal.terminal.project import Project
+    from pal.terminal.setup import ensure_local
+    quiet = Console(file=io.StringIO())
+    try:
+        host = args.host or backend.DEFAULT_HOST
+        if core_factory is None:
+            hw = backend.hardware()
+            out["local"] = ensure_local(quiet, hw, host, interactive=False, choose=False).detail
+            info = backend.local_info(host)
+            if automatic(args, core_factory):
+                background_helper(hw, info)
+        project = None
+        if not os.environ.get("PAL_SKIP_PROJECT"):
+            try:
+                project = Project(Path(getattr(args, "dir", ".") or "."))
+                project.prepare()
+            except Exception:  # noqa: BLE001  (the session still starts without the folder's map, graph and documents)
+                project = None
+        out["project"] = project
+        out["need_model"] = automatic(args, core_factory) and not has_main_model(args, host)
+        if not out["need_model"]:
+            out["session"] = start(args, core_factory, project, prompt=False)
+    except Exception as e:  # noqa: BLE001  (the foreground tries again and shows what went wrong)
+        out["error"] = e
+
+
+def finish_session(args, core_factory: Callable | None, ready: dict, console, boot: Boot) -> PalSession | None:
+    """The real session, once the background setup is done. Asks the person only what it must (a first model, an API key)."""
+    session = ready.get("session")
     if session is None:
-        return 1
-    session.local_status = local
-    session.brand = "bench" if getattr(args, "bench_screen", False) else "cli"
-    if project is not None:
-        ui.show_project(console, session)
-        console.print()
-    box = {"wf": Workflow(session)}
-    _bind_status(box["wf"])
-    if box["wf"].notice:
-        ui.say(console, Text(box["wf"].notice, style=theme.RED_HI))
-        console.print()
-        session.notice = box["wf"].notice.split(",")[0] + ": started a new plan"
-    first, draft = True, ""
+        host = args.host or backend.DEFAULT_HOST
+        if ready.get("need_model"):
+            from pal.terminal.setup import choose_models
+            if not choose_models(console, backend.hardware(), host, helper=False):
+                console.print(Text("\nNo model chosen. Run  pal cli  again to choose one.\n", style=theme.MUTED))
+                return None
+        session = start(args, core_factory, ready.get("project"))
+        if session is None:
+            return None
+    session.mode = boot.mode
+    session.local_status = ready.get("local", "")
+    session.brand = boot.brand
+    return session
+
+
+def interactive(args, core_factory: Callable | None = None) -> int:
+    """pal cli: the screen is drawn at once; the setup (Ollama, the folder, the helper, the model) runs in the background while you type.
+    The model is changed by clicking it (or /model). Only when there is no model at all yet is the person asked for one."""
+    import threading
+
     from pal.terminal.history import History
-    history = History(session.cwd)
+    console = ui.make_console()
+    boot = Boot(args, backend.load_prefs())
+    ready: dict = {}
+    prep = threading.Thread(target=prepare_quietly, args=(args, core_factory, ready), daemon=True, name="pal-setup")
+    prep.start()
+    history = History(boot.cwd)
+    state: dict = {"session": None, "box": None}
+
+    def session_now() -> PalSession | None:
+        """The real session: waits for the background setup the first time (only if it has not finished yet)."""
+        if state["session"] is None:
+            if prep.is_alive():
+                with console.status(Text("Getting ready\u2026", style=theme.MUTED), spinner="dots", spinner_style=theme.RED):
+                    prep.join()
+            s = finish_session(args, core_factory, ready, console, boot)
+            if s is None:
+                return None
+            state["session"], state["box"] = s, {"wf": Workflow(s)}
+            _bind_status(state["box"]["wf"])
+        return state["session"]
+
+    first, draft, code = True, "", 0
     try:
         while True:
-            text = ui.read_input(session, console, backend.save_prefs, landing=first, version=__version__, history=history, initial=draft,
-                                 on_shift_tab=lambda: cycle_autonomy(box["wf"]))
-            first, session.notice, draft = False, "", ""
+            shown = state["session"] or boot
+            box = state["box"]
+            text = ui.read_input(shown, console, backend.save_prefs, landing=first, version=__version__, history=history, initial=draft,
+                                 on_shift_tab=(lambda: cycle_autonomy(state["box"]["wf"])) if box else None)
+            landing, first, shown.notice, draft = first, False, "", ""
             if text is None:
                 break
-            if text.startswith("\x00voice\x00"):           # Ctrl+Space: record, then back to the box with the words added
+            if text.startswith("\x00voice\x00"):           # the mic (click or Ctrl+Space): record, then back to the box with the words added
                 before = text[len("\x00voice\x00"):]
                 heard = voice_flow(console)
                 draft = (before + (" " if before and heard else "") + heard) if heard else before
+                first = landing
+                continue
+            session = session_now()
+            if session is None:
+                code = 1
+                break
+            box = state["box"]
+            if text.startswith("\x00model\x00"):           # the model was clicked on the first screen: choose one, then back to it
+                draft = text[len("\x00model\x00"):]
+                state["session"], _ = handle("/model", args, session, console, core_factory, box)
+                first = landing
                 continue
             history.add(text)
             text = text.strip()
@@ -833,7 +972,7 @@ def interactive(args, core_factory: Callable | None = None) -> int:
                 continue
             try:
                 if text.startswith("/"):
-                    session, go = handle(text, args, session, console, core_factory, box)
+                    state["session"], go = handle(text, args, session, console, core_factory, box)
                     if not go:
                         break
                 elif text and getattr(args, "bench_screen", False):     # pal bench: the task both ways, then the comparison
@@ -850,10 +989,12 @@ def interactive(args, core_factory: Callable | None = None) -> int:
                 ui.say(console, Text("Stopped.", style=theme.MUTED))
                 console.print()
     finally:
-        box["wf"].close()
-        session.close()
+        if state["box"] is not None:
+            state["box"]["wf"].close()
+        if state["session"] is not None:
+            state["session"].close()
     console.print(Text("Bye.", style=theme.MUTED))
-    return 0
+    return code
 
 
 def ask_once(args, core_factory: Callable | None = None) -> int:

{pal_code-0.1.2 → pal_code-0.1.3}/src/pal/terminal/setup.py

@@ -398,7 +398,7 @@ def _get(console: Console, tag: str, installed: list[str], confirm: Callable[[st
 
 def choose_models(console: Console, hw: Hardware, host: str = backend.DEFAULT_HOST, pick: Callable[..., str | None] | None = None,
                   puller: Callable[[str], bool] = pull, api_chooser: Callable | None = None, confirm: Callable[[str], bool] | None = None,
-                  info: dict | None = None) -> bool:
+                  info: dict | None = None, helper: bool = True) -> bool:
     """Ask which models to use for this session; nothing is chosen in advance. The main model is an external API model (any provider, the key
     is never saved) or a local model that suits this GPU (installed ones are marked; others are downloaded after asking). Then the helper: a small
     local model for Pal's own jobs, or none. The choice is saved. False when the person chose nothing."""
@@ -428,6 +428,9 @@ def choose_models(console: Console, hw: Hardware, host: str = backend.DEFAULT_HO
     if not ready:
         backend.save_prefs(helper_model="", setup_done="1")
         return True
+    if not helper:                                     # Pal chooses the helper itself (auto_helper)
+        backend.save_prefs(setup_done="1")
+        return True
     main = "" if answer == API_OPTION else answer
     helpers = helper_choices(hw, installed, exclude=main) + [(NO_HELPER, "the main model also does Pal's small jobs (uses more of its tokens)")]
     helper = pick("Which small local helper should do Pal's own jobs? (routing easy questions, trimming what you type)", helpers, None, True, "Helper")
@@ -453,3 +456,25 @@ def choose_agent(console: Console, pick: Callable[..., str | None] | None = None
     if mode:
         backend.save_prefs(mode=mode)
     return mode
+
+
+def auto_helper(console: Console, hw: Hardware, host: str = backend.DEFAULT_HOST, puller: Callable[[str], bool] = pull,
+                info: dict | None = None) -> str:
+    """Pal chooses its own helper: the best small model for this computer. Already installed: used as it is. Not installed: downloaded now
+    (Ollama shows its progress). Nothing is asked. Returns the helper's name, or '' when there is none (no GPU, Ollama not running, failed)."""
+    from pal.terminal.local_models import api_only, pick_helper
+    if api_only(hw):
+        return ""
+    info = info if info is not None else backend.local_info(host)
+    if not info.get("ok"):
+        return ""
+    best = pick_helper(hw)
+    if best.tag not in backend.chat_models(info):
+        _say(console, Text(f"Getting Pal's helper model ready: {best.tag} (about {best.size_gb:g} GB, once). It does Pal's small jobs, like trimming what you type.",
+                           style=theme.MUTED))
+        if not puller(best.tag):
+            _say(console, Text(f"The helper {best.tag} could not be downloaded: Pal works without it for now and tries again next time.", style=theme.MUTED))
+            backend.save_prefs(helper_model="")
+            return ""
+    backend.save_prefs(helper_model=best.tag)
+    return best.tag