@kernel.chat/kbot 3.99.7 → 3.99.9

package/dist/agent.js

@@ -105,6 +105,8 @@ async function safeReadBody(res, maxBytes = MAX_RESPONSE_BODY) {
     }
     return decoder.decode(merged);
 }
+// Track whether we've already warned about a weak-tool-calling model this process.
+let weakModelWarningShown = false;
 // ── Local-first execution ──
 async function tryLocalFirst(message) {
     const lower = message.toLowerCase().trim();
@@ -790,6 +792,18 @@ export async function runAgent(message, options = {}) {
     if (isLocal && byokProvider === 'ollama') {
         warmOllamaModelCache().catch(() => { }); // non-blocking
     }
+    // Step 0b: One-time-per-session warning if configured model lacks tool calling
+    if (isLocal && !weakModelWarningShown) {
+        weakModelWarningShown = true;
+        try {
+            const { getWeakModelWarning } = await import('./model-capabilities.js');
+            const model = getProviderModel(byokProvider, 'default');
+            const warning = await getWeakModelWarning(byokProvider, model);
+            if (warning)
+                ui.onWarning(warning);
+        }
+        catch { /* capability check is non-critical */ }
+    }
     // Step 0: Parse multimodal content (images in message)
     const parsed = options.multimodal || parseMultimodalMessage(message);
     if (parsed.isMultimodal) {

package/dist/auth.js

@@ -490,8 +490,34 @@ export function getProviderModel(provider, speed, taskHint) {
     if (provider === 'ollama' && speed === 'default' && taskHint) {
         return selectOllamaModel(taskHint);
     }
+    // Respect user's configured local_model (Ollama) / fast_model / thinking_model
+    // from ~/.kbot/config.json BEFORE falling back to hardcoded defaults.
+    if (provider === 'ollama') {
+        try {
+            const cfg = loadConfigRaw();
+            if (speed === 'fast' && cfg.fast_model)
+                return cfg.fast_model;
+            if (speed === 'default' && cfg.local_model)
+                return cfg.local_model;
+        }
+        catch { /* config missing — fall through */ }
+    }
     return speed === 'fast' ? p.fastModel : p.defaultModel;
 }
+/** Lightweight config read — avoids circular dep with full loadConfig. */
+function loadConfigRaw() {
+    try {
+        const { readFileSync } = require('node:fs');
+        const { join } = require('node:path');
+        const { homedir } = require('node:os');
+        const path = join(homedir(), '.kbot', 'config.json');
+        const content = readFileSync(path, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return {};
+    }
+}
 /** Get the provider API URL */
 export function getProviderUrl(provider) {
     return PROVIDERS[provider].apiUrl;

package/dist/doctor.js

@@ -404,6 +404,29 @@ async function checkOllamaMLX() {
         message: `Ollama ${version} — upgrade to 0.19+ for MLX backend (2x faster on Apple Silicon)`,
     };
 }
+async function checkToolCapability() {
+    try {
+        const { getByokProvider, getProviderModel } = await import('./auth.js');
+        const { supportsToolCalls } = await import('./model-capabilities.js');
+        const provider = getByokProvider();
+        const model = getProviderModel(provider, 'default');
+        const ok = await supportsToolCalls(provider, model);
+        if (ok === true) {
+            return { name: 'Tool calling', status: 'pass', message: `${model} supports tool calls` };
+        }
+        if (ok === false) {
+            return {
+                name: 'Tool calling',
+                status: 'fail',
+                message: `${model} does NOT support tool calls — file reads, bash, git will hallucinate. Switch with \`kbot auth\` to qwen2.5-coder:14b, mistral:7b, or any Ollama model with the "tools" capability.`,
+            };
+        }
+        return { name: 'Tool calling', status: 'warn', message: `could not determine tool-call support for ${model}` };
+    }
+    catch {
+        return { name: 'Tool calling', status: 'warn', message: 'check failed unexpectedly' };
+    }
+}
 // ── Hardware checks (uses machine.ts) ──
 async function checkHardware() {
     const results = [];
@@ -491,6 +514,8 @@ export async function runDoctor() {
     // Ollama MLX check (Apple Silicon only)
     if (ollamaMLXResult)
         checks.push(ollamaMLXResult);
+    // Tool-calling capability of configured model
+    checks.push(await checkToolCapability());
     // Hardware checks
     checks.push(...hardwareResults);
     // More synchronous checks

package/dist/model-capabilities.d.ts

@@ -0,0 +1,14 @@
+import type { ByokProvider } from './auth.js';
+/**
+ * Check whether a specific model can invoke tools.
+ * For Ollama/local: queries the model's capabilities endpoint.
+ * For cloud providers: returns true for the known-capable list.
+ * Returns `null` if the answer can't be determined (non-fatal — caller decides).
+ */
+export declare function supportsToolCalls(provider: ByokProvider, model: string): Promise<boolean | null>;
+/**
+ * Human-readable recommendation when a model lacks tool support.
+ * Returns null if the model is fine OR if we can't tell.
+ */
+export declare function getWeakModelWarning(provider: ByokProvider, model: string): Promise<string | null>;
+//# sourceMappingURL=model-capabilities.d.ts.map

package/dist/model-capabilities.js

@@ -0,0 +1,71 @@
+// Model Capability Detection
+//
+// kbot's agent loop depends on tool calling. When the configured model
+// doesn't support tools, users see weird bugs: answers hallucinated instead
+// of reading files, capabilities denied instead of exercised, tool-call
+// syntax printed as markdown instead of invoked.
+//
+// This module answers one question reliably: does the configured model
+// support tool calls?
+//
+// For Ollama, we query `/api/show` which returns `capabilities: ['tools', ...]`
+// for tool-capable models. For cloud providers, tool support is assumed
+// (Anthropic, OpenAI, Google, Groq, Mistral, DeepSeek all support it).
+/** Cloud providers with reliable tool-calling support */
+const CLOUD_TOOL_CAPABLE = new Set([
+    'anthropic', 'openai', 'google', 'groq', 'mistral',
+    'deepseek', 'cohere', 'xai', 'openrouter', 'together',
+]);
+/**
+ * Check whether a specific model can invoke tools.
+ * For Ollama/local: queries the model's capabilities endpoint.
+ * For cloud providers: returns true for the known-capable list.
+ * Returns `null` if the answer can't be determined (non-fatal — caller decides).
+ */
+export async function supportsToolCalls(provider, model) {
+    // Cloud providers — trust the allowlist
+    if (CLOUD_TOOL_CAPABLE.has(provider))
+        return true;
+    // Ollama — ask the server directly
+    if (provider === 'ollama') {
+        try {
+            const res = await fetch('http://localhost:11434/api/show', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ name: model }),
+                signal: AbortSignal.timeout(3000),
+            });
+            if (!res.ok)
+                return null;
+            const data = await res.json();
+            if (!Array.isArray(data.capabilities))
+                return null;
+            return data.capabilities.includes('tools');
+        }
+        catch {
+            return null;
+        }
+    }
+    // Unknown — don't speculate
+    return null;
+}
+/**
+ * Human-readable recommendation when a model lacks tool support.
+ * Returns null if the model is fine OR if we can't tell.
+ */
+export async function getWeakModelWarning(provider, model) {
+    const ok = await supportsToolCalls(provider, model);
+    if (ok !== false)
+        return null; // true or null → no warning
+    const recs = {
+        ollama: ['qwen2.5-coder:14b', 'qwen2.5-coder:7b', 'mistral:7b', 'llama3.1:8b', 'kernel-coder:latest'],
+    };
+    const suggestions = recs[provider]?.filter(s => s !== model).slice(0, 3) ?? [];
+    const suggestionStr = suggestions.length > 0
+        ? ` Suggested tool-capable alternatives: ${suggestions.join(', ')}.`
+        : '';
+    return `Model "${model}" does not support tool calls. ` +
+        `kbot's file reads, shell commands, and git operations will silently fail or be hallucinated.${suggestionStr} ` +
+        `Switch with: \`kbot auth\` or set a tool-capable model in ~/.kbot/config.json.`;
+}
+//# sourceMappingURL=model-capabilities.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kernel.chat/kbot",
-  "version": "3.99.7",
+  "version": "3.99.9",
   "description": "Open-source terminal AI agent. 787+ tools, 35 agents, 20 providers. Dreams, learns, watches your system. Controls your phone. Fully local, fully sovereign. MIT.",
   "type": "module",
   "repository": {