ollanet 0.1.1 → 0.2.0

package/dist/cli.js

@@ -16,6 +16,7 @@ Usage:
   ollanet prompt <machine|ip> [model] <prompt...>
   ollanet prompt --chat <hash> <prompt...>
   ollanet chats [--json] [--id <hash>]
+  ollanet bench <machine|ip> [model...] [--all] [options]
 
 Examples:
   ollanet scan
@@ -24,6 +25,8 @@ Examples:
   ollanet prompt 192.168.1.50 gemma4:12b "Hello"
   ollanet prompt --chat a1b2c3d4e5f6 "Tell me more"
   ollanet chats
+  ollanet bench localhost --all
+  ollanet bench localhost llama3.2:1b --runs 3
 
 Config: ~/.ollanet/config.json when installed, ./config.json in a checkout
         (override with OLLANET_CONFIG)
@@ -68,6 +71,12 @@ async function main() {
             await run();
             return;
         }
+        case "bench":
+        case "benchmark": {
+            const { main: run } = await import("./bench.js");
+            await run();
+            return;
+        }
         default:
             console.error(`Unknown command: ${cmd}\n`);
             process.stderr.write(HELP);

package/dist/config.js

@@ -94,6 +94,9 @@ export function normalizeSettings(input) {
     const numCtx = asFiniteNumber(src.num_ctx ?? src.numCtx);
     if (numCtx != null)
         out.num_ctx = Math.trunc(numCtx);
+    const seed = asFiniteNumber(src.seed);
+    if (seed != null)
+        out.seed = Math.trunc(seed);
     const keepAlive = src.keep_alive ?? src.keepAlive;
     if (typeof keepAlive === "string" && keepAlive.trim()) {
         out.keep_alive = keepAlive.trim();
@@ -196,6 +199,8 @@ export function mergeSettings(...layers) {
             out.num_predict = layer.num_predict;
         if (layer.num_ctx != null)
             out.num_ctx = layer.num_ctx;
+        if (layer.seed != null)
+            out.seed = layer.seed;
         if (layer.keep_alive != null)
             out.keep_alive = layer.keep_alive;
         if (layer.format !== undefined)

package/dist/hosts.js

@@ -108,7 +108,9 @@ function parseHostEntry(entry) {
     const name = (entry.name ?? address).trim();
     return makeHost({
         hostname: name,
-        dnsName: address.includes(".") ? address : "",
+        // An IPv4 literal is not a DNS name; treating it as one makes shortName()
+        // return the first octet ("192") instead of the configured name.
+        dnsName: !/^\d{1,3}(\.\d{1,3}){3}$/.test(address) && address.includes(".") ? address : "",
         ip: address,
         source: "config",
         online: true,

package/dist/ollama-chat.js

@@ -0,0 +1,307 @@
+function buildOptions(settings) {
+    const options = {};
+    if (settings.temperature != null)
+        options.temperature = settings.temperature;
+    if (settings.num_predict != null)
+        options.num_predict = settings.num_predict;
+    if (settings.num_ctx != null)
+        options.num_ctx = settings.num_ctx;
+    if (settings.seed != null)
+        options.seed = settings.seed;
+    return options;
+}
+function parseChunk(url, raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Non-JSON response from ${url} (is something else on this port?): ${raw.slice(0, 120)}`);
+    }
+}
+/** POST /api/chat with optional streaming and AbortSignal timeout. */
+export async function ollamaChat(opts) {
+    const url = `${opts.baseUrl}/api/chat`;
+    // Default think:false — thinking models otherwise burn num_predict on hidden reasoning.
+    const think = opts.settings.think === true;
+    const body = {
+        model: opts.model,
+        messages: opts.messages,
+        stream: opts.stream,
+        think,
+    };
+    if (opts.settings.keep_alive != null)
+        body.keep_alive = opts.settings.keep_alive;
+    if (opts.settings.format !== undefined)
+        body.format = opts.settings.format;
+    const options = buildOptions(opts.settings);
+    if (Object.keys(options).length > 0)
+        body.options = options;
+    const controller = new AbortController();
+    const timer = opts.timeoutMs > 0 ? setTimeout(() => controller.abort(), opts.timeoutMs) : undefined;
+    let res;
+    try {
+        res = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Accept: "application/json" },
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+    }
+    catch (err) {
+        if (timer)
+            clearTimeout(timer);
+        const name = err instanceof Error ? err.name : "";
+        if (name === "AbortError") {
+            throw new Error(`Prompt timed out after ${opts.timeoutMs}ms (${url})`);
+        }
+        throw err;
+    }
+    if (!res.ok) {
+        if (timer)
+            clearTimeout(timer);
+        const text = await res.text().catch(() => "");
+        throw new Error(`Ollama HTTP ${res.status} ${res.statusText}${text ? `: ${text}` : ""}`);
+    }
+    try {
+        if (!opts.stream) {
+            const chunk = parseChunk(url, await res.text());
+            if (chunk.error)
+                throw new Error(chunk.error);
+            const content = chunk.message?.content ?? "";
+            const thinking = chunk.message?.thinking ?? "";
+            if (opts.writeStdout) {
+                if (think && thinking) {
+                    process.stderr.write(`${thinking}\n---\n`);
+                }
+                const visible = content || thinking;
+                if (visible)
+                    process.stdout.write(`${visible}\n`);
+            }
+            return { content: content || thinking, thinking, chunk };
+        }
+        if (!res.body)
+            throw new Error("No response body from Ollama");
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let last = {};
+        let content = "";
+        let thinking = "";
+        let thinkingHeader = false;
+        const handleChunk = (chunk) => {
+            if (chunk.error)
+                throw new Error(chunk.error);
+            const thinkPiece = chunk.message?.thinking ?? "";
+            const contentPiece = chunk.message?.content ?? "";
+            if (thinkPiece) {
+                thinking += thinkPiece;
+                if (opts.writeStdout && think) {
+                    if (!thinkingHeader) {
+                        process.stderr.write("[thinking]\n");
+                        thinkingHeader = true;
+                    }
+                    process.stderr.write(thinkPiece);
+                }
+            }
+            if (contentPiece) {
+                content += contentPiece;
+                if (opts.writeStdout) {
+                    if (thinkingHeader) {
+                        process.stderr.write("\n---\n");
+                        thinkingHeader = false;
+                    }
+                    process.stdout.write(contentPiece);
+                }
+            }
+            last = chunk;
+        };
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                handleChunk(parseChunk(url, trimmed));
+            }
+        }
+        const trailing = buffer.trim();
+        if (trailing) {
+            handleChunk(parseChunk(url, trailing));
+        }
+        if (opts.writeStdout && !content && thinking) {
+            if (think)
+                process.stderr.write("\n---\n");
+            process.stdout.write(`${thinking}\n`);
+        }
+        else if (opts.writeStdout && content.length > 0 && !content.endsWith("\n")) {
+            process.stdout.write("\n");
+        }
+        return { content: content || thinking, thinking, chunk: last };
+    }
+    catch (err) {
+        const name = err instanceof Error ? err.name : "";
+        if (name === "AbortError") {
+            throw new Error(`Prompt timed out after ${opts.timeoutMs}ms (${url})`);
+        }
+        throw err;
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+export async function ollamaTags(baseUrl, timeoutMs) {
+    const url = `${baseUrl}/api/tags`;
+    const body = await ollamaGetJson(url, timeoutMs);
+    return body.models ?? [];
+}
+export async function ollamaShow(baseUrl, model, timeoutMs) {
+    const url = `${baseUrl}/api/show`;
+    return ollamaPostJson(url, { model }, timeoutMs);
+}
+export async function ollamaVersion(baseUrl, timeoutMs) {
+    try {
+        const body = await ollamaGetJson(`${baseUrl}/api/version`, timeoutMs);
+        return body.version;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function ollamaPs(baseUrl, timeoutMs) {
+    try {
+        const body = await ollamaGetJson(`${baseUrl}/api/ps`, timeoutMs);
+        return body.models ?? [];
+    }
+    catch {
+        return [];
+    }
+}
+function modelKey(name) {
+    return name.trim().toLowerCase();
+}
+export function psHasModel(models, name) {
+    const key = modelKey(name);
+    return models.some((m) => {
+        const n = (m.name ?? m.model ?? "").toLowerCase();
+        return n === key || n.startsWith(`${key}:`) || key.startsWith(`${n}:`);
+    });
+}
+function findPsModel(models, name) {
+    const key = modelKey(name);
+    return models.find((m) => {
+        const n = (m.name ?? m.model ?? "").toLowerCase();
+        return n === key || n.startsWith(`${key}:`) || key.startsWith(`${n}:`);
+    });
+}
+export function vramForModel(models, name) {
+    return findPsModel(models, name)?.size_vram;
+}
+export function contextLengthForModel(models, name) {
+    return findPsModel(models, name)?.context_length;
+}
+/**
+ * Capability filter: omitempty / empty means "unknown → treat as completion".
+ * Only skip when a non-empty capabilities array is present and lacks completion.
+ */
+export function isCompletionCapable(capabilities) {
+    if (capabilities == null || capabilities.length === 0)
+        return true;
+    return capabilities.includes("completion");
+}
+/**
+ * Vision-capable models (moondream, llava, …) often fail a text-only suite.
+ * Only true when capabilities are present and include vision — absent/empty → false
+ * (don't skip unknown older servers).
+ */
+export function isVisionCapable(capabilities) {
+    if (capabilities == null || capabilities.length === 0)
+        return false;
+    return capabilities.includes("vision");
+}
+/** True when capabilities are known and lack thinking (absent/empty → no warning). */
+export function shouldWarnNoThinking(capabilities) {
+    if (capabilities == null || capabilities.length === 0)
+        return false;
+    return !capabilities.includes("thinking");
+}
+/** Poll /api/ps until model is absent (or timeout). Returns elapsed ms. */
+export async function waitUntilUnloaded(baseUrl, model, timeoutMs, pollMs = 200) {
+    const started = Date.now();
+    while (Date.now() - started < timeoutMs) {
+        const models = await ollamaPs(baseUrl, Math.min(5000, timeoutMs));
+        if (!psHasModel(models, model)) {
+            return { unloaded: true, waitedMs: Date.now() - started };
+        }
+        await new Promise((r) => setTimeout(r, pollMs));
+    }
+    return { unloaded: false, waitedMs: Date.now() - started };
+}
+/** Request unload via keep_alive: 0 (no-op-ish if already unloaded after a short chat). */
+export async function ollamaUnload(baseUrl, model, timeoutMs) {
+    await ollamaChat({
+        baseUrl,
+        model,
+        messages: [{ role: "user", content: "ping" }],
+        stream: false,
+        writeStdout: false,
+        timeoutMs,
+        settings: { keep_alive: 0, num_predict: 1, think: false },
+    });
+}
+async function ollamaGetJson(url, timeoutMs) {
+    const controller = new AbortController();
+    const timer = timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : undefined;
+    try {
+        const res = await fetch(url, {
+            headers: { Accept: "application/json" },
+            signal: controller.signal,
+        });
+        if (!res.ok) {
+            throw new Error(`Ollama HTTP ${res.status} ${res.statusText} (${url})`);
+        }
+        const text = await res.text();
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            throw new Error(`Non-JSON response from ${url} (is something else on this port?): ${text.slice(0, 120)}`);
+        }
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+async function ollamaPostJson(url, body, timeoutMs) {
+    const controller = new AbortController();
+    const timer = timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : undefined;
+    try {
+        const res = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Accept: "application/json" },
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            throw new Error(`Ollama HTTP ${res.status} ${res.statusText}${text ? `: ${text}` : ""} (${url})`);
+        }
+        const text = await res.text();
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            throw new Error(`Non-JSON response from ${url} (is something else on this port?): ${text.slice(0, 120)}`);
+        }
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}

package/dist/paths.js

@@ -22,3 +22,7 @@ export function defaultConfigPath() {
 export function defaultResponsesDir() {
     return IS_INSTALLED ? path.join(USER_DIR, "responses") : projectPath("responses");
 }
+/** Default benchmark results dir (mirrors responses layout). */
+export function defaultBenchmarksDir() {
+    return IS_INSTALLED ? path.join(USER_DIR, "benchmarks") : projectPath("benchmarks");
+}

package/dist/prompt.js

@@ -16,6 +16,7 @@ import { stdin as stdinStream } from "node:process";
 import { appendMessage, cleanTopic, createChat, loadChat, saveChat, toApiMessages, topicFromPrompt, } from "./chat-store.js";
 import { configPath, defaultModelForHost, loadConfig, machineSettingsForHost, mergeSettings, parseFormat, settingsFromEnv, settingsSummary, } from "./config.js";
 import { discoverHosts, envInt, findDiscoveredHost, ollamaBaseUrl, resolveHost, shortName, } from "./hosts.js";
+import { ollamaChat } from "./ollama-chat.js";
 /** Prompt/chat HTTP timeout (ms). 0 = no timeout. Separate from scan's OLLAMA_TIMEOUT_MS. */
 const PROMPT_TIMEOUT_MS = envInt("OLLAMA_PROMPT_TIMEOUT_MS", 600_000);
 function usage() {
@@ -269,169 +270,15 @@ async function readStdinIfPiped() {
     }
     return Buffer.concat(chunks).toString("utf8").trim();
 }
-function buildOptions(settings) {
-    const options = {};
-    if (settings.temperature != null)
-        options.temperature = settings.temperature;
-    if (settings.num_predict != null)
-        options.num_predict = settings.num_predict;
-    if (settings.num_ctx != null)
-        options.num_ctx = settings.num_ctx;
-    return options;
-}
-async function runChat(opts) {
-    const url = `${opts.baseUrl}/api/chat`;
-    // Default think:false — thinking models otherwise burn num_predict on hidden reasoning.
-    const think = opts.settings.think === true;
-    const body = {
-        model: opts.model,
-        messages: opts.messages,
-        stream: opts.stream,
-        think,
-    };
-    if (opts.settings.keep_alive != null)
-        body.keep_alive = opts.settings.keep_alive;
-    if (opts.settings.format !== undefined)
-        body.format = opts.settings.format;
-    const options = buildOptions(opts.settings);
-    if (Object.keys(options).length > 0)
-        body.options = options;
-    const controller = new AbortController();
-    const timer = PROMPT_TIMEOUT_MS > 0 ? setTimeout(() => controller.abort(), PROMPT_TIMEOUT_MS) : undefined;
-    let res;
-    try {
-        res = await fetch(url, {
-            method: "POST",
-            headers: { "Content-Type": "application/json", Accept: "application/json" },
-            body: JSON.stringify(body),
-            signal: controller.signal,
-        });
-    }
-    catch (err) {
-        if (timer)
-            clearTimeout(timer);
-        const name = err instanceof Error ? err.name : "";
-        if (name === "AbortError") {
-            throw new Error(`Prompt timed out after ${PROMPT_TIMEOUT_MS}ms (${url})`);
-        }
-        throw err;
-    }
-    if (!res.ok) {
-        if (timer)
-            clearTimeout(timer);
-        const text = await res.text().catch(() => "");
-        throw new Error(`Ollama HTTP ${res.status} ${res.statusText}${text ? `: ${text}` : ""}`);
-    }
-    const parseChunk = (raw) => {
-        try {
-            return JSON.parse(raw);
-        }
-        catch {
-            throw new Error(`Non-JSON response from ${url} (is something else on this port?): ${raw.slice(0, 120)}`);
-        }
-    };
-    try {
-        if (!opts.stream) {
-            const chunk = parseChunk(await res.text());
-            if (chunk.error)
-                throw new Error(chunk.error);
-            const content = chunk.message?.content ?? "";
-            const thinking = chunk.message?.thinking ?? "";
-            if (opts.writeStdout) {
-                if (think && thinking) {
-                    process.stderr.write(`${thinking}\n---\n`);
-                }
-                const visible = content || thinking;
-                if (visible)
-                    process.stdout.write(`${visible}\n`);
-            }
-            return { content: content || thinking, thinking, chunk };
-        }
-        if (!res.body)
-            throw new Error("No response body from Ollama");
-        const reader = res.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = "";
-        let last = {};
-        let content = "";
-        let thinking = "";
-        let thinkingHeader = false;
-        const handleChunk = (chunk) => {
-            if (chunk.error)
-                throw new Error(chunk.error);
-            const thinkPiece = chunk.message?.thinking ?? "";
-            const contentPiece = chunk.message?.content ?? "";
-            if (thinkPiece) {
-                thinking += thinkPiece;
-                if (opts.writeStdout && think) {
-                    if (!thinkingHeader) {
-                        process.stderr.write("[thinking]\n");
-                        thinkingHeader = true;
-                    }
-                    process.stderr.write(thinkPiece);
-                }
-            }
-            if (contentPiece) {
-                content += contentPiece;
-                if (opts.writeStdout) {
-                    if (thinkingHeader) {
-                        process.stderr.write("\n---\n");
-                        thinkingHeader = false;
-                    }
-                    process.stdout.write(contentPiece);
-                }
-            }
-            last = chunk;
-        };
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            buffer += decoder.decode(value, { stream: true });
-            const lines = buffer.split("\n");
-            buffer = lines.pop() ?? "";
-            for (const line of lines) {
-                const trimmed = line.trim();
-                if (!trimmed)
-                    continue;
-                handleChunk(parseChunk(trimmed));
-            }
-        }
-        const trailing = buffer.trim();
-        if (trailing) {
-            handleChunk(parseChunk(trailing));
-        }
-        // If the model only emitted thinking (budget exhausted), surface it on stdout.
-        if (opts.writeStdout && !content && thinking) {
-            if (think)
-                process.stderr.write("\n---\n");
-            process.stdout.write(`${thinking}\n`);
-        }
-        else if (opts.writeStdout && content.length > 0 && !content.endsWith("\n")) {
-            process.stdout.write("\n");
-        }
-        return { content: content || thinking, thinking, chunk: last };
-    }
-    catch (err) {
-        const name = err instanceof Error ? err.name : "";
-        if (name === "AbortError") {
-            throw new Error(`Prompt timed out after ${PROMPT_TIMEOUT_MS}ms (${url})`);
-        }
-        throw err;
-    }
-    finally {
-        if (timer)
-            clearTimeout(timer);
-    }
-}
 async function generateTopic(opts) {
     const fallback = topicFromPrompt(opts.prompt);
     try {
-        const { content } = await runChat({
+        const { content } = await ollamaChat({
             baseUrl: opts.baseUrl,
             model: opts.model,
             stream: false,
             writeStdout: false,
+            timeoutMs: PROMPT_TIMEOUT_MS,
             settings: mergeSettings(opts.settings, {
                 temperature: 0.2,
                 num_predict: 24,
@@ -550,12 +397,13 @@ export async function main() {
         const chatTag = parsed.chatId ? `  chat=${chat.id}` : "";
         console.error(`→ ${shortName(host)} (${host.ip})  model=${model}  [${src}]${chatTag}${extras ? `  ${extras}` : ""}`);
     }
-    const { content, thinking, chunk } = await runChat({
+    const { content, thinking, chunk } = await ollamaChat({
         baseUrl,
         model,
         messages: toApiMessages(chat),
         stream: json ? false : stream,
         writeStdout: !json,
+        timeoutMs: PROMPT_TIMEOUT_MS,
         settings,
     });
     appendMessage(chat, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ollanet",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Chat with Ollama servers on any reachable network — scan hosts, prompt models, continue chats by hash",
   "type": "module",
   "bin": {
@@ -18,8 +18,11 @@
     "scan": "tsx src/cli.ts scan",
     "prompt": "tsx src/cli.ts prompt",
     "chats": "tsx src/cli.ts chats",
+    "bench": "tsx src/cli.ts bench",
     "start": "tsx src/cli.ts scan",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "tsc -p tsconfig.build.json && node --test test/*.test.mjs",
+    "test:only": "node --test test/*.test.mjs"
   },
   "keywords": [
     "ollama",