sliceagent 0.1.5__tar.gz → 0.1.7__tar.gz

{sliceagent-0.1.5 → sliceagent-0.1.7}/CHANGELOG.md

@@ -5,6 +5,30 @@ this project aims for [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.1.7] — 2026-07-02
+
+### Fixed
+- `/model`: the current env-configured model row is now labeled `current (env)` instead of the
+  provider family name — it could masquerade as a configured provider (e.g. an env `gpt-5.5` on a
+  DeepSeek endpoint showed as "deepseek").
+
+## [0.1.6] — 2026-07-02
+
+The clear config journey: one wizard, two doors, an honest /model.
+
+### Added
+- **`/config`** — manage LLM providers *inside* sliceagent: the same wizard as first-run onboarding
+  (provider → model → key → live test), then the config hot-reloads and the new provider shows up
+  in `/model` immediately.
+- **`/model` switches providers for real** — the menu lists ONLY configured providers' models
+  (saved model + suggestions, labeled by provider), and picking one switches **model + endpoint +
+  key together** (the old menu changed the model string but never the endpoint). The last-picked
+  provider is remembered across sessions.
+
+### Changed
+- Typed `/model <name>` stays same-endpoint (documented as such); the mismatch warning now points
+  at `/config` + the `/model` menu instead of `config --use`.
+
 ## [0.1.5] — 2026-07-02
 
 ### Changed

{sliceagent-0.1.5 → sliceagent-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sliceagent
-Version: 0.1.5
+Version: 0.1.7
 Summary: A coding agent with a new context-engineering framework: bounded, deterministic, reconstructed context (slice architecture) — built for long-horizon work.
 Author: TT-Wang
 License-Expression: MIT

{sliceagent-0.1.5 → sliceagent-0.1.7}/src/sliceagent/__init__.py

@@ -1,3 +1,3 @@
 """sliceagent — a memory-native coding agent (deterministic, bounded, reconstructed context)."""
 
-__version__ = "0.1.5"
+__version__ = "0.1.7"

{sliceagent-0.1.5 → sliceagent-0.1.7}/src/sliceagent/cli.py

@@ -134,8 +134,8 @@ def _reasoning_note(llm) -> str:
         label = {"openai": "an OpenAI", "deepseek": "a DeepSeek",
                  "moonshot": "a Moonshot", "anthropic": "an Anthropic"}.get(home, f"a {home}")
         return (f"note: {llm.model} looks like {label} model, but you're connected to {base or '(default)'}"
-                f" — it will likely fail on your next message. Run `sliceagent init` to add {label} provider, "
-                f"then `config --use <id>` to switch (or `/model` with no args to see what's configured).")
+                f" — it will likely fail on your next message. Add {label} provider with /config, then pick "
+                f"its model from the /model menu (the menu switches the endpoint too; typed /model doesn't).")
     eff = (getattr(llm, "reasoning", "full") or "full").lower()
     if eff == "full":
         return ""
@@ -162,10 +162,14 @@ def main() -> None:
     _load_env()
     # config-persisted key/endpoint (written by `sliceagent init`) populate the env BEFORE the gate, so a
     # configured user never has to export anything; ENV still wins for one-off overrides.
-    from .config import load_config
-
-    def _env_from_config(c) -> None:
-        for _env, _val in (("LLM_API_KEY", c.api_key), ("LLM_BASE_URL", c.base_url)):
+    from .config import load_config, load_prefs
+    _boot_prefs = load_prefs()   # the last /model choice may pin a PROVIDER (endpoint+key), not just a model
+
+    def _env_from_config(c, pid: str | None = None) -> None:
+        tbl = (c.providers() or {}).get(pid) if pid else None
+        key = (tbl or {}).get("api_key") or c.api_key
+        base = ((tbl or {}).get("base_url") if tbl and tbl.get("api_key") else None) or c.base_url
+        for _env, _val in (("LLM_API_KEY", key), ("LLM_BASE_URL", base)):
             if not os.environ.get(_env) and _val:
                 os.environ[_env] = _val
 
@@ -185,7 +189,7 @@ def main() -> None:
         return run_init() == 0
 
     cfg = load_config()
