> ## Documentation Index
> Fetch the complete documentation index at: https://docs.sglang.io/llms.txt
> Use this file to discover all available pages before exploring further.
# PPLX-Decider-v1-27B
> Deploy PPLX-Decider-v1-27B with SGLang. Perplexity's decision model, fine-tuned from Qwen3.8-27B, returns calibrated probabilities for choice, yes or no, and score questions on /v1/systemone, on one NVIDIA H200 or GB300 in BF16.
export const Playground = ({config}) => {
if (!config) {
return Playground: missing config prop
;
}
const DIMENSIONS = ["hw", ...(config.matchDims || [{
id: "variant"
}, {
id: "quant"
}, {
id: "strategy"
}, {
id: "nodes"
}]).map(d => d.id)];
const optionVisible = (opt, sel) => typeof opt.showWhen !== "function" || opt.showWhen(sel);
const optionDisabled = (opt, sel) => typeof opt.disabled === "function" ? opt.disabled(sel) : !!opt.disabled;
const visibleOptions = (spec, sel) => (spec.options || []).filter(o => optionVisible(o, sel));
const rowVisible = (spec, sel) => (typeof spec.showWhen !== "function" || spec.showWhen(sel)) && visibleOptions(spec, sel).length > 0;
const overlayPick = sel => {
const picked = [];
for (const spec of config.overlayDims || []) {
if (!rowVisible(spec, sel)) continue;
const opt = (spec.options || []).find(o => o.id === sel[spec.id]);
if (opt && !optionDisabled(opt, sel)) picked.push(opt);
}
return picked;
};
const overlayPart = (sel, key) => {
const out = [];
for (const opt of overlayPick(sel)) {
const add = typeof opt[key] === "function" ? opt[key](sel) : opt[key];
if (add) out.push(...add);
}
return out;
};
const overlayCompose = (cellFlags, sel) => {
const strip = overlayPart(sel, "stripPrefixes");
const add = overlayPart(sel, "flags");
if (!strip.length) return [...cellFlags || [], ...add];
const used = new Set();
const replacementsFor = tok => {
const out = [];
add.forEach((f, i) => {
if (used.has(i) || f.split(/[\s=]/)[0] !== tok) return;
used.add(i);
out.push(f);
});
return out;
};
const out = [];
for (const f of cellFlags || []) {
const tok = f.split(/[\s=]/)[0];
if (!strip.includes(tok)) out.push(f); else out.push(...replacementsFor(tok));
}
add.forEach((f, i) => {
if (!used.has(i)) out.push(f);
});
return out;
};
const withOverlay = (cell, sel) => cell && ({
...cell,
flags: overlayCompose(cell.flags, sel),
env: [...cell.env || [], ...overlayPart(sel, "env")]
}) || cell;
const STORAGE_KEY = "sglang-deploy-env";
const DEPLOYMENT_COMPONENT_ID = "deployment-configurator";
const pgFeatures = config.playgroundFeatures || ({});
const PD_PORTS = {
prefill: {
serve: 30000,
dist: 30335
},
decode: {
serve: 30100,
dist: 30435
}
};
const findCell = (cells, sel) => {
const cell = cells.find(c => DIMENSIONS.every(d => c.match[d] === sel[d]));
return cell && typeof config.resolveRecipe === "function" ? config.resolveRecipe(cell, sel) : cell;
};
const findMatchingCell = (cells, sel, pgEnv, pgFlags) => {
const fixedDims = DIMENSIONS.filter(d => d !== "strategy");
const flagsEq = (a, b) => a.length === b.length && a.every((x, i) => x === b[i]);
const envEq = (a, b) => {
if (a.length !== b.length) return false;
const set = new Set(a);
for (const x of b) if (!set.has(x)) return false;
return true;
};
for (const raw of cells) {
const c = typeof config.resolveRecipe === "function" ? config.resolveRecipe(raw, {
...sel,
...raw.match
}) : raw;
if (fixedDims.some(d => c.match[d] !== sel[d])) continue;
if (flagsEq(c.flags || [], pgFlags || []) && envEq(c.env || [], pgEnv || [])) {
return c;
}
}
return null;
};
const resolveModelName = sel => {
const keys = [`${sel.hw}|${sel.variant}|${sel.quant}`, `${sel.variant}|${sel.quant}`, `${sel.hw}|${sel.quant}`, sel.quant, sel.hw, "default"];
for (const k of keys) {
const hit = config.modelNames[k];
if (hit) return hit;
}
return "";
};
const interpolate = (text, env, modelName) => text.replace(/{{(\w+)}}/g, (_, key) => key === "MODEL_NAME" ? modelName : env[key] ?? `{{${key}}}`);
const parseNnodes = id => {
if (id === "single") return 1;
const m = (/^multi-(\d+)$/).exec(id);
return m ? parseInt(m[1], 10) : 1;
};
const placeholderDefaults = schema => {
const out = {};
for (const [k, v] of Object.entries(schema || ({}))) out[k] = v.default ?? "";
return out;
};
const matchConstraint = (base, constraint) => {
if (!constraint || typeof constraint !== "object") return false;
const entries = Object.entries(constraint);
if (entries.length === 0) return false;
return entries.every(([k, vs]) => Array.isArray(vs) && vs.includes(base[k]));
};
const exclusiveGroupsFor = (axisId, base) => (config.playgroundExclusiveGroups || []).filter(group => group.axes.includes(axisId) && matchConstraint(base, group.when));
const updateAxisDeltas = (deltas, axisId, next, base) => {
const updated = {
...deltas,
[axisId]: next
};
if (next?.enable === true) {
for (const group of exclusiveGroupsFor(axisId, base)) {
for (const peer of group.axes) {
if (peer !== axisId && updated[peer]) {
updated[peer] = {
...updated[peer],
enable: false
};
}
}
}
}
return updated;
};
const backendEnv = (entry, base) => {
if (!entry) return [];
const override = (entry.envOverrides || []).find(r => matchConstraint(base, r.when));
return override ? override.env || [] : entry.env || [];
};
const resolveRouter = (fc, sel) => {
if (!fc || !fc.router) return null;
const hit = (fc.routerOverrides || []).find(r => r && matchConstraint(sel, r.when));
return hit ? {
...fc.router,
...hit
} : fc.router;
};
const evaluateChip = (entry, base) => {
if (entry === null || typeof entry !== "object") {
return {
value: entry,
label: undefined,
hidden: false,
disabled: false,
disableReason: ""
};
}
const hidden = entry.hide ? matchConstraint(base, entry.hide) : false;
let disabled = entry.disabled === true || entry.disable === true;
let disableReason = typeof entry.disableReason === "function" ? entry.disableReason(base) : entry.disableReason || "";
if (!disabled && entry.disable && typeof entry.disable === "object") {
if (Array.isArray(entry.disable)) {
for (const item of entry.disable) {
const cond = item && item.when || item;
if (matchConstraint(base, cond)) {
disabled = true;
if (item && item.reason) disableReason = item.reason;
break;
}
}
} else {
disabled = matchConstraint(base, entry.disable);
}
}
const labelOverride = (entry.labelWhen || []).find(l => l && l.when && matchConstraint(base, l.when));
return {
...entry,
value: entry.id !== undefined ? entry.id : entry.value,
label: labelOverride ? labelOverride.label : entry.label,
hidden,
disabled,
disableReason
};
};
const findEntry = (entries, picked) => {
for (const e of entries || []) {
const v = e === null || typeof e !== "object" ? e : e.id !== undefined ? e.id : e.value;
if (v === picked) return e;
}
return null;
};
const isHidden = (entries, picked, base) => {
const e = findEntry(entries, picked);
if (e === null || e === undefined) return false;
return evaluateChip(e, base).hidden;
};
const stripFlagsByFirstToken = (flags, prefixes) => {
const set = new Set(prefixes);
return flags.filter(f => !set.has(f.split(/[\s=]/)[0]));
};
const stripEnvByPrefix = (envList, prefixes) => {
if (!prefixes || !prefixes.length) return envList;
const set = new Set(prefixes);
return envList.filter(e => !set.has(e.split("=")[0]));
};
const insertBeforeTail = (flags, additions) => {
const idx = flags.findIndex(f => f.startsWith("--host"));
const at = idx === -1 ? flags.length : idx;
const out = flags.slice();
out.splice(at, 0, ...additions);
return out;
};
const insertAfter = (flags, afterAnyOf, additions) => {
let idx = -1;
for (const anchor of afterAnyOf) {
idx = flags.findIndex(f => f.split(/[\s=]/)[0] === anchor);
if (idx !== -1) break;
}
if (idx === -1) idx = flags.findIndex(f => f.startsWith("--model-path"));
const out = flags.slice();
out.splice(idx + 1, 0, ...additions);
return out;
};
const parseIntFlag = (flags, prefix) => {
for (const f of flags || []) {
if (f.split(/[\s=]/)[0] !== prefix) continue;
const rest = f.slice(prefix.length).replace(/^[\s=]+/, "");
const n = parseInt(rest, 10);
if (!isNaN(n)) return n;
}
return null;
};
const hasFlag = (flags, name) => (flags || []).some(f => f.split(/[\s=]/)[0] === name);
const findFlagArg = (flags, prefix) => {
for (const f of flags || []) {
if (f.split(/[\s=]/)[0] !== prefix) continue;
const rest = f.slice(prefix.length).replace(/^[\s=]+/, "");
return rest.length ? rest : null;
}
return null;
};
const TP_HEADS = ["--tp-size", "--tp", "--tensor-parallel-size"];
const EP_HEADS = ["--ep-size", "--ep", "--expert-parallel-size"];
const DP_HEADS = ["--dp-size", "--dp", "--data-parallel-size"];
const ATTN_DP_HEADS = ["--attn-dp-size", "--attention-data-parallel-size"];
const parseIntFlagAny = (flags, heads) => {
for (const head of heads) {
const n = parseIntFlag(flags, head);
if (n !== null) return n;
}
return null;
};
const flagSpelling = (flags, heads, fallback) => heads.find(head => (flags || []).some(f => f.split(/[\s=]/)[0] === head)) || fallback;
const dpAttnOnIn = flags => (parseIntFlagAny(flags, ATTN_DP_HEADS) ?? 1) > 1;
const ANCHOR_NEAR_MODEL_PATH = ["--model-path"];
const ANCHOR_NEAR_TP = ["--tp-size", "--tp", "--model-path"];
const ANCHOR_NEAR_DP = ["--dp-size", "--dp", "--tp-size", "--tp", "--model-path"];
const ANCHOR_NEAR_DPATTN = [...ATTN_DP_HEADS, "--dp-size", "--dp", "--tp-size", "--tp", "--model-path"];
const ANCHOR_NEAR_MOE = ["--moe-a2a-backend", "--moe-runner-backend", ...ATTN_DP_HEADS, "--dp-size", "--dp", "--tp-size", "--tp", "--model-path"];
const helpers = {
matchConstraint,
evaluateChip,
findEntry,
isHidden,
stripFlagsByFirstToken,
stripEnvByPrefix,
insertBeforeTail,
insertAfter,
parseIntFlag,
hasFlag,
findFlagArg,
TP_HEADS,
EP_HEADS,
DP_HEADS,
ATTN_DP_HEADS,
parseIntFlagAny,
flagSpelling,
dpAttnOnIn,
ANCHOR_NEAR_MODEL_PATH,
ANCHOR_NEAR_TP,
ANCHOR_NEAR_DP,
ANCHOR_NEAR_DPATTN,
ANCHOR_NEAR_MOE
};
const HICACHE_HEADS = ["--enable-hierarchical-cache", "--hicache-ratio", "--hicache-size", "--hicache-write-policy", "--hicache-mem-layout", "--hicache-io-backend", "--hicache-storage-backend", "--hicache-storage-prefetch-policy", "--hicache-storage-backend-extra-config"];
const umbpRoleOverride = (fc, sel, h) => (fc.roleOverrides || []).find(r => r && sel && r.mode === sel.pdMode && (!r.when || h.matchConstraint(sel, r.when)));
const CP_ENABLE_HEADS = ["--enable-prefill-cp", "--enable-nsa-prefill-context-parallel", "--enable-dsa-prefill-context-parallel", "--enable-prefill-context-parallel"];
const CP_MODE_HEADS = ["--nsa-prefill-cp-mode", "--dsa-prefill-cp-mode", "--prefill-cp-mode"];
const CP_OWNED_HEADS = [...CP_ENABLE_HEADS, ...CP_MODE_HEADS, "--cp-strategy", "--attn-cp-size"];
const CP_MODE_TO_STRATEGY = {
"in-seq-split": "zigzag",
"round-robin-split": "interleave"
};
const cpEnabledIn = flags => CP_ENABLE_HEADS.some(head => hasFlag(flags, head));
const bakedCpStrategy = flags => findFlagArg(flags, "--cp-strategy") || CP_MODE_TO_STRATEGY[findFlagArg(flags, "--nsa-prefill-cp-mode")] || CP_MODE_TO_STRATEGY[findFlagArg(flags, "--dsa-prefill-cp-mode")] || CP_MODE_TO_STRATEGY[findFlagArg(flags, "--prefill-cp-mode")] || null;
const AXIS_HANDLERS = {
attention: {
initState: () => ({
tp: null,
cp: null,
cpStrategy: null,
dpAttn: null
}),
deriveFromBase: (cell, fc, h) => {
const flags = cell && cell.flags || [];
const dpVal = h.parseIntFlagAny(flags, h.ATTN_DP_HEADS);
const dpAttn = dpVal !== null ? dpVal : false;
const cpSize = h.parseIntFlag(flags, "--attn-cp-size");
return {
tp: h.parseIntFlagAny(flags, h.TP_HEADS),
cp: cpEnabledIn(flags) ? cpSize !== null ? cpSize : 2 : null,
cpStrategy: bakedCpStrategy(flags),
dpAttn
};
},
apply: ({flags, env, value, fc, sel, h}) => {
const knobEntry = id => (fc.knobs || []).find(k => k.id === id) || ({});
const factsNow = () => ({
...sel || ({}),
dpAttnOn: h.dpAttnOnIn(flags),
cpOn: cpEnabledIn(flags),
cpStrategy: bakedCpStrategy(flags) || "interleave",
effTp: h.parseIntFlagAny(flags, h.TP_HEADS)
});
const cpSizeTargetNow = () => {
if (knobEntry("cp").freeSize) return null;
const dpIntent = value.dpAttn !== null && value.dpAttn !== undefined ? value.dpAttn : h.parseIntFlagAny(flags, h.ATTN_DP_HEADS) ?? false;
if (typeof dpIntent === "number" && dpIntent > 1) return null;
return h.parseIntFlagAny(flags, h.TP_HEADS);
};
const blocked = (id, v) => {
const facts = factsNow();
const kc = h.evaluateChip(knobEntry(id), facts);
if (kc.hidden || kc.disabled) return true;
if (id === "cp" && typeof v === "number" && v > 1) {
const target = cpSizeTargetNow();
if (target !== null && v !== target) return true;
}
const e = h.findEntry(knobEntry(id).values || [], v);
return !!(e !== null && e !== undefined && h.evaluateChip(e, facts).disabled);
};
if (value.tp !== null && !blocked("tp", value.tp)) {
const tpHead = h.flagSpelling(flags, h.TP_HEADS, "--tp");
flags = h.stripFlagsByFirstToken(flags, h.TP_HEADS);
flags = h.insertAfter(flags, h.ANCHOR_NEAR_MODEL_PATH, [`${tpHead} ${value.tp}`]);
}
const cpStrategyOverride = value.cpStrategy && !blocked("cpStrategy", value.cpStrategy) ? value.cpStrategy : null;
const cpPick = value.cp !== null ? value.cp : cpStrategyOverride && cpEnabledIn(flags) ? h.parseIntFlag(flags, "--attn-cp-size") ?? 2 : null;
const cpStrategyPick = cpStrategyOverride || bakedCpStrategy(flags) || "interleave";
if (cpPick !== null && !blocked("cp", cpPick)) {
flags = h.stripFlagsByFirstToken(flags, CP_OWNED_HEADS);
if (cpPick > 1) {
flags = h.insertAfter(flags, h.ANCHOR_NEAR_DPATTN, [`--attn-cp-size ${cpPick}`, "--enable-prefill-cp", `--cp-strategy ${cpStrategyPick}`]);
}
}
const dpForced = (knobEntry("dpAttn").forceOff || []).find(r => r && h.matchConstraint(factsNow(), r.when));
if (dpForced) {
flags = h.stripFlagsByFirstToken(flags, [...h.ATTN_DP_HEADS, "--enable-dp-attention-local-control-broadcast"]);
const stripEnv = dpForced.stripEnv || [];
if (stripEnv.length) {
env = env.filter(e => !stripEnv.includes(e.split("=")[0]));
}
} else if (value.dpAttn !== null && value.dpAttn !== undefined && !blocked("dpAttn", value.dpAttn)) {
const dpHead = h.flagSpelling(flags, h.ATTN_DP_HEADS, "--attn-dp-size");
const hadLocalBroadcast = h.hasFlag(flags, "--enable-dp-attention-local-control-broadcast");
flags = h.stripFlagsByFirstToken(flags, [...h.ATTN_DP_HEADS, "--enable-dp-attention-local-control-broadcast"]);
if (typeof value.dpAttn === "number" && value.dpAttn > 0) {
flags = h.insertAfter(flags, h.ANCHOR_NEAR_TP, [`${dpHead} ${value.dpAttn}`, ...hadLocalBroadcast ? ["--enable-dp-attention-local-control-broadcast"] : []]);
}
}
return {
flags,
env
};
},
render: ({axisId, value, setValue, fc, base, s, h, renderSelect, derived}) => {
const knobs = fc.knobs || [];
if (!knobs.length) return null;
const setKnob = (k, v) => setValue({
...value,
[k]: v
});
const labelFor = knob => c => {
if (c.label !== undefined) return c.label;
if (knob.id === "dpAttn") {
const labelMap = knob.labels || ({
"auto": "Auto",
"false": "Off"
});
const k = c.value === null ? "auto" : String(c.value);
return labelMap[k] || k;
}
return c.value === null ? "Auto" : String(c.value);
};
const knobDisplay = knob => {
const v = value[knob.id];
if (v !== null && v !== undefined) return v;
if (derived && derived[knob.id] !== undefined) return derived[knob.id];
return null;
};
const hideNullFor = knob => {
const d = derived ? derived[knob.id] : null;
return d !== null && d !== undefined ? [null] : [];
};
const entriesFor = knob => {
const vals = knob.values || [null];
if (knob.id !== "cp" || knob.freeSize) return vals;
const target = base.cpSizeTarget;
if (target === null || target === undefined) return vals;
return vals.map(entry => {
const v = entry === null || typeof entry !== "object" ? entry : entry.id !== undefined ? entry.id : entry.value;
if (typeof v !== "number" || v <= 1 || v === target) return entry;
const wrapped = entry === null || typeof entry !== "object" ? {
value: entry
} : {
...entry
};
return {
...wrapped,
disabled: true,
disableReason: `SGLang derives the prefill-CP size as attn_cp_size = TP / DP-Attention (= ${target} here), so only that size can be enabled.`
};
});
};
return
Attention
{knobs.map(knob => {
const kc = h.evaluateChip(knob, base);
if (kc.hidden) return null;
const forced = (knob.forceOff || []).find(r => r && h.matchConstraint(base, r.when));
return
{knob.label || knob.id.toUpperCase()}
{renderSelect(forced ? false : knobDisplay(knob), entriesFor(knob), nv => setKnob(knob.id, nv), base, labelFor(knob), {
hideValues: hideNullFor(knob),
disabled: kc.disabled || !!forced,
disabledReason: forced ? forced.reason : kc.disableReason
})}
;
})}
;
}
},
moe: {
initState: () => ({
backend: null,
ep: null,
mmQuant: null
}),
deriveFromBase: (cell, fc, h) => {
const flags = cell && cell.flags || [];
const a2a = h.findFlagArg(flags, "--moe-a2a-backend");
const runner = h.findFlagArg(flags, "--moe-runner-backend");
const w4a4 = h.hasFlag(flags, "--enable-w4a4-mxfp4-megamoe");
return {
backend: a2a || runner || null,
ep: h.parseIntFlagAny(flags, h.EP_HEADS),
mmQuant: w4a4 ? "w4a4" : "w4a8"
};
},
apply: ({flags, env, value, fc, sel, h, derived}) => {
if (value.backend !== null) {
flags = h.stripFlagsByFirstToken(flags, ["--moe-a2a-backend", "--moe-runner-backend"]);
const backendEnvKeys = [];
for (const o of fc.backend?.options || []) {
const allEnv = [...o.env || [], ...(o.envOverrides || []).flatMap(r => r.env || [])];
for (const e of allEnv) backendEnvKeys.push(e.split("=")[0]);
}
if (backendEnvKeys.length) env = h.stripEnvByPrefix(env, backendEnvKeys);
const opt = (fc.backend?.options || []).find(o => o.id === value.backend);
if (opt?.flags?.length) {
flags = h.insertAfter(flags, h.ANCHOR_NEAR_DPATTN, opt.flags);
}
const selectedEnv = backendEnv(opt, sel);
if (selectedEnv.length && (!opt.envWhen || h.matchConstraint(sel, opt.envWhen))) {
env = [...env, ...selectedEnv];
}
}
const mq = fc.megamoeQuant;
const mqActive = !!mq && !(mq.hideHw || []).includes(sel && sel.hw);
if (mq) {
const quantKeys = [];
const quantFlagHeads = [];
for (const o of mq.options || []) {
for (const e of o.env || []) quantKeys.push(e.split("=")[0]);
for (const f of o.flags || []) quantFlagHeads.push(f.split(/[\s=]/)[0]);
}
flags = h.stripFlagsByFirstToken(flags, quantFlagHeads);
const effBackend = value.backend !== null ? value.backend : derived && derived.backend;
if (effBackend === "megamoe" && mqActive) {
env = h.stripEnvByPrefix(env, [...mq.stripEnv || [], ...quantKeys]);
const quant = value.mmQuant != null ? value.mmQuant : derived && derived.mmQuant || "w4a8";
const opt = (mq.options || []).find(o => o.id === quant);
if (opt?.flags?.length) {
flags = h.insertAfter(flags, h.ANCHOR_NEAR_MOE, opt.flags);
}
if (opt?.env?.length) env = [...env, ...opt.env];
} else if (value.backend !== null) {
env = h.stripEnvByPrefix(env, quantKeys);
}
}
if (value.ep !== null) {
const epHead = h.flagSpelling(flags, h.EP_HEADS, "--ep");
flags = h.stripFlagsByFirstToken(flags, h.EP_HEADS);
if (value.ep > 1) {
flags = h.insertAfter(flags, h.ANCHOR_NEAR_MOE, [`${epHead} ${value.ep}`]);
}
}
return {
flags,
env
};
},
render: ({axisId, value, setValue, fc, base, s, renderSelect, derived}) => {
if (!fc.backend && !fc.ep) return null;
const setSlot = (k, v) => setValue({
...value,
[k]: v
});
const slotDisplay = k => {
const v = value[k];
if (v !== null && v !== undefined) return v;
if (derived && derived[k] !== undefined) return derived[k];
return null;
};
const hideNull = k => {
const d = derived ? derived[k] : null;
return d !== null && d !== undefined ? [null] : [];
};
const mmOpt = (fc.backend?.options || []).find(o => o.id === "megamoe");
const mmAvail = !!mmOpt && (!mmOpt.requiresHw || mmOpt.requiresHw.includes(base.hw)) && (!mmOpt.excludesStrategy || !mmOpt.excludesStrategy.includes(base.strategy));
const backendIsMega = slotDisplay("backend") === "megamoe";
const epShown = !!fc.ep && !(typeof fc.ep.showWhen === "function" && !fc.ep.showWhen(base));
return
MoE
{fc.backend &&
Backend
{renderSelect(slotDisplay("backend"), fc.backend.options || [], v => setSlot("backend", v), base, undefined, {
hideValues: [...hideNull("backend"), ...mmAvail ? [] : ["megamoe"]]
})}
}
{fc.megamoeQuant && backendIsMega && !(fc.megamoeQuant.hideHw || []).includes(base.hw) &&
Quantization
{renderSelect(value.mmQuant != null ? value.mmQuant : derived && derived.mmQuant || "w4a8", fc.megamoeQuant.options || [], v => setSlot("mmQuant", v), base)}
}
{epShown &&
{fc.ep.label || "EP"}
{renderSelect(slotDisplay("ep"), fc.ep.values || [null], v => setSlot("ep", v), base, undefined, {
hideValues: hideNull("ep")
})}
}
;
}
},
parsers: {
initState: fc => {
const out = {};
for (const item of fc.items || []) out[item.id] = null;
return out;
},
deriveFromBase: (cell, fc, h) => {
const flags = cell && cell.flags || [];
const out = {};
for (const item of fc.items || []) {
const prefix = item.flag.split(/[\s=]/)[0];
out[item.id] = h.hasFlag(flags, prefix);
}
return out;
},
apply: ({flags, env, value, fc, h, derived}) => {
const items = fc.items || [];
const eff = {};
const baseOf = {};
for (const item of items) {
baseOf[item.id] = derived ? !!derived[item.id] : false;
const v = value[item.id];
eff[item.id] = v === null || v === undefined ? baseOf[item.id] : v;
}
const anyOverride = items.some(it => eff[it.id] !== baseOf[it.id]);
if (!anyOverride) return {
flags,
env
};
flags = h.stripFlagsByFirstToken(flags, ["--reasoning-parser", "--tool-call-parser"]);
const adds = [];
for (const item of items) {
if (eff[item.id]) adds.push(item.flag);
}
if (adds.length) flags = h.insertBeforeTail(flags, adds);
return {
flags,
env
};
},
render: ({axisId, value, setValue, fc, base, s, h, renderChip, derived}) => {
const visible = (fc.items || []).map(item => ({
item,
c: h.evaluateChip(item, base)
})).filter(({c}) => !c.hidden);
if (visible.length === 0) return null;
const effOn = id => {
const v = value[id];
if (v !== null && v !== undefined) return v;
if (derived && derived[id] !== undefined) return derived[id];
return false;
};
return
Parsers
{visible.map(({item, c}) =>
{renderChip(item.label, effOn(item.id), true, () => setValue({
...value,
[item.id]: !effOn(item.id)
}), {
disabled: c.disabled,
disabledReason: c.disableReason
})}
)}
;
}
},
speculative: {
initState: () => "current",
deriveFromBase: (cell, fc) => {
const flags = cell && cell.flags || [];
const baseSpec = flags.filter(f => {
const head = f.split(/[\s=]/)[0];
return head === "--speculative-algorithm" || head === "--speculative-num-steps" || head === "--speculative-eagle-topk" || head === "--speculative-num-draft-tokens" || head === "--speculative-adaptive" || head === "--speculative-dspark-block-size" || head === "--enable-linear-replayssm-spec" || head === "--linear-replayssm-cache-len" || head === "--speculative-ngram-max-bfs-breadth";
});
if (baseSpec.length === 0) return "off";
for (const opt of fc.options || []) {
if (!opt.flags || opt.flags.length !== baseSpec.length) continue;
const ok = opt.flags.every(pf => baseSpec.includes(pf));
if (ok) return opt.id;
}
if (!cell.pd) return "current";
const algorithm = flags.find(f => f.startsWith("--speculative-algorithm "));
const algorithmOnly = (fc.options || []).find(opt => opt.flags && opt.flags.length === 1 && opt.flags[0] === algorithm);
return algorithmOnly ? algorithmOnly.id : "current";
},
apply: ({flags, env, value, fc, sel, h, derived}) => {
if (value === "current") return {
flags,
env
};
if (derived && value === derived) return {
flags,
env
};
const picked = (fc.options || []).find(p => p.id === value);
if (picked && h.evaluateChip(picked, {
...sel,
dpAttnOn: h.dpAttnOnIn(flags)
}).disabled) {
return {
flags,
env
};
}
flags = flags.filter(flag => {
const head = flag.split(/[\s=]/)[0];
return !head.startsWith("--speculative-") && !["--enable-linear-replayssm-spec", "--linear-replayssm-cache-len"].includes(head);
});
const preset = (fc.options || []).find(p => p.id === value);
if (preset?.flags?.length) flags = h.insertBeforeTail(flags, preset.flags);
return {
flags,
env
};
},
render: ({axisId, value, setValue, fc, base, s, h, renderChip, derived}) => {
const opts = fc.options || [];
if (!opts.length) return null;
const display = value !== "current" ? value : derived ? derived : "current";
const hideCurrent = !!(derived && derived !== "current");
const visible = opts.map(opt => h.evaluateChip(opt, base)).filter(c => !c.hidden && !(hideCurrent && c.value === "current"));
if (visible.length === 0) return null;
const note = (visible.find(c => c.value === display) || ({})).note;
return
Speculative
{visible.map(c =>
{renderChip(c.label, display, c.value, () => setValue(c.value), {
disabled: c.disabled,
disabledReason: c.disableReason
})}
)}
{note &&
{note}
}
;
}
},
pdDisagg: {
initState: (fc, base) => {
const visible = entries => (entries || []).filter(e => e && !(e.hide && base && matchConstraint(base, e.hide)));
const pick = entries => (entries || []).find(e => e && e.defaultWhen && base && matchConstraint(base, e.defaultWhen));
const backends = visible(fc && fc.transferBackends);
const cell = findCell(config.cells, base || ({}));
return {
mode: cell && cell.pd ? cell.pdMode : "off",
transferBackend: (pick(backends) || backends[0] || ({})).id || "mooncake",
ibDevice: (pick(visible(fc && fc.ibDevices)) || ({})).id || "auto"
};
},
apply: ({flags, env, value, sel, fc, h}) => {
const cell = findCell(config.cells, sel);
if (cell && cell.pd) {
const replace = (head, arg) => {
const line = arg ? `${head} ${arg}` : null;
const present = flags.some(f => f.split(/[\s=]/)[0] === head);
flags = flags.flatMap(f => f.split(/[\s=]/)[0] === head ? line ? [line] : [] : [f]);
if (!present && line) flags = h.insertBeforeTail(flags, [line]);
};
replace("--disaggregation-transfer-backend", value.transferBackend);
replace("--disaggregation-ib-device", value.ibDevice === "auto" ? null : value.ibDevice);
return {
flags,
env
};
}
const bootstrapPort = h.findFlagArg(flags, "--disaggregation-bootstrap-port");
flags = h.stripFlagsByFirstToken(flags, ["--disaggregation-mode", "--disaggregation-transfer-backend", "--disaggregation-ib-device", "--disaggregation-bootstrap-port"]);
const backends = fc.transferBackends || [];
const mode = (fc.modes || []).length ? value.mode : sel && sel.pdMode || "off";
if (mode === "prefill" || mode === "decode") {
const specAlgorithm = (h.findFlagArg(flags, "--speculative-algorithm") || "").toUpperCase();
if ((fc.incompatibleSpeculativeAlgorithms || []).includes(specAlgorithm)) {
flags = flags.filter(flag => !flag.split(/[\s=]/)[0].startsWith("--speculative-"));
}
const backend = value.transferBackend || (backends[0] || ({})).id || "mooncake";
const adds = [`--disaggregation-mode ${mode}`, `--disaggregation-transfer-backend ${backend}`];
if (bootstrapPort) {
adds.push(`--disaggregation-bootstrap-port ${bootstrapPort}`);
}
if (value.ibDevice && value.ibDevice !== "auto") {
adds.push(`--disaggregation-ib-device ${value.ibDevice}`);
}
const modeMeta = (fc.modes || []).find(m => m.id === mode);
const roleOverride = (fc.roleOverrides || []).find(r => r && r.mode === mode && r.when && h.matchConstraint(sel, r.when));
const roleSpec = roleOverride || modeMeta;
const modeGate = roleOverride ? null : modeMeta && modeMeta.when;
const modeOk = !modeGate || Object.keys(modeGate).every(k => (modeGate[k] || []).includes(sel[k]));
if (modeOk && roleSpec && roleSpec.flags && roleSpec.flags.length) {
const byHead = new Map();
for (const f of roleSpec.flags) {
const t = f.split(/[\s=]/)[0];
if (!byHead.has(t)) byHead.set(t, []);
byHead.get(t).push(f);
}
const consumed = new Set();
const next = [];
for (const f of flags) {
const t = f.split(/[\s=]/)[0];
if (!byHead.has(t)) {
next.push(f);
continue;
}
if (consumed.has(t)) continue;
consumed.add(t);
for (const r of byHead.get(t)) next.push(r);
}
flags = next;
for (const [t, fs] of byHead) {
if (!consumed.has(t)) adds.push(...fs);
}
}
if (modeOk && roleSpec && roleSpec.stripFlags && roleSpec.stripFlags.length) {
flags = h.stripFlagsByFirstToken(flags, roleSpec.stripFlags);
}
flags = h.insertBeforeTail(flags, adds);
const servePort = PD_PORTS[mode].serve;
flags = flags.map(f => f.split(/[\s=]/)[0] === "--port" ? `--port ${servePort}` : f);
if (modeOk && roleSpec && roleSpec.stripEnv && roleSpec.stripEnv.length) {
env = h.stripEnvByPrefix(env, roleSpec.stripEnv);
}
const meta = backends.find(b => b.id === backend);
const selectedEnv = backendEnv(meta, sel);
if (meta && selectedEnv.length) {
const gate = meta.envWhen;
const ok = !gate || Object.keys(gate).every(k => (gate[k] || []).includes(sel[k]));
if (ok) env = [...env, ...selectedEnv.filter(e => !env.includes(e))];
}
if (modeOk && roleSpec && roleSpec.env && roleSpec.env.length) {
env = [...env, ...roleSpec.env.filter(e => !env.includes(e))];
}
}
return {
flags,
env
};
},
getRenderHints: (value, fc, context) => {
const specAlgorithm = (context.h.findFlagArg(context.flags, "--speculative-algorithm") || "").toUpperCase();
if ((fc.incompatibleSpeculativeAlgorithms || []).includes(specAlgorithm)) {
return null;
}
const cell = findCell(config.cells, context.sel);
const mode = cell && cell.pd ? cell.pdMode : value.mode;
if (mode === "prefill" || mode === "decode") {
return {
pdMode: mode
};
}
return null;
},
render: ({axisId, value, setValue, fc, base, s, h, renderSelect}) => {
const setSlot = (k, v) => setValue({
...value,
[k]: v
});
const showModes = (fc.modes || []).length > 0 && !findCell(config.cells, base)?.pd;
const showBackends = (fc.transferBackends || []).length > 0;
const showIb = (fc.ibDevices || []).length > 0;
if (!showModes && !showBackends && !showIb) return null;
const note = (fc.notes || []).find(n => n && (!n.mode || [].concat(n.mode).includes(value.mode)) && h.matchConstraint(base, n.when));
return
PD Disagg
{showModes &&
Mode
{renderSelect(value.mode, fc.modes, v => setSlot("mode", v), base)}
}
{showBackends &&
Transfer Backend
{renderSelect(value.transferBackend, fc.transferBackends, v => setSlot("transferBackend", v), base)}
}
{showIb &&
IB Device
{renderSelect(value.ibDevice, fc.ibDevices, v => setSlot("ibDevice", v), base)}
}
{note &&
{note.text}
}
;
}
},
hisparse: {
initState: fc => ({
enable: false,
hostRatio: fc && fc.defaultHostRatio || null
}),
apply: ({flags, env, value, fc, h}) => {
const ownedHeads = ["--enable-hisparse", "--hisparse-config", ...(fc.requiredFlags || []).map(f => f.split(/\s/)[0])];
flags = h.stripFlagsByFirstToken(flags, ownedHeads);
const isDecode = flags.includes("--disaggregation-mode decode");
if (value.enable && isDecode) {
const ratio = value.hostRatio !== null && value.hostRatio !== undefined ? value.hostRatio : fc.defaultHostRatio || 10;
const cfg = {
...fc.config || ({}),
host_to_device_ratio: ratio
};
const adds = [...fc.requiredFlags || [], "--enable-hisparse", `--hisparse-config '${JSON.stringify(cfg)}'`];
flags = h.insertBeforeTail(flags, adds);
}
return {
flags,
env
};
},
render: ({axisId, value, setValue, fc, base, s, renderChip, renderSelect}) => {
if (base.pdMode !== "decode") return null;
const setSlot = (k, v) => setValue({
...value,
[k]: v
});
const hasRatios = (fc.hostRatios || []).length > 0;
return
HiSparse
{typeof fc.showWhen !== "function" &&
{renderChip("Enable", value.enable, true, () => setSlot("enable", !value.enable))}
}
{hasRatios &&
Host ratio
{renderSelect(value.hostRatio, fc.hostRatios, v => setSlot("hostRatio", v), base)}
}
;
}
},
hicache: {
initState: () => ({
enable: null,
backend: null,
writePolicy: "auto"
}),
deriveFromBase: (cell, fc, h) => {
const flags = cell && cell.flags || [];
return {
enable: h.hasFlag(flags, "--enable-hierarchical-cache"),
backend: h.findFlagArg(flags, "--hicache-storage-backend"),
writePolicy: h.findFlagArg(flags, "--hicache-write-policy") || "auto"
};
},
apply: ({flags, env, value, fc, sel, h, derived}) => {
if (fc.excludesHw && sel && fc.excludesHw.includes(sel.hw)) return {
flags,
env
};
if (typeof fc.showWhen === "function") {
const set = (name, val) => {
flags = h.stripFlagsByFirstToken(flags, [name]);
if (val) flags = h.insertBeforeTail(flags, [`${name} ${val}`]);
};
if (value.backend) set("--hicache-storage-backend", value.backend);
if (value.writePolicy && value.writePolicy !== "auto") {
set("--hicache-write-policy", value.writePolicy);
}
return {
flags,
env
};
}
const hasOverride = value.enable !== null || value.backend !== null || value.writePolicy && value.writePolicy !== "auto";
if (!hasOverride) return {
flags,
env
};
const backendOptions = fc.backends || [];
const ownedHeads = [...HICACHE_HEADS, ...(fc.requiredFlags || []).map(f => f.split(/\s/)[0]), ...backendOptions.flatMap(o => (o.flags || []).map(f => f.split(/\s/)[0]))];
const ownedEnvKeys = [...fc.requiredEnv || [], ...backendOptions.flatMap(o => o.env || [])].map(e => e.split("=")[0]);
flags = h.stripFlagsByFirstToken(flags, ownedHeads);
if (ownedEnvKeys.length) env = h.stripEnvByPrefix(env, ownedEnvKeys);
const enabled = value.enable !== null ? value.enable : !!(derived && derived.enable);
const backend = value.backend !== null ? value.backend : derived && derived.backend || fc.defaultBackend || null;
if (enabled) {
const isAmd = sel && (/^mi\d/).test(sel.hw);
const pdMode = h.findFlagArg(flags, "--disaggregation-mode") || "off";
const pdBackend = h.findFlagArg(flags, "--disaggregation-transfer-backend");
const roleOverride = (fc.roleOverrides || []).find(item => {
if (!item || item.mode !== pdMode) return false;
if (item.transferBackend && item.transferBackend !== pdBackend) return false;
return !item.when || h.matchConstraint(sel, item.when);
});
const amdIo = roleOverride || isAmd && fc.amdIo;
const ratio = amdIo && amdIo.ratio || 2;
const useAmdIo = isAmd && amdIo;
const adds = ["--enable-hierarchical-cache", `--hicache-ratio ${ratio}`];
if (!useAmdIo) {
adds.push("--hicache-size 0");
}
if (useAmdIo) {
adds.push(`--hicache-mem-layout ${amdIo.memLayout}`, `--hicache-io-backend ${amdIo.ioBackend}`);
} else if (backend) {
adds.push("--hicache-mem-layout page_first_direct", "--hicache-io-backend direct");
}
const writePolicy = value.writePolicy && value.writePolicy !== "auto" ? value.writePolicy : amdIo && amdIo.writePolicy || "write_through";
adds.push(`--hicache-write-policy ${writePolicy}`);
if (isAmd && fc.amdStorageFileOnly ? backend === "file" : !!backend) {
adds.push(`--hicache-storage-backend ${backend}`, `--hicache-storage-prefetch-policy ${amdIo && amdIo.prefetchPolicy || "wait_complete"}`);
} else if (amdIo && amdIo.prefetchPolicy) {
adds.push(`--hicache-storage-prefetch-policy ${amdIo.prefetchPolicy}`);
}
const backendOption = backendOptions.find(o => o.id === backend);
adds.push(...backendOption?.flags || [], ...fc.requiredFlags || []);
flags = h.insertBeforeTail(flags, adds);
env = [...env, ...backendOption?.env || [], ...fc.requiredEnv || []];
}
return {
flags,
env
};
},
render: ({axisId, value, setValue, fc, base, s, renderChip, renderSelect, derived}) => {
if (fc.excludesHw && fc.excludesHw.includes(base.hw)) return null;
const setSlot = (k, v) => setValue({
...value,
[k]: v
});
const hasBackends = (fc.backends || []).length > 0;
const hasPolicies = (fc.writePolicies || []).length > 0;
const enabled = value.enable !== null ? value.enable : !!(derived && derived.enable);
const hasAutoBackend = (fc.backends || []).some(o => o.id === null);
const backend = value.backend !== null ? value.backend : hasAutoBackend ? null : derived && derived.backend || fc.defaultBackend || null;
const writePolicy = value.writePolicy !== "auto" ? value.writePolicy : derived && derived.writePolicy || "auto";
return
HiCache
{typeof fc.showWhen !== "function" &&
{renderChip("Enable", enabled, true, () => setSlot("enable", !enabled))}
}
{hasBackends &&
Storage
{renderSelect(backend, fc.backends, v => setSlot("backend", v), base)}
}
{hasPolicies &&
Write
{renderSelect(writePolicy, fc.writePolicies, v => setSlot("writePolicy", v), base)}
}
;
}
},
umbp: {
initState: () => ({
enable: null,
backend: null
}),
deriveFromBase: (cell, fc, h) => {
const flags = cell && cell.flags || [];
return {
enable: h.hasFlag(flags, "--enable-unified-cache-external-linker"),
backend: h.findFlagArg(flags, "--unified-cache-external-linker-backend")
};
},
apply: ({flags, env, value, fc, sel, h, derived}) => {
const roleOverride = umbpRoleOverride(fc, sel, h);
const inherited = derived && derived.enable && findCell(config.cells, sel)?.pd;
const ownsOptimisticPrefill = inherited || exclusiveGroupsFor("umbp", sel).length > 0;
if (inherited && value.enable !== false && (value.backend === null || value.backend === derived.backend) && h.hasFlag(flags, "--enable-unified-cache-external-linker") && !h.hasFlag(flags, "--enable-hierarchical-cache")) return {
flags,
env
};
const linkerConfig = h.findFlagArg(flags, "--hicache-storage-backend-extra-config");
const optimisticPrefill = h.findFlagArg(flags, "--optimistic-prefill-attempts");
const ownedHeads = [...inherited ? ["--hicache-storage-backend-extra-config"] : [], ...ownsOptimisticPrefill ? ["--optimistic-prefill-attempts"] : [], "--enable-unified-cache-external-linker", "--unified-cache-external-linker-backend", ...(fc.requiredFlags || []).map(f => f.split(/\s/)[0])];
flags = h.stripFlagsByFirstToken(flags, ownedHeads);
const ownedEnv = [...fc.requiredEnv || [], ...roleOverride && roleOverride.env || []];
const standalone = env.find(e => e.startsWith("UMBP_STANDALONE_ADDRESS="));
if (inherited && standalone) ownedEnv.push(standalone);
if (ownedEnv.length) {
env = h.stripEnvByPrefix(env, ownedEnv.map(e => e.split("=")[0]));
}
const enabled = value.enable !== null ? value.enable : roleOverride ? !!roleOverride.enable : !!(derived && derived.enable);
if (!enabled) return {
flags,
env
};
if (fc.onlyHw && sel && !fc.onlyHw.includes(sel.hw)) return {
flags,
env
};
if (fc.requiresDpAttention && !(roleOverride && roleOverride.allowTp) && !h.dpAttnOnIn(flags)) {
return {
flags,
env
};
}
flags = h.stripFlagsByFirstToken(flags, HICACHE_HEADS);
const backend = value.backend || derived && derived.backend || fc.defaultBackend || "mori";
flags = h.insertBeforeTail(flags, ["--enable-unified-cache-external-linker", `--unified-cache-external-linker-backend ${backend}`, ...fc.requiredFlags || [], ...roleOverride && roleOverride.flags || [], ...ownsOptimisticPrefill && optimisticPrefill ? [`--optimistic-prefill-attempts ${optimisticPrefill}`] : [], ...inherited && backend === "mori" && linkerConfig ? [`--hicache-storage-backend-extra-config ${linkerConfig}`] : []]);
const extraEnv = [...fc.requiredEnv || [], ...roleOverride && roleOverride.env || []];
if (inherited && backend === "mori" && standalone) extraEnv.push(standalone);
env = [...env, ...extraEnv.filter(e => !env.includes(e))];
return {
flags,
env
};
},
render: ({axisId, value, setValue, fc, base, s, h, renderChip, renderSelect, derived}) => {
if (fc.onlyHw && !fc.onlyHw.includes(base.hw)) return null;
const setSlot = (k, v) => setValue({
...value,
[k]: v
});
const roleOverride = umbpRoleOverride(fc, base, h);
const enabled = value.enable !== null ? value.enable : roleOverride ? !!roleOverride.enable : !!(derived && derived.enable);
const needsDp = !!fc.requiresDpAttention && !base.dpAttnOn && !(roleOverride && roleOverride.allowTp);
const backend = value.backend !== null ? value.backend : derived && derived.backend || fc.defaultBackend || "mori";
return
{}
Unified Cache External Linker
{renderChip("Enable", enabled, true, () => setSlot("enable", !enabled), {
disabled: needsDp,
disabledReason: needsDp ? "Needs DP Attention — the linker keyspace is per DP rank, so under pure TP the store holds one copy per TP rank." : ""
})}
{(fc.backends || []).length > 0 &&
Backend
{renderSelect(backend, fc.backends, v => setSlot("backend", v), base)}
}
{enabled && !needsDp && roleOverride && roleOverride.note &&
{roleOverride.note}
}
;
}
},
flagSelects: {
initState: (fc, base) => {
const out = {};
for (const spec of fc || []) {
const d = typeof spec.default === "function" ? spec.default(base) : spec.default;
out[spec.id] = d ?? null;
}
return out;
},
deriveFromBase: (cell, fc) => {
const flags = cell && cell.flags || [];
const out = {};
for (const spec of fc || []) {
const prefixes = spec.stripPrefixes || [];
const fam = flags.filter(f => prefixes.includes(f.split(/[\s=]/)[0]));
let hit = null;
for (const opt of spec.options || []) {
if (typeof opt.flags === "function") continue;
const of = opt.flags || [];
if (of.length === fam.length && of.every(x => fam.includes(x))) {
hit = opt.id;
break;
}
}
out[spec.id] = hit;
}
return out;
},
apply: ({flags, env, value, fc, sel, h, derived}) => {
const evalBase = {
...sel || ({}),
dpAttnOn: h.dpAttnOnIn(flags),
pdMode: h.findFlagArg(flags, "--disaggregation-mode") || "off"
};
for (const spec of fc || []) {
if (typeof spec.showWhen === "function" && !spec.showWhen(sel, value, derived)) continue;
const v = value ? value[spec.id] : null;
if (v === null || v === undefined) continue;
const d = derived ? derived[spec.id] : null;
if (v === d) continue;
const opt = (spec.options || []).find(o => o.id === v);
if (!opt) continue;
if (h.evaluateChip(opt, evalBase).disabled) continue;
const optFlags = typeof opt.flags === "function" ? opt.flags(value, evalBase) : opt.flags || [];
if (optFlags === null) continue;
const strip = new Set(spec.stripPrefixes || []);
const byTok = new Map();
for (const f of optFlags) {
const t = f.split(/[\s=]/)[0];
if (!byTok.has(t)) byTok.set(t, []);
byTok.get(t).push(f);
}
const consumed = new Set();
const next = [];
for (const f of flags) {
const t = f.split(/[\s=]/)[0];
if (byTok.has(t)) {
if (!consumed.has(t)) {
next.push(...byTok.get(t));
consumed.add(t);
}
} else if (!strip.has(t)) {
next.push(f);
}
}
const fresh = [];
for (const [t, fs] of byTok) {
if (!consumed.has(t)) fresh.push(...fs);
}
flags = fresh.length ? h.insertBeforeTail(next, fresh) : next;
const envKeys = [...spec.stripEnv || []];
for (const o of spec.options || []) {
for (const e of o.env || []) envKeys.push(e.split("=")[0]);
}
if (envKeys.length) env = h.stripEnvByPrefix(env, envKeys);
if (opt.env && opt.env.length) env = [...env, ...opt.env];
}
return {
flags,
env
};
},
render: ({axisId, value, setValue, fc, base, s, h, renderChip, derived}) => {
const cards = [];
for (const spec of fc || []) {
if (typeof spec.showWhen === "function" && !spec.showWhen(base, value, derived)) continue;
const opts = (spec.options || []).map(o => h.evaluateChip(o, base)).filter(c => !c.hidden);
if (!opts.length) continue;
const explicit = value ? value[spec.id] : null;
const display = explicit !== null && explicit !== undefined ? explicit : derived ? derived[spec.id] : null;
if (spec.control === "slider") {
const idx = Math.max(0, opts.findIndex(c => c.value === display));
const cur = opts[idx];
cards.push();
continue;
}
cards.push(
{spec.title}
{opts.map(c =>
{renderChip(c.label, display, c.value, () => setValue({
...value,
[spec.id]: c.value
}), {
disabled: c.disabled,
disabledReason: c.disableReason
})}
)}
);
}
return cards.length ? cards : null;
}
}
};
const applyAllDeltas = (baseFlags, baseEnv, allDeltas, sel, derivedMap) => {
let flags = [...baseFlags];
let env = [...baseEnv || []];
let pdMode = null;
const pdFc = pgFeatures.pdDisagg;
const pdDelta = allDeltas.pdDisagg;
const resolvedCell = findCell(config.cells, sel);
const pdRoleSel = resolvedCell && resolvedCell.pd ? resolvedCell.pdMode : pdFc && (pdFc.modes || []).length && pdDelta ? pdDelta.mode : sel && sel.pdMode || "off";
for (const [axisId, handler] of Object.entries(AXIS_HANDLERS)) {
const fc = pgFeatures[axisId];
if (!fc) continue;
const value = allDeltas[axisId];
if (value === undefined) continue;
const derived = derivedMap ? derivedMap[axisId] : null;
const specAlgorithm = (findFlagArg(flags, "--speculative-algorithm") || "").toUpperCase() || null;
const liveSel = {
...sel,
specAlgorithm,
pdMode: pdRoleSel,
workerNnodes: resolvedCell?.nnodes ?? parseNnodes(sel.nodes)
};
const out = handler.apply({
flags,
env,
value,
fc,
sel: liveSel,
h: helpers,
derived
});
flags = out.flags;
env = out.env;
if (handler.getRenderHints) {
const hints = handler.getRenderHints(value, fc, {
flags,
env,
sel: liveSel,
h: helpers
}) || ({});
if (hints.pdMode) pdMode = hints.pdMode;
}
}
return {
flags,
env,
pdMode
};
};
const renderCommandLines = (cell, flags, cellEnv, sel, envValues, pdMode = null, mode = "python") => {
const modelName = resolveModelName(sel);
if (cell.pd && cell.commands) return interpolate(cell.commands[mode] || cell.commands.python, envValues, modelName);
pdMode = cell.pd ? cell.pdMode : pdMode;
let f = [...flags];
const nnodesFlag = f.find(x => x.split(/[\s=]/)[0] === "--nnodes");
const nnodesMatch = nnodesFlag && (/^--nnodes(?:\s+|=)(\d+)$/).exec(nnodesFlag.trim());
const baseNnodes = cell && cell.pd ? cell.nnodes || 1 : sel.nodes !== undefined ? parseNnodes(sel.nodes) : cell && cell.nnodes || 1;
const nnodes = nnodesMatch ? parseInt(nnodesMatch[1], 10) : baseNnodes;
const multinode = nnodes > 1;
if (multinode && !f.some(x => x.startsWith("--nnodes"))) {
const PARALLELISM_ANCHORS = [...ATTN_DP_HEADS, "--dp-size", "--dp", "--tp-size", "--tp"];
let at = -1;
for (const anchor of PARALLELISM_ANCHORS) {
at = f.findIndex(x => x.split(/[\s=]/)[0] === anchor);
if (at !== -1) break;
}
if (at === -1) at = f.findIndex(x => x.startsWith("--model-path"));
const distPort = pdMode && PD_PORTS[pdMode] ? PD_PORTS[pdMode].dist : 20000;
f.splice(at + 1, 0, `--nnodes ${nnodes}`, `--node-rank {{NODE_RANK}}`, `--dist-init-addr {{NODE0_IP}}:${distPort}`);
}
let cmd;
if (mode === "docker") {
const di = config.dockerImages || ({});
const image = cell.pd && cell.dockerImage || di[`${sel.hw}|${sel.variant}|${sel.quant}`] || di[`${sel.variant}|${sel.quant}`] || di[`${sel.hw}|${sel.quant}|${sel.strategy}`] || di[`${sel.hw}|${sel.quant}`] || di[sel.hw] || "lmsysorg/sglang:dev";
const dockerRunCommand = typeof config.dockerRunCommand === "function" ? config.dockerRunCommand(sel) : config.dockerRunCommand || "sglang serve";
const portFlag = f.find(x => x.split(/[\s=]/)[0] === "--port");
const servePort = portFlag ? portFlag.slice(("--port").length).trim() : "{{PORT}}";
const hostNetwork = multinode || pdMode || typeof config.dockerHostNetworkWhen === "function" && config.dockerHostNetworkWhen(sel, {
flags: f,
env: cellEnv
});
const AMD_RDMA_DOCKER_FLAGS = ["--device /dev/infiniband", "--cap-add IPC_LOCK", "--ulimit memlock=-1", "--ulimit stack=67108864", "--ulimit nofile=1048576:1048576"];
const HW_MULTINODE_DOCKER_FLAGS = {
"dgx-spark": ["--ulimit memlock=-1:-1", "--cap-add IPC_LOCK", "--device /dev/infiniband"],
mi300x: AMD_RDMA_DOCKER_FLAGS,
mi325x: AMD_RDMA_DOCKER_FLAGS,
mi350x: AMD_RDMA_DOCKER_FLAGS,
mi355x: AMD_RDMA_DOCKER_FLAGS
};
const fabricFlags = HW_MULTINODE_DOCKER_FLAGS[sel.hw] || [];
const isAmdHw = (/^mi\d/).test(sel.hw || "");
const HW_NPU_DEVICES = {
a3: 16,
a5: 8
};
const npuDevices = HW_NPU_DEVICES[sel.hw];
const davinciLines = devices => {
const lines = [];
for (let i = 0; i < devices; i += 4) {
const group = [];
for (let k = i; k < Math.min(i + 4, devices); k++) {
group.push(`--device=/dev/davinci${k}`);
}
lines.push(" " + group.join(" "));
}
return lines;
};
const dockerLines = [...isAmdHw ? ["docker run", " --device=/dev/kfd --device=/dev/dri", " --group-add video", " --cap-add=SYS_PTRACE --security-opt seccomp=unconfined", " --shm-size 32g"] : npuDevices ? ["docker run --privileged --shm-size=16g", ...davinciLines(npuDevices), " --device=/dev/davinci_manager", " --device=/dev/hisi_hdc", " -v /usr/local/sbin:/usr/local/sbin", " -v /usr/local/Ascend/driver:/usr/local/Ascend/driver", " -v /usr/local/Ascend/firmware:/usr/local/Ascend/firmware", " -v /etc/ascend_install.info:/etc/ascend_install.info", " -v /var/queue_schedule:/var/queue_schedule", " -v ~/.cache/:/root/.cache/"] : ["docker run --gpus all", " --shm-size 32g"], hostNetwork ? " --network host" : ` -p ${servePort}:${servePort}`, ...multinode || pdMode ? fabricFlags.map(x => " " + x) : [], ...npuDevices ? [] : [" -v ~/.cache/huggingface:/root/.cache/huggingface"], ...[...config.dockerMounts || [], ...cell.pd ? cell.dockerMounts || [] : []].map(mount => ` -v ${mount}`), ` --env "HF_TOKEN={{HF_TOKEN}}"`, ...cellEnv.map(e => ` --env ${e}`), " --ipc=host", ` ${image}`, ` ${dockerRunCommand}`, ...f.map(x => " " + x)];
cmd = dockerLines.join(" \\\n");
} else {
const flagBlock = f.map(x => " " + x).join(" \\\n");
const envBlock = cellEnv.length ? cellEnv.join(" \\\n") + " \\\n" : "";
cmd = `${envBlock}sglang serve \\\n${flagBlock}`;
}
const cellHints = (cell.pd ? cell.hints || [] : []).filter(() => f.some(x => x === "--enable-unified-cache-external-linker"));
if (cellHints.length) cmd = cellHints.map(line => "# " + line).join("\n") + "\n" + cmd;
if (multinode && config.multiNodeHints && config.multiNodeHints[sel.hw]) {
const hint = config.multiNodeHints[sel.hw].map(line => line.length ? "# " + line : "#").join("\n");
cmd = `${hint}\n${cmd}`;
}
cmd = interpolate(cmd, envValues, modelName);
if (multinode) {
const header = `# Multi-node (${nnodes} nodes). Run the same command on every node with:\n` + `# = 0 on the head node, 1..${nnodes - 1} on the others\n` + `# = IP of the head node (reachable from all others)`;
cmd = `${header}\n${cmd}`;
}
if (!cell.pd && (pdMode === "prefill" || pdMode === "decode")) {
const sibling = pdMode === "prefill" ? "decode" : "prefill";
const routerCfg = resolveRouter(config.playgroundFeatures && config.playgroundFeatures.pdDisagg, sel);
const routerPort = routerCfg && routerCfg.port || 8000;
const routerLine = routerCfg ? `# then front BOTH with the Router shown below.\n` + `# Client traffic (cURL) targets the router (:${routerPort}), not this role server.` : `# then front BOTH with a router; client traffic targets the router, not this role server.`;
const hicacheCfg = config.playgroundFeatures && config.playgroundFeatures.hicache;
const pdBackend = findFlagArg(f, "--disaggregation-transfer-backend");
const hicacheEnabled = f.some(x => x === "--enable-hierarchical-cache");
const hicacheNotice = hicacheEnabled && hicacheCfg ? (hicacheCfg.notices || []).find(item => {
if (!item || item.mode !== pdMode) return false;
if (item.transferBackend && item.transferBackend !== pdBackend) return false;
return !item.when || matchConstraint(sel, item.when);
}) : null;
const noticeLine = hicacheNotice && hicacheNotice.text ? `# Note: ${hicacheNotice.text}\n` : "";
const banner = `# === PD Disaggregation: ${pdMode.toUpperCase()} role ===\n` + noticeLine + `# Runs the ${pdMode} server. Also run the ${sibling} role on its peer host,\n` + routerLine;
cmd = `${banner}\n${cmd}`;
}
return cmd;
};
const computeDiff = (baseStr, pgStr) => {
const a = baseStr.split("\n");
const b = pgStr.split("\n");
const m = a.length, n = b.length;
const dp = Array(m + 1).fill(null).map(() => new Array(n + 1).fill(0));
for (let i = 1; i <= m; i++) {
for (let j = 1; j <= n; j++) {
if (a[i - 1] === b[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1; else dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
}
}
const out = [];
let i = m, j = n;
while (i > 0 || j > 0) {
if (i > 0 && j > 0 && a[i - 1] === b[j - 1]) {
out.unshift({
line: a[i - 1],
kind: "unchanged"
});
i--;
j--;
} else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
out.unshift({
line: b[j - 1],
kind: "added"
});
j--;
} else {
out.unshift({
line: a[i - 1],
kind: "removed"
});
i--;
}
}
return out;
};
const serializeCell = (sel, env, flags) => {
const matchEntries = [`hw: ${JSON.stringify(sel.hw)}`, `variant: ${JSON.stringify(sel.variant)}`, `quant: ${JSON.stringify(sel.quant)}`, `strategy: ${JSON.stringify(sel.strategy)}`, `nodes: ${JSON.stringify(sel.nodes)}`].join(", ");
const fmtList = items => {
if (!items || items.length === 0) return "[]";
const lines = items.map(s => ` ${JSON.stringify(s)},`).join("\n");
return `[\n${lines}\n ]`;
};
return [" {", ` match: { ${matchEntries} },`, " verified: true,", ` env: ${fmtList(env)},`, ` flags: ${fmtList(flags)},`, " },"].join("\n");
};
const buildSubmitUrl = (sel, fields) => {
const gh = config.github || ({});
const owner = gh.owner || "sgl-project";
const repo = gh.repo || "sglang";
const tmpl = gh.issueTemplate || "3-playground-verified-cell.yml";
const cookbookModel = gh.cookbookModel || "deepseek-ai/deepseek-v4";
const combo = `${sel.hw} / ${sel.variant} / ${sel.quant} / ${sel.strategy} / ${sel.nodes}`;
const params = new URLSearchParams({
template: tmpl,
title: `[Playground] Verified cell: ${combo}`,
model: cookbookModel,
combination: combo,
"cell-snippet": fields.cellSnippet || "",
"existing-cell": fields.existingCell || "",
"sglang-version": fields.sglangVersion || "",
"bench-result": fields.benchResult || "",
notes: fields.notes || ""
});
return `https://github.com/${owner}/${repo}/issues/new?${params.toString()}`;
};
const makeStyles = isDark => ({
container: {
maxWidth: "900px",
margin: "0 auto",
display: "flex",
flexDirection: "column",
gap: "6px"
},
card: {
padding: "6px 10px",
border: `1px solid ${isDark ? "#374151" : "#e5e7eb"}`,
borderLeft: `3px solid ${isDark ? "#FDBA74" : "#FB923C"}`,
borderRadius: "4px",
background: isDark ? "#1f2937" : "#fff"
},
cardStack: {
display: "flex",
flexDirection: "column",
gap: "6px"
},
baseStrip: {
padding: "8px 12px",
borderRadius: "4px",
background: isDark ? "#064e3b" : "#d1fae5",
color: isDark ? "#a7f3d0" : "#065f46",
fontSize: "12px",
display: "flex",
alignItems: "center",
gap: "10px"
},
title: {
fontSize: "13px",
fontWeight: "600",
color: isDark ? "#e5e7eb" : "inherit",
marginBottom: "8px"
},
compactRow: {
display: "flex",
flexWrap: "wrap",
alignItems: "center",
gap: "10px",
rowGap: "4px"
},
axisTitle: {
fontSize: "12px",
fontWeight: 700,
color: isDark ? "#FDBA74" : "#C2410C",
letterSpacing: "0.02em",
minWidth: "100px",
flexShrink: 0
},
field: {
display: "inline-flex",
alignItems: "center",
gap: "4px"
},
fieldLabel: {
fontSize: "11px",
fontWeight: 500,
color: isDark ? "#9ca3af" : "#6b7280"
},
select: {
padding: "2px 6px",
border: `1px solid ${isDark ? "#4b5563" : "#d1d5db"}`,
borderRadius: "3px",
fontSize: "12px",
background: isDark ? "#111827" : "#fff",
color: isDark ? "#e5e7eb" : "#111827",
cursor: "pointer",
lineHeight: "1.4"
},
rowFlex: {
display: "flex",
flexWrap: "wrap",
gap: "6px",
alignItems: "center",
flex: 1
},
subRow: {
display: "flex",
alignItems: "center",
gap: "10px"
},
subLabel: {
fontSize: "11px",
fontWeight: 600,
color: isDark ? "#9ca3af" : "#6b7280",
minWidth: "96px",
flexShrink: 0,
letterSpacing: "0.02em"
},
chipRow: {
display: "flex",
flexWrap: "wrap",
gap: "6px",
flex: 1
},
chip: {
padding: "3px 9px",
border: `1px solid ${isDark ? "#9ca3af" : "#d1d5db"}`,
borderRadius: "3px",
cursor: "pointer",
fontSize: "12px",
userSelect: "none",
background: isDark ? "#374151" : "#fff",
color: isDark ? "#e5e7eb" : "inherit",
textAlign: "center"
},
chipChecked: {
background: "#D45D44",
color: "white",
borderColor: "#D45D44"
},
chipDisabled: {
cursor: "not-allowed",
opacity: 0.4
},
commandWrap: {
position: "relative",
background: isDark ? "#111827" : "#f5f5f5",
borderRadius: "6px",
border: `1px solid ${isDark ? "#374151" : "#e5e7eb"}`,
overflow: "hidden"
},
commandHeader: {
display: "flex",
flexWrap: "wrap",
justifyContent: "space-between",
alignItems: "center",
gap: "6px 10px",
padding: "6px 10px",
borderBottom: `1px solid ${isDark ? "#374151" : "#e5e7eb"}`,
background: isDark ? "#1f2937" : "#fafafa"
},
commandPre: {
padding: "12px 16px",
fontFamily: "'Menlo', 'Monaco', 'Courier New', monospace",
fontSize: "12px",
lineHeight: "1.5",
color: isDark ? "#e5e7eb" : "#374151",
whiteSpace: "pre-wrap",
overflowX: "auto",
margin: 0
},
axisNote: {
margin: "6px 0 0",
padding: "6px 10px",
borderRadius: "6px",
fontSize: "11px",
lineHeight: "1.45",
background: isDark ? "#78350f" : "#fef3c7",
color: isDark ? "#fde68a" : "#92400e",
border: `1px solid ${isDark ? "#92400e" : "#fcd34d"}`
},
mtpWarn: {
margin: "8px 0 0",
padding: "8px 12px",
borderRadius: "8px",
fontSize: "12px",
lineHeight: "1.45",
background: isDark ? "#78350f" : "#fef3c7",
color: isDark ? "#fde68a" : "#92400e",
border: `1px solid ${isDark ? "#92400e" : "#fcd34d"}`
},
diffLineUnchanged: {
display: "block"
},
diffLineAdded: {
display: "block",
background: isDark ? "rgba(16,185,129,0.15)" : "rgba(16,185,129,0.18)",
color: isDark ? "#a7f3d0" : "#065f46",
borderLeft: `3px solid #10b981`,
paddingLeft: "8px",
marginLeft: "-8px"
},
diffLineRemoved: {
display: "block",
background: isDark ? "rgba(239,68,68,0.10)" : "rgba(239,68,68,0.10)",
color: isDark ? "#fca5a5" : "#991b1b",
textDecoration: "line-through",
opacity: 0.7,
borderLeft: `3px solid #ef4444`,
paddingLeft: "8px",
marginLeft: "-8px"
},
badge: verified => ({
display: "inline-flex",
alignItems: "center",
gap: "6px",
padding: "2px 8px",
borderRadius: "10px",
background: verified ? isDark ? "#064e3b" : "#d1fae5" : isDark ? "#78350f" : "#fef3c7",
color: verified ? isDark ? "#a7f3d0" : "#065f46" : isDark ? "#fde68a" : "#92400e",
fontSize: "11px",
fontWeight: 600
}),
badgeDot: verified => ({
width: "8px",
height: "8px",
borderRadius: "50%",
background: verified ? "#10b981" : "#f59e0b"
}),
iconButton: {
padding: "4px 10px",
border: `1px solid ${isDark ? "#4b5563" : "#d1d5db"}`,
borderRadius: "4px",
background: isDark ? "#1f2937" : "#fff",
color: isDark ? "#e5e7eb" : "#374151",
fontSize: "11px",
fontWeight: 500,
cursor: "pointer",
display: "inline-flex",
alignItems: "center",
gap: "4px"
},
iconRow: {
display: "inline-flex",
flexWrap: "wrap",
gap: "6px"
},
runModeWrap: {
display: "inline-flex",
border: `1px solid ${isDark ? "#4b5563" : "#d1d5db"}`,
borderRadius: "10px",
overflow: "hidden",
fontSize: "11px",
fontWeight: 600,
userSelect: "none"
},
runModeChip: active => ({
padding: "2px 10px",
cursor: "pointer",
background: active ? isDark ? "#1f2937" : "#fff" : "transparent",
color: active ? isDark ? "#e5e7eb" : "#111827" : isDark ? "#9ca3af" : "#6b7280",
borderRight: `1px solid ${isDark ? "#4b5563" : "#d1d5db"}`
}),
runModeChipLast: active => ({
padding: "2px 10px",
cursor: "pointer",
background: active ? isDark ? "#1f2937" : "#fff" : "transparent",
color: active ? isDark ? "#e5e7eb" : "#111827" : isDark ? "#9ca3af" : "#6b7280"
}),
headerLeft: {
display: "inline-flex",
flexWrap: "wrap",
alignItems: "center",
gap: "8px"
},
dialog: {
background: isDark ? "#1f2937" : "#fff",
color: isDark ? "#e5e7eb" : "#111827",
borderRadius: "8px",
padding: "20px",
maxWidth: "720px",
width: "92%",
maxHeight: "calc(100vh - 80px)",
overflowY: "auto",
border: `1px solid ${isDark ? "#374151" : "#e5e7eb"}`,
boxShadow: "0 10px 25px rgba(0,0,0,0.25)",
margin: "auto"
},
modalHeader: {
display: "flex",
justifyContent: "space-between",
alignItems: "center",
marginBottom: "12px"
},
modalTitle: {
fontSize: "15px",
fontWeight: 600
},
modalCloseBtn: {
background: "transparent",
border: "none",
color: "inherit",
fontSize: "20px",
cursor: "pointer",
padding: "0 6px",
lineHeight: 1
},
formField: {
display: "flex",
flexDirection: "column",
gap: "4px",
marginBottom: "10px"
},
formLabel: {
fontSize: "12px",
fontWeight: 500,
color: isDark ? "#9ca3af" : "#4b5563"
},
formInput: {
padding: "6px 10px",
fontSize: "13px",
border: `1px solid ${isDark ? "#4b5563" : "#d1d5db"}`,
borderRadius: "4px",
background: isDark ? "#111827" : "#fff",
color: isDark ? "#e5e7eb" : "#111827",
fontFamily: "'Menlo', 'Monaco', 'Courier New', monospace"
},
sectionHeading: {
fontSize: "12px",
fontWeight: 600,
textTransform: "uppercase",
letterSpacing: "0.04em",
color: isDark ? "#9ca3af" : "#6b7280",
margin: "12px 0 6px 0"
},
primaryBtn: {
padding: "6px 14px",
background: isDark ? "#FDBA74" : "#FB923C",
color: isDark ? "#7C2D12" : "white",
border: "none",
borderRadius: "4px",
cursor: "pointer",
fontSize: "13px",
fontWeight: 500
},
resetBtn: {
marginLeft: "auto",
padding: "2px 8px",
fontSize: "11px",
border: `1px solid ${isDark ? "#4b5563" : "#d1d5db"}`,
borderRadius: "3px",
background: "transparent",
color: isDark ? "#9ca3af" : "#6b7280",
cursor: "pointer"
},
switchBaseBtn: {
padding: "2px 8px",
fontSize: "11px",
fontWeight: 600,
border: `1px solid ${isDark ? "#FDBA74" : "#FB923C"}`,
borderRadius: "3px",
background: "transparent",
color: isDark ? "#FDBA74" : "#C2410C",
cursor: "pointer"
},
matchedHint: {
fontSize: "11px",
color: isDark ? "#9ca3af" : "#6b7280",
marginLeft: "8px",
display: "inline-flex",
alignItems: "center",
gap: "4px"
},
matchedSwitchBtn: {
marginLeft: "4px",
background: "transparent",
border: "none",
padding: 0,
color: isDark ? "#FDBA74" : "#C2410C",
cursor: "pointer",
fontSize: "11px",
fontWeight: 600,
textDecoration: "underline",
textUnderlineOffset: "2px"
}
});
const [isDark, setIsDark] = useState(false);
useEffect(() => {
const check = () => {
const html = document.documentElement;
setIsDark(html.classList.contains("dark") || html.getAttribute("data-theme") === "dark" || html.style.colorScheme === "dark");
};
check();
const observer = new MutationObserver(check);
observer.observe(document.documentElement, {
attributes: true,
attributeFilter: ["class", "data-theme", "style"]
});
return () => observer.disconnect();
}, []);
const [env, setEnv] = useState(() => placeholderDefaults(config.placeholders));
useEffect(() => {
try {
const raw = window.localStorage.getItem(STORAGE_KEY);
if (raw) {
const parsed = JSON.parse(raw);
setEnv({
...placeholderDefaults(config.placeholders),
...parsed
});
}
} catch {}
}, []);
const saveEnv = next => {
setEnv(next);
try {
window.localStorage.setItem(STORAGE_KEY, JSON.stringify(next));
} catch {}
};
const overlayDefaults = () => {
const out = {};
for (const d of config.overlayDims || []) {
const opts = d.options || [];
out[d.id] = d.default !== undefined ? d.default : opts[0] && opts[0].id || "";
}
return out;
};
const baseFallback = () => ({
...config.cells[0].match,
...overlayDefaults()
});
const initialBaseFromHash = () => {
const fallback = baseFallback();
if (typeof window === "undefined") return {
...fallback
};
const raw = window.location.hash.replace(/^#/, "");
if (!raw) return {
...fallback
};
const params = new URLSearchParams(raw);
const out = {
...fallback
};
params.forEach((value, key) => {
if ((key in out)) out[key] = value;
});
return out;
};
const [base, setBase] = useState(() => initialBaseFromHash());
useEffect(() => {
const onHash = () => setBase(initialBaseFromHash());
const onSelEvent = e => {
const fallback = baseFallback();
const incoming = e && e.detail || ({});
const next = {
...fallback
};
for (const k of Object.keys(next)) {
if (incoming[k] !== undefined) next[k] = incoming[k];
}
setBase(next);
};
window.addEventListener("hashchange", onHash);
window.addEventListener("sglang-deploy-sel", onSelEvent);
return () => {
window.removeEventListener("hashchange", onHash);
window.removeEventListener("sglang-deploy-sel", onSelEvent);
};
}, []);
const [pgRatios, setPgRatios] = useState({
eff: null,
base: null
});
useEffect(() => {
const onRatio = e => setPgRatios({
eff: e.detail && e.detail.ratio || null,
base: e.detail && (e.detail.baseRatio || e.detail.ratio) || null
});
window.addEventListener("sglang-k3-mamba-ratio", onRatio);
return () => window.removeEventListener("sglang-k3-mamba-ratio", onRatio);
}, []);
const initialDeltas = () => {
const out = {};
for (const [axisId, handler] of Object.entries(AXIS_HANDLERS)) {
const fc = pgFeatures[axisId];
if (fc) out[axisId] = handler.initState(fc, base);
}
return out;
};
const [deltas, setDeltas] = useState(initialDeltas);
useEffect(() => {
setDeltas(initialDeltas());
}, [Object.keys(base).sort().map(k => `${k}=${base[k]}`).join("&")]);
const [modal, setModal] = useState(null);
const openDialog = el => {
if (el && !el.open) {
try {
el.showModal();
} catch {}
}
};
const onDialogClick = e => {
if (e.target !== e.currentTarget) return;
const r = e.currentTarget.getBoundingClientRect();
const {clientX: x, clientY: y} = e;
if (x < r.left || x > r.right || y < r.top || y > r.bottom) setModal(null);
};
useEffect(() => {
const ID = "__playground_dialog_backdrop";
if (document.getElementById(ID)) return undefined;
const style = document.createElement("style");
style.id = ID;
style.textContent = `dialog::backdrop { background: rgba(0, 0, 0, 0.5); }`;
document.head.appendChild(style);
return () => {
const el = document.getElementById(ID);
if (el) el.remove();
};
}, []);
const [copied, setCopied] = useState(false);
const [curlCopied, setCurlCopied] = useState(false);
const [routerCopied, setRouterCopied] = useState(false);
const [envDraft, setEnvDraft] = useState(env);
useEffect(() => {
if (modal === "env") setEnvDraft(env);
}, [modal, env]);
const [runMode, setRunMode] = useState("python");
const [submitDraft, setSubmitDraft] = useState({
sglangVersion: "",
benchResult: "",
notes: ""
});
const [submitAttest, setSubmitAttest] = useState({
ranCommand: false,
reachedReady: false,
outputCorrect: false
});
useEffect(() => {
if (modal === "submit") {
setSubmitDraft({
sglangVersion: "",
benchResult: "",
notes: ""
});
setSubmitAttest({
ranCommand: false,
reachedReady: false,
outputCorrect: false
});
}
}, [modal]);
const s = makeStyles(isDark);
const baseCell = withOverlay(findCell(config.cells, base), base);
const modelName = resolveModelName(base);
const derivedMap = {};
if (baseCell) {
for (const [axisId, handler] of Object.entries(AXIS_HANDLERS)) {
const fc = pgFeatures[axisId];
if (!fc || !handler.deriveFromBase) continue;
derivedMap[axisId] = handler.deriveFromBase(baseCell, fc, helpers);
}
}
const attnDelta = deltas.attention || ({});
const attnDerived = derivedMap.attention || ({});
const attnKnobs = (pgFeatures.attention || ({})).knobs || [];
const effTp = attnDelta.tp !== null && attnDelta.tp !== undefined ? attnDelta.tp : attnDerived.tp !== undefined ? attnDerived.tp : null;
const staleExplicit = (knobId, picked) => {
const knob = attnKnobs.find(k => k.id === knobId);
const e = knob ? findEntry(knob.values || [], picked) : null;
return !!(e !== null && e !== undefined && evaluateChip(e, {
...base,
effTp
}).disabled);
};
const effDpAttn = attnDelta.dpAttn !== null && attnDelta.dpAttn !== undefined ? staleExplicit("dpAttn", attnDelta.dpAttn) ? null : attnDelta.dpAttn : attnDerived.dpAttn !== undefined ? attnDerived.dpAttn : null;
const dpAttnOn = effDpAttn === true || typeof effDpAttn === "number" && effDpAttn > 1;
const dpDegEff = typeof effDpAttn === "number" && effDpAttn > 0 ? effDpAttn : 1;
const cpKnobFreeSize = !!(attnKnobs.find(k => k.id === "cp") || ({})).freeSize;
const cpSizeTarget = !cpKnobFreeSize && dpDegEff === 1 && typeof effTp === "number" && effTp > 0 ? effTp : null;
const cpSizeStale = v => typeof v === "number" && v > 1 && cpSizeTarget !== null && v !== cpSizeTarget;
const effCp = attnDelta.cp !== null && attnDelta.cp !== undefined ? staleExplicit("cp", attnDelta.cp) || cpSizeStale(attnDelta.cp) ? null : attnDelta.cp : attnDerived.cp !== undefined ? attnDerived.cp : null;
const cpOn = typeof effCp === "number" && effCp > 1;
const cpStrategy = (attnDelta.cpStrategy && !staleExplicit("cpStrategy", attnDelta.cpStrategy) ? attnDelta.cpStrategy : attnDerived.cpStrategy !== undefined ? attnDerived.cpStrategy : null) || "interleave";
const constraintEffective = baseCell ? applyAllDeltas(baseCell.flags, baseCell.env, deltas, base, derivedMap) : null;
const pdCardOwnsMode = (pgFeatures.pdDisagg && pgFeatures.pdDisagg.modes || []).length > 0;
const pdMode = pdCardOwnsMode ? constraintEffective && constraintEffective.pdMode || "off" : base.pdMode || "off";
const specAlgorithm = constraintEffective ? (findFlagArg(constraintEffective.flags, "--speculative-algorithm") || "").toUpperCase() || null : null;
const constraintBase = {
...base,
dpAttnOn,
cpOn,
cpStrategy,
cpSizeTarget,
effTp,
pdMode,
workerNnodes: baseCell?.nnodes ?? parseNnodes(base.nodes),
specAlgorithm
};
let baseCommand = "";
let playgroundCommand = "";
let diffLines = [];
let pgFlagsLatest = [];
let pgEnvLatest = [];
const withRatio = (fl, value) => {
if (!value) return fl;
if (fl.some(f => f.startsWith("--mamba-full-memory-ratio") || f.startsWith("--max-mamba-cache-size"))) return fl;
const out = [...fl];
const line = `--mamba-full-memory-ratio ${value}`;
const i = out.findIndex(f => f.startsWith("--host"));
if (i >= 0) out.splice(i, 0, line); else out.push(line);
return out;
};
if (baseCell) {
baseCommand = renderCommandLines(baseCell, withRatio(baseCell.flags, pgRatios.base), baseCell.env, base, env, null, runMode);
const {flags: pgFlags, env: pgEnv, pdMode} = applyAllDeltas(baseCell.flags, baseCell.env, deltas, base, derivedMap);
pgFlagsLatest = pgFlags;
pgEnvLatest = pgEnv;
playgroundCommand = renderCommandLines(baseCell, withRatio(pgFlags, pgRatios.eff), pgEnv, base, env, pdMode, runMode);
diffLines = computeDiff(baseCommand, playgroundCommand);
}
const effectiveKey = pgFlagsLatest.join("\n") + " " + pgEnvLatest.join("\n") + " " + (baseCell ? baseCell.flags.join("\n") + " " + baseCell.env.join("\n") : "");
useEffect(() => {
if (typeof window === "undefined" || !baseCell) return;
window.dispatchEvent(new CustomEvent("sglang-k3-effective-config", {
detail: {
flags: pgFlagsLatest,
env: pgEnvLatest,
baseFlags: baseCell.flags,
baseEnv: baseCell.env
}
}));
}, [effectiveKey]);
const matchedCell = baseCell ? findMatchingCell(config.cells, base, pgEnvLatest, pgFlagsLatest) : null;
const playgroundVerified = !!(matchedCell && matchedCell.verified);
const matchedSiblingCell = matchedCell && DIMENSIONS.some(d => matchedCell.match[d] !== base[d]) ? matchedCell : null;
const pgSpecAlgoFlag = pgFlagsLatest.find(f => f.split(/[\s=]/)[0] === "--speculative-algorithm");
const pgPdRole = pdMode === "prefill" || pdMode === "decode";
const pgSpecHint = !!pgSpecAlgoFlag && (pgPdRole || !pgFlagsLatest.some(f => f.split(/[\s=]/)[0] === "--max-running-requests"));
const specAlgoLabels = {
EAGLE: "MTP",
EAGLE3: "MTP",
FROZEN_KV_MTP: "MTP",
DSPARK: "DSpark",
DFLASH: "DFlash",
NGRAM: "N-gram",
STANDALONE: "standalone draft"
};
const pgSpecAlgoValue = pgSpecAlgoFlag ? pgSpecAlgoFlag.split(/[\s=]/).filter(Boolean)[1] || "" : "";
const pgSpecAlgoName = specAlgoLabels[pgSpecAlgoValue.toUpperCase()] || pgSpecAlgoValue || "MTP";
const pgCpDpHint = cpEnabledIn(pgFlagsLatest) && (bakedCpStrategy(pgFlagsLatest) || "interleave") === "interleave" && dpAttnOnIn(pgFlagsLatest);
const proposedCellSnippet = baseCell ? serializeCell(base, pgEnvLatest, pgFlagsLatest) : "";
const existingCellSnippet = baseCell ? serializeCell(base, baseCell.env || [], baseCell.flags) : "";
const submitUrl = baseCell ? buildSubmitUrl(base, {
cellSnippet: proposedCellSnippet,
existingCell: existingCellSnippet,
sglangVersion: submitDraft.sglangVersion,
benchResult: submitDraft.benchResult,
notes: submitDraft.notes
}) : "";
const submitReady = submitAttest.ranCommand && submitAttest.reachedReady && submitAttest.outputCorrect && submitDraft.sglangVersion.trim().length > 0;
const pdRouter = baseCell && baseCell.pd && baseCell.router || pdMode !== "off" && resolveRouter(config.playgroundFeatures && config.playgroundFeatures.pdDisagg, base) || null;
const curlEnv = pdRouter && pdRouter.port != null ? {
...env,
CURL_PORT: String(pdRouter.port)
} : env;
const curlText = interpolate(config.curl || "", curlEnv, modelName);
const routerText = pdRouter && pdRouter.command ? interpolate(pdRouter.command, {
...env,
PREFILL_PORT: PD_PORTS.prefill.serve,
DECODE_PORT: PD_PORTS.decode.serve,
ROUTER_PORT: pdRouter.port
}, modelName) : "";
const resetAll = () => setDeltas(initialDeltas());
const placeholderGroups = (() => {
const out = {
command: [],
curl: []
};
for (const [key, meta] of Object.entries(config.placeholders || ({}))) {
(out[meta.target] || (out[meta.target] = [])).push({
key,
...meta
});
}
return out;
})();
const handleCopy = () => {
navigator.clipboard.writeText(playgroundCommand);
setCopied(true);
setTimeout(() => setCopied(false), 1200);
};
const copyCurl = () => {
navigator.clipboard.writeText(curlText);
setCurlCopied(true);
setTimeout(() => setCurlCopied(false), 1200);
};
const baseSummary = baseCell ? Object.entries(base).filter(([k, v]) => v !== undefined && v !== "" && (!config.resolveRecipe || !(config.overlayDims || []).some(d => d.id === k && !rowVisible(d, base)))).map(([k, v]) => k === "hw" ? String(v).toUpperCase() : String(v)).join(" · ") : "(no verified cell at the current Deploy selection — showing playground only)";
const renderChip = (label, current, value, onPick, opts = {}) => {
const checked = current === value;
const disabled = !!opts.disabled;
return {
if (!disabled) onPick(value);
}}>
{label}
;
};
const renderSelect = (current, entries, onPick, base, labelFor, opts = {}) => {
const hideSet = new Set(opts.hideValues || []);
const items = [];
for (const entry of entries || []) {
const c = helpers.evaluateChip(entry, base);
if (c.hidden) continue;
if (hideSet.has(c.value)) continue;
const lbl = labelFor ? labelFor(c) : c.label !== undefined ? c.label : c.value === null ? "Auto" : String(c.value);
items.push({
...c,
label: lbl
});
}
let idx = items.findIndex(c => c.value === current);
if (idx === -1) idx = 0;
return {
const next = items[parseInt(e.target.value, 10)];
if (next && !next.disabled) onPick(next.value);
}}>
{items.map((c, i) =>
{c.label}{c.disabled ? " (n/a)" : ""}
)}
;
};
if (baseCell && baseCell.pd && baseCell.pdMode === "router") return
Select Prefill or Decode in the Deployment panel to tune that worker.
The Router tab contains the shared frontend command.
;
return
{}
Inherited base from Deployment:
{baseSummary}
{}
{
const el = document.getElementById(DEPLOYMENT_COMPONENT_ID) || document.getElementById("deployment") || document.getElementById("deploy");
if (el) el.scrollIntoView({
behavior: "smooth",
block: "start"
});
}}>
↑ Switch base
Reset all overrides
{}
{Object.entries(AXIS_HANDLERS).map(([axisId, handler]) => {
const fc = pgFeatures[axisId];
if (!fc) return null;
if (typeof fc.showWhen === "function" && !fc.showWhen(constraintBase)) return null;
const setValue = next => setDeltas(d => updateAxisDeltas(d, axisId, next, constraintBase));
const rendered = handler.render({
axisId,
value: deltas[axisId],
setValue,
fc,
base: constraintBase,
s,
h: helpers,
renderChip,
renderSelect,
derived: derivedMap[axisId] || null
});
const group = exclusiveGroupsFor(axisId, constraintBase).find(g => g.axes[0] === axisId && g.note);
return rendered && group ?
: rendered;
})}
{}
Playground Command (compare with base)
{}
{matchedSiblingCell &&
matches
{matchedSiblingCell.match.strategy}
{
const m = matchedSiblingCell.match;
setDeltas(initialDeltas());
const hash = new URLSearchParams(m).toString();
window.location.hash = hash;
window.dispatchEvent(new CustomEvent("sglang-deploy-sel", {
detail: m
}));
}}>
switch base →
}
setRunMode("python")} role="tab" aria-selected={runMode === "python"}>
Python
setRunMode("docker")} role="tab" aria-selected={runMode === "docker"}>
Docker
{copied ? "✓ Copied" : "⧉ Copy"}
setModal("curl")}>$ cURL
setModal("env")}>⚙ Env
{}
{!playgroundVerified && baseCell && setModal("submit")} title="I verified this command on my hardware — open a pre-filled GitHub issue to land it as a cookbook cell.">
Submit ↗
}
{baseCell ? diffLines.map((d, i) =>
{d.kind === "added" ? "+ " : d.kind === "removed" ? "- " : " "}
{d.line}{"\n"}
) : "# No verified base cell at the current Deployment selection.\n# Pick a supported hardware/variant in the Deployment panel to populate the playground base."}
{pgSpecHint &&
{pgPdRole ? <>⚠️ Speculative decoding ({pgSpecAlgoName}) is on — for a target concurrency of N, set --max-running-requests <N*2> on both the prefill and decode roles. That ceiling is server-wide and floor-divided by attn_dp_size, so size the decode graphs to the per-rank batch it leaves: --cuda-graph-bs-decode up to N*2 / dp_size. : <>⚠️ Speculative decoding ({pgSpecAlgoName}) is on — SGLang resets --max-running-requests to 48 when it isn't set. Add --max-running-requests <N> sized for your target concurrency.}
}
{pgCpDpHint &&
⚠️ Interleave prefill-CP together with DP-Attention: current SGLang releases assert attn_dp_size == 1 for the interleave layout, so this command fails at startup. Combined CP + DP-Attention support is planned upstream — keep one of the two off until it lands.
}
{}
{pdRouter && routerText &&
Router
Run after both roles are up. Substitute
{""} /{" "}
{""} with reachable hosts (both
127.0.0.1{" "}
on a same-host deployment). Client traffic (cURL) targets this router.
port {pdRouter.port}
{
navigator.clipboard.writeText(routerText);
setRouterCopied(true);
setTimeout(() => setRouterCopied(false), 1200);
}}>
{routerCopied ? "✓ Copied" : "⧉ Copy"}
{routerText}
}
{}
{modal === "curl" &&
setModal(null)} onClick={onDialogClick}>
cURL example
setModal(null)} aria-label="Close">×
Model: {modelName || "(unresolved)"}
{curlCopied ? "✓ Copied" : "⧉ Copy"}
{curlText}
{pdRouter &&
PD-Disaggregation active — this targets the router on
{" "}:{pdRouter.port}; client traffic must not hit the role
servers directly.
}
Edit CURL_HOST / CURL_PORT in the Env panel.
}
{}
{modal === "env" &&
setModal(null)} onClick={onDialogClick}>
Env / placeholder values
setModal(null)} aria-label="Close">×
{placeholderGroups.curl.length > 0 &&
cURL placeholders
{placeholderGroups.curl.map(({key, label}) =>
{label} {`{{${key}}}`}
)}
}
{placeholderGroups.command.length > 0 &&
Command placeholders
{placeholderGroups.command.map(({key, label}) =>
{label} {`{{${key}}}`}
)}
}
setModal(null)}>Cancel
{
saveEnv(envDraft);
setModal(null);
}}>Save
Values persist in localStorage and are shared with the Deployment panel.
}
{}
{modal === "submit" &&
setModal(null)} onClick={onDialogClick}>
Submit verified cell
setModal(null)} aria-label="Close">×
You've put together a combination that isn't in the verified
catalog yet. After you've run the command end-to-end on the
target hardware, this submits a pre-filled GitHub Issue that a
maintainer can convert into a PR.
Combination
{base.hw} / {base.variant} / {base.quant} / {base.strategy} / {base.nodes}
{}
{(() => {
const adds = diffLines.filter(d => d.kind === "added");
const rems = diffLines.filter(d => d.kind === "removed");
if (adds.length === 0 && rems.length === 0) return null;
return <>
Overrides vs base ({adds.length} added · {rems.length} removed)
{[...rems, ...adds].map((d, i) =>
{d.kind === "added" ? "+ " : "- "}
{d.line.replace(/^\s*/, "")}
)}
;
})()}
Attestation (all required)
SGLang version (required)
Benchmark result (optional)
Notes / caveats (optional)