@khanglvm/llm-router 2.6.0 → 2.6.1

package/src/runtime/handler/provider-call.js

@@ -135,21 +135,6 @@ function queueLargeRequestEvent(onLargeRequestLog, payload) {
   }
 }
 
-async function resolveRequestProviderUrl(provider, plan, candidate, runtimeFlags) {
-  if (provider?.type === "local-runtime" && typeof runtimeFlags?.resolveLocalRuntimeBaseUrl === "function") {
-    const dynamicBaseUrl = await runtimeFlags.resolveLocalRuntimeBaseUrl({
-      candidate,
-      targetFormat: plan.targetFormat,
-      requestKind: plan.requestKind
-    });
-    if (dynamicBaseUrl) {
-      return resolveProviderUrl({ ...provider, baseUrl: dynamicBaseUrl }, plan.targetFormat, plan.requestKind);
-    }
-  }
-
-  return resolveProviderUrl(provider, plan.targetFormat, plan.requestKind);
-}
-
 function maybeQueueLargeRequestLog({
   env,
   onLargeRequestLog,
@@ -1089,27 +1074,8 @@ export async function makeProviderCall({
   }
 
   const executeHttpProviderRequest = async (plan) => {
-    let providerUrl;
-    try {
-      providerUrl = await resolveRequestProviderUrl(provider, plan, candidate, runtimeFlags);
-    } catch (error) {
-      return jsonResponse({
-        type: "error",
-        error: {
-          type: "api_error",
-          message: error instanceof Error ? error.message : String(error)
-        }
-      }, 503);
-    }
-    if (!providerUrl) {
-      return jsonResponse({
-        type: "error",
-        error: {
-          type: "configuration_error",
-          message: `Provider ${provider.id} has invalid baseUrl.`
-        }
-      }, 500);
-    }
+    const providerUrl = resolveProviderUrl(provider, plan.targetFormat, plan.requestKind);
+    if (!providerUrl) return null;
     const headers = mergeCachingHeaders(
       buildProviderHeaders(provider, env, plan.targetFormat),
       requestHeaders,
@@ -1148,6 +1114,22 @@ export async function makeProviderCall({
     }
   };
 
+  if (!resolveProviderUrl(provider, activePlan.targetFormat, activePlan.requestKind)) {
+    return {
+      ok: false,
+      status: 500,
+      retryable: false,
+      errorKind: "configuration_error",
+      response: jsonResponse({
+        type: "error",
+        error: {
+          type: "configuration_error",
+          message: `Provider ${provider.id} has invalid baseUrl.`
+        }
+      }, 500)
+    };
+  }
+
   let response;
   try {
     response = await executeHttpProviderRequest(activePlan);

package/src/runtime/handler/runtime-policy.js

@@ -27,10 +27,7 @@ export function resolveRuntimeFlags(options = {}, env = {}) {
     workerRuntime,
     workerSafeMode,
     allowBestEffortStatefulRouting,
-    statefulRoutingEnabled: !workerSafeMode || allowBestEffortStatefulRouting,
-    ...(typeof options.resolveLocalRuntimeBaseUrl === "function"
-      ? { resolveLocalRuntimeBaseUrl: options.resolveLocalRuntimeBaseUrl }
-      : {})
+    statefulRoutingEnabled: !workerSafeMode || allowBestEffortStatefulRouting
   };
 }
 

package/src/runtime/local-models.js

@@ -20,34 +20,6 @@ function normalizePositiveNumber(value) {
   return Math.floor(parsed);
 }
 
-function normalizeRuntimeProfile(raw = {}) {
-  const source = isPlainObject(raw) ? raw : {};
-  const overrides = isPlainObject(source.overrides) ? { ...source.overrides } : {};
-  const extraArgs = Array.isArray(source.extraArgs)
-    ? source.extraArgs.map((value) => normalizeString(value)).filter(Boolean)
-    : [];
-
-  return {
-    mode: normalizeString(source.mode) === "custom" ? "custom" : "auto",
-    preset: normalizeString(source.preset) || "balanced",
-    overrides,
-    extraArgs,
-    lastKnownGood: isPlainObject(source.lastKnownGood) ? { ...source.lastKnownGood } : null,
-    lastFailure: isPlainObject(source.lastFailure) ? { ...source.lastFailure } : null
-  };
-}
-
-function normalizeRuntimeStatus(raw = {}) {
-  const source = isPlainObject(raw) ? raw : {};
-
-  return {
-    activeInstanceId: normalizeString(source.activeInstanceId),
-    lastFailure: isPlainObject(source.lastFailure) ? { ...source.lastFailure } : null,
-    lastStartedAt: normalizeString(source.lastStartedAt),
-    lastHealthyAt: normalizeString(source.lastHealthyAt)
-  };
-}
-
 function normalizeLocalModelLibraryEntry(key, entry) {
   if (!isPlainObject(entry)) return null;
 
@@ -104,14 +76,6 @@ function normalizeLocalModelVariantEntry(key, entry) {
     else delete normalized.availability;
   }
 
-  if (normalized.runtime === "llamacpp") {
-    normalized.runtimeProfile = normalizeRuntimeProfile(entry.runtimeProfile);
-    normalized.runtimeStatus = normalizeRuntimeStatus(entry.runtimeStatus);
-  } else {
-    delete normalized.runtimeProfile;
-    delete normalized.runtimeStatus;
-  }
-
   return normalized;
 }
 

package/src/runtime/quota-probe.js

@@ -0,0 +1,179 @@
+/**
+ * Pure logic for provider quota-probe snapshots, verdicts, and config normalization.
+ * Zero IO — all functions are deterministic and side-effect free.
+ */
+
+const VALID_CAP_KINDS = new Set(["dollars", "tokens", "requests"]);
+const VALID_COMBINATORS = new Set(["AND", "OR", "REPLACE"]);
+const VALID_ENFORCE_MODES = new Set(["gate", "observe"]);
+const VALID_PROBE_MODES = new Set(["http", "custom"]);
+const VALID_HTTP_METHODS = new Set(["GET", "POST"]);
+
+const HTTP_TIMEOUT_DEFAULT = 5000;
+const HTTP_TIMEOUT_CAP = 15000;
+const CUSTOM_TIMEOUT_DEFAULT = 2000;
+const CUSTOM_TIMEOUT_CAP = 10000;
+
+function isFiniteNonNeg(v) {
+  return typeof v === "number" && Number.isFinite(v) && v >= 0;
+}
+
+export function validateSnapshot(raw) {
+  if (!raw || typeof raw !== "object") {
+    return { valid: false, error: "snapshot must be an object" };
+  }
+  if (!VALID_CAP_KINDS.has(raw.capKind)) {
+    return { valid: false, error: `invalid capKind: ${raw.capKind}` };
+  }
+  for (const field of ["used", "limit", "remaining"]) {
+    if (field in raw && raw[field] !== undefined && raw[field] !== null) {
+      if (!isFiniteNonNeg(raw[field])) {
+        return { valid: false, error: `${field} must be a non-negative finite number` };
+      }
+    }
+  }
+  if (!raw.isUnlimited) {
+    const present = ["used", "limit", "remaining"].filter(
+      (f) => f in raw && isFiniteNonNeg(raw[f])
+    );
+    if (present.length < 2) {
+      return { valid: false, error: "at least two of {used, limit, remaining} required" };
+    }
+  }
+  return { valid: true, error: null };
+}
+
+export function deriveSnapshot(raw) {
+  const out = { ...raw };
+  const hasUsed = isFiniteNonNeg(out.used);
+  const hasLimit = isFiniteNonNeg(out.limit);
+  const hasRemaining = isFiniteNonNeg(out.remaining);
+
+  if (hasUsed && hasLimit && !hasRemaining) {
+    out.remaining = out.limit - out.used;
+  } else if (hasLimit && hasRemaining && !hasUsed) {
+    out.used = out.limit - out.remaining;
+  } else if (hasUsed && hasRemaining && !hasLimit) {
+    out.limit = out.used + out.remaining;
+  }
+  return out;
+}
+
+export function isExhausted(snapshot, safetyMargin) {
+  if (snapshot.isUnlimited) return false;
+  if (!isFiniteNonNeg(snapshot.remaining)) return false;
+
+  const dollarMargin = safetyMargin?.dollars ?? 0;
+  const percentMargin = safetyMargin?.percent ?? 0;
+  const limitBased = isFiniteNonNeg(snapshot.limit)
+    ? (snapshot.limit * percentMargin) / 100
+    : 0;
+  const effectiveMargin = Math.max(dollarMargin, limitBased);
+  return snapshot.remaining <= effectiveMargin;
+}
+
+export function resolveProbeVerdict(snapshot, probeConfig, _now) {
+  if (!snapshot || !probeConfig?.enabled) return null;
+  if (probeConfig.enforce !== "gate") return null;
+  if (snapshot.state === "unknown" || snapshot.state === "errored") return null;
+  if (snapshot.isUnlimited) return { available: true, reason: "unlimited" };
+
+  const derived = deriveSnapshot(snapshot);
+  const margin = probeConfig.safetyMargin ?? { dollars: 0, percent: 0 };
+  if (isExhausted(derived, margin)) {
+    return { available: false, reason: "quota exhausted" };
+  }
+  return { available: true, reason: "within budget" };
+}
+
+export function applyQuotaProbeGate({ combinator, probeAvailable, rateLimitEligible }) {
+  const probeOk = probeAvailable === null || probeAvailable === undefined ? true : probeAvailable;
+  const rlOk = !!rateLimitEligible;
+
+  switch (combinator) {
+    case "OR":
+      return probeOk || rlOk
+        ? { eligible: true, skipReason: null }
+        : { eligible: false, skipReason: "probe and rate-limit both unavailable" };
+    case "REPLACE":
+      return probeOk
+        ? { eligible: true, skipReason: null }
+        : { eligible: false, skipReason: "probe unavailable" };
+    case "AND":
+    default:
+      if (!probeOk && !rlOk) return { eligible: false, skipReason: "probe and rate-limit both unavailable" };
+      if (!probeOk) return { eligible: false, skipReason: "probe unavailable" };
+      if (!rlOk) return { eligible: false, skipReason: "rate-limit exceeded" };
+      return { eligible: true, skipReason: null };
+  }
+}
+
+function clampTimeout(value, defaultVal, cap) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return defaultVal;
+  return Math.min(n, cap);
+}
+
+function normalizeHttpBlock(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const method = VALID_HTTP_METHODS.has(raw.method) ? raw.method : "GET";
+  const url = typeof raw.url === "string" ? raw.url : "";
+  const headers = Array.isArray(raw.headers) ? raw.headers : [];
+  const body = raw.body !== undefined ? raw.body : undefined;
+  const timeoutMs = clampTimeout(raw.timeoutMs, HTTP_TIMEOUT_DEFAULT, HTTP_TIMEOUT_CAP);
+  const mapping = raw.mapping && typeof raw.mapping === "object" ? raw.mapping : {};
+  return { method, url, headers, body, timeoutMs, mapping };
+}
+
+function normalizeCustomBlock(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const source = typeof raw.source === "string" ? raw.source : "";
+  const timeoutMs = clampTimeout(raw.timeoutMs, CUSTOM_TIMEOUT_DEFAULT, CUSTOM_TIMEOUT_CAP);
+  return { source, timeoutMs };
+}
+
+function normalizeMargin(raw) {
+  if (!raw || typeof raw !== "object") return { dollars: 0, percent: 0 };
+  const dollars = isFiniteNonNeg(raw.dollars) ? raw.dollars : 0;
+  const percent = isFiniteNonNeg(raw.percent) ? raw.percent : 0;
+  return { dollars, percent };
+}
+
+function normalizeRefreshTriggers(raw) {
+  const defaults = { onUiOpen: false, onManual: true, onResetAt: false, onUpstreamError: null };
+  if (!raw || typeof raw !== "object") return defaults;
+  const out = {
+    onUiOpen: !!raw.onUiOpen,
+    onManual: true,
+    onResetAt: !!raw.onResetAt,
+    onUpstreamError: null
+  };
+  if (raw.onUpstreamError && typeof raw.onUpstreamError === "object") {
+    out.onUpstreamError = {
+      statusCodes: Array.isArray(raw.onUpstreamError.statusCodes)
+        ? raw.onUpstreamError.statusCodes.filter((c) => Number.isFinite(c))
+        : [],
+      bodyRegex: typeof raw.onUpstreamError.bodyRegex === "string"
+        ? raw.onUpstreamError.bodyRegex
+        : null
+    };
+  }
+  return out;
+}
+
+export function normalizeQuotaProbeConfig(raw) {
+  if (!raw || typeof raw !== "object" || raw.enabled !== true) return null;
+
+  const capKind = VALID_CAP_KINDS.has(raw.capKind) ? raw.capKind : null;
+  if (!capKind) return null;
+
+  const combinator = VALID_COMBINATORS.has(raw.combinator) ? raw.combinator : "AND";
+  const enforce = VALID_ENFORCE_MODES.has(raw.enforce) ? raw.enforce : "gate";
+  const mode = VALID_PROBE_MODES.has(raw.mode) ? raw.mode : "http";
+  const safetyMargin = normalizeMargin(raw.safetyMargin);
+  const http = normalizeHttpBlock(raw.http);
+  const custom = normalizeCustomBlock(raw.custom);
+  const refreshTriggers = normalizeRefreshTriggers(raw.refreshTriggers);
+
+  return { enabled: true, capKind, combinator, enforce, mode, safetyMargin, http, custom, refreshTriggers };
+}

package/src/node/llamacpp-managed-runtime.js

@@ -1,202 +0,0 @@
-export function createLlamacppManagedRuntimeRegistry(deps = {}) {
-  const instances = new Map();
-  const inFlightStarts = new Map();
-  let nextPort = 39391;
-  const MIN_PORT = 1;
-  const MAX_PORT = 65535;
-
-  function resolveSpawnRuntime(overrides = {}) {
-    if (typeof overrides.spawnRuntime === "function") return overrides.spawnRuntime;
-    if (typeof deps.spawnRuntime === "function") return deps.spawnRuntime;
-    return async ({ host = "127.0.0.1", port } = {}) => ({
-      pid: undefined,
-      host,
-      port,
-      baseUrl: `http://${host}:${port}/v1`
-    });
-  }
-
-  function resolveWaitForHealthy(overrides = {}) {
-    if (typeof overrides.waitForHealthy === "function") return overrides.waitForHealthy;
-    if (typeof deps.waitForHealthy === "function") return deps.waitForHealthy;
-    return async (instance) => ({ ...instance, healthy: true });
-  }
-
-  function resolveListListeningPids(overrides = {}) {
-    if (typeof overrides.listListeningPids === "function") return overrides.listListeningPids;
-    if (typeof deps.listListeningPids === "function") return deps.listListeningPids;
-    return async () => [];
-  }
-
-  function resolveStopProcessByPid(overrides = {}) {
-    if (typeof overrides.stopProcessByPid === "function") return overrides.stopProcessByPid;
-    if (typeof deps.stopProcessByPid === "function") return deps.stopProcessByPid;
-    return async () => {};
-  }
-
-  function isTrackedInstanceReusable(instance) {
-    if (instance?.healthy !== true) return false;
-    const child = instance?.child;
-    if (child) {
-      return child.exitCode === null && child.killed !== true;
-    }
-    return true;
-  }
-
-  function isChildAlive(child) {
-    if (!child) return true;
-    return child.exitCode === null && child.killed !== true;
-  }
-
-  function normalizeRuntimePort(value, fallback = null) {
-    const parsed = Number(value);
-    if (!Number.isInteger(parsed) || parsed < MIN_PORT || parsed > MAX_PORT) return fallback;
-    return parsed;
-  }
-
-  function buildCompatibilityKey(variantKey, profileHash) {
-    return `${String(variantKey || "")}::${String(profileHash || "")}`;
-  }
-
-  function buildReservedPorts() {
-    const reserved = new Set();
-    for (const instance of instances.values()) {
-      if (!isChildAlive(instance?.child)) continue;
-      const port = normalizeRuntimePort(instance?.port);
-      if (port !== null) reserved.add(port);
-    }
-    for (const start of inFlightStarts.values()) {
-      const port = normalizeRuntimePort(start?.reservedPort);
-      if (port !== null) reserved.add(port);
-    }
-    return reserved;
-  }
-
-  function pruneDeadInstances() {
-    for (const [instanceId, instance] of instances.entries()) {
-      if (!isChildAlive(instance?.child)) {
-        instances.delete(instanceId);
-      }
-    }
-  }
-
-  function allocatePort(preferredPort) {
-    const reservedPorts = buildReservedPorts();
-    const preferred = normalizeRuntimePort(preferredPort);
-    if (preferred !== null && !reservedPorts.has(preferred)) {
-      if (preferred >= nextPort) nextPort = preferred + 1;
-      return preferred;
-    }
-
-    let port = Math.max(39391, nextPort);
-    if (port > MAX_PORT) {
-      port = 39391;
-    }
-    const startPort = port;
-    while (reservedPorts.has(port)) {
-      port += 1;
-      if (port > MAX_PORT) {
-        port = 39391;
-      }
-      if (port === startPort) {
-        throw new Error("No available managed runtime port.");
-      }
-    }
-
-    nextPort = port + 1;
-    return port;
-  }
-
-  async function ensureRuntimeForVariant({ variantKey, profileHash, launchArgs, preferredPort } = {}, runtimeDeps = {}) {
-    const spawnRuntime = resolveSpawnRuntime(runtimeDeps);
-    const waitForHealthy = resolveWaitForHealthy(runtimeDeps);
-    const compatibilityKey = buildCompatibilityKey(variantKey, profileHash);
-    pruneDeadInstances();
-
-    for (const instance of instances.values()) {
-      if (
-        instance.profileHash === profileHash
-        && instance.variantKey === variantKey
-        && isTrackedInstanceReusable(instance)
-      ) {
-        return instance;
-      }
-    }
-
-    const inFlight = inFlightStarts.get(compatibilityKey);
-    if (inFlight?.promise) {
-      return inFlight.promise;
-    }
-
-    const port = allocatePort(preferredPort);
-    const startPromise = (async () => {
-      const spawned = await spawnRuntime({ variantKey, profileHash, launchArgs, port });
-      const healthy = await waitForHealthy(spawned);
-      const assignedPort = normalizeRuntimePort(healthy?.port, port);
-      if (!isChildAlive(healthy?.child)) {
-        throw new Error("Managed runtime exited before becoming healthy.");
-      }
-      const instance = {
-        instanceId: `${variantKey}:${profileHash}:${assignedPort}`,
-        owner: "llm-router",
-        variantKey,
-        profileHash,
-        healthy: true,
-        ...healthy,
-        port: assignedPort
-      };
-      instances.set(instance.instanceId, instance);
-      return instance;
-    })().finally(() => {
-      inFlightStarts.delete(compatibilityKey);
-    });
-
-    inFlightStarts.set(compatibilityKey, { promise: startPromise, reservedPort: port });
-    return startPromise;
-  }
-
-  async function reconcile(runtimeDeps = {}) {
-    const listListeningPids = resolveListListeningPids(runtimeDeps);
-    const stopProcessByPid = resolveStopProcessByPid(runtimeDeps);
-    for (const [instanceId, instance] of instances.entries()) {
-      const probe = await listListeningPids(instance.port).catch(() => null);
-      const livePids = Array.isArray(probe)
-        ? probe
-        : (probe && typeof probe === "object" && Array.isArray(probe.pids) ? probe.pids : null);
-      const probeFailed = Boolean(probe && typeof probe === "object" && probe.ok === false);
-      if (probeFailed || !Array.isArray(livePids)) continue;
-      if (livePids.includes(instance.pid)) continue;
-      if (instance.owner === "llm-router") {
-        await stopProcessByPid(instance.pid).catch(() => {});
-      }
-      instances.delete(instanceId);
-    }
-  }
-
-  async function waitForInFlightStarts() {
-    while (inFlightStarts.size > 0) {
-      const pending = [...inFlightStarts.values()]
-        .map((entry) => entry?.promise)
-        .filter(Boolean)
-        .map((promise) => promise.catch(() => null));
-      if (pending.length === 0) return;
-      await Promise.all(pending);
-    }
-  }
-
-  return {
-    ensureRuntimeForVariant,
-    reconcile,
-    waitForInFlightStarts,
-    trackInstance: async (instance) => {
-      instances.set(instance.instanceId, { ...instance });
-    },
-    untrackInstance: async (instanceId) => {
-      instances.delete(instanceId);
-    },
-    clear: async () => {
-      instances.clear();
-    },
-    snapshot: () => [...instances.values()]
-  };
-}

package/src/node/llamacpp-runtime-profile.js

@@ -1,133 +0,0 @@
-function isPlainObject(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-
-function normalizeString(value) {
-  return typeof value === "string" ? value.trim() : "";
-}
-
-function toGiB(bytes) {
-  return Math.round((Number(bytes || 0) / (1024 ** 3)) * 10) / 10;
-}
-
-function normalizePositiveInteger(value, fallback) {
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
-  return Math.floor(parsed);
-}
-
-const LLAMACPP_PRESET_TUNING = Object.freeze({
-  balanced: Object.freeze({
-    canonicalPreset: "balanced",
-    batchSize: 64,
-    ubatchSize: 16,
-    gpuLayers: { darwin: 99, other: 0 },
-    penaltyRatio: 0.10,
-    noContBatching: false
-  }),
-  "long-context": Object.freeze({
-    canonicalPreset: "long-context",
-    batchSize: 32,
-    ubatchSize: 8,
-    gpuLayers: { darwin: 80, other: 0 },
-    penaltyRatio: 0.16,
-    noContBatching: false
-  }),
-  "low-memory": Object.freeze({
-    canonicalPreset: "low-memory",
-    batchSize: 32,
-    ubatchSize: 8,
-    gpuLayers: { darwin: 0, other: 0 },
-    penaltyRatio: 0.04,
-    noContBatching: true
-  }),
-  "fast-response": Object.freeze({
-    canonicalPreset: "fast-response",
-    batchSize: 16,
-    ubatchSize: 8,
-    gpuLayers: { darwin: 40, other: 0 },
-    penaltyRatio: 0.07,
-    noContBatching: false
-  }),
-  "cpu-safe": Object.freeze({
-    canonicalPreset: "cpu-safe",
-    batchSize: 32,
-    ubatchSize: 8,
-    gpuLayers: { darwin: 0, other: 0 },
-    penaltyRatio: 0.04,
-    noContBatching: true
-  })
-});
-
-function resolveCanonicalPreset(requestedPreset) {
-  const normalizedPreset = normalizeString(requestedPreset).toLowerCase();
-  if (normalizedPreset === "throughput") return LLAMACPP_PRESET_TUNING["fast-response"];
-  if (normalizedPreset === "memory-safe") return LLAMACPP_PRESET_TUNING["low-memory"];
-  return LLAMACPP_PRESET_TUNING[normalizedPreset] || LLAMACPP_PRESET_TUNING.balanced;
-}
-
-export function estimateLlamacppRuntimeBytes({
-  sizeBytes = 0,
-  contextWindow = 0,
-  preset = "balanced"
-} = {}) {
-  const base = Number(sizeBytes || 0);
-  const contextBytes = Number(contextWindow || 0) * 163840;
-  const tuning = resolveCanonicalPreset(preset);
-  const presetPenalty = Math.floor(base * tuning.penaltyRatio);
-  return base + contextBytes + presetPenalty;
-}
-
-export function deriveLlamacppLaunchProfile({
-  variant,
-  baseModel,
-  system
-} = {}) {
-  const requestedPreset = normalizeString(variant?.preset)
-    || normalizeString(variant?.runtimeProfile?.preset)
-    || "balanced";
-  const failureCategory = normalizeString(
-    variant?.runtimeProfile?.lastFailure?.category || variant?.runtimeStatus?.lastFailure?.category
-  );
-  const tuning = resolveCanonicalPreset(failureCategory === "metal-oom" ? "cpu-safe" : requestedPreset);
-  const preset = tuning.canonicalPreset;
-  const contextWindow = normalizePositiveInteger(variant?.contextWindow, 2048);
-  const overrides = isPlainObject(variant?.runtimeProfile?.overrides) ? variant.runtimeProfile.overrides : {};
-  const extraArgs = Array.isArray(variant?.runtimeProfile?.extraArgs)
-    ? variant.runtimeProfile.extraArgs.map((value) => normalizeString(value)).filter(Boolean)
-    : [];
-  const gpuLayers = Number.isFinite(Number(overrides.gpuLayers))
-    ? Math.floor(Number(overrides.gpuLayers))
-    : (system?.platform === "darwin" ? tuning.gpuLayers.darwin : tuning.gpuLayers.other);
-  const batchSize = Number.isFinite(Number(overrides.batchSize))
-    ? Math.floor(Number(overrides.batchSize))
-    : tuning.batchSize;
-  const ubatchSize = Number.isFinite(Number(overrides.ubatchSize))
-    ? Math.floor(Number(overrides.ubatchSize))
-    : tuning.ubatchSize;
-  const estimatedRuntimeBytes = estimateLlamacppRuntimeBytes({
-    sizeBytes: baseModel?.metadata?.sizeBytes,
-    contextWindow,
-    preset
-  });
-  const args = [
-    "-m", normalizeString(baseModel?.path),
-    "-a", normalizeString(variant?.id),
-    "-c", String(contextWindow),
-    "-np", "1",
-    "-b", String(batchSize),
-    "-ub", String(ubatchSize),
-    "--cache-ram", "0",
-    "--no-warmup"
-  ];
-
-  if (tuning.noContBatching) args.push("--no-cont-batching");
-  args.push("-ngl", String(gpuLayers), ...extraArgs);
-
-  return {
-    preset,
-    args: args.filter(Boolean),
-    estimatedRuntimeBytes,
-    memoryLabel: `${toGiB(estimatedRuntimeBytes)} GB`
-  };
-}