diff --git a/README.md b/README.md index defd865..393c6fa 100644 --- a/README.md +++ b/README.md @@ -127,13 +127,15 @@ used" — so `claude-mode openrouter` always means `default`. ## Presets shipped +One per mode, so `claude-mode ` is never ambiguous and there is no +menu to read before the thing you asked for happens. Build more with +`preset new` whenever one stops being enough. + | preset | provider | opus | sonnet | haiku | fable | |---|---|---|---|---|---| -| `default` | openrouter | `deepseek/deepseek-v4-flash-0731` | `qwen/qwen3.7-flash` | `openrouter/free` | `z-ai/glm-5.3` | -| `cheap` | openrouter | `deepseek/deepseek-v4-pro` | `deepseek/deepseek-v4-flash-0731` | `qwen/qwen3.7-flash` | `openai/gpt-5.6-luna-pro` | +| `default` | openrouter | `z-ai/glm-5.3-flash` | `deepseek/deepseek-v4-flash-0731` | `openrouter/free` | `z-ai/glm-5.3` | | `zai` | zai | `glm-5.3` | `glm-5.3` | `glm-4.7` | `glm-5.3` | -| `lmstudio` | lmstudio | `kwaipilot_kat-coder-v2.5-dev` (all tiers) | | | | -| `lmstudio-qwen` | lmstudio | `qwen3.6-35b-a3b-uncensored-heretic-native-mtp-preserved` (all tiers) | | | | +| `lmstudio` | lmstudio | whatever setup finds on your server (all tiers) | | | | Presets are plain JSON in `~/.claude-mode/presets/`. A preset declares its `provider`; `claude-mode lmstudio default` is rejected rather than silently @@ -164,8 +166,8 @@ CLAUDE_CODE_AUTO_COMPACT_WINDOW = | preset | contextTokens | |---|---| -| `default`, `cheap`, `zai` | 1,000,000 | -| `lmstudio`, `lmstudio-qwen` | 262,144 | +| `default`, `zai` | 1,000,000 | +| `lmstudio` | 262,144 | `doctor` cross-checks the declared window against each tier's *actual* model window and names any tier that falls short — `default` maps haiku to @@ -246,17 +248,18 @@ Scanning your installed models' templates: | **`qwen/qwen3.5-9b`**, **`prism-ml/bonsai-27b`** | **assert** | `doctor` now reports this per model, and `models` flags affected entries with -`TEMPLATE RISK`. **The fix is to use a model without the flag** — which is -exactly the `lmstudio-qwen` preset, verified end-to-end with a cold JIT load, -streaming, and tool calls. +`TEMPLATE RISK`. **The fix is to use a model without the flag.** The Qwen3.6 +line above is what the single `lmstudio` preset ships pointed at, verified +end-to-end with a cold JIT load, streaming, and tool calls. Honest caveat: KAT-Coder's template *does* contain the assertion, but I could not reproduce the failure against it here — cold JIT, streaming, tools, system blocks, and multi-turn `tool_result` all succeeded. Whether it trips seems to -depend on which parser strategy the runtime picks. If it spams, switch: +depend on which parser strategy the runtime picks. If the model setup lands on +does spam, run setup again and pick another: -```powershell -claude-mode lmstudio lmstudio-qwen +```bash +claude-mode setup lmstudio ``` Other notes: use a model with **>25k context** (`doctor` warns below that), and @@ -402,6 +405,38 @@ active configuration: mode, preset, model map, context window, key backend, and the switchable preset catalogue. No key material. A switch and a `status` both refresh it; the command exists for anything that wants to force it. +## First-run setup + +A shipped preset is a starting point, not a working configuration. OpenRouter +and Z.AI have no key stored. LM Studio's model ids are whatever happened to be +installed on the machine this was packaged on, which is almost certainly not +yours. + +So the shipped presets carry `configured: false`, and preflight treats that as a +blocker with its own remedy: + +```bash +claude-mode setup openrouter # key, then models from OpenRouter's catalogue +claude-mode setup zai # key, then per-tier GLM models +claude-mode setup lmstudio # server URL, auth, then models from that server +claude-mode setup anthropic # nothing to do; it uses your existing login +``` + +Setup asks only what it cannot work out, shows the current model map before +offering to change it, and picks from the provider's own catalogue rather than +asking anyone to type a model id from memory. LM Studio maps one model across +every tier, since a local server has one loaded at a time and per-tier mapping +would just pay the load cost on every tier change; the remote gateways ask per +tier, which is the point of them. + +In a terminal, a switch that trips this offers to run setup there and then +rather than printing a command to type next. It sets `configured: true` on the +way out. + +**Absent means configured.** Presets that predate this, and any built by hand +with `preset new`, are nobody's business but yours and will not start demanding +a wizard. + ## Refusing a switch that would not work A switch writes settings.json and is picked up by the *next* `claude` launch, so @@ -417,6 +452,7 @@ So the preconditions are checked before the write, not after: | mode | checked | when it fails | |---|---|---| +| any gateway | the preset has been through setup at least once | `claude-mode setup ` | | `anthropic` | nothing to check | — | | `openrouter`, `zai` | a key exists for the preset's `keyRef`, and the helper is executable | `claude-mode set-key ` | | `lmstudio` (anywhere) | the server answers, and accepts the credential the preset would send | see below | @@ -554,11 +590,12 @@ stock glyph in this bar measures: Choosing a target does not switch immediately — it runs the same two checks the CLI does, and both can stop it: -1. **Preflight.** If the mode has no key stored, or its server is not answering, - the panel says which and offers the fix: *Store the key…* opens a terminal - for the hidden prompt (a bar popup has nowhere to host one), *Check again* - re-runs the preflight once the server is up, and *Server settings…* opens the - form below. The gear on any LM Studio preset row opens the same form without +1. **Preflight.** If the mode has not been set up, has no key stored, or its + server is not answering, the panel says which and offers the fix: *Set up + …* opens a terminal and runs the whole first-run flow there (a bar popup + can host neither a hidden key prompt nor a filter-select model list), *Store + the key…* opens a terminal for just the prompt, *Check again* re-runs the + preflight, and *Server settings…* opens the form below. The gear on any LM Studio preset row opens the same form without waiting for a failure — per row, because two LM Studio presets can point at two different machines. diff --git a/linux/claude-mode b/linux/claude-mode index fc3d917..6cc8f4d 100755 --- a/linux/claude-mode +++ b/linux/claude-mode @@ -274,6 +274,7 @@ claude-mode - switch Claude Code between Anthropic, OpenRouter, Z.AI, LM Studio claude-mode doctor verify auth, endpoint, model ids, env claude-mode repair strip [1m] tags from cached model ids claude-mode health refresh health.json (machine-readable state) + claude-mode setup [--terminal] first-run setup: key, server, models claude-mode preflight [preset] check a mode can actually serve, without switching claude-mode sessions [--stop|--restart] running sessions; close or reopen them @@ -453,6 +454,13 @@ cm_preflight() { return 1 fi + if ! preset_configured "$pf"; then + cm_pf_set 'needs-setup' "$(mode_label "$mode" | cut -d- -f1 | sed 's/ *$//') has not been set up yet" \ + "The shipped preset is a starting point: it has no key stored, and its model ids are whatever was on the machine this was packaged on. Setup asks for what it needs and picks models from the provider's own catalogue." \ + "claude-mode setup $mode" 'setup' + return 1 + fi + base="$(jget "$pf" baseUrl)"; CM_PF_BASEURL="$base" auth_mode="$(jget "$pf" auth.mode)"; [ -z "$auth_mode" ] && auth_mode=vault @@ -868,9 +876,24 @@ set_mode() { if [ "$CM_FORCE" -eq 0 ] && ! cm_preflight "$mode" "$preset_name"; then err "$CM_PF_TITLE" [ -n "$CM_PF_DETAIL" ] && say "$CM_PF_DETAIL" - [ -n "$CM_PF_REMEDY" ] && printf ' %sfix:%s %s\n' "$C_DIM" "$C_RESET" "$CM_PF_REMEDY" - printf ' %s--force switches anyway%s\n' "$C_DIM" "$C_RESET" - return 1 + + # Standing in a terminal with the fix one keystroke away, printing + # the command to type next is a poor substitute for running it. + if ui_interactive && [ "$CM_PF_KIND" = "setup" ]; then + printf '\n' + if ask_yes "set up $mode now?"; then + cmd_setup "$mode" "$preset_name" || return 1 + cm_preflight "$mode" "$preset_name" || { + err "$CM_PF_TITLE"; return 1 + } + else + return 1 + fi + else + [ -n "$CM_PF_REMEDY" ] && printf ' %sfix:%s %s\n' "$C_DIM" "$C_RESET" "$CM_PF_REMEDY" + printf ' %s--force switches anyway%s\n' "$C_DIM" "$C_RESET" + return 1 + fi fi [ -f "$preset_file" ] || { err "preset '$preset_name' not found"; return 1; } fi @@ -1107,9 +1130,26 @@ or_catalogue() { curl -fsS --max-time 30 https://openrouter.ai/api/v1/models 2>/dev/null | "$PY" "$JSON" or-models 2>/dev/null } +# The credential a preset would send. Empty when there is nothing to send. +cm_preset_token() { + local pf="$1" am ref + am="$(jget "$pf" auth.mode)"; [ -z "$am" ] && am=vault + if [ "$am" = "vault" ]; then + ref="$(jget "$pf" auth.keyRef)"; [ -z "$ref" ] && ref=openrouter + cm_vault_get "$ref" 2>/dev/null || true + else + jget "$pf" auth.token + fi +} + +# The token is not optional decoration. An LM Studio server with authentication +# switched on answers /api/v0/models with 401 like anything else, so without it +# the catalogue comes back empty and every caller silently believes the server +# has no models installed - on exactly the setups that need the list most. lms_catalogue() { - local base="${1%/}" - curl -fsS --max-time 10 "$base/api/v0/models" 2>/dev/null | "$PY" "$JSON" lms-models 2>/dev/null + local base="${1%/}" token="${2:-}" + curl -fsS --max-time 10 ${token:+-H "Authorization: Bearer $token"} \ + "$base/api/v0/models" 2>/dev/null | "$PY" "$JSON" lms-models 2>/dev/null } # --------------------------------------------------------------------------- @@ -1181,7 +1221,7 @@ cmd_models() { case "$mode" in lmstudio) head_ "models installed in LM Studio at $(jget "$pf" baseUrl)" - lms_catalogue "$(jget "$pf" baseUrl)" | while IFS=$'\t' read -r id st ctx; do + lms_catalogue "$(jget "$pf" baseUrl)" "$(cm_preset_token "$pf")" | while IFS=$'\t' read -r id st ctx; do [ -z "$filter" ] || case "$id" in *"$filter"*) ;; *) continue ;; esac printf ' %-58s %-11s %s\n' "$id" "$st" "$ctx" done @@ -1295,7 +1335,7 @@ else: print(' ok spend %.2f of %.2f limit (%s), %.2f remaining' % (use, lim, fi if [ "$mode" = "lmstudio" ]; then - local cat; cat="$(lms_catalogue "$base")" + local cat; cat="$(lms_catalogue "$base" "$(cm_preset_token "$pf")")" if [ -n "$cat" ]; then ok "LM Studio reachable at $base ($(printf '%s\n' "$cat" | wc -l | tr -d ' ') models installed)" local t id row st ctx @@ -1636,7 +1676,7 @@ ui_pick_model() { while IFS=$'\t' read -r id st ctx; do [ -n "$id" ] || continue ids+=("$id"); ui_add_item "$id" "state: $st max context: $ctx" - done < <(lms_catalogue "$base") + done < <(lms_catalogue "$base" "$(cm_preset_token "$pf")") ;; zai) ids+=('glm-5.3'); ui_add_item 'glm-5.3' 'flagship coding model - opus/sonnet tier' @@ -1783,6 +1823,217 @@ ui_menu() { done } +# --------------------------------------------------------------------------- +# First-run setup +# +# A shipped preset is a starting point, not a working configuration. OpenRouter +# needs a key before it can serve anything; LM Studio needs to be told where the +# server is and which of the models it actually has installed to use - and the +# ids it ships with are whatever happened to be on the machine this was written +# on, which is almost certainly not yours. +# +# So a preset says whether it has been through setup. `configured: false` is +# written into the shipped presets and cleared once setup has run, and preflight +# treats it as a blocker: better to be walked through it once than to switch +# into something that half-works and produces a confusing failure later. +# +# Absent means configured. That is deliberate - presets that predate this, and +# ones the user built by hand with `preset new`, are their own business and must +# not suddenly start demanding a wizard. +# --------------------------------------------------------------------------- + +preset_configured() { + local v; v="$(jget "$1" configured)" + [ "$v" = "false" ] && return 1 + return 0 +} + +mark_configured() { + "$PY" "$JSON" set-flag "$1" configured true >/dev/null 2>&1 +} + +# A y/N prompt that defaults to no on anything that is not a clear yes. +ask_yes() { + local prompt="$1" reply + printf ' %s [y/N] ' "$prompt" + IFS= read -r reply || return 1 + case "$reply" in y|Y|yes|YES) return 0 ;; *) return 1 ;; esac +} + +# Prompt with a default shown in brackets; empty input keeps the default. +# +# The prompt goes to stderr for the same reason warn/err do: this is called +# inside $( ), where anything on stdout is captured as the return value. Printed +# to stdout it came back as part of the answer - " server base URL [...]: " with +# the typed URL glued on the end, which set-url then rejected. +ask_value() { + local prompt="$1" default="$2" reply + if [ -n "$default" ]; then printf ' %s [%s]: ' "$prompt" "$default" >&2 + else printf ' %s: ' "$prompt" >&2; fi + IFS= read -r reply || return 1 + [ -n "$reply" ] && printf '%s' "$reply" || printf '%s' "$default" +} + +setup_key() { + local ref="$1" label="$2" + if cm_vault_has "$ref"; then + ok "a key is already stored for '$ref' ($(cm_vault_backend_label))" + ask_yes "replace it?" || return 0 + else + say "$label needs an API key. It goes into $(cm_vault_backend_label)," + say 'not into settings.json.' + fi + cmd_set_key "$ref" +} + +# Offer the provider's own catalogue rather than asking someone to type a model +# id from memory. Falls back to typing when the catalogue cannot be reached, +# because being offline should not block finishing setup. +setup_models() { + local pf="$1" provider="$2" name="$3" + printf '\n' + say 'current model map:' + local t v + for t in "${TIERS[@]}"; do + v="$(jget "$pf" "models.$t")" + [ -n "$v" ] && printf ' %-8s %s\n' "$t" "$v" + done + printf '\n' + ask_yes 'change which models back these tiers?' || return 0 + + if ! ui_interactive; then + warn 'model picking needs an interactive terminal' + return 0 + fi + + if [ "$provider" = "lmstudio" ]; then + # One model for every tier is the normal shape for a local server: it + # has one loaded at a time, and mapping tiers to different models just + # means paying the load cost on every tier change. + local base ids=() id st ctx + base="$(jget "$pf" baseUrl)" + while IFS=$'\t' read -r id st ctx; do + [ -n "$id" ] || continue + ids+=("$id") + done < <(lms_catalogue "$base" "$(cm_preset_token "$pf")") + + if [ "${#ids[@]}" -eq 0 ]; then + warn 'the server returned no models; type an id by hand instead' + local manual; manual="$(ask_value 'model id for every tier' "$(jget "$pf" models.opus)")" + [ -n "$manual" ] && "$PY" "$JSON" set-all "$pf" "$manual" >/dev/null && ok "all tiers -> $manual" + return 0 + fi + + ui_reset_items + for id in "${ids[@]}"; do ui_add_item "$id" 'use this for every tier'; done + if ui_filter_select "model for all tiers of '$name'" 'esc = keep current'; then + "$PY" "$JSON" set-all "$pf" "${ids[$UI_SEL]}" >/dev/null + ok "all tiers -> ${ids[$UI_SEL]}" + fi + return 0 + fi + + # Remote gateways map a different model per tier, which is the whole point + # of them, so each tier is asked for separately. + local cur + for t in "${TIERS[@]}"; do + cur="$(jget "$pf" "models.$t")" + ui_pick_model "$pf" "$t" "$cur" || continue + [ -n "$UI_PICKED" ] || continue + "$PY" "$JSON" set-tier "$pf" "$t" "$UI_PICKED" >/dev/null && ok "$t -> $UI_PICKED" + done +} + +setup_lmstudio_server() { + local pf="$1" name="$2" url probe token + url="$(jget "$pf" baseUrl)"; [ -n "$url" ] || url='http://127.0.0.1:1234' + + printf '\n' + say 'LM Studio does not have to be on this machine - a LAN address or' + say 'anything reachable through a tunnel or proxy works just as well.' + url="$(ask_value 'server base URL' "$url")" + "$PY" "$JSON" set-url "$pf" "$url" >/dev/null || return 1 + ok "baseUrl -> $url" + + printf '\n' + if ask_yes 'does that server require an API key?'; then + local ref; ref="$(ask_value 'key name to store it under' 'lmstudio')" + "$PY" "$JSON" set-auth "$pf" key "$ref" >/dev/null + ok "auth -> vault key '$ref'" + cm_vault_has "$ref" || cmd_set_key "$ref" + token="$(cm_vault_get "$ref" 2>/dev/null || true)" + else + "$PY" "$JSON" set-auth "$pf" none >/dev/null + ok 'auth -> none (inline placeholder token)' + token='lmstudio' + fi + + printf '\n' + say "checking $url ..." + probe="$(cm_probe_server "$url" "$token")" + case "$probe" in + ok) ok 'server answered' ;; + auth) err 'the server refused that credential'; return 1 ;; + notfound) err 'something answered there, but not an LM Studio API' ; return 1 ;; + skip) warn 'curl is missing, so the server was not checked' ;; + *) err 'nothing answered at that address' + say 'start the server and run: claude-mode setup lmstudio' + return 1 ;; + esac + return 0 +} + +cmd_setup() { + local mode="${1:-}" name pf + + case "$mode" in + anthropic) + head_ 'setup: anthropic' + ok 'nothing to configure - it uses your existing Claude login' + return 0 ;; + openrouter|zai|lmstudio) ;; + z.ai|z-ai) mode=zai ;; + '') err 'usage: claude-mode setup '; return 1 ;; + *) err "unknown mode '$mode'"; return 1 ;; + esac + + name="$(resolve_preset "$mode" "${2:-}")" || return 1 + pf="$(preset_path "$name")" + + if ! ui_interactive; then + err 'setup needs an interactive terminal' + say "run: claude-mode setup $mode" + return 1 + fi + + head_ "setup: $mode / preset '$name'" + say "$(mode_label "$mode")" + + case "$mode" in + openrouter) + printf '\n' + setup_key openrouter 'OpenRouter' + setup_models "$pf" openrouter "$name" + ;; + zai) + printf '\n' + say 'get a key from https://z.ai/manage-apikey/apikey-list' + setup_key zai 'Z.AI' + setup_models "$pf" zai "$name" + ;; + lmstudio) + setup_lmstudio_server "$pf" "$name" || return 1 + setup_models "$pf" lmstudio "$name" + ;; + esac + + mark_configured "$pf" + printf '\n' + ok "$mode is set up" + say "switch to it with: claude-mode $mode" + return 0 +} + # --------------------------------------------------------------------------- # Dispatch # --------------------------------------------------------------------------- @@ -1836,6 +2087,27 @@ case "$cmd" in doctor) cmd_doctor ;; health) write_health "$(state_mode)" "$(state_preset)" ;; preflight) cmd_preflight "${1:-}" "${2:-}" ;; + setup) + # --terminal for callers with no stdin to offer. The bar widget + # cannot host a hidden key prompt or a filter-select list, so it + # asks a terminal to host the whole flow instead. + _mode="${1:-}"; _term=0; _rest='' + for _a in "$@"; do + case "$_a" in + --terminal) _term=1 ;; + "$_mode") ;; + *) _rest="$_a" ;; + esac + done + if [ "$_term" -eq 1 ]; then + _t="$(cm_terminal_cmd)" + setsid nohup "$_t" -e bash -lc \ + "'$0' setup '$_mode' $_rest; printf '\n press enter to close '; read -r _" \ + >/dev/null 2>&1 & + ok "opened $_t to set up $_mode" + else + cmd_setup "$_mode" "$_rest" + fi ;; sessions) cmd_sessions "$@" ;; repair) scope='' diff --git a/linux/cm-json.py b/linux/cm-json.py index 7bc5940..169c934 100644 --- a/linux/cm-json.py +++ b/linux/cm-json.py @@ -579,6 +579,30 @@ def cmd_set_auth(argv): save(path, p) print(json.dumps(p["auth"])) + +def cmd_set_flag(argv): + """set-flag true|false + + Only used for `configured` so far. Kept generic because a preset-level + boolean written by hand is exactly the kind of thing that ends up as a + string "false", which is truthy everywhere that matters. + """ + path, key, val = argv[0], argv[1], argv[2] + p = load(path) + p[key] = (val == "true") + save(path, p) + + +def cmd_set_all(argv): + """set-all - point every tier and the subagent at one id.""" + path, model = argv[0], argv[1] + p = load(path) + p["models"] = {t: model for t in TIERS} + if p.get("subagentModel") and p["subagentModel"] != "inherit": + p["subagentModel"] = model + save(path, p) + print(model) + COMMANDS = { "health": cmd_health, "preflight-json": cmd_preflight_json, @@ -592,6 +616,8 @@ COMMANDS = { "models": cmd_models, "set-tier": cmd_set_tier, "set-url": cmd_set_url, + "set-flag": cmd_set_flag, + "set-all": cmd_set_all, "set-auth": cmd_set_auth, "scaffold": cmd_scaffold, "get": cmd_get, diff --git a/omarchy/smoido.claude-mode/Panel.qml b/omarchy/smoido.claude-mode/Panel.qml index 7f26cc8..da47ff5 100644 --- a/omarchy/smoido.claude-mode/Panel.qml +++ b/omarchy/smoido.claude-mode/Panel.qml @@ -279,6 +279,17 @@ Panel { } } + // First-run setup asks for a key behind a hidden prompt and picks models from + // a filter-select list - neither of which a bar popup can host. The terminal + // gets the whole flow; this side just launches it and re-checks afterwards. + function runSetup() { + if (root.pendingMode === "") return + setupProc.command = root.cli(["setup", root.pendingMode, "--terminal"]) + setupProc.running = true + } + + Process { id: setupProc; running: false } + function retryPending() { if (root.pendingMode === "") { root.resetFlow(); return } var m = root.pendingMode, p = root.pendingPreset @@ -688,6 +699,12 @@ Panel { width: parent.width spacing: Style.space(7) + PillButton { + label: "Set up " + Modes.title(root.pendingMode) + "…" + primary: true + visible: root.blocker && String(root.blocker.remedyKind) === "setup" + onTriggered: root.runSetup() + } PillButton { label: "Store the key…" primary: true @@ -698,10 +715,11 @@ Panel { label: "Server settings…" primary: root.blocker && ["start-server", "set-url", "needs-key"].indexOf(String(root.blocker.remedyKind)) >= 0 visible: root.pendingMode === "lmstudio" + && !(root.blocker && String(root.blocker.remedyKind) === "setup") onTriggered: root.openServerSettings(root.pendingPreset) } PillButton { - label: root.blocker && String(root.blocker.remedyKind) === "start-server" + label: root.blocker && ["start-server", "setup"].indexOf(String(root.blocker.remedyKind)) >= 0 ? "Check again" : "Try again" primary: root.blocker && String(root.blocker.remedyKind) === "start-server" onTriggered: root.retryPending() diff --git a/presets/cheap.json b/presets/cheap.json deleted file mode 100644 index 0372ff4..0000000 --- a/presets/cheap.json +++ /dev/null @@ -1,18 +0,0 @@ -{ - "provider": "openrouter", - "description": "Minimum cost. Everything on flash-class models with 1M context.", - "baseUrl": "https://openrouter.ai/api", - "auth": { - "mode": "vault", - "keyRef": "openrouter" - }, - "models": { - "opus": "deepseek/deepseek-v4-pro", - "sonnet": "deepseek/deepseek-v4-flash-0731", - "haiku": "qwen/qwen3.7-flash", - "fable": "openai/gpt-5.6-luna-pro" - }, - "subagentModel": "qwen/qwen3.7-flash", - "gatewayModelDiscovery": true, - "contextTokens": 1000000 -} diff --git a/presets/default.json b/presets/default.json index db02741..be85d27 100644 --- a/presets/default.json +++ b/presets/default.json @@ -1,18 +1,19 @@ { "provider": "openrouter", - "description": "Daily driver. Cheap flash models on the hot tiers, GLM on fable.", + "description": "Daily driver. Flash-class models on the hot tiers, GLM on fable.", "baseUrl": "https://openrouter.ai/api", "auth": { "mode": "vault", "keyRef": "openrouter" }, "models": { - "opus": "deepseek/deepseek-v4-flash-0731", - "sonnet": "qwen/qwen3.7-flash", + "opus": "z-ai/glm-5.3-flash", + "sonnet": "deepseek/deepseek-v4-flash-0731", "haiku": "openrouter/free", "fable": "z-ai/glm-5.3" }, "subagentModel": "inherit", "gatewayModelDiscovery": true, - "contextTokens": 1000000 + "contextTokens": 1000000, + "configured": false } diff --git a/presets/lmstudio-qwen.json b/presets/lmstudio-qwen.json deleted file mode 100644 index 01a2363..0000000 --- a/presets/lmstudio-qwen.json +++ /dev/null @@ -1,21 +0,0 @@ -{ - "provider": "lmstudio", - "description": "Local Qwen3.6-35B-A3B uncensored (heretic, MTP-preserved). Clean chat template - verified working with tools + streaming.", - "baseUrl": "http://127.0.0.1:1234", - "auth": { - "mode": "literal", - "token": "lmstudio" - }, - "models": { - "opus": "qwen3.6-35b-a3b-uncensored-heretic-native-mtp-preserved", - "sonnet": "qwen3.6-35b-a3b-uncensored-heretic-native-mtp-preserved", - "haiku": "qwen3.6-35b-a3b-uncensored-heretic-native-mtp-preserved", - "fable": "qwen3.6-35b-a3b-uncensored-heretic-native-mtp-preserved" - }, - "subagentModel": "qwen3.6-35b-a3b-uncensored-heretic-native-mtp-preserved", - "gatewayModelDiscovery": true, - "extraEnv": { - "CLAUDE_CODE_ATTRIBUTION_HEADER": "0" - }, - "contextTokens": 262144 -} diff --git a/presets/lmstudio.json b/presets/lmstudio.json index dfc3aff..0a38f20 100644 --- a/presets/lmstudio.json +++ b/presets/lmstudio.json @@ -1,21 +1,22 @@ { "provider": "lmstudio", - "description": "Local KAT-Coder v2.5. NOTE: its chat template asserts message order - if you hit 'Unable to generate parser for this template', use the lmstudio-qwen preset.", + "description": "Local LM Studio server. Set up picks the model from whatever the server actually has installed.", "baseUrl": "http://127.0.0.1:1234", "auth": { "mode": "literal", "token": "lmstudio" }, "models": { - "opus": "kwaipilot_kat-coder-v2.5-dev", - "sonnet": "kwaipilot_kat-coder-v2.5-dev", - "haiku": "kwaipilot_kat-coder-v2.5-dev", - "fable": "kwaipilot_kat-coder-v2.5-dev" + "opus": "qwen3.6-35b-a3b-uncensored-heretic-native-mtp-preserved", + "sonnet": "qwen3.6-35b-a3b-uncensored-heretic-native-mtp-preserved", + "haiku": "qwen3.6-35b-a3b-uncensored-heretic-native-mtp-preserved", + "fable": "qwen3.6-35b-a3b-uncensored-heretic-native-mtp-preserved" }, - "subagentModel": "kwaipilot_kat-coder-v2.5-dev", + "subagentModel": "qwen3.6-35b-a3b-uncensored-heretic-native-mtp-preserved", "gatewayModelDiscovery": true, "extraEnv": { "CLAUDE_CODE_ATTRIBUTION_HEADER": "0" }, - "contextTokens": 262144 + "contextTokens": 262144, + "configured": false } diff --git a/presets/zai.json b/presets/zai.json index 9a269d3..77d90f4 100644 --- a/presets/zai.json +++ b/presets/zai.json @@ -18,5 +18,6 @@ "API_TIMEOUT_MS": "3000000", "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1" }, - "contextTokens": 1000000 + "contextTokens": 1000000, + "configured": false }