@telora/daemon 0.18.61 → 0.18.67

package/dist/host-control/load.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Load / unload orchestration for the host-control plane (Local model host
+ * control, D2).
+ *
+ * Per-pass model selection (D1) records which local model a coding vs review
+ * pass wants, but the daemon had no LOAD path -- so the selection could not
+ * drive an actual model switch. This module closes that gap: it loads / unloads
+ * the chosen per-pass model around each pass as a SEQUENTIAL swap on a single
+ * GPU (one model resident at a time -- loading evicts the prior), so a distinct
+ * coding-vs-review model can run end-to-end with NO manual swap in the studio.
+ *
+ * The control endpoints live under `/v1` (reachable from the stored baseUrl
+ * directly, which already ends in `/v1`): `POST /v1/load`, `POST /v1/unload`,
+ * `GET /v1/status`. Live JSON shapes are host-specific; `/v1/status` in
+ * particular is NOT pinned, so `normalizeStatus` is DEFENSIVE (tolerant of
+ * reasonable field names) and must be reconciled per the runbook.
+ *
+ * The maxSeqLength a load uses is an INJECTED input (an option, never hardcoded
+ * inside `ensureLoaded`) so Delivery 3 can replace the fixed `DEFAULT_MAX_SEQ_LENGTH`
+ * floor with a computed safe value without re-architecting this module.
+ */
+import type { HostStatus, LoadModelParams, SwapDecision } from './types.js';
+/**
+ * The control surface lives under `/v1` -- the SAME segment the stored baseUrl
+ * already ends in. We append these to the baseUrl directly (NOT the host root):
+ * a baseUrl of `http://host:8888/v1` yields `http://host:8888/v1/load`. A
+ * baseUrl without a trailing `/v1` still composes a sane path.
+ */
+export declare const HOST_CONTROL_LOAD_PATH = "/load";
+export declare const HOST_CONTROL_UNLOAD_PATH = "/unload";
+export declare const HOST_CONTROL_STATUS_PATH = "/status";
+/**
+ * Default max sequence length for a load. Sized at the live-proven 16384, which
+ * clears codex's ~8k turn-1 context floor with headroom. NOTE: Delivery 3 will
+ * REPLACE this fixed value with a computed safe value derived from the model +
+ * available VRAM; `loadModel`/`ensureLoaded` take maxSeqLength as an INJECTED
+ * input so D3 can pass a computed value without touching this module's shape.
+ */
+export declare const DEFAULT_MAX_SEQ_LENGTH = 16384;
+/**
+ * How long `ensureLoaded` will poll `/v1/status` for the target to become ready
+ * after issuing a load before giving up with a typed timeout. A cold load on a
+ * 12GB GPU has real latency; this is the bounded ceiling, not the expected wait.
+ */
+export declare const HOST_CONTROL_LOAD_READY_TIMEOUT_MS = 180000;
+/** Interval between `/v1/status` readiness polls while waiting for a load. */
+export declare const HOST_CONTROL_LOAD_POLL_INTERVAL_MS = 2000;
+/** Address-free category for a load that never reached ready within the budget. */
+export declare const HOST_CONTROL_ERROR_LOAD_TIMEOUT = "Host load did not reach ready in time";
+/**
+ * Normalize a `/v1/status` payload into a typed `HostStatus`. DEFENSIVE: the
+ * live shape is NOT pinned, so we tolerate the loaded-model id under any of
+ * `model`/`id`/`loaded_model`/... and readiness under `status`/`state`/`ready`
+ * (string token OR boolean). A payload that proves nothing loaded yields
+ * `{ loadedModelId: null, ready: false }`. Pure + exported for unit testing.
+ *
+ * Runbook flag: confirm the live `/v1/status` field names + readiness vocabulary
+ * and tighten `STATUS_*_KEYS` / `READY_TOKENS` once observed.
+ */
+export declare function normalizeStatus(payload: unknown): HostStatus;
+/**
+ * Issue a model load (`POST /v1/load`). Maps camelCase app params to the host's
+ * snake_case wire field names (`model_path`, `max_seq_length`, `cache_type_kv`,
+ * `gpu_ids`) at THIS boundary only. `maxSeqLength` is a required INJECTED input
+ * so D3 can pass a computed value. Throws `HostControlError` on any failure.
+ */
+export declare function loadModel(baseUrl: string, params: LoadModelParams, apiKey?: string | null): Promise<void>;
+/** Issue an unload (`POST /v1/unload`) -- evicts whatever is currently resident. */
+export declare function unloadModel(baseUrl: string, apiKey?: string | null): Promise<void>;
+/** Read current host status (`GET /v1/status`), normalized to a typed shape. */
+export declare function getStatus(baseUrl: string, apiKey?: string | null): Promise<HostStatus>;
+/**
+ * Resolve a chosen local_models `model` id to the host's `model_path` by reading
+ * the loadable catalog (D1) and matching by id. Returns null when the host is
+ * not controllable, the id is not in the catalog, or the matching entry carries
+ * no modelPath (a floor entry). The caller treats null as "cannot load" and
+ * skips the swap.
+ */
+export declare function resolveModelPath(baseUrl: string, modelId: string, apiKey?: string | null): Promise<string | null>;
+/**
+ * PURE swap decision over the current vs target resident model. Extracted from
+ * `ensureLoaded` so the core single-GPU swap logic is unit-testable with NO HTTP:
+ *
+ *   - target already resident + ready -> 'noop'
+ *   - a DIFFERENT model resident       -> 'evict_then_load' (single GPU -- evict first)
+ *   - nothing resident                 -> 'load'
+ *
+ * `current.modelId` is the currently-loaded id (null = nothing resident);
+ * `current.ready` gates the noop (a resident-but-not-ready target still needs a
+ * poll, but no reload -- treated as 'load' here so `ensureLoaded` re-issues +
+ * polls; the host treats a load of the resident model as a fast no-op/confirm).
+ */
+export declare function decideSwap(input: {
+    current: {
+        modelId: string | null;
+        ready: boolean;
+    };
+    target: string;
+}): SwapDecision;
+/** Options for `ensureLoaded`. `maxSeqLength` is injected (D3 computes it). */
+export interface EnsureLoadedOptions {
+    /** Context window to load with. Defaults to `DEFAULT_MAX_SEQ_LENGTH`. */
+    maxSeqLength?: number;
+    /** Optional KV cache dtype passed through to the load. */
+    cacheTypeKv?: string;
+    /** Optional GPU id selection passed through to the load. */
+    gpuIds?: number[];
+    /** Override the ready-poll budget (ms). Defaults to the module constant. */
+    readyTimeoutMs?: number;
+    /** Override the ready-poll interval (ms). Defaults to the module constant. */
+    pollIntervalMs?: number;
+    /**
+     * Injectable sleep, so the timeout/poll path is fast + deterministic in tests.
+     * Defaults to a real `setTimeout` wait.
+     */
+    sleep?: (ms: number) => Promise<void>;
+    /** Injectable clock for the bounded-poll deadline (defaults to `Date.now`). */
+    now?: () => number;
+}
+/**
+ * Orchestrate the SEQUENTIAL single-GPU swap so the target model is resident +
+ * ready before the caller spawns against it:
+ *
+ *   1. read status; if the target is already resident + ready -> no-op return.
+ *   2. else: if a DIFFERENT model is resident, unload it first (single GPU --
+ *      one resident at a time). Resolve the target id -> model_path, then load
+ *      with the injected maxSeqLength.
+ *   3. poll `/v1/status` until the target is ready, or throw a typed timeout
+ *      (`HOST_CONTROL_ERROR_LOAD_TIMEOUT`) once the bounded budget elapses.
+ *
+ * Throws `HostControlError` on an unresolvable path, a load/unload failure, or
+ * the ready timeout. The caller (focus-executor) turns any throw into "skip the
+ * spawn this tick" -- it must NOT spawn against a not-yet-loaded model.
+ */
+export declare function ensureLoaded(baseUrl: string, modelId: string, opts?: EnsureLoadedOptions, apiKey?: string | null): Promise<void>;
+//# sourceMappingURL=load.d.ts.map

