@qvac/harness 0.6.0 → 0.7.1

package/dist-lib/lib/tools/exec/adapters/python/worker/active.d.ts

@@ -0,0 +1,19 @@
+import { type WorkerMessage } from './protocol.ts';
+import type { WorkerLink } from './spawn.ts';
+export interface ActiveWorker {
+    readonly link: WorkerLink;
+    readonly view: Uint8Array;
+    readonly ready: Promise<void>;
+    nextId: number;
+}
+export declare function activeWorker(boot: () => ActiveWorker): ActiveWorker;
+export declare function forget(worker: ActiveWorker): void;
+export declare function destroy(worker: ActiveWorker): void;
+export declare function readMessage(link: WorkerLink): Promise<WorkerMessage | null>;
+export declare function drainAndReap(worker: ActiveWorker): Promise<void>;
+export interface Grace {
+    expired: Promise<'grace'>;
+    clear: () => void;
+}
+export declare function grace(ms: number): Grace;
+export declare function closePythonWorker(): Promise<void>;

package/dist-lib/lib/tools/exec/adapters/python/worker/active.js

@@ -0,0 +1,72 @@
+import { hlog } from '../../../../../log.js';
+import { asWorkerMessage } from './protocol.js';
+const SHUTDOWN_GRACE_MS = 3_000;
+let active = null;
+export function activeWorker(boot) {
+    return (active ??= boot());
+}
+export function forget(worker) {
+    if (active === worker) {
+        active = null;
+    }
+}
+export function destroy(worker) {
+    forget(worker);
+    worker.link.kill();
+}
+export async function readMessage(link) {
+    for (;;) {
+        const message = asWorkerMessage(await link.read());
+        if (message?.type !== 'log') {
+            return message;
+        }
+        hlog(`python worker: ${message.message}`);
+    }
+}
+export async function drainAndReap(worker) {
+    forget(worker);
+    const closed = readMessage(worker.link).then(() => 'message', () => 'closed');
+    const timer = grace(SHUTDOWN_GRACE_MS);
+    try {
+        const settled = await Promise.race([closed, timer.expired]);
+        if (settled === 'closed') {
+            worker.link.reap();
+        }
+        else {
+            worker.link.kill();
+        }
+    }
+    finally {
+        timer.clear();
+    }
+}
+export function grace(ms) {
+    let timer;
+    const expired = new Promise((resolve) => {
+        timer = setTimeout(() => resolve('grace'), ms);
+    });
+    return { expired, clear: () => clearTimeout(timer) };
+}
+export async function closePythonWorker() {
+    const worker = active;
+    if (!worker) {
+        return;
+    }
+    active = null;
+    const timer = grace(SHUTDOWN_GRACE_MS);
+    try {
+        const booted = await Promise.race([worker.ready.then(() => 'ready'), timer.expired]);
+        if (booted === 'grace') {
+            worker.link.kill();
+            return;
+        }
+        await worker.link.write({ type: 'close' });
+        await drainAndReap(worker);
+    }
+    catch {
+        worker.link.kill();
+    }
+    finally {
+        timer.clear();
+    }
+}

package/dist-lib/lib/tools/exec/adapters/python/worker/client.d.ts

@@ -6,4 +6,3 @@ export interface RunSpecOptions {
     readonly askConnect?: ((host: string) => Promise<boolean>) | undefined;
 }
 export declare function runPythonInWorker(spec: RunSpec, opts: RunSpecOptions): Promise<PythonRunResult>;
-export declare function closePythonWorker(): Promise<void>;

package/dist-lib/lib/tools/exec/adapters/python/worker/client.js

@@ -1,30 +1,19 @@
-import { spawnPythonWorker } from '#pyodide-worker-spawn';
 import { AbortController } from 'bare-abort-controller';
 import process from 'process';
 import { fileURLToPath } from 'url';
 import { AbortedError, raceAbort } from '../../../../../helpers/race-abort.js';
 import { harnessLogEnabled, hlog } from '../../../../../log.js';
-import { asWorkerMessage, fromWireResult } from './protocol.js';
-const SIGINT = 2;
-const RESEND_MS = 100;
+import { RESEND_MS, SIGINT } from '../deadline-state.js';
+import { fromWireResult } from './protocol.js';
+import { activeWorker, destroy, drainAndReap, forget, grace, readMessage } from './active.js';
+import { spawnPythonWorker } from './spawn.js';
 function interruptGraceMs() {
     const ms = Number(process.env.QVAC_PYODIDE_INTERRUPT_GRACE_MS);
     return ms > 0 ? ms : 30_000;
 }
