@atomic-chat/core 0.5.1 → 0.13.6

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

@@ -0,0 +1,30 @@
+/**
+ * TensorRT-LLM as a managed engine (change `add-vllm-runtime`, design D3): its adapter, its settings,
+ * its memory rule and checkpoint quirks for the shared check, its route policy, and its descriptor in
+ * conf. Registered by core like any other managed engine.
+ */
+import { TENSORRT_LLM_DESCRIPTOR_SOURCE, TENSORRT_LLM_ENGINE_ID } from '../environment/index.js';
+import { tensorrtLlmAdapter } from './adapter.js';
+import { tensorrtLlmCheckEngine, tensorrtLlmLaunchPlan } from './compatibility.js';
+import { tensorrtLlmRoutePolicy } from './route-policy.js';
+import { tensorrtLlmSettings } from './settings.js';
+function memorySizing(settings) {
+    return {
+        contextLength: settings.context_length,
+        kvCacheFreeGpuMemoryFraction: settings.kv_cache_free_gpu_memory_fraction,
+        cudaGraphs: settings.cuda_graphs,
+    };
+}
+export const TENSORRT_LLM_ENGINE = {
+    engine_id: TENSORRT_LLM_ENGINE_ID,
+    provider: TENSORRT_LLM_ENGINE_ID,
+    label: 'TensorRT-LLM',
+    descriptor: TENSORRT_LLM_DESCRIPTOR_SOURCE,
+    adapter: tensorrtLlmAdapter,
+    settings: tensorrtLlmSettings,
+    check: (settings) => tensorrtLlmCheckEngine(memorySizing(settings)),
+    // Whether `auto` captures CUDA graphs, decided on the card as it stands right before the container.
+    launchPlan: (settings, checkpoint, gpu, host) => tensorrtLlmLaunchPlan(memorySizing(settings), checkpoint, gpu, host),
+    routePolicy: tensorrtLlmRoutePolicy,
+};
+//# sourceMappingURL=engine.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"engine.js","sourceRoot":"","sources":["../../../src/runtime/tensorrt-llm/engine.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,8BAA8B,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAA;AAEhG,OAAO,EAAE,kBAAkB,EAA4B,MAAM,cAAc,CAAA;AAC3E,OAAO,EAAE,sBAAsB,EAAE,qBAAqB,EAA2B,MAAM,oBAAoB,CAAA;AAC3G,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAA;AAC1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAA;AAEnD,SAAS,YAAY,CAAC,QAA6B;IACjD,OAAO;QACL,aAAa,EAAE,QAAQ,CAAC,cAAc;QACtC,4BAA4B,EAAE,QAAQ,CAAC,iCAAiC;QACxE,UAAU,EAAE,QAAQ,CAAC,WAAW;KACjC,CAAA;AACH,CAAC;AAED,MAAM,CAAC,MAAM,mBAAmB,GAA2C;IACzE,SAAS,EAAE,sBAAsB;IACjC,QAAQ,EAAE,sBAAsB;IAChC,KAAK,EAAE,cAAc;IACrB,UAAU,EAAE,8BAA8B;IAC1C,OAAO,EAAE,kBAAkB;IAC3B,QAAQ,EAAE,mBAAmB;IAC7B,KAAK,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,sBAAsB,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;IACnE,oGAAoG;IACpG,UAAU,EAAE,CAAC,QAAQ,EAAE,UAAU,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,CAC9C,qBAAqB,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,UAAU,EAAE,GAAG,EAAE,IAAI,CAAC;IACtE,WAAW,EAAE,sBAAsB;CACpC,CAAA"}

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

@@ -0,0 +1,8 @@
+import { type GuestMount, type WslDistributionTransport } from '../wsl/index.js';
+/** Sizing and removing model and cache folders; the Linux default walks the file system itself. */
+export interface ModelFileOps {
+    /** Bytes under each path; a path that is not there is 0. */
+    sizes(paths: string[]): Promise<Map<string, number>>;
+    remove(paths: string[]): Promise<void>;
+}
+export declare function guestModelFiles(transport: WslDistributionTransport, mount?: GuestMount): ModelFileOps;

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

@@ -0,0 +1,49 @@
+/**
+ * The files of `tensorrt-llm` models and engine caches on Windows (change `add-tensorrt-llm-windows`,
+ * task 2.8, design D5): they live in the WSL guest's ext4, and core sees them through
+ * `\\wsl.localhost`. Listing and reading a `model.yml` through that path is fine; sizing or deleting
+ * tens of gigabytes through it is not — thousands of 9p round trips for what `du` and `rm` do in the
+ * guest at once. So sizes and removals run as commands in the guest, as root, with the guest paths
+ * behind the UNC ones (`guestPathFor`, which refuses anything outside the distribution). One `du`
+ * call for every path counts a hard-linked file once, as the Linux walk does.
+ */
+import { AtomicCoreError } from '../../contracts/index.js';
+import { WSL_LOCALHOST_MOUNT } from '../wsl/index.js';
+const TIMEOUT_MS = 30 * 60_000;
+export function guestModelFiles(transport, mount = WSL_LOCALHOST_MOUNT) {
+    const toGuest = (paths) => paths.map((path) => mount.guestPath(transport.name, path));
+    return {
+        sizes: async (paths) => {
+            const sizes = new Map(paths.map((path) => [path, 0]));
+            if (paths.length === 0)
+                return sizes;
+            const guest = toGuest(paths);
+            const answer = await transport.exec(['du', '-s', '-b', '--', ...guest], {
+                user: 'root',
+                timeoutMs: TIMEOUT_MS,
+            });
+            // `du` exits 1 when one path is missing, and still prints every other.
+            for (const line of answer.stdout.split('\n')) {
+                const match = /^(\d+)\t(.+)$/.exec(line);
+                if (match === null)
+                    continue;
+                const index = guest.indexOf(match[2]);
+                if (index !== -1)
+                    sizes.set(paths[index], Number(match[1]));
+            }
+            return sizes;
+        },
+        remove: async (paths) => {
+            if (paths.length === 0)
+                return;
+            const answer = await transport.exec(['rm', '-rf', '--', ...toGuest(paths)], {
+                user: 'root',
+                timeoutMs: TIMEOUT_MS,
+            });
+            if (answer.code !== 0) {
+                throw new AtomicCoreError('IO_ERROR', 'The files could not be removed in the Atomic Chat distribution.', answer.stderr.trim());
+            }
+        },
+    };
+}
+//# sourceMappingURL=guest-files.js.map