package/dist/host-control/load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../src/host-control/load.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAc,YAAY,EAAE,MAAM,YAAY,CAAC;AAExF;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,UAAU,CAAC;AAC9C,eAAO,MAAM,wBAAwB,YAAY,CAAC;AAClD,eAAO,MAAM,wBAAwB,YAAY,CAAC;AAElD;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,QAAQ,CAAC;AAE5C;;;;GAIG;AACH,eAAO,MAAM,kCAAkC,SAAU,CAAC;AAE1D,8EAA8E;AAC9E,eAAO,MAAM,kCAAkC,OAAQ,CAAC;AAExD,mFAAmF;AACnF,eAAO,MAAM,+BAA+B,0CAA0C,CAAC;AAoCvF;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,UAAU,CA4B5D;AAED;;;;;GAKG;AACH,wBAAsB,SAAS,CAC7B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,eAAe,EACvB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GACrB,OAAO,CAAC,IAAI,CAAC,CAQf;AAED,oFAAoF;AACpF,wBAAsB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAExF;AAED,gFAAgF;AAChF,wBAAsB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,UAAU,CAAC,CAG5F;AAED;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GACrB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAIxB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE;IAChC,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;IACpD,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,YAAY,CAWf;AAED,+EAA+E;AAC/E,MAAM,WAAW,mBAAmB;IAClC,yEAAyE;IACzE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,0DAA0D;IAC1D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4DAA4D;IAC5D,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,4EAA4E;IAC5E,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,8EAA8E;IAC9E,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACtC,+EAA+E;IAC/E,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAMD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,YAAY,CAChC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,mBAAwB,EAC9B,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GACrB,OAAO,CAAC,IAAI,CAAC,CAqDf"}

