offgrid-ai 0.13.0 → 0.14.1

package/src/profile-setup.mjs

@@ -9,6 +9,7 @@ import { detectCapabilities } from "./autodetect.mjs";
 import { matchDrafter } from "./scan.mjs";
 import { scanGgufModels } from "./scan.mjs";
 import { estimateMemoryMb } from "./mlx-flags.mjs";
+import { capabilitySummary } from "./model-summary.mjs";
 
 const execFileAsync = promisify(execFile);
 
@@ -70,7 +71,7 @@ export async function configureLocalProfile(prompt, profile) {
   console.log("");
   console.log(renderSection("Model setup", renderRows([
     ["Model", pc.bold(profile.label)],
-    ["Detected", detectionSummary(caps)],
+    ["Detected", capabilitySummary(caps)],
     ["Context", `${profile.flags.ctxSize.toLocaleString()} tokens`],
     ["KV cache", `${profile.flags.cacheTypeK}/${profile.flags.cacheTypeV}`],
     ["Sampling", samplingSummary(profile.flags)],
@@ -151,16 +152,12 @@ export function applyRuntimeFlagOverrides(profile, overrides) {
 
 export function applyMtpDefaults(profile) {
   const flags = { ...profile.flags, port: LLAMA_CPP_MTP_PORT };
-  const edits = {
-    values: { "--spec-type": "draft-mtp", "--spec-draft-n-max": 4 },
-  };
-  if (profile.drafterPath) edits.values["--spec-draft-model"] = profile.drafterPath;
   return applyProfileFlags({
     ...profile,
     backend: "llama-cpp-mtp",
     providerId: "llama-cpp-mtp",
     capabilities: { ...(profile.capabilities ?? {}), mtp: true },
-  }, flags, edits);
+  }, flags);
 }
 
 export function removeMtpDefaults(profile) {
@@ -171,9 +168,7 @@ export function removeMtpDefaults(profile) {
     providerId: "llama-cpp",
     drafterPath: null,
     capabilities: { ...(profile.capabilities ?? {}), mtp: false },
-  }, flags, {
-    remove: ["--spec-type", "--spec-draft-n-max", "--spec-draft-model"],
-  });
+  }, flags);
 }
 
 function applyVisionDefaults(profile) {
@@ -201,10 +196,10 @@ function applyThinkingDefaults(profile) {
 function removeThinkingDefaults(profile) {
   const flags = { ...profile.flags, ...GENERAL_DEFAULTS };
   delete flags.chatTemplateKwargs;
-  return applyProfileFlags(profile, flags, { remove: ["--chat-template-kwargs"] });
+  return applyProfileFlags(profile, flags);
 }
 
-function applyProfileFlags(profile, flags, edits = {}) {
+function applyProfileFlags(profile, flags) {
   const next = {
     ...profile,
     flags,
@@ -214,43 +209,9 @@ function applyProfileFlags(profile, flags, edits = {}) {
       pi: { ...(profile.harnesses?.pi ?? {}), enabled: true, model: `${profile.providerId ?? profile.backend}/${profile.modelAlias ?? profile.id}` },
     },
   };
-  next.commandArgv = updateArgv(profile.commandArgv ?? [], {
-    "--host": flags.host,
-    "--port": flags.port,
-    "--ctx-size": flags.ctxSize,
-    "--cache-type-k": flags.cacheTypeK,
-    "--cache-type-v": flags.cacheTypeV,
-    "--top-k": flags.topK,
-    "--presence-penalty": flags.presencePenalty,
-    "--repeat-penalty": flags.repeatPenalty,
-    ...(flags.chatTemplateKwargs ? { "--chat-template-kwargs": JSON.stringify(flags.chatTemplateKwargs) } : {}),
-  }, edits);
-  return next;
-}
-
-function updateArgv(argv, values, edits = {}) {
-  let next = [...argv];
-  for (const flag of edits.remove ?? []) next = removeOption(next, flag);
-  for (const [flag, value] of Object.entries({ ...values, ...(edits.values ?? {}) })) {
-    if (value === undefined) continue;
-    const index = next.indexOf(flag);
-    if (index === -1) next.push(flag, String(value));
-    else next[index + 1] = String(value);
-  }
   return next;
 }
 
-function removeOption(argv, flag) {
-  const next = [];
-  for (let i = 0; i < argv.length; i++) {
-    if (argv[i] === flag) {
-      if (argv[i + 1] && !argv[i + 1].startsWith("--")) i += 1;
-      continue;
-    }
-    next.push(argv[i]);
-  }
-  return next;
-}
 
 function renderMemoryEstimate(profile) {
   try {
@@ -283,18 +244,6 @@ async function runtimeSupportsGemma4Unified() {
   }
 }
 
-function detectionSummary(caps) {
-  const parts = [];
-  if (caps.architecture) parts.push(caps.architecture);
-  if (caps.quant) parts.push(caps.quant);
-  if (caps.mtp) parts.push("MTP");
-  if (caps.qat) parts.push("QAT");
-
-  if (caps.thinking) parts.push("thinking");
-  if (caps.vision) parts.push("vision");
-  return parts.length > 0 ? parts.join(" · ") : "standard GGUF";
-}
-
 function samplingSummary(flags) {
   return `temp ${flags.temperature}, top-p ${flags.topP}, top-k ${flags.topK}`;
 }
@@ -342,7 +291,7 @@ export async function configureMlxProfile(prompt, profile) {
     ["Backend", configured.backend],
     ["Endpoint", configured.baseUrl],
     ["Context", String(configured.flags.ctxSize) + " tokens"],
-    ["Thinking", configured.capabilities.thinking && configured.commandArgv.includes("--enable-thinking") ? "on" : "off"],
+    ["Thinking", configured.capabilities?.thinking ? "on" : "off"],
     ["Vision", configured.capabilities.vision ? "yes" : "no"],
   ])));
 
@@ -352,33 +301,19 @@ export async function configureMlxProfile(prompt, profile) {
 
 async function applyMlxThinkingToggle(profile, enabled) {
   if (!profile.capabilities.thinking) return profile;
-  const { computeMlxVlmFlags } = await import("./mlx-flags.mjs");
-  const { args } = computeMlxVlmFlags(profile.modelPath, {
-    port: profile.flags.port,
-    ctxSize: profile.flags.ctxSize,
-    thinkingEnabled: enabled,
-  });
   return {
     ...profile,
-    commandArgv: args,
     capabilities: { ...profile.capabilities, thinkingEnabled: enabled },
   };
 }
 
 function applyMlxContextSize(profile, ctxSize) {
   const flags = { ...profile.flags, ctxSize };
-  const next = {
+  return {
     ...profile,
     flags,
     baseUrl: baseUrlForFlags(flags),
   };
-  const idx = next.commandArgv.indexOf("--max-kv-size");
-  if (idx !== -1 && next.commandArgv[idx + 1] != null) {
-    next.commandArgv[idx + 1] = String(ctxSize);
-  } else if (ctxSize && ctxSize > 0) {
-    next.commandArgv.push("--max-kv-size", String(ctxSize));
-  }
-  return next;
 }
 
 function renderMlxMemoryEstimate(profile) {

package/src/profiles.mjs

@@ -18,10 +18,6 @@ export function profileJsonPath(id) {
   return join(profileDir(id), "profile.json");
 }
 
-export function commandJsonPath(id) {
-  return join(profileDir(id), "command.json");
-}
-
 export function notesPath(id) {
   return join(profileDir(id), "notes.md");
 }
@@ -69,9 +65,8 @@ export async function saveProfile(profile, options = {}) {
   };
   await writeJson(profileJsonPath(id), saved);
 
-  // Note: command.json is no longer written — the server command is computed
-  // fresh from the profile config at launch time (see computeServerCommand in
-  // process.mjs).  commandArgv is kept in the profile for backwards compat.
+  // Note: commandArgv is no longer stored — computeServerCommand computes
+  // the full command fresh from profile config at launch time.
 
   if (!existsSync(notesPath(id))) {
     await writeFile(notesPath(id), `# ${saved.label}\n\nNotes for this model profile.\n`, "utf8");
@@ -134,7 +129,7 @@ export async function createProfileFromModel(model, backendId, drafterPath) {
   // If a drafter is provided, this model supports MTP regardless of filename
   const hasMtp = caps.mtp || Boolean(drafterPath);
   const backend = backendId ?? (hasMtp ? "llama-cpp-mtp" : "llama-cpp");
-  const { flags, argv } = computeFlags(
+  const { flags } = computeFlags(
     { ...caps, mtp: hasMtp },
     model.path,
     model.mmprojPath,
@@ -154,21 +149,15 @@ export async function createProfileFromModel(model, backendId, drafterPath) {
     capabilities: summarizeCapabilities({ ...caps, mtp: hasMtp }),
     preset: null, // no presets — auto-detected
     flags,
-    commandArgv: argv,
   });
 }
 
 // ── Auto-create profile from a discovered MLX model ────────────────────────
 
 export async function createProfileFromMlxModel(model) {
-  const { computeMlxVlmFlags, DEFAULT_PORT } = await import("./mlx-flags.mjs");
+  const { DEFAULT_PORT } = await import("./mlx-flags.mjs");
   const caps = await detectMlxCapabilities(model.filePath);
   const ctxSize = defaultMlxContextLength(caps.contextLength, detectHardware().totalRamBytes / (1024 ** 3));
-  const { args } = computeMlxVlmFlags(model.filePath, {
-    port: DEFAULT_PORT,
-    ctxSize,
-    thinkingEnabled: caps.thinking,
-  });
   return normalizeProfile({
     id: slugFromLabel(model.label),
     label: model.label,
@@ -182,7 +171,6 @@ export async function createProfileFromMlxModel(model) {
     modelSizeBytes: model.sizeBytes,
     capabilities: caps,
     flags: { host: "127.0.0.1", port: DEFAULT_PORT, ctxSize },
-    commandArgv: args,
   });
 }
 
@@ -203,11 +191,6 @@ function summarizeCapabilities(caps) {
 
 // ── State files (for running servers) ──────────────────────────────────────
 
-export async function readCommandArgv(profile) {
-  const command = await readJson(commandJsonPath(profile.id), null);
-  return Array.isArray(command?.argv) ? command.argv.map(String) : (profile.commandArgv ?? []).map(String);
-}
-
 export async function readState(id) {
   return readJson(statePath(id), null);
 }

package/src/benchmark/pi-runner.mjs

@@ -1,257 +0,0 @@
-// ── Run benchmark in Pi (non-interactive JSON mode) ───────────────────────────
-
-import { writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { spawn } from "node:child_process";
-import {
-  BENCH_COLORS, renderStreamEvent,
-  formatToolCall, printFinalLine, stopExecTimer,
-} from "./stream-renderer.mjs";
-import { piModelString } from "./shared.mjs";
-
-export async function runBenchmarkInPi(profile, runDirectory, { signal } = {}) {
-  const model = piModelString(profile);
-  const args = ["--model", model, "--mode", "json", "-p", "@prompt.md"];
-
-  const child = spawn("pi", args, {
-    cwd: runDirectory,
-    stdio: ["ignore", "pipe", "pipe"],
-  });
-
-  const runResult = {
-    model,
-    exitCode: null,
-    wallClockMs: null,
-    agentTurns: 0,
-    promptTokens: 0,
-    completionTokens: 0,
-    totalTokens: 0,
-    cacheRead: 0,
-    cacheWrite: 0,
-    toolCalls: 0,
-    toolResults: 0,
-    perTurn: [],
-    rawResponseLines: [],
-    error: null,
-  };
-
-  let streamBuffer = "";
-  let responseBuffer = "";
-  let currentTurnStartMs = null;
-  let lastTurnEndMs = null;
-  let runStartMs = null;
-  let firstEventMs = null;
-  let lastEventMs = null;
-  let cancelled = false;
-
-  const streamPath = join(runDirectory, "stream.ndjson");
-  const stderrPath = join(runDirectory, "stderr.log");
-  const responsePath = join(runDirectory, "response.raw.txt");
-
-  const streamHandle = await openFileHandle(streamPath, "w");
-  const stderrHandle = await openFileHandle(stderrPath, "w");
-
-  const verbose = Boolean(process.env.OFFGRID_BENCHMARK_VERBOSE);
-  const renderState = {
-    cwd: runDirectory,
-    turn: 0,
-    turnHadToolError: false,
-    modelPrinted: false,
-    activeTool: null,
-    execTimer: null,
-    status: { mode: "idle", toolName: null, bytes: 0, tokens: 0, execStartedAt: null },
-  };
-
-  function appendResponse(text) {
-    responseBuffer += text;
-  }
-
-  function flushResponse() {
-    if (responseBuffer) {
-      runResult.rawResponseLines.push(responseBuffer);
-      responseBuffer = "";
-    }
-  }
-
-  function updateTimeBounds(timestamp) {
-    if (!timestamp) return;
-    if (firstEventMs === null) firstEventMs = timestamp;
-    lastEventMs = timestamp;
-  }
-
-  function beginTurn() {
-    runResult.agentTurns += 1;
-    currentTurnStartMs = lastTurnEndMs ?? runStartMs ?? null;
-  }
-
-  function endTurn(usage, timestamp) {
-    const turnEndMs = timestamp ?? null;
-    const wallClockMs = currentTurnStartMs && turnEndMs ? turnEndMs - currentTurnStartMs : null;
-    runResult.perTurn.push({
-      turn: runResult.agentTurns,
-      inputTokens: usage?.input ?? 0,
-      outputTokens: usage?.output ?? 0,
-      cacheRead: usage?.cacheRead ?? 0,
-      cacheWrite: usage?.cacheWrite ?? 0,
-      wallClockMs,
-      toolCalls: 0,
-    });
-    if (turnEndMs) lastTurnEndMs = turnEndMs;
-    currentTurnStartMs = null;
-  }
-
-  function processLine(line) {
-    if (!line.trim()) return;
-    streamHandle.write(line + "\n");
-    let parsed;
-    try {
-      parsed = JSON.parse(line);
-    } catch (err) {
-      console.log(BENCH_COLORS.error(`[parse error] ${err.message}`));
-      return;
-    }
-
-    const timestamp = extractTimestamp(parsed);
-    updateTimeBounds(timestamp);
-
-    renderStreamEvent(parsed, renderState, { verbose });
-
-    if (parsed.type === "session" || parsed.type === "agent_start") {
-      if (timestamp && runStartMs === null) runStartMs = timestamp;
-    }
-
-    if (parsed.type === "turn_start") {
-      beginTurn();
-    }
-
-    if (parsed.type === "turn_end" && parsed.message?.usage) {
-      const usage = parsed.message.usage;
-      runResult.promptTokens += usage.input ?? 0;
-      runResult.completionTokens += usage.output ?? 0;
-      runResult.cacheRead += usage.cacheRead ?? 0;
-      runResult.cacheWrite += usage.cacheWrite ?? 0;
-      endTurn(usage, timestamp);
-    }
-
-    if (parsed.type === "message_update" && parsed.assistantMessageEvent) {
-      const evt = parsed.assistantMessageEvent;
-      const subtype = String(evt.type ?? "").replace(/_/gu, "");
-      if (subtype === "thinkingdelta" || subtype === "textdelta") {
-        appendResponse(evt.delta || "");
-      }
-    }
-
-    if (parsed.type === "message_end" && parsed.message?.role === "assistant") {
-      flushResponse();
-      const content = parsed.message.content ?? [];
-      for (const item of content) {
-        if (item.type === "toolCall") {
-          runResult.toolCalls += 1;
-          appendResponse(`\n${formatToolCall(item)}\n`);
-          const currentTurn = runResult.perTurn[runResult.perTurn.length - 1];
-          if (currentTurn) currentTurn.toolCalls += 1;
-        }
-      }
-    }
-
-    if (parsed.type === "toolResult") {
-      runResult.toolResults += 1;
-      const status = parsed.isError ? "error" : "ok";
-      appendResponse(`\n[toolResult] ${parsed.toolName} (${status})\n`);
-    }
-
-    if (parsed.type === "agent_end") {
-      flushResponse();
-    }
-  }
-
-  child.stdout.setEncoding("utf8");
-  child.stdout.on("data", (chunk) => {
-    streamBuffer += chunk;
-    const lines = streamBuffer.split("\n");
-    streamBuffer = lines.pop();
-    for (const line of lines) {
-      processLine(line);
-    }
-  });
-
-  child.stderr.setEncoding("utf8");
-  child.stderr.on("data", (chunk) => {
-    stderrHandle.write(chunk);
-  });
-
-  const abortListener = () => {
-    if (cancelled) return;
-    cancelled = true;
-    console.log(BENCH_COLORS.error("\n\n[Cancelled by user]"));
-    child.kill("SIGTERM");
-  };
-
-  if (signal) {
-    signal.addEventListener("abort", abortListener);
-  }
-
-  return new Promise((resolve) => {
-    child.on("exit", async (code) => {
-      if (signal) signal.removeEventListener("abort", abortListener);
-      stopExecTimer(renderState);
-      if (streamBuffer.trim()) {
-        processLine(streamBuffer);
-      }
-      flushResponse();
-      await streamHandle.close();
-      await stderrHandle.close();
-      await writeFile(responsePath, runResult.rawResponseLines.join(""), "utf8");
-
-      runResult.exitCode = code ?? 0;
-      if (firstEventMs !== null && lastEventMs !== null) {
-        runResult.wallClockMs = lastEventMs - firstEventMs;
-      }
-
-      if (cancelled) {
-        runResult.error = { message: "Cancelled by user" };
-        resolve(runResult);
-        return;
-      }
-
-      printFinalLine(BENCH_COLORS.info("Pi benchmark finished"));
-
-      if (runResult.exitCode !== 0) {
-        runResult.error = { message: `Pi exited with code ${runResult.exitCode}` };
-        resolve(runResult);
-        return;
-      }
-
-      resolve(runResult);
-    });
-
-    child.on("error", async (err) => {
-      if (signal) signal.removeEventListener("abort", abortListener);
-      stopExecTimer(renderState);
-      await streamHandle.close();
-      await stderrHandle.close();
-      runResult.error = { message: err.message };
-      resolve(runResult);
-    });
-  });
-}
-
-function extractTimestamp(event) {
-  const raw = event?.message?.timestamp ?? event?.timestamp ?? event?.assistantMessageEvent?.partial?.timestamp;
-  if (typeof raw === "number") return raw;
-  if (typeof raw === "string") {
-    const parsed = Date.parse(raw);
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  const iso = event?.message?.createdAt ?? event?.createdAt ?? event?.created_at;
-  if (typeof iso === "string") {
-    const parsed = Date.parse(iso);
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  return null;
-}
-
-async function openFileHandle(path, flags) {
-  const { open } = await import("node:fs/promises");
-  return open(path, flags);
-}