metrillm-mcp 0.1.2 → 0.2.0

package/dist/index.js

@@ -100,8 +100,13 @@ function toBenchmarkFailureLabel(err) {
   return compact.length > maxLen ? `ERROR: ${compact.slice(0, maxLen - 1)}\u2026` : `ERROR: ${compact}`;
 }
 function stripThinkTags(text) {
-  const stripped = text.replace(/<think(?:ing)?[\s>][\s\S]*?<\/think(?:ing)?>/gi, "");
-  return stripped.trim();
+  const withoutThinking = text.replace(/<think(?:ing)?[\s>][\s\S]*?<\/think(?:ing)?>/gi, "");
+  const withoutTrailingWhitespace = withoutThinking.trimEnd();
+  const withoutTrailingControlTokens = withoutTrailingWhitespace.replace(
+    /(?:\s*(?:<\|(?:im_end|eot_id|end_of_text|eom_id|end)\|>|<\/s>))+$/gi,
+    ""
+  );
+  return withoutTrailingControlTokens.trim();
 }
 function hasThinkingContent(response, thinkingField) {
   if (thinkingField && thinkingField.trim().length > 0) return true;
@@ -182,18 +187,20 @@ function stripTypeAnnotations(code) {
     return code;
   } catch {
   }
-  try {
-    const mod = __require("module");
-    if (typeof mod.stripTypeScriptTypes === "function") {
-      const stripped = mod.stripTypeScriptTypes(code);
-      try {
-        new vm.Script(`${stripped}
+  if (process.env.METRILLM_ENABLE_EXPERIMENTAL_TS_STRIP === "1") {
+    try {
+      const mod = __require("module");
+      if (typeof mod.stripTypeScriptTypes === "function") {
+        const stripped = mod.stripTypeScriptTypes(code);
+        try {
+          new vm.Script(`${stripped}
 ;`);
-        return stripped;
-      } catch {
+          return stripped;
+        } catch {
+        }
       }
+    } catch {
     }
-  } catch {
   }
   let result = code;
   result = stripInterfaceDeclarations(result);
@@ -506,7 +513,7 @@ function extractCodeBlock(text, preferredFunctionName) {
 // ../src/core/ollama-client.ts
 var client = new Ollama();
 var DEFAULT_OLLAMA_HOST = "http://127.0.0.1:11434";
-var OLLAMA_INIT_TIMEOUT_MS = 15e3;
+var OLLAMA_INIT_TIMEOUT_MS = 12e4;
 var STREAM_STALL_TIMEOUT_MS = 3e4;
 function getOllamaBaseUrl() {
   const configured = process.env.OLLAMA_HOST?.trim();
@@ -541,7 +548,8 @@ async function listModels() {
     size: m.size,
     parameterSize: m.details?.parameter_size,
     quantization: m.details?.quantization_level,
-    family: m.details?.family
+    family: m.details?.family,
+    modelFormat: "gguf"
   }));
 }
 async function listRunningModels() {
@@ -578,6 +586,7 @@ async function generateStream(model, prompt, callbacks, options) {
   let fullResponse = "";
   let fullThinking = "";
   let result = null;
+  let firstChunkSeen = false;
   let stallTimer = null;
   const resetStallTimer = () => {
     if (stallTimer) clearTimeout(stallTimer);
@@ -589,6 +598,10 @@ async function generateStream(model, prompt, callbacks, options) {
     resetStallTimer();
     for await (const chunk of stream) {
       resetStallTimer();
+      if (!firstChunkSeen) {
+        firstChunkSeen = true;
+        callbacks?.onFirstChunk?.();
+      }
       const chunkAny = chunk;
       if (chunkAny.thinking) {
         fullThinking += String(chunkAny.thinking);
@@ -639,7 +652,706 @@ function abortOngoingRequests() {
   client.abort();
 }
 
+// ../src/core/lm-studio-client.ts
+import os from "os";
+import path from "path";
+import { promises as fs } from "fs";
+var DEFAULT_LM_STUDIO_BASE_URL = "http://127.0.0.1:1234";
+var LM_STUDIO_INIT_TIMEOUT_MS = 15e3;
+var LM_STUDIO_METADATA_TIMEOUT_MS = 2e3;
+var DEFAULT_STREAM_STALL_TIMEOUT_MS = 18e4;
+var DEFAULT_LM_STUDIO_HOME_DIR = path.join(os.homedir(), ".lmstudio");
+var DEFAULT_LM_STUDIO_MODELS_DIR = path.join(DEFAULT_LM_STUDIO_HOME_DIR, "models");
+var LM_STUDIO_HOME_DIR_ENV = "LM_STUDIO_HOME_DIR";
+var LM_STUDIO_MODELS_DIR_ENV = "LM_STUDIO_MODELS_DIR";
+var defaultKeepAlive2;
+var activeAbortControllers = /* @__PURE__ */ new Set();
+var directorySizeCache = /* @__PURE__ */ new Map();
+var modelDefinitionCache = /* @__PURE__ */ new Map();
+function buildThinkingConfig(think) {
+  if (think === void 0) return {};
+  const effort = think ? "high" : "low";
+  return {
+    include_reasoning: think,
+    reasoning_effort: effort,
+    reasoning: { effort }
+  };
+}
+function parseNonNegativeInt(value) {
+  if (!/^\d+$/.test(value)) return null;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isSafeInteger(parsed) || parsed < 0) return null;
+  return parsed;
+}
+function resolveStreamStallTimeoutMs(override) {
+  if (override !== void 0) {
+    if (!Number.isFinite(override) || override < 0) return DEFAULT_STREAM_STALL_TIMEOUT_MS;
+    return override === 0 ? void 0 : Math.trunc(override);
+  }
+  const configured = process.env.LM_STUDIO_STREAM_STALL_TIMEOUT_MS?.trim();
+  if (!configured) return DEFAULT_STREAM_STALL_TIMEOUT_MS;
+  const parsed = parseNonNegativeInt(configured);
+  if (parsed === null) return DEFAULT_STREAM_STALL_TIMEOUT_MS;
+  return parsed === 0 ? void 0 : parsed;
+}
+function getLMStudioBaseUrl() {
+  const configured = process.env.LM_STUDIO_BASE_URL?.trim();
+  if (!configured) return DEFAULT_LM_STUDIO_BASE_URL;
+  const candidate = /^https?:\/\//i.test(configured) ? configured : `http://${configured}`;
+  try {
+    return new URL(candidate).toString();
+  } catch {
+    return DEFAULT_LM_STUDIO_BASE_URL;
+  }
+}
+function getLMStudioHeaders() {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  const apiKey = process.env.LM_STUDIO_API_KEY?.trim();
+  if (apiKey) {
+    headers.Authorization = `Bearer ${apiKey}`;
+  }
+  return headers;
+}
+function extractUsage(payload) {
+  if (typeof payload !== "object" || payload === null) return void 0;
+  const usage = payload.usage;
+  if (!usage) return void 0;
+  return usage;
+}
+function extractChoice2(payload) {
+  if (typeof payload !== "object" || payload === null) return void 0;
+  const choices = payload.choices;
+  if (!choices || choices.length === 0) return void 0;
+  return choices[0];
+}
+function extractContent(choice) {
+  const content = choice?.delta?.content ?? choice?.message?.content;
+  return typeof content === "string" ? content : "";
+}
+function extractReasoning(choice) {
+  const reasoning = choice?.delta?.reasoning_content ?? choice?.delta?.reasoning ?? choice?.message?.reasoning_content ?? choice?.message?.reasoning;
+  return typeof reasoning === "string" ? reasoning : "";
+}
+function asNonEmptyString(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function stripOptionalQuotes(value) {
+  const trimmed = value.trim();
+  return trimmed.replace(/^["']|["']$/g, "").trim();
+}
+function normalizeToken(value) {
+  return (value ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+function tokenizeModelName(value) {
+  return value.toLowerCase().split(/[^a-z0-9]+/g).map((token) => token.trim()).filter((token) => token.length >= 3 && /[a-z]/.test(token));
+}
+function getLMStudioHomeDir() {
+  const fromEnv = process.env[LM_STUDIO_HOME_DIR_ENV]?.trim();
+  if (!fromEnv) return DEFAULT_LM_STUDIO_HOME_DIR;
+  if (fromEnv.startsWith("~")) {
+    return path.join(os.homedir(), fromEnv.slice(1));
+  }
+  return fromEnv;
+}
+async function pathIsDirectory(targetPath) {
+  try {
+    const stat = await fs.stat(targetPath);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function loadHubModelDefinition(modelId) {
+  if (modelDefinitionCache.has(modelId)) {
+    return modelDefinitionCache.get(modelId) ?? null;
+  }
+  const [publisher, modelName] = modelId.split("/", 2);
+  if (!publisher || !modelName) {
+    modelDefinitionCache.set(modelId, null);
+    return null;
+  }
+  const yamlPath = path.join(getLMStudioHomeDir(), "hub", "models", publisher, modelName, "model.yaml");
+  let content = "";
+  try {
+    content = await fs.readFile(yamlPath, "utf8");
+  } catch {
+    modelDefinitionCache.set(modelId, null);
+    return null;
+  }
+  const sourcePattern = /user:\s*([^\n#]+?)\s*(?:\r?\n)\s*repo:\s*([^\n#]+?)\s*(?:\r?\n|$)/g;
+  const sourceMap = /* @__PURE__ */ new Map();
+  let sourceMatch = null;
+  while ((sourceMatch = sourcePattern.exec(content)) !== null) {
+    const user = stripOptionalQuotes(sourceMatch[1] ?? "");
+    const repo = stripOptionalQuotes(sourceMatch[2] ?? "");
+    if (!user || !repo) continue;
+    sourceMap.set(`${user}/${repo}`, { user, repo });
+  }
+  const paramsPattern = /paramsStrings:\s*(?:\r?\n)\s*-\s*([^\n#]+)/;
+  const paramsMatch = paramsPattern.exec(content);
+  const parameterSize = paramsMatch?.[1] ? stripOptionalQuotes(paramsMatch[1]) : void 0;
+  const definition = {
+    parameterSize: parameterSize || void 0,
+    sources: Array.from(sourceMap.values())
+  };
+  modelDefinitionCache.set(modelId, definition);
+  return definition;
+}
+async function readDirectorySizeBytes(dirPath) {
+  const cached = directorySizeCache.get(dirPath);
+  if (cached !== void 0) return cached;
+  let total = 0;
+  const queue = [dirPath];
+  while (queue.length > 0) {
+    const current = queue.pop();
+    if (!current) continue;
+    let entries = [];
+    try {
+      entries = await fs.readdir(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.isSymbolicLink()) continue;
+      const fullPath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        queue.push(fullPath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      try {
+        const stat = await fs.stat(fullPath);
+        total += stat.size;
+      } catch {
+      }
+    }
+  }
+  directorySizeCache.set(dirPath, total);
+  return total;
+}
+function scoreModelSourceCandidate(source, modelId, apiModel) {
+  const repoToken = normalizeToken(source.repo);
+  let score = 0;
+  const quantToken = normalizeToken(apiModel?.quantization);
+  if (quantToken && repoToken.includes(quantToken)) score += 8;
+  const compatibilityToken = normalizeToken(apiModel?.compatibility_type);
+  if (compatibilityToken && repoToken.includes(compatibilityToken)) score += 4;
+  const [, shortModelName] = modelId.split("/", 2);
+  const modelToken = normalizeToken(shortModelName ?? modelId);
+  if (modelToken && repoToken.includes(modelToken)) score += 2;
+  return score;
+}
+async function resolveModelsRootDir() {
+  const fromEnv = process.env[LM_STUDIO_MODELS_DIR_ENV]?.trim();
+  if (fromEnv) {
+    if (fromEnv.startsWith("~")) {
+      return path.join(os.homedir(), fromEnv.slice(1));
+    }
+    return fromEnv;
+  }
+  const settingsCandidates = [
+    path.join(getLMStudioHomeDir(), "settings.json"),
+    path.join(os.homedir(), "Library", "Application Support", "LM Studio", "settings.json")
+  ];
+  for (const settingsPath of settingsCandidates) {
+    try {
+      const content = await fs.readFile(settingsPath, "utf8");
+      const parsed = JSON.parse(content);
+      const downloadsFolder = asNonEmptyString(parsed.downloadsFolder);
+      if (downloadsFolder) {
+        return downloadsFolder.startsWith("~") ? path.join(os.homedir(), downloadsFolder.slice(1)) : downloadsFolder;
+      }
+    } catch {
+    }
+  }
+  return DEFAULT_LM_STUDIO_MODELS_DIR;
+}
+async function listImmediateSubdirs(dirPath) {
+  let entries = [];
+  try {
+    entries = await fs.readdir(dirPath, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries.filter((entry) => entry.isDirectory() && !entry.isSymbolicLink()).map((entry) => path.join(dirPath, entry.name));
+}
+async function findPublisherDirs(rootDir, publisher) {
+  const normalizedPublisher = normalizeToken(publisher);
+  if (!normalizedPublisher) return [];
+  const dirs = await listImmediateSubdirs(rootDir);
+  return dirs.filter((dir) => normalizeToken(path.basename(dir)) === normalizedPublisher);
+}
+function scorePublisherModelCandidate(modelDirName, modelId, apiModel) {
+  const dirToken = normalizeToken(modelDirName);
+  if (!dirToken) return 0;
+  let score = 0;
+  const idToken = normalizeToken(modelId);
+  if (idToken && dirToken.includes(idToken)) score += 24;
+  const [, shortModelName] = modelId.split("/", 2);
+  const shortToken = normalizeToken(shortModelName ?? modelId);
+  if (shortToken && dirToken.includes(shortToken)) score += 16;
+  for (const token of tokenizeModelName(shortModelName ?? modelId)) {
+    if (dirToken.includes(token)) score += 3;
+  }
+  const quantToken = normalizeToken(apiModel?.quantization);
+  if (quantToken && dirToken.includes(quantToken)) score += 6;
+  const compatibilityToken = normalizeToken(apiModel?.compatibility_type);
+  if (compatibilityToken && dirToken.includes(compatibilityToken)) score += 4;
+  return score;
+}
+async function resolvePublisherModelMetadata(modelId, apiModel, modelsRootDir) {
+  const explicitPublisher = asNonEmptyString(apiModel?.publisher);
+  const [publisherFromId] = modelId.split("/", 1);
+  const publisher = explicitPublisher ?? publisherFromId;
+  if (!publisher) {
+    return { size: 0, parameterSize: inferParameterSizeFromModelId(modelId) };
+  }
+  const bundledModelsDir = path.join(getLMStudioHomeDir(), ".internal", "bundled-models");
+  const roots = Array.from(/* @__PURE__ */ new Set([modelsRootDir, bundledModelsDir]));
+  const candidates = [];
+  for (const root of roots) {
+    const publisherDirs = await findPublisherDirs(root, publisher);
+    for (const publisherDir of publisherDirs) {
+      const modelDirs = await listImmediateSubdirs(publisherDir);
+      if (modelDirs.length === 0) {
+        candidates.push({
+          fullPath: publisherDir,
+          score: scorePublisherModelCandidate(path.basename(publisherDir), modelId, apiModel)
+        });
+        continue;
+      }
+      for (const modelDir of modelDirs) {
+        candidates.push({
+          fullPath: modelDir,
+          score: scorePublisherModelCandidate(path.basename(modelDir), modelId, apiModel)
+        });
+      }
+    }
+  }
+  if (candidates.length === 0) {
+    return { size: 0, parameterSize: inferParameterSizeFromModelId(modelId) };
+  }
+  candidates.sort((a, b) => {
+    const scoreDiff = b.score - a.score;
+    if (scoreDiff !== 0) return scoreDiff;
+    return a.fullPath.localeCompare(b.fullPath);
+  });
+  let bestSize = 0;
+  for (const candidate of candidates) {
+    const size = await readDirectorySizeBytes(candidate.fullPath);
+    if (size > bestSize) bestSize = size;
+    if (size > 0 && candidate.score > 0) {
+      return { size, parameterSize: inferParameterSizeFromModelId(modelId) };
+    }
+  }
+  return { size: bestSize, parameterSize: inferParameterSizeFromModelId(modelId) };
+}
+async function resolveLocalModelMetadata(modelId, apiModel, modelsRootDir) {
+  const definition = await loadHubModelDefinition(modelId);
+  if (!definition) {
+    return resolvePublisherModelMetadata(modelId, apiModel, modelsRootDir);
+  }
+  const installedSources = [];
+  for (const source of definition.sources) {
+    const fullPath = path.join(modelsRootDir, source.user, source.repo);
+    if (await pathIsDirectory(fullPath)) {
+      installedSources.push({ ...source, fullPath });
+    }
+  }
+  if (installedSources.length === 0) {
+    const fallback2 = await resolvePublisherModelMetadata(modelId, apiModel, modelsRootDir);
+    if (fallback2.size > 0) {
+      return {
+        size: fallback2.size,
+        parameterSize: definition.parameterSize ?? fallback2.parameterSize
+      };
+    }
+    return { size: 0, parameterSize: definition.parameterSize };
+  }
+  installedSources.sort((a, b) => {
+    const diff = scoreModelSourceCandidate(b, modelId, apiModel) - scoreModelSourceCandidate(a, modelId, apiModel);
+    if (diff !== 0) return diff;
+    return a.repo.localeCompare(b.repo);
+  });
+  let bestSize = 0;
+  for (const source of installedSources) {
+    const size = await readDirectorySizeBytes(source.fullPath);
+    if (size > bestSize) bestSize = size;
+    if (size > 0) {
+      return { size, parameterSize: definition.parameterSize };
+    }
+  }
+  if (bestSize > 0) {
+    return { size: bestSize, parameterSize: definition.parameterSize };
+  }
+  const fallback = await resolvePublisherModelMetadata(modelId, apiModel, modelsRootDir);
+  if (fallback.size > 0) {
+    return {
+      size: fallback.size,
+      parameterSize: definition.parameterSize ?? fallback.parameterSize
+    };
+  }
+  return { size: 0, parameterSize: definition.parameterSize ?? fallback.parameterSize };
+}
+function parseSizeBytes(model) {
+  if (!model) return 0;
+  const candidates = [
+    model.size_bytes,
+    model.model_size_bytes,
+    model.file_size_bytes,
+    model.bytes,
+    model.size
+  ];
+  for (const candidate of candidates) {
+    if (typeof candidate !== "number" || !Number.isFinite(candidate)) continue;
+    if (candidate > 0) return Math.trunc(candidate);
+  }
+  return 0;
+}
+function normalizeModelNumber(value) {
+  return value.replace(/\.0+$/, "");
+}
+function inferParameterSizeFromModelId(modelId) {
+  const id = modelId.toLowerCase();
+  const mixtureMatch = id.match(/\b(\d+(?:\.\d+)?)\s*[x*]\s*(\d+(?:\.\d+)?)\s*b\b/);
+  if (mixtureMatch) {
+    const experts = normalizeModelNumber(mixtureMatch[1] ?? "");
+    const perExpert = normalizeModelNumber(mixtureMatch[2] ?? "");
+    if (experts && perExpert) return `${experts}x${perExpert}B`;
+  }
+  const billionMatch = id.match(/\b(\d+(?:\.\d+)?)\s*b\b/);
+  if (billionMatch?.[1]) {
+    return `${normalizeModelNumber(billionMatch[1])}B`;
+  }
+  const millionMatch = id.match(/\b(\d+(?:\.\d+)?)\s*m\b/);
+  if (millionMatch?.[1]) {
+    return `${normalizeModelNumber(millionMatch[1])}M`;
+  }
+  return void 0;
+}
+function isLoadedState(state) {
+  if (!state) return false;
+  const normalized = state.trim().toLowerCase();
+  if (!normalized || normalized.includes("not-loaded")) return false;
+  if (normalized === "loaded" || normalized === "ready") return true;
+  return normalized.includes("loaded");
+}
+async function fetchApiModels() {
+  try {
+    const resp = await fetchWithTimeout(
+      "/api/v0/models",
+      { method: "GET", headers: getLMStudioHeaders() },
+      LM_STUDIO_METADATA_TIMEOUT_MS,
+      "LM Studio API metadata"
+    );
+    if (!resp.ok) return null;
+    const payload = await resp.json();
+    return Array.isArray(payload.data) ? payload.data : [];
+  } catch {
+    return null;
+  }
+}
+async function fetchWithTimeout(path2, init, timeoutMs, label) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  const baseUrl = getLMStudioBaseUrl();
+  try {
+    const url = new URL(path2, baseUrl);
+    return await fetch(url, { ...init, signal: controller.signal });
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      throw new Error(`${label} timed out after ${timeoutMs}ms`);
+    }
+    throw err;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function resolveLocalLMStudioVersion() {
+  const historicalVersionPath = path.join(
+    getLMStudioHomeDir(),
+    ".internal",
+    "historical-version-info.json"
+  );
+  try {
+    const content = await fs.readFile(historicalVersionPath, "utf8");
+    const parsed = JSON.parse(content);
+    const version = asNonEmptyString(parsed.lastRecordedAppVersion) ?? asNonEmptyString(parsed.lastRecorderdAppVersion);
+    if (!version) return null;
+    const build = asNonEmptyString(parsed.lastRecordedAppBuildVersion);
+    return build ? `${version}+${build}` : version;
+  } catch {
+    return null;
+  }
+}
+async function getLMStudioVersion() {
+  const localVersion = await resolveLocalLMStudioVersion();
+  try {
+    const resp = await fetchWithTimeout(
+      "/v1/models",
+      { method: "GET", headers: getLMStudioHeaders() },
+      5e3,
+      "LM Studio version check"
+    );
+    if (!resp.ok) return localVersion ?? "unknown";
+    const fromHeader = asNonEmptyString(resp.headers.get("x-lmstudio-version"));
+    if (fromHeader) return fromHeader;
+    return localVersion ?? "unknown";
+  } catch {
+    return localVersion ?? "unknown";
+  }
+}
+async function listModels2() {
+  const resp = await fetchWithTimeout(
+    "/v1/models",
+    { method: "GET", headers: getLMStudioHeaders() },
+    LM_STUDIO_INIT_TIMEOUT_MS,
+    "LM Studio list models"
+  );
+  if (!resp.ok) {
+    throw new Error(`LM Studio list models failed (${resp.status} ${resp.statusText})`);
+  }
+  const data = await resp.json();
+  const ids = (data.data ?? []).map((m) => m.id?.trim()).filter((id) => Boolean(id));
+  const apiModels = await fetchApiModels();
+  const apiById = /* @__PURE__ */ new Map();
+  for (const model of apiModels ?? []) {
+    const id = asNonEmptyString(model.id);
+    if (!id) continue;
+    apiById.set(id, model);
+  }
+  const modelsRootDir = await resolveModelsRootDir();
+  const localMetadataById = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    const localMetadata = await resolveLocalModelMetadata(id, apiById.get(id), modelsRootDir);
+    localMetadataById.set(id, localMetadata);
+  }
+  return ids.map((id) => {
+    const apiModel = apiById.get(id);
+    const localMetadata = localMetadataById.get(id);
+    const apiSize = parseSizeBytes(apiModel);
+    return {
+      name: id,
+      size: apiSize > 0 ? apiSize : localMetadata?.size ?? 0,
+      parameterSize: localMetadata?.parameterSize ?? inferParameterSizeFromModelId(id),
+      quantization: asNonEmptyString(apiModel?.quantization),
+      runtimeStatus: asNonEmptyString(apiModel?.state),
+      modelFormat: asNonEmptyString(apiModel?.compatibility_type),
+      family: asNonEmptyString(apiModel?.arch) ?? asNonEmptyString(apiModel?.type) ?? asNonEmptyString(apiModel?.publisher)
+    };
+  });
+}
+async function listRunningModels2() {
+  const apiModels = await fetchApiModels();
+  if (!apiModels) return [];
+  return apiModels.filter((model) => isLoadedState(model.state)).map((model) => ({
+    name: model.id ?? "",
+    size: parseSizeBytes(model),
+    vramUsed: 0
+  })).filter((model) => model.name.trim().length > 0);
+}
+function setDefaultKeepAlive2(keepAlive) {
+  defaultKeepAlive2 = keepAlive;
+  void defaultKeepAlive2;
+}
+async function generate2(model, prompt, options) {
+  const start = Date.now();
+  const controller = new AbortController();
+  activeAbortControllers.add(controller);
+  try {
+    const baseUrl = getLMStudioBaseUrl();
+    const url = new URL("/v1/chat/completions", baseUrl);
+    const resp = await fetch(url, {
+      method: "POST",
+      headers: getLMStudioHeaders(),
+      body: JSON.stringify({
+        model,
+        messages: [{ role: "user", content: prompt }],
+        temperature: options?.temperature ?? 0,
+        max_tokens: options?.num_predict ?? 512,
+        stream: false,
+        ...buildThinkingConfig(options?.think)
+      }),
+      signal: controller.signal
+    });
+    if (!resp.ok) {
+      const body = await resp.text().catch(() => "");
+      throw new Error(`LM Studio generate failed (${resp.status} ${resp.statusText}) ${body}`.trim());
+    }
+    const payload = await resp.json();
+    const choice = extractChoice2(payload);
+    const response = extractContent(choice);
+    const reasoning = extractReasoning(choice);
+    const usage = extractUsage(payload);
+    const totalDuration = Math.max(0, Date.now() - start) * 1e6;
+    return {
+      response,
+      ...reasoning ? { thinking: reasoning } : {},
+      totalDuration,
+      loadDuration: 0,
+      promptEvalCount: usage?.prompt_tokens ?? 0,
+      promptEvalDuration: 0,
+      evalCount: usage?.completion_tokens ?? 0,
+      evalDuration: totalDuration
+    };
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      throw new Error("LM Studio generate request aborted");
+    }
+    throw err;
+  } finally {
+    activeAbortControllers.delete(controller);
+  }
+}
+async function generateStream2(model, prompt, callbacks, options) {
+  const start = Date.now();
+  const controller = new AbortController();
+  activeAbortControllers.add(controller);
+  const stallTimeoutMs = resolveStreamStallTimeoutMs(options?.stall_timeout_ms);
+  let abortedByStallTimeout = false;
+  const baseUrl = getLMStudioBaseUrl();
+  const url = new URL("/v1/chat/completions", baseUrl);
+  let stallTimer = null;
+  const resetStallTimer = () => {
+    if (stallTimeoutMs === void 0) return;
+    if (stallTimer) clearTimeout(stallTimer);
+    stallTimer = setTimeout(() => {
+      abortedByStallTimeout = true;
+      controller.abort();
+    }, stallTimeoutMs);
+  };
+  try {
+    resetStallTimer();
+    const resp = await fetch(url, {
+      method: "POST",
+      headers: getLMStudioHeaders(),
+      body: JSON.stringify({
+        model,
+        messages: [{ role: "user", content: prompt }],
+        temperature: options?.temperature ?? 0,
+        max_tokens: options?.num_predict ?? 512,
+        stream: true,
+        stream_options: { include_usage: true },
+        ...buildThinkingConfig(options?.think)
+      }),
+      signal: controller.signal
+    });
+    if (!resp.ok) {
+      const body = await resp.text().catch(() => "");
+      throw new Error(`LM Studio stream failed (${resp.status} ${resp.statusText}) ${body}`.trim());
+    }
+    if (!resp.body) {
+      throw new Error("LM Studio stream response body is empty");
+    }
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+    let buffered = "";
+    let doneReceived = false;
+    let fullResponse = "";
+    let fullThinking = "";
+    let usage;
+    let firstChunkSeen = false;
+    let firstTokenTime = null;
+    let lastTokenTime = null;
+    const processDataLine = (rawLine) => {
+      const line = rawLine.trim();
+      if (!line.startsWith("data:")) return;
+      const dataStr = line.slice(5).trim();
+      if (!dataStr) return;
+      if (dataStr === "[DONE]") {
+        doneReceived = true;
+        return;
+      }
+      let payload;
+      try {
+        payload = JSON.parse(dataStr);
+      } catch {
+        return;
+      }
+      const choice = extractChoice2(payload);
+      const content = extractContent(choice);
+      const reasoning = extractReasoning(choice);
+      const chunkUsage = extractUsage(payload);
+      if (chunkUsage) usage = chunkUsage;
+      if (reasoning) {
+        fullThinking += reasoning;
+      }
+      if (content) {
+        const now = Date.now();
+        if (firstTokenTime === null) firstTokenTime = now;
+        lastTokenTime = now;
+        fullResponse += content;
+        callbacks?.onToken?.(content);
+      }
+    };
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      resetStallTimer();
+      if (!firstChunkSeen) {
+        firstChunkSeen = true;
+        callbacks?.onFirstChunk?.();
+      }
+      buffered += decoder.decode(value, { stream: true });
+      const lines = buffered.split("\n");
+      buffered = lines.pop() ?? "";
+      for (const rawLine of lines) {
+        processDataLine(rawLine);
+      }
+    }
+    if (buffered.trim().length > 0) {
+      processDataLine(buffered);
+    }
+    if (stallTimer) clearTimeout(stallTimer);
+    if (!doneReceived && !fullResponse && !fullThinking) {
+      throw new Error("LM Studio stream ended without content");
+    }
+    const totalDuration = Math.max(0, Date.now() - start) * 1e6;
+    const evalDurationMs = firstTokenTime !== null && lastTokenTime !== null && lastTokenTime > firstTokenTime ? lastTokenTime - firstTokenTime : Date.now() - start;
+    const result = {
+      response: fullResponse,
+      ...fullThinking ? { thinking: fullThinking } : {},
+      totalDuration,
+      loadDuration: 0,
+      promptEvalCount: usage?.prompt_tokens ?? 0,
+      promptEvalDuration: firstTokenTime !== null ? (firstTokenTime - start) * 1e6 : 0,
+      evalCount: usage?.completion_tokens ?? 0,
+      evalDuration: Math.max(1, evalDurationMs) * 1e6
+    };
+    callbacks?.onDone?.(result);
+    return result;
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      if (abortedByStallTimeout && stallTimeoutMs !== void 0) {
+        throw new Error(`LM Studio stream timed out after ${stallTimeoutMs}ms`);
+      }
+      throw new Error("LM Studio stream request aborted");
+    }
+    throw err;
+  } finally {
+    if (stallTimer) clearTimeout(stallTimer);
+    activeAbortControllers.delete(controller);
+  }
+}
+async function unloadModel2(_model) {
+}
+function abortOngoingRequests2() {
+  for (const controller of activeAbortControllers) {
+    controller.abort();
+  }
+  activeAbortControllers.clear();
+}
+
 // ../src/core/runtime.ts
+var SUPPORTED_RUNTIME_BACKENDS = ["ollama", "lm-studio"];
+var RUNTIME_LABELS = {
+  ollama: "Ollama",
+  "lm-studio": "LM Studio"
+};
 var OllamaRuntime = class {
   name = "ollama";
   modelFormat = "gguf";
@@ -668,29 +1380,105 @@ var OllamaRuntime = class {
     abortOngoingRequests();
   }
 };
+var LMStudioRuntime = class {
+  name = "lm-studio";
+  modelFormat = "gguf";
+  generate(model, prompt, opts) {
+    return generate2(model, prompt, opts);
+  }
+  generateStream(model, prompt, callbacks, opts) {
+    return generateStream2(model, prompt, callbacks, opts);
+  }
+  listModels() {
+    return listModels2();
+  }
+  listRunningModels() {
+    return listRunningModels2();
+  }
+  getVersion() {
+    return getLMStudioVersion();
+  }
+  unloadModel(model) {
+    return unloadModel2(model);
+  }
+  setKeepAlive(keepAlive) {
+    setDefaultKeepAlive2(keepAlive);
+  }
+  abort() {
+    abortOngoingRequests2();
+  }
+};
 var activeRuntime = new OllamaRuntime();
-function generate2(model, prompt, opts) {
+function createRuntime(backend) {
+  if (backend === "lm-studio") return new LMStudioRuntime();
+  return new OllamaRuntime();
+}
+function normalizeRuntimeBackend(value) {
+  const candidate = (value ?? "ollama").trim().toLowerCase();
+  if (candidate === "ollama" || candidate === "lm-studio") {
+    return candidate;
+  }
+  throw new Error(
+    `Unsupported backend "${value}". Supported backends: ${SUPPORTED_RUNTIME_BACKENDS.join(", ")}`
+  );
+}
+function setRuntimeByName(backend) {
+  const normalized = normalizeRuntimeBackend(backend);
+  if (activeRuntime.name === normalized) return normalized;
+  activeRuntime = createRuntime(normalized);
+  return normalized;
+}
+function getRuntimeDisplayName(runtimeName = activeRuntime.name) {
+  if (runtimeName === "lm-studio") return RUNTIME_LABELS["lm-studio"];
+  if (runtimeName === "ollama") return RUNTIME_LABELS.ollama;
+  return runtimeName;
+}
+function getRuntimeModelInstallHint(runtimeName = activeRuntime.name) {
+  if (runtimeName === "lm-studio") {
+    return "Download/select a model in LM Studio, then load it in the local server.";
+  }
+  if (runtimeName === "ollama") {
+    return "Pull one with: ollama pull <model>";
+  }
+  return "Add at least one model in your selected runtime.";
+}
+function getRuntimeSetupHints(runtimeName = activeRuntime.name) {
+  if (runtimeName === "lm-studio") {
+    return [
+      "Start LM Studio local server (Developer tab -> Local Server).",
+      "Optionally set LM_STUDIO_BASE_URL if your server is not on http://127.0.0.1:1234."
+    ];
+  }
+  if (runtimeName === "ollama") {
+    return [
+      "Start it with:  ollama serve",
+      "Install it at:  https://ollama.com"
+    ];
+  }
+  return ["Verify the runtime is reachable and configured correctly."];
+}
+function generate3(model, prompt, opts) {
   return activeRuntime.generate(model, prompt, opts);
 }
-function generateStream2(model, prompt, callbacks, opts) {
+function generateStream3(model, prompt, callbacks, opts) {
   return activeRuntime.generateStream(model, prompt, callbacks, opts);
 }
-function listModels2() {
+function listModels3() {
   return activeRuntime.listModels();
 }
-function listRunningModels2() {
+function listRunningModels3() {
   return activeRuntime.listRunningModels();
 }
 function getRuntimeVersion() {
   return activeRuntime.getVersion();
 }
-function unloadModel2(model) {
+function unloadModel3(model) {
   return activeRuntime.unloadModel(model);
 }
 function setRuntimeKeepAlive(keepAlive) {
   activeRuntime.setKeepAlive(keepAlive);
 }
-function abortOngoingRequests2() {
+function abortOngoingRequests3() {
   activeRuntime.abort();
 }
 function getRuntimeName() {
@@ -706,7 +1494,7 @@ import chalk8 from "chalk";
 
 // ../src/core/hardware.ts
 import si from "systeminformation";
-import os from "os";
+import os2 from "os";
 import { execFile as execFile2 } from "child_process";
 import { readFile } from "fs/promises";
 function execCommand(cmd, args, timeoutMs = 3e3) {
@@ -782,6 +1570,56 @@ async function detectPowerMode() {
     return "unknown";
   }
 }
+async function detectThermalPressure() {
+  try {
+    if (process.platform === "darwin") {
+      const output4 = await execCommand("pmset", ["-g", "therm"]);
+      if (!output4) return "unknown";
+      const match = output4.match(/CPU_Speed_Limit\s*=\s*(\d+)/i);
+      if (!match) return "unknown";
+      const limit = parseInt(match[1], 10);
+      if (limit >= 100) return "nominal";
+      if (limit >= 80) return "moderate";
+      if (limit >= 50) return "heavy";
+      return "critical";
+    }
+    const temp = await si.cpuTemperature();
+    const main2 = temp.main;
+    if (main2 == null || main2 <= 0) return "unknown";
+    if (main2 < 80) return "nominal";
+    if (main2 < 90) return "moderate";
+    if (main2 < 100) return "heavy";
+    return "critical";
+  } catch {
+    return "unknown";
+  }
+}
+async function detectBatteryPowered() {
+  try {
+    if (process.platform === "darwin") {
+      const output4 = await execCommand("pmset", ["-g", "ps"]);
+      if (!output4) return void 0;
+      if (output4.includes("Battery Power")) return true;
+      if (output4.includes("AC Power")) return false;
+      return void 0;
+    }
+    const battery = await si.battery();
+    if (!battery.hasBattery) return void 0;
+    if (typeof battery.acConnected === "boolean") return !battery.acConnected;
+    if (typeof battery.isCharging === "boolean") return !battery.isCharging;
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function getSwapUsedGB() {
+  try {
+    const mem = await si.mem();
+    return +(mem.swapused / 1024 / 1024 / 1024).toFixed(2);
+  } catch {
+    return 0;
+  }
+}
 async function getHardwareInfo() {
   const [cpu, mem, graphics, osInfo, memLayout, powerMode, cpuSpeed, machineModel] = await Promise.all([
     si.cpu(),
@@ -813,12 +1651,20 @@ async function getHardwareInfo() {
     gpuCores: gpuCores && !isNaN(gpuCores) ? gpuCores : null,
     gpuVramMB: gpuController?.vram ?? null,
     os: `${osInfo.distro} ${osInfo.release}`,
-    arch: os.arch(),
+    arch: os2.arch(),
     machineModel: machineModel || null,
     powerMode,
     cpuCurrentSpeedGHz: cpuSpeed?.avg ?? null
   };
 }
+async function getCpuLoad() {
+  try {
+    const load = await si.currentLoad();
+    return +load.currentLoad.toFixed(1);
+  } catch {
+    return -1;
+  }
+}
 async function getMemoryUsage() {
   const mem = await si.mem();
   const totalGB = mem.total / 1024 / 1024 / 1024;
@@ -979,8 +1825,22 @@ var BENCH_PROMPTS = [
   "Write a detailed step-by-step explanation of how a compiler transforms source code into machine code, covering lexing, parsing, semantic analysis, optimization, and code generation.",
   "Implement a function in pseudocode that checks whether a given string of parentheses, brackets, and braces is balanced. Explain the time and space complexity."
 ];
-var DEFAULT_WARMUP_TIMEOUT_MS = 12e4;
-var DEFAULT_PROMPT_TIMEOUT_MS = 6e4;
+var DEFAULT_WARMUP_TIMEOUT_MS = 3e5;
+var DEFAULT_PROMPT_TIMEOUT_MS = 12e4;
+async function optionalProbe(probe, fallback) {
+  try {
+    return await probe();
+  } catch {
+    return fallback;
+  }
+}
+async function optionalProbeWithAvailability(probe, fallback) {
+  try {
+    return { value: await probe(), available: true };
+  } catch {
+    return { value: fallback, available: false };
+  }
+}
 async function runPerformanceBench(model, options = {}) {
   const spinner = createSpinner("Warming up model...");
   spinner.start();
@@ -989,21 +1849,39 @@ async function runPerformanceBench(model, options = {}) {
     const promptTimeoutMs = options.promptTimeoutMs ?? DEFAULT_PROMPT_TIMEOUT_MS;
     const minSuccessfulPrompts = options.minSuccessfulPrompts ?? Math.max(1, Math.ceil(BENCH_PROMPTS.length / 2));
     const failOnPromptError = options.failOnPromptError ?? false;
-    const memBefore = await getMemoryUsage();
+    const [memBefore, thermalBefore, swapBeforeResult, batteryPowered] = await Promise.all([
+      getMemoryUsage(),
+      optionalProbe(() => detectThermalPressure(), "unknown"),
+      optionalProbeWithAvailability(() => getSwapUsedGB(), 0),
+      optionalProbe(() => detectBatteryPowered(), void 0)
+    ]);
     const warmup = await withTimeout(
-      generateStream2(model, WARMUP_PROMPT, void 0, {
+      generateStream3(model, WARMUP_PROMPT, void 0, {
         num_predict: 32,
-        think: options.think
+        think: options.think,
+        stall_timeout_ms: options.streamStallTimeoutMs
       }),
       warmupTimeoutMs,
       "Model warmup",
-      abortOngoingRequests2
+      abortOngoingRequests3
     );
+    const runtimeName = getRuntimeName();
+    const loadTimeAvailable = !(runtimeName === "lm-studio" && warmup.loadDuration === 0);
     const loadTime = warmup.loadDuration / 1e6;
-    const runningModels = await listRunningModels2();
+    const runningModels = await listRunningModels3();
     const thisModel = runningModels.find((m) => m.name === model);
+    let installedModelSizeBytes = 0;
+    try {
+      const availableModels = await listModels3();
+      const listedModel = availableModels.find((m) => m.name === model);
+      if (listedModel && Number.isFinite(listedModel.size) && listedModel.size > 0) {
+        installedModelSizeBytes = listedModel.size;
+      }
+    } catch {
+    }
     spinner.succeed("Model loaded");
     const tpsValues = [];
+    const firstChunkValues = [];
     const ttftValues = [];
     let totalPromptTokens = 0;
     let totalCompletionTokens = 0;
@@ -1013,33 +1891,47 @@ async function runPerformanceBench(model, options = {}) {
     let failedPrompts = 0;
     let thinkingDetected = false;
     let totalThinkingTokens = 0;
+    const cpuLoadSamples = [];
     for (let i = 0; i < BENCH_PROMPTS.length; i++) {
       spinner.start(`Running performance test ${i + 1}/${BENCH_PROMPTS.length}...`);
+      let firstChunkTime = null;
       let firstTokenTime = null;
       const startTime = Date.now();
       try {
         const result = await withTimeout(
-          generateStream2(
+          generateStream3(
             model,
             BENCH_PROMPTS[i],
             {
+              onFirstChunk: () => {
+                if (firstChunkTime === null) {
+                  firstChunkTime = Date.now() - startTime;
+                }
+              },
               onToken: () => {
                 if (firstTokenTime === null) {
                   firstTokenTime = Date.now() - startTime;
                 }
               }
             },
-            { num_predict: 256, think: options.think }
+            {
+              num_predict: 256,
+              think: options.think,
+              stall_timeout_ms: options.streamStallTimeoutMs
+            }
           ),
           promptTimeoutMs,
           "Performance benchmark",
-          abortOngoingRequests2
+          abortOngoingRequests3
         );
         const evalDurationSec = result.evalDuration / 1e9;
         const tps = evalDurationSec > 0 ? result.evalCount / evalDurationSec : 0;
         tpsValues.push(tps);
         totalEvalCount += result.evalCount;
         totalEvalDurationNs += result.evalDuration;
+        if (firstChunkTime !== null) {
+          firstChunkValues.push(firstChunkTime);
+        }
         if (firstTokenTime !== null) {
           ttftValues.push(firstTokenTime);
         }
@@ -1052,8 +1944,10 @@ async function runPerformanceBench(model, options = {}) {
         totalCompletionTokens += result.evalCount;
         successfulPrompts++;
         subStep(
-          `  Prompt ${i + 1}: ${tps.toFixed(1)} tok/s, TTFT ${firstTokenTime ?? "?"}ms`
+          `  Prompt ${i + 1}: ${tps.toFixed(1)} tok/s, first chunk ${firstChunkTime ?? "?"}ms, TTFT ${firstTokenTime ?? "?"}ms`
         );
+        const cpuSample = await optionalProbe(() => getCpuLoad(), -1);
+        if (cpuSample >= 0) cpuLoadSamples.push(cpuSample);
       } catch (err) {
         failedPrompts++;
         const message = err instanceof Error ? err.message : String(err);
@@ -1073,24 +1967,43 @@ async function runPerformanceBench(model, options = {}) {
         `  Completed with ${failedPrompts} failed prompt(s); metrics use ${successfulPrompts} successful prompt(s).`
       );
     }
-    const memAfter = await getMemoryUsage();
+    const [memAfter, thermalAfter, swapAfterResult] = await Promise.all([
+      getMemoryUsage(),
+      optionalProbe(() => detectThermalPressure(), thermalBefore),
+      optionalProbeWithAvailability(() => getSwapUsedGB(), swapBeforeResult.value)
+    ]);
     let memoryUsedGB;
     let memoryPercent;
-    if (thisModel && thisModel.size > 0) {
-      memoryUsedGB = thisModel.size / 1024 ** 3;
+    const loadedModelSizeBytes = thisModel && thisModel.size > 0 ? thisModel.size : installedModelSizeBytes;
+    if (loadedModelSizeBytes > 0) {
+      memoryUsedGB = loadedModelSizeBytes / 1024 ** 3;
       memoryPercent = memoryUsedGB / memAfter.totalGB * 100;
     } else {
       memoryUsedGB = Math.max(0, memAfter.usedGB - memBefore.usedGB);
       memoryPercent = Math.max(0, memAfter.percent - memBefore.percent);
     }
     spinner.succeed("Performance benchmark complete");
+    const firstChunkMs = firstChunkValues.length > 0 ? avg(firstChunkValues) : void 0;
     const ttft = ttftValues.length > 0 ? avg(ttftValues) : -1;
+    const swapDeltaGB = swapBeforeResult.available && swapAfterResult.available ? +(swapAfterResult.value - swapBeforeResult.value).toFixed(2) : void 0;
+    const cpuAvgLoad = cpuLoadSamples.length > 0 ? +(cpuLoadSamples.reduce((a, b) => a + b, 0) / cpuLoadSamples.length).toFixed(1) : void 0;
+    const cpuPeakLoad = cpuLoadSamples.length > 0 ? +Math.max(...cpuLoadSamples).toFixed(1) : void 0;
+    const benchEnvironment = {
+      thermalPressureBefore: thermalBefore,
+      thermalPressureAfter: thermalAfter,
+      ...swapDeltaGB !== void 0 && swapDeltaGB > 0 ? { swapDeltaGB } : {},
+      ...batteryPowered != null ? { batteryPowered } : {},
+      ...cpuAvgLoad !== void 0 ? { cpuAvgLoad } : {},
+      ...cpuPeakLoad !== void 0 ? { cpuPeakLoad } : {}
+    };
     return {
       metrics: {
         tokensPerSecond: totalEvalDurationNs > 0 ? totalEvalCount / (totalEvalDurationNs / 1e9) : avg(tpsValues),
+        ...firstChunkMs !== void 0 ? { firstChunkMs } : {},
         ttft: ttft >= 0 ? ttft : 3e4,
         // Fallback: 30s if no TTFT measured
         loadTime,
+        loadTimeAvailable,
         totalTokens: totalPromptTokens + totalCompletionTokens,
         promptTokens: totalPromptTokens,
         completionTokens: totalCompletionTokens,
@@ -1101,7 +2014,8 @@ async function runPerformanceBench(model, options = {}) {
         tpsStdDev: tpsValues.length >= 2 ? stddev(tpsValues) : void 0,
         ...totalThinkingTokens > 0 ? { thinkingTokensEstimate: totalThinkingTokens } : {}
       },
-      thinkingDetected
+      thinkingDetected,
+      benchEnvironment
     };
   } catch (err) {
     if (spinner.isSpinning) {
@@ -1467,11 +2381,13 @@ var reasoning_default = [
 
 // ../src/benchmarks/reasoning.ts
 var questions = reasoning_default;
+var DEFAULT_REASONING_TIMEOUT_MS = 12e4;
 async function runReasoningBench(model, opts) {
   const spinner = createSpinner("Running reasoning benchmark...");
   spinner.start();
   const details = [];
   let correct = 0;
+  const timeoutMs = opts?.timeoutMs ?? DEFAULT_REASONING_TIMEOUT_MS;
   try {
     for (let i = 0; i < questions.length; i++) {
       const q = questions[i];
@@ -1485,10 +2401,10 @@ Answer:`;
       const startTime = Date.now();
       try {
         const result = await withTimeout(
-          generate2(model, prompt, { temperature: 0, num_predict: 1024, think: opts?.think }),
-          6e4,
+          generate3(model, prompt, { temperature: 0, num_predict: 1024, think: opts?.think }),
+          timeoutMs,
           "Reasoning question",
-          abortOngoingRequests2
+          abortOngoingRequests3
         );
         const answer = stripThinkTags(result.response);
         const actual = extractChoice(answer) ?? answer.trim();
@@ -1795,11 +2711,13 @@ var math_default = [
 
 // ../src/benchmarks/math.ts
 var problems = math_default;
+var DEFAULT_MATH_TIMEOUT_MS = 12e4;
 async function runMathBench(model, opts) {
   const spinner = createSpinner("Running math benchmark...");
   spinner.start();
   const details = [];
   let correct = 0;
+  const timeoutMs = opts?.timeoutMs ?? DEFAULT_MATH_TIMEOUT_MS;
   try {
     for (let i = 0; i < problems.length; i++) {
       const p = problems[i];
@@ -1812,10 +2730,10 @@ Answer:`;
       const startTime = Date.now();
       try {
         const result = await withTimeout(
-          generate2(model, prompt, { temperature: 0, num_predict: 1024, think: opts?.think }),
-          6e4,
+          generate3(model, prompt, { temperature: 0, num_predict: 1024, think: opts?.think }),
+          timeoutMs,
           "Math problem",
-          abortOngoingRequests2
+          abortOngoingRequests3
         );
         const actual = extractNumber(stripThinkTags(result.response));
         const tolerance = p.tolerance ?? 0;
@@ -5366,6 +6284,7 @@ var DIFFICULTY_WEIGHT = {
 var SANDBOX_TIMEOUT_MS = 5e3;
 var ISOLATED_WALL_TIMEOUT_MIN_MS = 8e3;
 var ISOLATED_WALL_TIMEOUT_MAX_MS = 6e4;
+var DEFAULT_CODING_TIMEOUT_MS = 24e4;
 var MAX_SANDBOX_STDOUT_BYTES = 64 * 1024;
 var MAX_SANDBOX_STDERR_BYTES = 64 * 1024;
 function runTestsInSandbox(code, task, sandboxTimeoutMs, vmModule) {
@@ -5668,6 +6587,7 @@ async function runCodingBench(model, opts) {
   const details = [];
   let totalPassed = 0;
   let totalTests = 0;
+  const timeoutMs = opts?.timeoutMs ?? DEFAULT_CODING_TIMEOUT_MS;
   try {
     for (let i = 0; i < tasks.length; i++) {
       const task = tasks[i];
@@ -5693,10 +6613,10 @@ Reply with ONLY the function code, no explanation.`;
       const startTime = Date.now();
       try {
         const result = await withTimeout(
-          generate2(model, prompt, { temperature: 0, num_predict: 2048, think: opts?.think }),
-          12e4,
+          generate3(model, prompt, { temperature: 0, num_predict: 2048, think: opts?.think }),
+          timeoutMs,
           "Coding task",
-          abortOngoingRequests2
+          abortOngoingRequests3
         );
         const rawCode = extractCodeBlock(stripThinkTags(result.response), task.functionName);
         const code = stripTypeAnnotations(rawCode);
@@ -5893,6 +6813,7 @@ var instruction_following_default = [
 
 // ../src/benchmarks/instruction-following.ts
 var questions2 = instruction_following_default;
+var DEFAULT_INSTRUCTION_FOLLOWING_TIMEOUT_MS = 12e4;
 function escapeRegex(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -6038,6 +6959,7 @@ async function runInstructionFollowingBench(model, opts) {
   spinner.start();
   const details = [];
   let correct = 0;
+  const timeoutMs = opts?.timeoutMs ?? DEFAULT_INSTRUCTION_FOLLOWING_TIMEOUT_MS;
   try {
     for (let i = 0; i < questions2.length; i++) {
       const q = questions2[i];
@@ -6046,10 +6968,10 @@ async function runInstructionFollowingBench(model, opts) {
       const startTime = Date.now();
       try {
         const result = await withTimeout(
-          generate2(model, prompt, { temperature: 0, num_predict: 1024, think: opts?.think }),
-          6e4,
+          generate3(model, prompt, { temperature: 0, num_predict: 1024, think: opts?.think }),
+          timeoutMs,
           "Instruction following task",
-          abortOngoingRequests2
+          abortOngoingRequests3
         );
         const answer = stripThinkTags(result.response);
         const isCorrect = validateInstructionFollowingResponse(answer, q);
@@ -6197,6 +7119,7 @@ var structured_output_default = [
 
 // ../src/benchmarks/structured-output.ts
 var questions3 = structured_output_default;
+var DEFAULT_STRUCTURED_OUTPUT_TIMEOUT_MS = 12e4;
 function tryParseJson(text) {
   try {
     return { ok: true, value: JSON.parse(text) };
@@ -6225,9 +7148,9 @@ function checkType(value, expectedType) {
   if (expectedType === "object") return typeof value === "object" && value !== null && !Array.isArray(value);
   return typeof value === expectedType;
 }
-function getNestedValue(obj, path) {
+function getNestedValue(obj, path2) {
   let current = obj;
-  for (const key of path) {
+  for (const key of path2) {
     if (typeof current !== "object" || current === null) return void 0;
     current = current[key];
   }
@@ -6303,8 +7226,8 @@ function validateStructuredOutputResponse(response, q) {
       const parsed = safeParse(response);
       if (!parsed) return false;
       const paths = ["path1", "path2", "path3", "path4"].filter((k) => k in p).map((k) => p[k]);
-      return paths.every((path) => {
-        const val = getNestedValue(parsed, path);
+      return paths.every((path2) => {
+        const val = getNestedValue(parsed, path2);
         return val !== void 0 && val !== null;
       });
     }
@@ -6423,6 +7346,7 @@ async function runStructuredOutputBench(model, opts) {
   spinner.start();
   const details = [];
   let correct = 0;
+  const timeoutMs = opts?.timeoutMs ?? DEFAULT_STRUCTURED_OUTPUT_TIMEOUT_MS;
   try {
     for (let i = 0; i < questions3.length; i++) {
       const q = questions3[i];
@@ -6430,10 +7354,10 @@ async function runStructuredOutputBench(model, opts) {
       const startTime = Date.now();
       try {
         const result = await withTimeout(
-          generate2(model, q.prompt, { temperature: 0, num_predict: 1024, think: opts?.think }),
-          6e4,
+          generate3(model, q.prompt, { temperature: 0, num_predict: 1024, think: opts?.think }),
+          timeoutMs,
           "Structured output task",
-          abortOngoingRequests2
+          abortOngoingRequests3
         );
         const answer = stripThinkTags(result.response);
         const isCorrect = validateStructuredOutputResponse(answer, q);
@@ -6616,6 +7540,7 @@ var multilingual_default = [
 
 // ../src/benchmarks/multilingual.ts
 var questions4 = multilingual_default;
+var DEFAULT_MULTILINGUAL_TIMEOUT_MS = 12e4;
 var NEGATION_PATTERNS = [
   /\b(?:not|never|no|non|pas|nicht|kein|keine|ningun|ninguna|nunca|jamas)\b/u,
   /\bn'?est\s+pas\b/u,
@@ -6680,6 +7605,7 @@ async function runMultilingualBench(model, opts) {
   spinner.start();
   const details = [];
   let correct = 0;
+  const timeoutMs = opts?.timeoutMs ?? DEFAULT_MULTILINGUAL_TIMEOUT_MS;
   try {
     for (let i = 0; i < questions4.length; i++) {
       const q = questions4[i];
@@ -6687,10 +7613,10 @@ async function runMultilingualBench(model, opts) {
       const startTime = Date.now();
       try {
         const result = await withTimeout(
-          generate2(model, q.prompt, { temperature: 0, num_predict: 1024, think: opts?.think }),
-          6e4,
+          generate3(model, q.prompt, { temperature: 0, num_predict: 1024, think: opts?.think }),
+          timeoutMs,
           "Multilingual task",
-          abortOngoingRequests2
+          abortOngoingRequests3
         );
         const answer = stripThinkTags(result.response);
         const isCorrect = validateMultilingualResponse(answer, q);
@@ -6793,24 +7719,24 @@ function deriveHardwareFitTuning(hardware) {
   };
 }
 function scoreSpeed(tps, tuning) {
-  if (tps >= tuning.speed.excellent) return 40;
+  if (tps >= tuning.speed.excellent) return 50;
   if (tps >= tuning.speed.good) {
-    return lerp(tps, tuning.speed.good, tuning.speed.excellent, 25, 40);
+    return lerp(tps, tuning.speed.good, tuning.speed.excellent, 30, 50);
   }
   if (tps >= tuning.speed.marginal) {
-    return lerp(tps, tuning.speed.marginal, tuning.speed.good, 10, 25);
+    return lerp(tps, tuning.speed.marginal, tuning.speed.good, 12, 30);
   }
-  return lerp(tps, 0, tuning.speed.marginal, 0, 10);
+  return lerp(tps, 0, tuning.speed.marginal, 0, 12);
 }
 function scoreTTFT(ttft, tuning) {
-  if (ttft <= tuning.ttft.excellentMs) return 30;
+  if (ttft <= tuning.ttft.excellentMs) return 20;
   if (ttft <= tuning.ttft.goodMs) {
-    return lerp(ttft, tuning.ttft.excellentMs, tuning.ttft.goodMs, 30, 20);
+    return lerp(ttft, tuning.ttft.excellentMs, tuning.ttft.goodMs, 20, 13);
   }
   if (ttft <= tuning.ttft.marginalMs) {
-    return lerp(ttft, tuning.ttft.goodMs, tuning.ttft.marginalMs, 20, 10);
+    return lerp(ttft, tuning.ttft.goodMs, tuning.ttft.marginalMs, 13, 6);
   }
-  return lerp(ttft, tuning.ttft.marginalMs, tuning.ttft.hardMaxMs, 10, 0);
+  return lerp(ttft, tuning.ttft.marginalMs, tuning.ttft.hardMaxMs, 6, 0);
 }
 function scoreMemory(memPercent) {
   if (memPercent <= 30) return 30;
@@ -6918,12 +7844,12 @@ function normalizeRawScore(value) {
   if (!Number.isFinite(value)) return 0;
   return clamp(value, 0, 100);
 }
-function computeFitness(perf, quality, hardware) {
+function computeFitness(perf, quality, hardware, benchEnv) {
   const tuning = deriveHardwareFitTuning(hardware);
   const performanceScore = computePerformanceScore(perf, hardware);
   const qualityScore = quality ? computeQualityScore(quality) : null;
   const hardwareFitScore = Math.round(performanceScore.total);
-  const globalScore = qualityScore ? clamp(Math.round(0.4 * hardwareFitScore + 0.6 * qualityScore.total), 0, 100) : null;
+  const globalScore = qualityScore ? clamp(Math.round(0.3 * hardwareFitScore + 0.7 * qualityScore.total), 0, 100) : null;
   const categoryLabels = quality ? [
     { category: "Reasoning", key: "reasoning", result: quality.reasoning },
     { category: "Coding", key: "coding", result: quality.coding },
@@ -7015,6 +7941,26 @@ function computeFitness(perf, quality, hardware) {
       `CPU appears throttled (${hardware.cpuCurrentSpeedGHz.toFixed(1)} GHz current vs ${hardware.cpuFreqGHz.toFixed(1)} GHz nominal, ${ratio}%).`
     );
   }
+  if (benchEnv?.thermalPressureAfter === "heavy" || benchEnv?.thermalPressureAfter === "critical") {
+    warnings.push(
+      `Thermal throttling detected after benchmark (${benchEnv.thermalPressureAfter}). Results may be degraded \u2014 consider cooling or shorter runs.`
+    );
+  }
+  if (benchEnv?.swapDeltaGB != null && benchEnv.swapDeltaGB > 0.5) {
+    warnings.push(
+      `Significant swap activity during benchmark (+${benchEnv.swapDeltaGB.toFixed(1)} GB). Model may exceed available RAM \u2014 results are severely degraded.`
+    );
+  }
+  if (benchEnv?.batteryPowered) {
+    warnings.push(
+      `Running on battery power \u2014 performance may be reduced.`
+    );
+  }
+  if (benchEnv?.cpuAvgLoad != null && benchEnv.cpuAvgLoad > 90) {
+    warnings.push(
+      `High CPU load during inference (avg ${benchEnv.cpuAvgLoad.toFixed(0)}%). System may feel unresponsive \u2014 GPU-accelerated runtimes (MLX) can reduce CPU pressure.`
+    );
+  }
   return {
     verdict,
     globalScore,
@@ -7101,7 +8047,7 @@ function printHardwareTable(hw) {
   }
   console.log(table.toString());
 }
-function printPerformanceTable(perf) {
+function printPerformanceTable(perf, benchEnvironment) {
   const table = new Table({
     head: [chalk3.bold("Metric"), chalk3.bold("Value")],
     style: { head: [], border: [] }
@@ -7111,8 +8057,15 @@ function printPerformanceTable(perf) {
   const memColor = perf.memoryPercent < 50 ? chalk3.green : perf.memoryPercent < 80 ? chalk3.yellow : chalk3.red;
   table.push(
     ["Tokens/sec", tpsColor(`${perf.tokensPerSecond.toFixed(1)} tok/s`)],
+    [
+      "First Chunk Latency",
+      perf.firstChunkMs !== void 0 ? formatDuration(perf.firstChunkMs) : chalk3.dim("N/A (stream metric unavailable)")
+    ],
     ["Time to First Token", ttftColor(formatDuration(perf.ttft))],
-    ["Model Load Time", formatDuration(perf.loadTime)],
+    [
+      "Model Load Time",
+      perf.loadTimeAvailable === false ? chalk3.dim("N/A (runtime metric unavailable)") : formatDuration(perf.loadTime)
+    ],
     ["Total Tokens", String(perf.totalTokens)],
     ["Prompt Tokens", String(perf.promptTokens)],
     ["Completion Tokens", String(perf.completionTokens)],
@@ -7133,6 +8086,13 @@ function printPerformanceTable(perf) {
       chalk3.magenta(`~${perf.thinkingTokensEstimate} tokens`)
     ]);
   }
+  if (benchEnvironment?.cpuAvgLoad != null && benchEnvironment.cpuAvgLoad >= 0) {
+    const cpuColor = benchEnvironment.cpuAvgLoad < 50 ? chalk3.green : benchEnvironment.cpuAvgLoad < 80 ? chalk3.yellow : chalk3.red;
+    table.push([
+      "CPU Load During Bench",
+      cpuColor(`avg ${benchEnvironment.cpuAvgLoad.toFixed(0)}%` + (benchEnvironment.cpuPeakLoad != null ? ` (peak ${benchEnvironment.cpuPeakLoad.toFixed(0)}%)` : ""))
+    ]);
+  }
   console.log(table.toString());
 }
 function printQualityTable(quality, timePenalties) {
@@ -7179,7 +8139,7 @@ function printSummaryTable(results) {
   const compact = termWidth < 100;
   console.log(
     chalk3.dim(
-      "Global = 40% Hardware Fit + 60% Quality. Hardware Fit = host compatibility. Quality = model capability."
+      "Global = 30% Hardware Fit + 70% Quality. Hardware Fit = host compatibility. Quality = model capability."
     )
   );
   const head = [
@@ -7362,7 +8322,7 @@ function printVerdict(model, fitness) {
   );
   sectionText(`Active profile: ${fitness.tuning.profile}`, fitBorder, chalk4.white);
   sectionText(
-    "Formula: Speed (/40) + TTFT (/30) + Memory (/30) = Hardware Fit (/100).",
+    "Formula: Speed (/50) + TTFT (/20) + Memory (/30) = Hardware Fit (/100).",
     fitBorder
   );
   sectionText(
@@ -7380,7 +8340,7 @@ function printVerdict(model, fitness) {
   sectionText("", fitBorder);
   scoreRow("Performance", fitness.performanceScore.total, fitBorder);
   sectionText(
-    `  Breakdown: Speed ${fitness.performanceScore.speed}/40  TTFT ${fitness.performanceScore.ttft}/30  Memory ${fitness.performanceScore.memory}/30`,
+    `  Breakdown: Speed ${fitness.performanceScore.speed}/50  TTFT ${fitness.performanceScore.ttft}/20  Memory ${fitness.performanceScore.memory}/30`,
     fitBorder
   );
   scoreRow("Hardware Fit", fitness.hardwareFitScore, fitBorder);
@@ -7449,7 +8409,7 @@ function printVerdict(model, fitness) {
   sectionStart("C) Global Score", globalBorder);
   if (fitness.globalScore !== null) {
     sectionText(
-      "Formula: Global = 40% Hardware Fit + 60% Quality.",
+      "Formula: Global = 30% Hardware Fit + 70% Quality.",
       globalBorder,
       chalk4.white
     );
@@ -7519,6 +8479,12 @@ var DEFAULT_CONFIG = {
 async function ensureDirs() {
   await mkdir(RESULTS_DIR, { recursive: true });
 }
+function parseRuntimeBackend(value) {
+  if (value === "ollama" || value === "lm-studio") {
+    return value;
+  }
+  return void 0;
+}
 function resultFilename(result) {
   const ts = result.timestamp.replace(/[:.]/g, "-").replace("T", "_").replace(/[^0-9_-]/g, "");
   const model = result.model.replace(/[^a-zA-Z0-9._-]/g, "_");
@@ -7540,7 +8506,15 @@ async function loadConfig() {
     const telemetry = typeof parsed.telemetry === "boolean" ? parsed.telemetry : void 0;
     const submitterNickname = typeof parsed.submitterNickname === "string" && isValidNickname(parsed.submitterNickname) ? normalizeNickname(parsed.submitterNickname) : void 0;
     const submitterEmail = typeof parsed.submitterEmail === "string" && isValidEmail(parsed.submitterEmail) ? normalizeEmail(parsed.submitterEmail) : void 0;
-    return { ...DEFAULT_CONFIG, autoShare, telemetry, submitterNickname, submitterEmail };
+    const runtimeBackend = parseRuntimeBackend(parsed.runtimeBackend);
+    return {
+      ...DEFAULT_CONFIG,
+      autoShare,
+      telemetry,
+      submitterNickname,
+      submitterEmail,
+      runtimeBackend
+    };
   } catch {
     return { ...DEFAULT_CONFIG };
   }
@@ -7552,24 +8526,40 @@ async function saveConfig(config) {
 
 // ../src/core/uploader.ts
 import { createClient } from "@supabase/supabase-js";
+var SUPABASE_URL_DEFAULT = "https://phvvzbgasxobjzjnkewf.supabase.co";
+var SUPABASE_ANON_KEY_DEFAULT = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InBodnZ6Ymdhc3hvYmp6am5rZXdmIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzIyOTMxNTksImV4cCI6MjA4Nzg2OTE1OX0.-Wn0V8f-Uv_x_krNUnjmFRcqfAOPQEVc_Qx1kZ2ppgk";
 var SUPABASE_URL_PLACEHOLDER = "https://YOUR_SUPABASE_PROJECT.supabase.co";
+var SUPABASE_URL_PLACEHOLDER_ALT = "https://your-project.supabase.co";
 var SUPABASE_ANON_KEY_PLACEHOLDER = "YOUR_SUPABASE_ANON_KEY";
+var SUPABASE_ANON_KEY_PLACEHOLDER_ALT = "your-supabase-anon-key";
+var PUBLIC_RESULT_BASE_URL_DEFAULT = "https://metrillm.dev";
 var PUBLIC_RESULT_BASE_URL_PLACEHOLDER = "https://YOUR_DASHBOARD_DOMAIN";
+var PUBLIC_RESULT_BASE_URL_PLACEHOLDER_ALT = "https://your-dashboard-domain";
 function resolveUploaderConfig() {
+  const configuredPublicBaseUrl = process.env.METRILLM_PUBLIC_RESULT_BASE_URL?.trim();
+  const publicResultBaseUrl = !configuredPublicBaseUrl || hasPlaceholder(configuredPublicBaseUrl) ? PUBLIC_RESULT_BASE_URL_DEFAULT : configuredPublicBaseUrl;
   return {
-    supabaseUrl: process.env.METRILLM_SUPABASE_URL ?? SUPABASE_URL_PLACEHOLDER,
-    supabaseAnonKey: process.env.METRILLM_SUPABASE_ANON_KEY ?? SUPABASE_ANON_KEY_PLACEHOLDER,
-    publicResultBaseUrl: process.env.METRILLM_PUBLIC_RESULT_BASE_URL ?? PUBLIC_RESULT_BASE_URL_PLACEHOLDER
+    supabaseUrl: !process.env.METRILLM_SUPABASE_URL || hasPlaceholder(process.env.METRILLM_SUPABASE_URL) ? SUPABASE_URL_DEFAULT : process.env.METRILLM_SUPABASE_URL,
+    supabaseAnonKey: !process.env.METRILLM_SUPABASE_ANON_KEY || hasPlaceholder(process.env.METRILLM_SUPABASE_ANON_KEY) ? SUPABASE_ANON_KEY_DEFAULT : process.env.METRILLM_SUPABASE_ANON_KEY,
+    publicResultBaseUrl
   };
 }
 function hasPlaceholder(value) {
-  return value.includes("YOUR_");
+  const normalized = value.trim();
+  if (normalized.length === 0) return true;
+  return [
+    SUPABASE_URL_PLACEHOLDER,
+    SUPABASE_URL_PLACEHOLDER_ALT,
+    SUPABASE_ANON_KEY_PLACEHOLDER,
+    SUPABASE_ANON_KEY_PLACEHOLDER_ALT,
+    PUBLIC_RESULT_BASE_URL_PLACEHOLDER,
+    PUBLIC_RESULT_BASE_URL_PLACEHOLDER_ALT
+  ].some((placeholder) => placeholder.toLowerCase() === normalized.toLowerCase());
 }
 function assertUploaderConfig(config) {
   const missing = [];
-  if (hasPlaceholder(config.supabaseUrl)) missing.push("METRILLM_SUPABASE_URL");
-  if (hasPlaceholder(config.supabaseAnonKey)) missing.push("METRILLM_SUPABASE_ANON_KEY");
-  if (hasPlaceholder(config.publicResultBaseUrl)) missing.push("METRILLM_PUBLIC_RESULT_BASE_URL");
+  if (!config.supabaseUrl.trim()) missing.push("METRILLM_SUPABASE_URL");
+  if (!config.supabaseAnonKey.trim()) missing.push("METRILLM_SUPABASE_ANON_KEY");
   if (missing.length > 0) {
     throw new Error(
       `Upload is not configured. Set these variables first: ${missing.join(", ")}`
@@ -8021,6 +9011,13 @@ async function promptThinkingMode() {
 var BENCHMARK_SPEC_VERSION = "0.2.0";
 var PROMPT_PACK_VERSION = "0.1.0";
 async function benchCommand(options) {
+  if (options.backend !== void 0) {
+    setRuntimeByName(options.backend);
+  }
+  const runtimeName = getRuntimeName();
+  const runtimeDisplayName = getRuntimeDisplayName(runtimeName);
+  const runtimeModelHint = getRuntimeModelInstallHint(runtimeName);
+  const runtimeSetupHints = getRuntimeSetupHints(runtimeName);
   const shouldSetExitCode = options.setExitCode !== false;
   const silent = options.json === true;
   const shouldUnloadAfterModel = options.unloadAfterBench ?? (!options.model || options.ciNoMenu === true);
@@ -8053,7 +9050,7 @@ async function benchCommand(options) {
     runtimeVersion = await getRuntimeVersion();
   } catch (err) {
     if (!silent) {
-      warnMsg("Could not detect Ollama version (continuing without it).");
+      warnMsg(`Could not detect ${runtimeDisplayName} version (continuing without it).`);
       if (err instanceof Error) warnMsg(err.message);
     }
   }
@@ -8062,7 +9059,7 @@ async function benchCommand(options) {
   if (options.model) {
     modelNames = [options.model];
     try {
-      allModels = await listModels2();
+      allModels = await listModels3();
     } catch {
     }
   } else {
@@ -8070,22 +9067,23 @@ async function benchCommand(options) {
     const spinnerModels = createSpinner("Fetching model list...");
     if (!silent) spinnerModels.start();
     try {
-      allModels = await listModels2();
+      allModels = await listModels3();
       modelNames = allModels.map((m) => m.name);
       if (!silent) spinnerModels.succeed(`Found ${allModels.length} model(s)`);
     } catch (err) {
       if (!silent) {
-        spinnerModels.fail("Cannot connect to Ollama");
-        errorMsg("Make sure Ollama is installed and running.");
-        errorMsg("  \u2022 Start it with:  ollama serve");
-        errorMsg("  \u2022 Install it at:  https://ollama.com");
+        spinnerModels.fail(`Cannot connect to ${runtimeDisplayName}`);
+        errorMsg(`Make sure ${runtimeDisplayName} is installed and running.`);
+        for (const hint of runtimeSetupHints) {
+          errorMsg(`  \u2022 ${hint}`);
+        }
         if (err instanceof Error) errorMsg(err.message);
       }
       if (shouldSetExitCode) process.exitCode = 1;
       return { results: [], failedModels: [] };
     }
     if (modelNames.length === 0) {
-      if (!silent) errorMsg("No models found. Pull one with: ollama pull <model>");
+      if (!silent) errorMsg(`No models found. ${runtimeModelHint}`);
       if (shouldSetExitCode) process.exitCode = 1;
       return { results: [], failedModels: [] };
     }
@@ -8097,6 +9095,8 @@ async function benchCommand(options) {
     thinkEnabled = options.thinking;
   } else if (!silent && !options.ciNoMenu) {
     thinkEnabled = await promptThinkingMode();
+  } else {
+    thinkEnabled = false;
   }
   if (!silent && thinkEnabled) {
     infoMsg("Thinking mode enabled \u2014 models that support it will use extended reasoning.");
@@ -8129,29 +9129,38 @@ ${tl}${h.repeat(innerWidth)}${tr}`));
           promptTimeoutMs: options.perfPromptTimeoutMs,
           minSuccessfulPrompts: options.perfMinSuccessfulPrompts,
           failOnPromptError: options.perfStrict,
-          think: thinkEnabled
+          think: thinkEnabled,
+          streamStallTimeoutMs: options.lmStudioStreamStallTimeoutMs
         });
         const perf = perfResult.metrics;
-        const thinkingDetected = perfResult.thinkingDetected;
-        if (!silent) printPerformanceTable(perf);
+        const benchEnvironment = perfResult.benchEnvironment;
+        if (!silent) printPerformanceTable(perf, benchEnvironment);
         let quality = null;
         if (!options.perfOnly) {
-          const qualityOpts = thinkEnabled !== void 0 ? { think: thinkEnabled } : void 0;
+          const qualityTimeoutMs = options.qualityTimeoutMs;
+          const codingTimeoutMs = options.codingTimeoutMs ?? options.qualityTimeoutMs;
+          const commonQualityOpts = {
+            think: thinkEnabled,
+            ...qualityTimeoutMs !== void 0 ? { timeoutMs: qualityTimeoutMs } : {}
+          };
           if (!silent) stepHeader("Quality Benchmark \u2014 Reasoning");
-          const reasoning = await runReasoningBench(modelName, qualityOpts);
+          const reasoning = await runReasoningBench(modelName, commonQualityOpts);
           if (!silent) stepHeader("Quality Benchmark \u2014 Math");
-          const math = await runMathBench(modelName, qualityOpts);
+          const math = await runMathBench(modelName, commonQualityOpts);
           if (!silent) stepHeader("Quality Benchmark \u2014 Coding");
-          const coding = await runCodingBench(modelName, qualityOpts);
+          const coding = await runCodingBench(modelName, {
+            think: thinkEnabled,
+            ...codingTimeoutMs !== void 0 ? { timeoutMs: codingTimeoutMs } : {}
+          });
           if (!silent) stepHeader("Quality Benchmark \u2014 Instruction Following");
-          const instructionFollowing = await runInstructionFollowingBench(modelName, qualityOpts);
+          const instructionFollowing = await runInstructionFollowingBench(modelName, commonQualityOpts);
           if (!silent) stepHeader("Quality Benchmark \u2014 Structured Output");
-          const structuredOutput = await runStructuredOutputBench(modelName, qualityOpts);
+          const structuredOutput = await runStructuredOutputBench(modelName, commonQualityOpts);
           if (!silent) stepHeader("Quality Benchmark \u2014 Multilingual");
-          const multilingual = await runMultilingualBench(modelName, qualityOpts);
+          const multilingual = await runMultilingualBench(modelName, commonQualityOpts);
           quality = { reasoning, math, coding, instructionFollowing, structuredOutput, multilingual };
         }
-        const fitness = computeFitness(perf, quality, hardware);
+        const fitness = computeFitness(perf, quality, hardware, benchEnvironment);
         if (!silent) {
           if (quality) {
             printQualityTable(quality, fitness.qualityScore?.timePenalties);
@@ -8163,8 +9172,9 @@ ${tl}${h.repeat(innerWidth)}${tr}`));
           parameterSize: matchedModel.parameterSize,
           quantization: matchedModel.quantization,
           family: matchedModel.family,
-          ...thinkingDetected ? { thinkingDetected } : {}
-        } : thinkingDetected ? { thinkingDetected } : void 0;
+          // Persist the configured benchmark mode (not model auto-detection).
+          thinkingDetected: thinkEnabled
+        } : { thinkingDetected: thinkEnabled };
         const partialResult = {
           model: modelName,
           modelInfo,
@@ -8172,13 +9182,14 @@ ${tl}${h.repeat(innerWidth)}${tr}`));
           performance: perf,
           quality,
           fitness,
+          benchEnvironment,
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           metadata: {
             benchmarkSpecVersion: BENCHMARK_SPEC_VERSION,
             promptPackVersion: PROMPT_PACK_VERSION,
             runtimeVersion,
             runtimeBackend: getRuntimeName(),
-            modelFormat: getRuntimeModelFormat()
+            modelFormat: matchedModel?.modelFormat ?? getRuntimeModelFormat()
           }
         };
         const rawLogHash = createHash3("sha256").update(JSON.stringify(partialResult)).digest("hex");
@@ -8233,7 +9244,7 @@ ${tl}${h.repeat(innerWidth)}${tr}`));
       } finally {
         if (shouldUnloadAfterModel) {
           try {
-            await unloadModel2(modelName);
+            await unloadModel3(modelName);
           } catch (err) {
             if (!silent) {
               warnMsg(`Could not unload model ${modelName} after benchmark.`);
@@ -8330,8 +9341,8 @@ ${tl}${h.repeat(innerWidth)}${tr}`));
 }
 
 // src/tools.ts
-var SUPPORTED_RUNTIMES = ["ollama"];
-var runtimeSchema = z.enum(SUPPORTED_RUNTIMES).optional().default("ollama").describe("Inference runtime to use. Currently only 'ollama' is supported.");
+var SUPPORTED_RUNTIMES = ["ollama", "lm-studio"];
+var runtimeSchema = z.enum(SUPPORTED_RUNTIMES).optional().default("ollama").describe("Inference runtime to use (ollama | lm-studio).");
 var listModelsSchema = z.object({
   runtime: runtimeSchema
 });
@@ -8365,18 +9376,24 @@ var toolDefinitions = [
   },
   {
     name: "share_result",
-    description: "Upload a benchmark result to the public MetriLLM leaderboard. Requires METRILLM_SUPABASE_URL and METRILLM_SUPABASE_ANON_KEY environment variables. The resultFile must be an absolute path to a JSON file in ~/.metrillm/results/.",
+    description: "Upload a benchmark result to the public MetriLLM leaderboard. Uses official upload defaults; METRILLM_* environment variables can override for self-hosted deployments. The resultFile must be an absolute path to a JSON file in ~/.metrillm/results/.",
     inputSchema: shareResultSchema
   }
 ];
 function assertRuntime(runtime) {
-  if (runtime !== "ollama") {
+  if (!SUPPORTED_RUNTIMES.includes(runtime)) {
     throw new Error(
       `Runtime "${runtime}" is not yet supported. Currently supported: ${SUPPORTED_RUNTIMES.join(", ")}. New runtimes will be added as they become available in the MetriLLM CLI.`
     );
   }
 }
 var RESULTS_DIR2 = join2(homedir2(), ".metrillm", "results");
+function normalizeResultRuntimeBackend(result) {
+  const runtimeBackend = result.metadata?.runtimeBackend?.trim().toLowerCase();
+  if (runtimeBackend === "lm-studio") return "lm-studio";
+  if (runtimeBackend === "ollama") return "ollama";
+  return "ollama";
+}
 var benchLock = Promise.resolve();
 function withBenchLock(fn) {
   const prev = benchLock;
@@ -8388,29 +9405,37 @@ function withBenchLock(fn) {
 }
 async function handleListModels(args) {
   assertRuntime(args.runtime);
-  const models = await listModels2();
-  if (models.length === 0) {
+  return withBenchLock(async () => {
+    setRuntimeByName(args.runtime);
+    const runtimeDisplayName = getRuntimeDisplayName(args.runtime);
+    const runtimeModelHint = getRuntimeModelInstallHint(args.runtime);
+    const models = await listModels3();
+    if (models.length === 0) {
+      return JSON.stringify({
+        models: [],
+        message: `No models found on ${runtimeDisplayName}. ${runtimeModelHint}`
+      });
+    }
     return JSON.stringify({
-      models: [],
-      message: "No models found. Pull one with: ollama pull <model>"
+      models: models.map((m) => ({
+        name: m.name,
+        size: m.size,
+        parameterSize: m.parameterSize ?? null,
+        quantization: m.quantization ?? null,
+        family: m.family ?? null
+      })),
+      count: models.length
     });
-  }
-  return JSON.stringify({
-    models: models.map((m) => ({
-      name: m.name,
-      size: m.size,
-      parameterSize: m.parameterSize ?? null,
-      quantization: m.quantization ?? null,
-      family: m.family ?? null
-    })),
-    count: models.length
   });
 }
 async function handleRunBenchmark(args) {
   assertRuntime(args.runtime);
+  const runtimeDisplayName = getRuntimeDisplayName(args.runtime);
   return withBenchLock(async () => {
+    setRuntimeByName(args.runtime);
     const outcome = await benchCommand({
       model: args.model,
+      backend: args.runtime,
       perfOnly: args.perfOnly,
       json: true,
       // suppress all UI output
@@ -8428,7 +9453,7 @@ async function handleRunBenchmark(args) {
     if (outcome.results.length === 0) {
       return JSON.stringify({
         success: false,
-        error: "No results produced. Is Ollama running? Is the model pulled?"
+        error: `No results produced. Is ${runtimeDisplayName} running?`
       });
     }
     const result = outcome.results[0];
@@ -8467,6 +9492,10 @@ async function handleGetResults(args) {
     try {
       const content = await readFile3(join2(RESULTS_DIR2, file), "utf8");
       const result = JSON.parse(content);
+      const resultRuntime = normalizeResultRuntimeBackend(result);
+      if (resultRuntime !== args.runtime) {
+        continue;
+      }
       if (args.model && !result.model.toLowerCase().includes(args.model.toLowerCase())) {
         continue;
       }