ai-switch-cli 0.2.2__tar.gz → 0.3.2__tar.gz

{ai_switch_cli-0.2.2 → ai_switch_cli-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ai-switch-cli
-Version: 0.2.2
+Version: 0.3.2
 Summary: One-command provider and model switching for Claude Code and Codex, with session-history checks
 Author: ZidongS
 License: MIT
@@ -78,13 +78,26 @@ Select `glm` or `deepseek`, enter the API key, and activate the generated config
 ai-switch use glm
 ```
 
-`use` lists the models the profile offers and remembers your choice:
+`use` activates the profile and does **not** ask anything: the profile's whole model list is published, so you
+pick the model inside the agent with `/model` (Codex) or its Opus/Sonnet/Haiku categories (Claude Code). The
+default for new sessions is the one you last used, or the profile default. Add `--choose` if you want to be
+asked, or `-m/--model` to set the default directly.
 
 ```text
-This profile provides 2 models:
+Active profile: glm
+Default model: glm-5.3 (new sessions)
+Published models: 3 - switch any time with /model inside codex (Claude Code uses its
+Opus/Sonnet/Haiku mappings), or change the default with -m/--model.
+```
+
+With `--choose` you get the picker instead:
+
+```text
+This profile provides 3 models:
   1) glm-5.3         GLM-5.3 flagship (1M context)  [default]
-  2) glm-5.3-flash   GLM-5.3 flash (fast, 1M context)
-Select model [1-2, Enter=glm-5.3, q=cancel]:
+  2) glm-5.3-flash   GLM-5.3 Flash (fast, text+image, 1M context)
+  3) glm-5-turbo     GLM-5 Turbo (agent-optimized, 200K context)
+Select model [1-3, Enter=glm-5.3, q=cancel]:
 ```
 
 For scripts and servers, choose without prompting (name, unique prefix, or index):
@@ -93,8 +106,11 @@ For scripts and servers, choose without prompting (name, unique prefix, or index
 ai-switch use glm --model glm-5.3-flash
 ai-switch use glm -m 2 -y
 ai-switch use glm --dry-run          # show what would change
+ai-switch use glm -m glm-5.3 --pin   # publish only this model (see below)
 ```
 
+Selecting a model sets the **default for new sessions** in both agents, and the profile's other models stay in the catalogue so you can still switch inside the agent. That means an in-app `/model` choice is a per-session override — and Codex writes its own choice back to `~/.codex/config.toml` when it exits, so the two agents can drift apart without anything else noticing; `ai-switch doctor` reports exactly that. If you want an activation to be exclusive instead, add `--pin`: the published catalogue then holds only the selected model, so Codex's own picker has nothing else to switch to (the next `ai-switch use` without `--pin` restores the full menu).
+
 Edit `~/.codex/config.toml` and `~/.claude/settings.json` for another provider, then save that configuration as a second profile:
 
 ```bash
@@ -133,7 +149,7 @@ For every model a profile records the Codex catalogue entry and the Claude Code
 * Codex: the top-level `model` (and `model_reasoning_effort`), plus a `~/.codex/models.json` catalogue that lists **every** model of the profile, which is what makes Codex's own `/model` picker show them.
 * Claude Code: the default model in `settings.json` plus the Opus/Sonnet/Haiku mappings. The presets map the three categories to *different* provider models where they exist, and they never set `ANTHROPIC_MODEL`, because a pinned environment model overrides your selection and makes `/model` do nothing.
 
-The `glm` and `deepseek` presets ship multi-model lists. A custom (OpenAI-compatible) profile is open-ended: it does not publish a catalogue, and `ai-switch use NAME --model anything` accepts any model name the endpoint serves.
+The `glm` and `deepseek` presets ship multi-model lists. A custom (OpenAI-compatible) profile is open-ended as well: when you create it you can name **several models at once, separated by spaces or commas** (for example `DeepSeek-V4.1-Flash Kimi-K3 Qwen3.8-Max`), and those become the profile's catalogue — both agents can then pick them. Any other name the endpoint serves still works with `ai-switch use NAME --model <name>`, and it is added to the catalogue when you use it.
 
 ### When a provider adds or renames a model
 
@@ -180,7 +196,7 @@ ai-switch doctor --fix    # quarantine damaged Codex runtime databases
   export CODEX_SQLITE_HOME=/var/tmp/codex-sqlite-$USER   # a local, persistent directory
   ```
 