package/dist/runtime/tensorrt-llm/guest-files.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"guest-files.js","sourceRoot":"","sources":["../../../src/runtime/tensorrt-llm/guest-files.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAC1D,OAAO,EAAE,mBAAmB,EAAkD,MAAM,iBAAiB,CAAA;AASrG,MAAM,UAAU,GAAG,EAAE,GAAG,MAAM,CAAA;AAE9B,MAAM,UAAU,eAAe,CAC7B,SAAmC,EACnC,QAAoB,mBAAmB;IAEvC,MAAM,OAAO,GAAG,CAAC,KAAe,EAAY,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAA;IACzG,OAAO;QACL,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;YACrB,MAAM,KAAK,GAAG,IAAI,GAAG,CAAiB,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;YACrE,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO,KAAK,CAAA;YACpC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAA;YAC5B,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,CAAC,EAAE;gBACtE,IAAI,EAAE,MAAM;gBACZ,SAAS,EAAE,UAAU;aACtB,CAAC,CAAA;YACF,uEAAuE;YACvE,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC7C,MAAM,KAAK,GAAG,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;gBACxC,IAAI,KAAK,KAAK,IAAI;oBAAE,SAAQ;gBAC5B,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAW,CAAC,CAAA;gBAC/C,IAAI,KAAK,KAAK,CAAC,CAAC;oBAAE,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAW,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;YACvE,CAAC;YACD,OAAO,KAAK,CAAA;QACd,CAAC;QACD,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;YACtB,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAM;YAC9B,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE;gBAC1E,IAAI,EAAE,MAAM;gBACZ,SAAS,EAAE,UAAU;aACtB,CAAC,CAAA;YACF,IAAI,MAAM,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;gBACtB,MAAM,IAAI,eAAe,CACvB,UAAU,EACV,iEAAiE,EACjE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CACrB,CAAA;YACH,CAAC;QACH,CAAC;KACF,CAAA;AACH,CAAC"}

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

@@ -0,0 +1,55 @@
+import type { GpuFacts } from '../../contracts/index.js';
+import type { DockerExec } from '../container/index.js';
+import type { HostExec } from '../environment/index.js';
+import type { HostMemory } from './compatibility.js';
+/** `linux-probe.ts`'s own `nvidia-smi` query: UUID, name, compute capability, memory, driver. */
+export declare const NVIDIA_SMI_GPU_QUERY: string[];
+export declare const PROC_MEMINFO_PATH = "/proc/meminfo";
+/** `/proc/meminfo`'s `MemAvailable` line, in bytes; `null` when the text has no such line, or it does not parse. */
+export declare function parseMemAvailableBytes(meminfo: string): number | null;
+/** `/proc/meminfo`'s `MemTotal` line, in bytes; `null` when the text has no such line, or it does not parse. */
+export declare function parseMemTotalBytes(meminfo: string): number | null;
+export interface ReadHostMemoryDeps {
+    /** `null` for ENOENT or any other read failure — `LinuxProbeDeps.readFile`'s own convention. */
+    readFile: (path: string) => Promise<string | null>;
+}
+/**
+ * `MemAvailable` and `MemTotal`, a unified-memory card's free memory and size (design D13): each `0`,
+ * never a guess, when `/proc/meminfo` cannot be read or that line does not parse. `0` is the safe
+ * direction here — unlike SELinux below, an unreadable `/proc/meminfo` only ever makes a
+ * unified-memory card under-report (its check fails short, it ranks last for the default card),
+ * never over-report, so this never needs to fail the whole probe the way an unanswered
+ * `docker info` does.
+ */
+export declare function readHostMemory(deps: ReadHostMemoryDeps): Promise<HostMemory>;
+export interface ProbeTensorrtLlmGpusDeps {
+    exec: HostExec;
+    /** `nvidia-smi` by name on a real host; the test host's own stand-in otherwise. */
+    nvidiaSmi: string;
+}
+/** Just the cards: the query and parser `probeTensorrtLlmHost` and the check route both share. */
+export declare function probeTensorrtLlmGpus(deps: ProbeTensorrtLlmGpusDeps): Promise<GpuFacts[]>;
+export interface TensorrtLlmHostFacts {
+    gpus: GpuFacts[];
+    selinux: boolean;
+    memory: HostMemory;
+}
+export interface ProbeTensorrtLlmHostDeps extends ProbeTensorrtLlmGpusDeps, ReadHostMemoryDeps {
+    docker: DockerExec;
+}
+/**
+ * A `docker info` that does not answer, or answers without a daemon behind it, refuses the load
+ * (findings-2.14-r1.md item 2): whether our mounts need the shared `:z` label is then unknown, and
+ * guessing "no SELinux" would start a container that cannot read its own weights on an enforcing host.
+ */
+export declare function probeTensorrtLlmHost(deps: ProbeTensorrtLlmHostDeps): Promise<TensorrtLlmHostFacts>;
+export interface ProbeTensorrtLlmGpusAndMemoryDeps extends ProbeTensorrtLlmGpusDeps, ReadHostMemoryDeps {
+}
+/**
+ * What `POST /models/tensorrt-llm/check` needs from the machine (task 2.16): the cards and
+ * the host's memory, never Docker (see the file banner).
+ */
+export declare function probeTensorrtLlmGpusAndMemory(deps: ProbeTensorrtLlmGpusAndMemoryDeps): Promise<{
+    gpus: GpuFacts[];
+    memory: HostMemory;
+}>;

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

