ollanet 0.1.0 → 0.1.1

package/README.md

@@ -6,7 +6,7 @@ Scan for models, fire prompts, and continue conversations later by a short hash.
 
 ## Origin
 
-This started as a selfish little script. I had Ollama running on a laptop on my Tailscale network and wanted an easy way to discover it, poke at the models, and actually talk to them from another machine — without babysitting IPs or opening a browser. One scan/prompt tool later, chats by hash showed up, LAN discovery crept in, and the thing grew into **ollanet**: a tiny CLI for using Ollama over whatever network you already have.
+This started as a personal little script. I had Ollama running on a laptop on my Tailscale network and wanted an easy way to discover it, poke at the models, and actually talk to them from another machine — without babysitting IPs or opening a browser. One scan/prompt tool later, chats by hash showed up, LAN discovery crept in, and the thing grew into **ollanet**: a tiny CLI for using Ollama over whatever network you already have.
 
 ## Related: Finetuna
 
@@ -127,6 +127,7 @@ ollanet prompt --chat <hash> <prompt...>
 | `--num-ctx <n>` | Context window |
 | `--keep-alive <value>` | Keep model loaded (`5m`, `0`, `-1`, …) |
 | `--format json\|<schema>` | JSON mode / schema |
+| `--think` / `--no-think` | Enable/disable model thinking (default **off** so replies aren’t empty on qwen3-style models) |
 | `--no-stream` | Buffer the full reply |
 | `--no-save` | Do not write a transcript |
 | `--json` | Emit JSON (includes chat id when saved) |
@@ -174,7 +175,8 @@ Edit `~/.ollanet/config.json` (installed) or `config.json` (checkout) — or poi
   "defaults": {
     "temperature": 0.7,
     "num_predict": 512,
-    "keep_alive": "5m"
+    "keep_alive": "5m",
+    "think": false
   },
   "machineDefaults": {
     "studio": { "num_ctx": 16384 }
@@ -200,7 +202,9 @@ Edit `~/.ollanet/config.json` (installed) or `config.json` (checkout) — or poi
 | `OLLAMA_KEEP_ALIVE` | Default keep-alive |
 | `OLLAMA_FORMAT` | Default format (`json` or schema JSON) |
 | `OLLAMA_SYSTEM` | Default system prompt |
+| `OLLANET_THINK` / `OLLAMA_THINK` | Enable thinking (`true`/`false`; default off) |
 | `OLLAMA_TIMEOUT_MS` | HTTP scan/probe timeout |
+| `OLLAMA_PROMPT_TIMEOUT_MS` | Prompt/chat HTTP timeout (default `600000`; `0` = none) |
 | `OLLAMA_CONCURRENCY` | Scan concurrency |
 
 ## Chat transcripts

package/dist/config.js

@@ -107,6 +107,16 @@ export function normalizeSettings(input) {
     if (typeof src.system === "string" && src.system.trim()) {
         out.system = src.system;
     }
+    const think = src.think;
+    if (typeof think === "boolean")
+        out.think = think;
+    else if (typeof think === "string") {
+        const v = think.trim().toLowerCase();
+        if (["1", "true", "yes", "on"].includes(v))
+            out.think = true;
+        if (["0", "false", "no", "off"].includes(v))
+            out.think = false;
+    }
     return out;
 }
 function asFiniteNumber(value) {
@@ -192,6 +202,8 @@ export function mergeSettings(...layers) {
             out.format = layer.format;
         if (layer.system != null)
             out.system = layer.system;
+        if (layer.think != null)
+            out.think = layer.think;
     }
     return out;
 }
@@ -203,6 +215,7 @@ export function settingsFromEnv() {
         keep_alive: process.env.OLLAMA_KEEP_ALIVE,
         format: process.env.OLLAMA_FORMAT,
         system: process.env.OLLAMA_SYSTEM,
+        think: process.env.OLLANET_THINK ?? process.env.OLLAMA_THINK,
     });
 }
 export function settingsSummary(settings) {
@@ -218,6 +231,10 @@ export function settingsSummary(settings) {
     if (settings.format !== undefined) {
         parts.push(settings.format === "json" ? "format=json" : "format=<schema>");
     }
+    if (settings.think === true)
+        parts.push("think=on");
+    if (settings.think === false)
+        parts.push("think=off");
     return parts.join(" ");
 }
 export function configPath() {

package/dist/hosts.js

@@ -3,7 +3,18 @@ import net from "node:net";
 import os from "node:os";
 import { promisify } from "node:util";
 const execFileAsync = promisify(execFile);
-export const OLLAMA_PORT = Number(process.env.OLLAMA_PORT ?? 11434);
+/** Parse a required numeric env var; invalid values throw instead of becoming NaN. */
+export function envInt(name, fallback) {
+    const raw = process.env[name];
+    if (raw == null || String(raw).trim() === "")
+        return fallback;
+    const n = Number(raw);
+    if (!Number.isFinite(n)) {
+        throw new Error(`Invalid ${name}="${raw}" (expected a number)`);
+    }
+    return Math.trunc(n);
+}
+export const OLLAMA_PORT = envInt("OLLAMA_PORT", 11434);
 function cleanDnsName(dnsName) {
     if (!dnsName)
         return "";
@@ -242,8 +253,8 @@ async function tcpOpen(ip, port, timeoutMs) {
     });
 }
 async function lanScanTargets(cidrs, port) {
-    const timeoutMs = Number(process.env.OLLANET_LAN_TIMEOUT_MS ?? 200);
-    const concurrency = Number(process.env.OLLANET_LAN_CONCURRENCY ?? 64);
+    const timeoutMs = envInt("OLLANET_LAN_TIMEOUT_MS", 200);
+    const concurrency = Math.max(1, envInt("OLLANET_LAN_CONCURRENCY", 64));
     const ips = [...new Set(cidrs.flatMap((cidr) => cidrToIps(cidr)))];
     if (ips.length === 0)
         return [];
@@ -261,15 +272,21 @@ async function lanScanTargets(cidrs, port) {
         port,
     }));
 }