-  `ai-switch add` offers to write `sqlite_home` into the generated Codex configuration when it detects a network filesystem.
+  Codex only honours the **environment variable**: a `sqlite_home` key in `config.toml` is parsed but ignored (checked with `codex doctor`). `ai-switch add` asks for a local directory when it detects a network filesystem, creates it and prints the export line to put in your shell profile; `ai-switch doctor` reports the variable's status.
 * **A stale model catalogue.** A catalogue left behind by the previous provider hides the new provider's models from Codex and makes sessions that used them unresumable. ai-switch removes that leftover file (only if it wrote it itself, and it backs it up first), and `doctor` verifies the configured model exists in the catalogue.
 * **Disabled history persistence** (`[history] persistence = "none"`), a Claude Code model pinned by `ANTHROPIC_MODEL`, and `claude`/`codex` processes that are running while you switch and will rewrite their configuration on exit.
 

{ai_switch_cli-0.2.2 → ai_switch_cli-0.3.2}/README.md

@@ -64,13 +64,26 @@ Select `glm` or `deepseek`, enter the API key, and activate the generated config
 ai-switch use glm
 ```
 
-`use` lists the models the profile offers and remembers your choice:
+`use` activates the profile and does **not** ask anything: the profile's whole model list is published, so you
+pick the model inside the agent with `/model` (Codex) or its Opus/Sonnet/Haiku categories (Claude Code). The
+default for new sessions is the one you last used, or the profile default. Add `--choose` if you want to be
+asked, or `-m/--model` to set the default directly.
 
 ```text
-This profile provides 2 models:
+Active profile: glm
+Default model: glm-5.3 (new sessions)
+Published models: 3 - switch any time with /model inside codex (Claude Code uses its
+Opus/Sonnet/Haiku mappings), or change the default with -m/--model.
+```
+
+With `--choose` you get the picker instead:
+
+```text
+This profile provides 3 models:
   1) glm-5.3         GLM-5.3 flagship (1M context)  [default]
-  2) glm-5.3-flash   GLM-5.3 flash (fast, 1M context)
-Select model [1-2, Enter=glm-5.3, q=cancel]:
+  2) glm-5.3-flash   GLM-5.3 Flash (fast, text+image, 1M context)
+  3) glm-5-turbo     GLM-5 Turbo (agent-optimized, 200K context)
+Select model [1-3, Enter=glm-5.3, q=cancel]:
 ```
 
 For scripts and servers, choose without prompting (name, unique prefix, or index):
@@ -79,8 +92,11 @@ For scripts and servers, choose without prompting (name, unique prefix, or index
 ai-switch use glm --model glm-5.3-flash
 ai-switch use glm -m 2 -y
 ai-switch use glm --dry-run          # show what would change
+ai-switch use glm -m glm-5.3 --pin   # publish only this model (see below)
 ```
 
+Selecting a model sets the **default for new sessions** in both agents, and the profile's other models stay in the catalogue so you can still switch inside the agent. That means an in-app `/model` choice is a per-session override — and Codex writes its own choice back to `~/.codex/config.toml` when it exits, so the two agents can drift apart without anything else noticing; `ai-switch doctor` reports exactly that. If you want an activation to be exclusive instead, add `--pin`: the published catalogue then holds only the selected model, so Codex's own picker has nothing else to switch to (the next `ai-switch use` without `--pin` restores the full menu).
+
 Edit `~/.codex/config.toml` and `~/.claude/settings.json` for another provider, then save that configuration as a second profile:
 
 ```bash
@@ -119,7 +135,7 @@ For every model a profile records the Codex catalogue entry and the Claude Code
 * Codex: the top-level `model` (and `model_reasoning_effort`), plus a `~/.codex/models.json` catalogue that lists **every** model of the profile, which is what makes Codex's own `/model` picker show them.
 * Claude Code: the default model in `settings.json` plus the Opus/Sonnet/Haiku mappings. The presets map the three categories to *different* provider models where they exist, and they never set `ANTHROPIC_MODEL`, because a pinned environment model overrides your selection and makes `/model` do nothing.
 
-The `glm` and `deepseek` presets ship multi-model lists. A custom (OpenAI-compatible) profile is open-ended: it does not publish a catalogue, and `ai-switch use NAME --model anything` accepts any model name the endpoint serves.
+The `glm` and `deepseek` presets ship multi-model lists. A custom (OpenAI-compatible) profile is open-ended as well: when you create it you can name **several models at once, separated by spaces or commas** (for example `DeepSeek-V4.1-Flash Kimi-K3 Qwen3.8-Max`), and those become the profile's catalogue — both agents can then pick them. Any other name the endpoint serves still works with `ai-switch use NAME --model <name>`, and it is added to the catalogue when you use it.
 
 ### When a provider adds or renames a model
 
@@ -166,7 +182,7 @@ ai-switch doctor --fix    # quarantine damaged Codex runtime databases
   export CODEX_SQLITE_HOME=/var/tmp/codex-sqlite-$USER   # a local, persistent directory
   ```
 
