@bendyline/gezel-inference 0.0.0-stage → 1.0.0

package/dist/providers/llama-cpp/reasoning-launch.d.ts

@@ -0,0 +1,7 @@
+export { REASONING_CHARS_PER_TOKEN, applyLlamaCppReasoningBudgetOverride, buildThinkingBudgetCorrective, clientThinkingBudgetForRequest, estimateReasoningTokens, parseReasoningBudgetEnv, } from '@bendyline/gezel/local-loop';
+/** Parse the opt-in llama.cpp reasoning-history preservation switch. */
+export declare function parseReasoningPreserveEnv(raw: string | undefined): boolean;
+export declare function reasoningLaunchOverridesFromEnv(env?: NodeJS.ProcessEnv): {
+    preserve: boolean;
+    budgetTokens: number | undefined;
+};

package/dist/providers/llama-cpp/reasoning-launch.js

@@ -0,0 +1,14 @@
+import { parseReasoningBudgetEnv } from '@bendyline/gezel/local-loop';
+// The budget parse and the per-request override run inside the shared loop.
+export { REASONING_CHARS_PER_TOKEN, applyLlamaCppReasoningBudgetOverride, buildThinkingBudgetCorrective, clientThinkingBudgetForRequest, estimateReasoningTokens, parseReasoningBudgetEnv, } from '@bendyline/gezel/local-loop';
+/** Parse the opt-in llama.cpp reasoning-history preservation switch. */
+export function parseReasoningPreserveEnv(raw) {
+    const normalized = raw?.trim().toLowerCase();
+    return normalized === '1' || normalized === 'true';
+}
+export function reasoningLaunchOverridesFromEnv(env = process.env) {
+    return {
+        preserve: parseReasoningPreserveEnv(env.GEZEL_LLAMA_REASONING_PRESERVE),
+        budgetTokens: parseReasoningBudgetEnv(env.GEZEL_LLAMA_REASONING_BUDGET_TOKENS),
+    };
+}

package/dist/providers/llama-cpp/spec-draft.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Speculative-decoding draft resolution, extracted from the chat/manager
+ * launcher so it can be unit-tested in isolation.
+ *
+ * A model manifest names its `draft-simple` draft by CATALOG id
+ * (`spec.draftModelId`) so it stays portable across installs — a user's GGUF
+ * path differs from any hardcoded one. But engine-flags passes
+ * `--spec-draft-model` verbatim and a `draft-simple` spec with no draft model
+ * is a FATAL llama-server launch, so the id must be resolved to the installed
+ * GGUF path (or the spec disabled) BEFORE the argv is built. This module owns
+ * exactly that decision:
+ *
+ *   - global `config.llamaCppDraftModelPath` set → operator's own path wins,
+ *     nothing to resolve.
+ *   - manifest draft resolves to an installed path → rewrite `draftModelId`
+ *     to that path.
+ *   - manifest-driven spec whose draft isn't installed → STRIP the spec so
+ *     the launch falls back to plain decoding instead of crashing. The
+ *     +decode win is opportunistic on the draft being present, never a hard
+ *     dependency.
+ *   - operator explicitly forced `config.llamaCppSpecType=draft-simple` but
+ *     no draft path resolves → leave it and warn; the operator owns it.
+ */
+import type { PerModelLlamaCppEngineConfig } from './engine-flags.js';
+export interface SpecDraftResolveInput {
+    /** The catalog manifest's `tuning.engine.llamaCpp` block, if any. */
+    perModel: PerModelLlamaCppEngineConfig | undefined;
+    /** Global `config.llamaCppSpecType`, if the operator set one. */
+    configSpecType?: string | undefined;
+    /** Global `config.llamaCppDraftModelPath`, if the operator set one. */
+    configDraftModelPath?: string | undefined;
+    /** Resolve a catalog draft id → installed GGUF path (null if not installed). */
+    resolveDraftPath: (id: string) => Promise<string | null>;
+}
+export interface SpecDraftResolution {
+    /** The perModel to hand to `buildLlamaCppEngineArgs` (spec rewritten or stripped). */
+    perModel: PerModelLlamaCppEngineConfig | undefined;
+    /** A log line to emit, or null. */
+    log: {
+        level: 'info' | 'warn';
+        message: string;
+    } | null;
+}
+export declare function resolveSpecDraft(input: SpecDraftResolveInput): Promise<SpecDraftResolution>;