package/dist/host-control/load.js

@@ -0,0 +1,241 @@
+/**
+ * Load / unload orchestration for the host-control plane (Local model host
+ * control, D2).
+ *
+ * Per-pass model selection (D1) records which local model a coding vs review
+ * pass wants, but the daemon had no LOAD path -- so the selection could not
+ * drive an actual model switch. This module closes that gap: it loads / unloads
+ * the chosen per-pass model around each pass as a SEQUENTIAL swap on a single
+ * GPU (one model resident at a time -- loading evicts the prior), so a distinct
+ * coding-vs-review model can run end-to-end with NO manual swap in the studio.
+ *
+ * The control endpoints live under `/v1` (reachable from the stored baseUrl
+ * directly, which already ends in `/v1`): `POST /v1/load`, `POST /v1/unload`,
+ * `GET /v1/status`. Live JSON shapes are host-specific; `/v1/status` in
+ * particular is NOT pinned, so `normalizeStatus` is DEFENSIVE (tolerant of
+ * reasonable field names) and must be reconciled per the runbook.
+ *
+ * The maxSeqLength a load uses is an INJECTED input (an option, never hardcoded
+ * inside `ensureLoaded`) so Delivery 3 can replace the fixed `DEFAULT_MAX_SEQ_LENGTH`
+ * floor with a computed safe value without re-architecting this module.
+ */
+import { hostGet, hostPost, HostControlError, HOST_CONTROL_ERROR_UNREACHABLE } from './client.js';
+import { readLoadableCatalog } from './catalog.js';
+/**
+ * The control surface lives under `/v1` -- the SAME segment the stored baseUrl
+ * already ends in. We append these to the baseUrl directly (NOT the host root):
+ * a baseUrl of `http://host:8888/v1` yields `http://host:8888/v1/load`. A
+ * baseUrl without a trailing `/v1` still composes a sane path.
+ */
+export const HOST_CONTROL_LOAD_PATH = '/load';
+export const HOST_CONTROL_UNLOAD_PATH = '/unload';
+export const HOST_CONTROL_STATUS_PATH = '/status';
+/**
+ * Default max sequence length for a load. Sized at the live-proven 16384, which
+ * clears codex's ~8k turn-1 context floor with headroom. NOTE: Delivery 3 will
+ * REPLACE this fixed value with a computed safe value derived from the model +
+ * available VRAM; `loadModel`/`ensureLoaded` take maxSeqLength as an INJECTED
+ * input so D3 can pass a computed value without touching this module's shape.
+ */
+export const DEFAULT_MAX_SEQ_LENGTH = 16384;
+/**
+ * How long `ensureLoaded` will poll `/v1/status` for the target to become ready
+ * after issuing a load before giving up with a typed timeout. A cold load on a
+ * 12GB GPU has real latency; this is the bounded ceiling, not the expected wait.
+ */
+export const HOST_CONTROL_LOAD_READY_TIMEOUT_MS = 180_000;
+/** Interval between `/v1/status` readiness polls while waiting for a load. */
+export const HOST_CONTROL_LOAD_POLL_INTERVAL_MS = 2_000;
+/** Address-free category for a load that never reached ready within the budget. */
+export const HOST_CONTROL_ERROR_LOAD_TIMEOUT = 'Host load did not reach ready in time';
+/**
+ * Join a baseUrl and a control-surface sub-path under `/v1`. The baseUrl already
+ * carries the `/v1` segment (it is the OpenAI-compatible base), so we append the
+ * sub-path directly, trimming a trailing slash so we never double up.
+ */
+function controlUrl(baseUrl, subPath) {
+    return `${baseUrl.replace(/\/+$/, '')}${subPath}`;
+}
+/** Read the first string-valued key present on an object, trimmed; null if none. */
+function firstStringOrNull(obj, keys) {
+    for (const key of keys) {
+        const v = obj[key];
+        if (typeof v === 'string') {
+            const trimmed = v.trim();
+            if (trimmed)
+                return trimmed;
+        }
+    }
+    return null;
+}
+/** Candidate keys carrying the currently-loaded model id on a `/v1/status` body. */
+const STATUS_LOADED_KEYS = ['model', 'id', 'loaded_model', 'loadedModel', 'model_id'];
+/** Candidate keys carrying a readiness signal on a `/v1/status` body. */
+const STATUS_READY_KEYS = ['status', 'state', 'ready'];
+/**
+ * String readiness tokens that mean "the loaded model is up and serving". The
+ * host's exact vocabulary is not pinned -- accept the common set. Reconcile
+ * against the live host per the runbook.
+ */
+const READY_TOKENS = new Set(['ready', 'loaded', 'running', 'ok', 'up', 'serving', 'idle']);
+/**
+ * Normalize a `/v1/status` payload into a typed `HostStatus`. DEFENSIVE: the
+ * live shape is NOT pinned, so we tolerate the loaded-model id under any of
+ * `model`/`id`/`loaded_model`/... and readiness under `status`/`state`/`ready`
+ * (string token OR boolean). A payload that proves nothing loaded yields
+ * `{ loadedModelId: null, ready: false }`. Pure + exported for unit testing.
+ *
+ * Runbook flag: confirm the live `/v1/status` field names + readiness vocabulary
+ * and tighten `STATUS_*_KEYS` / `READY_TOKENS` once observed.
+ */
+export function normalizeStatus(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return { loadedModelId: null, ready: false };
+    }
+    const obj = payload;
+    const loadedModelId = firstStringOrNull(obj, STATUS_LOADED_KEYS);
+    // Readiness can arrive as a boolean (`ready: true`) or a string token
+    // (`status: "ready"` / `state: "running"`). Accept either, defensively.
+    let ready = false;
+    for (const key of STATUS_READY_KEYS) {
+        const v = obj[key];
+        if (typeof v === 'boolean') {
+            if (v)
+                ready = true;
+            // An explicit `ready: false` is authoritative -- stop looking.
+            break;
+        }
+        if (typeof v === 'string' && READY_TOKENS.has(v.trim().toLowerCase())) {
+            ready = true;
+            break;
+        }
+    }
+    // A model id with no contradicting readiness signal is treated as ready only
+    // when a readiness key actually said so; absent any readiness key but with a
+    // loaded id, be conservative and report not-ready (let the poller confirm).
+    return { loadedModelId, ready };
+}
+/**
+ * Issue a model load (`POST /v1/load`). Maps camelCase app params to the host's
+ * snake_case wire field names (`model_path`, `max_seq_length`, `cache_type_kv`,
+ * `gpu_ids`) at THIS boundary only. `maxSeqLength` is a required INJECTED input
+ * so D3 can pass a computed value. Throws `HostControlError` on any failure.
+ */
+export async function loadModel(baseUrl, params, apiKey) {
+    const body = {
+        model_path: params.modelPath,
+        max_seq_length: params.maxSeqLength,
+    };
+    if (params.cacheTypeKv !== undefined)
+        body.cache_type_kv = params.cacheTypeKv;
+    if (params.gpuIds !== undefined)
+        body.gpu_ids = params.gpuIds;
+    await hostPost(controlUrl(baseUrl, HOST_CONTROL_LOAD_PATH), body, { apiKey });
+}
+/** Issue an unload (`POST /v1/unload`) -- evicts whatever is currently resident. */
+export async function unloadModel(baseUrl, apiKey) {
+    await hostPost(controlUrl(baseUrl, HOST_CONTROL_UNLOAD_PATH), {}, { apiKey });
+}
+/** Read current host status (`GET /v1/status`), normalized to a typed shape. */
+export async function getStatus(baseUrl, apiKey) {
+    const payload = await hostGet(controlUrl(baseUrl, HOST_CONTROL_STATUS_PATH), { apiKey });
+    return normalizeStatus(payload);
+}
+/**
+ * Resolve a chosen local_models `model` id to the host's `model_path` by reading
+ * the loadable catalog (D1) and matching by id. Returns null when the host is
+ * not controllable, the id is not in the catalog, or the matching entry carries
+ * no modelPath (a floor entry). The caller treats null as "cannot load" and
+ * skips the swap.
+ */
+export async function resolveModelPath(baseUrl, modelId, apiKey) {
+    const catalog = await readLoadableCatalog(baseUrl, apiKey);
+    const match = catalog.models.find((m) => m.id === modelId);
+    return match?.modelPath ?? null;
+}
+/**
+ * PURE swap decision over the current vs target resident model. Extracted from
+ * `ensureLoaded` so the core single-GPU swap logic is unit-testable with NO HTTP:
+ *
+ *   - target already resident + ready -> 'noop'
+ *   - a DIFFERENT model resident       -> 'evict_then_load' (single GPU -- evict first)
+ *   - nothing resident                 -> 'load'
+ *
+ * `current.modelId` is the currently-loaded id (null = nothing resident);
+ * `current.ready` gates the noop (a resident-but-not-ready target still needs a
+ * poll, but no reload -- treated as 'load' here so `ensureLoaded` re-issues +
+ * polls; the host treats a load of the resident model as a fast no-op/confirm).
+ */
+export function decideSwap(input) {
+    const { current, target } = input;
+    let action;
+    if (current.modelId === target) {
+        action = current.ready ? 'noop' : 'load';
+    }
+    else if (current.modelId !== null) {
+        action = 'evict_then_load';
+    }
+    else {
+        action = 'load';
+    }
+    return { action };
+}
+function defaultSleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Orchestrate the SEQUENTIAL single-GPU swap so the target model is resident +
+ * ready before the caller spawns against it:
+ *
+ *   1. read status; if the target is already resident + ready -> no-op return.
+ *   2. else: if a DIFFERENT model is resident, unload it first (single GPU --
+ *      one resident at a time). Resolve the target id -> model_path, then load
+ *      with the injected maxSeqLength.
+ *   3. poll `/v1/status` until the target is ready, or throw a typed timeout
+ *      (`HOST_CONTROL_ERROR_LOAD_TIMEOUT`) once the bounded budget elapses.
+ *
+ * Throws `HostControlError` on an unresolvable path, a load/unload failure, or
+ * the ready timeout. The caller (focus-executor) turns any throw into "skip the
+ * spawn this tick" -- it must NOT spawn against a not-yet-loaded model.
+ */
+export async function ensureLoaded(baseUrl, modelId, opts = {}, apiKey) {
+    const maxSeqLength = opts.maxSeqLength ?? DEFAULT_MAX_SEQ_LENGTH;
+    const readyTimeoutMs = opts.readyTimeoutMs ?? HOST_CONTROL_LOAD_READY_TIMEOUT_MS;
+    const pollIntervalMs = opts.pollIntervalMs ?? HOST_CONTROL_LOAD_POLL_INTERVAL_MS;
+    const sleep = opts.sleep ?? defaultSleep;
+    const now = opts.now ?? Date.now;
+    const status = await getStatus(baseUrl, apiKey);
+    const decision = decideSwap({
+        current: { modelId: status.loadedModelId, ready: status.ready },
+        target: modelId,
+    });
+    if (decision.action === 'noop')
+        return;
+    if (decision.action === 'evict_then_load') {
+        await unloadModel(baseUrl, apiKey);
+    }
+    const modelPath = await resolveModelPath(baseUrl, modelId, apiKey);
+    if (!modelPath) {
+        // No load path -> cannot load this model. Address-free category so the
+        // caller logs daemon-side and skips the spawn (re-attempts next poll).
+        throw new HostControlError(`No host model_path for model id "${modelId}"`, HOST_CONTROL_ERROR_UNREACHABLE);
+    }
+    await loadModel(baseUrl, {
+        modelPath,
+        maxSeqLength,
+        ...(opts.cacheTypeKv !== undefined ? { cacheTypeKv: opts.cacheTypeKv } : {}),
+        ...(opts.gpuIds !== undefined ? { gpuIds: opts.gpuIds } : {}),
+    }, apiKey);
+    // Poll for readiness up to the bounded budget. A cold load has real latency.
+    const deadline = now() + readyTimeoutMs;
+    for (;;) {
+        const polled = await getStatus(baseUrl, apiKey);
+        if (polled.loadedModelId === modelId && polled.ready)
+            return;
+        if (now() >= deadline) {
+            throw new HostControlError(`Model "${modelId}" did not reach ready within ${readyTimeoutMs}ms`, HOST_CONTROL_ERROR_LOAD_TIMEOUT);
+        }
+        await sleep(pollIntervalMs);
+    }
+}
+//# sourceMappingURL=load.js.map

