@atomic-chat/core 0.13.2 → 0.13.6

package/dist/runtime/tensorrt-llm/quant-format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quant-format.js","sourceRoot":"","sources":["../../../src/runtime/tensorrt-llm/quant-format.ts"],"names":[],"mappings":"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"}

package/dist/runtime/tensorrt-llm/registry.d.ts

@@ -0,0 +1,26 @@
+import type { TensorrtLlmModelYmlDocument } from './model-dir.js';
+export interface TensorrtLlmModelEntry {
+    id: string;
+    /** Directory holding `model.yml`. */
+    dir: string;
+    yml: TensorrtLlmModelYmlDocument;
+}
+/** Scan errors are collected rather than thrown: one broken model must not hide the rest of the list. */
+export interface TensorrtLlmScanResult {
+    entries: TensorrtLlmModelEntry[];
+    skipped: Array<{
+        dir: string;
+        error: string;
+    }>;
+}
+export declare class TensorrtLlmModelRegistry {
+    private readonly modelsDir;
+    /**
+     * The models root, or how to learn it at each scan (change `add-tensorrt-llm-windows`, task 2.8): on
+     * Windows it is a folder in Atomic Chat's WSL distribution, known only once that exists — `null`
+     * until then, which lists nothing.
+     */
+    constructor(modelsDir: string | (() => Promise<string | null>));
+    scan(): Promise<TensorrtLlmScanResult>;
+    list(): Promise<TensorrtLlmModelEntry[]>;
+}

package/dist/runtime/tensorrt-llm/registry.js

@@ -0,0 +1,68 @@
+/**
+ * The `tensorrt-llm` model registry (task 2.16, spec `tensorrt-llm-models`, "Модель — каталог
+ * провайдера с манифестом"): a depth-first scan of `<data>/tensorrt-llm/models`, following the same
+ * rules `src/models/registry.ts`'s `ModelRegistry` already uses for llama.cpp so all three surfaces
+ * (core, the app, the CLI) see the same ids for the same folders — a directory holding `model.yml`
+ * *is* a model and is never descended into, the id is its path relative to the models root with `\`
+ * rewritten to `/`, ids sort ascending, and an unreadable or invalid `model.yml` is skipped rather
+ * than failing the whole scan (spec "Недокачанный каталог": a directory with files but no
+ * `model.yml` is not shown at all).
+ *
+ * There is no caching here, by design: every call re-walks the directory, so a model the app finishes
+ * downloading and writes `model.yml` for appears on the very next `list()` with no restart needed
+ * (spec "Модель докачана в app"). `model.yml` itself is a different shape from llama.cpp's
+ * (`repository`, `revision`, `files`, `architectures`, `quantization` — no `model_path`), which is
+ * why this is its own registry rather than a reuse of the llama.cpp one; `parseTensorrtLlmModelYml`
+ * (`model-dir.ts`) is the one parser both this scan and the single-id load-path lookup
+ * (`readTensorrtLlmModel`) share, so they can never disagree about what a `model.yml` means.
+ */
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { MODEL_YML, modelIdFromDir } from '../../config/index.js';
+import { parseTensorrtLlmModelYml } from './model-dir.js';
+export class TensorrtLlmModelRegistry {
+    modelsDir;
+    /**
+     * The models root, or how to learn it at each scan (change `add-tensorrt-llm-windows`, task 2.8): on
+     * Windows it is a folder in Atomic Chat's WSL distribution, known only once that exists — `null`
+     * until then, which lists nothing.
+     */
+    constructor(modelsDir) {
+        this.modelsDir = modelsDir;
+    }
+    async scan() {
+        const result = { entries: [], skipped: [] };
+        const root = typeof this.modelsDir === 'string' ? this.modelsDir : await this.modelsDir().catch(() => null);
+        if (root === null)
+            return result;
+        const stack = [root];
+        while (stack.length) {
+            const dir = stack.pop();
+            const ymlPath = join(dir, MODEL_YML);
+            const text = await readFile(ymlPath, 'utf8').catch(() => undefined);
+            if (text !== undefined) {
+                try {
+                    result.entries.push({
+                        id: modelIdFromDir(root, dir),
+                        dir,
+                        yml: parseTensorrtLlmModelYml(text, ymlPath),
+                    });
+                }
+                catch (e) {
+                    result.skipped.push({ dir, error: e.message });
+                }
+                continue; // a model directory is a leaf, whether or not it parsed
+            }
+            const children = await readdir(dir, { withFileTypes: true }).catch(() => []);
+            for (const child of children)
+                if (child.isDirectory())
+                    stack.push(join(dir, child.name));
+        }
+        result.entries.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+        return result;
+    }
+    async list() {
+        return (await this.scan()).entries;
+    }
+}
+//# sourceMappingURL=registry.js.map

