fix(mlx): defer to upstream when gated_delta_update gets unknown kwargs

A newer mlx-lm adding parameters (precedent: the qwen3_5 attention
kwargs that needed #721) would previously TypeError inside the patched
wrapper. Silently dropping them could change training semantics, so
unknown kwargs now delegate to the original implementation with a
one-time warning naming the new arguments — old mlx-lm is unchanged,
newer mlx-lm stays correct until the patch is updated.

Author: Lyxot

tests/test_mlx_gated_delta_vjp.py

@@ -286,3 +286,24 @@ def spy(*args, **kwargs):
     y, s = gd.gated_delta_update(q, k, v, a, b, A_log, dt_bias, state=None)
     mx.eval(y, s)
     assert called.get("kernel"), "training call did not route to kernel VJP"
+
+
+def test_unknown_kwargs_delegate_to_original(fake_mlx_lm, monkeypatch):
+    """A newer mlx-lm adding parameters must not crash or silently drop
+    them: the patched function defers to the original implementation."""
+    calls = {}
+
+    def newer_original(q, k, v, a, b, A_log, dt_bias,
+                       state=None, mask=None, use_kernel=True, new_flag=None):
+        calls["kwargs"] = {"new_flag": new_flag}
+        return "y", "state"
+
+    fake_mlx_lm.gated_delta.gated_delta_update = newer_original
+    for module in fake_mlx_lm.consumers.values():
+        module.gated_delta_update = newer_original
+    _patch()
+
+    patched = fake_mlx_lm.gated_delta.gated_delta_update
+    result = patched(*[object()] * 7, state=None, new_flag="x")
+    assert result == ("y", "state")
+    assert calls["kwargs"] == {"new_flag": "x"}

unsloth_zoo/gated_delta_vjp.py

@@ -250,6 +250,7 @@ def _chunked_vjp(primals, cotangents, outputs):
 
 
 _WARNED_FOREIGN_GATED_DELTA: set = set()
+_WARNED_UNKNOWN_GD_KWARGS: set = set()
 
 
 def patch_gated_delta():
@@ -269,8 +270,26 @@ def patch_gated_delta():
 
         def patched_gated_delta_update(
             q, k, v, a, b, A_log, dt_bias,
-            state=None, mask=None, use_kernel=True,
+            state=None, mask=None, use_kernel=True, **kwargs,
         ):
+            if kwargs:
+                # A newer mlx-lm added parameters this patch does not know
+                # about. Silently dropping them could change semantics, so
+                # defer to the original implementation (correct, unpatched)
+                # and warn once that the patch needs updating.
+                if not _WARNED_UNKNOWN_GD_KWARGS:
+                    _WARNED_UNKNOWN_GD_KWARGS.add(True)
+                    print(
+                        "Unsloth: WARNING — gated_delta_update received "
+                        f"unknown arguments {sorted(kwargs)} from a newer "
+                        "mlx-lm; falling back to the unpatched implementation "
+                        "(training will be slow — pass compile=False — until "
+                        "unsloth_zoo/gated_delta_vjp.py is updated)."
+                    )
+                return original_gated_delta_update(
+                    q, k, v, a, b, A_log, dt_bias,
+                    state=state, mask=mask, use_kernel=use_kernel, **kwargs,
+                )
             # Heuristic: training calls enter with state=None (no cache); inference
             # passes the cached state in. Route training through the efficient ops
             # so the custom VJP runs — gated_delta_kernel has none, so it would keep