@@ -0,0 +1,87 @@
+/**
+ * What a `tensorrt-llm` load asks the machine right before it starts a container (task 2.14), plus
+ * what the compatibility check (task 2.16) needs on its own: which NVIDIA cards there are —
+ * `nvidia-smi`, the same query and parser the host assessment uses, so a saved `gpu_id` names a card
+ * the same way everywhere (`GPU-<uuid>`) — `/proc/meminfo`'s `MemAvailable` and `MemTotal` (design
+ * D13: a unified-memory card's free memory and size, for `checkModelCompatibility` and for
+ * `selectLaunchGpu`'s ranking, design D12b), and, for a load only, whether Docker runs with
+ * SELinux, read from `docker info` over the system socket through the core's one executor (design
+ * D15: our mounts then carry `:z`). Everything here is asked fresh rather than cached: a card can
+ * disappear between two loads, and the spec wants that noticed ("Выбранная карта исчезла").
+ *
+ * `probeTensorrtLlmGpusAndMemory` (the check route, `check.ts`) deliberately never asks Docker
+ * anything: a compatibility question has to answer the same whether or not the engine is even
+ * installed yet, so unlike `probeTensorrtLlmHost` (the load path, which genuinely cannot start a
+ * container without knowing SELinux) it must never fail closed on `docker info`.
+ */
+import { AtomicCoreError } from '../../contracts/index.js';
+import { withSystemSocket } from '../container/index.js';
+import { parseDockerInfo, parseNvidiaSmi } from '../environment/index.js';
+/** `linux-probe.ts`'s own `nvidia-smi` query: UUID, name, compute capability, memory, driver. */
+export const NVIDIA_SMI_GPU_QUERY = [
+    '--query-gpu=uuid,name,compute_cap,memory.total,memory.free,driver_version',
+    '--format=csv,noheader,nounits',
+];
+export const PROC_MEMINFO_PATH = '/proc/meminfo';
+const MEM_AVAILABLE_LINE = /^MemAvailable:\s*(\d+)\s*kB\s*$/m;
+const MEM_TOTAL_LINE = /^MemTotal:\s*(\d+)\s*kB\s*$/m;
+function parseMeminfoLine(meminfo, line) {
+    const match = line.exec(meminfo);
+    if (match === null)
+        return null;
+    const kib = Number.parseInt(match[1], 10);
+    return Number.isFinite(kib) ? kib * 1024 : null;
+}
+/** `/proc/meminfo`'s `MemAvailable` line, in bytes; `null` when the text has no such line, or it does not parse. */
+export function parseMemAvailableBytes(meminfo) {
+    return parseMeminfoLine(meminfo, MEM_AVAILABLE_LINE);
+}
+/** `/proc/meminfo`'s `MemTotal` line, in bytes; `null` when the text has no such line, or it does not parse. */
+export function parseMemTotalBytes(meminfo) {
+    return parseMeminfoLine(meminfo, MEM_TOTAL_LINE);
+}
+/**
+ * `MemAvailable` and `MemTotal`, a unified-memory card's free memory and size (design D13): each `0`,
+ * never a guess, when `/proc/meminfo` cannot be read or that line does not parse. `0` is the safe
+ * direction here — unlike SELinux below, an unreadable `/proc/meminfo` only ever makes a
+ * unified-memory card under-report (its check fails short, it ranks last for the default card),
+ * never over-report, so this never needs to fail the whole probe the way an unanswered
+ * `docker info` does.
+ */
+export async function readHostMemory(deps) {
+    const text = await deps.readFile(PROC_MEMINFO_PATH);
+    if (text === null)
+        return { availableBytes: 0, totalBytes: 0 };
+    return { availableBytes: parseMemAvailableBytes(text) ?? 0, totalBytes: parseMemTotalBytes(text) ?? 0 };
+}
+/** Just the cards: the query and parser `probeTensorrtLlmHost` and the check route both share. */
+export async function probeTensorrtLlmGpus(deps) {
+    return parseNvidiaSmi(await deps.exec(deps.nvidiaSmi, NVIDIA_SMI_GPU_QUERY)).gpus;
+}
+/**
+ * A `docker info` that does not answer, or answers without a daemon behind it, refuses the load
+ * (findings-2.14-r1.md item 2): whether our mounts need the shared `:z` label is then unknown, and
+ * guessing "no SELinux" would start a container that cannot read its own weights on an enforcing host.
+ */
+export async function probeTensorrtLlmHost(deps) {
+    const [gpus, info, memory] = await Promise.all([
+        probeTensorrtLlmGpus(deps),
+        deps.docker(withSystemSocket(['info', '--format', '{{json .}}'])).catch(() => null),
+        readHostMemory(deps),
+    ]);
+    const docker = parseDockerInfo(info, null);
+    if (!docker.daemon_reachable) {
+        throw new AtomicCoreError('MANAGED_PREREQUISITE_BLOCKED', 'Docker did not answer `docker info`, so whether SELinux needs our mounts relabelled is unknown; ' +
+            'the model is not loaded. Check that the Docker daemon is running.', [info?.stderr, ...docker.server_errors].filter((line) => line !== undefined && line !== '').join('; '));
+    }
+    return { gpus, selinux: docker.selinux, memory };
+}
+/**
+ * What `POST /models/tensorrt-llm/check` needs from the machine (task 2.16): the cards and
+ * the host's memory, never Docker (see the file banner).
+ */
+export async function probeTensorrtLlmGpusAndMemory(deps) {
+    const [gpus, memory] = await Promise.all([probeTensorrtLlmGpus(deps), readHostMemory(deps)]);
+    return { gpus, memory };
+}
+//# sourceMappingURL=host-facts.js.map

