Qwen3.8-Flash-Next on any consumer hardware: one-click install for Windows / Linux. Strata inference engine, OpenAI/Anthropic API on localhost, optional image input.
C++
Your own engine settings are kept: user_args, a reserve of 0 on a compute-only card, control vectors survive a load (#3215 #3270 #3216)
Niko12218aaf188aa9f7
diff --git a/apps/host/server/native-control.mjs b/apps/host/server/native-control.mjsindex ae4ec6485..c59afeb1d 100644--- a/apps/host/server/native-control.mjs+++ b/apps/host/server/native-control.mjs@@ -7,7 +7,8 @@ import { join, resolve, dirname, basename } from 'node:path';import { fileURLToPath } from 'node:url';import { createServer } from 'node:net';import { NATIVE_FIELDS, APP_OWNED_FIELDS, withoutDraftLayer, validateNativeSettings, validateMcpServers, publicMcpServers, publicNativeEnv, restoreNativeEnv } from './native-settings.mjs';-import { resourceSettings, saferStart } from './native-resources.mjs';+import { resourceSettings, saferStart, reserveChoice } from './native-resources.mjs';+import { USER_KEY, capture as captureUserArgs, merge as mergeUserArgs, setFlag as setUserFlag, stamped as stampedUserArgs } from './native-user-args.mjs';import { resolvePython, venvPython } from './python-resolver.mjs';import os from 'node:os';import { runtimeVision } from './native-vision.mjs';@@ -129,7 +130,7 @@ export function createNativeControl({directory,requests=()=>[],changed=()=>{},sp/* A mistake in the file holds the start back with the line, instead of an engine that dies on it. Warnings (an unknown key) never do. */function assertSettingsFile(path){const check=checkRunConfig(readFileSync(path,'utf8'));if(!check.ok)throw new Error(`The settings file for this model has a mistake, so the model was not started. ${describeIssues(check.issues,'error').join(' ')}`);}function settings(model){const {config}=record(model);const values=Object.fromEntries(NATIVE_FIELDS.map(f=>[f.id,config[f.id]??null]));if(typeof values.aliases==='string')values.aliases=values.aliases.split(',').map(v=>v.trim()).filter(Boolean);values.sampling=config.sampling??{};values.args=config.args??[];values.env=publicNativeEnv(config.env??{});return {model,values,mcp:publicMcpServers(config.mcp_servers??config.mcpServers??{}),restartNeeded:true};}- function save(model,{values,mcp}){if([...jobs.values()].some(j=>j.state==='running'))throw new Error('Finish the current operation before saving native settings.');const {path,config}=record(model);if(busy(requests().filter(r=>instances.get(r.instanceId)?.model===model)))throw new Error('Finish this model’s requests before saving its settings.');const patch=validateNativeSettings(values??{}),next={...config};for(const field of nativeFields())if(field.supported===false&&patch[field.id]!=null&&JSON.stringify(patch[field.id])!==JSON.stringify(config[field.id]))throw new Error(`${field.label} needs a newer native Strata installation. Update it in Settings → About.`);for(const [key,value] of Object.entries(patch)){if(key==='env')next.env=restoreNativeEnv(value,config.env??{});else if(value===null)delete next[key];else next[key]=value;}if(mcp!==undefined){next.mcp_servers=validateMcpServers(mcp,config.mcp_servers??config.mcpServers??{});delete next.mcpServers;}copyFileSync(path,path+'.bak');chmodSync(path+'.bak',0o600);const temp=path+'.ui-tmp';writeFileSync(temp,JSON.stringify(next,null,2)+'\n',{mode:0o600});renameSync(temp,path);return settings(model);}+ function save(model,{values,mcp}){if([...jobs.values()].some(j=>j.state==='running'))throw new Error('Finish the current operation before saving native settings.');const {path,config}=record(model);if(busy(requests().filter(r=>instances.get(r.instanceId)?.model===model)))throw new Error('Finish this model’s requests before saving its settings.');const patch=validateNativeSettings(values??{}),next={...config};for(const field of nativeFields())if(field.supported===false&&patch[field.id]!=null&&JSON.stringify(patch[field.id])!==JSON.stringify(config[field.id]))throw new Error(`${field.label} needs a newer native Strata installation. Update it in Settings → About.`);for(const [key,value] of Object.entries(patch)){if(key==='env')next.env=restoreNativeEnv(value,config.env??{});else if(value===null)delete next[key];else next[key]=value;}if('vram_reserve_mib' in patch){const base=captureUserArgs(next);const mine=setUserFlag(base,'--vram-reserve-mib',patch.vram_reserve_mib);if(mine.length)next[USER_KEY]=mine;else delete next[USER_KEY];next.args=mine.length&&patch.vram_reserve_mib!==null?mergeUserArgs(next.args??[],mine):setUserFlag(next.args??[],'--vram-reserve-mib',null);delete next.ui_reserve_applied;if(Array.isArray(next.args_written))next.args_written=[...next.args];}if(mcp!==undefined){next.mcp_servers=validateMcpServers(mcp,config.mcp_servers??config.mcpServers??{});delete next.mcpServers;}copyFileSync(path,path+'.bak');chmodSync(path+'.bak',0o600);const temp=path+'.ui-tmp';writeFileSync(temp,JSON.stringify(next,null,2)+'\n',{mode:0o600});renameSync(temp,path);return settings(model);}function previousEngine(){if(packaged)return !!snapshot.engine?.previous;try{const data=snapshot.installed?.data_dir??snapshot.installed?.data_folder;return [join(preferences.repo,'engine/.previous'),data&&join(data,'engine/.previous')].filter(Boolean).some(existsSync)&&readFileSync(join(preferences.repo,'setup.py'),'utf8').includes('--rollback-engine');}catch{return false;}}async function plan(args){await refresh();if(!snapshot.available)throw new Error(snapshot.error);return tool('strata_install',installArgs(args,false));}function installArgs(args,confirm){const allowed=['family','model','context','vision','kv','gpu','gpus','backend','low_ram','port','gguf_dir'];const size=snapshot.catalog?.families?.find(f=>f.family===args.family)?.sizes.find(s=>s.model===args.model);const existing=snapshot.installed?.models?.find(m=>m.model===size?.id);/* A model adopted from the person's own GGUF folder reports that folder's parent as its data folder: it is theirs, not Strata's, so a second preparation never uses it for the packs. */const data=nativeDataDirectory(args.data_dir??(args.gguf_dir?undefined:existing?.dataFolder)??preferences.downloadDirectory??modelsDirectory?.());return {...(data?{data_dir:data}:{}),...Object.fromEntries(allowed.filter(k=>args[k]!==undefined).map(k=>[k,args[k]])),/* Picture reading is only downloaded when it was asked for (Read pictures); the default stays the smaller download. */...(packaged&&args.vision===undefined?{vision:'no'}:{}),confirm};}@@ -192,10 +193,17 @@ return {summary:result.summary??'Deleted',removed:result.plan?.gb??null};}function buildConfig(args,config){const vision=runtimeVision(config,args.vision);const visionPreferences=args.vision!==undefined?{ui_vision_enabled:args.vision!=='no',ui_vision_device:args.vision==='no'?config.ui_vision_device??'yes':args.vision}:{};- const resources=args.resourceProfile?resourceSettings({...config,vision},snapshot.hardware,args.resourceProfile,modelArena(args.model)):null;+ /* The engine options the person set by hand (user_args, and what they wrote into "args" since the last write) go over everything the app generates, and an+ explicit GPU-memory reserve (the Expert setting, user_args, a value they wrote) is never replaced by the safety default (#3215 #3270 #3216). */+ const values0=args.values??{},cleared='vram_reserve_mib' in values0&&(values0.vram_reserve_mib===null||values0.vram_reserve_mib===''),base0=cleared?{...config,vram_reserve_mib:undefined,[USER_KEY]:setUserFlag(config[USER_KEY],'--vram-reserve-mib',null)}:config;+ let mine=captureUserArgs(base0);const asked=cleared?null:reserveChoice({...base0,[USER_KEY]:mine},snapshot.hardware,values0).asked;+ if(asked!==null)mine=setUserFlag(mine,'--vram-reserve-mib',asked);+ const resources=args.resourceProfile?resourceSettings({...base0,[USER_KEY]:mine,vision},snapshot.hardware,args.resourceProfile,modelArena(args.model),values0):null;const cfg={...config,...visionPreferences,...(resources?{...resources,ui_resource_profile:args.resourceProfile}:{}),host:'127.0.0.1',open_browser:false,...validateNativeSettings(args.values??{}),vision};if(args.gpus!==undefined){const detected=new Set((snapshot.hardware?.gpus??[]).map(g=>g.index));if(!Array.isArray(args.gpus)||!args.gpus.length||new Set(args.gpus).size!==args.gpus.length||args.gpus.some(g=>!Number.isInteger(g)||!detected.has(g)))throw new Error('Choose distinct detected GPUs. CPU-only text inference is not supported by this native adapter.');cfg.gpu=args.gpus.length===1?args.gpus[0]:args.gpus;cfg.layer_split=args.gpus.length>1?validateNativeSettings({layer_split:args.layerSplit??'auto'}).layer_split:'auto';if(cfg.layer_split!=='auto'&&cfg.layer_split.split(',').length!==args.gpus.length-1)throw new Error('Choose one layer split point between each pair of GPUs.');}- if(cfg.vram_reserve_mib!==undefined&&cfg.vram_reserve_mib!==null){cfg.args=[...(cfg.args??[])];const at=cfg.args.indexOf('--vram-reserve-mib');if(at>=0)cfg.args.splice(at,2);cfg.args.push('--vram-reserve-mib',String(cfg.vram_reserve_mib));}if(cfg.vision){if(cfg.vision_tokens!=null)cfg.vision={...cfg.vision,max_tokens:cfg.vision_tokens};if(cfg.vision_min_tokens!=null)cfg.vision={...cfg.vision,min_tokens:cfg.vision_min_tokens};}cfg.mcp={...(cfg.mcp??{}),...(cfg.mcp_timeout_s!=null?{timeout_s:cfg.mcp_timeout_s}:{}),...(cfg.mcp_max_rounds!=null?{max_rounds:cfg.mcp_max_rounds}:{}),...(cfg.mcp_max_result_chars!=null?{max_result_chars:cfg.mcp_max_result_chars}:{})};+ if(cfg.vram_reserve_mib!==undefined&&cfg.vram_reserve_mib!==null){cfg.args=[...(cfg.args??[])];const at=cfg.args.indexOf('--vram-reserve-mib');if(at>=0)cfg.args.splice(at,2);cfg.args.push('--vram-reserve-mib',String(cfg.vram_reserve_mib));}+ if(mine.length){cfg.args=mergeUserArgs(cfg.args??[],mine);cfg[USER_KEY]=mine;}else delete cfg[USER_KEY];+ if(cfg.vision){if(cfg.vision_tokens!=null)cfg.vision={...cfg.vision,max_tokens:cfg.vision_tokens};if(cfg.vision_min_tokens!=null)cfg.vision={...cfg.vision,min_tokens:cfg.vision_min_tokens};}cfg.mcp={...(cfg.mcp??{}),...(cfg.mcp_timeout_s!=null?{timeout_s:cfg.mcp_timeout_s}:{}),...(cfg.mcp_max_rounds!=null?{max_rounds:cfg.mcp_max_rounds}:{}),...(cfg.mcp_max_result_chars!=null?{max_result_chars:cfg.mcp_max_result_chars}:{})};/* The model's own choices win over what setup wrote into the arguments: "Draft layer (MTP)" off leaves --mtp out of every start, and a picture reading that is off leaves --vision out (setup writes both again whenever it runs; the saved settings are applied here, on every load). */if(cfg.mtp===false&&Array.isArray(cfg.args))cfg.args=withoutDraftLayer(cfg.args);if(!cfg.vision&&Array.isArray(cfg.args))cfg.args=cfg.args.filter(a=>a!=='--vision');@@ -268,7 +276,7 @@ return {summary:result.summary??'Deleted',removed:result.plan?.gb??null};}}const deadline=Date.now()+300000;while(Date.now()<deadline&&job.state==='running'){if(instance.status==='error')throw new Error(instance.error);- try{const response=await fetcher(`http://127.0.0.1:${instance.port}/health`,{headers:{authorization:`Bearer ${key}`},signal:AbortSignal.timeout(2000)});if(job.state!=='running'){await unload(id);return;}if(response.ok){instance.status='ready';instance.phase='idle';if(resources||args.vision!==undefined)writeModelConfig(record(args.model).path,{...config,...(resources?{...resources,ui_resource_profile:args.resourceProfile}:{}),...visionPreferences});emit();ensurePoll();instance.parallelNote=parallelNote;return {summary:retried?`${instance.label} is ready, after a second try: ${retried.words}`:`${instance.label} is ready.${parallelNote?' '+parallelNote:''}`,instanceId:id};}}catch{}+ try{const response=await fetcher(`http://127.0.0.1:${instance.port}/health`,{headers:{authorization:`Bearer ${key}`},signal:AbortSignal.timeout(2000)});if(job.state!=='running'){await unload(id);return;}if(response.ok){instance.status='ready';instance.phase='idle';if(resources||args.vision!==undefined||JSON.stringify(cfg[USER_KEY]??null)!==JSON.stringify(config[USER_KEY]??null))writeModelConfig(record(args.model).path,{...config,...(resources?{...resources,ui_resource_profile:args.resourceProfile}:{}),...visionPreferences,...(cfg[USER_KEY]?{[USER_KEY]:cfg[USER_KEY]}:{})});emit();ensurePoll();instance.parallelNote=parallelNote;return {summary:retried?`${instance.label} is ready, after a second try: ${retried.words}`:`${instance.label} is ready.${parallelNote?' '+parallelNote:''}`,instanceId:id};}}catch{}await new Promise(resolve=>setTimeout(resolve,1200));}if(job.state!=='running'){await unload(id);return;}@@ -321,7 +329,8 @@ return {summary:result.summary??'Deleted',removed:result.plan?.gb??null};}}function updateSummary(done){const r=(done.results??[]).filter(x=>x.status==='updated').map(x=>x.component==='engine'?'The engine is updated and ready.':'Strata is updated. It takes effect the next time you open the app.');return r.length?r.join(' '):'Everything is already up to date.';}function execute(cmd,args,cwd){return new Promise((resolve,reject)=>{let output='';const process=spawnProcess(cmd,args,{cwd,stdio:['ignore','pipe','pipe']});process.stdout.on('data',c=>{output+=c;if(output.length>100000)process.kill();});process.stderr.on('data',c=>append('update',c.toString()));process.on('error',reject);process.on('exit',code=>code===0?resolve(output):reject(new Error('Git could not update this installation. Open diagnostics.')));});}- function writeModelConfig(path,next){copyFileSync(path,path+'.bak');chmodSync(path+'.bak',0o600);const temp=path+'.ui-tmp';writeFileSync(temp,JSON.stringify(next,null,2)+'\n',{mode:0o600});renameSync(temp,path);}+ /* Every write of a model's run config keeps the person's options: those they wrote into "args" or "user_args" since the file was last written are read from the file itself, go over what the caller built, and "args_written" is refreshed. */+ function writeModelConfig(path,next){const mine=mergeUserArgs(captureUserArgs(readJson(path)),next[USER_KEY]??[]);next=stampedUserArgs(next,mine);copyFileSync(path,path+'.bak');chmodSync(path+'.bak',0o600);const temp=path+'.ui-tmp';writeFileSync(temp,JSON.stringify(next,null,2)+'\n',{mode:0o600});renameSync(temp,path);}async function tune(job,args){await refresh(true);if(job.state!=='running')return;const chosen=record(args.model);resourceSettings(chosen.config,snapshot.hardware,args.profile,modelArena(args.model));diff --git a/apps/host/server/native-resources.mjs b/apps/host/server/native-resources.mjsindex 5dcf7baa5..1d29620d8 100644--- a/apps/host/server/native-resources.mjs+++ b/apps/host/server/native-resources.mjs@@ -1,10 +1,59 @@+import {USER_KEY,flagValue} from './native-user-args.mjs';++/** The engine's own default reserve, and the one setup writes for pictures read on the GPU: neither is a choice of the person. */+const ENGINE_DEFAULT_RESERVE_MIB=700;+/** A card that drives no display needs little beside the engine; the engine keeps the last few hundred MiB for allocations it makes after the cache. */+const COMPUTE_ONLY_RESERVE_MIB=512;++const wholeMib=v=>v!==null&&v!==undefined&&v!==''&&Number.isFinite(Number(v))&&Number(v)>=0?Math.trunc(Number(v)):null;++/** The graphics memory the person asked to keep free, or null when they asked for nothing (#3215 #3270): the Expert setting of this load,+ * "user_args", the setting saved for the model ("vram_reserve_mib", unless it is the value the app itself wrote last), or a value written by hand into "args"+ * (not the engine's default 700, and not the one the app wrote). Any number counts, 0 too. */+function candidateReserve(config,values={},legacyDefaults=new Set()){+ if(values&&typeof values==='object'&&'vram_reserve_mib' in values){const v=wholeMib(values.vram_reserve_mib);if(v!==null)return v;}+ const user=wholeMib(flagValue(config?.[USER_KEY],'--vram-reserve-mib'));if(user!==null)return user;+ const applied=config?.ui_reserve_applied,legacy=applied===undefined&&config?.ui_resource_baseline!==undefined; // 0.2.0-beta wrote the key itself, without saying so+ const key=wholeMib(config?.vram_reserve_mib),arg=wholeMib(flagValue(config?.args,'--vram-reserve-mib'));+ const keyOk=key!==null&&key!==applied,argOk=arg!==null&&arg!==applied&&arg!==ENGINE_DEFAULT_RESERVE_MIB;+ if(legacy)return [arg,key].map((n,i)=>(i===0?argOk:keyOk)?n:null).find(n=>n!==null&&!(n===1536||n===2048||legacyDefaults.has(n)))??null; // a 0.2.0-beta file: the app wrote both, so what is not one of its own numbers is the person's+ return keyOk?key:argOk?arg:null;+}++/** What the app keeps free when the person asked for nothing: [work, performance]. A card that drives a display (or is not known to be headless) gets no+ * less than 1536 MiB on a card of 16 GB or less, 1024 above, 2048 with pictures (the engine warns below ~1-1.5 GiB of free VRAM: the driver then pages GPU memory to+ * system RAM and decoding falls to a few tokens a second, #2065); "work" also keeps a fifth of the card. A card the probe says drives no display keeps 512 MiB+ * (700 with pictures) on either profile. */+export function defaultReserves(config,hardware,baselineReserve=0){+ const placement=Array.isArray(config.gpu)?config.gpu:[config.gpu??0];+ const placed=(hardware?.gpus??[]).filter(g=>placement.includes(g.index)),gpuMemory=placed.map(g=>g.vram_gb).filter(n=>Number.isFinite(n)&&n>0);+ const headless=placed.length>0&&placed.every(computeOnly); // no display on the card (the desktop is on an integrated GPU): no desktop to keep room for+ const floor=headless?(config.vision?ENGINE_DEFAULT_RESERVE_MIB:COMPUTE_ONLY_RESERVE_MIB):gpuMemory.length&&Math.min(...gpuMemory)>16?1024:1536;+ const safety=headless?floor:Math.max(config.vision?2048:floor,baselineReserve);+ return {work:gpuMemory.length&&!headless?Math.max(safety,Math.floor(Math.min(...gpuMemory)*1024*.2)):safety,performance:safety};+}++/** The reserve the person asked for (null: nothing) and the default for each profile. A 0.2.0-beta file has the key and the same number in "args" with no note that the+ * app wrote them: a number that is one of the app's two defaults is the app's, any other is the person's. */+export function reserveChoice(config,hardware,values={},baselineReserve=0){+ const defaults=defaultReserves(config,hardware,config.ui_resource_baseline?.reserve??baselineReserve);+ const asked=candidateReserve(config,values,new Set([defaults.work,defaults.performance]));+ return {asked,defaults};+}+export const explicitReserve=(config,values={},hardware=null)=>reserveChoice(config,hardware,values).asked;++/** True when the probe says this card drives no display: only compute runs on it. Unknown counts as a display card. */+const computeOnly=g=>g?.drives_display===false;+/** Headroom is a worker/memory budget, not a hard utilisation throttle. */-export function resourceSettings(config,hardware,profile,model={}){+export function resourceSettings(config,hardware,profile,model={},values={}){if(!['work','performance'].includes(profile))throw new Error('Choose a resource preference.');const args=[...(config.args??[])];const remove=flag=>{for(let at=args.indexOf(flag);at>=0;at=args.indexOf(flag))args.splice(at,2);};const value=flag=>{const at=args.indexOf(flag);return at>=0?Number(args[at+1])||0:0;};- const baseline=config.ui_resource_baseline??{workers:value('--pool-workers'),reserve:Math.max(Number(config.vram_reserve_mib)||0,value('--vram-reserve-mib'))};+ const first=reserveChoice(config,hardware,values).asked;+ const baseline=config.ui_resource_baseline??{workers:value('--pool-workers'),reserve:first!==null?0:Math.max(Number(config.vram_reserve_mib)||0,value('--vram-reserve-mib'))};+ const {asked,defaults}=reserveChoice(config,hardware,values,baseline.reserve);if(profile==='performance'&&config.ui_resource_profile==='work'){remove('--pool-workers');if(baseline.workers>0)args.push('--pool-workers',String(baseline.workers));}@@ -15,13 +64,8 @@ export function resourceSettings(config,hardware,profile,model={}){args.push('--pool-workers',String(previous>0?Math.min(previous,workers):workers));}// Preserve calibrated worker counts and the installation's safety/vision reserve.- const placement=Array.isArray(config.gpu)?config.gpu:[config.gpu??0];- const gpuMemory=(hardware?.gpus??[]).filter(g=>placement.includes(g.index)).map(g=>g.vram_gb).filter(n=>Number.isFinite(n)&&n>0);- /* The engine warns below ~1-1.5 GiB of free VRAM (the driver then pages GPU memory to system RAM and decoding falls to a few tokens a- second, #2065), so neither profile may reserve less: 1536 MiB on a card of 16 GB or less, 1024 above; with pictures 2048. */- const floor=gpuMemory.length&&Math.min(...gpuMemory)>16?1024:1536;- const safety=Math.max(config.vision?2048:floor,baseline.reserve);- const reserve=profile==='work'&&gpuMemory.length?Math.max(safety,Math.floor(Math.min(...gpuMemory)*1024*.2)):safety;+ /* A reserve the person set is theirs, 0 included: no floor and no share of the card (#3215 #3270). Without one the card gets the safety default (defaultReserves). */+ const reserve=asked!==null?asked:defaults[profile];remove('--vram-reserve-mib');args.push('--vram-reserve-mib',String(reserve));// RAM: "leave 20% for my work" keeps the model's RAM within 80% of the PC. A model whose experts do not fit there (the// setup rule: experts plus 10 GB) keeps only that many GiB of them in RAM and reads the rest from the model files@@ -37,7 +81,7 @@ export function resourceSettings(config,hardware,profile,model={}){// available for other programs (it keeps fewer experts if the PC is busy), and it said nothing about this before.let ramHeadroom=false;if(ramBudget&&!(config.env?.STRATA_RESIDENT_HEADROOM_GIB)){env={...(env??config.env??{}),STRATA_RESIDENT_HEADROOM_GIB:String(Math.ceil(ram*.2))};ramHeadroom=true;}- return {args,vram_reserve_mib:reserve,...(env?{env}:{}),ui_resource_baseline:{...baseline,ramBudget,ramHeadroom}};+ return {args,vram_reserve_mib:reserve,...(asked!==null?{}:{ui_reserve_applied:reserve}),...(env?{env}:{}),ui_resource_baseline:{...baseline,ramBudget,ramHeadroom}};}/* One automatic second try after a start that died. Returns null when there is nothing safer to try (the caller then reports the firstdiff --git a/apps/host/server/native-user-args.mjs b/apps/host/server/native-user-args.mjsnew file mode 100644index 000000000..d06557a26--- /dev/null+++ b/apps/host/server/native-user-args.mjs@@ -0,0 +1,47 @@+/** The engine options a person set by hand in a model's run config (strata_control/user_args.py is the same rule in Python).+ * "user_args" holds them; "args_written" is the whole "args" as setup or the app last wrote it, so an option in "args" that is not in+ * that copy was added or changed by hand since. Every load and every write puts the person's options over the generated ones. */+export const USER_KEY='user_args',WRITTEN_KEY='args_written';+/** Options the app or setup choose from their own answers (context, KV type, pictures, draft layer, layer split): never taken from "args" as hand edits. */+export const CHOICE_FLAGS=new Set(['--max-context','--kv','--vision','--mtp','--spec-min-p','--batch-mtp','--layer-split']);++export function groups(args){+ const out=[];+ for(const raw of Array.isArray(args)?args:[]){const a=String(raw);if(a.startsWith('--')||!out.length)out.push([a]);else out[out.length-1].push(a);}+ return out;+}+export const flat=gs=>gs.flat();+export const flagOf=g=>g?.[0]?.startsWith('--')?g[0]:'';+/** `args` with every option the person set replaced by theirs (appended after the generated ones). */+export function merge(args,user){+ const ug=groups(user),mine=new Set(ug.map(flagOf).filter(Boolean));+ return flat([...groups(args).filter(g=>!mine.has(flagOf(g))),...ug]);+}+function byFlag(gs){const m=new Map();for(const g of gs){const f=flagOf(g);if(!m.has(f))m.set(f,[]);m.get(f).push(g);}return m;}+const same=(a,b)=>JSON.stringify(a??null)===JSON.stringify(b??null);+/** The person's options of a config: its user_args, with the options of "args" that differ from "args_written" on top. */+export function capture(cfg,skip=CHOICE_FLAGS){+ const mine=byFlag(groups(cfg?.[USER_KEY]));+ if(Array.isArray(cfg?.[WRITTEN_KEY])&&Array.isArray(cfg?.args)){+ const cur=byFlag(groups(cfg.args)),was=byFlag(groups(cfg[WRITTEN_KEY]));+ for(const [flag,gs] of cur)if(flag&&!skip.has(flag)&&!same(was.get(flag),gs))mine.set(flag,gs);+ for(const flag of [...mine.keys()])if(was.has(flag)&&!cur.has(flag))mine.delete(flag);+ }+ return flat([...mine.values()].flat());+}+export function setFlag(user,flag,value){+ const rest=groups(user).filter(g=>flagOf(g)!==flag);+ if(value!==null&&value!==undefined)rest.push([flag,String(value)]);+ return flat(rest);+}+export function flagValue(args,flag){+ const list=(Array.isArray(args)?args:[]).map(String),at=list.indexOf(flag);+ return at>=0&&at+1<list.length?list[at+1]:null;+}+/** `config` with the person's options merged into "args", recorded in "user_args", and "args_written" refreshed (only when the config has one). */+export function stamped(config,user){+ const next={...config};+ if(user.length){next.args=merge(next.args,user);next[USER_KEY]=user;}else delete next[USER_KEY];+ if(WRITTEN_KEY in config)next[WRITTEN_KEY]=[...(next.args??[])];+ return next;+}diff --git a/apps/host/tests/user-args.test.mjs b/apps/host/tests/user-args.test.mjsnew file mode 100644index 000000000..b678934a6--- /dev/null+++ b/apps/host/tests/user-args.test.mjs@@ -0,0 +1,176 @@+/**+ * The person's own engine settings survive a load (#3215 #3270 #3216): a --vram-reserve-mib of 0, the Expert setting "GPU memory for other+ * apps", and engine arguments the app does not know (the control vector options). Nothing here starts an engine; Control is a fake that+ * records the run file the host saved and asked it to start.+ */+import test from 'node:test';+import assert from 'node:assert/strict';+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';+import { join } from 'node:path';+import { tmpdir } from 'node:os';+import { createNativeControl } from '../server/native-control.mjs';+import { resourceSettings, explicitReserve } from '../server/native-resources.mjs';+import { capture, merge, groups } from '../server/native-user-args.mjs';++const ARGS = ['--pack', '/p', '--expert-cache', 'auto', '--spec', '4', '--max-context', '40000', '--kv', 'int8'];+const CVEC = ['--control-vector-scaled', 'C:/vectors/mine.gguf:1.0', '--control-vector-layer-range', '4', '44', '--cvec-mode', 'project', '--cvec-dir', 'per-layer'];++function fixture(config = {}, { gpus = [{ index: 0, vram_gb: 12 }] } = {}) {+ const root = mkdtempSync(join(tmpdir(), 'strata-userargs-test-'));+ const install = join(root, 'install'), data = join(root, 'data');+ mkdirSync(install, { recursive: true });+ process.env.STRATA_INSTALL_DIR = install;+ const path = join(install, 'strata-q2_0.json');+ writeFileSync(path, JSON.stringify({ exe: 'component:strata-engine', tokenizer: join(install, 'tok'), args: ARGS, model_name: 'Qwen q2_0', port: 8080, ...config }));+ const saved = [];+ const control = {+ control: { dir: join(root, 'control') }, version: '0.2.0',+ async installedModels() { return { install_dir: install, models: [{ id: 'q2_0', name: 'Qwen q2_0', source_config: path, component_status: 'present', context_tokens: 40000 }] }; },+ async engine() { return { usable: true, backend: 'cuda', components_dir: 'E:\\c', engine: { version: '0.2.0', platform: 'windows-x86_64', backend: 'cuda', exe: 'E:\\e\\strata.exe', root: 'E:\\e' } }; },+ async saveProfile(name, file) { saved.push(JSON.parse(readFileSync(file, 'utf8'))); return {}; },+ async start() { return { ok: true, state: 'ready' }; },+ async stop() { return { ok: true }; },+ };+ const native = createNativeControl({ control, hardwareProbe: () => gpus, directory: data, spawnProcess: () => { throw new Error('no process'); }, fetcher: async () => Response.json({ status: 'ok' }), requests: () => [] });+ return { native, saved, path, read: () => JSON.parse(readFileSync(path, 'utf8')), write: c => writeFileSync(path, JSON.stringify(c)), cleanup: () => rmSync(root, { recursive: true, force: true }) };+}+const finish = async (native, id) => { for (let i = 0; i < 500; i++) { const job = native.state().jobs.find(j => j.id === id); if (job.state !== 'running') return job; await new Promise(r => setTimeout(r, 10)); } throw new Error('job did not finish'); };+const reserveOf = args => args[args.indexOf('--vram-reserve-mib') + 1];+const load = async (f, args = {}) => { const job = await finish(f.native, f.native.operation('load', { model: 'q2_0', vision: 'no', ...args }).id); assert.equal(job.state, 'done', job.error); return f.saved.at(-1); };++test('the rule: groups, merge and capture', () => {+ assert.deepEqual(groups(['--a', '1', '--b', '--c', 'x', 'y']), [['--a', '1'], ['--b'], ['--c', 'x', 'y']]);+ assert.deepEqual(merge(['--a', '1', '--b', '2'], ['--a', '9']), ['--b', '2', '--a', '9']);+ const written = [...ARGS, '--vram-reserve-mib', '1536'];+ assert.deepEqual(capture({ args: [...written, ...CVEC], args_written: written }), CVEC);+ assert.deepEqual(capture({ args: written, args_written: written }), []);+ assert.deepEqual(capture({ args: written.map(a => (a === '1536' ? '0' : a)), args_written: written }), ['--vram-reserve-mib', '0']);+ assert.deepEqual(capture({ args: ['--max-context', '1'], args_written: ['--max-context', '2'] }), [], 'the context is the app\'s own choice');+});++test('explicitReserve: any number the person set counts (0 too); the engine default, the app\'s own value and beta leftovers do not', () => {+ assert.equal(explicitReserve({ args: ['--vram-reserve-mib', '0'] }), 0);+ assert.equal(explicitReserve({ args: [], vram_reserve_mib: 0 }), 0);+ assert.equal(explicitReserve({ args: [], user_args: ['--vram-reserve-mib', '256'], vram_reserve_mib: 3000 }), 256);+ assert.equal(explicitReserve({ args: [], vram_reserve_mib: 3000 }, { vram_reserve_mib: 128 }), 128, 'the Expert setting of this load');+ assert.equal(explicitReserve({ args: ['--vram-reserve-mib', '700'] }), null, 'setup writes 700 for pictures: not a choice');+ assert.equal(explicitReserve({ args: [] }), null);+ // what the app wrote last is not the person's: the value and the note that it was the app's+ assert.equal(explicitReserve({ args: ['--vram-reserve-mib', '3276'], vram_reserve_mib: 3276, ui_reserve_applied: 3276 }), null);+ assert.equal(explicitReserve({ args: ['--vram-reserve-mib', '1024'], vram_reserve_mib: 1024, ui_reserve_applied: 3276 }), 1024, 'changed since: the person\'s');+ // a 0.2.0-beta file: the app wrote the same number in both places, without a note+ const beta = { args: ['--vram-reserve-mib', '1536'], vram_reserve_mib: 1536, ui_resource_baseline: { workers: 0, reserve: 700 } };+ assert.equal(explicitReserve(beta), null);+ assert.equal(explicitReserve({ ...beta, args: ['--vram-reserve-mib', '0'] }), 0, 'a different number in args is the person\'s');+});++test('3215: a reserve of 0 is kept on both resource profiles; the safety default stays where nothing was asked', () => {+ const display = { cpu: { cores: 12 }, ram_gb: 64, gpus: [{ index: 0, vram_gb: 12, drives_display: true }] };+ const headless = { cpu: { cores: 12 }, ram_gb: 64, gpus: [{ index: 0, vram_gb: 12, drives_display: false }] };+ const unknown = { cpu: { cores: 12 }, ram_gb: 64, gpus: [{ index: 0, vram_gb: 12 }] };+ const zero = { gpu: 0, args: ['--vram-reserve-mib', '0'] };+ for (const profile of ['work', 'performance']) for (const hw of [display, headless, unknown]) {+ const r = resourceSettings(zero, hw, profile);+ assert.equal(reserveOf(r.args), '0', `${profile}`);+ assert.equal(r.vram_reserve_mib, 0);+ assert.equal(r.ui_reserve_applied, undefined, 'the app did not choose it');+ }+ assert.equal(resourceSettings({ gpu: 0, args: [], vision: { gpu: true } }, display, 'performance').vram_reserve_mib, 2048, 'a display card with pictures: the safety default');+ assert.equal(resourceSettings({ gpu: 0, args: [] }, display, 'performance').vram_reserve_mib, 1536);+ assert.equal(resourceSettings({ gpu: 0, args: [] }, unknown, 'performance').vram_reserve_mib, 1536, 'not known to be headless: the safety default');+ assert.equal(resourceSettings({ gpu: 0, args: [] }, display, 'work').vram_reserve_mib, Math.floor(12 * 1024 * 0.2));+ // a card that drives no display: 512 MiB (700 with pictures), and "Leave 20% for my work" has no desktop to keep room for+ for (const profile of ['work', 'performance']) {+ assert.equal(resourceSettings({ gpu: 0, args: [] }, headless, profile).vram_reserve_mib, 512, profile);+ assert.equal(resourceSettings({ gpu: 0, args: [], vision: { gpu: true } }, headless, profile).vram_reserve_mib, 700, `${profile} with pictures`);+ }+ // two cards, one of them on the desktop+ const mixed = { ...display, gpus: [{ index: 0, vram_gb: 12, drives_display: false }, { index: 1, vram_gb: 12, drives_display: true }] };+ assert.equal(resourceSettings({ gpu: [0, 1], args: [] }, mixed, 'performance').vram_reserve_mib, 1536);+});++test('3215: the app load keeps --vram-reserve-mib 0 typed into the file, on every load', async () => {+ const f = fixture({ args: [...ARGS, '--vram-reserve-mib', '0'] });+ try {+ await f.native.refresh(true);+ for (let i = 0; i < 3; i++) {+ const run = await load(f, { resourceProfile: i === 1 ? 'performance' : 'work' });+ assert.equal(reserveOf(run.args), '0', `load ${i + 1}`);+ assert.equal(run.args.filter(a => a === '--vram-reserve-mib').length, 1);+ const file = f.read();+ assert.equal(reserveOf(file.args), '0', 'the file keeps it too');+ assert.deepEqual(file.user_args, ['--vram-reserve-mib', '0']);+ }+ } finally { await f.native.close(); f.cleanup(); }+});++test('3270: the Expert setting "GPU memory for other apps" is kept across loads, a lowered value is not reset, and clearing it brings the default back', async () => {+ const f = fixture({ args: [...ARGS, '--vram-reserve-mib', '2048'], args_written: [...ARGS, '--vram-reserve-mib', '2048'], vram_reserve_mib: 2048 });+ try {+ await f.native.refresh(true);+ await load(f, { resourceProfile: 'work' }); // the app's own load first: its numbers are in the file now+ f.native.save('q2_0', { values: { vram_reserve_mib: 1024 } });+ for (let i = 0; i < 2; i++) {+ const run = await load(f, { resourceProfile: 'work' });+ assert.equal(reserveOf(run.args), '1024', `load ${i + 1}`);+ assert.equal(f.read().vram_reserve_mib, 1024);+ assert.equal(reserveOf(f.read().args), '1024');+ }+ f.native.save('q2_0', { values: { vram_reserve_mib: 300 } });+ assert.equal(reserveOf((await load(f, { resourceProfile: 'performance' })).args), '300');+ // edited by hand in both places of the file+ const hand = f.read(); hand.vram_reserve_mib = 900; hand.args = hand.args.map(a => (a === '300' ? '900' : a)); f.write(hand);+ assert.equal(reserveOf((await load(f, { resourceProfile: 'work' })).args), '900');+ // the value of this load alone+ assert.equal(reserveOf((await load(f, { resourceProfile: 'work', values: { vram_reserve_mib: 128 } })).args), '128');+ f.native.save('q2_0', { values: { vram_reserve_mib: null } });+ const cleared = f.read();+ assert.equal('vram_reserve_mib' in cleared, false);+ assert.equal(cleared.args.includes('--vram-reserve-mib'), false);+ assert.equal(cleared.user_args, undefined);+ assert.equal(reserveOf((await load(f, { resourceProfile: 'performance' })).args), '1536', 'nothing asked: the safety default');+ } finally { await f.native.close(); f.cleanup(); }+});++test('3270: a 0.2.0-beta file (the app wrote 1536 itself) is not taken for the person\'s choice, but a number they changed is', async () => {+ const f = fixture({ args: [...ARGS, '--vram-reserve-mib', '1536'], vram_reserve_mib: 1536, ui_resource_profile: 'work', ui_resource_baseline: { workers: 0, reserve: 700, ramBudget: false, ramHeadroom: false } });+ try {+ await f.native.refresh(true);+ assert.equal(reserveOf((await load(f, { resourceProfile: 'performance' })).args), '1536');+ const edited = f.read(); edited.args = edited.args.map(a => (a === '1536' ? '1024' : a)); f.write(edited);+ assert.equal(reserveOf((await load(f, { resourceProfile: 'performance' })).args), '1024');+ } finally { await f.native.close(); f.cleanup(); }+});++test('3216: engine arguments the app does not know (control vectors) survive a load and a setup run that rewrites "args"', async () => {+ // setup wrote ARGS (and a copy of them); the person typed the control vector options into the JSON editor+ const f = fixture({ args: [...ARGS, ...CVEC], args_written: ARGS });+ try {+ await f.native.refresh(true);+ const run = await load(f, { resourceProfile: 'work' });+ assert.deepEqual(run.args.slice(run.args.indexOf('--control-vector-scaled'), run.args.indexOf('--control-vector-scaled') + 9), CVEC);+ const file = f.read();+ assert.deepEqual(file.user_args, CVEC);+ assert.ok(file.args.join(' ').includes(CVEC.join(' ')), 'the file keeps them in "args" too');+ // a setup run rewrites "args" from its own choices and carries user_args along (setup.py carry_user_args)+ f.write({ ...file, args: [...ARGS, '--max-context', '65536'], args_written: undefined });+ const again = await load(f, { resourceProfile: 'work' });+ assert.ok(again.args.join(' ').includes(CVEC.join(' ')), 'still there after the rewrite');+ assert.equal(again.args.filter(a => a === '--cvec-mode').length, 1);+ assert.deepEqual(f.read().user_args, CVEC);+ // removing them from "user_args" and "args" by hand takes them off for good+ const bare = f.read(); bare.user_args = undefined; bare.args = [...ARGS]; bare.args_written = [...ARGS]; f.write(bare);+ assert.ok(!(await load(f, { resourceProfile: 'work' })).args.includes('--cvec-mode'));+ } finally { await f.native.close(); f.cleanup(); }+});++test('3216: without any resource preference the load keeps them too, and the person\'s value beats a generated one for the same option', async () => {+ const f = fixture({ args: ARGS.map(a => (a === '4' ? '2' : a)), args_written: ARGS });+ try {+ await f.native.refresh(true);+ const run = await load(f); // no resourceProfile: the plain path+ assert.equal(run.args.filter(a => a === '--spec').length, 1);+ assert.equal(run.args[run.args.indexOf('--spec') + 1], '2', 'a hand-changed --spec is the person\'s');+ assert.deepEqual(f.read().user_args, ['--spec', '2']);+ } finally { await f.native.close(); f.cleanup(); }+});diff --git a/docs/TROUBLESHOOTING.md b/docs/TROUBLESHOOTING.mdindex ac541308b..e2c206a98 100644--- a/docs/TROUBLESHOOTING.md+++ b/docs/TROUBLESHOOTING.md@@ -66,13 +66,23 @@ for one model: in the app, Models, Expert settings, "Draft layer (MTP)": Off; inmodel's `strata-<model>.json`. The choice is kept per model and applied on every start.**I changed `strata-<model>.json` by hand and the change came back.**-The app and `START-HERE` own the `args` list and the `vision` section of that file: whenever you prepare a model, change its-context size or its picture setting, or use "Download / repair", setup writes both again from its own choices. It keeps every-other key (`sampling`, `mcp_servers`, `mtp`, `ui_vision_enabled`, `parallel`, ...) and the earlier file as-`strata-<model>.json.bak`. So put your choice where it is kept: `"mtp": false` for the draft layer, the picture tick in the-Models screen (saved as `ui_vision_enabled`), and the context size in the Models screen. Hand-editing `args` still works for-a model you only start (the `START-HERE` run file and `strata launch` both read the file as it is); setup says which options it-dropped and where the earlier file is.+Engine options you add to `args` by hand (control vectors, `--spec`, `--vram-reserve-mib 0`, anything the app does not offer)+are kept. The file has two helper keys for this. `user_args` lists your options; every start and every setup run puts them+over the ones the app generates, and for the same option your value wins. `args_written` is a copy of `args` as the app last+wrote it, so an option you added or changed in `args` is noticed and moved into `user_args` the next time the app or setup+touches the file. To undo one, delete it from both `args` and `user_args`. A value you save in the app's Expert settings+("GPU memory for other apps") is put in `user_args` for you.++Two things the app still chooses itself: the context size, KV type, picture reading and draft layer. Set them in the Models+screen, or with `"mtp": false` (draft layer). The app keeps the earlier file as `strata-<model>.json.bak`.++**The app keeps more graphics memory free than I want (decode is slower than in 0.1.45).**+Without a value of yours the app keeps 1536 MiB free (2048 with picture reading) on a card that drives a display, and 512 MiB+(700 with pictures) on a card that has no display attached, such as a second GPU with the screen on the integrated one. It+reads that from the driver (nvidia-smi `display_active`, or the Windows adapter that has the desktop); when it cannot tell, it+assumes a display. Your own value is never raised or lowered: set "GPU memory for other apps" in Expert settings, or+`--vram-reserve-mib 0` in `args`. The engine's own warning about low free memory stays; a card that also draws the desktop+can freeze or slow to a few tokens a second with a very small reserve.**It stopped while downloading or installing.**Run `START-HERE.bat` (Linux: `./setup.sh`) again. It continues where it stopped.diff --git a/serve/runconfig.py b/serve/runconfig.pyindex 741680d9f..1d84ba8ef 100644--- a/serve/runconfig.py+++ b/serve/runconfig.py@@ -14,6 +14,8 @@ import osimport shutilfrom pathlib import Path+from strata_control import user_args+# (key, kind, help). kind: "bool", "int>=0", "num>=0", ("enum", values), "names", or ("sampling", check) for a key# of the "sampling" block, ("arg", flag) for an engine option kept in "args".EDITABLE = [@@ -155,6 +157,13 @@ def apply(cfg: dict, changes: dict) -> tuple[dict, list[str]]:elif v is not None:a += [flag, str(v)]new["args"] = a+ mine = user_args.set_flag(user_args.capture(new), flag, v) # a value set here is the person's: it survives setup and the app+ if mine:+ new[user_args.USER_KEY] = mine+ else:+ new.pop(user_args.USER_KEY, None)+ if user_args.WRITTEN_KEY in new:+ new[user_args.WRITTEN_KEY] = list(a)elif v is None:new.pop(key, None)else:diff --git a/serve/server.py b/serve/server.pyindex 94a488c66..68433809b 100644--- a/serve/server.py+++ b/serve/server.py@@ -69,6 +69,7 @@ from strata_control import engine_component # noqa: E402from strata_control import hipblaslt_tuning # noqa: E402from strata_control import vision_reader # noqa: E402from strata_control import draft_layer # noqa: E402+from strata_control import user_args # noqa: E402from serve import ready as ready_file # noqa: E402from serve import owner_guard # noqa: E402from serve import launch_identity # noqa: E402@@ -2873,6 +2874,10 @@ def engine_args(cfg: dict) -> list[str]:config: "auto" by default, or the first layer of each later GPU's share, e.g. "18" or "16,32"; seelayer_split_value)."""args = list(cfg["args"])+ # "user_args" (strata_control/user_args.py): the options the person set by hand, over the generated ones at every start,+ # so a setup run or the app rewriting "args" cannot undo them (#3216 #3215 #3270)+ if cfg.get("user_args"):+ args = user_args.merge(args, cfg["user_args"])# "mtp": false (the Models settings, `strata launch --mtp off`, or by hand): no draft layer, whatever the args say. A setup run# that writes --mtp back into the args cannot undo it, because this is applied at every start.if draft_layer.is_off(cfg):diff --git a/setup.py b/setup.pyindex aa39757bf..8cede166d 100644--- a/setup.py+++ b/setup.py@@ -64,6 +64,7 @@ from pathlib import Pathfrom strata_control import acquisitionfrom strata_control import draft_layer+from strata_control import user_argsROOT = Path(__file__).resolve().parent# The desktop app runs this installer under Strata Control (its bundled Python, STRATA_CONTROL_INSTALL=1). The source@@ -5487,8 +5488,10 @@ def write_config(path: Path, cfg: dict):# #629: the run config's keys setup writes itself (and rewrites on every setup run); any other key is the user's - a# "sampling" or "mcp_servers" block, "allowed_hosts", "cors_origins", "open_browser" - and is kept when setup runs again+# "args_written" (strata_control/user_args.py) is setup's own; "user_args" is not in SETUP_KEYS on purpose: carry_over keeps it,+# then applies the person's options over the generated onesSETUP_KEYS = frozenset({"exe", "args", "cwd", "tokenizer", "model_name", "log", "lib_dirs", "port", "backend", "env",- "gpu", "gpus_asked", "layer_split", "host", "api_key", "draft_vocab", "vision"})+ "gpu", "gpus_asked", "layer_split", "host", "api_key", "draft_vocab", "vision", "args_written"})SETUP_ENV = frozenset({"STRATA_HIPBLASLT_TUNING", "STRATA_ROCBLAS_TUNING", "STRATA_RESIDENT_PIN", "STRATA_NO_ARENA_THP", "STRATA_MMQ_KQ", "STRATA_HC_Q8","STRATA_ROUTE_TAIL_SKIP"}) | frozenset(GFX1103_SWITCHES) | frozenset(GFX1150_SWITCHES) # the "env" entries setup writes (the gfx1103 switches are setup's too: a re-run refreshes them, they do not linger)# 0.1.44 added these three, written for Unsloth's files only (unsloth_default_env). In any other model's config they are the@@ -5498,12 +5501,13 @@ SETUP_ENV_UNSLOTH = frozenset({"STRATA_MMQ_KQ", "STRATA_HC_Q8", "STRATA_ROUTE_TASETUP_VISION = frozenset({"exe", "cpu_exe", "mmproj", "model", "gpu", "max_tokens", "threads"})-def carry_over(old: dict, cfg: dict) -> list[str]:+def carry_over(old: dict, cfg: dict, explicit: list[str] | None = None) -> list[str]:"""#629: setup run again for an installed model keeps what the user added to its run config: every key setup doesnot write (`SETUP_KEYS`), the "env" entries setup does not write, and in "vision" the keys setup does not writeplus an mmproj of their own (a Q8_0 one, #625) that still exists. `cfg` (the new config) is updated in place;the names of what was kept are returned. Engine options added by hand to "args" are not merged (setup chooses- those): `args_dropped` names them."""+ those): `args_dropped` names them. `explicit`: engine options given on this run's command line (they win and are+ kept from now on, see carry_user_args)."""kept = []for k, v in old.items():if k not in SETUP_KEYS and k not in cfg:@@ -5526,12 +5530,69 @@ def carry_over(old: dict, cfg: dict) -> list[str]:nv["mmproj"] = mmkept.append("vision mmproj")kept += carry_profile_args(old, cfg)+ kept += carry_user_args(old, cfg, explicit)off = draft_layer.apply(cfg) # "mtp": false was the user's (a key setup does not write): the new args honour itif off:kept.append("mtp off (" + " ".join(off) + " left out of args)")return kept+# the options setup chooses itself on every run from its answers (context, KV type, pictures, the draft layer, the layer split):+# a hand edit of one of these is carried by the answers (choices_from_config) or by its own key ("mtp", "vision"), not by user_args+SETUP_CHOICE_FLAGS = frozenset({"--max-context", "--kv", "--vision", "--mtp", "--spec-min-p", "--batch-mtp", "--layer-split"})+++def setup_flags() -> frozenset:+ """Every engine option this file names (setup.py's own source): the options setup can write. Used for a run config+ that has no `args_written` (written by an earlier Strata): an option in its args that is not in this set was added by hand."""+ global _SETUP_FLAGS+ if _SETUP_FLAGS is None:+ try:+ text = Path(__file__).read_text(encoding="utf-8")+ _SETUP_FLAGS = frozenset(re.findall(r'"(--[a-z][a-z0-9-]+)"', text))+ except OSError:+ _SETUP_FLAGS = frozenset()+ return _SETUP_FLAGS+++_SETUP_FLAGS = None+++def explicit_args(a) -> list[str]:+ """The engine options this run's command line sets that the person keeps from now on (user_args): --vram-reserve-mib."""+ n = getattr(a, "vram_reserve_mib", None)+ return ["--vram-reserve-mib", str(n)] if n is not None else []+++def carry_user_args(old: dict, cfg: dict, explicit: list[str] | None = None) -> list[str]:+ """#3216 #3215 #3270: the engine options the person set by hand in the earlier run config are put back over the+ generated ones, and recorded in the new one's "user_args" (strata_control/user_args.py). They are the earlier+ "user_args", the options of "args" that differ from "args_written" (hand edits), for a config with no "args_written"+ the options its args had and the new ones do not (control vectors, --spec, ...) and an explicit --vram-reserve-mib of+ the earlier file. `explicit`: options given on this run's command line, which win. The names kept are returned."""+ nargs = cfg.get("args")+ if not isinstance(nargs, list):+ return []+ mine = user_args.capture(old, SETUP_CHOICE_FLAGS)+ oargs = old.get("args")+ if user_args.WRITTEN_KEY not in old and isinstance(oargs, list):+ have = {user_args.flag_of(g) for g in user_args.groups(mine)}+ mine += user_args.flat([g for g in user_args.groups(user_args.dropped_by_setup(oargs, nargs, setup_flags(), SETUP_CHOICE_FLAGS))+ if user_args.flag_of(g) not in have])+ reserve = flag_value(oargs, "--vram-reserve-mib") # an old file: the reserve it names, unless it is the vision default or the app's own+ vis = isinstance(old.get("vision"), dict)+ if reserve is not None and reserve.isdigit() and not (vis and int(reserve) == VISION["gpu"]["reserve_mib"]) and "ui_resource_baseline" not in old and "--vram-reserve-mib" not in mine:+ mine += ["--vram-reserve-mib", reserve]+ for g in user_args.groups(explicit or []):+ mine = user_args.merge(mine, g)+ if not mine:+ user_args.stamp(cfg, [])+ return []+ cfg["args"] = user_args.merge(nargs, mine)+ user_args.stamp(cfg, mine)+ return ["args " + f for f in dict.fromkeys(g[0] for g in user_args.groups(mine) if g[0].startswith("--"))]++def flag_value(args: list, flag: str):"""The value after `flag` in an argument list, or None."""for i, a in enumerate(args[:-1]):@@ -5575,7 +5636,7 @@ def engine_exe(eng: Path) -> str:return "component:strata-engine" if CONTROL else str(eng / EXE)-def write_setup_config(cfg_path: Path, cfg: dict, source: Path | None = None) -> None:+def write_setup_config(cfg_path: Path, cfg: dict, source: Path | None = None, explicit: list[str] | None = None) -> None:"""#629: setup's run config, written over an earlier one for the same model without losing what the user addedto it: the keys setup does not write are carried over (carry_over), and the earlier file is kept asstrata-<model>.json.bak when it changes. `source`: an earlier install's config to carry the keys over from when@@ -5589,7 +5650,10 @@ def write_setup_config(cfg_path: Path, cfg: dict, source: Path | None = None) ->passif not isinstance(old, dict):old = None- kept = carry_over(old, cfg) if old is not None else []+ kept = carry_over(old, cfg, explicit) if old is not None else []+ if old is None:+ carry_user_args({}, cfg, explicit) # a first install: only what this run's command line sets (nothing to report as kept)+ user_args.stamp(cfg) # args_written: what setup wrote, for the next hand-edit checkif "images" in cfg and cfg["images"] is None: # --images no (or not downloaded): no image sectioncfg.pop("images")bak = None@@ -5994,6 +6058,9 @@ def _start(cfg_path: Path, port: int | None, gpu: int | list | None = None, openargs[args.index("--vram-reserve-mib") + 1] = str(reserve)else:args += ["--vram-reserve-mib", str(reserve)]+ cfg[user_args.USER_KEY] = user_args.set_flag(user_args.capture(cfg), "--vram-reserve-mib", reserve) # the person's own value: kept by every later setup run and start+ if user_args.WRITTEN_KEY in cfg:+ cfg[user_args.WRITTEN_KEY] = list(cfg["args"])write_config(cfg_path, cfg)ok(f"saved for this model: {reserve} MiB of VRAM kept free for other programs (--vram-reserve-mib)")if keep and any(cfg.get(k) != v for k, v in keep.items()): # #179: a --host/--api-key on a start was ignored@@ -6946,7 +7013,7 @@ def install_own_path(a, family, gpu, hip, amd, cuda_tk, multi, port, ram, adopteelse:cfg["parallel"] = 1ok("parallel requests: one at a time (--parallel 1)")- write_setup_config(cfg_path, cfg, adopted if adopted is not None and adopted.name == cfg_path.name else None)+ write_setup_config(cfg_path, cfg, adopted if adopted is not None and adopted.name == cfg_path.name else None, explicit_args(a))script = write_run_script(tag, cfg_path, port, cfg.get("open_browser") is not False)ok(f"start script: {script.name}")say()@@ -8443,7 +8510,7 @@ def main() -> int:say(" " + line)for line in bench_tips(cfg["args"], cfg.get("env"), ram, MODELS[model]["ram_gb"], gpu.get("vram_gb", 0.0), vision, WIN):say(" " + line)- write_setup_config(cfg_path, cfg, adopted if adopted is not None and adopted.name == cfg_path.name else None)+ write_setup_config(cfg_path, cfg, adopted if adopted is not None and adopted.name == cfg_path.name else None, explicit_args(a))script = write_run_script(tag, cfg_path, port, cfg.get("open_browser") is not False)# offered only when someone answers: --yes installs and adopted earlier installs are not held up by itif cal is None and not hip and not a.no_start and not a.yes and ask(diff --git a/strata_control/tune_apply.py b/strata_control/tune_apply.pyindex 6aced3faa..70d4c6642 100644--- a/strata_control/tune_apply.py+++ b/strata_control/tune_apply.py@@ -41,6 +41,8 @@ from dataclasses import dataclassfrom pathlib import Pathfrom typing import Any, Callable, Sequence+from strata_control import user_args+SCHEMA_VERSION = 1@@ -152,6 +154,14 @@ def apply_args_to_config(config: dict[str, Any], argv: Sequence[str]) -> dict[stfor flag in sorted(wanted):stripped.extend(wanted[flag])candidate["args"] = stripped+ # The person's own options (user_args, strata_control/user_args.py) are kept, except the flags this recommendation sets: a tuning+ # the person asks for is their newer choice. The hand edits so far are recorded first, so writing "args" here loses none.+ if candidate.get(user_args.WRITTEN_KEY) is not None or candidate.get(user_args.USER_KEY):+ mine = user_args.capture(config)+ mine = user_args.flat([g for g in user_args.groups(mine) if user_args.flag_of(g) not in wanted])+ user_args.stamp(candidate, mine)+ if user_args.WRITTEN_KEY not in config:+ candidate.pop(user_args.WRITTEN_KEY, None)return candidatediff --git a/strata_control/user_args.py b/strata_control/user_args.pynew file mode 100644index 000000000..ce698aa14--- /dev/null+++ b/strata_control/user_args.py@@ -0,0 +1,118 @@+"""The engine options a person set by hand in a model's run config (strata-<model>.json).++Setup and the app write ``"args"`` from their own choices, and used to write it again on every run, so an option added by+hand (the control vector options, a --vram-reserve-mib of 0, --spec, ...) was gone after the next Load (#3216 #3215 #3270).+The run config now keeps what the person set apart from what was generated:++* ``"user_args"``: the person's options, in the same form as ``"args"`` (``["--vram-reserve-mib", "0", ...]``). Every start+ (serve/server.py engine_args) and every setup run applies them on top of the generated ones; for the same flag the+ person's value wins. The person can edit this list by hand; the app's settings window writes the options it shows here.+* ``"args_written"``: the whole ``"args"`` as setup or the app last wrote it. An option in ``"args"`` that is not in this+ copy was added or changed by hand since: ``capture`` moves it into ``"user_args"``. A config without the copy (one an+ older Strata wrote) has nothing to compare with: setup then keeps the options of the old file that its new arguments do not+ have (see ``dropped_by_setup``).++Writers that change ``"args"`` themselves (setup, the app's resource profile, a tuning run) call ``stamp`` after they have+captured, so their own changes are never mistaken for the person's.+"""++from __future__ import annotations++from typing import Any++USER_KEY = "user_args"+WRITTEN_KEY = "args_written"++#: option groups the engine takes more than one of, or that make sense only together: kept whole+#: (the control vector options of the experimental speed projection and the person's own vectors, #3216)+USER_KEPT_FLAGS = frozenset({"--control-vector", "--control-vector-scaled", "--control-vector-layer-range", "--cvec-mode",+ "--cvec-dir"})+++def groups(args: Any) -> list[list[str]]:+ """Split an argument list into groups: an option and the values after it (up to the next ``--option``)."""+ out: list[list[str]] = []+ for a in args if isinstance(args, list) else []:+ a = str(a)+ if a.startswith("--") or not out:+ out.append([a])+ else:+ out[-1].append(a)+ return out+++def flat(gs: list[list[str]]) -> list[str]:+ return [t for g in gs for t in g]+++def flag_of(group: list[str]) -> str:+ return group[0] if group and group[0].startswith("--") else ""+++def merge(args: Any, user: Any) -> list[str]:+ """``args`` with the person's options on top: every group of ``args`` whose option the person set is replaced."""+ ug = groups(user)+ mine = {flag_of(g) for g in ug if flag_of(g)}+ kept = [g for g in groups(args) if flag_of(g) not in mine]+ return flat(kept + ug)+++def apply(cfg: dict) -> list[str]:+ """Puts the config's ``user_args`` over its ``args`` (in place); returns the options applied."""+ ug = groups(cfg.get(USER_KEY))+ if not ug or not isinstance(cfg.get("args"), list):+ return []+ cfg["args"] = merge(cfg["args"], flat(ug))+ return [flag_of(g) for g in ug if flag_of(g)]+++def _by_flag(gs: list[list[str]]) -> dict[str, list[list[str]]]:+ d: dict[str, list[list[str]]] = {}+ for g in gs:+ d.setdefault(flag_of(g), []).append(g)+ return d+++def capture(cfg: dict, skip=frozenset()) -> list[str]:+ """The person's options of a config: its ``user_args``, with the options of ``args`` that differ from ``args_written``+ (added or changed by hand since the last write) on top. Without ``args_written`` only ``user_args`` is returned.+ ``skip``: options the caller chooses itself (setup's context, KV type, pictures, draft layer), never taken from ``args``."""+ mine = _by_flag(groups(cfg.get(USER_KEY)))+ written = cfg.get(WRITTEN_KEY)+ if isinstance(written, list) and isinstance(cfg.get("args"), list):+ cur, was = _by_flag(groups(cfg["args"])), _by_flag(groups(written))+ for flag, gs in cur.items():+ if flag and flag not in skip and was.get(flag) != gs:+ mine[flag] = gs # added, or its value changed, by hand+ for flag in list(mine):+ if flag in was and flag not in cur:+ del mine[flag] # taken out of "args" by hand: the person no longer wants it+ return flat([g for gs in mine.values() for g in gs])+++def stamp(cfg: dict, user: list[str] | None = None) -> None:+ """Records ``cfg["args"]`` as written (call after the last change to it) and ``user`` as the person's options."""+ if user is not None:+ if user:+ cfg[USER_KEY] = list(user)+ else:+ cfg.pop(USER_KEY, None)+ if isinstance(cfg.get("args"), list):+ cfg[WRITTEN_KEY] = list(cfg["args"])+++def dropped_by_setup(old_args: Any, new_args: Any, setup_flags: set[str] | frozenset[str], skip=frozenset()) -> list[str]:+ """For an old config with no ``args_written``: its options that the new arguments do not have and that setup never+ writes (``setup_flags``: every option setup.py names), plus the control vector options. These were added by hand."""+ have = {flag_of(g) for g in groups(new_args)}+ out = [g for g in groups(old_args) if flag_of(g) and flag_of(g) not in have and flag_of(g) not in skip+ and (flag_of(g) not in setup_flags or flag_of(g) in USER_KEPT_FLAGS)]+ return flat(out)+++def set_flag(user: list[str], flag: str, value: Any) -> list[str]:+ """``user`` with ``flag`` set to ``value`` (None: the person's option removed)."""+ rest = [g for g in groups(user) if flag_of(g) != flag]+ if value is not None:+ rest.append([flag, str(value)])+ return flat(rest)diff --git a/tools/strata_mcp.py b/tools/strata_mcp.pyindex f9ddcc04f..37e14b8b0 100644--- a/tools/strata_mcp.py+++ b/tools/strata_mcp.py@@ -868,6 +868,10 @@ class Strata:for g in amd: # a Ryzen's integrated graphics beside an NVIDIA card: the engine runs on the NVIDIA cardif g.get("uma") and g.get("usable"):g["usable"], g["problem"] = False, "integrated graphics: Strata uses the NVIDIA card in this computer"+ try: # does the card drive a display? (the app keeps less VRAM free on one that does not, #3215)+ mark_display(nv + amd, nvidia_display_active() if nv else {}, windows_desktop_adapters() if WIN and amd else [])+ except Exception: # noqa: BLE001 - unknown stays unknown: the app then keeps its safety default+ passhw["gpus"] = nv + amdself._engine_vendor(hw)if WIN:@@ -1436,6 +1440,43 @@ def own_nvidia_gpus() -> list:return found+def nvidia_display_active() -> dict:+ """{GPU index: True when a display is attached to the card} from nvidia-smi (display_active Enabled); {} when it says nothing."""+ found = {}+ for line in run_quiet(["nvidia-smi", "--query-gpu=index,display_active", "--format=csv,noheader"]).strip().splitlines():+ idx, _, state = line.partition(",")+ if idx.strip().isdigit() and state.strip().lower() in ("enabled", "disabled"):+ found[int(idx)] = state.strip().lower() == "enabled"+ return found+++def windows_desktop_adapters() -> list:+ """The PNPDeviceIDs of the Windows display adapters that have a desktop resolution (a monitor is attached to them)."""+ out = []+ for line in run_quiet(["powershell", "-NoProfile", "-NonInteractive", "-Command",+ "Get-CimInstance Win32_VideoController | ForEach-Object { $_.PNPDeviceID + '|' + $_.CurrentHorizontalResolution }"]+ ).splitlines():+ pnp, _, res = line.strip().rpartition("|")+ if pnp and res.strip().isdigit() and int(res) > 0:+ out.append(pnp)+ return out+++def mark_display(gpus: list, nvidia_active: dict, desktop_pnp: list) -> None:+ """Sets g["drives_display"] (True / False) on the cards that can be told, from nvidia-smi (NVIDIA) and the Windows adapters that have a desktop+ resolution (AMD and Intel, matched by PCI device id; two cards of one model are not told apart: left unknown). A card left without the key is+ unknown, and the app treats an unknown card as one that drives a display."""+ desk = [str(p).upper() for p in desktop_pnp]+ for g in gpus:+ if g.get("vendor") == "nvidia" and g.get("index") in nvidia_active:+ g["drives_display"] = nvidia_active[g["index"]]+ elif g.get("vendor") == "amd" and isinstance(g.get("pci_id"), int) and desktop_pnp is not None and desktop_pnp:+ tag = f"DEV_{g['pci_id']:04X}"+ twins = [x for x in gpus if x.get("vendor") == "amd" and x.get("pci_id") == g["pci_id"]]+ if len(twins) == 1:+ g["drives_display"] = any(tag in p and "VEN_1002" in p for p in desk)++def windows_video_controllers() -> list:s = run_quiet(["powershell", "-NoProfile", "-NonInteractive", "-Command","Get-CimInstance Win32_VideoController | Select-Object Name,DriverVersion | ConvertTo-Json -Compress"])diff --git a/tools/test_setup_config.py b/tools/test_setup_config.pyindex daf0ced2e..25c9457db 100644--- a/tools/test_setup_config.py+++ b/tools/test_setup_config.py@@ -53,11 +53,12 @@ class CarryOver(unittest.TestCase):self.assertEqual(cfg[k], v, k)a = cfg["args"]self.assertEqual(a[a.index("--max-context") + 1], "131072") # the new choice is used- self.assertNotIn("--hand-option", a) # setup chooses the engine options...+ self.assertEqual(a[a.index("--hand-option") + 1], "7") # an option added by hand is kept (#3216)...+ self.assertEqual(cfg["user_args"], ["--hand-option", "7"]) # ...and recorded as the person'sself.assertIn("kept from your earlier strata-q2_0.json: sampling, mcp_servers, mcp, cors_origins, ""reasoning_effort", out)self.assertIn("kept as strata-q2_0.json.bak", out)- self.assertIn("--hand-option", out) # ...and says which ones it did not keep+ self.assertIn("args --hand-option", out) # ...and the run says it was keptdef test_a_first_install_is_unchanged(self):code, out, cfg, _ = self.run_setup()@@ -111,7 +112,7 @@ class CarryOver(unittest.TestCase):p = Path(d) / "strata-x.json"p.write_text("{cut off", encoding="utf-8")quiet(setup.write_setup_config, p, {"exe": "e", "args": []})- self.assertEqual(json.loads(p.read_text(encoding="utf-8")), {"exe": "e", "args": []})+ self.assertEqual(json.loads(p.read_text(encoding="utf-8")), {"exe": "e", "args": [], "args_written": []})self.assertEqual((Path(d) / "strata-x.json.bak").read_text(encoding="utf-8"), "{cut off")def test_display_tip_and_typed_ahead_flush(self):diff --git a/tools/test_setup_golden.py b/tools/test_setup_golden.pyindex 18239701b..03a439d1b 100644--- a/tools/test_setup_golden.py+++ b/tools/test_setup_golden.py@@ -140,6 +140,8 @@ def install(ram, found, argv, answers=None, extra=(), avx512=False, configs=()):cfg = Noneif written and code == 0:cfg = normalize(json.loads(written[-1].read_text(encoding="utf-8")), t)+ # "args_written" (strata_control/user_args.py): the arguments as setup wrote them, so a later hand edit can be told; the golden configs keep their own keys+ assert cfg.pop("args_written", cfg.get("args")) == cfg.get("args"), "args_written is not the written args"return code, out.getvalue(), cfg, askeddiff --git a/tools/test_setup_qwen36.py b/tools/test_setup_qwen36.pyindex 1af98b3ea..2d47302bd 100644--- a/tools/test_setup_qwen36.py+++ b/tools/test_setup_qwen36.py@@ -101,7 +101,7 @@ class InstallOwnPath(unittest.TestCase):(eng / setup.HVEXE).write_text("x")return self.root / "llama", eng, {"version": "0.1.44"}, ["/libs"], gpu, vision- def write_cfg(path, cfg, source=None):+ def write_cfg(path, cfg, source=None, explicit=None):self.cfg = cfgself.calls.append(("config", path.name))diff --git a/tools/test_user_args.py b/tools/test_user_args.pynew file mode 100644index 000000000..83878cb94--- /dev/null+++ b/tools/test_user_args.py@@ -0,0 +1,192 @@+"""The engine options a person set by hand survive setup, the app and every start (#3216 control vectors, #3215 and #3270+--vram-reserve-mib). strata_control/user_args.py is the rule; setup.carry_over, serve/server.py engine_args, serve/runconfig.py+and strata_control/tune_apply.py use it. Every outside effect is mocked (tools/test_setup_golden.py's install()).++ python -m unittest tools.test_user_args+"""+from __future__ import annotations++import contextlib+import io+import sys+import unittest+from pathlib import Path++ROOT = Path(__file__).resolve().parents[1]+sys.path.insert(0, str(ROOT))+sys.path.insert(0, str(ROOT / "tools"))+import setup # noqa: E402+import strata_mcp # noqa: E402+from serve import runconfig # noqa: E402+from serve.server import engine_args # noqa: E402+from strata_control import tune_apply, user_args # noqa: E402+from test_setup_golden import PROFILES, install # noqa: E402++CVEC = ["--control-vector-scaled", "C:/vectors/mine.gguf:1.0", "--control-vector-layer-range", "4", "44",+ "--cvec-mode", "project", "--cvec-dir", "per-layer"]+++def value(args, flag):+ return args[args.index(flag) + 1] if flag in args[:-1] else None+++class Rule(unittest.TestCase):+ def test_groups_and_merge(self):+ self.assertEqual(user_args.groups(["--a", "1", "--b", "--c", "x", "y"]), [["--a", "1"], ["--b"], ["--c", "x", "y"]])+ self.assertEqual(user_args.merge(["--a", "1", "--b", "2", "--a", "3"], ["--a", "9", "--z"]), ["--b", "2", "--a", "9", "--z"])+ self.assertEqual(user_args.merge(["--a", "1"], []), ["--a", "1"])++ def test_capture_tells_hand_edits_from_what_was_written(self):+ written = ["--max-context", "32768", "--vram-reserve-mib", "700", "--spec", "4"]+ cfg = {"args": written + CVEC, "args_written": written}+ self.assertEqual(user_args.capture(cfg), CVEC)+ cfg = {"args": ["--max-context", "32768", "--vram-reserve-mib", "0", "--spec", "4"], "args_written": written}+ self.assertEqual(user_args.capture(cfg), ["--vram-reserve-mib", "0"])+ self.assertEqual(user_args.capture({**cfg, "args": written}), []) # nothing changed+ # the context is setup's own choice: a hand edit of it is not taken as an override+ self.assertEqual(user_args.capture({"args": ["--max-context", "1"], "args_written": ["--max-context", "2"]},+ setup.SETUP_CHOICE_FLAGS), [])+ # an option taken out of "args" by hand is the person's no more+ self.assertEqual(user_args.capture({"args": written[:4], "args_written": written, "user_args": ["--spec", "2"]}), [])+ self.assertEqual(user_args.capture({"args": written, "args_written": written, "user_args": ["--spec", "2"]}), ["--spec", "2"]) # user_args stands+ # no copy of what was written: only user_args is known+ self.assertEqual(user_args.capture({"args": CVEC, "user_args": ["--a", "1"]}), ["--a", "1"])+++class SetupRerun(unittest.TestCase):+ """The app's Load runs setup again whenever the context, KV type or pictures differ from the installed ones."""++ def setUp(self):+ self.ram, self.found = PROFILES["64GB-1x32GB"]++ def run_setup(self, *extra, configs=()):+ return install(self.ram, self.found, ["--family", "qwen", "--model", "Q2_0", "--no-start", *extra], configs=configs)++ def first(self):+ code, out, first, _ = self.run_setup("--context", "65536")+ self.assertEqual(code, 0, out)+ return first++ def test_3216_control_vector_arguments_survive_a_load(self):+ first = self.first()+ old = {**first, "args": first["args"] + CVEC, "args_written": first["args"]} # typed into the JSON editor+ code, out, cfg, _ = self.run_setup("--context", "131072", configs=[("strata-q2_0.json", old)])+ self.assertEqual(code, 0, out)+ a = cfg["args"]+ self.assertEqual(a[a.index("--control-vector-scaled"):][:9], CVEC)+ self.assertEqual(value(a, "--max-context"), "131072") # setup's own choice still applies+ self.assertEqual(cfg["user_args"], CVEC)+ # the second Load: the options are in user_args, so they stay+ code, out, again, _ = self.run_setup("--context", "65536", configs=[("strata-q2_0.json", cfg)])+ self.assertEqual(again["user_args"], CVEC)+ self.assertEqual(value(again["args"], "--cvec-mode"), "project")++ def test_3216_a_config_without_args_written_keeps_them_too(self):+ first = self.first()+ old = {**first, "args": first["args"] + CVEC} # 0.2.0-beta: no copy of what was written+ code, out, cfg, _ = self.run_setup("--context", "131072", configs=[("strata-q2_0.json", old)])+ self.assertEqual(code, 0, out)+ self.assertEqual(cfg["user_args"], CVEC)+ self.assertEqual(cfg["args"][-len(CVEC):], CVEC)++ def test_3215_a_reserve_of_zero_is_kept(self):+ first = self.first()+ written = list(first["args"])+ edited = [*written]+ edited[edited.index("--vram-reserve-mib") + 1] = "0"+ for old in ({**first, "args": edited, "args_written": written}, # with the copy of what was written+ {**first, "args": edited}): # a 0.2.0-beta file+ code, out, cfg, _ = self.run_setup("--context", "131072", configs=[("strata-q2_0.json", old)])+ self.assertEqual(code, 0, out)+ self.assertEqual(value(cfg["args"], "--vram-reserve-mib"), "0")+ self.assertEqual(cfg["user_args"], ["--vram-reserve-mib", "0"])++ def test_3270_a_lowered_reserve_is_not_reset(self):+ first = self.first()+ written = list(first["args"])+ for mib in ("1024", "256"):+ edited = [*written]+ edited[edited.index("--vram-reserve-mib") + 1] = mib+ code, out, cfg, _ = self.run_setup("--context", "131072", configs=[("strata-q2_0.json", {**first, "args": edited, "args_written": written})])+ self.assertEqual(value(cfg["args"], "--vram-reserve-mib"), mib)++ def test_the_vision_default_is_not_taken_for_a_choice(self):+ first = self.first() # pictures on the GPU write 700 themselves+ self.assertEqual(value(first["args"], "--vram-reserve-mib"), "700")+ code, out, cfg, _ = self.run_setup("--context", "131072", "--vision", "cpu", configs=[("strata-q2_0.json", first)])+ self.assertNotIn("user_args", cfg)+ self.assertNotIn("--vram-reserve-mib", cfg["args"]) # the CPU reader needs no reserve++ def test_an_option_given_on_the_command_line_wins_and_is_kept(self):+ first = self.first()+ old = {**first, "args": first["args"] + ["--vram-reserve-mib", "0"], "user_args": ["--vram-reserve-mib", "0"]}+ code, out, cfg, _ = self.run_setup("--context", "131072", "--vram-reserve-mib", "256", configs=[("strata-q2_0.json", old)])+ self.assertEqual(code, 0, out)+ self.assertEqual(cfg["user_args"], ["--vram-reserve-mib", "256"])+ self.assertEqual(value(cfg["args"], "--vram-reserve-mib"), "256")++ def test_a_first_install_with_a_reserve_records_it(self):+ code, out, cfg, _ = self.run_setup("--vram-reserve-mib", "300")+ self.assertEqual(cfg["user_args"], ["--vram-reserve-mib", "300"])++ def test_setup_writes_args_written_and_a_rerun_with_no_edit_makes_no_user_args(self):+ first = self.first()+ code, out, cfg, _ = self.run_setup("--context", "131072", configs=[("strata-q2_0.json", {**first, "args_written": first["args"]})])+ self.assertNotIn("user_args", cfg)+++class Start(unittest.TestCase):+ def test_every_start_puts_the_persons_options_over_the_generated_ones(self):+ cfg = {"args": ["--pack", "/p", "--vram-reserve-mib", "1536", "--spec", "4"],+ "user_args": ["--vram-reserve-mib", "0"] + CVEC}+ with contextlib.redirect_stdout(io.StringIO()):+ args = engine_args(cfg)+ self.assertEqual(value(args, "--vram-reserve-mib"), "0")+ self.assertEqual(args.count("--vram-reserve-mib"), 1)+ self.assertEqual(args[args.index("--control-vector-scaled"):][:9], CVEC)+ self.assertEqual(cfg["args"][3], "1536") # the config in memory is untouched++ def test_the_settings_page_records_the_reserve_as_the_persons(self):+ cfg = {"args": ["--pack", "/p", "--vram-reserve-mib", "1536"], "args_written": ["--pack", "/p", "--vram-reserve-mib", "1536"]}+ new, changed = runconfig.apply(cfg, {"vram_reserve_mib": 0})+ self.assertEqual(changed, ["vram_reserve_mib"])+ self.assertEqual(new["user_args"], ["--vram-reserve-mib", "0"])+ self.assertEqual(new["args_written"], new["args"])+ back, _ = runconfig.apply(new, {"vram_reserve_mib": None})+ self.assertNotIn("user_args", back)+ self.assertNotIn("--vram-reserve-mib", back["args"])++ def test_a_tuning_replaces_only_the_flags_it_sets(self):+ cfg = {"args": ["--pack", "/p", "--vram-reserve-mib", "0", *CVEC], "args_written": ["--pack", "/p"],+ "user_args": ["--vram-reserve-mib", "0", *CVEC]}+ out = tune_apply.apply_args_to_config(cfg, ["--vram-reserve-mib", "512", "--pcie-frac", "0.5"])+ self.assertEqual(value(out["args"], "--vram-reserve-mib"), "512")+ self.assertEqual(out["user_args"], CVEC) # the tuned flag is no longer the old pin+ self.assertEqual(out["args_written"], out["args"])+++class DisplayCards(unittest.TestCase):+ """The app keeps the safety reserve for a card that drives a display and less on one that does not (#3215)."""++ def test_nvidia_by_nvidia_smi(self):+ gpus = [{"vendor": "nvidia", "index": 0}, {"vendor": "nvidia", "index": 1}, {"vendor": "nvidia", "index": 2}]+ strata_mcp.mark_display(gpus, {0: False, 1: True}, [])+ self.assertIs(gpus[0]["drives_display"], False)+ self.assertIs(gpus[1]["drives_display"], True)+ self.assertNotIn("drives_display", gpus[2]) # not told: unknown++ def test_amd_by_the_windows_adapter_with_a_desktop(self):+ amd = {"vendor": "amd", "index": 1, "pci_id": 0x744C}+ gpus = [{"vendor": "amd", "index": 0, "pci_id": 0x164E}, amd]+ strata_mcp.mark_display(gpus, {}, ["PCI\\VEN_1002&DEV_164E&SUBSYS_1"])+ self.assertIs(gpus[0]["drives_display"], True)+ self.assertIs(amd["drives_display"], False)+ twins = [{"vendor": "amd", "pci_id": 0x744C}, {"vendor": "amd", "pci_id": 0x744C}]+ strata_mcp.mark_display(twins, {}, ["PCI\\VEN_1002&DEV_744C"])+ self.assertNotIn("drives_display", twins[0]) # two of one model: not told apart+ strata_mcp.mark_display(gpus[:1] + [{"vendor": "amd", "pci_id": 0x1}], {}, [])+ self.assertTrue(True)+++if __name__ == "__main__":+ unittest.main()