-    _env_from_config(cfg)
+    _env_from_config(cfg, _boot_prefs.get("provider"))
     if not _key_present() and _first_run_setup("Welcome! No API key configured yet"):
         cfg = load_config()          # the wizard just wrote ~/.sliceagent/config.toml — pick it up
         _env_from_config(cfg)
@@ -465,12 +469,33 @@ def main() -> None:
         return {"y": "yes", "yes": "yes", "a": "always", "always": "always"}.get(ans, "no")
 
     def _handle_slash(line):  # TUI navigation palette — wired to existing session ops
+        nonlocal cfg          # /config hot-reloads the config after the in-session wizard
         parts = line.split(maxsplit=1)
         cmd, arg = parts[0], (parts[1].strip() if len(parts) > 1 else "")
         if cmd == "/help":
-            _console.print("commands: /model · /mode · /cwd · /learn · /plan · /cost · /threads · /plugins · /mcp · "
-                           "/help · /exit\n  (type / for the menu · /cwd <path> switches workspace · "
-                           "Esc = undo last turn · say \"review my changes\" for code_review · @path pins a file)")
+            _console.print("commands: /config · /model · /mode · /cwd · /learn · /plan · /cost · /threads · "
+                           "/plugins · /mcp · /help · /exit\n  (type / for the menu · /config adds LLM "
+                           "providers · /cwd <path> switches workspace · Esc = undo last turn · "
+                           "say \"review my changes\" for code_review · @path pins a file)")
+        elif cmd == "/config":
+            # THE clear user journey: providers are managed INSIDE sliceagent — same wizard as first-run
+            # onboarding (provider → model → key → live test), then the new provider shows up in /model.
+            if sys.stdin.isatty() and not use_live:
+                from .onboarding import run_init
+                try:
+                    rc = run_init()
+                except (EOFError, KeyboardInterrupt):
+                    rc = 1
+                if rc == 0:
+                    from .config import load_config as _reload
+                    cfg = _reload()                      # hot-reload: /model now sees the new provider
+                    provs = cfg.providers()
+                    _console.print("  providers configured: "
+                                   + (", ".join(f"[bold]{k}[/] ({v.get('model', '?')})"
+                                                for k, v in provs.items()) or "(none)"))
+                    _console.print("  switch with [bold]/model[/] — it lists your configured providers' models.")
+            else:
+                _console.print("  /config needs an interactive terminal — run `sliceagent init` instead.")
         elif cmd == "/plan":
             s = session.active() if session.active_id else None
             plan = getattr(s, "plan", None) if s else None
@@ -562,23 +587,31 @@ def main() -> None:
                 from .tui import select_model_reasoning
                 choice = select_model_reasoning(llm, cfg)
                 if choice:
-                    llm.switch(model=choice[0], reasoning=choice[1])
+                    _model, _reasoning, _pid = choice
+                    _kw = {}
+                    if _pid:                              # a CONFIGURED provider → switch endpoint+key too
+                        _tbl = (cfg.providers() or {}).get(_pid) or {}
+                        if _tbl.get("api_key"):
+                            _kw = {"base_url": _tbl.get("base_url") or "", "api_key": _tbl["api_key"]}
+                    llm.switch(model=_model, reasoning=_reasoning, **_kw)
                     _stats["model"] = llm.model
-                    save_prefs({"model": llm.model, "reasoning": llm.reasoning})
+                    save_prefs({"model": llm.model, "reasoning": llm.reasoning,
+                                **({"provider": _pid} if _pid else {})})
                     note = _reasoning_note(llm)