package/dist/providers/llama-cpp/spec-draft.js

@@ -0,0 +1,44 @@
+export async function resolveSpecDraft(input) {
+    const { perModel, configSpecType, configDraftModelPath, resolveDraftPath } = input;
+    const effectiveSpecType = configSpecType ?? perModel?.spec?.type;
+    // Only the manifest-draftModelId path needs resolving. An explicit global
+    // draft path, a non-draft-simple spec, or no draft id → nothing to do.
+    if (effectiveSpecType !== 'draft-simple' ||
+        !perModel?.spec?.draftModelId ||
+        configDraftModelPath) {
+        return { perModel, log: null };
+    }
+    const draftId = perModel.spec.draftModelId;
+    const draftPath = await resolveDraftPath(draftId).catch(() => null);
+    if (draftPath) {
+        return {
+            perModel: { ...perModel, spec: { ...perModel.spec, draftModelId: draftPath } },
+            log: {
+                level: 'info',
+                message: `[llama-cpp] speculative decoding: draft "${draftId}" → ${draftPath}`,
+            },
+        };
+    }
+    if (!configSpecType) {
+        // Manifest-driven spec, draft absent → strip so we don't fatal-launch a
+        // draft-simple with no draft model.
+        const { spec: _spec, ...rest } = perModel;
+        return {
+            perModel: rest,
+            log: {
+                level: 'info',
+                message: `[llama-cpp] speculative decoding (manifest draft "${draftId}") skipped: draft model not installed; running without it.`,
+            },
+        };
+    }
+    // Operator forced the spec type via global config but gave no resolvable
+    // draft — leave it and let llama-server surface the error rather than
+    // silently overriding an explicit request.
+    return {
+        perModel,
+        log: {
+            level: 'warn',
+            message: `[llama-cpp] config.llamaCppSpecType=draft-simple but draft "${draftId}" is not installed and no llamaCppDraftModelPath is set; the launch may fail.`,
+        },
+    };
+}

package/dist/providers/llama-cpp/stdout-parser.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Classify a single line of llama-server stdout/stderr into a lifecycle
+ * phase + human-readable detail. Used by the supervisor's onLog pipe to
+ * surface engine state in the UI instead of a bare "thinking" spinner.
+ *
+ * Deliberately small and tolerant: matching patterns are well-known
+ * upstream log lines that have been stable across recent llama.cpp
+ * versions, but we never crash on an unrecognized line — we just return
+ * null and the line continues to the raw log file. A format change
+ * degrades us to "no phase detail" rather than broken UX.
+ *
+ * Phase mapping:
+ *   - `starting`       : process has spawned but hasn't started loading
+ *                        weights yet (version banner, system info).
+ *   - `loading_model`  : mapping GGUF into memory, compiling GPU
+ *                        shaders, initializing KV cache.
+ *   - `prefill`        : mid-turn prompt evaluation — the model is
+ *                        consuming the input context in batches. Long
+ *                        histories (10k+ tokens) can sit here for
+ *                        tens of seconds before the first output
+ *                        token arrives; exposing batch progress is
+ *                        the biggest user-facing win.
+ *   - `ready`          : HTTP listener bound; server can accept
+ *                        requests. The supervisor's `/health` probe
+ *                        corroborates this.
+ *
+ * `progress` is emitted only when the line carries an explicit
+ * percentage we can trust. We err on the side of omitting it —
+ * guessing progress from per-line milestones would feel stuttery.
+ */
+export interface StartupPhase {
+    phase: 'starting' | 'loading_model' | 'prefill' | 'generating' | 'ready';
+    detail?: string;
+    progress?: number;
+    /**
+     * Bytes allocated for this line's memory region (model buffer, KV
+     * cache, etc.). Set only on lines that carry an explicit size;
+     * the caller accumulates these to produce a total engine-memory
+     * number for the UI. Absent on all other phase events.
+     */
+    bufferBytes?: number;
+    /**
+     * Exact decode counters when the line carries them. They travel as
+     * fields, never folded into `detail`: the UI already names the phase
+     * and renders its own counter row, and prose a consumer has to scrape
+     * back apart is not an interface.
+     */
+    outputTokens?: number;
+    tokensPerSec?: number;
+}
+/**
+ * Strip out any leading log prefix (the supervisor prepends
+ * `[llama-server] `) + trim. Exposed so callers can share the same
+ * normalization — both the real supervisor and the test fixture.
+ */
+export declare function stripLogPrefix(line: string): string;
+/**
+ * Pure classifier. Returns a phase descriptor when the line matches a
+ * known pattern, null otherwise. Caller decides whether to publish on
+ * null (typically no) and whether to dedupe repeated identical phases
+ * (typically yes — a burst of `load_tensors:` lines shouldn't flood
+ * the event bus).
+ */
+export declare function classifyStartupLine(rawLine: string): StartupPhase | null;
+/**
+ * Convert a `"2356.44 MiB"` pair into bytes. Returns null for units
+ * we don't recognize — defensive against format drift. Accepts the
+ * SI + binary unit suffixes llama.cpp actually emits.
+ */
+export declare function parseMemorySize(valueStr: string, unit: string): number | null;

