@kernel.chat/kbot 3.99.6 → 3.99.8

package/dist/agent.js

@@ -105,12 +105,16 @@ 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();
-    // Only match file-like paths — avoid intercepting "open chrome" or "show me how to..."
-    const readMatch = lower.match(/^(?:read|cat|view)\s+(.+)$/i)
-        || lower.match(/^(?:show|open)\s+((?:\.{0,2}\/|~\/|\w+\.\w+).+)$/i);
+    // Only match simple "read <single-filepath>" — reject anything with trailing
+    // conversational text. Prevents "Read package.json and tell me X" from
+    // feeding the whole prompt to read_file as a filename.
+    const readMatch = lower.match(/^(?:read|cat|view)\s+(\S+)\s*$/i)
+        || lower.match(/^(?:show|open)\s+((?:\.{0,2}\/|~\/|[\w.-]+\.[\w-]+))\s*$/i);
     if (readMatch) {
         const tool = getTool('read_file');
         if (tool)
@@ -788,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/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.6",
+  "version": "3.99.8",
   "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": {