package/dist/runtime/tensorrt-llm/host-facts.js.map

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

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

@@ -0,0 +1,30 @@
+/**
+ * The `tensorrt-llm` provider (openspec change `add-tensorrt-llm-linux`).
+ *
+ * `compatibility.ts` is TensorRT-LLM's memory rule and checkpoint quirks plugged into the shared
+ * check skeleton (`../managed-models/`, change `add-vllm-runtime`), behind
+ * `POST /atomic/v1/models/tensorrt-llm/check` (spec `tensorrt-llm-models`); the shared naming rule
+ * and the GPU-selection rule the load path reuses are re-exported from there. `adapter.ts` (task 2.13) is the `ManagedTextAdapter`
+ * the engine-neutral load lifecycle (`../managed-text/`) plugs into. Task 2.14 adds the provider
+ * itself: `runtime.ts` (the `LocalRuntime`), `settings.ts` (stored settings → adapter settings),
+ * `route-policy.ts` (what the public server must refuse or map for a session), `installation.ts`
+ * (the ready installation and its pinned descriptor), `host-facts.ts` (cards, SELinux and
+ * `MemAvailable`/`MemTotal`, per load) and `model-dir.ts` (the single-model lookup `runtime.ts`'s
+ * load path uses). Task 2.16 wires the pure check in: `registry.ts` (the full model listing scan),
+ * `check.ts` (the route handler behind `compatibility.ts`'s pure verdict) and `prelaunch.ts` (the
+ * file-and-compatibility re-check `runtime.ts`'s load path runs before a container is created).
+ * Task 2.24 adds `delete.ts`: a deleted model's engine caches and folder, with the bytes freed.
+ *
+ * Public API of this module is exported from this file only.
+ */
+export * from './compatibility.js';
+export * from '../managed-models/quant-format.js';
+export * from './adapter.js';
+export * from './kv-cache.js';
+export * from './settings.js';
+export * from './route-policy.js';
+export * from './installation.js';
+export * from './host-facts.js';
+export * from './check.js';
+export * from './prelaunch.js';
+export * from './engine.js';

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

@@ -0,0 +1,31 @@
+/**
+ * The `tensorrt-llm` provider (openspec change `add-tensorrt-llm-linux`).
+ *
+ * `compatibility.ts` is TensorRT-LLM's memory rule and checkpoint quirks plugged into the shared
+ * check skeleton (`../managed-models/`, change `add-vllm-runtime`), behind
+ * `POST /atomic/v1/models/tensorrt-llm/check` (spec `tensorrt-llm-models`); the shared naming rule
+ * and the GPU-selection rule the load path reuses are re-exported from there. `adapter.ts` (task 2.13) is the `ManagedTextAdapter`
+ * the engine-neutral load lifecycle (`../managed-text/`) plugs into. Task 2.14 adds the provider
+ * itself: `runtime.ts` (the `LocalRuntime`), `settings.ts` (stored settings → adapter settings),
+ * `route-policy.ts` (what the public server must refuse or map for a session), `installation.ts`
+ * (the ready installation and its pinned descriptor), `host-facts.ts` (cards, SELinux and
+ * `MemAvailable`/`MemTotal`, per load) and `model-dir.ts` (the single-model lookup `runtime.ts`'s
+ * load path uses). Task 2.16 wires the pure check in: `registry.ts` (the full model listing scan),
+ * `check.ts` (the route handler behind `compatibility.ts`'s pure verdict) and `prelaunch.ts` (the
+ * file-and-compatibility re-check `runtime.ts`'s load path runs before a container is created).
+ * Task 2.24 adds `delete.ts`: a deleted model's engine caches and folder, with the bytes freed.
+ *
+ * Public API of this module is exported from this file only.
+ */
+export * from './compatibility.js';
+export * from '../managed-models/quant-format.js';
+export * from './adapter.js';
+export * from './kv-cache.js';
+export * from './settings.js';
+export * from './route-policy.js';
+export * from './installation.js';
+export * from './host-facts.js';
+export * from './check.js';
+export * from './prelaunch.js';
+export * from './engine.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime/tensorrt-llm/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,cAAc,oBAAoB,CAAA;AAClC,cAAc,mCAAmC,CAAA;AACjD,cAAc,cAAc,CAAA;AAC5B,cAAc,eAAe,CAAA;AAC7B,cAAc,eAAe,CAAA;AAC7B,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA;AACjC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,YAAY,CAAA;AAC1B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,aAAa,CAAA"}

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

@@ -0,0 +1,23 @@
+import type { PlatformImage, RuntimeDescriptor, RuntimeInstallation } from '../../contracts/index.js';
+import type { InstallationStore, RuntimeDescriptorProvider } from '../environment/index.js';
+export type ContainerPlatform = 'linux/amd64' | 'linux/arm64';
+/** `process.arch` to the descriptor's image key; null for a CPU no image is published for. */
+export declare function containerPlatformFor(arch: string): ContainerPlatform | null;
+export interface ReadyInstallation {
+    installation: RuntimeInstallation;
+    descriptor: RuntimeDescriptor;
+    /** The descriptor's image for this host's platform, pinned by digest. */
+    image: PlatformImage;
+}
+export interface ResolveReadyInstallationDeps {
+    /** The setup operation's installation records (`InstallationStore`); a torn or foreign file is skipped there. */
+    installations: Pick<InstallationStore, 'list'>;
+    descriptors: Pick<RuntimeDescriptorProvider, 'forInstallation'>;
+    /** This host's container platform; null when the CPU has no published image. */
+    platform: ContainerPlatform | null;
+    /** The managed engine the load is for (change `add-vllm-runtime`); `tensorrt-llm` when omitted. */
+    engineId?: string;
+    /** That engine in messages; defaults to its known name, else its id. */
+    label?: string;
+}
+export declare function resolveReadyInstallation(deps: ResolveReadyInstallationDeps): Promise<ReadyInstallation>;

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