package/dist/host-control/load.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.js","sourceRoot":"","sources":["../../src/host-control/load.ts"],"names":[],"mappings":"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"}

package/dist/host-control/sizing.d.ts

@@ -0,0 +1,207 @@
+/**
+ * Hardware-aware context sizing for the host-control plane (Local model host
+ * control, D3).
+ *
+ * The problem this closes: `max_seq_length` (the load-time context window) was a
+ * MANUAL, hardware-blind input. Set it too SMALL and codex's turn-1 prompt does
+ * not fit -- the load silently fails turn-1 with an instant `response.failed`
+ * (live: a 4096-ctx load failed; a manual reload to >=16k fixed it). Set it too
+ * LARGE and the KV-cache (which scales with context) OOMs a near-full GPU (live:
+ * a 12GB card sat ~93% used with a model resident). The safe value is bounded
+ * BELOW by codex's ~8k turn-1 floor and ABOVE by remaining VRAM headroom.
+ *
+ * This module adds two things:
+ *   1. defensive client reads over the host's hardware + kv-cache endpoints
+ *      (`getHardware`, `getKvCacheEstimate`) -- the live JSON shapes are NOT
+ *      pinned, so the normalizers tolerate reasonable field-name variants and
+ *      are flagged for runbook reconciliation;
+ *   2. a PURE `computeSafeMaxSeqLength` (no HTTP) -- the heart: pick the largest
+ *      context that clears the codex floor without exceeding VRAM headroom,
+ *      reaching for optional KV-cache quantization when it lets a context fit.
+ *
+ * The hardware/kv-cache endpoints live under the host ROOT (NOT `/v1`), so we
+ * derive the root with `hostRootFromBaseUrl` (strips a trailing `/v1`). All
+ * errors are address-free (TEL-5): the load path treats any read failure as
+ * "no sizing data" and falls back to the fixed floor default, never breaking a
+ * swap that previously worked.
+ */
+import type { HostHardware, KvCacheEstimate, KvCacheEstimateParams, SafeMaxSeqInput, SafeMaxSeqResult } from './types.js';
+/**
+ * The control-surface path (under the host ROOT, not `/v1`) for GPU hardware
+ * info: GPU name + total/used VRAM. Reconcile field names per the runbook.
+ */
+export declare const HOST_CONTROL_HARDWARE_PATH = "/api/system/hardware";
+/**
+ * The control-surface path (under the host ROOT, not `/v1`) for a KV-cache fit
+ * prediction at a candidate context. Reconcile field names per the runbook.
+ */
+export declare const HOST_CONTROL_KV_CACHE_PATH = "/api/models/kv-cache-estimate";
+/**
+ * Codex's turn-1 context floor. A load BELOW this silently fails the very first
+ * codex turn (instant `response.failed`) -- so we treat it as a HARD lower
+ * bound and never return a `maxSeqLength` under it, even when VRAM headroom is
+ * tight (we signal quant-required/marginal instead of silently going lower).
+ *
+ * The live datapoint: a 4096-ctx load failed turn-1; a reload to >=16384
+ * worked. The exact floor is ~8k; 8192 is the documented conservative pin.
+ */
+export declare const CODEX_TURN1_FLOOR = 8192;
+/**
+ * VRAM safety margin (MB) held back from raw headroom before sizing the KV
+ * cache. A near-full GPU (live: 12GB card ~93% used with a model resident)
+ * leaves little slack; this guards against the estimate being slightly optimistic,
+ * driver/allocator overhead, and fragmentation. Conservative on purpose --
+ * an OOM costs a whole swap, a slightly-smaller context costs nothing.
+ */
+export declare const VRAM_SAFETY_MARGIN_MB = 512;
+/**
+ * Per-token KV-cache cost heuristic (MB per 1 token of context) used as the
+ * FALLBACK growth model when the host's kv-cache-estimate endpoint is not
+ * consulted (the pure path takes only static inputs). This is intentionally a
+ * coarse upper-ish estimate for a ~7-8B class model at fp16 KV; the actual
+ * footprint is model-architecture-specific. The host's `getKvCacheEstimate`
+ * endpoint, when reachable, gives a far better per-context number and SHOULD be
+ * preferred by the orchestrator; this constant only bounds the pure computation
+ * when no live estimate is supplied.
+ *
+ * Derivation sketch (documented so the runbook can refine it): KV bytes ~=
+ * 2 (K and V) * layers * 2 (kv heads grouping varies) * head_dim * bytes/elem.
+ * For a 7B-class model at fp16 this lands on the order of ~0.12-0.20 MB/token;
+ * we pin a conservative 0.16 MB/token. Quantized KV (int8/fp8) roughly halves
+ * this -- see `KV_QUANT_FOOTPRINT_FACTOR`.
+ */
+export declare const KV_CACHE_MB_PER_TOKEN = 0.16;
+/**
+ * Footprint multiplier when KV-cache quantization is requested. int8/fp8 KV
+ * roughly halves the per-token cost vs fp16. Conservative 0.5 -- a real host
+ * may do better; the kv-cache-estimate endpoint, when consulted, supersedes
+ * this heuristic.
+ */
+export declare const KV_QUANT_FOOTPRINT_FACTOR = 0.5;
+/**
+ * The KV-cache dtype token sent as `cache_type_kv` on the load wire when the
+ * sizer elects to quantize to fit a context. The exact accepted token is
+ * host-specific; `q8_0` is the common llama.cpp-family int8 KV token. Flag for
+ * the runbook to confirm against the live host's accepted values.
+ */
+export declare const KV_QUANT_CACHE_TYPE = "q8_0";
+/**
+ * Hard ceiling on the context we will ever request, independent of headroom,
+ * when no native-context bound is known. A sane upper clamp so a wildly large
+ * estimate cannot produce an absurd request. Native context (when known) clamps
+ * tighter than this.
+ */
+export declare const MAX_SEQ_LENGTH_CEILING = 131072;
+/**
+ * Normalize a `/api/system/hardware` payload into a typed `HostHardware`.
+ * DEFENSIVE: the live shape is NOT pinned. Tolerates MB- or bytes-named VRAM
+ * fields, a flat or a `{ gpu: {...} }` / `{ gpus: [...] }` nesting, and missing
+ * fields (-> null). Pure + exported for unit testing.
+ *
+ * Runbook flag: confirm the live `/api/system/hardware` field names + units
+ * (MB vs bytes) and tighten `HW_*_KEYS` once observed.
+ */
+export declare function normalizeHardware(payload: unknown): HostHardware;
+/**
+ * Normalize a `/api/models/kv-cache-estimate` payload into a typed
+ * `KvCacheEstimate`. DEFENSIVE: footprint under MB- or bytes-named fields, an
+ * optional boolean fit verdict, both null/undefined when absent. Pure + exported.
+ *
+ * Runbook flag: confirm the live estimate field names + whether the endpoint
+ * echoes the candidate context; tighten `KV_*_KEYS` once observed.
+ */
+export declare function normalizeKvCacheEstimate(payload: unknown): KvCacheEstimate;
+/**
+ * Read the host's GPU + VRAM info (`GET <root>/api/system/hardware`), normalized
+ * to a typed `HostHardware`. The hardware endpoint lives under the host ROOT,
+ * NOT `/v1`, so we derive the root from the stored baseUrl. Throws
+ * `HostControlError` (address-free) on any transport failure -- the caller
+ * fail-safes to the floor default.
+ */
+export declare function getHardware(baseUrl: string, apiKey?: string | null): Promise<HostHardware>;
+/**
+ * Read a KV-cache fit prediction for a candidate context
+ * (`GET <root>/api/models/kv-cache-estimate`). The candidate context (and an
+ * optional model path + kv quant) are passed as query params; the live host's
+ * exact param names are NOT pinned, so we send the common-sense set and the
+ * normalizer is defensive about the response. Throws `HostControlError` on any
+ * transport failure -- the caller treats it as "no estimate" and uses the pure
+ * heuristic instead.
+ *
+ * Runbook flag: confirm the live query-param names (`max_seq_length`,
+ * `model_path`, `cache_type_kv`) the endpoint expects.
+ */
+export declare function getKvCacheEstimate(baseUrl: string, params: KvCacheEstimateParams, apiKey?: string | null): Promise<KvCacheEstimate>;
+/**
+ * PURE: compute the safe `max_seq_length` (and whether to quantize the KV cache)
+ * for a load, given VRAM totals/usage, the resident model size, and the model's
+ * native context. NO HTTP -- the orchestrator gathers the inputs and (optionally)
+ * validates the result against the live kv-cache endpoint.
+ *
+ * The arithmetic, with the live constraints in mind:
+ *
+ *  - headroom = vramTotal - vramUsed - VRAM_SAFETY_MARGIN_MB. This is the VRAM
+ *    available for the KV cache AFTER the model weights are resident. (Live: a
+ *    12GB card sat ~93% used with a model loaded -- headroom is small, so the
+ *    KV cache, which scales with context, is the binding constraint.) When
+ *    `vramUsed` already accounts for the weights, `modelSizeMb` is informational;
+ *    when it does not, we subtract `modelSizeMb` too (see below).
+ *
+ *  - The KV cache grows ~linearly with context (`KV_CACHE_MB_PER_TOKEN`). We pick
+ *    the LARGEST context whose KV cache fits headroom, clamped to the model's
+ *    native context (`nativeContext`) and the global ceiling.
+ *
+ *  - HARD LOWER BOUND (codex floor): a context below `CODEX_TURN1_FLOOR` silently
+ *    fails turn-1, so we NEVER return below it. If headroom can't fit the floor
+ *    at fp16 KV, we try quantization (`cacheTypeKv`), which ~halves the footprint.
+ *    If even quantized KV can't fit the floor, we return the floor ANYWAY with
+ *    `quantRequired`/`marginal` set -- going below is not an option; better to
+ *    attempt the floor (and let the load fail loudly / the operator add VRAM)
+ *    than to silently load a too-small context that fails turn-1 with no signal.
+ *
+ *  - When inputs are missing/degenerate (no VRAM data, zero/negative headroom),
+ *    we degrade SAFELY to the floor default -- never throw, never go below floor.
+ */
+export declare function computeSafeMaxSeqLength(input: SafeMaxSeqInput): SafeMaxSeqResult;
+/**
+ * The sizing inputs the orchestrator could not read from the host but the caller
+ * may know (from the D1 catalog entry or registry). Both optional -- when a field
+ * is unknown the sizer degrades safely (native unknown -> ceiling clamp; model
+ * size unknown -> no weights reservation).
+ */
+export interface SafeLoadSizingHints {
+    /** The candidate model's weights size in MB, when the caller knows it. */
+    modelSizeMb?: number | null;
+    /** The model's native context window, when the caller knows it. */
+    nativeContext?: number | null;
+}
+/**
+ * Resolve the safe `EnsureLoadedOptions` sizing bits (`maxSeqLength` + optional
+ * `cacheTypeKv`) for a load by reading the host's hardware, running the PURE
+ * `computeSafeMaxSeqLength`, and OPTIONALLY validating the result against the
+ * live kv-cache-estimate endpoint. This is the seam the focus-executor calls in
+ * place of D2's fixed `DEFAULT_MAX_SEQ_LENGTH`.
+ *
+ * FAIL-SAFE: if the hardware endpoint is missing / unreachable / returns no VRAM
+ * totals, we DO NOT compute against headroom -- we return the fixed
+ * `DEFAULT_MAX_SEQ_LENGTH` (>= the codex floor) exactly as D2 did, and report the
+ * fallback so the caller logs it. A sizing failure must NEVER break a swap that
+ * previously worked with the fixed default.
+ *
+ * The kv-cache-estimate validation is best-effort: if it predicts the computed
+ * context will NOT fit (and we are not already quantizing), we re-run the sizer
+ * forcing quantization; if the endpoint is unreachable we keep the pure result.
+ * The estimate is never allowed to push the context BELOW the floor.
+ *
+ * Returns `{ maxSeqLength, cacheTypeKv?, source, marginal?, quantRequired? }`.
+ * `source` is `'computed'` when hardware drove the value, `'fallback'` when we
+ * fell back to the fixed default -- the caller logs which path it took.
+ */
+export declare function resolveSafeLoadOptions(baseUrl: string, modelPath: string | null, hints?: SafeLoadSizingHints, apiKey?: string | null): Promise<{
+    maxSeqLength: number;
+    cacheTypeKv?: string;
+    source: 'computed' | 'fallback';
+    marginal?: boolean;
+    quantRequired?: boolean;
+}>;
+//# sourceMappingURL=sizing.d.ts.map

package/dist/host-control/sizing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sizing.d.ts","sourceRoot":"","sources":["../../src/host-control/sizing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,qBAAqB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE1H;;;GAGG;AACH,eAAO,MAAM,0BAA0B,yBAAyB,CAAC;AAEjE;;;GAGG;AACH,eAAO,MAAM,0BAA0B,kCAAkC,CAAC;AAE1E;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,OAAO,CAAC;AAEtC;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,qBAAqB,OAAO,CAAC;AAE1C;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAE7C;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,SAAS,CAAC;AAE1C;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,SAAS,CAAC;AA0F7C;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,YAAY,CAUhE;AASD;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,GAAG,eAAe,CAmB1E;AAID;;;;;;GAMG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,CAIhG;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,qBAAqB,EAC7B,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GACrB,OAAO,CAAC,eAAe,CAAC,CAY1B;AAmCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,eAAe,GAAG,gBAAgB,CAsEhF;AAID;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,0EAA0E;IAC1E,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,mEAAmE;IACnE,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAAG,IAAI,EACxB,KAAK,GAAE,mBAAwB,EAC/B,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,GACrB,OAAO,CAAC;IACT,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC;IAChC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC,CAyDD"}