package/dist/runtime/tensorrt-llm/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../src/runtime/tensorrt-llm/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AACpD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AACjE,OAAO,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAA;AAgBzD,MAAM,OAAO,wBAAwB;IAMN;IAL7B;;;;OAIG;IACH,YAA6B,SAAkD;QAAlD,cAAS,GAAT,SAAS,CAAyC;IAAG,CAAC;IAEnF,KAAK,CAAC,IAAI;QACR,MAAM,MAAM,GAA0B,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,CAAA;QAClE,MAAM,IAAI,GACR,OAAO,IAAI,CAAC,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAA;QAChG,IAAI,IAAI,KAAK,IAAI;YAAE,OAAO,MAAM,CAAA;QAChC,MAAM,KAAK,GAAa,CAAC,IAAI,CAAC,CAAA;QAC9B,OAAO,KAAK,CAAC,MAAM,EAAE,CAAC;YACpB,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,EAAY,CAAA;YACjC,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,SAAS,CAAC,CAAA;YACpC,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAA;YACnE,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;gBACvB,IAAI,CAAC;oBACH,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC;wBAClB,EAAE,EAAE,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC;wBAC7B,GAAG;wBACH,GAAG,EAAE,wBAAwB,CAAC,IAAI,EAAE,OAAO,CAAC;qBAC7C,CAAC,CAAA;gBACJ,CAAC;gBAAC,OAAO,CAAC,EAAE,CAAC;oBACX,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,KAAK,EAAG,CAAW,CAAC,OAAO,EAAE,CAAC,CAAA;gBAC3D,CAAC;gBACD,SAAQ,CAAC,wDAAwD;YACnE,CAAC;YACD,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAA;YAC5E,KAAK,MAAM,KAAK,IAAI,QAAQ;gBAAE,IAAI,KAAK,CAAC,WAAW,EAAE;oBAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAA;QAC1F,CAAC;QACD,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;QACvE,OAAO,MAAM,CAAA;IACf,CAAC;IAED,KAAK,CAAC,IAAI;QACR,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,OAAO,CAAA;IACpC,CAAC;CACF"}

package/dist/runtime/tensorrt-llm/runtime.d.ts