@@ -0,0 +1,53 @@
+/**
+ * Which TensorRT-LLM installation a load runs (spec `tensorrt-llm-runtime`, "Загрузка без готовой
+ * установки"; design D7): only a `ready` one, only with the descriptor it was pinned to
+ * (`active_descriptor_id`, read from the descriptor cache — never fetched, so a release published
+ * since cannot change what runs), and only with that descriptor's image for this host's CPU. Anything
+ * short of that refuses the load with `MANAGED_ADAPTER_UNAVAILABLE` before a container exists.
+ *
+ * The installations themselves are read by the setup operation's own store (`InstallationStore`,
+ * `../environment/installations.ts`): the records under the shared per-user root that both scopes
+ * read, so a setup finished by the app is `ready` for the CLI core too. There is one reader of that
+ * format; this file only decides which of its installations a load may run.
+ */
+import { AtomicCoreError } from '../../contracts/index.js';
+/** The engine a load needs an installation of when the caller names none (the descriptor's own `engine_id`). */
+const ENGINE_ID = 'tensorrt-llm';
+const LABELS = { 'tensorrt-llm': 'TensorRT-LLM' };
+/** `process.arch` to the descriptor's image key; null for a CPU no image is published for. */
+export function containerPlatformFor(arch) {
+    if (arch === 'x64')
+        return 'linux/amd64';
+    if (arch === 'arm64')
+        return 'linux/arm64';
+    return null;
+}
+function unavailable(message, details) {
+    return new AtomicCoreError('MANAGED_ADAPTER_UNAVAILABLE', message, details);
+}
+export async function resolveReadyInstallation(deps) {
+    const engineId = deps.engineId ?? ENGINE_ID;
+    const label = deps.label ?? LABELS[engineId] ?? engineId;
+    const ours = (await deps.installations.list())
+        .map((record) => record.installation)
+        .filter((i) => i.engine_id === engineId);
+    const ready = ours.find((i) => i.status === 'ready' && i.active_descriptor_id !== null);
+    if (ready === undefined) {
+        const status = ours.map((i) => `${i.installation_id}: ${i.status}`).join(', ');
+        throw unavailable(ours.length === 0
+            ? `The ${label} engine is not installed; set it up before loading a model.`
+            : `The ${label} engine is not ready; finish or repair its setup before loading a model.`, status === '' ? undefined : status);
+    }
+    const resolved = await deps.descriptors.forInstallation(ready.active_descriptor_id);
+    if (resolved.kind !== 'available')
+        throw resolved.error;
+    const { descriptor } = resolved;
+    if (descriptor.engine_id !== engineId) {
+        throw new AtomicCoreError('MANAGED_METADATA_INVALID', 'The installation is pinned to a descriptor of another engine.', `${descriptor.descriptor_id}: ${descriptor.engine_id}`);
+    }
+    if (deps.platform === null) {
+        throw unavailable(`${label} publishes no image for this CPU architecture.`);
+    }
+    return { installation: ready, descriptor, image: descriptor.image[deps.platform] };
+}
+//# sourceMappingURL=installation.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"installation.js","sourceRoot":"","sources":["../../../src/runtime/tensorrt-llm/installation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAI1D,gHAAgH;AAChH,MAAM,SAAS,GAAG,cAAc,CAAA;AAChC,MAAM,MAAM,GAA2B,EAAE,cAAc,EAAE,cAAc,EAAE,CAAA;AAIzE,8FAA8F;AAC9F,MAAM,UAAU,oBAAoB,CAAC,IAAY;IAC/C,IAAI,IAAI,KAAK,KAAK;QAAE,OAAO,aAAa,CAAA;IACxC,IAAI,IAAI,KAAK,OAAO;QAAE,OAAO,aAAa,CAAA;IAC1C,OAAO,IAAI,CAAA;AACb,CAAC;AAqBD,SAAS,WAAW,CAAC,OAAe,EAAE,OAAgB;IACpD,OAAO,IAAI,eAAe,CAAC,6BAA6B,EAAE,OAAO,EAAE,OAAO,CAAC,CAAA;AAC7E,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAC5C,IAAkC;IAElC,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,IAAI,SAAS,CAAA;IAC3C,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAA;IACxD,MAAM,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;SAC3C,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC;SACpC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,KAAK,QAAQ,CAAC,CAAA;IAC1C,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,OAAO,IAAI,CAAC,CAAC,oBAAoB,KAAK,IAAI,CAAC,CAAA;IACvF,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,eAAe,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QAC9E,MAAM,WAAW,CACf,IAAI,CAAC,MAAM,KAAK,CAAC;YACf,CAAC,CAAC,OAAO,KAAK,6DAA6D;YAC3E,CAAC,CAAC,OAAO,KAAK,0EAA0E,EAC1F,MAAM,KAAK,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CACnC,CAAA;IACH,CAAC;IACD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,KAAK,CAAC,oBAA8B,CAAC,CAAA;IAC7F,IAAI,QAAQ,CAAC,IAAI,KAAK,WAAW;QAAE,MAAM,QAAQ,CAAC,KAAK,CAAA;IACvD,MAAM,EAAE,UAAU,EAAE,GAAG,QAAQ,CAAA;IAC/B,IAAI,UAAU,CAAC,SAAS,KAAK,QAAQ,EAAE,CAAC;QACtC,MAAM,IAAI,eAAe,CACvB,0BAA0B,EAC1B,+DAA+D,EAC/D,GAAG,UAAU,CAAC,aAAa,KAAK,UAAU,CAAC,SAAS,EAAE,CACvD,CAAA;IACH,CAAC;IACD,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,EAAE,CAAC;QAC3B,MAAM,WAAW,CAAC,GAAG,KAAK,gDAAgD,CAAC,CAAA;IAC7E,CAAC;IACD,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAA;AACpF,CAAC"}

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