-const SHUTDOWN_GRACE_MS = 3_000;
-let active = null;
 function workerEntry() {
-    return (process.env.QVAC_PYODIDE_WORKER_ENTRY ??
-        fileURLToPath(new URL(import.meta.url.endsWith('.ts') ? './entry.ts' : './entry.js', import.meta.url).href));
-}
-async function readMessage(link) {
-    for (;;) {
-        const message = asWorkerMessage(await link.read());
-        if (message?.type !== 'log') {
-            return message;
-        }
-        hlog(`python worker: ${message.message}`);
-    }
+    return (process.env.QVAC_PYODIDE_WORKER_ENTRY ||
+        fileURLToPath(import.meta.resolve('#pyodide-worker-entry')));
 }
 async function awaitReady(link) {
     const message = await readMessage(link);
@@ -47,38 +36,11 @@ function boot() {
         nextId: 1
     };
     worker.ready.catch(() => {
-        if (active === worker) {
-            active = null;
-        }
+        forget(worker);
         link.kill();
     });
     return worker;
 }
-function destroy(worker) {
-    if (active === worker) {
-        active = null;
-    }
-    worker.link.kill();
-}
-async function drainAndReap(worker) {
-    if (active === worker) {
-        active = null;
-    }
-    const closed = readMessage(worker.link).then(() => 'message', () => 'closed');
-    const timer = grace(SHUTDOWN_GRACE_MS);
-    try {
-        const settled = await Promise.race([closed, timer.expired]);
-        if (settled === 'closed') {
-            worker.link.reap();
-        }
-        else {
-            worker.link.kill();
-        }
-    }
-    finally {
-        timer.clear();
-    }
-}
 async function resultFor(worker, id, askConnect) {
     let message = await readMessage(worker.link);
     while (message?.type === 'connect-ask') {
@@ -97,13 +59,6 @@ async function resultFor(worker, id, askConnect) {
     }
     throw new Error('python worker sent an unexpected message');
 }
-function grace(ms) {
-    let timer;
-    const expired = new Promise((resolve) => {
-        timer = setTimeout(() => resolve('grace'), ms);
-    });
-    return { expired, clear: () => clearTimeout(timer) };
-}
 async function interrupt(worker, outcome) {
     Atomics.store(worker.view, 0, SIGINT);
     const resend = setInterval(() => Atomics.store(worker.view, 0, SIGINT), RESEND_MS);
@@ -128,7 +83,7 @@ async function interrupt(worker, outcome) {
     }
 }
 export async function runPythonInWorker(spec, opts) {
-    const worker = (active ??= boot());
+    const worker = activeWorker(boot);
     worker.link.ref();
     try {
         const id = worker.nextId++;
@@ -190,27 +145,4 @@ export async function runPythonInWorker(spec, opts) {
         worker.link.unref();
     }
 }
-export async function closePythonWorker() {
-    const worker = active;
-    if (!worker) {
-        return;
-    }
-    active = null;
-    const timer = grace(SHUTDOWN_GRACE_MS);
-    try {
-        const booted = await Promise.race([worker.ready.then(() => 'ready'), timer.expired]);
-        if (booted === 'grace') {
-            worker.link.kill();
-            return;
-        }
-        await worker.link.write({ type: 'close' });
-        await drainAndReap(worker);
-    }
-    catch {
-        worker.link.kill();
-    }
-    finally {
-        timer.clear();
-    }
-}
 function noop() { }

package/dist-lib/lib/tools/exec/adapters/python/worker/entry.js

@@ -1,127 +1,3 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-import process from 'process';
-import { errorMessage, isRecord } from '../../../../../guards.js';
-import { setHarnessLog, setHarnessLogSink } from '../../../../../log.js';
 import { defaultLoad } from '../loader.js';
-import { performRun } from '../run-session.js';
-import { asHostMessage, toWireResult } from './protocol.js';
-function narrowThreadData(data) {
-    if (isRecord(data) && 'sab' in data && 'handle' in data) {
-        const sab = data.sab;
-        const log = 'log' in data && data.log === true;
-        if (sab instanceof SharedArrayBuffer) {
-            return { handle: data.handle, sab, log };
-        }
-    }
-    throw new Error('python worker started without { handle, sab } thread data');
-}
-async function openBarePort() {
-    const { default: Channel } = await import('bare-channel');
-    const self = Bare.Thread.self;
-    if (!self) {
-        throw new Error('python worker entry loaded on the main thread');
-    }
-    const { handle, sab, log } = narrowThreadData(self.data);
-    const port = Channel.from(handle).connect();
-    return {
-        port: {
-            read: () => port.read(),
-            write: (message) => void port.write(message),
-            close: () => void port.close()
-        },
-        handle,
-        sab,
-        log
-    };
-}
-async function openNodePort() {
-    const { parentPort, workerData } = await import('worker_threads');
-    if (!parentPort) {
-        throw new Error('python worker entry loaded on the main thread');
-    }
-    const data = narrowThreadData({ handle: parentPort, ...workerData });
-    const queued = [];
-    const waiting = [];
-    parentPort.on('message', (value) => {
-        const next = waiting.shift();
-        if (next) {
-            next(value);
-        }
-        else {
-            queued.push(value);
-        }
-    });
-    return {
-        port: {
-            read() {
-                if (queued.length > 0) {
-                    return Promise.resolve(queued.shift());
-                }
-                return new Promise((resolve) => waiting.push(resolve));
-            },
-            write: (message) => parentPort.postMessage(message),
-            close: () => parentPort.close()
-        },
-        ...data
-    };
-}
-async function loadInterpreter() {
-    const testLoader = process.env.QVAC_PYODIDE_TEST_LOADER;
-    if (!testLoader) {
-        return defaultLoad;
-    }
-    const loaded = await import(__rewriteRelativeImportExtension(testLoader));
-    if (isRecord(loaded) && 'default' in loaded && typeof loaded.default === 'function') {
-        return loaded.default;
-    }
-    throw new Error(`QVAC_PYODIDE_TEST_LOADER module has no default export: ${testLoader}`);
-}
-const { port, sab, log } = typeof globalThis.Bare !== 'undefined' ? await openBarePort() : await openNodePort();
-setHarnessLog(log);
-setHarnessLogSink((message) => port.write({ type: 'log', message }));
-try {
-    const load = await loadInterpreter();
-    const py = await load();
-    py.setInterruptBuffer(new Uint8Array(sab));
-    port.write({ type: 'ready' });
-    for (;;) {
-        const message = asHostMessage(await port.read());
-        if (!message || message.type === 'close') {
-            break;
-        }
-        if (message.type === 'connect-answer') {
-            continue;
-        }
-        let closing = false;
-        const askConnect = async (host) => {
-            if (closing)
-                return false;
-            port.write({ type: 'connect-ask', host });
-            const answer = asHostMessage(await port.read());
-            if (answer?.type === 'connect-answer') {
-                return answer.allowed;
-            }
-            closing = true;
-            return false;
-        };
-        const { result, evict } = await performRun(py, message.spec, { askConnect });
-        port.write({ type: 'result', id: message.id, result: toWireResult(result), evict });
-        if (evict || closing) {
-            break;
-        }
-    }
-}
-catch (error) {
-    const message = errorMessage(error);
-    port.write({ type: 'boot-error', message });
-}
-finally {
-    port.close();
-}
+import { serve } from './serve.js';
+await serve(defaultLoad);

package/dist-lib/lib/tools/exec/adapters/python/worker/interrupt-deadline.d.ts

@@ -0,0 +1 @@
+export {};

package/dist-lib/lib/tools/exec/adapters/python/worker/interrupt-deadline.js

@@ -0,0 +1,21 @@
+import { workerData } from 'worker_threads';
+import { isRecord } from '../../../../../guards.js';
+import { ARMED, FIRED, RESEND_MS, SIGINT } from '../deadline-state.js';
+function narrowDeadlineData(data) {
+    if (isRecord(data)) {
+        const { state, interrupt, ms } = data;
+        if (state instanceof SharedArrayBuffer && interrupt instanceof SharedArrayBuffer) {
+            return { state, interrupt, ms: Number(ms) };
+        }
+    }
+    throw new Error('interrupt deadline started without { state, interrupt } worker data');
+}
+const data = narrowDeadlineData(workerData);
+const state = new Int32Array(data.state);
+const interrupt = new Uint8Array(data.interrupt);
+Atomics.wait(state, 0, ARMED, data.ms);
+if (Atomics.compareExchange(state, 0, ARMED, FIRED) === ARMED) {
+    do {
+        Atomics.store(interrupt, 0, SIGINT);
+    } while (Atomics.wait(state, 0, FIRED, RESEND_MS) === 'timed-out');
+}

package/dist-lib/lib/tools/exec/adapters/python/worker/serve.d.ts

@@ -0,0 +1,2 @@
+import { type LoadPyodideFn } from '../run-session.ts';
+export declare function serve(load: LoadPyodideFn): Promise<void>;

package/dist-lib/lib/tools/exec/adapters/python/worker/serve.js

@@ -0,0 +1,90 @@
+import { parentPort, workerData } from 'worker_threads';
+import { errorMessage, isRecord } from '../../../../../guards.js';
+import { setHarnessLog, setHarnessLogSink } from '../../../../../log.js';
+import { performRun } from '../run-session.js';
+import { asHostMessage, toWireResult } from './protocol.js';
+function narrowThreadData(data) {
+    if (isRecord(data) && 'sab' in data) {
+        const sab = data.sab;
+        const log = 'log' in data && data.log === true;
+        if (sab instanceof SharedArrayBuffer) {
+            return { sab, log };
+        }
+    }
+    throw new Error('python worker started without { sab } worker data');
+}
+function openPort() {
+    const parent = parentPort;
+    if (!parent) {
+        throw new Error('python worker entry loaded on the main thread');
+    }
+    const queued = [];
+    const waiting = [];
+    parent.on('message', (value) => {
+        const next = waiting.shift();
+        if (next) {
+            next(value);
+        }
+        else {
+            queued.push(value);
+        }
+    });
+    return {
+        port: {
+            read() {
+                if (queued.length > 0) {
+                    return Promise.resolve(queued.shift());
+                }
+                return new Promise((resolve) => waiting.push(resolve));
+            },
+            write: (message) => parent.postMessage(message),
+            close: () => parent.close()
+        },
+        ...narrowThreadData(workerData)
+    };
+}
+async function serveRuns(port, py) {
+    for (;;) {
+        const message = asHostMessage(await port.read());
+        if (!message || message.type === 'close') {
+            break;
+        }
+        if (message.type === 'connect-answer') {
+            continue;
+        }
+        let closing = false;
+        const askConnect = async (host) => {
+            if (closing)
+                return false;
+            port.write({ type: 'connect-ask', host });
+            const answer = asHostMessage(await port.read());
+            if (answer?.type === 'connect-answer') {
+                return answer.allowed;
+            }
+            closing = true;
+            return false;
+        };
+        const { result, evict } = await performRun(py, message.spec, { askConnect });
+        port.write({ type: 'result', id: message.id, result: toWireResult(result), evict });
+        if (evict || closing) {
+            break;
+        }
+    }
+}
+export async function serve(load) {
+    const { port, sab, log } = openPort();
+    setHarnessLog(log);
+    setHarnessLogSink((message) => port.write({ type: 'log', message }));
+    try {
+        const py = await load();
+        py.setInterruptBuffer(new Uint8Array(sab));
+        port.write({ type: 'ready' });
+        await serveRuns(port, py);
+    }
+    catch (error) {
+        port.write({ type: 'boot-error', message: errorMessage(error) });
+    }
+    finally {
+        port.close();
+    }
+}

package/dist-lib/lib/tools/exec/adapters/python/worker/{spawn-node.d.ts → spawn.d.ts}

@@ -11,4 +11,3 @@ export interface WorkerData {
     readonly log: boolean;
 }
 export declare function spawnPythonWorker(entry: string, data: WorkerData): WorkerLink;
-export declare function spawnInlineThread(source: string, data: object): () => void;

package/dist-lib/lib/tools/exec/adapters/python/worker/{spawn-node.js → spawn.js}

@@ -48,11 +48,3 @@ export function spawnPythonWorker(entry, data) {
         unref: () => worker.unref()
     };
 }
-export function spawnInlineThread(source, data) {
-    const worker = new Worker(`const data = require('worker_threads').workerData\n${source}`, {
-        eval: true,
-        workerData: data
-    });
-    worker.unref();
-    return () => { };
-}

package/dist-lib/lib/tools/exec/bare-runtime.d.ts

@@ -0,0 +1,2 @@
+import type { ShellRuntime } from './adapters/shell/shell-adapter.ts';
+export declare function bareRuntime(): Promise<Required<ShellRuntime>>;

package/dist-lib/lib/tools/exec/bare-runtime.js

@@ -0,0 +1,10 @@
+import { spawnEnv } from '../../helpers/spawn-path.js';
+export async function bareRuntime() {
+    const [{ spawn }, { default: process }] = await Promise.all([
+        import('bare-subprocess'),
+        import('bare-process')
+    ]);
+    const rawSpawn = spawn;
+    const spawnFn = (command, opts = {}) => rawSpawn(command, { ...opts, env: spawnEnv(process.env, process.platform, opts.env) });
+    return { spawn: spawnFn, killProcess: process.kill.bind(process) };
+}

package/dist-lib/lib/tools/exec.d.ts

@@ -1,7 +1,6 @@
 import type { ToolDefinition } from '../capabilities/completion.ts';
 import type { ExecError } from './exec/adapters/python/output-policy.ts';
 import type { LoadPyodideFn } from './exec/adapters/python/pyodide.ts';
-import { type ShellRuntime } from './exec/adapters/shell/shell-adapter.ts';
 import { type KillProcess, type SpawnFn } from './exec/runner.ts';
 import { type Realpath } from './fs/scope.ts';
 import type { CredentialStoreFn } from './skills/auth-resolver.ts';
@@ -19,7 +18,6 @@ export interface ExecToolOptions {
     readonly deniedRoots?: readonly string[];
     readonly skillsDir?: string;
 }
-export declare function bareRuntime(): Promise<Required<ShellRuntime>>;
 export interface ScriptRun {
     args: Record<string, unknown>;
     trusted: boolean;

package/dist-lib/lib/tools/exec.js

@@ -1,8 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import { AbortedError } from '../helpers/race-abort.js';
-import { spawnEnv } from '../helpers/spawn-path.js';
-import { checkPdfBuildSource, checkBareLengthArgs, checkPptxBuildSource, checkPythonSource, checkUnstagedRead, createPythonAdapter, isPythonLanguage, parseInputs, parseOutputs, parsePackages, parseWorkdir, pinned, runsThroughPyodide, unwrapPythonSource } from './exec/adapters/python/python-adapter.js';
+import { checkPdfBuildSource, checkBareLengthArgs, checkPptxBuildSource, checkPythonSource, checkUnstagedRead, createPythonAdapter, isPythonLanguage, parseInputs, parseOutputs, parsePackages, parseWorkdir, pinned, runsThroughPyodide, sandboxInstallError, unwrapPythonSource } from './exec/adapters/python/python-adapter.js';
 import { pythonCreateEffect } from './exec/adapters/python/create-effect.js';
 import { namedHosts } from './exec/adapters/python/named-hosts.js';
 import { pythonReachesNetwork } from './exec/adapters/python/net-shim.js';
@@ -12,6 +11,7 @@ import { MAX_OUTPUT_CHARS_LIMIT } from './exec/runner.js';
 import { bareBin, firstCommandToken, sanitizeCommand } from './exec/scope.js';
 import { FILES_NEED_PYTHON_ERROR, isPythonSourceShaped, PACKAGES_NEED_PYTHON_ERROR, pythonRedirectError, startsLikePython, videoToolError } from './exec/shell-guidance.js';
 import { shellArgv } from './exec/shell-argv.js';
+import { bareRuntime } from './exec/bare-runtime.js';
 import { canonicalDenyRoots, defaultRealpath, hostPath, resolveKey } from './fs/scope.js';
 import { unquoteArg } from './model-args.js';
 import { settingsEnv } from './skills/skill-settings.js';
@@ -48,15 +48,6 @@ function shellEffect(command, toolOps) {
     }
     return matched.every((op) => op.annotation(argv) === 'read') ? 'read' : 'write';
 }
-export async function bareRuntime() {
-    const [{ spawn }, { default: process }] = await Promise.all([
-        import('bare-subprocess'),
-        import('bare-process')
-    ]);
-    const rawSpawn = spawn;
-    const spawnFn = (command, opts = {}) => rawSpawn(command, { ...opts, env: spawnEnv(process.env, process.platform, opts.env) });
-    return { spawn: spawnFn, killProcess: process.kill.bind(process) };
-}
 function resolveExecution({ adapters, fallback }, args, ctx) {
     for (const adapter of adapters) {
         const plan = adapter.resolve(args, ctx);
@@ -468,6 +459,10 @@ export function createExecTool({ spawn, killProcess, loadPyodide, disablePyodide
                 if (packages && 'error' in packages) {
                     return packages.error;
                 }
+                const refusal = ctx?.sandboxMode === true ? sandboxInstallError(command, packages) : null;
+                if (refusal) {
+                    return refusal;
+                }
                 if (!scriptRun || !scriptRun.trusted) {
                     const sourceError = checkPythonSource(command);
                     if (sourceError) {

package/dist-lib/schema/harness.js

@@ -339,7 +339,8 @@ export function registerHarnessTypes(ns) {
             { name: 'supportsImages', type: 'bool', required: true },
             { name: 'expectedSize', type: 'uint', required: true },
             { name: 'actualSize', type: 'uint' },
-            { name: 'label', type: 'string' }
+            { name: 'label', type: 'string' },
+            { name: 'isLoading', type: 'bool' }
         ]
     });
     ns.register({
@@ -450,7 +451,8 @@ export function registerHarnessTypes(ns) {
         fields: [
             { name: 'capabilityProfile', type: '@harness/capability-profile', required: true },
             { name: 'recommendedModelName', type: 'string', required: true },
-            { name: 'memoryBudget', type: '@harness/memory-budget' }
+            { name: 'memoryBudget', type: '@harness/memory-budget' },
+            { name: 'mobile', type: 'bool' }
         ]
     });
     ns.register({

package/dist-lib/spec/hrpc/messages.js

@@ -1,12 +1,12 @@
 // This file is autogenerated by the hyperschema compiler
-// Schema Version: 16
+// Schema Version: 18
 /* eslint-disable camelcase */
 /* eslint-disable quotes */
 /* eslint-disable space-before-function-paren */
 
 import { c } from 'hyperschema/runtime'
 
-const VERSION = 16
+const VERSION = 18
 
 // eslint-disable-next-line no-unused-vars
 let version = VERSION
@@ -1610,7 +1610,7 @@ const encoding31 = {
     c.string.preencode(state, m.type)
     c.string.preencode(state, m.registryPath)
     c.string.preencode(state, m.registrySource)
-    state.end++ // max flag is 16 so always one byte
+    state.end++ // max flag is 32 so always one byte
     c.uint.preencode(state, m.expectedSize)
 
     if (m.actualSize) c.uint.preencode(state, m.actualSize)
@@ -1622,7 +1622,8 @@ const encoding31 = {
       (m.isLoaded ? 2 : 0) |
       (m.supportsImages ? 4 : 0) |
       (m.actualSize ? 8 : 0) |
-      ((version >= 15 && m.label) ? 16 : 0)
+      ((version >= 15 && m.label) ? 16 : 0) |
+      ((version >= 18 && m.isLoading) ? 32 : 0)
 
     c.string.encode(state, m.name)
     c.string.encode(state, m.type)
@@ -1651,7 +1652,8 @@ const encoding31 = {
       supportsImages: (flags & 4) !== 0,
       expectedSize: c.uint.decode(state),
       actualSize: (flags & 8) !== 0 ? c.uint.decode(state) : 0,
-      label: (version >= 15 && (flags & 16) !== 0) ? c.string.decode(state) : null
+      label: (version >= 15 && (flags & 16) !== 0) ? c.string.decode(state) : null,
+      isLoading: (version >= 18 && (flags & 32) !== 0)
     }
   }
 }
@@ -1919,12 +1921,12 @@ const encoding42 = {
   preencode(state, m) {
     encoding38.preencode(state, m.capabilityProfile)
     c.string.preencode(state, m.recommendedModelName)
-    state.end++ // max flag is 1 so always one byte
+    state.end++ // max flag is 2 so always one byte
 
     if (version >= 2 && m.memoryBudget) encoding42_2.preencode(state, m.memoryBudget)
   },
   encode(state, m) {
-    const flags = (version >= 2 && m.memoryBudget) ? 1 : 0
+    const flags = ((version >= 2 && m.memoryBudget) ? 1 : 0) | ((version >= 17 && m.mobile) ? 2 : 0)
 
     encoding38.encode(state, m.capabilityProfile)
     c.string.encode(state, m.recommendedModelName)
@@ -1940,7 +1942,8 @@ const encoding42 = {
     return {
       capabilityProfile: r0,
       recommendedModelName: r1,
-      memoryBudget: (version >= 2 && (flags & 1) !== 0) ? encoding42_2.decode(state) : null
+      memoryBudget: (version >= 2 && (flags & 1) !== 0) ? encoding42_2.decode(state) : null,
+      mobile: (version >= 17 && (flags & 2) !== 0)
     }
   }
 }