@@ -0,0 +1,130 @@
+import type { SessionInfo, UnloadResult } from '../../contracts/index.js';
+import type { ModelCapabilities } from '../../models/index.js';
+import type { ManagedLastAttempt, ManagedTextCapabilities, ManagedTextLifecycle } from '../managed-text/index.js';
+import type { CtxIncreaseResult, GpuClaimHook, GpuOccupancy, LocalLoadOptions, LocalRuntime, RecreateResult, SessionRoutePolicy } from '../shared/index.js';
+import type { TensorrtLlmHostFacts } from './host-facts.js';
+import type { ReadyInstallation } from './installation.js';
+import type { TensorrtLlmModel } from './model-dir.js';
+export interface TensorrtLlmRuntimeDeps {
+    /**
+     * The lifecycle over the core's one Docker executor and journal (the startup handle the setup
+     * operation shares), asked at every load: `null` while this host has no docker CLI — a setup that
+     * installs Docker later makes the next load find it, with no restart; rejected, with the cause,
+     * when wiring the executor failed. The same instance every time it resolves non-null.
+     */
+    lifecycle: () => Promise<ManagedTextLifecycle | null>;
+    /** The `ready` installation, its pinned descriptor and image; rejects with why there is none. */
+    readyInstallation: () => Promise<ReadyInstallation>;
+    /** The cards and SELinux, asked right before each load: a card can disappear between two loads. */
+    hostFacts: () => Promise<TensorrtLlmHostFacts>;
+    model: (modelId: string) => Promise<TensorrtLlmModel>;
+    /** The provider's stored settings (`settings.get('tensorrt-llm')`), read at every load. */
+    settings: () => Record<string, unknown>;
+    /**
+     * Core's GPU residency (spec `gpu-residency`), run as the `stopping-previous` stage: frees the chosen
+     * card of every other engine and this provider's other session. Absent, the stage stops only the
+     * other `tensorrt-llm` models, itself.
+     */
+    claimGpu?: GpuClaimHook;
+}
+/**
+ * `GET /models/tensorrt-llm/:id/capabilities`: the fields every provider's answer has (all false for
+ * this engine — no projector, no embedding, no speculative decoding), and the managed engine's own,
+ * which the app gates Agent, tools and attachments on (task 3.8).
+ */
+export type TensorrtLlmModelCapabilities = ModelCapabilities & ManagedTextCapabilities & {
+    /** The architecture `model.yml` names, which picked the descriptor's `model_families` entry. */
+    architecture: string | null;
+};
+/** `GET /models/tensorrt-llm/:id/logs`: the loaded container's live tail, or the last failed attempt's. */
+export type TensorrtLlmModelLogs = {
+    model_id: string;
+    source: 'session';
+    generation: string;
+    log_tail: string;
+} | {
+    model_id: string;
+    source: 'last-attempt';
+    generation: string;
+    log_tail: string;
+    error: ManagedLastAttempt['error'];
+    at: number;
+} | {
+    model_id: string;
+    source: null;
+    log_tail: '';
+};
+export declare class TensorrtLlmRuntime implements LocalRuntime {
+    private readonly deps;
+    private current;
+    private closed;
+    /** Removals of the engine in progress: while any holds loads off, every load is refused (M-1). */
+    private loadHolds;
+    /** Deletions of one model in progress (task 2.24): each refuses loads of that model only, counted. */
+    private readonly modelHolds;
+    /** Generations whose GPU claim succeeded: a load only holds its card from then on. */
+    private readonly claimed;
+    /** What each loaded session can do, keyed by model and pinned to the generation it was computed for. */
+    private readonly sessionCapabilities;
+    constructor(deps: TensorrtLlmRuntimeDeps);
+    list(): SessionInfo[];
+    findSession(modelId: string): SessionInfo | undefined;
+    getLoadedModels(): string[];
+    isLoading(modelId: string): boolean;
+    load(modelId: string, opts?: LocalLoadOptions): Promise<SessionInfo>;
+    /**
+     * Throws `MANAGED_STOP_UNCONFIRMED` when Docker will not confirm the stop: the card stays reserved
+     * and the caller is told, rather than handed a success that is not one.
+     */
+    unload(modelId: string): Promise<UnloadResult>;
+    /**
+     * Every model holding a card through this provider — loading, ready, stopping, or stopped without
+     * Docker's confirmation: what a removal of the engine must unload first (task 2.6), through core's
+     * own unload so each model's cross-process claim is released with it (final review M-1).
+     */
+    residentModels(): string[];
+    /**
+     * Refuses every load with `MANAGED_OPERATION_CONFLICT` until the returned release is called (final
+     * review M-1): a removal of the engine holds loads off for as long as it runs, so no load creates
+     * a container on an installation being removed. Holds nest; each release counts once.
+     */
+    holdOffLoads(): () => void;
+    /**
+     * Refuses loads of this one model with `MANAGED_OPERATION_CONFLICT` until the returned release is
+     * called (task 2.24): a deletion holds them off from before it stops the model until its files are
+     * gone, so no load mounts a folder being removed. Other models load as usual. Holds nest.
+     */
+    holdOffModel(modelId: string): () => void;
+    /** Never: the context is fixed when the container starts (design D9, spec "без авто-роста"). */
+    autoIncreaseCtx(_modelId: string): Promise<CtxIncreaseResult>;
+    recreateSession(modelId: string): Promise<RecreateResult>;
+    shutdown(): Promise<void>;
+    routePolicy(modelId: string): SessionRoutePolicy | undefined;
+    /** Answers rather than throws, like every provider's capabilities: all false while nothing resolves. */
+    capabilities(modelId: string): Promise<TensorrtLlmModelCapabilities>;
+    logs(modelId: string): Promise<TensorrtLlmModelLogs>;
+    private assertOpen;
+    private assertNotHeldOff;
+    /**
+     * The card each container holds, for core's residency rule: every model past its claim — loading,
+     * ready, stopping, or stopped without Docker's confirmation, which still holds the card.
+     */
+    gpuOccupancy(): GpuOccupancy[];
+    /**
+     * The `stopping-previous` stage. With core's residency: its claim on `gpuId`, which stops every other
+     * `tensorrt-llm` model (one session at a time) and every other engine on that card, each with a
+     * confirmed exit, and refuses with `GPU_BUSY` while one will not stop. Without it: every other
+     * `tensorrt-llm` model, loading or loaded, stopped with confirmation. Either way the load holds its
+     * card from then on — with residency, from the moment core grants the claim, inside core's turn.
+     */
+    private stopOthers;
+    /**
+     * The lifecycle's `beforeCreate` hook (task 2.16w round 1, finding 1 (Critical)): the pre-launch
+     * check's memory line, re-probed fresh right before the container is actually created — after
+     * `stopPrevious` has run, so a model switch on a single-GPU host sees the card the previous
+     * session just freed, never a snapshot `load()` took before eviction. `MANAGED_PREREQUISITE_
+     * BLOCKED` when the chosen card is no longer on the host at all (the same code a missing card gets
+     * earlier in `load()`); `MODEL_INCOMPATIBLE` when it is still there but does not have room.
+     */
+    private checkMemoryBeforeCreate;
+}