+/**
+ * True for IPs, FQDNs, and host:port — not bare words.
+ * Bare words must match a discovered host so typos get a helpful error.
+ */
 function looksLikeAddress(query) {
     const q = query.trim();
-    if (!q)
+    if (!q || /\s/.test(q))
         return false;
-    if (/^\d{1,3}(\.\d{1,3}){3}$/.test(q))
+    if (/^\d{1,3}(\.\d{1,3}){3}(:\d+)?$/.test(q))
+        return true;
+    if (/^\[[0-9a-f:]+\](:\d+)?$/i.test(q))
         return true;
-    if (q.includes(":") && !q.includes(" "))
-        return true; // hostname:port or ipv6-ish
-    if (/^[a-z0-9][a-z0-9._-]*$/i.test(q))
+    if (/^[a-z0-9][a-z0-9._-]*:\d+$/i.test(q))
+        return true;
+    if (q.includes(".") && /^[a-z0-9][a-z0-9.-]+$/i.test(q))
         return true;
     return false;
 }
@@ -286,16 +303,23 @@ function parseDirectAddress(query) {
         hostname = ip;
         port = Number(ipv4WithPort[2]);
     }
-    else if (!q.includes("://") && q.includes(".") === false && q.includes(":")) {
-        // host:port without dots (rare) — skip to avoid mangling IPv6
-    }
     else {
+        // host:port with or without dots. Requires a single colon + numeric port so
+        // bare IPv6 (multiple colons) is left alone.
         const hostPort = q.match(/^([a-z0-9][a-z0-9._-]*):(\d+)$/i);
         if (hostPort) {
             hostname = hostPort[1];
             ip = hostname;
             port = Number(hostPort[2]);
         }
+        else {
+            const bracketed = q.match(/^\[([0-9a-f:]+)\]:(\d+)$/i);
+            if (bracketed) {
+                ip = bracketed[1];
+                hostname = ip;
+                port = Number(bracketed[2]);
+            }
+        }
     }
     return makeHost({
         hostname,
@@ -358,16 +382,30 @@ export async function discoverHosts(opts = {}) {
                 : sources.join("+") || "local");
     return { hosts, sources, networkLabel };
 }
+function hostNameMatches(host, q) {
+    const names = [host.hostname, host.dnsName, shortName(host), host.ip].map((n) => n.toLowerCase());
+    return names.includes(q) || names.some((n) => n.startsWith(`${q}.`));
+}
+/**
+ * Match a query against already-discovered hosts only (no direct-address fallback).
+ * Used when peeling an optional leading hostname before a prompt.
+ */
+export function findDiscoveredHost(targets, query) {
+    const q = query.trim().toLowerCase().replace(/\.$/, "");
+    if (!q)
+        return undefined;
+    const matches = targets.filter((host) => hostNameMatches(host, q));
+    if (matches.length === 1)
+        return matches[0];
+    return undefined;
+}
 /** Resolve a machine name against discovered hosts, or treat it as a direct address. */
 export function resolveHost(targets, query) {
     const q = query.trim().toLowerCase().replace(/\.$/, "");
     if (!q) {
         throw new Error("Machine name is empty.");
     }
-    const matches = targets.filter((host) => {
-        const names = [host.hostname, host.dnsName, shortName(host), host.ip].map((n) => n.toLowerCase());
-        return names.includes(q) || names.some((n) => n.startsWith(`${q}.`));
-    });
+    const matches = targets.filter((host) => hostNameMatches(host, q));
     if (matches.length === 1)
         return matches[0];
     if (matches.length > 1) {

package/dist/prompt.js

@@ -3,7 +3,7 @@
  * Run a prompt / continue a chat against an Ollama server on the network.
  *
  * New chat (saved by default):
- *   ollanet prompt mycroftone "What is Tailscale?"
+ *   ollanet prompt localhost "What is Tailscale?"
  *   ollanet prompt 192.168.1.50 "Hello"
  *
  * Continue:
@@ -15,7 +15,9 @@
 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, ollamaBaseUrl, resolveHost, shortName, } from "./hosts.js";
+import { discoverHosts, envInt, findDiscoveredHost, ollamaBaseUrl, resolveHost, shortName, } from "./hosts.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() {
     console.error(`Usage:
   ollanet prompt <machine> [model] <prompt...>
@@ -23,9 +25,9 @@ function usage() {
   ollanet prompt <machine> --chat <hash> <prompt...>
 
 Examples:
-  ollanet prompt mycroftone "Explain MagicDNS"
+  ollanet prompt localhost "Explain MagicDNS"
   ollanet prompt --chat a1b2c3d4e5f6 "Give an example"
-  ollanet prompt mycroftone --temperature 0.2 --num-predict 64 "2+2?"
+  ollanet prompt localhost --temperature 0.2 --num-predict 64 "2+2?"
   ollanet chats
 
 Each reply is saved under responses/<hash>.json and the hash is printed so you
@@ -45,12 +47,72 @@ Options:
   --num-ctx <n>          Context window size
   --keep-alive <value>   Keep model loaded (e.g. 5m, 0, -1)
   --format <json|schema> Force JSON mode or a JSON schema string
+  --think                Enable model thinking (qwen3 etc.); streams to stderr
+  --no-think             Disable thinking (default) so tokens go to the reply
   --no-stream            Wait for the full response
   --json                 Emit final response JSON (implies --no-stream)`);
     process.exit(1);
 }
+/**
+ * Heuristic for an optional positional model token.
+ * Rejects whitespace (so quoted prompts with ":" stay prompts) and URL schemes.
+ * Confirmed against the host's /api/tags before peeling.
+ */
 function looksLikeModel(value) {
-    return value.includes(":") || value.includes("/");
+    const v = value.trim();
+    if (!v || /\s/.test(v))
+        return false;
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(v))
+        return false;
+    return /^[a-z0-9][a-z0-9._-]*([/:@][a-z0-9._-]+)+$/i.test(v);
+}
+function modelNameMatches(available, candidate) {
+    const c = candidate.toLowerCase();
+    return available.some((name) => {
+        const n = name.toLowerCase();
+        return n === c || n.startsWith(`${c}:`) || c.startsWith(`${n}:`);
+    });
+}
+async function listModelNames(host) {
+    const url = `${ollamaBaseUrl(host)}/api/tags`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), Math.min(PROMPT_TIMEOUT_MS || 2500, 5000));
+    try {
+        const res = await fetch(url, {
+            signal: controller.signal,
+            headers: { Accept: "application/json" },
+        });
+        if (!res.ok)
+            return null;
+        const body = (await res.json());
+        return (body.models ?? []).map((m) => m.name).filter((n) => Boolean(n));
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** Peel a leading model token only when it looks like one and exists on the host. */
+async function maybePeelModel(host, promptParts, fromStdin) {
+    if (promptParts.length === 0)
+        return { promptParts };
+    const candidate = promptParts[0];
+    if (!looksLikeModel(candidate))
+        return { promptParts };
+    const names = await listModelNames(host);
+    if (names) {
+        if (modelNameMatches(names, candidate)) {
+            return { model: candidate, promptParts: promptParts.slice(1) };
+        }
+        return { promptParts };
+    }
+    // Tags unavailable: only peel when something remains for the prompt body.
+    if (promptParts.length > 1 || fromStdin) {
+        return { model: candidate, promptParts: promptParts.slice(1) };
+    }
+    return { promptParts };
 }
 function takeValue(args, flag) {
     const value = args.shift();
@@ -97,6 +159,14 @@ function parseArgs(argv) {
             save = false;
             continue;
         }
+        if (arg === "--think") {
+            settings.think = true;
+            continue;
+        }
+        if (arg === "--no-think") {
+            settings.think = false;
+            continue;
+        }
         if (arg === "--chat" || arg.startsWith("--chat=")) {
             chatId = arg.includes("=") ? arg.slice("--chat=".length) : takeValue(args, "--chat");
             continue;
@@ -150,20 +220,16 @@ function parseArgs(argv) {
         positional.push(arg);
     }
     let machine = machineFlag;
-    let model = modelFlag;
+    const model = modelFlag;
     let promptParts = positional;
     if (!chatId) {
-        // New chat: <machine> [model] <prompt...>
+        // New chat: <machine> [model] <prompt...> — model is peeled later against /api/tags.
         if (!machine) {
             if (positional.length < 1)
                 usage();
             machine = positional[0];
             promptParts = positional.slice(1);
         }
-        if (!model && promptParts.length > 0 && looksLikeModel(promptParts[0])) {
-            model = promptParts[0];
-            promptParts = promptParts.slice(1);
-        }
     }
     // Continue (--chat): all positionals are the prompt. Optional machine override
     // via --machine, or a leading discovered-host name peeled in main().
@@ -172,6 +238,31 @@ function parseArgs(argv) {
 async function readStdinIfPiped() {
     if (stdinStream.isTTY)
         return "";
+    // Under npm/pnpm/CI, stdin is often a pipe that never gets EOF. Only drain it
+    // when data arrives promptly; otherwise treat as "no stdin prompt".
+    const hasData = await new Promise((resolve) => {
+        if (stdinStream.readableLength > 0 || stdinStream.readableEnded) {
+            resolve(true);
+            return;
+        }
+        let settled = false;
+        const done = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            stdinStream.off("readable", onReadable);
+            stdinStream.off("end", onEnd);
+            resolve(value);
+        };
+        const onReadable = () => done(true);
+        const onEnd = () => done(true);
+        stdinStream.once("readable", onReadable);
+        stdinStream.once("end", onEnd);
+        const timer = setTimeout(() => done(stdinStream.readableLength > 0), 25);
+    });
+    if (!hasData)
+        return "";
     const chunks = [];
     for await (const chunk of stdinStream) {
         chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
@@ -190,10 +281,13 @@ function buildOptions(settings) {
 }
 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;
@@ -202,71 +296,133 @@ async function runChat(opts) {
     const options = buildOptions(opts.settings);
     if (Object.keys(options).length > 0)
         body.options = options;
-    const res = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json", Accept: "application/json" },
-        body: JSON.stringify(body),
-    });
+    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}` : ""}`);
     }
-    if (!opts.stream) {
-        const chunk = (await res.json());
-        if (chunk.error)
-            throw new Error(chunk.error);
-        const content = chunk.message?.content ?? "";
-        if (opts.writeStdout)
-            process.stdout.write(`${content}\n`);
-        return { content, 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 = "";
-    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;
-            const chunk = JSON.parse(trimmed);
+    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 piece = chunk.message?.content ?? "";
-            if (piece) {
-                content += piece;
-                if (opts.writeStdout)
-                    process.stdout.write(piece);
+            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 };
     }
-    const trailing = buffer.trim();
-    if (trailing) {
-        const chunk = JSON.parse(trailing);
-        if (chunk.error)
-            throw new Error(chunk.error);
-        const piece = chunk.message?.content ?? "";
-        if (piece) {
-            content += piece;
-            if (opts.writeStdout)
-                process.stdout.write(piece);
+    catch (err) {
+        const name = err instanceof Error ? err.name : "";
+        if (name === "AbortError") {
+            throw new Error(`Prompt timed out after ${PROMPT_TIMEOUT_MS}ms (${url})`);
         }
-        last = chunk;
+        throw err;
     }
-    if (opts.writeStdout && content.length > 0 && !content.endsWith("\n")) {
-        process.stdout.write("\n");
+    finally {
+        if (timer)
+            clearTimeout(timer);
     }
-    return { content, chunk: last };
 }
 async function generateTopic(opts) {
     const fallback = topicFromPrompt(opts.prompt);
@@ -279,8 +435,8 @@ async function generateTopic(opts) {
             settings: mergeSettings(opts.settings, {
                 temperature: 0.2,
                 num_predict: 24,
-                // keep_alive 0 so topic pass doesn't pin the model longer than needed
-                keep_alive: 0,
+                think: false,
+                // Inherit caller's keep_alive — do not force-unload the model after topic gen.
             }),
             messages: [
                 {
@@ -307,14 +463,9 @@ function formatDuration(ns) {
 }
 export async function main() {
     const parsed = parseArgs(process.argv.slice(2));
-    const { promptParts, stream, json, save } = parsed;
-    const fromArgs = promptParts.join(" ").trim();
+    const { stream, json, save } = parsed;
+    let promptParts = parsed.promptParts;
     const fromStdin = await readStdinIfPiped();
-    const prompt = [fromArgs, fromStdin].filter(Boolean).join("\n\n").trim();
-    if (!prompt) {
-        console.error("No prompt provided (pass args and/or pipe stdin).");
-        usage();
-    }
     const config = await loadConfig();
     const { hosts: targets } = await discoverHosts({
         hosts: config.hosts,
@@ -323,19 +474,15 @@ export async function main() {
     let chat;
     let isNewChat = false;
     let machineQuery = parsed.machine;
-    let promptText = prompt;
     if (parsed.chatId) {
         chat = await loadChat(parsed.chatId);
-        // Allow `ollanet prompt mycroftone --chat HASH "follow-up"` by peeling a
-        // leading positional that matches a discovered host.
+        // Allow `ollanet prompt <host> --chat HASH "follow-up"` only when the
+        // leading token matches an already-discovered host (not direct-address fallback).
         if (!machineQuery && promptParts.length >= 2) {
-            try {
-                resolveHost(targets, promptParts[0]);
+            const hit = findDiscoveredHost(targets, promptParts[0]);
+            if (hit) {
                 machineQuery = promptParts[0];
-                promptText = [...promptParts.slice(1), fromStdin].filter(Boolean).join("\n\n").trim();
-            }
-            catch {
-                // first token is part of the prompt
+                promptParts = promptParts.slice(1);
             }
         }
     }
@@ -344,22 +491,32 @@ export async function main() {
         console.error("Machine is required for a new chat (or use --chat <hash>).");
         usage();
     }
-    if (!promptText) {
-        console.error("No prompt provided (pass args and/or pipe stdin).");
-        usage();
-    }
     const host = resolveHost(targets, machineQuery);
     if (!host.online && !host.isSelf && host.source === "tailscale") {
         throw new Error(`Machine "${shortName(host)}" appears offline.`);
     }
+    let peeledModel;
+    if (!parsed.chatId && !parsed.model) {
+        const peeled = await maybePeelModel(host, promptParts, fromStdin);
+        peeledModel = peeled.model;
+        promptParts = peeled.promptParts;
+    }
+    const promptText = [promptParts.join(" ").trim(), fromStdin].filter(Boolean).join("\n\n").trim();
+    if (!promptText) {
+        console.error("No prompt provided (pass args and/or pipe stdin).");
+        usage();
+    }
     const model = parsed.model ??
+        peeledModel ??
         chat?.model ??
         defaultModelForHost(config, host);
     if (!model) {
         throw new Error(`No model specified for "${shortName(host)}" and no default in ${configPath()}.\n` +
             `Pass a model, use --model <name>, or add it under defaultModels.`);
     }
-    const settings = mergeSettings(config.defaults, machineSettingsForHost(config, host), settingsFromEnv(), chat?.system ? { system: chat.system } : undefined, parsed.settings);
+    const settings = mergeSettings(
+    // Thinking models otherwise spend the whole num_predict budget on hidden reasoning.
+    { think: false }, config.defaults, machineSettingsForHost(config, host), settingsFromEnv(), chat?.system ? { system: chat.system } : undefined, parsed.settings);
     if (!chat && save) {
         chat = createChat({
             machine: shortName(host),
@@ -393,7 +550,7 @@ 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, chunk } = await runChat({
+    const { content, thinking, chunk } = await runChat({
         baseUrl,
         model,
         messages: toApiMessages(chat),
@@ -404,6 +561,7 @@ export async function main() {
     appendMessage(chat, {
         role: "assistant",
         content,
+        ...(thinking ? { thinking } : {}),
         machine: shortName(host),
         model,
         stats: {
@@ -434,6 +592,7 @@ export async function main() {
             chat_id: save ? chat.id : null,
             topic: chat.topic,
             content,
+            thinking: thinking || null,
             ollama: chunk,
         }, null, 2));
         return;

package/dist/scan.js

@@ -5,9 +5,9 @@
  * Usage: ollanet scan [--lan] [--json] [--all]
  */
 import { loadConfig } from "./config.js";
-import { OLLAMA_PORT, discoverHosts, shortName, } from "./hosts.js";
-const TIMEOUT_MS = Number(process.env.OLLAMA_TIMEOUT_MS ?? 2500);
-const CONCURRENCY = Number(process.env.OLLAMA_CONCURRENCY ?? 16);
+import { OLLAMA_PORT, discoverHosts, envInt, shortName, } from "./hosts.js";
+const TIMEOUT_MS = envInt("OLLAMA_TIMEOUT_MS", 2500);
+const CONCURRENCY = Math.max(1, envInt("OLLAMA_CONCURRENCY", 16));
 function formatBytes(bytes) {
     if (bytes == null || !Number.isFinite(bytes))
         return "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ollanet",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Chat with Ollama servers on any reachable network — scan hosts, prompt models, continue chats by hash",
   "type": "module",
   "bin": {