open-agents-ai 0.103.71 → 0.103.73

package/dist/index.js

@@ -26934,6 +26934,8 @@ function renderSlashHelp() {
     ["/endpoint <url>", "Set backend URL (auto-detects type)"],
     ["/endpoint <url> --auth <t>", "Set endpoint with Bearer auth"],
     ["/config", "Show current configuration"],
+    ["/parallel", "Show current Ollama parallel inference slots"],
+    ["/parallel <1-15>", "Set parallel slots (restarts Ollama, max 15)"],
     ["/update", "Check for updates and auto-install"],
     ["/update auto", "Enable auto-update after task completion (default)"],
     ["/update manual", "Disable auto-update (only update on /update)"],
@@ -34092,6 +34094,9 @@ async function handleSlashCommand(input, ctx) {
     case "ep":
       await handleEndpoint(arg, ctx, hasLocal);
       return "handled";
+    case "parallel":
+      await handleParallel(arg, ctx);
+      return "handled";
     case "update":
     case "upgrade":
       await handleUpdate(arg, ctx);
@@ -35515,6 +35520,137 @@ async function handlePeerEndpoint(peerId, authKey, ctx, local) {
     renderWarning("Active task aborted \u2014 endpoint changed. Send a new prompt to continue.");
   }
 }
+async function handleParallel(arg, ctx) {
+  const { execSync: execSync29 } = await import("node:child_process");
+  const baseUrl = ctx.config.backendUrl || "http://localhost:11434";
+  const isRemote = ctx.config.backendType === "nexus";
+  if (isRemote) {
+    renderInfo("Parallel slots are configured on the remote provider's Ollama, not locally.");
+    renderInfo("The remote provider controls OLLAMA_NUM_PARALLEL on their end.");
+    return;
+  }
+  if (!arg) {
+    const envVal = process.env.OLLAMA_NUM_PARALLEL;
+    let runningInfo = "";
+    try {
+      const psResp = await fetch(baseUrl + "/api/ps", { signal: AbortSignal.timeout(3e3) });
+      if (psResp.ok) {
+        const ps = await psResp.json();
+        const models = ps.models || [];
+        if (models.length > 0) {
+          runningInfo = models.map((m) => `    ${c2.cyan(m.name)} \u2014 ${m.size_vram ? (m.size_vram / 1e9).toFixed(1) + " GB VRAM" : "CPU"}`).join("\n");
+        }
+      }
+    } catch {
+    }
+    let systemdVal = "";
+    try {
+      const out = execSync29("systemctl show ollama.service -p Environment 2>/dev/null || true", { encoding: "utf8" });
+      const match = out.match(/OLLAMA_NUM_PARALLEL=(\d+)/);
+      if (match)
+        systemdVal = match[1];
+    } catch {
+    }
+    const effective = envVal || systemdVal || "1 (default)";
+    console.log("");
+    console.log(`  ${c2.bold("Parallel Inference Slots")}`);
+    console.log("");
+    console.log(`  ${c2.dim("OLLAMA_NUM_PARALLEL:")} ${c2.bold(c2.cyan(effective))}`);
+    console.log(`  ${c2.dim("Endpoint:")} ${baseUrl}`);
+    if (runningInfo) {
+      console.log(`  ${c2.dim("Running models:")}`);
+      console.log(runningInfo);
+    }
+    console.log("");
+    console.log(`  ${c2.dim("Set with:")} ${c2.cyan("/parallel <1-15>")}`);
+    console.log(`  ${c2.dim("Each slot multiplies context memory usage per model.")}`);
+    console.log("");
+    return;
+  }
+  const n = parseInt(arg, 10);
+  if (isNaN(n) || n < 1 || n > 15) {
+    renderError("Parallel slots must be between 1 and 15. Usage: /parallel <1-15>");
+    return;
+  }
+  const isSystemd = (() => {
+    try {
+      const out = execSync29("systemctl is-active ollama.service 2>/dev/null", { encoding: "utf8" }).trim();
+      return out === "active" || out === "inactive";
+    } catch {
+      return false;
+    }
+  })();
+  if (isSystemd) {
+    renderInfo(`Setting OLLAMA_NUM_PARALLEL=${n} via systemd override...`);
+    try {
+      const overrideDir = "/etc/systemd/system/ollama.service.d";
+      const overrideFile = `${overrideDir}/parallel.conf`;
+      const overrideContent = `[Service]
+Environment="OLLAMA_NUM_PARALLEL=${n}"
+`;
+      execSync29(`sudo mkdir -p ${overrideDir}`, { stdio: "pipe" });
+      execSync29(`echo '${overrideContent}' | sudo tee ${overrideFile} > /dev/null`, { stdio: "pipe" });
+      execSync29("sudo systemctl daemon-reload", { stdio: "pipe" });
+      execSync29("sudo systemctl restart ollama.service", { stdio: "pipe" });
+      let ready = false;
+      for (let i = 0; i < 30 && !ready; i++) {
+        await new Promise((r) => setTimeout(r, 500));
+        try {
+          const resp = await fetch(baseUrl + "/api/tags", { signal: AbortSignal.timeout(2e3) });
+          if (resp.ok)
+            ready = true;
+        } catch {
+        }
+      }
+      if (ready) {
+        renderInfo(`Ollama restarted with OLLAMA_NUM_PARALLEL=${n}. ${n > 4 ? "Note: memory usage scales with parallel slots." : ""}`);
+      } else {
+        renderWarning(`Ollama service restarted but not responding yet. Check: sudo systemctl status ollama`);
+      }
+    } catch (e) {
+      renderError(`Failed to set systemd override: ${e.message || e}`);
+      renderInfo(`Manual steps:
+  sudo mkdir -p /etc/systemd/system/ollama.service.d
+  echo '[Service]\\nEnvironment="OLLAMA_NUM_PARALLEL=${n}"' | sudo tee /etc/systemd/system/ollama.service.d/parallel.conf
+  sudo systemctl daemon-reload && sudo systemctl restart ollama`);
+    }
+  } else {
+    renderInfo(`Setting OLLAMA_NUM_PARALLEL=${n}...`);
+    try {
+      try {
+        execSync29("pkill -f 'ollama serve' 2>/dev/null || true", { stdio: "pipe" });
+      } catch {
+      }
+      await new Promise((r) => setTimeout(r, 1e3));
+      process.env.OLLAMA_NUM_PARALLEL = String(n);
+      const { spawn: spawn19 } = await import("node:child_process");
+      const child = spawn19("ollama", ["serve"], {
+        stdio: "ignore",
+        detached: true,
+        env: { ...process.env, OLLAMA_NUM_PARALLEL: String(n) }
+      });
+      child.unref();
+      let ready = false;
+      for (let i = 0; i < 30 && !ready; i++) {
+        await new Promise((r) => setTimeout(r, 500));
+        try {
+          const resp = await fetch(baseUrl + "/api/tags", { signal: AbortSignal.timeout(2e3) });
+          if (resp.ok)
+            ready = true;
+        } catch {
+        }
+      }
+      if (ready) {
+        renderInfo(`Ollama restarted with OLLAMA_NUM_PARALLEL=${n}. ${n > 4 ? "Note: memory usage scales with parallel slots." : ""}`);
+      } else {
+        renderWarning(`Ollama restarted but not responding yet. Try: OLLAMA_NUM_PARALLEL=${n} ollama serve`);
+      }
+    } catch (e) {
+      renderError(`Failed to restart Ollama: ${e.message || e}`);
+      renderInfo(`Set manually: OLLAMA_NUM_PARALLEL=${n} ollama serve`);
+    }
+  }
+}
 async function handleUpdate(subcommand, ctx) {
   const repoRoot = ctx.repoRoot;
   if (subcommand === "auto") {
@@ -46730,6 +46866,7 @@ ${entry.fullContent}`
           "ep",
           "update",
           "upgrade",
+          "parallel",
           "telegram",
           "tg",
           "call",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.103.71",
+  "version": "0.103.73",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",