-  `ai-switch add` offers to write `sqlite_home` into the generated Codex configuration when it detects a network filesystem.
+  Codex only honours the **environment variable**: a `sqlite_home` key in `config.toml` is parsed but ignored (checked with `codex doctor`). `ai-switch add` asks for a local directory when it detects a network filesystem, creates it and prints the export line to put in your shell profile; `ai-switch doctor` reports the variable's status.
 * **A stale model catalogue.** A catalogue left behind by the previous provider hides the new provider's models from Codex and makes sessions that used them unresumable. ai-switch removes that leftover file (only if it wrote it itself, and it backs it up first), and `doctor` verifies the configured model exists in the catalogue.
 * **Disabled history persistence** (`[history] persistence = "none"`), a Claude Code model pinned by `ANTHROPIC_MODEL`, and `claude`/`codex` processes that are running while you switch and will rewrite their configuration on exit.
 

{ai_switch_cli-0.2.2 → ai_switch_cli-0.3.2}/ai_switch.py

@@ -23,7 +23,7 @@ Conversation history is never part of a profile
 import argparse, hashlib, json, os, re, shutil, sqlite3, sys, tempfile, time
 from pathlib import Path
 
-VERSION = "0.2.2"
+VERSION = "0.3.2"
 
 
 def _env_path(name, default):
@@ -267,8 +267,9 @@ def build_claude_settings(live, profile_settings, entry):
     env = {k: v for k, v in live_env.items() if k not in CLAUDE_PROVIDER_ENV}
     env.update({k: v for k, v in prof_env.items() if k not in CLAUDE_MODEL_PINS})
     if entry:
-        env.update(entry.get("claude", {}).get("env") or {})
-        out["model"] = entry["claude"].get("model") or entry["slug"]
+        mapped = entry.get("claude") if isinstance(entry.get("claude"), dict) else {}
+        env.update(mapped.get("env") or {})
+        out["model"] = mapped.get("model") or entry["slug"]
     elif "model" in profile_settings:
         out["model"] = profile_settings["model"]
     out["env"] = env
@@ -322,6 +323,22 @@ def claude_mapping(model, opus=None, sonnet=None, haiku=None, subagent=None):
     return {"model": model, "env": env}
 
 