@@ -0,0 +1,41 @@
+/**
+ * The KV-cache numbers the launch (`adapter.ts`) and the memory check (`compatibility.ts`) must agree
+ * on, in one module both import: the pure policy never reaches into the adapter (and through it the
+ * managed-text lifecycle) for a constant.
+ */
+/** The one default KV-cache fraction: the launch passes it (`adapter.ts`'s `buildTensorrtLlmLaunch`, through the validated settings), the model check
+ *  and the pre-launch check size their reserve with it (`compatibility.ts`'s `kvCacheReserveBytes`,
+ *  through the same validated settings), and `src/settings/schema/tensorrt-llm.json` stores it
+ *  (pinned equal by `settings.test.ts`). Below `trtllm-serve`'s own 0.9 on purpose: at 0.9 an 8 GB
+ *  card ran out of memory on the engine's non-KV allocations after the KV cache took its share
+ *  (budget table `_no_capture_init_kv_cache: 3.50 / 0.35`); 0.85 failed too, 0.8 loaded (docs/decisions/2026-09-29-tensorrt-llm-kv-cache-fraction-0-8-and-oom-read-from-the-whole-log.md). */
+export declare const TENSORRT_LLM_DEFAULT_KV_CACHE_FREE_FRACTION = 0.8;
+/**
+ * How many full contexts the KV cache holds on a unified-memory card: one full-context request plus
+ * a concurrent one. A starting value, not a measurement (docs/decisions/2026-09-29-tensorrt-llm-
+ * unified-memory-kv-cache-bounded-by-tokens.md).
+ */
+export declare const TENSORRT_LLM_UNIFIED_KV_CONTEXTS = 2;
+/**
+ * Tokens in one KV-cache block: `KvCacheConfig.tokens_per_block`'s default in 1.3.0rc29, logged by
+ * both cache managers ("tokens per block=32", "KVCacheV2Scheduler: tokens_per_block=32"). The engine
+ * turns `kv_cache_config.max_tokens` into whole blocks, rounding down: 2096 tokens became 65 blocks,
+ * a 2080-token sequence for a 2096-token context, and the readiness check refused the load as out of
+ * memory on a card with 17 GiB free (RTX 5090 Laptop, 2026-10-09). Re-check with each engine image.
+ */
+export declare const TENSORRT_LLM_TOKENS_PER_BLOCK = 32;
+/** `tokens` rounded up to whole KV-cache blocks: what the engine keeps when asked for at least that many. */
+export declare function tensorrtLlmWholeBlockTokens(tokens: number): number;
+/**
+ * The `kv_cache_config.max_tokens` that holds `sequences` sequences at full context at once: each
+ * sequence takes whole blocks of its own, so the blocks are counted per sequence before multiplying
+ * (2 × 2096 tokens is 131 blocks, but two 2096-token sequences need 66 each).
+ */
+export declare function tensorrtLlmKvTokens(contextLength: number, sequences: number): number;
+/**
+ * The `kv_cache_config.max_tokens` a unified-memory launch writes, and the token count its memory
+ * check reserves KV for. On a unified-memory card (GB10/DGX Spark) "free GPU memory" is the system's
+ * free RAM, so `--kv_cache_free_gpu_memory_fraction` alone would hand most of the machine's memory to
+ * the KV cache whatever the context length; this bounds it to what the configured context needs.
+ */
+export declare function tensorrtLlmUnifiedKvMaxTokens(contextLength: number): number;

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

@@ -0,0 +1,48 @@
+/**
+ * The KV-cache numbers the launch (`adapter.ts`) and the memory check (`compatibility.ts`) must agree
+ * on, in one module both import: the pure policy never reaches into the adapter (and through it the
+ * managed-text lifecycle) for a constant.
+ */
+/** The one default KV-cache fraction: the launch passes it (`adapter.ts`'s `buildTensorrtLlmLaunch`, through the validated settings), the model check
+ *  and the pre-launch check size their reserve with it (`compatibility.ts`'s `kvCacheReserveBytes`,
+ *  through the same validated settings), and `src/settings/schema/tensorrt-llm.json` stores it
+ *  (pinned equal by `settings.test.ts`). Below `trtllm-serve`'s own 0.9 on purpose: at 0.9 an 8 GB
+ *  card ran out of memory on the engine's non-KV allocations after the KV cache took its share
+ *  (budget table `_no_capture_init_kv_cache: 3.50 / 0.35`); 0.85 failed too, 0.8 loaded (docs/decisions/2026-09-29-tensorrt-llm-kv-cache-fraction-0-8-and-oom-read-from-the-whole-log.md). */
+export const TENSORRT_LLM_DEFAULT_KV_CACHE_FREE_FRACTION = 0.8;
+/**
+ * How many full contexts the KV cache holds on a unified-memory card: one full-context request plus
+ * a concurrent one. A starting value, not a measurement (docs/decisions/2026-09-29-tensorrt-llm-
+ * unified-memory-kv-cache-bounded-by-tokens.md).
+ */
+export const TENSORRT_LLM_UNIFIED_KV_CONTEXTS = 2;
+/**
+ * Tokens in one KV-cache block: `KvCacheConfig.tokens_per_block`'s default in 1.3.0rc29, logged by
+ * both cache managers ("tokens per block=32", "KVCacheV2Scheduler: tokens_per_block=32"). The engine
+ * turns `kv_cache_config.max_tokens` into whole blocks, rounding down: 2096 tokens became 65 blocks,
+ * a 2080-token sequence for a 2096-token context, and the readiness check refused the load as out of
+ * memory on a card with 17 GiB free (RTX 5090 Laptop, 2026-10-09). Re-check with each engine image.
+ */
+export const TENSORRT_LLM_TOKENS_PER_BLOCK = 32;
+/** `tokens` rounded up to whole KV-cache blocks: what the engine keeps when asked for at least that many. */
+export function tensorrtLlmWholeBlockTokens(tokens) {
+    return Math.ceil(tokens / TENSORRT_LLM_TOKENS_PER_BLOCK) * TENSORRT_LLM_TOKENS_PER_BLOCK;
+}
+/**
+ * The `kv_cache_config.max_tokens` that holds `sequences` sequences at full context at once: each
+ * sequence takes whole blocks of its own, so the blocks are counted per sequence before multiplying
+ * (2 × 2096 tokens is 131 blocks, but two 2096-token sequences need 66 each).
+ */
+export function tensorrtLlmKvTokens(contextLength, sequences) {
+    return sequences * tensorrtLlmWholeBlockTokens(contextLength);
+}
+/**
+ * The `kv_cache_config.max_tokens` a unified-memory launch writes, and the token count its memory
+ * check reserves KV for. On a unified-memory card (GB10/DGX Spark) "free GPU memory" is the system's
+ * free RAM, so `--kv_cache_free_gpu_memory_fraction` alone would hand most of the machine's memory to
+ * the KV cache whatever the context length; this bounds it to what the configured context needs.
+ */
+export function tensorrtLlmUnifiedKvMaxTokens(contextLength) {
+    return tensorrtLlmKvTokens(contextLength, TENSORRT_LLM_UNIFIED_KV_CONTEXTS);
+}
+//# sourceMappingURL=kv-cache.js.map