package/dist/runtime/tensorrt-llm/runtime.js

@@ -0,0 +1,395 @@
+/**
+ * The `tensorrt-llm` provider (task 2.14, spec `tensorrt-llm-runtime`): a `LocalRuntime` on the
+ * engine-neutral managed-text lifecycle (`../managed-text/`), registered by core only on Linux. What
+ * this file adds on top of the lifecycle is the provider's own part of a load:
+ *
+ *  - refusing it before any container exists — no Docker, no `ready` installation
+ *    (`MANAGED_ADAPTER_UNAVAILABLE`), settings the adapter rejects (`INVALID_ARGUMENT`), a model that
+ *    is not installed, a host with no NVIDIA card, an embedding request;
+ *  - the card: the saved `gpu_id` when the probe still finds it, otherwise the one with the most free
+ *    memory, ties by the most total memory (`selectLaunchGpu`, the same rule `POST /check` uses,
+ *    design D12b), with the replacement reported on every load event;
+ *  - one session at a time, and one resident model per card: the lifecycle's `stopping-previous`
+ *    stage asks core's GPU residency (`claimGpu`, task 2.15) to stop every other `tensorrt-llm`
+ *    model and every other engine on the chosen card, each with a confirmed exit, before this one's
+ *    container is created — or, with no residency wired, stops the other `tensorrt-llm` models itself;
+ *  - what a session can do (`routePolicy`, `capabilities`), read off the pinned descriptor's
+ *    `model_families` entry for the model's architecture — never guessed (design D9);
+ *  - never growing a context or recreating a session: a restart of a multi-minute container in the
+ *    middle of a conversation is worse than an honest `context_length_exceeded` (design D9);
+ *  - the pre-launch check (task 2.16), split in two (round 1, finding 1 (Critical)): before
+ *    `stopPrevious` runs, `verifyModelFilesAndCompatibility` (`prelaunch.ts`) re-verifies every file
+ *    `model.yml` recorded present on disk at its size, and recomputes architecture/format/compute-
+ *    capability against `config.json`/`hf_quant_config.json` as they sit in the model's directory
+ *    right now — never memory, which the model this load is about to replace may still be holding on
+ *    the very same card. Memory is checked after `stopPrevious`, through the lifecycle's own
+ *    `beforeCreate` hook (`checkMemoryBeforeCreate` below), which re-probes the chosen card's free
+ *    memory once whatever `stopPrevious` freed is actually free;
+ *  - `family` (tools/structured output/route policy) is read off the descriptor's `model_families`
+ *    entry for the *verified* `config.json` architecture (finding 5) — `model.yml`'s own copy of the
+ *    architecture is never consulted for this, since the pre-launch check may have found it stale.
+ *
+ * Everything that touches the machine arrives injected: the lifecycle over the core's one Docker
+ * executor, the ready installation, the host facts, the model lookup and the stored settings.
+ */
+import { AtomicCoreError } from '../../contracts/index.js';
+import { throwIfLoadCancelled } from '../shared/index.js';
+import { tensorrtLlmAdapter } from './adapter.js';
+import { checkModelMemory, selectLaunchGpu } from './compatibility.js';
+import { verifyModelFilesAndCompatibility } from './prelaunch.js';
+import { tensorrtLlmRoutePolicy } from './route-policy.js';
+import { tensorrtLlmSettings } from './settings.js';
+const NONE = {
+    tools: false,
+    reasoning: false,
+    structured_output: false,
+    vision: false,
+    embeddings: false,
+    responses: false,
+};
+/** `capabilities()`'s own lookup, off `model.yml`'s architecture: no disk verification runs for it. */
+function familyOf(ready, model) {
+    if (model.architecture === null)
+        return null;
+    return ready.descriptor.model_families[model.architecture] ?? null;
+}
+/**
+ * The load path's own lookup (finding 5): off the *verified* `config.json` architecture
+ * (`ResolvedCheckpoint.architectures[0]`, from the pre-launch check), never `model.yml`'s — the two
+ * can disagree (a stale `model.yml`, or none at all), and only the one the compatibility check just
+ * confirmed against the descriptor's `supported_architectures` is trustworthy enough to gate what a
+ * session is allowed to do.
+ */
+function familyFromResolved(ready, resolved) {
+    const architecture = resolved.architectures[0];
+    return architecture === undefined ? null : (ready.descriptor.model_families[architecture] ?? null);
+}
+export class TensorrtLlmRuntime {
+    deps;
+    current = null;
+    closed = false;
+    /** Removals of the engine in progress: while any holds loads off, every load is refused (M-1). */
+    loadHolds = 0;
+    /** Deletions of one model in progress (task 2.24): each refuses loads of that model only, counted. */
+    modelHolds = new Map();
+    /** Generations whose GPU claim succeeded: a load only holds its card from then on. */
+    claimed = new Set();
+    /** What each loaded session can do, keyed by model and pinned to the generation it was computed for. */
+    sessionCapabilities = new Map();
+    constructor(deps) {
+        this.deps = deps;
+    }
+    list() {
+        return this.current?.list() ?? [];
+    }
+    findSession(modelId) {
+        return this.current?.findSession(modelId);
+    }
+    getLoadedModels() {
+        return this.list().map((session) => session.model_id);
+    }
+    isLoading(modelId) {
+        return this.current?.isLoading(modelId) ?? false;
+    }
+    async load(modelId, opts = {}) {
+        const { signal } = opts;
+        this.assertOpen();
+        this.assertNotHeldOff(modelId);
+        throwIfLoadCancelled(signal);
+        if (opts.isEmbedding) {
+            throw new AtomicCoreError('INVALID_ARGUMENT', 'tensorrt-llm models do not serve embeddings.', modelId);
+        }
+        // Validated first, before anything is asked of the machine (spec: schema validation before start).
+        const settings = tensorrtLlmSettings(this.deps.settings(), opts.overrides);
+        const lifecycle = await this.deps.lifecycle().catch((cause) => {
+            throw new AtomicCoreError('MANAGED_ADAPTER_UNAVAILABLE', 'The managed container runtime failed to initialise, so tensorrt-llm cannot run models.', cause instanceof Error ? cause.message : String(cause));
+        });
+        if (lifecycle === null) {
+            throw new AtomicCoreError('MANAGED_ADAPTER_UNAVAILABLE', 'Docker is not installed on this machine, so tensorrt-llm cannot run models.');
+        }
+        // Kept from the first load on: what `list`, `unload` and `shutdown` act on. Nothing is loaded
+        // before that, so there is nothing for them to find earlier either.
+        this.current = lifecycle;
+        const ready = await this.deps.readyInstallation();
+        throwIfLoadCancelled(signal);
+        const model = await this.deps.model(modelId);
+        const facts = await this.deps.hostFacts();
+        throwIfLoadCancelled(signal);
+        this.assertOpen();
+        const gpu = selectLaunchGpu(facts.gpus, facts.memory, settings.gpu_id ?? undefined);
+        if (gpu === null) {
+            throw new AtomicCoreError('MANAGED_PREREQUISITE_BLOCKED', 'No NVIDIA GPU was found on this machine, so tensorrt-llm cannot load a model.');
+        }
+        const substituted = settings.gpu_id !== null && gpu.gpu_id !== settings.gpu_id
+            ? { requested_gpu_id: settings.gpu_id, gpu_id: gpu.gpu_id }
+            : undefined;
+        const memory = {
+            contextLength: settings.context_length,
+            kvCacheFreeGpuMemoryFraction: settings.kv_cache_free_gpu_memory_fraction,
+        };
+        // Pre-launch check, phase 1 (task 2.16, spec "Проверка файлов при загрузке"; round 1, finding 1
+        // (Critical)): every file model.yml recorded is still on disk at its size, and architecture/
+        // format/compute-capability are recomputed against config.json/hf_quant_config.json as they sit
+        // on disk right now — never model.yml's word for it, and never memory, which the model this load
+        // is about to replace may still be holding on this very card. No container exists yet; a failure
+        // here never creates one.
+        const resolved = await verifyModelFilesAndCompatibility(model, ready.descriptor, facts.gpus, facts.memory, { gpuId: gpu.gpu_id, memory });
+        throwIfLoadCancelled(signal);
+        this.assertOpen();
+        // family from the *verified* config.json architecture, never model.yml's own (finding 5).
+        const family = familyFromResolved(ready, resolved);
+        const { descriptor } = ready;
+        // Again right before the lifecycle registers this load (synchronously, inside `lifecycle.load`):
+        // a removal that began while this load was probing the host must not find it past the check.
+        this.assertNotHeldOff(modelId);
+        const session = await lifecycle.load({
+            modelId,
+            modelPath: model.dir,
+            weightBytes: model.weightBytes,
+            installation: {
+                descriptor_id: descriptor.descriptor_id,
+                engine_id: descriptor.engine_id,
+                adapter_id: descriptor.adapter_id,
+                adapter_contract_version: descriptor.adapter_contract_version,
+                image: ready.image,
+            },
+            family,
+            gpuUuid: gpu.gpu_id,
+            // No VRAM of its own (design D13): the launch bounds the KV cache by tokens, as the memory
+            // check (`checkModelMemory`, same rule) reserved for it.
+            unifiedMemory: gpu.total_vram_bytes === null,
+            gpuTotalVramBytes: gpu.total_vram_bytes,
+            gpuComputeCapability: gpu.compute_capability,
+            selinux: facts.selinux,
+            settings,
+            // Always passed, evaluated when the stage runs: a second model that arrived a moment earlier
+            // is still found, so two loads racing each other can never both end up running.
+            stopPrevious: (stageSignal, generation) => this.stopOthers(lifecycle, { modelId, generation, gpuId: gpu.gpu_id }, stageSignal),
+            // Pre-launch check, phase 2 (finding 1): the memory line alone, re-probed fresh once
+            // stopPrevious (above) has actually freed the card — never the snapshot `facts` took before
+            // eviction, which is why this is a lifecycle hook and not just more code in this function.
+            beforeCreate: () => this.checkMemoryBeforeCreate(gpu.gpu_id, descriptor, resolved, memory),
+            ...(opts.timeoutSecs !== undefined ? { timeoutMs: opts.timeoutSecs * 1000 } : {}),
+            ...(signal !== undefined ? { signal } : {}),
+            ...(substituted !== undefined ? { gpuSubstituted: substituted } : {}),
+        });
+        this.sessionCapabilities.set(modelId, {
+            generation: session.generation ?? '',
+            capabilities: tensorrtLlmAdapter.capabilities({ settings, family }),
+            limits: { contextLength: settings.context_length, maxOutputTokens: settings.max_output_tokens },
+        });
+        return session;
+    }
+    /**
+     * Throws `MANAGED_STOP_UNCONFIRMED` when Docker will not confirm the stop: the card stays reserved
+     * and the caller is told, rather than handed a success that is not one.
+     */
+    async unload(modelId) {
+        // Read before the stop: an id this provider never had answers `was_loaded: false` (spec
+        // `tensorrt-llm-runtime`), so a client's wrong id never reads as a stopped model (G-app-4).
+        const wasLoaded = this.residentModels().includes(modelId);
+        await this.current?.unload(modelId);
+        this.sessionCapabilities.delete(modelId);
+        return { success: true, was_loaded: wasLoaded };
+    }
+    /**
+     * Every model holding a card through this provider — loading, ready, stopping, or stopped without
+     * Docker's confirmation: what a removal of the engine must unload first (task 2.6), through core's
+     * own unload so each model's cross-process claim is released with it (final review M-1).
+     */
+    residentModels() {
+        return [...new Set((this.current?.reservations() ?? []).map((r) => r.model_id))];
+    }
+    /**
+     * Refuses every load with `MANAGED_OPERATION_CONFLICT` until the returned release is called (final
+     * review M-1): a removal of the engine holds loads off for as long as it runs, so no load creates
+     * a container on an installation being removed. Holds nest; each release counts once.
+     */
+    holdOffLoads() {
+        this.loadHolds += 1;
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            this.loadHolds -= 1;
+        };
+    }
+    /**
+     * Refuses loads of this one model with `MANAGED_OPERATION_CONFLICT` until the returned release is
+     * called (task 2.24): a deletion holds them off from before it stops the model until its files are
+     * gone, so no load mounts a folder being removed. Other models load as usual. Holds nest.
+     */
+    holdOffModel(modelId) {
+        this.modelHolds.set(modelId, (this.modelHolds.get(modelId) ?? 0) + 1);
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            const left = (this.modelHolds.get(modelId) ?? 1) - 1;
+            if (left > 0)
+                this.modelHolds.set(modelId, left);
+            else
+                this.modelHolds.delete(modelId);
+        };
+    }
+    /** Never: the context is fixed when the container starts (design D9, spec "без авто-роста"). */
+    autoIncreaseCtx(_modelId) {
+        return Promise.resolve({ ok: false, reason: 'unsupported' });
+    }
+    recreateSession(modelId) {
+        return Promise.reject(new AtomicCoreError('INVALID_ARGUMENT', 'A tensorrt-llm session is not recreated in place; unload the model and load it again.', modelId));
+    }
+    async shutdown() {
+        this.closed = true;
+        await this.current?.shutdown();
+        this.sessionCapabilities.clear();
+    }
+    routePolicy(modelId) {
+        const session = this.findSession(modelId);
+        if (session === undefined)
+            return undefined;
+        const known = this.sessionCapabilities.get(modelId);
+        // A session with no record of what it can do is treated as able to do nothing optional.
+        if (known === undefined || known.generation !== session.generation)
+            return tensorrtLlmRoutePolicy(NONE);
+        return tensorrtLlmRoutePolicy(known.capabilities, known.limits);
+    }
+    /** Answers rather than throws, like every provider's capabilities: all false while nothing resolves. */
+    async capabilities(modelId) {
+        const base = {
+            modelId,
+            mmprojExists: false,
+            isEmbedding: false,
+            isDecision: false,
+            audio: false,
+            gemmaMtp: false,
+            dflash: false,
+            dflashDrafts: [],
+            ...NONE,
+            architecture: null,
+        };
+        try {
+            const [ready, model] = await Promise.all([this.deps.readyInstallation(), this.deps.model(modelId)]);
+            const settings = tensorrtLlmSettings({});
+            return {
+                ...base,
+                ...tensorrtLlmAdapter.capabilities({ settings, family: familyOf(ready, model) }),
+                architecture: model.architecture,
+            };
+        }
+        catch {
+            return base;
+        }
+    }
+    async logs(modelId) {
+        const lifecycle = this.current;
+        const session = lifecycle?.findSession(modelId);
+        if (lifecycle && session) {
+            return {
+                model_id: modelId,
+                source: 'session',
+                generation: session.generation ?? '',
+                log_tail: (await lifecycle.logs(modelId)) ?? '',
+            };
+        }
+        const attempt = lifecycle?.lastAttempt(modelId);
+        if (attempt === undefined)
+            return { model_id: modelId, source: null, log_tail: '' };
+        return {
+            model_id: modelId,
+            source: 'last-attempt',
+            generation: attempt.generation,
+            log_tail: attempt.log_tail,
+            error: attempt.error,
+            at: attempt.at,
+        };
+    }
+    assertOpen() {
+        if (this.closed) {
+            throw new AtomicCoreError('CORE_NOT_RUNNING', 'The tensorrt-llm provider is shutting down.');
+        }
+    }
+    assertNotHeldOff(modelId) {
+        if (this.loadHolds > 0) {
+            throw new AtomicCoreError('MANAGED_OPERATION_CONFLICT', 'The TensorRT-LLM engine is being removed; load the model once the removal has finished.', modelId);
+        }
+        if (this.modelHolds.has(modelId)) {
+            throw new AtomicCoreError('MANAGED_OPERATION_CONFLICT', 'The model is being deleted.', modelId);
+        }
+    }
+    /**
+     * The card each container holds, for core's residency rule: every model past its claim — loading,
+     * ready, stopping, or stopped without Docker's confirmation, which still holds the card.
+     */
+    gpuOccupancy() {
+        return (this.current?.reservations() ?? [])
+            .filter((r) => r.state !== 'loading' || this.claimed.has(r.generation))
+            .map((r) => ({
+            model_id: r.model_id,
+            cards: [r.gpu_uuid],
+            auxiliary: false,
+            state: r.state,
+            ...(r.state === 'stop-unconfirmed' && r.container_id !== null
+                ? {
+                    remedy: `Loading again retries the stop; if Docker keeps failing, restart Docker or remove ` +
+                        `container ${r.container_id} (docker rm -f ${r.container_id}).`,
+                }
+                : {}),
+        }));
+    }
+    /**
+     * The `stopping-previous` stage. With core's residency: its claim on `gpuId`, which stops every other
+     * `tensorrt-llm` model (one session at a time) and every other engine on that card, each with a
+     * confirmed exit, and refuses with `GPU_BUSY` while one will not stop. Without it: every other
+     * `tensorrt-llm` model, loading or loaded, stopped with confirmation. Either way the load holds its
+     * card from then on — with residency, from the moment core grants the claim, inside core's turn.
+     */
+    async stopOthers(lifecycle, load, signal) {
+        // Generations whose reservation is gone are forgotten here, never while answering a read.
+        const live = new Set(lifecycle.reservations().map((r) => r.generation));
+        for (const generation of this.claimed)
+            if (!live.has(generation))
+                this.claimed.delete(generation);
+        const hold = () => {
+            this.claimed.add(load.generation);
+        };
+        if (this.deps.claimGpu) {
+            const claim = {
+                model_id: load.modelId,
+                cards: [load.gpuId],
+                auxiliary: false,
+                soleSessionOfProvider: true,
+            };
+            await this.deps.claimGpu(claim, signal, hold);
+        }
+        else {
+            const others = new Set(lifecycle.reservations().map((r) => r.model_id));
+            others.delete(load.modelId);
+            for (const other of others)
+                await this.unload(other);
+        }
+        hold();
+    }
+    /**
+     * The lifecycle's `beforeCreate` hook (task 2.16w round 1, finding 1 (Critical)): the pre-launch
+     * check's memory line, re-probed fresh right before the container is actually created — after
+     * `stopPrevious` has run, so a model switch on a single-GPU host sees the card the previous
+     * session just freed, never a snapshot `load()` took before eviction. `MANAGED_PREREQUISITE_
+     * BLOCKED` when the chosen card is no longer on the host at all (the same code a missing card gets
+     * earlier in `load()`); `MODEL_INCOMPATIBLE` when it is still there but does not have room.
+     */
+    async checkMemoryBeforeCreate(gpuId, descriptor, resolved, memory) {
+        const facts = await this.deps.hostFacts();
+        if (!facts.gpus.some((gpu) => gpu.gpu_id === gpuId)) {
+            throw new AtomicCoreError('MANAGED_PREREQUISITE_BLOCKED', 'The selected GPU disappeared before the container could start.', gpuId);
+        }
+        const verdict = checkModelMemory(resolved, descriptor, facts.gpus, facts.memory, memory);
+        if (!verdict.verdict.ok) {
+            const { code, message, details } = verdict.verdict.error;
+            throw new AtomicCoreError(code, message, details);
+        }
+    }
+}
+//# sourceMappingURL=runtime.js.map