+def adhoc_model(slug, index=99):
+    """Model entry for an endpoint whose catalogue we do not know (custom provider).
+
+    Every Claude Code category points at the same model: a gateway usually serves
+    one namespace, so Claude's own alias names (``claude-sonnet-*``) would be
+    rejected by it.
+    """
+    return {"slug": slug, "label": "custom model", "reasoning": "",
+            "codex": codex_entry(slug, "custom model", ("text",), index, 1048576, "high"),
+            "claude": claude_mapping(slug, opus=slug, sonnet=slug, haiku=slug, subagent=slug)}
+
+
+def split_models(text):
+    return [part for part in re.split(r"[,\s]+", text or "") if part]
+
+
 GLM_MODELS = [
     # Model names are exactly what the ZAI endpoint accepts; the ``[1m]`` marker
     # some proxies use is rejected there (glm-5.3 is 1M context by default), so
@@ -459,7 +476,7 @@ def resolve_model(catalog, token):
     raise ValueError(f"unknown model '{token}'; this profile offers: {available}")
 
 
-def pick_model(catalog, requested, fallback, assume_yes=False):
+def pick_model(catalog, requested, fallback, assume_yes=False, force=False):
     """Choose the model to activate (no prompting when requested/non-interactive)."""
     if not catalog:
         return requested
@@ -469,7 +486,7 @@ def pick_model(catalog, requested, fallback, assume_yes=False):
         return resolve_model(catalog, requested)
     if fallback not in slugs:
         fallback = catalog["default"] if catalog["default"] in slugs else slugs[0]
-    if assume_yes or not sys.stdin.isatty() or len(entries) == 1:
+    if assume_yes or (not force and (not sys.stdin.isatty() or len(entries) == 1)):
         return fallback
     print(f"This profile provides {len(entries)} models:")
     for index, entry in enumerate(entries, 1):
@@ -500,16 +517,17 @@ def catalog_target(text, catalog_path):
     return catalog_path
 
 
-def build_codex_catalog(d, catalog):
+def build_codex_catalog(d, catalog, include_profile_entries=True):
     """Union of the profile's catalog file and every selectable model entry."""
     entries = {}
-    try:
-        raw = json.loads((d / "codex-models.json").read_text())
-        for entry in (raw.get("models") if isinstance(raw, dict) else raw) or []:
-            if isinstance(entry, dict) and entry.get("slug"):
-                entries[entry["slug"]] = entry
-    except (OSError, ValueError, AttributeError):
-        pass
+    if include_profile_entries:
+        try:
+            raw = json.loads((d / "codex-models.json").read_text())
+            for entry in (raw.get("models") if isinstance(raw, dict) else raw) or []:
+                if isinstance(entry, dict) and entry.get("slug"):
+                    entries[entry["slug"]] = entry
+        except (OSError, ValueError, AttributeError):
+            pass
     for entry in catalog["models"]:
         if isinstance(entry.get("codex"), dict):
             entries[entry["slug"]] = entry["codex"]
@@ -520,7 +538,7 @@ def build_codex_catalog(d, catalog):
     return {"models": ordered}
 
 
-def compute_changes(d, slug):
+def compute_changes(d, slug, pin=False):
     """Return {path: text-or-None}: None means "remove this stale file"."""
     changes, notes = {}, []
     catalog = load_catalog(d)
@@ -530,12 +548,23 @@ def compute_changes(d, slug):
 
     text = read_text(d / "codex-config.toml")
     codex_catalog = None
+    # A model that is used but not listed (open-ended custom endpoint, or a legacy
+    # profile without a model list) gets a generated entry so that both agents are
+    # pointed at the requested model instead of falling back to the snapshot.
+    if slug and entry is None:
+        entry = adhoc_model(slug)
+        if catalog and catalog.get("open_ended"):
+            catalog = dict(catalog, models=catalog["models"] + [entry])
     if text is not None:
-        # Open-ended providers (custom endpoints) are not pinned to a catalogue;
-        # everything else publishes every selectable model so the picker inside
-        # Codex lists them all.
-        if catalog and (not catalog.get("open_ended") or (d / "codex-models.json").exists()):
-            codex_catalog = build_codex_catalog(d, catalog)
+        # Every profile publishes its models, so the picker inside Codex lists
+        # them too.  --pin publishes only the activated one, which removes the
+        # other entries from Codex's own picker.
+        if catalog:
+            if pin and entry:
+                codex_catalog = build_codex_catalog(d, dict(catalog, models=[entry]),
+                                                    include_profile_entries=False)
+            else:
+                codex_catalog = build_codex_catalog(d, catalog)
         if codex_catalog is not None:
             catalog_path = catalog_target(text, CODEX_MODELS)
             changes[catalog_path] = json.dumps(codex_catalog, indent=2) + "\n"
@@ -657,9 +686,8 @@ def codex_health_warnings(check_codex=True):
             if status != "ok":
                 warnings.append(f"Codex runtime DB {db.name} is unusable ({detail}) - sessions may be missing "
                                 "from the resume picker; run 'ai-switch doctor --fix'")
-    running = running_agents()
-    if running:
-        warnings.append("running now: " + ", ".join(running) +
+    if running_agents():
+        warnings.append("running now: " + running_agents_summary() +
                         " - restart them after switching, a running agent rewrites its config on exit")
     return warnings
 
@@ -672,23 +700,34 @@ def cmd_use(args):
     if not any((d / profile_file).exists() for profile_file in PROFILE_FILES):
         raise ValueError(f"profile '{name}' has no Codex or Claude configuration to activate")
     catalog = load_catalog(d)
-    fallback = args.model or last_model(name) or (catalog or {}).get("default")
-    if catalog and args.model and catalog.get("open_ended"):
+    fallback = last_model(name) or (catalog or {}).get("default")
+    slug = args.model or fallback
+    if args.model and catalog and catalog.get("open_ended"):
         try:
             slug = resolve_model(catalog, args.model)
         except ValueError:
             slug = args.model
             print(f"Note: '{args.model}' is not in the profile's model list; using it as-is.", file=sys.stderr)
-    else:
-        slug = pick_model(catalog, args.model, fallback, assume_yes=args.yes)
+    elif args.model and catalog:
+        slug = resolve_model(catalog, args.model)
+    elif catalog and args.choose:
+        # Picking a model here only sets the default for new sessions; every model
+        # of the profile is published, so it can also be changed inside the agent.
+        slug = pick_model(catalog, None, fallback, force=True)
     if slug and catalog is None:
         print(f"Note: profile '{name}' has no model list, using '{slug}' as-is.", file=sys.stderr)
-    changes, notes = compute_changes(d, slug)
+    changes, notes = compute_changes(d, slug, pin=args.pin)
     for note in notes:
         print(f"Note: {note}", file=sys.stderr)
     backup = apply_changes(changes, name, slug, dry_run=args.dry_run)
     if not args.dry_run:
-        print(f"Active profile: {name}" + (f"\nActive model: {slug}" if slug else ""))
+        print(f"Active profile: {name}" + (f"\nDefault model: {slug} (new sessions)" if slug else ""))
+        if args.pin and slug:
+            print(f"Pinned: only '{slug}' is published, so Codex cannot switch to another model.")
+        elif catalog:
+            print(f"Published models: {len(catalog['models'])} - switch any time with /model inside "
+                  "codex (Claude Code uses its Opus/Sonnet/Haiku mappings), or change the default "
+                  "with -m/--model.")
         print(f"Backup: {backup}" if backup else "Backup: nothing to back up (no files existed yet)")
         print("Restart claude/codex so they reload their configuration.")
         if not args.no_check:
@@ -912,15 +951,17 @@ def cmd_add(_):
     if preset:
         chosen = preset["models"]
         print(f"{provider} preset offers: " + ", ".join(m["slug"] for m in chosen))
-        wanted = _ask("Models to include (comma separated, Enter=all)", "all")
+        wanted = _ask("Models to include (space or comma separated, Enter=all)", "all")
         if wanted.lower() not in ("all", ""):
-            names = [part.strip() for part in wanted.split(",") if part.strip()]
+            names = split_models(wanted)
             by_slug = {m["slug"]: m for m in chosen}
             chosen = []
             for token in names:
-                slug = [s for s in by_slug if s.lower().startswith(token.lower())]
+                exact = [s for s in by_slug if s.lower() == token.lower()]
+                slug = exact or [s for s in by_slug if s.lower().startswith(token.lower())]
                 if len(slug) != 1:
-                    raise ValueError(f"unknown model '{token}'")
+                    raise ValueError(f"unknown or ambiguous model '{token}'"
+                                     f" (choose one of: {', '.join(by_slug)})")
                 chosen.append(by_slug[slug[0]])
         default = _ask("Default model", chosen[0]["slug"])
         default = resolve_model({"models": chosen}, default)
@@ -931,13 +972,21 @@ def cmd_add(_):
         if not endpoint:
             raise ValueError("an endpoint URL is required")
         claude_endpoint = endpoint[:-3].rstrip("/") if endpoint.endswith("/v1") else endpoint.rstrip("/")
-        slug = _ask("Model name")
-        if not slug:
-            raise ValueError("a model name is required")
-        chosen = [{"slug": slug, "label": "custom model", "reasoning": "",
-                   "codex": codex_entry(slug, "custom model", ("text",), 0, 1048576, "high"),
-                   "claude": claude_mapping(slug)}]
-        default, common_env = slug, {}
+        names = split_models(_ask("Model name(s) (space or comma separated, e.g. 'Big-Model Small-Model')"))
+        if not names:
+            raise ValueError("at least one model name is required")
+        chosen = []
+        for index, name in enumerate(names):
+            model = adhoc_model(name, index)
+            if len(names) > 1:
+                model["label"] = f"custom model (use --model {name})"
+            chosen.append(model)
+        default = chosen[0]["slug"]
+        if len(chosen) > 1:
+            print("This endpoint is open ended: any name works with "
+                  f"'ai-switch use <profile> --model <name>', and the ones listed above appear in the picker.")
+            default = resolve_model({"models": chosen}, _ask("Default model", chosen[0]["slug"]))
+        common_env = {}
     name = _ask("Profile name")
     if not name:
         raise ValueError("a profile name is required")
@@ -950,7 +999,7 @@ def cmd_add(_):
         suggested = f"/var/tmp/codex-sqlite-{os.environ.get('USER', 'user')}"
         print(f"\n{CODEX_DIR} is on a network filesystem ({fstype_for(CODEX_DIR)}); SQLite runtime databases "
               "can be corrupted there, which makes sessions disappear.")
-        sqlite_home = _ask("Local directory for Codex runtime databases (Enter=leave default)", suggested)
+        sqlite_home = _ask("Local directory for Codex runtime databases (Enter=skip)", suggested)
     d = profile(name)
     blank_profile_dir(d)
     catalog = {"version": 2, "provider": provider, "default": default, "models": chosen,
@@ -965,17 +1014,15 @@ def cmd_add(_):
                     .replace("@CATALOG@", display_path(catalog_path))
                     .replace("@ENDPOINT@", preset["endpoint"]).replace("@KEY@", key))
         else:
-            # A custom endpoint usually serves models we cannot know about, so no
-            # catalogue is written: Codex keeps listing the models the endpoint has.
+            # A gateway often serves dozens of models; the catalogue holds the ones
+            # you named, and ``use --model <other>`` extends it on demand.
             base = (f'model = "{default}"\nmodel_provider = "custom"\npreferred_auth_method = "apikey"\n'
-                    f'forced_login_method = "api"\n\n[model_providers.custom]\nname = "custom"\n'
+                    f'forced_login_method = "api"\nmodel_catalog_json = "{display_path(CODEX_MODELS)}"\n\n'
+                    f'[model_providers.custom]\nname = "custom"\n'
                     f'base_url = "{endpoint}"\nwire_api = "responses"\n'
                     f'requires_openai_auth = true\nexperimental_bearer_token = "{key}"\n')
-        if sqlite_home:
-            base += f'\n# Keeps Codex runtime SQLite databases off the network filesystem.\nsqlite_home = "{display_path(expand(sqlite_home))}"\n'
         write_atomic(d / "codex-config.toml", base)
-        if preset:
-            write_atomic(d / "codex-models.json", json.dumps(build_codex_catalog(d, catalog), indent=2) + "\n")
+        write_atomic(d / "codex-models.json", json.dumps(build_codex_catalog(d, catalog), indent=2) + "\n")
         write_atomic(d / "codex-auth.json", json.dumps({"OPENAI_API_KEY": key}, indent=2) + "\n")
     if clients in ("both", "claude"):
         env = {"ANTHROPIC_BASE_URL": claude_endpoint, "ANTHROPIC_AUTH_TOKEN": key}
@@ -986,6 +1033,16 @@ def cmd_add(_):
                                                  "provider": provider, "default_model": default}, indent=2) + "\n")
     print(f"\nCreated profile: {name}")
     print(f"Activate it with: ai-switch use {name}   (choose between {len(chosen)} model(s))")