package/dist/runtime/tensorrt-llm/kv-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kv-cache.js","sourceRoot":"","sources":["../../../src/runtime/tensorrt-llm/kv-cache.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;8LAK8L;AAC9L,MAAM,CAAC,MAAM,2CAA2C,GAAG,GAAG,CAAA;AAE9D;;;;GAIG;AACH,MAAM,CAAC,MAAM,gCAAgC,GAAG,CAAC,CAAA;AAEjD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,EAAE,CAAA;AAE/C,6GAA6G;AAC7G,MAAM,UAAU,2BAA2B,CAAC,MAAc;IACxD,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,6BAA6B,CAAC,GAAG,6BAA6B,CAAA;AAC1F,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,aAAqB,EAAE,SAAiB;IAC1E,OAAO,SAAS,GAAG,2BAA2B,CAAC,aAAa,CAAC,CAAA;AAC/D,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,6BAA6B,CAAC,aAAqB;IACjE,OAAO,mBAAmB,CAAC,aAAa,EAAE,gCAAgC,CAAC,CAAA;AAC7E,CAAC"}

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

@@ -0,0 +1,20 @@
+import type { TensorrtLlmModelLocation } from '../../contracts/index.js';
+import type { WindowsEnvironmentRecord } from '../environment/index.js';
+import { type GuestMount, type WslDistributionTransport } from '../wsl/index.js';
+/** Linux: `<data>/tensorrt-llm/models`, with the free space of the volume it is (or will be) on. */
+export declare function linuxModelLocation(root: string, freeBytes?: (path: string) => Promise<number | null>): Promise<TensorrtLlmModelLocation>;
+export interface WindowsModelLocationDeps {
+    records: {
+        read(): Promise<WindowsEnvironmentRecord | null>;
+    };
+    /** This scope's `scope_key` (`readOrCreateGuestScopeKey`). */
+    scopeKey: () => Promise<string>;
+    transport: (distribution: string) => WslDistributionTransport;
+    /** Free bytes on the Windows volume holding `path` (`WindowsHost.freeDiskBytes`). */
+    volumeFreeBytes: (path: string) => Promise<number | null>;
+    /** How core reaches the guest's files; `\\wsl.localhost` unless a test says otherwise. */
+    mount?: GuestMount;
+}
+/** The guest folder of this scope's `tensorrt-llm` models. */
+export declare function guestModelsRoot(scopeKey: string): string;
+export declare function windowsModelLocation(deps: WindowsModelLocationDeps): Promise<TensorrtLlmModelLocation>;

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