package/dist/providers/llama-cpp/stdout-parser.js

@@ -0,0 +1,197 @@
+/**
+ * Strip out any leading log prefix (the supervisor prepends
+ * `[llama-server] `) + trim. Exposed so callers can share the same
+ * normalization — both the real supervisor and the test fixture.
+ */
+export function stripLogPrefix(line) {
+    return line.replace(/^\[[^\]]+\]\s*/, '').trim();
+}
+/**
+ * Pure classifier. Returns a phase descriptor when the line matches a
+ * known pattern, null otherwise. Caller decides whether to publish on
+ * null (typically no) and whether to dedupe repeated identical phases
+ * (typically yes — a burst of `load_tensors:` lines shouldn't flood
+ * the event bus).
+ */
+export function classifyStartupLine(rawLine) {
+    if (rawLine.includes('memory-admission:'))
+        return { phase: 'starting', detail: 'Waiting for available memory' };
+    const line = stripLogPrefix(rawLine);
+    if (!line)
+        return null;
+    // Server is up and listening — move to ready. This is the authoritative
+    // "can accept requests" signal; the /health 200 that follows confirms.
+    if (/^main:\s+server is listening/.test(line)) {
+        return { phase: 'ready', detail: 'Server ready' };
+    }
+    // Runtime: prompt processing progress. Fires per batch as llama-server
+    // consumes the input prompt before generation starts. For a long
+    // history this can be 5-40 seconds of otherwise-silent work — the
+    // single biggest user-facing win. Two log shapes across builds:
+    //   older/Metal: `slot update_slots: id 3 | task 0 | prompt processing
+    //                 progress, n_tokens = 2048, batch.n_tokens = 2048,
+    //                 progress = 0.146474`
+    //   newer/Vulkan: `... I slot print_timing: id 0 | task 0 | prompt
+    //                 processing, n_tokens = 4096, progress = 0.17, t =
+    //                 5.22 s / 785.15 tokens per second`
+    // The newer build drops the word "progress" from the phrase (it's a
+    // plain comma) and carries the fraction as a later `progress =` key.
+    // Match both: "prompt processing" optionally followed by " progress",
+    // then the running `n_tokens` count and the `progress =` fraction that
+    // appears anywhere after it. Non-anchored on purpose — the structured
+    // build prepends an `<uptime> <level> <scope>` prefix we don't strip.
+    const promptProgressMatch = line.match(/prompt processing(?:\s+progress)?\b.*?n_tokens\s*=\s*(\d+).*?\bprogress\s*=\s*([\d.]+)/);
+    if (promptProgressMatch) {
+        const nTokens = Number.parseInt(promptProgressMatch[1], 10);
+        const progress = Number.parseFloat(promptProgressMatch[2]);
+        if (!Number.isNaN(progress) && progress >= 0 && progress <= 1) {
+            // Project the total prompt size from `nTokens / progress`. This is
+            // exact (modulo float rounding) because llama.cpp emits both
+            // values from the same point in the same loop. We surface the
+            // total as "X / Y tokens" so the chat composer's progress chip
+            // shows the magnitude of the prompt being prefilled (the user-
+            // facing "where am I going") rather than the current running
+            // count (the "where am I now" the bar already conveys). When
+            // progress is too small to project meaningfully (first batch,
+            // <1%), keep the running-only format — a "2,048 / 200,000 tokens"
+            // estimate from a 1% sample is mostly noise.
+            const canProject = progress >= 0.01 && progress <= 0.99;
+            const projectedTotal = canProject ? Math.round(nTokens / progress) : null;
+            const tokenText = projectedTotal !== null
+                ? `${nTokens.toLocaleString('en-US')} / ${projectedTotal.toLocaleString('en-US')} tokens`
+                : `${nTokens.toLocaleString('en-US')} tokens`;
+            return {
+                phase: 'prefill',
+                detail: `Processing prompt (${Math.round(progress * 100)}% · ${tokenText})`,
+                progress,
+            };
+        }
+    }
+    // Slot-release line fires when generation completes a slot — useful
+    // as a "phase ended" signal we map back to ready. The structured
+    // build right-pads the tag to align colons (`slot      release:`),
+    // so key off the `release:` tag alone rather than a fixed `slot `
+    // spacing.
+    if (/\brelease:.*stop processing/.test(line)) {
+        return { phase: 'ready', detail: 'Turn complete' };
+    }
+    // Version banner + system info — pre-model-load. Useful detail to
+    // surface on the first-ever launch so the user sees something
+    // happened (the process booted).
+    const buildMatch = line.match(/^build:\s+(\d+)\s*\(([^)]+)\)/);
+    if (buildMatch) {
+        return {
+            phase: 'starting',
+            detail: `llama build ${buildMatch[1]} (${buildMatch[2]})`,
+        };
+    }
+    if (/^system info:/.test(line)) {
+        // Skip most of the system-info text — it's 500+ chars of capability
+        // flags. Just acknowledge the phase without a detail.
+        return { phase: 'starting' };
+    }
+    // Metal / Vulkan / CUDA backend init. These are the "compiling
+    // shaders" / "mapping to GPU" moments that account for a big chunk
+    // of cold-start wall-clock on the first ever run.
+    if (/^ggml_metal_init:/.test(line)) {
+        return { phase: 'loading_model', detail: 'Initializing Metal backend' };
+    }
+    if (/^ggml_vulkan:/.test(line) || /^ggml_cuda_init:/.test(line)) {
+        return { phase: 'loading_model', detail: 'Initializing GPU backend' };
+    }
+    // GGUF header parse / model metadata read.
+    if (/^llama_model_loader:\s+loaded meta data/.test(line)) {
+        return { phase: 'loading_model', detail: 'Reading model metadata' };
+    }
+    // Tensor buffer allocation — each line names a buffer and its size.
+    // The bulk of the "silent" wait on a cold start happens here. Parse
+    // the size into bytes so the provider can accumulate a RAM total
+    // across all the buffer lines.
+    const tensorsMatch = line.match(/^load_tensors:\s+\S+\s+model buffer size\s*=\s*([\d.]+)\s+(\w+)/);
+    if (tensorsMatch) {
+        const bytes = parseMemorySize(tensorsMatch[1], tensorsMatch[2]);
+        return {
+            phase: 'loading_model',
+            detail: `Loading model weights (${bytes === null ? `${tensorsMatch[1]} ${tensorsMatch[2]}` : formatMemoryBytes(bytes)})`,
+            ...(bytes !== null ? { bufferBytes: bytes } : {}),
+        };
+    }
+    // Some older / verbose builds emit a literal percentage when loading.
+    const percentMatch = line.match(/loading[^0-9]{0,40}(\d{1,3})%/i);
+    if (percentMatch) {
+        const pct = Number.parseInt(percentMatch[1], 10);
+        if (!Number.isNaN(pct) && pct >= 0 && pct <= 100) {
+            return {
+                phase: 'loading_model',
+                detail: `Loading model weights (${pct}%)`,
+                progress: pct / 100,
+            };
+        }
+    }
+    // KV cache allocation — runs after the model is mapped. Close to
+    // ready. Parse the buffer size when the line carries one so the
+    // total RAM footprint includes KV cache, not just weights.
+    // Format example: `llama_kv_cache_init: Metal KV buffer size = 256.00 MiB`
+    const kvMatch = line.match(/^llama_kv_cache_init:.*?KV buffer size\s*=\s*([\d.]+)\s+(\w+)/);
+    if (kvMatch) {
+        const bytes = parseMemorySize(kvMatch[1], kvMatch[2]);
+        return {
+            phase: 'loading_model',
+            detail: `Allocating KV cache (${bytes === null ? `${kvMatch[1]} ${kvMatch[2]}` : formatMemoryBytes(bytes)})`,
+            ...(bytes !== null ? { bufferBytes: bytes } : {}),
+        };
+    }
+    if (/^llama_kv_cache_init:/.test(line)) {
+        return { phase: 'loading_model', detail: 'Allocating KV cache' };
+    }
+    // Context params summary — right before serving. Signals "almost ready."
+    if (/^llama_context:/.test(line)) {
+        return { phase: 'loading_model', detail: 'Finalizing context' };
+    }
+    // Model load into memory (structured / Vulkan build). These `srv`-scope
+    // lines are the ONLY signal during the load window on builds that don't
+    // log per-tensor `load_tensors:` allocation — for a 27B GGUF off a cold
+    // disk that's 10+ seconds of otherwise-silent wait. Matched un-anchored
+    // because the line carries an `<uptime> <level> srv` prefix.
+    //   `... srv load_model: loading model '/path/Model-Q4_K_M.gguf'`
+    //   `... srv load_model: initializing, n_slots = 3, n_ctx_slot = 65536`
+    if (/\bload_model:\s*loading model\b/.test(line)) {
+        return { phase: 'loading_model', detail: 'Loading model into memory' };
+    }
+    if (/\bload_model:\s*initializing\b/.test(line)) {
+        return { phase: 'loading_model', detail: 'Initializing engine' };
+    }
+    return null;
+}
+/**
+ * Convert a `"2356.44 MiB"` pair into bytes. Returns null for units
+ * we don't recognize — defensive against format drift. Accepts the
+ * SI + binary unit suffixes llama.cpp actually emits.
+ */
+export function parseMemorySize(valueStr, unit) {
+    const value = Number.parseFloat(valueStr);
+    if (!Number.isFinite(value) || value < 0)
+        return null;
+    const multipliers = {
+        B: 1,
+        KB: 1_000,
+        KiB: 1_024,
+        MB: 1_000_000,
+        MiB: 1_024 * 1_024,
+        GB: 1_000_000_000,
+        GiB: 1_024 * 1_024 * 1_024,
+    };
+    const mult = multipliers[unit];
+    if (mult === undefined)
+        return null;
+    return Math.round(value * mult);
+}
+function formatMemoryBytes(bytes) {
+    if (bytes >= 1024 ** 3)
+        return `${(bytes / 1024 ** 3).toFixed(1)} GB`;
+    if (bytes >= 1024 ** 2)
+        return `${(bytes / 1024 ** 2).toFixed(0)} MB`;
+    if (bytes >= 1024)
+        return `${(bytes / 1024).toFixed(0)} KB`;
+    return `${bytes} B`;
+}