+    if sqlite_home:
+        # Codex reads this from the environment only: a `sqlite_home` key in
+        # config.toml is accepted but ignored (verified with `codex doctor`).
+        target = expand(sqlite_home)
+        try:
+            target.mkdir(parents=True, exist_ok=True)
+        except OSError:
+            pass
+        print(f"\nKeep Codex's runtime databases off {fstype_for(CODEX_DIR)} by exporting this before "
+              f"starting codex (add it to ~/.bashrc):\n    export CODEX_SQLITE_HOME={sqlite_home}")
     return 0
 
 
@@ -1099,21 +1156,47 @@ def running_agents():
     return names
 
 
+def running_agents_summary(limit=4):
+    """A short, readable list (this file server runs dozens of agents)."""
+    running = running_agents()
+    if len(running) <= limit:
+        return ", ".join(running)
+    return ", ".join(running[:limit]) + f" and {len(running) - limit} more"
+
+
 def check_report():
     checks = []
 
     def add(status, title, detail, hint=""):
         checks.append({"status": status, "title": title, "detail": detail, "hint": hint})
 
+    sqlite_home = os.environ.get("CODEX_SQLITE_HOME", "")
+    sqlite_home_fs = fstype_for(expand(sqlite_home)) if sqlite_home else ""
     for label, path in (("CODEX_HOME", CODEX_DIR), ("Claude config", CLAUDE_DIR), ("ai-switch home", ROOT)):
         fs_type = fstype_for(path) or "unknown"
         if fs_type in NETWORK_FS:
-            add("warn", f"{label} is on {fs_type}", f"{path} ({fs_type})",
-                "SQLite databases (Codex runtime state, goals, memories, logs) can be corrupted on network "
-                "filesystems, which makes sessions disappear. Point CODEX_SQLITE_HOME at a local disk, e.g. "
-                f"export CODEX_SQLITE_HOME=/var/tmp/codex-sqlite-$USER")
+            moved = path == CODEX_DIR and sqlite_home and sqlite_home_fs not in NETWORK_FS
+            detail = f"{path} ({fs_type})"
+            if path == CODEX_DIR and sqlite_home:
+                detail += f", runtime databases in {sqlite_home} ({sqlite_home_fs or 'unknown'})"
+            if moved:
+                add("warn", f"{label} is on {fs_type}, runtime databases are not", detail,
+                    "Codex keeps state/log/goal databases in CODEX_SQLITE_HOME now; only history.jsonl and "
+                    "the rollout files stay on the network share.")
+            else:
+                hint = ("SQLite databases (Codex runtime state, goals, memories, logs) can be corrupted on network "
+                        "filesystems, which makes sessions disappear. Codex only honours the environment variable "
+                        "(a sqlite_home config key is ignored):\n"
+                        "        export CODEX_SQLITE_HOME=/var/tmp/codex-sqlite-$USER")
+                add("warn", f"{label} is on {fs_type}", detail, hint if path == CODEX_DIR else "")
         else:
             add("ok", f"{label} filesystem", f"{path} ({fs_type})")
+    if sqlite_home:
+        if sqlite_home_fs in NETWORK_FS:
+            add("warn", "CODEX_SQLITE_HOME is also on a network filesystem", f"{sqlite_home} ({sqlite_home_fs})",
+                "Pick a directory on a local disk, otherwise the runtime databases keep getting corrupted.")
+        else:
+            add("ok", "CODEX_SQLITE_HOME", f"{sqlite_home} ({sqlite_home_fs or 'unknown'})")
 
     text = read_text(CODEX) or ""
     persisted = section_value(text, "history", "persistence")
@@ -1132,9 +1215,19 @@ def check_report():
         add("fail", "Codex model catalogue is missing", f"{catalog_path} does not exist",
             "Re-run 'ai-switch use <profile>' to rewrite it.")
     elif slugs and model and model not in slugs:
-        add("fail", "Codex model catalogue does not contain the configured model",
-            f"model = {model}, catalogue has {', '.join(str(s) for s in slugs)}",
-            "Codex refuses to resume sessions whose model is unknown. Re-run 'ai-switch use <profile>'.")
+        open_ended = False
+        try:
+            open_ended = bool(json.loads((PROFILES / active_profile() / "models.json").read_text()).get("open_ended"))
+        except (OSError, ValueError):
+            pass
+        detail = f"model = {model}, catalogue has {', '.join(str(s) for s in slugs)}"
+        if open_ended:
+            add("warn", "Codex model catalogue does not list the configured model", detail,
+                "The active profile describes an open-ended endpoint, so any model name is allowed; "
+                "'ai-switch use NAME -m MODEL' adds it to the catalogue.")
+        else:
+            add("fail", "Codex model catalogue does not contain the configured model", detail,
+                "Codex refuses to resume sessions whose model is unknown. Re-run 'ai-switch use <profile>'.")
     elif slugs:
         add("ok", "Codex model catalogue", f"{len(slugs)} model(s): {', '.join(str(s) for s in slugs)}")
     else:
@@ -1197,15 +1290,30 @@ def check_report():
         f"{len(transcripts)} transcript(s) under {display_path(projects)}")
 
     state = load_state()
-    add("ok", "Active profile", f"{active_profile() or '(none)'}"
-        + (f", model {state.get('models', {}).get(active_profile())}" if isinstance(state.get("models"), dict)
-           and state.get("models", {}).get(active_profile()) else ""))
+    active = active_profile()
+    recorded = (state.get("models") or {}).get(active) if isinstance(state.get("models"), dict) else None
+    add("ok", "Active profile", f"{active or '(none)'}" + (f", model {recorded}" if recorded else ""))
+    if recorded:
+        # A running agent rewrites its own config on exit, so the live files can
+        # silently diverge from what 'ai-switch use' activated.
+        if model and model != recorded:
+            add("warn", "Codex is not using the model ai-switch activated",
+                f"config.toml has model = {model}, ai-switch activated {recorded}",
+                "A running codex session rewrites config.toml when it exits, so a /model choice made "
+                f"inside codex wins. Close codex and re-run 'ai-switch use {active} -m {recorded}', or use "
+                "--pin so the in-app picker cannot switch away.")
+        claude_model = str(settings.get("model") or "")
+        stem = lambda text: re.split(r"[\[/]", text)[0]
+        if claude_model and stem(claude_model) != stem(str(recorded)):
+            add("warn", "Claude Code is not using the model ai-switch activated",
+                f"settings.json has model = {claude_model}, ai-switch activated {recorded}",
+                f"Re-run 'ai-switch use {active} -m {recorded}' to bring both agents back in sync.")
     profiles = [p.name for p in sorted(PROFILES.iterdir()) if p.is_dir()] if PROFILES.exists() else []
     add("ok" if profiles else "note", "Profiles", ", ".join(profiles) or "none yet")
 
     running = running_agents()
     if running:
-        add("warn", "Agents are running", ", ".join(running),
+        add("warn", "Agents are running", running_agents_summary() + f" ({len(running)} process(es))",
             "A running agent rewrites its configuration on exit and may overwrite the switch; restart it after switching.")
     else:
         add("ok", "No agent processes running", "config.toml / settings.json are not being rewritten")
@@ -1289,8 +1397,12 @@ files inside a profile are switched. Restart claude/codex after switching."""
 
     p = sub.add_parser("use", help="activate a profile (optionally choosing a model)")
     p.add_argument("name")
-    p.add_argument("-m", "--model", help="model to activate (name, unique prefix, or 1-based index)")
-    p.add_argument("-y", "--yes", action="store_true", help="never prompt; use the default model")
+    p.add_argument("-m", "--model", help="set the default model for new sessions (name, unique prefix, or index)")
+    p.add_argument("--choose", action="store_true",
+                   help="ask which model the new sessions should start with (the others stay selectable in /model)")
+    p.add_argument("--pin", action="store_true",
+                   help="publish only this model, so Codex's own picker cannot switch to another one")
+    p.add_argument("-y", "--yes", action="store_true", help="accepted for compatibility; use never prompts by default")
     p.add_argument("-n", "--dry-run", action="store_true", help="show what would change")
     p.add_argument("--no-check", action="store_true", help="skip the session-history health check")
     p.set_defaults(fn=cmd_use)

{ai_switch_cli-0.2.2 → ai_switch_cli-0.3.2}/ai_switch_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ai-switch-cli
-Version: 0.2.2
+Version: 0.3.2
 Summary: One-command provider and model switching for Claude Code and Codex, with session-history checks
 Author: ZidongS
 License: MIT
@@ -78,13 +78,26 @@ Select `glm` or `deepseek`, enter the API key, and activate the generated config
 ai-switch use glm
 ```
 
-`use` lists the models the profile offers and remembers your choice:
+`use` activates the profile and does **not** ask anything: the profile's whole model list is published, so you
+pick the model inside the agent with `/model` (Codex) or its Opus/Sonnet/Haiku categories (Claude Code). The
+default for new sessions is the one you last used, or the profile default. Add `--choose` if you want to be
+asked, or `-m/--model` to set the default directly.
 
 ```text
-This profile provides 2 models:
+Active profile: glm
+Default model: glm-5.3 (new sessions)
+Published models: 3 - switch any time with /model inside codex (Claude Code uses its
+Opus/Sonnet/Haiku mappings), or change the default with -m/--model.
+```
+
+With `--choose` you get the picker instead:
+
+```text
+This profile provides 3 models:
   1) glm-5.3         GLM-5.3 flagship (1M context)  [default]
-  2) glm-5.3-flash   GLM-5.3 flash (fast, 1M context)
-Select model [1-2, Enter=glm-5.3, q=cancel]:
+  2) glm-5.3-flash   GLM-5.3 Flash (fast, text+image, 1M context)
+  3) glm-5-turbo     GLM-5 Turbo (agent-optimized, 200K context)
+Select model [1-3, Enter=glm-5.3, q=cancel]:
 ```
 
 For scripts and servers, choose without prompting (name, unique prefix, or index):
@@ -93,8 +106,11 @@ For scripts and servers, choose without prompting (name, unique prefix, or index
 ai-switch use glm --model glm-5.3-flash
 ai-switch use glm -m 2 -y
 ai-switch use glm --dry-run          # show what would change
+ai-switch use glm -m glm-5.3 --pin   # publish only this model (see below)
 ```
 
+Selecting a model sets the **default for new sessions** in both agents, and the profile's other models stay in the catalogue so you can still switch inside the agent. That means an in-app `/model` choice is a per-session override — and Codex writes its own choice back to `~/.codex/config.toml` when it exits, so the two agents can drift apart without anything else noticing; `ai-switch doctor` reports exactly that. If you want an activation to be exclusive instead, add `--pin`: the published catalogue then holds only the selected model, so Codex's own picker has nothing else to switch to (the next `ai-switch use` without `--pin` restores the full menu).
+
 Edit `~/.codex/config.toml` and `~/.claude/settings.json` for another provider, then save that configuration as a second profile:
 
 ```bash
@@ -133,7 +149,7 @@ For every model a profile records the Codex catalogue entry and the Claude Code
 * Codex: the top-level `model` (and `model_reasoning_effort`), plus a `~/.codex/models.json` catalogue that lists **every** model of the profile, which is what makes Codex's own `/model` picker show them.
 * Claude Code: the default model in `settings.json` plus the Opus/Sonnet/Haiku mappings. The presets map the three categories to *different* provider models where they exist, and they never set `ANTHROPIC_MODEL`, because a pinned environment model overrides your selection and makes `/model` do nothing.
 
-The `glm` and `deepseek` presets ship multi-model lists. A custom (OpenAI-compatible) profile is open-ended: it does not publish a catalogue, and `ai-switch use NAME --model anything` accepts any model name the endpoint serves.
+The `glm` and `deepseek` presets ship multi-model lists. A custom (OpenAI-compatible) profile is open-ended as well: when you create it you can name **several models at once, separated by spaces or commas** (for example `DeepSeek-V4.1-Flash Kimi-K3 Qwen3.8-Max`), and those become the profile's catalogue — both agents can then pick them. Any other name the endpoint serves still works with `ai-switch use NAME --model <name>`, and it is added to the catalogue when you use it.
 
 ### When a provider adds or renames a model
 
@@ -180,7 +196,7 @@ ai-switch doctor --fix    # quarantine damaged Codex runtime databases
   export CODEX_SQLITE_HOME=/var/tmp/codex-sqlite-$USER   # a local, persistent directory
   ```
 
-  `ai-switch add` offers to write `sqlite_home` into the generated Codex configuration when it detects a network filesystem.
+  Codex only honours the **environment variable**: a `sqlite_home` key in `config.toml` is parsed but ignored (checked with `codex doctor`). `ai-switch add` asks for a local directory when it detects a network filesystem, creates it and prints the export line to put in your shell profile; `ai-switch doctor` reports the variable's status.
 * **A stale model catalogue.** A catalogue left behind by the previous provider hides the new provider's models from Codex and makes sessions that used them unresumable. ai-switch removes that leftover file (only if it wrote it itself, and it backs it up first), and `doctor` verifies the configured model exists in the catalogue.
 * **Disabled history persistence** (`[history] persistence = "none"`), a Claude Code model pinned by `ANTHROPIC_MODEL`, and `claude`/`codex` processes that are running while you switch and will rewrite their configuration on exit.
 

{ai_switch_cli-0.2.2 → ai_switch_cli-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ai-switch-cli"
-version = "0.2.2"
+version = "0.3.2"
 description = "One-command provider and model switching for Claude Code and Codex, with session-history checks"
 readme = "README.md"
 requires-python = ">=3.9"