@@ -0,0 +1,48 @@
+/**
+ * Where `tensorrt-llm` models live, as clients must use it (change `add-tensorrt-llm-windows`, task
+ * 2.8, design D6; spec `tensorrt-llm-models` "Core сообщает расположение моделей"). One answer, from
+ * core, on every platform, so a client never derives the folder itself: on Linux the data folder's own
+ * `<data>/tensorrt-llm/models` as before; on Windows the scope's folder in Atomic Chat's WSL
+ * distribution, `\\wsl.localhost\<distribution>\var\lib\atomic-chat\scopes\<scope_key>\models\tensorrt-llm`,
+ * created (and handed to uid 1000) before a client writes into it. The free space on Windows is the
+ * smaller of the guest's own and the Windows volume's that holds the distribution's disk image: the
+ * guest's disk can grow only as far as that volume lets it. Before the distribution exists there is no
+ * such folder: `MANAGED_ADAPTER_UNAVAILABLE`, and no download starts.
+ */
+import { AtomicCoreError } from '../../contracts/index.js';
+import { freeBytesAtNearest, parseDfAvail } from '../environment/index.js';
+import { ensureGuestScope, guestScopeRoot, WSL_LOCALHOST_MOUNT, } from '../wsl/index.js';
+/** Linux: `<data>/tensorrt-llm/models`, with the free space of the volume it is (or will be) on. */
+export async function linuxModelLocation(root, freeBytes = freeBytesAtNearest) {
+    return { root, free_bytes: await freeBytes(root).catch(() => null) };
+}
+/** The guest folder of this scope's `tensorrt-llm` models. */
+export function guestModelsRoot(scopeKey) {
+    return `${guestScopeRoot(scopeKey)}/models/tensorrt-llm`;
+}
+export async function windowsModelLocation(deps) {
+    const record = await deps.records.read();
+    if (record === null) {
+        throw new AtomicCoreError('MANAGED_ADAPTER_UNAVAILABLE', 'TensorRT-LLM models live in Atomic Chat’s WSL distribution, which is not set up yet.');
+    }
+    const key = await deps.scopeKey();
+    const transport = deps.transport(record.distribution.name);
+    const guestRoot = guestModelsRoot(key);
+    // A distribution unregistered behind the app's back is no environment at all for a client.
+    await ensureGuestScope(transport, key).catch((error) => {
+        throw new AtomicCoreError('MANAGED_ADAPTER_UNAVAILABLE', 'Atomic Chat’s WSL distribution does not answer; set the environment up again.', error instanceof Error ? error.message : String(error));
+    });
+    const [guest, volume] = await Promise.all([
+        transport
+            .exec(['df', '--output=avail', '-B1', guestRoot], { user: 'root', timeoutMs: 120_000 })
+            .then(parseDfAvail)
+            .catch(() => null),
+        deps.volumeFreeBytes(record.distribution.path).catch(() => null),
+    ]);
+    const known = [guest, volume].filter((value) => value !== null);
+    return {
+        root: (deps.mount ?? WSL_LOCALHOST_MOUNT).hostPath(record.distribution.name, guestRoot),
+        free_bytes: known.length === 0 ? null : Math.min(...known),
+    };
+}
+//# sourceMappingURL=location.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"location.js","sourceRoot":"","sources":["../../../src/runtime/tensorrt-llm/location.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAE1D,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAE1E,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,mBAAmB,GAGpB,MAAM,iBAAiB,CAAA;AAExB,oGAAoG;AACpG,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,IAAY,EACZ,YAAsD,kBAAkB;IAExE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,EAAE,CAAA;AACtE,CAAC;AAaD,8DAA8D;AAC9D,MAAM,UAAU,eAAe,CAAC,QAAgB;IAC9C,OAAO,GAAG,cAAc,CAAC,QAAQ,CAAC,sBAAsB,CAAA;AAC1D,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,IAA8B;IAE9B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAA;IACxC,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QACpB,MAAM,IAAI,eAAe,CACvB,6BAA6B,EAC7B,sFAAsF,CACvF,CAAA;IACH,CAAC;IACD,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAA;IACjC,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAA;IAC1D,MAAM,SAAS,GAAG,eAAe,CAAC,GAAG,CAAC,CAAA;IACtC,2FAA2F;IAC3F,MAAM,gBAAgB,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE;QAC9D,MAAM,IAAI,eAAe,CACvB,6BAA6B,EAC7B,+EAA+E,EAC/E,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CACvD,CAAA;IACH,CAAC,CAAC,CAAA;IACF,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;QACxC,SAAS;aACN,IAAI,CAAC,CAAC,IAAI,EAAE,gBAAgB,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC;aACtF,IAAI,CAAC,YAAY,CAAC;aAClB,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC;QACpB,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC;KACjE,CAAC,CAAA;IACF,MAAM,KAAK,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAmB,EAAE,CAAC,KAAK,KAAK,IAAI,CAAC,CAAA;IAChF,OAAO;QACL,IAAI,EAAE,CAAC,IAAI,CAAC,KAAK,IAAI,mBAAmB,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,SAAS,CAAC;QACvF,UAAU,EAAE,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;KAC3D,CAAA;AACH,CAAC"}

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

@@ -0,0 +1,38 @@
+import type { CheckpointFile } from './compatibility.js';
+/** `model.yml`'s own fields, parsed and typed; nothing here is derived. */
+export interface TensorrtLlmModelYmlDocument {
+    /** `null` when `model.yml` does not carry one (tolerated: `readTensorrtLlmModel`'s own contract). */
+    repository: string | null;
+    revision: string | null;
+    architectures: string[];
+    quantization: string | null;
+    files: CheckpointFile[];
+}
+export interface TensorrtLlmModel {
+    id: string;
+    /** The checkpoint directory as core sees it; mounted read-only into the container. */
+    dir: string;
+    repository: string | null;
+    revision: string | null;
+    /** `architectures[0]`: the Hugging Face class name the descriptor's `model_families` is keyed by. */
+    architecture: string | null;
+    quantization: string | null;
+    /** The revision's file listing exactly as `model.yml` recorded it (the pre-launch check's input). */
+    files: CheckpointFile[];
+    /** Weight bytes of `files` (`weightBytes`), 0 when `model.yml` lists none. */
+    weightBytes: number;
+}
+/**
+ * `model.yml`'s codec (`parse` only — the app and the CLI write it, core never does, spec
+ * `tensorrt-llm-models`): `MANAGED_METADATA_INVALID` when `text` is not valid YAML or not a mapping.
+ * `repository`/`revision`/`architectures`/`quantization` tolerate absence or the wrong type by
+ * reading as `null`/`[]`, the same way `readTensorrtLlmModel`'s own tests already expect for a bare
+ * `model.yml` — a model missing optional metadata is still a model, not a broken one. `files` is the
+ * one field held to a stricter rule (task 2.16w round 1, finding 4): the array itself may be absent
+ * (`[]`), but once present every entry must be well-formed (`fileList`/`parseFileEntry`) —
+ * silently dropping a malformed entry would leave a shard unverified, a checkpoint's weight bytes
+ * under-counted, or an `hf_quant_config.json` entry quietly lost.
+ */
+export declare function parseTensorrtLlmModelYml(text: string, path: string): TensorrtLlmModelYmlDocument;
+/** `MODEL_NOT_FOUND` without a readable `model.yml`; `MANAGED_METADATA_INVALID` when it is not a mapping. */
+export declare function readTensorrtLlmModel(modelsDir: string, modelId: string): Promise<TensorrtLlmModel>;