package/dist/providers/local-tool-call-salvage.d.ts

@@ -0,0 +1 @@
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/local-tool-call-salvage.js

@@ -0,0 +1,2 @@
+// Moved to core so the portable runtime runs the same loop; see core/src/local-loop.
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/local-turn-policy.d.ts

@@ -0,0 +1 @@
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/local-turn-policy.js

@@ -0,0 +1,2 @@
+// Moved to core so the portable runtime runs the same loop; see core/src/local-loop.
+export * from '@bendyline/gezel/local-loop';

package/dist/providers/mlx/async-file-handoff.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A successful async handoff is the terminal action for this sender.
+ * Role-typed `delegate_*` tools share `message_gezel`'s parked-delivery
+ * contract: the recipient cannot start until this provider turn releases the
+ * session. The provider executes the whole emitted tool-call batch before
+ * checking this predicate, so one response can still fan out to several
+ * recipients.
+ */
+export declare function isSuccessfulAsyncHandoff(toolName: string, output: string): boolean;
+export declare function asyncHandoffClosing(count: number): string;
+export declare function immediateFileWriteClosing(paths: string[]): string;

package/dist/providers/mlx/async-file-handoff.js

@@ -0,0 +1,25 @@
+/**
+ * A successful async handoff is the terminal action for this sender.
+ * Role-typed `delegate_*` tools share `message_gezel`'s parked-delivery
+ * contract: the recipient cannot start until this provider turn releases the
+ * session. The provider executes the whole emitted tool-call batch before
+ * checking this predicate, so one response can still fan out to several
+ * recipients.
+ */
+export function isSuccessfulAsyncHandoff(toolName, output) {
+    return (!output.startsWith('ERROR:') &&
+        (toolName === 'message_gezel' || toolName.startsWith('delegate_')));
+}
+export function asyncHandoffClosing(count) {
+    return count === 1
+        ? 'I sent the handoff and ended my turn so the recipient can use the provider queue. Their reply will arrive asynchronously.'
+        : `I sent ${count} handoffs and ended my turn so the recipients can use the provider queue. Their replies will arrive asynchronously.`;
+}
+export function immediateFileWriteClosing(paths) {
+    const unique = [...new Set(paths.filter((path) => path.trim().length > 0))];
+    if (unique.length === 0)
+        return 'I wrote the requested file to the workspace.';
+    if (unique.length === 1)
+        return `I wrote \`${unique[0]}\` to the workspace.`;
+    return `I wrote ${unique.map((path) => `\`${path}\``).join(', ')} to the workspace.`;
+}

package/dist/providers/mlx/build-provider.d.ts

@@ -0,0 +1,65 @@
+import { type GezelConfig } from '@bendyline/gezel';
+import type { ConfigStore as Store } from '../../fs/config-store.js';
+import { MlxProvider } from './provider.js';
+/**
+ * MLX does not receive a fixed-context launch flag: its KV cache grows with
+ * the request up to the model architecture's native limit. Consequently the
+ * catalog context window — not an arbitrary prefill-performance target — is
+ * the correct denominator for overflow checks, compaction, tool-output caps,
+ * and user-facing context warnings. An explicit operator limit still wins,
+ * clamped to the model's native maximum. Manual model paths have no catalog
+ * metadata, so they fall back to the host's context floor (64K, or 32K on a
+ * memory-constrained machine).
+ */
+export declare function resolveMlxEffectiveNumCtx(opts: {
+    modelContextWindow?: number;
+    configuredLimit?: number;
+    minViableContextTokens?: number;
+}): number;
+/**
+ * Construct an `MlxProvider` honoring env vars, config, and the
+ * UvRuntime bootstrap. Resolution order for the wire target:
+ *
+ *   1. `GEZEL_MLX_SERVER_URL` / `config.mlxBaseUrl` — external wire mode,
+ *      no subprocess. Mirrors llama-cpp's external-baseUrl branch.
+ *   2. A supervised `mlx_lm.server` subprocess launched from the MLX
+ *      venv UvRuntime manages. Requires:
+ *        - Apple Silicon (darwin-arm64). Other platforms → actionable
+ *          error pointing the user at llama-cpp.
+ *        - A UvRuntime instance on `ChatManager` (see `ChatManagerOptions`).
+ *        - An installed MLX model directory — via `mlxModels` catalog
+ *          manager or `config.mlxModelPath` env/config override.
+ *   3. Any of those missing → actionable error the Settings UI can
+ *      surface with a clear "install a model / switch Python runtime"
+ *      affordance.
+ *
+ * Unlike buildLlamaCppProvider, we must ensure the Python venv + mlx-lm
+ * package are provisioned BEFORE the supervisor spawns — the child
+ * launch command is the venv's `mlx_lm.server` console script. That's
+ * an `await uvRuntime.ensureVenv(...)` on the cold path, which can
+ * take minutes on first install. Subsequent boots are a no-op.
+ */
+export declare function buildMlxProvider(opts: {
+    config: GezelConfig;
+    affinity: boolean | undefined;
+    store: Pick<Store, 'readConfig' | 'writeConfig' | 'homePath'>;
+    mlxModels?: import('./index.js').MlxModelManager;
+    uvRuntime?: import('../../python/uv-runtime.js').UvRuntime;
+    mlxRuntimeStatus?: import('../../python/mlx-runtime-status-bus.js').MlxRuntimeStatusBus;
+    /**
+     * Pool-driven multi-engine routing. Same role as the same field on
+     * {@link buildLlamaCppProvider} — caller wins over config defaults.
+     */
+    modelOverride?: {
+        modelId: string;
+        replicaIdx: number;
+    };
+    /**
+     * Capacity broker (multi-model pool path). When present, its committed-bytes
+     * snapshot subtracts co-resident model reservations from the KV budget so the
+     * slot ceiling + cache budget account for what else is already loaded. Absent
+     * on the singleton path → full budget, committedOther = 0.
+     */
+    broker?: import('../native/capacity-broker.js').CapacityBroker;
+    arbiter?: import('../gpu-arbiter.js').GpuArbiter;
+}): Promise<MlxProvider>;