@qvac/harness 0.2.4 → 0.2.6

package/dist-lib/index.d.ts

@@ -63,6 +63,7 @@ export interface MusicModelOptions extends MusicModelStages {
 }
 export interface HarnessOptions {
     tools?: ToolDefinition[];
+    gpuStats?: unknown;
     sdkLoader?: SdkLoader;
     skillsDir?: string;
     projectionModel?: string | Record<string, string>;
@@ -81,6 +82,7 @@ export interface HarnessOptions {
     transcriptionDevice?: 'cpu' | 'gpu';
     credentialStore?: CredentialStoreFn;
     platform?: string;
+    completionModelCap?: number;
 }
 export interface CompletionContext {
     model: string;
@@ -131,6 +133,8 @@ export declare class Harness extends ReadyResource {
     private readonly _kvCacheK?;
     private readonly _kvCacheV?;
     private readonly _transcriptionDevice?;
+    private readonly _gpuStats?;
+    private readonly _completionModelCap;
     private _allSkills;
     private _credentialStore?;
     private _credentials;
@@ -143,7 +147,7 @@ export declare class Harness extends ReadyResource {
     private _capability;
     private _capabilityInflight;
     private readonly _modelFaults;
-    constructor({ tools, sdkLoader, skillsDir, projectionModel, imageModel, imageClamps, musicModel, musicClamps, llmDevice, llmGpuLayers, contextSize, kvCacheK, kvCacheV, embedDevice, embedGpuLayers, embedBatchSize, transcriptionDevice, credentialStore, platform }?: HarnessOptions);
+    constructor({ tools, sdkLoader, skillsDir, projectionModel, imageModel, imageClamps, musicModel, musicClamps, llmDevice, llmGpuLayers, contextSize, kvCacheK, kvCacheV, embedDevice, embedGpuLayers, embedBatchSize, transcriptionDevice, completionModelCap, credentialStore, platform, gpuStats }?: HarnessOptions);
     _open(): Promise<void>;
     get suspended(): boolean;
     get skillNames(): string[];
@@ -236,6 +240,7 @@ export declare class Harness extends ReadyResource {
         signal?: BareAbortSignal;
     }): Promise<void>;
     completion({ model, agent, messages, cacheKey, thinkingDefault, toolConfigs, generationParams, responseFormat, grantedDirs, grantedDrives, driveOp, grantedWriteDirs, approve, attach, fetchAttachment, ragSearch, progress, askUser, signal }: CompletionContext): AsyncGenerator<CompletionEvent>;
+    private _makeRoomForCompletion;
     private _evictWedgedModel;
     private _evictAfterLeases;
 }

package/dist-lib/index.js

@@ -2,7 +2,7 @@ import fs from 'fs';
 import { platform, totalmem } from 'os';
 import process from 'process';
 import ReadyResource from 'ready-resource';
-import { readSystemStats } from '#hw-gpu-stats';
+import { probeGpuStats } from "./lib/hardware/gpu-probe.js";
 import { probeCapabilityProfile } from "./lib/hardware/capability-probe.js";
 import { closePythonWorker } from "./lib/tools/exec/adapters/python/worker/client.js";
 import { completion } from "./lib/capabilities/completion.js";
@@ -17,7 +17,7 @@ import { AbortedError, raceAbort } from "./lib/helpers/race-abort.js";
 import { audioGenDownloadMetadata, customProjectionMap, defaultProjectionMap, defaultTtsFor, defaultVoiceModel, diffusionDownloadMetadata, infraModelsFor, modelNameToCapabilityProfile, musicModelSet, setCustomModels } from "./lib/models/model-catalog.js";
 import { createModelStatusCache, invalidateModelStatusCache, listModels } from "./lib/models/model-list.js";
 import { deleteModelFiles, summarizeDelete } from "./lib/models/model-delete.js";
-import { createEmbedPool, createLoadTracker, createModelPool, createVoicePool, evictAllWithin, evictIdle, evictModelWithin, isResident, leaseCount, loadedModels, modelKey, releaseModel, resolveLoadOptions, progressState } from "./lib/models/model-pool.js";
+import { createEmbedPool, createLoadTracker, createModelPool, createVoicePool, awaitModelCapacity, evictIdle, evictModelWithin, isResident, leaseCount, loadedModels, modelKey, releaseModel, resolveLoadOptions, progressState } from "./lib/models/model-pool.js";
 import { resolveMainGpu } from "./lib/models/gpu-selection.js";
 import { openclCacheDir } from "./lib/models/opencl-cache.js";
 import { assertEmbedDevice, createEmbedConfig } from "./lib/models/embed-config.js";
@@ -68,6 +68,9 @@ const TRANSCRIPTION_MODEL_LABEL = 'transcription model';
 const DIFFUSION_EVICT_WAIT_MS = 15_000;
 const MUSIC_EVICT_WAIT_MS = 15_000;
 const WEDGED_EVICT_WAIT_MS = 10_000;
+const MODEL_ROOM_WAIT_MS = 300_000;
+const WARM_ROOM_WAIT_MS = 2_000;
+const DEFAULT_COMPLETION_MODEL_CAP = 1;
 const WEDGED_EVICT_LEASED_MS = 120_000;
 const TTS_MODEL_CONFIG = {
     ttsEngine: 'supertonic',
@@ -103,6 +106,8 @@ export class Harness extends ReadyResource {
     _kvCacheK;
     _kvCacheV;
     _transcriptionDevice;
+    _gpuStats;
+    _completionModelCap;
     _allSkills;
     _credentialStore;
     _credentials = new Map();
@@ -115,15 +120,17 @@ export class Harness extends ReadyResource {
     _capability = null;
     _capabilityInflight = null;
     _modelFaults = new Map();
-    constructor({ tools = [], sdkLoader, skillsDir, projectionModel, imageModel, imageClamps, musicModel, musicClamps, llmDevice, llmGpuLayers, contextSize, kvCacheK, kvCacheV, embedDevice, embedGpuLayers, embedBatchSize, transcriptionDevice, credentialStore, platform } = {}) {
+    constructor({ tools = [], sdkLoader, skillsDir, projectionModel, imageModel, imageClamps, musicModel, musicClamps, llmDevice, llmGpuLayers, contextSize, kvCacheK, kvCacheV, embedDevice, embedGpuLayers, embedBatchSize, transcriptionDevice, completionModelCap, credentialStore, platform, gpuStats } = {}) {
         super();
         this._sdk = sdkLoader ?? createSdkLoader();
         this._llmDevice = llmDevice;
+        this._gpuStats = gpuStats;
         this._llmGpuLayers = llmGpuLayers;
         this._contextSize = contextSize;
         this._kvCacheK = kvCacheK;
         this._kvCacheV = kvCacheV;
         this._transcriptionDevice = transcriptionDevice;
+        this._completionModelCap = completionModelCap ?? DEFAULT_COMPLETION_MODEL_CAP;
         const embedConfig = createEmbedConfig({
             device: embedDevice,
             gpuLayers: embedGpuLayers,
@@ -166,7 +173,7 @@ export class Harness extends ReadyResource {
                 onBeforeLoad: async (signal) => {
                     if (this._models.destroyed)
                         return;
-                    const evicted = await evictAllWithin(this._models, DIFFUSION_EVICT_WAIT_MS, undefined, signal);
+                    const evicted = await awaitModelCapacity(this._models, 1, DIFFUSION_EVICT_WAIT_MS, undefined, signal);
                     if (signal?.aborted)
                         throw new AbortedError();
                     if (!evicted) {
@@ -185,7 +192,7 @@ export class Harness extends ReadyResource {
                 onBeforeLoad: async (signal) => {
                     if (this._models.destroyed)
                         return;
-                    const evicted = await evictAllWithin(this._models, MUSIC_EVICT_WAIT_MS, undefined, signal);
+                    const evicted = await awaitModelCapacity(this._models, 1, MUSIC_EVICT_WAIT_MS, undefined, signal);
                     if (signal?.aborted)
                         throw new AbortedError();
                     if (!evicted) {
@@ -898,7 +905,7 @@ export class Harness extends ReadyResource {
                     return null;
                 }
             },
-            readGpuStats: () => readSystemStats()
+            readGpuStats: () => (this._gpuStats !== undefined ? this._gpuStats : probeGpuStats())
         };
         this._capabilityInflight = probeCapabilityProfile(reads)
             .then((capability) => {
@@ -925,7 +932,8 @@ export class Harness extends ReadyResource {
         const pool = this._models;
         hlog('warm model', { model, resident: isResident(pool, key) });
         if (!isResident(pool, key)) {
-            await evictIdle(pool);
+            if (!(await this._makeRoomForCompletion(signal, WARM_ROOM_WAIT_MS)))
+                return;
             await this._imageRuntime?.unloadIdle().catch(noop);
         }
         try {
@@ -951,13 +959,13 @@ export class Harness extends ReadyResource {
         const resident = isResident(pool, key);
         hlog('completion start', { model, resident, projection: Boolean(projectionModel) });
         if (!resident) {
-            await evictIdle(pool);
+            await this._makeRoomForCompletion(signal);
             await this._imageRuntime?.unloadIdle().catch(noop);
             await this._musicRuntime?.unloadIdle().catch(noop);
         }
         const acquireRound = async () => {
             if (!isResident(pool, key)) {
-                await evictIdle(pool);
+                await this._makeRoomForCompletion(signal);
                 await this._imageRuntime?.unloadIdle().catch(noop);
                 await this._musicRuntime?.unloadIdle().catch(noop);
             }
@@ -1050,6 +1058,16 @@ export class Harness extends ReadyResource {
             void this._musicRuntime?.unloadIdle().catch(noop);
         }
     }
+    async _makeRoomForCompletion(signal, deadlineMs = MODEL_ROOM_WAIT_MS) {
+        const roomed = await awaitModelCapacity(this._models, this._completionModelCap, deadlineMs, 250, signal);
+        if (!roomed) {
+            hlog('model room wait gave up', {
+                cap: this._completionModelCap,
+                loaded: loadedModels(this._models).length
+            });
+        }
+        return roomed;
+    }
     async _evictWedgedModel(model, key) {
         const faults = (this._modelFaults.get(model) ?? 0) + 1;
         this._modelFaults.set(model, faults);

package/dist-lib/lib/hardware/capability-probe.d.ts

@@ -4,6 +4,6 @@ export interface PlatformReads {
     platform(): string;
     readFile(path: string): Promise<string | null>;
     run(command: string): Promise<string | null>;
-    readGpuStats(): unknown;
+    readGpuStats(): unknown | Promise<unknown>;
 }
 export declare function probeCapabilityProfile(reads: PlatformReads): Promise<CapabilityInfo>;

package/dist-lib/lib/hardware/capability-probe.js

@@ -49,7 +49,7 @@ async function probeSysfs(reads) {
 }
 async function probeDesktop(reads) {
     const ram = reads.totalmem();
-    const addon = probeWithAddon(reads.readGpuStats(), ram);
+    const addon = probeWithAddon(await reads.readGpuStats(), ram);
     if (addon && addon.source === 'vram')
         return addon;
     const nvidia = await reads.run('nvidia-smi --query-gpu=memory.total --format=csv,noheader,nounits');

package/dist-lib/lib/hardware/gpu-probe-entry.d.ts

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

package/dist-lib/lib/hardware/gpu-probe-entry.js

@@ -0,0 +1,2 @@
+import { runGpuProbeIfRequested } from "./gpu-probe.js";
+runGpuProbeIfRequested();

package/dist-lib/lib/hardware/gpu-probe.d.ts

@@ -0,0 +1,8 @@
+export interface GpuProbeResult {
+    readonly ok: boolean;
+    readonly stats: unknown;
+}
+export declare function runGpuProbeIfRequested(): void;
+export declare function parseGpuProbeOutput(output: string): unknown;
+export declare function spawnGpuProbe(entry?: string): Promise<GpuProbeResult>;
+export declare function probeGpuStats(): Promise<unknown>;

package/dist-lib/lib/hardware/gpu-probe.js

@@ -0,0 +1,54 @@
+import { spawn } from 'child_process';
+import os from 'os';
+import { readSystemStats } from '#hw-gpu-stats';
+const FLAG = '--gpu-probe';
+const TIMEOUT_MS = 5000;
+export function runGpuProbeIfRequested() {
+    if (!Bare.argv.includes(FLAG))
+        return;
+    console.log(JSON.stringify(readSystemStats()));
+    queueMicrotask(() => Bare.exit(0));
+}
+export function parseGpuProbeOutput(output) {
+    const line = output.trim().split('\n').at(-1) ?? '';
+    if (line.length === 0)
+        return null;
+    try {
+        const parsed = JSON.parse(line);
+        return typeof parsed === 'object' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function spawnGpuProbe(entry = Bare.argv[1]) {
+    return new Promise((resolve) => {
+        const child = spawn(Bare.argv[0], [entry, FLAG], {
+            stdio: ['ignore', 'pipe', 'pipe', 'pipe']
+        });
+        let output = '';
+        const timer = setTimeout(() => {
+            child.kill();
+            resolve({ ok: false, stats: null });
+        }, TIMEOUT_MS);
+        child.stdout?.on('data', (chunk) => {
+            output += Buffer.from(chunk).toString();
+        });
+        child.stderr?.on('data', () => { });
+        child.on('error', () => {
+            clearTimeout(timer);
+            resolve({ ok: false, stats: null });
+        });
+        child.on('exit', (code) => {
+            clearTimeout(timer);
+            resolve(code === 0 ? { ok: true, stats: parseGpuProbeOutput(output) } : { ok: false, stats: null });
+        });
+    });
+}
+export async function probeGpuStats() {
+    const platform = os.platform();
+    if (typeof Bare === 'undefined' || (platform !== 'linux' && platform !== 'win32')) {
+        return readSystemStats();
+    }
+    return (await spawnGpuProbe()).stats;
+}

package/dist-lib/lib/hardware/gpu-stats.bare.d.ts

@@ -1 +1 @@
-export declare function readSystemStats(): unknown;
+export { readSystemStats } from './gpu-stats.native.cjs';

package/dist-lib/lib/hardware/gpu-stats.bare.js

@@ -1,24 +1 @@
-import os from 'os';
-import GPUInfo from 'bare-gpu-info';
-export function readSystemStats() {
-    try {
-        const info = new GPUInfo();
-        try {
-            const devices = [];
-            for (const gpu of info) {
-                if (typeof gpu.memory !== 'number' || !gpu.name)
-                    continue;
-                devices.push({ name: gpu.name, videoMemoryBytes: gpu.memory });
-            }
-            if (devices.length === 0)
-                return null;
-            return { memory: { totalBytes: os.totalmem() }, gpu: { devices } };
-        }
-        finally {
-            info.destroy();
-        }
-    }
-    catch {
-        return null;
-    }
-}
+export { readSystemStats } from './gpu-stats.native.cjs';

package/dist-lib/lib/hardware/gpu-stats.native.cjs

@@ -0,0 +1,27 @@
+const os = require('os')
+
+// loaded on first read: the addon drags the graphics stack (and on Linux a
+// second LLVM) into whichever process imports it
+let GPUInfo
+
+// Shaped for probeWithAddon (gpu-probe-addon.ts): the probe only wants each
+// device's name and VRAM total, plus system RAM to catch integrated-GPU lies.
+exports.readSystemStats = function readSystemStats() {
+  try {
+    GPUInfo ??= require('bare-gpu-info')
+    const info = new GPUInfo()
+    try {
+      const devices = []
+      for (const gpu of info) {
+        if (typeof gpu.memory !== 'number' || !gpu.name) continue
+        devices.push({ name: gpu.name, videoMemoryBytes: gpu.memory })
+      }
+      if (devices.length === 0) return null
+      return { memory: { totalBytes: os.totalmem() }, gpu: { devices } }
+    } finally {
+      info.destroy()
+    }
+  } catch {
+    return null
+  }
+}

package/dist-lib/lib/hardware/gpu-stats.native.d.cts

@@ -0,0 +1 @@
+export function readSystemStats(): unknown

package/dist-lib/lib/models/model-pool.d.ts

@@ -72,7 +72,7 @@ export declare function loadedModels(pool: PoolLike): LoadedModel[];
 export declare function isResident(pool: PoolLike, key: string): boolean;
 export declare function leaseCount(pool: PoolLike, key: string): number;
 export declare function evictIdle(pool: PoolLike): Promise<void>;
-export declare function evictAllWithin(pool: PoolLike, deadlineMs: number, tickMs?: number, signal?: {
+export declare function awaitModelCapacity(pool: PoolLike, cap: number, deadlineMs: number, tickMs?: number, signal?: {
     aborted?: boolean;
 }): Promise<boolean>;
 export declare function evictModelWithin(pool: PoolLike, key: string, deadlineMs: number, tickMs?: number): Promise<boolean>;

package/dist-lib/lib/models/model-pool.js

@@ -103,7 +103,8 @@ export async function evictIdle(pool) {
         await pool.gc();
     }
 }
-export async function evictAllWithin(pool, deadlineMs, tickMs = 250, signal) {
+export async function awaitModelCapacity(pool, cap, deadlineMs, tickMs = 250, signal) {
+    const roomed = () => loadedModels(pool).length < cap;
     let done = false;
     let timer = null;
     const expired = new Promise((resolve) => {
@@ -114,7 +115,7 @@ export async function evictAllWithin(pool, deadlineMs, tickMs = 250, signal) {
     });
     const evicting = (async () => {
         await evictIdle(pool);
-        while (loadedModels(pool).length > 0) {
+        while (!roomed()) {
             if (done || signal?.aborted)
                 return false;
             await new Promise((resolve) => setTimeout(resolve, tickMs));

package/dist-lib/lib/spawn.d.ts

@@ -20,10 +20,12 @@ export interface HarnessLlmConfig {
     contextSize?: number;
     kvCacheK?: string;
     kvCacheV?: string;
+    completionModelCap?: number;
 }
 export interface HarnessChildOptions {
     runner: StowRunner;
     skillsDir?: string;
+    gpuStats?: unknown;
     wheelsDir?: string;
     sdkStorage?: SdkStorage;
     embedDevice?: EmbedDevice;
@@ -46,6 +48,7 @@ export interface HarnessChildOptions {
 export declare function harnessChild(entry: string, opts: HarnessChildOptions): ChildSpec<RemoteHarness>;
 export interface SpawnHarnessOptions {
     entry: string;
+    gpuStats?: unknown;
     skillsDir?: string;
     wheelsDir?: string;
     sdkStorage: SdkStorage;

package/dist-lib/lib/spawn.js

@@ -5,7 +5,7 @@ import { createEmbedConfig } from "./models/embed-config.js";
 export function harnessChild(entry, opts) {
     if (opts.logger)
         setHarnessLog(true);
-    const { runner, skillsDir, wheelsDir, sdkStorage, embedDevice, embedGpuLayers, embedBatchSize, imageModel, imageClamps, musicModel, musicClamps, llm, onIpc, logger = null, ...spec } = opts;
+    const { runner, skillsDir, gpuStats, wheelsDir, sdkStorage, embedDevice, embedGpuLayers, embedBatchSize, imageModel, imageClamps, musicModel, musicClamps, llm, onIpc, logger = null, ...spec } = opts;
     const embedConfig = createEmbedConfig({
         device: embedDevice,
         gpuLayers: embedGpuLayers,
@@ -24,7 +24,8 @@ export function harnessChild(entry, opts) {
             llm ? JSON.stringify(llm) : '',
             musicModel ? JSON.stringify(musicModel) : '',
             musicClamps ? JSON.stringify(musicClamps) : '',
-            wheelsDir ?? ''
+            wheelsDir ?? '',
+            gpuStats === undefined ? '' : JSON.stringify(gpuStats)
         ],
         logger,
         create: (ipc) => {
@@ -55,7 +56,8 @@ export function spawnHarness(opts) {
             opts.llm ? JSON.stringify(opts.llm) : '',
             opts.musicModel ? JSON.stringify(opts.musicModel) : '',
             opts.musicClamps ? JSON.stringify(opts.musicClamps) : '',
-            opts.wheelsDir ?? ''
+            opts.wheelsDir ?? '',
+            opts.gpuStats === undefined ? '' : JSON.stringify(opts.gpuStats)
         ]);
         sidecar.stdout.on('data', (data) => logger?.info('harness', data.toString().trimEnd()));
         sidecar.stderr.on('data', (data) => logger?.warn('harness', data.toString().trimEnd()));

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

@@ -4,8 +4,14 @@ type NodeShapedProcess = typeof process & {
     binding(name: string): Record<string, unknown>;
 };
 export declare function nodeShapedProcess(base: typeof process): NodeShapedProcess;
-export declare function pyodideLoadOptions(): {
-    packageCacheDir: string;
-} | undefined;
+declare const silentStdio: {
+    stdin: () => null;
+    stdout: (_msg: string) => void;
+    stderr: (_msg: string) => void;
+};
+export declare function pyodideLoadOptions(): PyodideLoadOptions;
+type PyodideLoadOptions = typeof silentStdio & {
+    packageCacheDir?: string;
+};
 export declare const defaultLoad: LoadPyodideFn;
 export {};

package/dist-lib/lib/tools/exec/adapters/python/loader.js

@@ -74,11 +74,16 @@ async function shapeBareGlobals() {
         g.performance = { now: () => Date.now() - origin, timeOrigin: origin };
     }
 }
+const silentStdio = {
+    stdin: () => null,
+    stdout: (_msg) => { },
+    stderr: (_msg) => { }
+};
 export function pyodideLoadOptions() {
     const cacheDir = process.env.QVAC_PYODIDE_CACHE_DIR;
     if (!cacheDir)
-        return undefined;
-    return { packageCacheDir: cacheDir };
+        return { ...silentStdio };
+    return { ...silentStdio, packageCacheDir: cacheDir };
 }
 export const defaultLoad = async () => {
     if (typeof globalThis.Bare !== 'undefined')
@@ -86,9 +91,7 @@ export const defaultLoad = async () => {
     const moduleName = 'pyodide';
     const { loadPyodide } = (await import(__rewriteRelativeImportExtension(moduleName)));
     const options = pyodideLoadOptions();
-    if (options) {
+    if (options.packageCacheDir)
         seedPackageCache(options.packageCacheDir);
-        return (await loadPyodide(options));
-    }
-    return (await loadPyodide());
+    return (await loadPyodide(options));
 };

package/dist-lib/schema/generate.d.ts

@@ -13,8 +13,12 @@ interface HRPCHandler {
 interface HRPCBuilderLike {
     handlers: ReadonlyArray<HRPCHandler>;
 }
+interface CallSiteOptions {
+    readonly optionalRequests?: ReadonlySet<string>;
+    readonly exportName?: string;
+}
 export declare function writeBind(builder: HRPCBuilderLike, outFile: string): void;
-export declare function writeClient(builder: HRPCBuilderLike, outFile: string, exportName?: string): void;
-export declare function writeCapabilities(builder: HRPCBuilderLike, outFile: string): void;
+export declare function writeClient(builder: HRPCBuilderLike, outFile: string, options?: CallSiteOptions | string): void;
+export declare function writeCapabilities(builder: HRPCBuilderLike, outFile: string, options?: CallSiteOptions): void;
 export declare function writeConfigTypes(outFile: string): void;
 export {};

package/dist-lib/schema/generate.js

@@ -13,6 +13,7 @@ function camel(name, prefix = '') {
     return prefix + cased.join('');
 }
 const HEADER = '// This file is autogenerated by schema/build.js\n// Do not edit manually.\n\n';
+const DEFAULT_OPTIONAL_REQUESTS = new Set(['@assistant/empty']);
 export function writeBind(builder, outFile) {
     let s = `${HEADER}import { pipeline, Readable } from "streamx";\n\nfunction noop() {}\n\nexport function bindApi(rpc, api) {\n`;
     for (const handler of builder.handlers) {
@@ -56,24 +57,28 @@ export function writeBind(builder, outFile) {
     s += '}\n';
     fs.writeFileSync(outFile, s);
 }
-export function writeClient(builder, outFile, exportName = 'engineClient') {
+export function writeClient(builder, outFile, options = {}) {
+    const callSite = typeof options === 'string' ? { exportName: options } : options;
+    const { optionalRequests = DEFAULT_OPTIONAL_REQUESTS, exportName = 'engineClient' } = callSite;
     let s = `${HEADER}function noop() {}\n\nfunction armed(stream) {\n  stream.on("error", noop);\n  return stream;\n}\n\nexport function ${exportName}(rpc) {\n  return {\n`;
     for (const handler of builder.handlers) {
         const method = camel(handler.name);
+        const input = optionalRequests.has(handler.request?.name ?? '') ? 'input ?? {}' : 'input';
         if (handler.request?.stream && handler.response?.stream) {
             s += `    ${method}: () => armed(rpc.${method}()),\n`;
         }
         else if (handler.response?.stream) {
-            s += `    ${method}: (input) => armed(rpc.${method}(input)),\n`;
+            s += `    ${method}: (input) => armed(rpc.${method}(${input})),\n`;
         }
         else {
-            s += `    ${method}: (input) => rpc.${method}(input),\n`;
+            s += `    ${method}: (input) => rpc.${method}(${input}),\n`;
         }
     }
     s += '  };\n}\n';
     fs.writeFileSync(outFile, s);
 }
-export function writeCapabilities(builder, outFile) {
+export function writeCapabilities(builder, outFile, options = {}) {
+    const { optionalRequests = DEFAULT_OPTIONAL_REQUESTS } = options;
     let s = HEADER;
     s += "import type * as T from './hyperschema/types.d.ts'\n\n";
     s +=
@@ -112,7 +117,7 @@ export function writeCapabilities(builder, outFile) {
         const method = camel(handler.name);
         const req = `T.${tsName(handler.request.name)}`;
         const res = `T.${tsName(handler.response.name)}`;
-        const input = handler.request.name === '@assistant/empty' ? `input?: ${req}` : `input: ${req}`;
+        const input = optionalRequests.has(handler.request.name) ? `input?: ${req}` : `input: ${req}`;
         if (handler.request?.stream && handler.response?.stream) {
             client += `  ${method}(): UploadStream<${req}, ${res}>\n`;
             server += `  ${method}(stream: AsyncIterable<${req}> | HandlerFrames<${req}>): AsyncIterable<${res}>\n`;