llm-runtime-dock 0.1.0 → 0.1.1

package/README.md

@@ -222,6 +222,7 @@ field.
 server:
   host: 127.0.0.1
   port: 8787
+  idle_unload: 60m # unload after an hour of quiet; 0 to never
 
 runtimes:
   mtplx:
@@ -291,6 +292,13 @@ Clients send the logical id and never see the backend model:
 
 ### Fields you will actually set
 
+On the gateway itself:
+
+| field           | meaning                                                            |
+| --------------- | ------------------------------------------------------------------ |
+| `host` / `port` | where `lrd` listens. Defaults to `127.0.0.1:8787`                  |
+| `idle_unload`   | unload the loaded model after this long with nothing to do (below) |
+
 On a runtime:
 
 | field                        | meaning                                                                      |
@@ -335,7 +343,9 @@ Some arguments belong to the gateway and are rejected rather than silently
 merged: `--host`, `--port`, `--model`, served-id flags like `--identifier`,
 `--api-key`, and idle-unload flags such as LM Studio's `--ttl` — an idle
 auto-unload would drop the model behind the gateway's back and leave its view of
-the world wrong. The check covers `extra_args` too, and the error names the
+the world wrong. That is about _who owns the timer_, not about the idea: the
+gateway runs one itself, in front of its own bookkeeping, and you set it with
+`idle_unload` (below). The check covers `extra_args` too, and the error names the
 field to use instead. The full table, with the reasoning per flag, is in
 [§12](docs/05-configuration.md#configuration).
 
@@ -356,6 +366,51 @@ releasing foreign mtplx server on :8001 to free the resident slot
 
 The reasoning is in [§8 of the specification](docs/03-lifecycle.md#lifecycle).
 
+### Unloading when you stop using it
+
+`lrd serve` is a long-lived process, and until something asks for a different
+model nothing frees the one it is holding. Leave the gateway running after a
+morning's work and that 27B is still in memory at midnight.
+
+So it unloads by itself after an hour of quiet:
+
+```yaml
+server:
+  idle_unload: 60m # 0 never unloads
+```
+
+Write it as `60m`, `1h`, `90s`, `3600000ms`, or a bare number of milliseconds.
+`lrd serve --idle-unload 90s` overrides it for one run, and `lrd serve` prints
+the window it is using on startup:
+
+```text
+idle:     1h then unload
+```
+
+The next request loads the model again exactly as the first one did — the cost
+is one reload after an hour of not working, which is the trade the default is
+picked for. Turn it off with `0` if you would rather keep the model warm
+indefinitely.
+
+Two things it will not do:
+
+- **it never unloads a `keep_resident` model.** That flag means "for as long as
+  the gateway runs", and an idle spell is not the gateway stopping;
+- **it will not stop a server it did not start.** If `lrd` attached to an MTPLX
+  or custom server you launched yourself, stopping it is the only way to free
+  that memory — and doing that because `lrd` went quiet is not its call. It says
+  so in the log and leaves it alone. On LM Studio, oMLX and Ollama the question
+  never arises: unloading one model leaves the server, and everyone else on it,
+  untouched.
+
+When it has unloaded something, `lrd status` says so rather than just showing an
+empty slot:
+
+```text
+resident: none
+released: coding-quality (idle, stop_server)
+```
+
 ### Keeping one model always loaded
 
 Sometimes one model should never leave memory — a small one a coding agent
@@ -419,8 +474,8 @@ kept:      summariser (mtplx, ready, 0 active)
 serving:   summariser
 ```
 
-Its lifetime is the gateway's. Stopping `lrd serve` releases everything loaded,
-kept entries included — nothing would be left to free the memory otherwise, and
+Its lifetime is the gateway's — the idle unload above does not touch it either.
+Stopping `lrd serve` releases everything loaded, kept entries included — nothing would be left to free the memory otherwise, and
 a model outliving the process that loaded it is exactly the leak this gateway
 exists to prevent.
 

package/dist/index.js

@@ -11308,6 +11308,50 @@ var applyAgent = async (options) => {
   };
 };
 
+// packages/core/dist/config/duration.js
+var UNIT_MS = {
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5
+};
+var SPELLING = "3600000, 3600000ms, 3600s, 60m or 1h; 0 disables";
+var parseDuration = (value, field) => {
+  if (typeof value === "number") {
+    if (!Number.isInteger(value) || value < 0) {
+      throw cliError("CONFIG_INVALID", `${field} must be a whole number of milliseconds or more`, {
+        details: { field, value: String(value) },
+        hint: `accepted: ${SPELLING}`
+      });
+    }
+    return value;
+  }
+  if (typeof value !== "string") {
+    throw cliError("CONFIG_INVALID", `${field} must be a duration`, {
+      details: { field, type: typeof value },
+      hint: `accepted: ${SPELLING}`
+    });
+  }
+  const match = value.trim().match(/^(\d+)\s*(ms|s|m|h)?$/i);
+  if (!match) {
+    throw cliError("CONFIG_INVALID", `${field} is not a duration: "${value}"`, {
+      details: { field, value },
+      hint: `accepted: ${SPELLING}`
+    });
+  }
+  return Number(match[1]) * UNIT_MS[(match[2] ?? "ms").toLowerCase()];
+};
+var formatDuration = (ms) => {
+  if (ms <= 0)
+    return "off";
+  for (const unit of ["h", "m", "s"]) {
+    const size = UNIT_MS[unit];
+    if (ms % size === 0)
+      return `${ms / size}${unit}`;
+  }
+  return `${ms}ms`;
+};
+
 // packages/core/dist/config/load.js
 var import_yaml = __toESM(require_dist(), 1);
 import { readFileSync as readFileSync2 } from "node:fs";
@@ -16474,7 +16518,25 @@ var modelEntrySchema = object({
 }).strict();
 var serverSchema = object({
   host: string2().min(1).default("127.0.0.1"),
-  port: number2().int().min(1).max(65535).default(8787)
+  port: number2().int().min(1).max(65535).default(8787),
+  /**
+   * Release the rotating occupant after this long with nothing to do (§29).
+   * Defaults to an hour; `0` switches it off.
+   *
+   * Shape only here: a duration may be written `60m`, `1h`, `90s`, `3600000ms`
+   * or as a bare number of milliseconds, and `parseDuration` in ./duration.ts
+   * is what resolves it — in `buildConfig`, so the error names the YAML key.
+   *
+   * The first key in this block that is not a bind setting. It sits here
+   * rather than on a model because it is a property of this gateway process,
+   * not of any one entry.
+   */
+  idle_unload: union([number2(), string2()], {
+    // zod's own text for a failed union is a bare "Invalid input", which
+    // says nothing at all for a field whose whole point is that it accepts
+    // several spellings.
+    error: "expected a duration such as 60m, 1h, 90s or a number of milliseconds"
+  }).optional()
 }).strict();
 var agentsSchema = object({
   claude: object({
@@ -16497,6 +16559,7 @@ var rawConfigSchema = object({
 
 // packages/core/dist/config/load.js
 var DEFAULT_HOST = "127.0.0.1";
+var DEFAULT_IDLE_UNLOAD_MS = 36e5;
 var loadConfig = (registry2, options = {}) => {
   const location = resolveConfigLocation(options);
   const contents = options.contents ?? readConfigFile(location);
@@ -16632,7 +16695,12 @@ var buildConfig = (raw, location, registry2) => {
   }
   checkKeptResidency(models, runtimes, runtimeAdapters);
   checkAgentRoles(raw.agents, models);
-  return { location, server: raw.server, runtimes, models, agents: raw.agents, raw };
+  const server = {
+    host: raw.server.host,
+    port: raw.server.port,
+    idleUnloadMs: raw.server.idle_unload === void 0 ? DEFAULT_IDLE_UNLOAD_MS : parseDuration(raw.server.idle_unload, "server.idle_unload")
+  };
+  return { location, server, runtimes, models, agents: raw.agents, raw };
 };
 var checkKeptResidency = (models, runtimes, adapters) => {
   for (const instance of models.values()) {
@@ -17965,11 +18033,13 @@ var listLogicalModels = (config2) => {
 // packages/core/dist/scheduler.js
 var DEFAULT_READY_TIMEOUT_MS = 3e5;
 var DEFAULT_DRAIN_TIMEOUT_MS = 6e5;
+var DEFAULT_IDLE_UNLOAD_MS2 = 36e5;
 var createScheduler = (options) => {
   const registry2 = options.registry;
   const logger = options.logger ?? nullLogger;
   const readyTimeoutMs = options.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS;
   const drainTimeoutMs = options.drainTimeoutMs ?? DEFAULT_DRAIN_TIMEOUT_MS;
+  const idleUnloadMs = options.idleUnloadMs ?? DEFAULT_IDLE_UNLOAD_MS2;
   let resident = null;
   const kept = /* @__PURE__ */ new Map();
   let serving = null;
@@ -17978,6 +18048,9 @@ var createScheduler = (options) => {
   let pumping = false;
   let switching = null;
   let lastRelease = null;
+  let idleTimer;
+  let idleSweep;
+  let shuttingDown = false;
   let drainWaiters = [];
   const describe3 = (slot) => ({
     modelId: slot.instance.id,
@@ -18006,6 +18079,7 @@ var createScheduler = (options) => {
   };
   const keepLoadedFor = (instance) => [...kept.values()].filter((slot) => slot.instance.id !== instance.id && slot.instance.runtimeId === instance.runtimeId).map((slot) => slot.adapter.servedModelId(slot.instance));
   const acquire = (instance, options2 = {}) => {
+    clearIdle();
     return new Promise((resolve2, reject) => {
       const waiter = {
         instance,
@@ -18061,6 +18135,9 @@ var createScheduler = (options) => {
     });
   };
   const shutdown = async () => {
+    shuttingDown = true;
+    clearIdle();
+    await idleSweep;
     for (const waiter of waiters.splice(0)) {
       waiter.settled = true;
       pending -= 1;
@@ -18070,7 +18147,7 @@ var createScheduler = (options) => {
       if (!slot)
         continue;
       try {
-        await releaseSlot(slot);
+        await releaseSlot(slot, "shutdown");
       } catch (error2) {
         logger.error("failed to release the resident slot during shutdown", {
           event: "slot.release_failed",
@@ -18082,6 +18159,7 @@ var createScheduler = (options) => {
     kept.clear();
     resident = null;
     serving = null;
+    shuttingDown = false;
   };
   const pump = async () => {
     if (pumping)
@@ -18114,6 +18192,7 @@ var createScheduler = (options) => {
       pumping = false;
       if (waiters.length > 0)
         void pump();
+      armIdle();
     }
   };
   const settle = (waiter, action) => {
@@ -18168,7 +18247,7 @@ var createScheduler = (options) => {
       if (existing)
         await discard(existing);
       if (!instance.keepResident && resident && resident.instance.id !== instance.id) {
-        await releaseRotating(resident);
+        await releaseRotating(resident, "switch");
         resident = null;
       } else if (instance.keepResident && resident) {
         logger.info("leaving the current occupant loaded for a kept entry", {
@@ -18185,7 +18264,8 @@ var createScheduler = (options) => {
         state: "starting",
         ownership: "unknown",
         leases: 0,
-        since: Date.now()
+        since: Date.now(),
+        idleSkipped: false
       };
       const keepLoaded = keepLoadedFor(instance);
       if (instance.keepResident)
@@ -18286,14 +18366,14 @@ var createScheduler = (options) => {
       slot.state = wasFailed ? "failed" : "ready";
     }
   };
-  const releaseRotating = async (slot) => {
+  const releaseRotating = async (slot, reason) => {
     const wasFailed = slot.state === "failed";
     slot.state = "stopping";
     if (wasFailed) {
       const health = await slot.adapter.health(slot.instance).catch(() => ({ state: "unreachable" }));
       if (health.state === "unreachable") {
         try {
-          await releaseSlot(slot);
+          await releaseSlot(slot, reason);
         } catch (error2) {
           logger.warn("ignoring release failure for a runtime that is already gone", {
             event: "slot.release_after_crash",
@@ -18301,14 +18381,14 @@ var createScheduler = (options) => {
             adapter: slot.adapter.id,
             error: error2.message
           });
-          lastRelease = { modelId: slot.instance.id, via: slot.adapter.modelRelease };
+          lastRelease = { modelId: slot.instance.id, via: slot.adapter.modelRelease, reason };
         }
         if (serving === slot)
           serving = null;
         return;
       }
     }
-    await releaseSlot(slot);
+    await releaseSlot(slot, reason);
     if (serving === slot)
       serving = null;
   };
@@ -18318,7 +18398,7 @@ var createScheduler = (options) => {
       resident = null;
     if (serving === slot)
       serving = null;
-    await releaseRotating(slot).catch((error2) => {
+    await releaseRotating(slot, "switch").catch((error2) => {
       logger.warn("could not release a runtime before rebuilding it", {
         event: "slot.release_failed",
         runtime: slot.instance.id,
@@ -18327,7 +18407,7 @@ var createScheduler = (options) => {
       });
     });
   };
-  const releaseSlot = async (slot) => {
+  const releaseSlot = async (slot, reason) => {
     const log = logger.child({
       runtime: slot.instance.id,
       adapter: slot.adapter.id,
@@ -18344,13 +18424,84 @@ var createScheduler = (options) => {
       throw wrapReleaseError(error2, slot);
     }
     slot.state = "stopped";
-    lastRelease = { modelId: slot.instance.id, via: slot.adapter.modelRelease };
+    lastRelease = { modelId: slot.instance.id, via: slot.adapter.modelRelease, reason };
     log.info("resident slot freed", {
       event: "slot.released",
       via: slot.adapter.modelRelease,
+      reason,
       durationMs: Date.now() - startedAt
     });
   };
+  const idleReleasable = (slot) => slot.adapter.modelRelease === "unload_model" || slot.ownership === "spawned";
+  const clearIdle = () => {
+    if (idleTimer === void 0)
+      return;
+    clearTimeout(idleTimer);
+    idleTimer = void 0;
+  };
+  const armIdle = () => {
+    clearIdle();
+    if (idleUnloadMs <= 0 || shuttingDown)
+      return;
+    if (pumping || pending > 0 || waiters.length > 0)
+      return;
+    if (!resident || resident.idleSkipped || resident.leases > 0)
+      return;
+    for (const slot of kept.values())
+      if (slot.leases > 0)
+        return;
+    idleTimer = setTimeout(() => {
+      idleSweep = sweepIdle().finally(() => {
+        idleSweep = void 0;
+      });
+    }, idleUnloadMs);
+    idleTimer.unref();
+  };
+  const sweepIdle = async () => {
+    idleTimer = void 0;
+    if (pumping || waiters.length > 0 || shuttingDown)
+      return;
+    const slot = resident;
+    if (!slot)
+      return;
+    pumping = true;
+    try {
+      if (slot.leases > 0)
+        return;
+      if (!idleReleasable(slot)) {
+        slot.idleSkipped = true;
+        logger.info(`leaving the foreign ${slot.adapter.id} server on :${slot.instance.port ?? "?"} loaded: only a switch may stop a server the gateway did not start`, {
+          event: "slot.idle_skipped",
+          runtime: slot.instance.id,
+          adapter: slot.adapter.id,
+          ownership: slot.ownership
+        });
+        return;
+      }
+      logger.info("releasing the resident slot after an idle period", {
+        event: "slot.idle_release",
+        runtime: slot.instance.id,
+        adapter: slot.adapter.id,
+        idleMs: idleUnloadMs
+      });
+      await releaseRotating(slot, "idle");
+      if (resident === slot)
+        resident = null;
+    } catch (error2) {
+      logger.warn("idle release failed; leaving the runtime loaded", {
+        event: "slot.idle_release_failed",
+        runtime: slot.instance.id,
+        adapter: slot.adapter.id,
+        error: error2.message
+      });
+    } finally {
+      pumping = false;
+      if (waiters.length > 0)
+        void pump();
+      else
+        armIdle();
+    }
+  };
   const waitForDrain = async (slot) => {
     if (slot.leases <= 0)
       return;
@@ -18404,7 +18555,8 @@ var createDockService = (options) => {
     registry: registry2,
     logger,
     readyTimeoutMs: options.readyTimeoutMs,
-    drainTimeoutMs: options.drainTimeoutMs
+    drainTimeoutMs: options.drainTimeoutMs,
+    ...options.idleUnloadMs !== void 0 ? { idleUnloadMs: options.idleUnloadMs } : {}
   });
   const resolve2 = (clientModelId) => resolveModel(config2, clientModelId);
   const status = () => ({
@@ -21865,10 +22017,12 @@ var runServe = async (context, options = {}) => {
     logger: context.logger,
     ...debugDir ? { dir: debugDir } : {}
   }) : null;
+  const idleUnloadMs = options.idleUnload === void 0 ? config2.server.idleUnloadMs : parseDuration(options.idleUnload, "--idle-unload");
   const service = createDockService({
     config: config2,
     registry: context.adapters,
     logger: context.logger,
+    idleUnloadMs,
     ...tap ? { tap } : {}
   });
   const gateway = await startGateway({
@@ -21880,13 +22034,14 @@ var runServe = async (context, options = {}) => {
   });
   if (!context.options.json) {
     const theme = context.theme;
-    const labels = ["config", "endpoint", "models"];
+    const labels = ["config", "endpoint", "models", "idle"];
     const width = labelWidth(labels);
     const line = (label, value) => context.out(keyValue(label, value, width, { label: theme.label }));
     const models = servedModelIds(config2);
     line("config", theme.path(config2.location.path));
     line("endpoint", theme.url(gateway.url));
     line("models", models.length > 0 ? models.map((id) => theme.id(id)).join(", ") : theme.muted("(none)"));
+    line("idle", idleUnloadMs > 0 ? `${theme.id(formatDuration(idleUnloadMs))} ${theme.muted("then unload")}` : theme.muted("off"));
   }
   if (tap) {
     context.err(`${context.theme.label("debug capture:")} ${context.theme.path(tap.path)}`);
@@ -22129,6 +22284,7 @@ var printStatus = (context, endpoint, status) => {
     "state",
     "kept",
     "serving",
+    "released",
     "queue"
   ]);
   const line = (label, value, style) => context.out(keyValue(label, value, width, { label: theme.label, value: style }));
@@ -22142,6 +22298,9 @@ var printStatus = (context, endpoint, status) => {
     line("state", status.resident.state, theme.state);
   } else {
     line("resident", "none", theme.muted);
+    if (status.lastRelease) {
+      line("released", `${theme.id(status.lastRelease.modelId)} (${status.lastRelease.reason}, ${status.lastRelease.via})`);
+    }
   }
   if (status.kept.length > 0) {
     for (const entry of status.kept) {
@@ -22208,7 +22367,7 @@ var runCli = async (options) => {
     };
     return createCliContext({ ...options, version: version2 }, merged);
   };
-  shared(program2.command("serve")).description("start the gateway").option("--host <host>", "bind address (default: from configuration)").option("--port <port>", "bind port (default: from configuration)", (value) => Number(value)).option("--debug", "capture every proxied request and response to an NDJSON file").option("--debug-dir <path>", "where --debug writes (default: a temp subdirectory)").action(async (local, command) => {
+  shared(program2.command("serve")).description("start the gateway").option("--host <host>", "bind address (default: from configuration)").option("--port <port>", "bind port (default: from configuration)", (value) => Number(value)).option("--debug", "capture every proxied request and response to an NDJSON file").option("--debug-dir <path>", "where --debug writes (default: a temp subdirectory)").option("--idle-unload <duration>", "release the loaded model after this long with nothing to do, e.g. 60m or 0 for never").action(async (local, command) => {
     await runServe(contextFor(command), local);
   });
   shared(program2.command("status"), true).description("ask a running gateway what it is doing").action(async (_local, command) => {
@@ -23157,10 +23316,22 @@ var createMtplxAdapter = (options = {}) => {
       return (parsed.models ?? []).filter((entry) => typeof entry.repo_id === "string").map((entry) => ({
         id: entry.repo_id,
         suggestedId: suggestLogicalId(entry.repo_id),
-        // MTPLX validates its own cache. A model it reports without a valid
-        // runtime contract cannot be served, so it is reported and skipped
-        // rather than written into a configuration that would fail later.
-        ...entry.validation?.ok === false ? { unusable: "MTPLX reports no valid runtime contract for this model" } : {}
+        // `unusable` means the runtime says it will not load this, and the
+        // only field here that says so is `has_config` — MTPLX reads it as
+        // `(dir / 'config.json').exists()`, i.e. the directory is not a model.
+        //
+        // Deliberately *not* `validation.ok`: that field is the MTP runtime
+        // contract, and this adapter used to read it as servability. It is
+        // not. MTPLX's own launch gate says so — "the gate asks one question,
+        // can this artifact execute; verification tier stays a label, it must
+        // never block loading" — and a pack with no contract degrades to
+        // target-only AR on its own (`native-ar-only-missing-mtp` flips
+        // `--generation-mode` to `ar` and loads). Skipping those hid two
+        // working models, so a missing contract is slower, never unusable.
+        //
+        // `=== false`, not `!entry.has_config`: an older `mtplx` that omits
+        // the field must not have its whole catalogue declared unusable.
+        ...entry.has_config === false ? { unusable: "MTPLX reports no config.json in this model pack" } : {}
       }));
     } catch {
       return [];
@@ -25092,13 +25263,17 @@ var createCodexIntegration = (options = {}) => {
     }
     const model = plan.roles.model;
     const providers = isRecord2(existing.model_providers) ? { ...existing.model_providers } : {};
+    const previous = isRecord2(providers[PROVIDER_ID]) ? providers[PROVIDER_ID] : {};
     const provider = {
+      ...previous,
       name: PROVIDER_ID,
       base_url: `${plan.gatewayBaseUrl}/v1`
     };
     const mapped = plan.models.find((entry) => entry.id === model);
     if (mapped?.apiKeyEnv) {
       provider.env_key = mapped.apiKeyEnv;
+    } else {
+      delete provider.env_key;
     }
     providers[PROVIDER_ID] = provider;
     const merged = { ...existing };
@@ -26544,6 +26719,7 @@ function applyEdits(text, edits) {
 // packages/agents/opencode/dist/index.js
 var PROVIDER_ID2 = "llm-runtime-dock";
 var PROVIDER_NAME = "LLM Runtime Dock";
+var ENV_REFERENCE = /^\{env:[^}]+\}$/;
 var createOpenCodeIntegration = (options = {}) => {
   const id = "opencode";
   const displayName = "OpenCode";
@@ -26559,49 +26735,54 @@ var createOpenCodeIntegration = (options = {}) => {
   const isInstalled = async () => {
     return existsSync6(configDir);
   };
+  const setPath = (content, path2, value) => {
+    let next = content;
+    const formatting = { formattingOptions: { insertSpaces: true, tabSize: 2 } };
+    for (const edit of modify(next, path2, value, formatting)) {
+      next = applyEdits(next, [edit]);
+    }
+    return next;
+  };
   const render = async (plan) => {
     const path2 = configPath();
     const source = plan.existing ?? "{}";
     const warnings = [];
     const errors = [];
-    parse5(source, errors, { allowTrailingComma: true });
+    const parsed = parse5(source, errors, { allowTrailingComma: true });
     if (errors.length > 0) {
       const first = errors[0];
       throw cliError("AGENT_CONFIG_UNREADABLE", `${path2} could not be parsed (${first ? printParseErrorCode(first.error) : "unknown error"} at offset ${first?.offset ?? 0})`, { details: { agent: id, path: path2 }, hint: "fix the file by hand; nothing was written" });
     }
+    const previous = providerBlock(parsed);
     const defaultModel = plan.roles.default;
-    const models = {};
-    for (const model of plan.models) {
-      const limit = {};
-      if (model.contextLimit !== void 0)
-        limit.context = model.contextLimit;
-      if (model.outputLimit !== void 0)
-        limit.output = model.outputLimit;
-      models[model.id] = {
-        name: model.name,
-        ...Object.keys(limit).length > 0 ? { limit } : {}
-      };
-    }
+    const base = ["provider", PROVIDER_ID2];
+    let content = source.trim() === "" ? "{}" : source;
+    content = setPath(content, [...base, "npm"], "@ai-sdk/openai-compatible");
+    content = setPath(content, [...base, "name"], PROVIDER_NAME);
+    content = setPath(content, [...base, "options", "baseURL"], `${plan.gatewayBaseUrl}/v1`);
     const secretModel = plan.models.find((model) => model.apiKeyEnv !== void 0);
-    const providerOptions = { baseURL: `${plan.gatewayBaseUrl}/v1` };
+    const existingKey = previousApiKey(previous);
     if (secretModel?.apiKeyEnv) {
-      providerOptions.apiKey = `{env:${secretModel.apiKeyEnv}}`;
+      content = setPath(content, [...base, "options", "apiKey"], `{env:${secretModel.apiKeyEnv}}`);
+    } else if (typeof existingKey === "string" && ENV_REFERENCE.test(existingKey)) {
+      content = setPath(content, [...base, "options", "apiKey"], void 0);
     }
-    const provider = {
-      npm: "@ai-sdk/openai-compatible",
-      name: PROVIDER_NAME,
-      options: providerOptions,
-      models
-    };
-    let content = source.trim() === "" ? "{}" : source;
-    const formatting = { formattingOptions: { insertSpaces: true, tabSize: 2 } };
-    for (const edit of modify(content, ["provider", PROVIDER_ID2], provider, formatting)) {
-      content = applyEdits(content, [edit]);
+    for (const model of plan.models) {
+      content = setPath(content, [...base, "models", model.id, "name"], model.name);
+      if (model.contextLimit !== void 0) {
+        content = setPath(content, [...base, "models", model.id, "limit", "context"], model.contextLimit);
+      }
+      if (model.outputLimit !== void 0) {
+        content = setPath(content, [...base, "models", model.id, "limit", "output"], model.outputLimit);
+      }
+    }
+    const served = new Set(plan.models.map((model) => model.id));
+    for (const stale of Object.keys(previousModels(previous))) {
+      if (!served.has(stale))
+        content = setPath(content, [...base, "models", stale], void 0);
     }
     if (defaultModel) {
-      for (const edit of modify(content, ["model"], `${PROVIDER_ID2}/${defaultModel}`, formatting)) {
-        content = applyEdits(content, [edit]);
-      }
+      content = setPath(content, ["model"], `${PROVIDER_ID2}/${defaultModel}`);
     }
     if (!content.endsWith("\n"))
       content += "\n";
@@ -26619,6 +26800,21 @@ var createOpenCodeIntegration = (options = {}) => {
     render
   };
 };
+var isRecord3 = (value) => {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+};
+var providerBlock = (parsed) => {
+  if (!isRecord3(parsed) || !isRecord3(parsed.provider))
+    return {};
+  const block = parsed.provider[PROVIDER_ID2];
+  return isRecord3(block) ? block : {};
+};
+var previousModels = (block) => {
+  return isRecord3(block.models) ? block.models : {};
+};
+var previousApiKey = (block) => {
+  return isRecord3(block.options) ? block.options.apiKey : void 0;
+};
 
 // src/index.ts
 var defaultAdapters = (logger) => {
@@ -26638,7 +26834,7 @@ var main = async (argv = process.argv) => {
     argv: stripArgSeparator(argv.slice(2)),
     adapters: defaultAdapters(),
     agents: defaultAgents(),
-    version: "0.1.0"
+    version: "0.1.1"
   });
   if (code !== 0) process.exit(code);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-runtime-dock",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Local OpenAI/Anthropic-compatible LLM gateway and runtime lifecycle manager",
   "license": "MIT",
   "author": "BartRuSec",
@@ -16,7 +16,6 @@
   "engines": {
     "node": ">=24.0.0"
   },
-  "packageManager": "pnpm@11.15.1",
   "bin": {
     "lrd": "./bin/lrd.mjs"
   },
@@ -44,11 +43,34 @@
     "ollama",
     "coding-agents"
   ],
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^24",
+    "esbuild": "^0.28.2",
+    "eslint": "^10.9.1",
+    "prettier": "^3.4.2",
+    "rimraf": "^6.0.1",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.18.1",
+    "vitest": "^4.1.11",
+    "@llm-runtime-dock/adapter-custom": "0.1.1",
+    "@llm-runtime-dock/adapter-lm-studio": "0.1.1",
+    "@llm-runtime-dock/adapter-omlx": "0.1.1",
+    "@llm-runtime-dock/adapter-ollama": "0.1.1",
+    "@llm-runtime-dock/agent-codex": "0.1.1",
+    "@llm-runtime-dock/agent-opencode": "0.1.1",
+    "@llm-runtime-dock/core": "0.1.1",
+    "@llm-runtime-dock/adapter-mtplx": "0.1.1",
+    "@llm-runtime-dock/cli": "0.1.1",
+    "@llm-runtime-dock/agent-claude": "0.1.1",
+    "@llm-runtime-dock/gateway": "0.1.1"
+  },
   "scripts": {
     "build": "node scripts/sync-version.mjs && pnpm -r run build && node scripts/bundle.mjs",
     "bundle": "node scripts/bundle.mjs",
     "version:sync": "node scripts/sync-version.mjs",
-    "prepack": "pnpm run build",
+    "version:bump": "node scripts/bump-version.mjs",
+    "release:github": "node scripts/release-github.mjs",
     "dev": "node scripts/dev.mjs",
     "clean": "pnpm -r run clean && rimraf dist",
     "typecheck": "node scripts/sync-version.mjs --check && pnpm -r run typecheck && tsc -p tsconfig.json",
@@ -60,27 +82,5 @@
     "format:check": "prettier --check .",
     "test:unit": "pnpm -r run test",
     "test:e2e": "vitest run"
-  },
-  "devDependencies": {
-    "@eslint/js": "^10.0.1",
-    "@llm-runtime-dock/adapter-custom": "workspace:*",
-    "@llm-runtime-dock/adapter-lm-studio": "workspace:*",
-    "@llm-runtime-dock/adapter-mtplx": "workspace:*",
-    "@llm-runtime-dock/adapter-omlx": "workspace:*",
-    "@llm-runtime-dock/adapter-ollama": "workspace:*",
-    "@llm-runtime-dock/agent-claude": "workspace:*",
-    "@llm-runtime-dock/agent-codex": "workspace:*",
-    "@llm-runtime-dock/agent-opencode": "workspace:*",
-    "@llm-runtime-dock/cli": "workspace:*",
-    "@llm-runtime-dock/core": "workspace:*",
-    "@llm-runtime-dock/gateway": "workspace:*",
-    "@types/node": "^24",
-    "esbuild": "^0.28.2",
-    "eslint": "^10.9.1",
-    "prettier": "^3.4.2",
-    "rimraf": "^6.0.1",
-    "typescript": "^6.0.3",
-    "typescript-eslint": "^8.18.1",
-    "vitest": "^4.1.11"
   }
-}
+}