-                    _console.print(f"  ✓ model → [bold]{llm.model}[/] · reasoning [bold]{llm.reasoning}[/] (saved)"
+                    _console.print(f"  ✓ model → [bold]{llm.model}[/]"
+                                   + (f" @ [bold]{_pid}[/]" if _pid else "")
+                                   + f" · reasoning [bold]{llm.reasoning}[/] (saved)"
                                    + (f"\n  {note}" if note else ""))
             elif not arg:
                 _console.print(f"  model: [bold]{llm.model}[/]  ·  reasoning: [bold]{llm.reasoning}[/]"
                                f"  ·  net: {getattr(llm, 'proxy_used', 'direct')}")
-                known = ("gpt-5.5", "gpt-5", "gpt-5-mini", "o3", "deepseek-chat",
-                         "kimi-k2-0905-preview", "claude-sonnet-4-6")
-                _console.print("  switch:  /model <name> [fast|full|high|max]")
-                _console.print("  known:   " + ", ".join(known))
+                _console.print("  switch:  /model <name> [fast|full|high|max]  (same endpoint)")
                 provs = cfg.providers()
                 if provs:
-                    _console.print("  providers (use `config --use <id>` to change endpoint): "
+                    _console.print("  configured providers (pick via the /model menu to switch endpoint too): "
                                    + ", ".join(f"{k}={v.get('model', '?')}" for k, v in provs.items()))
+                else:
+                    _console.print("  no providers configured yet — add one with [bold]/config[/]")
             else:
                 name, *rest = arg.split()
                 eff = rest[0].lower() if rest else None

{sliceagent-0.1.5 → sliceagent-0.1.7}/src/sliceagent/llm.py

@@ -220,6 +220,7 @@ class OpenAILLM:
         # the SDK's own (cleaner) timeout fires first when it can, and SIGALRM only catches the stalls
         # the read-timeout misses (silent mid-response connections).
         self._hard_timeout = max(int(timeout) + 15, 30)
+        self._timeout = timeout                              # kept for live endpoint switches (switch())
         # No built-in default model — the user picks (parallels the CLI's model gate; a silent
         # fallback here would contradict it for library/embedding callers).
         self.model = model or os.environ.get("AGENT_MODEL") or ""
@@ -259,11 +260,32 @@ class OpenAILLM:
         # thereafter reasoning_effort is dropped when tools are present (graceful degrade, no re-400).
         self._drop_reasoning_effort = False
 
-    def switch(self, *, model: str | None = None, reasoning: str | None = None) -> None:
-        """Live-switch the model id and/or reasoning intent for SUBSEQUENT turns (mutates in place — the
-        loop passes this same llm object every turn, so the change applies from the next turn on). Resets
-        the reasoning_effort+tools degrade memory since a different model may support the pairing. Same
-        endpoint/client; switching to a DIFFERENT PROVIDER (base_url/key) is `sliceagent config --use`."""
+    def switch(self, *, model: str | None = None, reasoning: str | None = None,
+               base_url: str | None = None, api_key: str | None = None) -> None:
+        """Live-switch model / reasoning — and, when `base_url`/`api_key` are given, the PROVIDER too:
+        the client is rebuilt against the new endpoint (with the proxy re-chosen for it), so /model can
+        hop between configured providers in one action. Mutates in place — the loop passes this same llm
+        object every turn, so the change applies from the next turn on. base_url semantics: None = keep
+        the current endpoint; "" = the SDK's default endpoint (OpenAI). Resets the
+        reasoning_effort+tools degrade memory (a different model/provider may support the pairing)."""
+        if base_url is not None or api_key:
+            import httpx
+            from openai import OpenAI
+            new_base = self._base_url if base_url is None else base_url
+            new_key = api_key or getattr(self.client, "api_key", None)
+            proxy = _choose_proxy(new_base, os.environ.get("AGENT_PROXY")
+                                  or os.environ.get("HTTPS_PROXY") or os.environ.get("HTTP_PROXY"))
+            use_proxy = bool(proxy) and proxy != "none"
+            self.proxy_used = proxy if use_proxy else "direct"
+            timeout = getattr(self, "_timeout", 60.0)
+            http_client = (httpx.Client(proxy=proxy, timeout=timeout) if use_proxy
+                           else httpx.Client(timeout=timeout))
+            ckw: dict = {"api_key": new_key}
+            if new_base:
+                ckw["base_url"] = new_base
+            self.client = OpenAI(http_client=http_client, timeout=timeout, max_retries=2, **ckw)
+            self._base_url = new_base or ""
+            self._drop_reasoning_effort = False
         if model:
             self.model = model
             self._drop_reasoning_effort = False

{sliceagent-0.1.5 → sliceagent-0.1.7}/src/sliceagent/tui.py

@@ -824,25 +824,41 @@ def run_selector(title, rows, *, current=-1, hint="↑↓ move · Enter select
 
 
 def _model_candidates(llm, cfg):
-    """Models to offer in the /model menu: the current model + any configured providers' models + a known
-    set, deduped and grouped by inferred provider family. Returns [(model, family)] sorted by family."""
+    """Models to offer in the /model menu — CONFIGURED providers only (the user's clear-journey rule:
+    the switcher shows what you can actually use). Each configured provider (has an api_key)
+    contributes its saved model + its wizard suggestions, labeled with the provider id; picking one
+    lets the CLI switch model+endpoint+key together. Returns [(model, group_label, provider_id)].
+    provider_id None = the current env-configured model (no provider table to rebind to). Fallback
+    when NO providers are configured (pure env setup): current model + a small known set."""
     from .model_catalog import capability
-    known = ["gpt-5.5", "gpt-5", "gpt-5-mini", "o3", "deepseek-chat", "kimi-k2-0905-preview", "claude-sonnet-4-6"]
-    prov = []
     try:
-        for tbl in (cfg.providers() or {}).values():
-            m = tbl.get("model") if isinstance(tbl, dict) else None
-            if m:
-                prov.append(m)
+        provs = {pid: t for pid, t in (cfg.providers() or {}).items()
+                 if isinstance(t, dict) and t.get("api_key")}
     except Exception:  # noqa: BLE001 — a malformed providers table must not break the menu
-        pass
+        provs = {}
     out, seen = [], set()
-    for m in [llm.model] + prov + known:
-        if m and m not in seen:
-            seen.add(m)
-            base = getattr(llm, "_base_url", "") if m == llm.model else ""
-            out.append((m, capability(m, base).family))
-    out.sort(key=lambda mf: (mf[1], mf[0]))
+    if provs:
+        try:
+            from .onboarding import MODEL_SUGGESTIONS
+        except Exception:  # noqa: BLE001
+            MODEL_SUGGESTIONS = {}
+        for pid, tbl in provs.items():
+            for m in [tbl.get("model")] + list(MODEL_SUGGESTIONS.get(pid, [])):
+                if m and (pid, m) not in seen:
+                    seen.add((pid, m))
+                    out.append((m, pid, pid))
+        out.sort(key=lambda t: (t[1], t[0]))
+        if all(m != llm.model for m, _, _ in out):   # an env-overridden current model still shows first
+            out.insert(0, (llm.model, "current (env)", None))  # not a configured provider — label honestly
+    else:
+        known = ["gpt-5.5", "gpt-5", "gpt-5-mini", "o3", "deepseek-chat", "kimi-k2-0905-preview",
+                 "claude-sonnet-5"]
+        for m in [llm.model] + known:
+            if m and m not in seen:
+                seen.add(m)
+                base = getattr(llm, "_base_url", "") if m == llm.model else ""
+                out.append((m, capability(m, base).family, None))
+        out.sort(key=lambda t: (t[1], t[0]))
     return out
 
 
@@ -860,17 +876,18 @@ def _reasoning_levels(model, base_url):
 
 
 def select_model_reasoning(llm, cfg, *, pt_input=None, pt_output=None):
-    """Two-tier picker: choose a model (grouped by provider) then its reasoning level (only the levels that
-    model supports). Returns (model, reasoning) to apply, or None if the model step was cancelled."""
+    """Two-tier picker: choose a model (from CONFIGURED providers) then its reasoning level (only the
+    levels that model supports). Returns (model, reasoning, provider_id) — provider_id is the configured
+    provider to switch endpoint+key to (None = keep the current endpoint) — or None if cancelled."""
     cands = _model_candidates(llm, cfg)
-    rows = [(m, f"provider: {fam}") for m, fam in cands]
-    cur_idx = next((i for i, (m, _) in enumerate(cands) if m == llm.model), -1)
+    rows = [(m, f"provider: {grp}") for m, grp, _pid in cands]
+    cur_idx = next((i for i, (m, _, _) in enumerate(cands) if m == llm.model), -1)
     pick = run_selector("Select model", rows, current=cur_idx,
                         hint="↑↓ move · Enter choose model → reasoning · Esc cancel",
                         pt_input=pt_input, pt_output=pt_output)
     if pick is None:
         return None
-    model = cands[pick][0]
+    model, _grp, pid = cands[pick]
     base = getattr(llm, "_base_url", "") if model == llm.model else ""
     levels = _reasoning_levels(model, base)
     lvl_rows = [(name, desc) for name, desc in levels]
@@ -879,12 +896,13 @@ def select_model_reasoning(llm, cfg, *, pt_input=None, pt_output=None):
                          hint="↑↓ move · Enter select · Esc keep current",
                          pt_input=pt_input, pt_output=pt_output)
     reasoning = levels[lpick][0] if lpick is not None else llm.reasoning   # Esc on step 2 = keep current
-    return (model, reasoning)
+    return (model, reasoning, pid)
 
 
 # ── input layer (prompt_toolkit) ─────────────────────────────────────────────────────────────
 _SLASH = {
-    "/model":   "switch model + reasoning — opens a menu (or /model <name> [fast|full|high|max])",
+    "/config":  "add / update LLM providers (the setup wizard, in-session) — then /model to switch",
+    "/model":   "switch model + reasoning — menu lists YOUR configured providers (switches endpoint too)",
     "/mode":    "permission mode — opens a menu (baby-sitter · teenager · let-it-go)",
     "/cwd":     "switch workspace root (/cwd <path>) — re-roots repo map, file tools & commands",
     "/learn":   "turn what you just did into a reusable SKILL (/learn [name])",

{sliceagent-0.1.5 → sliceagent-0.1.7}/tests/test_bughunt_fixes.py

@@ -816,11 +816,11 @@ def model_menu_is_provider_aware():
         def providers(self):
             return {}
 
-    cands = t._model_candidates(_LLM(), _CFG())
-    models = [m for m, _ in cands]
+    cands = t._model_candidates(_LLM(), _CFG())   # 3-tuples since the configured-only journey
+    models = [m for m, _grp, _pid in cands]
     assert "deepseek-chat" in models and "gpt-5.5" in models      # current + known both present
     assert len(models) == len(set(models))                        # deduped
-    fams = [fam for _, fam in cands]
+    fams = [fam for _, fam, _pid in cands]
     assert fams == sorted(fams)                                   # grouped (sorted) by provider family
 
 
@@ -1337,7 +1337,7 @@ def model_switch_warns_when_the_endpoint_cant_serve_it():
             self.model, self._base_url, self.reasoning = model, base_url, reasoning
 
     note = _reasoning_note(LLM("gpt-5.5", "https://api.deepseek.com/v1", "full"))
-    assert "OpenAI" in note and "deepseek" in note.lower() and "init" in note, note
+    assert "OpenAI" in note and "deepseek" in note.lower() and "/config" in note, note
     # same provider, no mismatch → must stay silent (no false positive)
     assert _reasoning_note(LLM("deepseek-chat", "https://api.deepseek.com/v1", "full")) == ""
     # real OpenAI → completely unaffected

sliceagent-0.1.7/tests/test_config_journey.py

@@ -0,0 +1,119 @@
+"""The clear config journey (user-designed): /config manages providers in-session, and /model shows
+ONLY configured providers' models — picking one switches model + endpoint + key together.
+Offline: stub objects, no network, no pytest. Run: PYTHONPATH=src python tests/test_config_journey.py
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
+
+from sliceagent.config import Config                      # noqa: E402
+from sliceagent.llm import OpenAILLM                      # noqa: E402
+from sliceagent.tui import _SLASH, _model_candidates, select_model_reasoning  # noqa: E402
+
+CHECKS = []
+def check(fn):
+    CHECKS.append(fn)
+    return fn
+
+
+class _Llm:
+    model = "deepseek-chat"
+    _base_url = "https://api.deepseek.com/v1"
+    reasoning = "full"
+
+
+_CFG = Config({"providers": {
+    "deepseek": {"api_key": "k1", "base_url": "https://api.deepseek.com/v1", "model": "deepseek-chat"},
+    "openrouter": {"api_key": "k2", "base_url": "https://openrouter.ai/api/v1", "model": "openai/gpt-5.5"},
+    "keyless": {"model": "phantom-model"},               # no api_key → NOT usable → must not appear
+}})
+
+
+@check
+def model_menu_lists_only_configured_providers():
+    cands = _model_candidates(_Llm(), _CFG)
+    pids = {pid for _, _, pid in cands if pid}
+    models = [m for m, _, _ in cands]
+    assert pids == {"deepseek", "openrouter"}, f"only keyed providers may appear, got {pids}"
+    assert "phantom-model" not in models, "a provider without a key must not contribute models"
+    assert "deepseek-chat" in models and "openai/gpt-5.5" in models
+    assert "anthropic/claude-sonnet-5" in models, "configured providers contribute their suggestions too"
+
+
+@check
+def every_candidate_carries_its_provider_for_endpoint_switch():
+    for m, _grp, pid in _model_candidates(_Llm(), _CFG):
+        assert pid in ("deepseek", "openrouter"), f"{m} must map to a configured provider, got {pid!r}"
+
+
+@check
+def env_current_model_is_labeled_honestly_not_as_a_provider():
+    class _EnvLlm:                                    # env model NOT in any configured provider's list
+        model = "gpt-5.5"
+        _base_url = "https://api.deepseek.com/v1"     # deepseek endpoint must NOT make it say "deepseek"
+        reasoning = "full"
+    cands = _model_candidates(_EnvLlm(), _CFG)
+    m, grp, pid = cands[0]
+    assert m == "gpt-5.5" and pid is None
+    assert grp == "current (env)", f"env model must not masquerade as a configured provider, got {grp!r}"
+
+
+@check
+def no_providers_configured_falls_back_to_known_set():
+    cands = _model_candidates(_Llm(), Config({}))
+    assert cands, "env-only setups still need a menu"
+    assert all(pid is None for _, _, pid in cands), "fallback entries have no provider to rebind to"
+    assert any(m == "deepseek-chat" for m, _, _ in cands)
+
+
+@check
+def switch_rebinds_endpoint_and_key():
+    saved = {k: os.environ.pop(k, None) for k in ("AGENT_PROXY", "HTTPS_PROXY", "HTTP_PROXY")}
+    try:
+        llm = OpenAILLM(model="deepseek-chat", api_key="k1", base_url="https://api.deepseek.com/v1")
+        assert llm._base_url == "https://api.deepseek.com/v1"
+        llm.switch(model="openai/gpt-5.5", base_url="https://openrouter.ai/api/v1", api_key="k2")
+        assert llm.model == "openai/gpt-5.5"
+        assert llm._base_url == "https://openrouter.ai/api/v1"
+        assert str(llm.client.base_url).startswith("https://openrouter.ai/api/v1"), \
+            "the OpenAI client itself must be rebuilt against the new endpoint"
+        assert llm.client.api_key == "k2", "the key must follow the provider"
+        # base_url="" → SDK default endpoint (OpenAI)
+        llm.switch(model="gpt-5.5", base_url="", api_key="k3")
+        assert llm._base_url == "" and "openrouter" not in str(llm.client.base_url)
+        # model-only switch keeps the endpoint (the classic /model <name> path)
+        llm.switch(model="gpt-5")
+        assert llm.model == "gpt-5" and llm.client.api_key == "k3"
+    finally:
+        for k, v in saved.items():
+            if v is not None:
+                os.environ[k] = v
+
+
+@check
+def selector_returns_the_provider_triple():
+    from prompt_toolkit.input.defaults import create_pipe_input
+    from prompt_toolkit.output import DummyOutput
+    with create_pipe_input() as pinp:
+        pinp.send_text("\r\r")                     # Enter (model) + Enter (reasoning)
+        got = select_model_reasoning(_Llm(), _CFG, pt_input=pinp, pt_output=DummyOutput())
+    assert got is not None and len(got) == 3, f"expected (model, reasoning, pid), got {got!r}"
+    model, _reasoning, pid = got
+    assert pid in ("deepseek", "openrouter") and isinstance(model, str)
+
+
+@check
+def config_command_is_in_the_slash_palette():
+    assert "/config" in _SLASH, "/config must be discoverable in the palette"
+
+
+if __name__ == "__main__":
+    ok = 0
+    for fn in CHECKS:
+        try:
+            fn(); ok += 1; print(f"PASS {fn.__name__}")
+        except Exception as e:  # noqa: BLE001
+            print(f"FAIL {fn.__name__}: {type(e).__name__}: {e}")
+    print(f"\n{ok}/{len(CHECKS)} passed")
+    sys.exit(0 if ok == len(CHECKS) else 1)