config: the lazy imports that buy nothing become eager

[ch-wan]

The series

Stacked, each PR based on the one above it. Read them in order; every boundary is
self-sufficient and green on its own.

1. #36896 — the resolution pipeline's dispatcher leaves the record
2. #36972 — the callbacks into the record go to zero
3. #36973 — six more runtime readers ask the bags
4. #36974 — the dead record parameters go
5. #36975 — the lazy imports that buy nothing become eager ← you are here

• #36925 — CI vehicle — runs the whole series against main, not for merge

Motivation

arg_groups.overrides is already imported at module scope by thirty-five files, server_args
among them. Importing it is neither a cycle nor a cost — by the time any resolution step runs, the
module is loaded. Ninety-three from ...overrides import statements were nonetheless written
inside the functions that use them, which reads as though laziness were required when mostly it
was habit.

Eight of the twenty files this touches had the lazy form before this series, so it is not only a
cleanup after it.

Modifications

The statements that buy nothing become module-scope imports.

Twenty-three more were mixed: a name the tests patch, plus names riding along on the same
statement that nothing patches. Splitting those frees thirty-six more riders. The _dsa_* pass
callables in model_hook are the shape of it —

from sglang.srt.arg_groups.overrides import (
    _dsa_kv_cache_dtype_default,      # only ever an argument
    _dsa_split_backend_resolution,    # only ever an argument
    run_post_process_pass,            # patched through the module
)

— three names, one reason. The two passes are handed to run_post_process_pass and never looked
up through the module, so they were lazy only by association. The seam stays a call-site import;
they go to the top.

model_hook and moe_hook are the exception: their import block also carries the two properties
PR 2 lifted, so the two changes cannot be separated by hunk without an intermediate commit that
does not compile. Their split lands in PR 2 with the move it is entangled with, and the counts
below are for the whole series.

What is left is load-bearing, for exactly two reasons and nothing else. They are worth writing
down because they decide where the next one goes.

The module is a test seam. use_mla_backend, attention_backends_of, model_config_of and
supports_mamba_cache_extra_buffer are patched as patch("...overrides.<name>"). The four
declaration paths — declare_resolution, declare_late_resolution, declare_direct_writes,
run_post_process_pass — are wrapped by setattr on the module in
test_no_entry_changes_after_it_is_recorded, which watches every declaration a resolution
makes.

A from ... import name is a copy. Hoisting these turns one seam into six or twenty: a test
that patches the source module reaches none of the copies, and a test that patches one consumer
reaches only that one. Hoisting the declarers is what this commit tried first, and the census
guard failed exactly as it was designed to — it recorded nothing, because the wrapper it installed
on the module was no longer what the callers called.

Import order. runtime_context is imported by utils.common, which overrides needs, so it
sits below overrides and cannot import it at module scope. That one is a cycle, not a
preference; it was found by the import smoke check, not by reasoning.

That leaves a rule a reader can check:

function-local overrides import	count
the module is a patched or watched seam	54
import order (runtime_context)	8
neither	0

Accuracy Tests

The 62-shape resolution probe is byte-identical to the base commit. A dummy resolution is
unchanged at ~9 ms and loads the same six arg_groups modules — which is the point: the laziness
these statements were written for was already provided by the families' own import placement, not
by the overrides import.

605 registered config tests pass, test_no_entry_changes_after_it_is_recorded among them — it is
the guard that fails the moment a declarer is hoisted.

Two properties worth stating because a hoist can break them silently: every newly module-bound name
is actually used in its file (no unused hoist), and no function still imports locally a name the
same file now binds at module scope (no UnboundLocal from late shadowing). Both hold by AST over
the commit. The newly eager modules are also off the overrides → utils.common →
runtime_context path, which is the cycle the keep-list's second reason protects.

Speed Tests and Profiling

None beyond the dummy-resolution timing above.

Checklist

• Format your code according to the Format code with pre-commit.
• Add unit tests according to the Run and add unit tests.
• Update documentation according to Write documentations.
• Provide accuracy and speed benchmark results according to Test the accuracy and Benchmark the speed.
• Follow the SGLang code style guidance.

Review and Merge Process

Mechanical apart from the keep-list, and the table above is the whole of it: eight names stay lazy
because the module is where tests patch or watch them, runtime_context stays lazy because of
import order, and nothing else stays lazy at all. A reviewer can check the claim by re-running the
same scan.

---

CI States

Latest PR Test (Base): 🚫 Run #33249957988
Latest PR Test (Extra): 🚫 Run #33249957857
Latest PR Test (AMD ROCm 7.2): 🚫 Run #33249958152

[chatgpt-codex-connector]

Codex Review Summary

This comment shows the latest Codex review activity on this pull request.

Review	Status	Commit	Review trigger
📝 Code Review	✅ Completed 2026-08-29T06:39:01.939566Z	24e78d7	New commits

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review" or "@codex security review".

Codex reacts with 👀 while any review is running, comments if it has suggestions, and reacts with 👍 once all reviews finish with no findings.