@kernel.chat/kbot 3.69.1 → 3.70.0

package/dist/doctor.js

@@ -9,7 +9,7 @@ import { join } from 'node:path';
 import { existsSync, readdirSync, statSync } from 'node:fs';
 import { execSync } from 'node:child_process';
 import chalk from 'chalk';
-import { loadConfig, isByokEnabled, getByokProvider, isLocalProvider, PROVIDERS, KBOT_DIR, ENV_KEYS, } from './auth.js';
+import { loadConfig, isByokEnabled, getByokProvider, isLocalProvider, PROVIDERS, KBOT_DIR, ENV_KEYS, getOllamaVersion, isOllamaMLXBackend, } from './auth.js';
 import { getExtendedStats } from './learning.js';
 import { getMachineProfile, probeMachine } from './machine.js';
 import { createRequire } from 'node:module';
@@ -168,15 +168,25 @@ async function checkLocalProviderReachable(providerId, providerConfig) {
         if (!res.ok) {
             return { name: providerConfig.name, status: 'fail', message: `returned ${res.status}` };
         }
-        // For Ollama, report model count
+        // For Ollama, report model count, version, and MLX backend
         if (providerId === 'ollama') {
             try {
                 const data = await res.json();
                 const models = data.models ?? [];
-                const modelInfo = models.length > 0
-                    ? `running (${models.length} model${models.length !== 1 ? 's' : ''})`
-                    : 'running (no models pulled)';
-                return { name: providerConfig.name, status: 'pass', message: modelInfo };
+                const parts = [];
+                // Model count
+                parts.push(models.length > 0
+                    ? `${models.length} model${models.length !== 1 ? 's' : ''}`
+                    : 'no models pulled');
+                // Version
+                const version = await getOllamaVersion();
+                if (version)
+                    parts.push(`v${version}`);
+                // MLX backend detection
+                const mlxActive = await isOllamaMLXBackend();
+                if (mlxActive)
+                    parts.push('MLX backend');
+                return { name: providerConfig.name, status: 'pass', message: `running (${parts.join(', ')})` };
             }
             catch {
                 return { name: providerConfig.name, status: 'pass', message: 'running' };
@@ -362,6 +372,38 @@ function checkShell() {
     const completionStatus = completionsInstalled ? ', completions installed' : '';
     return { name: 'Shell', status: 'pass', message: `${shellName}${completionStatus}` };
 }
+// ── Ollama MLX check (0.19+ on Apple Silicon) ──
+async function checkOllamaMLX() {
+    // Only relevant on Apple Silicon
+    if (process.platform !== 'darwin' || process.arch !== 'arm64')
+        return null;
+    const version = await getOllamaVersion();
+    if (!version)
+        return null; // Ollama not running — already reported by provider check
+    const parts = version.split('.').map(Number);
+    const [major = 0, minor = 0] = parts;
+    if (major > 0 || minor >= 19) {
+        const mlxActive = await isOllamaMLXBackend();
+        if (mlxActive) {
+            return {
+                name: 'Ollama MLX',
+                status: 'pass',
+                message: `Ollama ${version} — MLX backend available for 2x faster inference on Apple Silicon`,
+            };
+        }
+        return {
+            name: 'Ollama MLX',
+            status: 'pass',
+            message: `Ollama ${version} — MLX supported (57% faster prefill, 93% faster decode on Apple Silicon)`,
+        };
+    }
+    // Ollama is running but older than 0.19
+    return {
+        name: 'Ollama MLX',
+        status: 'warn',
+        message: `Ollama ${version} — upgrade to 0.19+ for MLX backend (2x faster on Apple Silicon)`,
+    };
+}
 // ── Hardware checks (uses machine.ts) ──
 async function checkHardware() {
     const results = [];
@@ -435,16 +477,20 @@ export async function runDoctor() {
     checks.push(checkKbotVersion());
     checks.push(checkApiKey());
     // Async checks — run in parallel for speed
-    const [providerResults, hardwareResults] = await Promise.all([
+    const [providerResults, hardwareResults, ollamaMLXResult] = await Promise.all([
         checkAllProviders().catch(() => [
             { name: 'Providers', status: 'warn', message: 'check failed unexpectedly' },
         ]),
         checkHardware().catch(() => [
             { name: 'Hardware', status: 'warn', message: 'check failed unexpectedly' },
         ]),
+        checkOllamaMLX().catch(() => null),
     ]);
     // Provider checks (one line per provider)
     checks.push(...providerResults);
+    // Ollama MLX check (Apple Silicon only)
+    if (ollamaMLXResult)
+        checks.push(ollamaMLXResult);
     // Hardware checks
     checks.push(...hardwareResults);
     // More synchronous checks

package/dist/machine.d.ts

@@ -73,6 +73,7 @@ export interface MachineProfile {
     canRunLocalModels: boolean;
     gpuAcceleration: 'metal' | 'cuda' | 'vulkan' | 'cpu-only';
     recommendedModelSize: string;
+    mlxAvailable: boolean;
     probedAt: string;
 }
 export declare function probeMachine(): Promise<MachineProfile>;

package/dist/machine.js

@@ -314,6 +314,18 @@ function detectGpuAcceleration(gpus) {
         return 'vulkan';
     return 'cpu-only';
 }
+// ── MLX framework detection (Apple Silicon) ──
+function detectMLX() {
+    if (platform() !== 'darwin' || arch() !== 'arm64')
+        return false;
+    // Quick check: try importing mlx in Python
+    const result = exec('python3 -c "import mlx; print(mlx.__version__)" 2>/dev/null', 3000);
+    if (result && !result.includes('ModuleNotFoundError'))
+        return true;
+    // Fallback: check common pip install path
+    const globCheck = exec('ls /usr/local/lib/python3.*/site-packages/mlx/__init__.py 2>/dev/null || ls ~/Library/Python/3.*/lib/python/site-packages/mlx/__init__.py 2>/dev/null', 2000);
+    return !!globCheck;
+}
 // ── Model size recommendation ──
 function recommendModelSize(totalMemoryGB, gpuAccel) {
     // Conservative: leave room for OS + apps
@@ -374,6 +386,7 @@ export async function probeMachine() {
         osInfo = probeLinuxOs();
     }
     const gpuAccel = detectGpuAcceleration(gpus);
+    const mlxAvailable = detectMLX();
     const devTools = probeDevTools();
     // Uptime
     const uptimeSeconds = plat === 'darwin'
@@ -420,6 +433,7 @@ export async function probeMachine() {
         canRunLocalModels: gpuAccel !== 'cpu-only' || totalGB >= 8,
         gpuAcceleration: gpuAccel,
         recommendedModelSize: recommendModelSize(totalGB, gpuAccel),
+        mlxAvailable,
         probedAt: new Date().toISOString(),
     };
     cached = profile;
@@ -505,6 +519,8 @@ export function formatMachineProfile(p) {
     lines.push('');
     lines.push('  AI Capabilities');
     lines.push(`    Acceleration    ${p.gpuAcceleration}`);
+    if (p.mlxAvailable)
+        lines.push(`    MLX framework   available (Apple Silicon accelerated)`);
     lines.push(`    Local models    ${p.canRunLocalModels ? 'yes' : 'no'}`);
     lines.push(`    Recommended     up to ${p.recommendedModelSize} parameters`);
     lines.push('');
@@ -529,7 +545,7 @@ export function formatMachineForPrompt(p) {
     if (p.battery.present) {
         parts.push(`Battery: ${p.battery.percent}% ${p.battery.charging ? 'charging' : 'discharging'}`);
     }
-    parts.push(`GPU accel: ${p.gpuAcceleration} — local models up to ${p.recommendedModelSize}`);
+    parts.push(`GPU accel: ${p.gpuAcceleration}${p.mlxAvailable ? ' + MLX' : ''} — local models up to ${p.recommendedModelSize}`);
     const toolNames = p.devTools.map(t => `${t.name} ${t.version}`).join(', ');
     if (toolNames)
         parts.push(`Tools: ${toolNames}`);

package/dist/serve.js

@@ -235,8 +235,9 @@ export async function startServe(options) {
         printInfo(`  GET  /metrics               — Execution metrics`);
         printInfo(`  GET  /apps                  — List MCP App-capable tools`);
         printInfo(`  GET  /.well-known/agent.json — A2A Agent Card`);
-        printInfo(`  POST /a2a/tasks             — A2A submit task`);
-        printInfo(`  GET  /a2a/tasks/:id         — A2A task status`);
+        printInfo(`  POST /a2a                   — A2A JSON-RPC endpoint`);
+        printInfo(`  POST /a2a/tasks             — A2A submit task (REST)`);
+        printInfo(`  GET  /a2a/tasks/:id         — A2A task status (REST)`);
         if (options.token) {
             printInfo(`  Auth: Bearer token required`);
         }

package/dist/tools/a2a.d.ts

@@ -0,0 +1,2 @@
+export declare function registerA2ATools(): void;
+//# sourceMappingURL=a2a.d.ts.map

package/dist/tools/a2a.js

@@ -0,0 +1,233 @@
+// kbot A2A Tools — Agent-to-Agent protocol status and management
+//
+// Provides the a2a_status tool for inspecting the A2A server state,
+// registered capabilities, active tasks, and discovered remote agents.
+//
+// Tools: a2a_status, a2a_discover, a2a_send, a2a_card
+import { registerTool } from './index.js';
+import { getA2AStatus, buildAgentCard, discoverAgent, delegateTask, listRemoteAgents, removeRemoteAgent, } from '../a2a.js';
+export function registerA2ATools() {
+    // ── a2a_status ──
+    registerTool({
+        name: 'a2a_status',
+        description: 'Show A2A (Agent-to-Agent) protocol server status: whether the server is running, ' +
+            'registered agent capabilities (all 35 kbot specialists), task statistics, ' +
+            'active connections, and discovered remote agents.',
+        parameters: {
+            verbose: {
+                type: 'boolean',
+                description: 'Show full skill descriptions and all tags. Defaults to false (summary only).',
+                required: false,
+                default: false,
+            },
+        },
+        tier: 'free',
+        async execute(args) {
+            const verbose = args.verbose === true || args.verbose === 'true';
+            const status = getA2AStatus();
+            const lines = [];
+            // Server section
+            lines.push('=== A2A Server Status ===');
+            lines.push(`Running:   ${status.server.running ? 'YES' : 'NO'}`);
+            if (status.server.running) {
+                lines.push(`Endpoint:  ${status.server.endpointUrl}`);
+                lines.push(`Started:   ${status.server.startedAt}`);
+                lines.push(`Uptime:    ${status.server.uptime}`);
+            }
+            else {
+                lines.push('(Server not started. Run `kbot serve` to start the A2A endpoint.)');
+            }
+            // Tasks section
+            lines.push('');
+            lines.push('=== Task Statistics ===');
+            lines.push(`Received:  ${status.tasks.received}`);
+            lines.push(`Completed: ${status.tasks.completed}`);
+            lines.push(`Failed:    ${status.tasks.failed}`);
+            lines.push(`Active:    ${status.tasks.active}`);
+            lines.push(`In Store:  ${status.tasks.stored}`);
+            // Capabilities section
+            lines.push('');
+            lines.push(`=== Registered Capabilities (${status.capabilities.totalSkills} agents) ===`);
+            if (verbose) {
+                for (const skill of status.capabilities.skills) {
+                    lines.push(`  ${skill.id}: ${skill.name}`);
+                    lines.push(`    Tags: ${skill.tags.join(', ')}`);
+                }
+            }
+            else {
+                // Compact: group by category
+                const ids = status.capabilities.skills.map(s => s.id);
+                lines.push(`Agents: ${ids.join(', ')}`);
+            }
+            // Connections section
+            lines.push('');
+            lines.push(`=== Active Connections (${status.connections.uniqueClients} unique clients) ===`);
+            if (status.connections.clients.length === 0) {
+                lines.push('  (no connections yet)');
+            }
+            else {
+                for (const client of status.connections.clients) {
+                    lines.push(`  - ${client}`);
+                }
+            }
+            // Remote agents section
+            lines.push('');
+            lines.push(`=== Discovered Remote Agents (${status.registry.remoteAgents}) ===`);
+            if (status.registry.agents.length === 0) {
+                lines.push('  (none discovered — use a2a_discover to find remote agents)');
+            }
+            else {
+                for (const agent of status.registry.agents) {
+                    lines.push(`  - ${agent.name} @ ${agent.url} (${agent.skills} skills)`);
+                    if (agent.lastContact) {
+                        lines.push(`    Last contact: ${agent.lastContact}`);
+                    }
+                }
+            }
+            return lines.join('\n');
+        },
+    });
+    // ── a2a_discover ──
+    registerTool({
+        name: 'a2a_discover',
+        description: 'Discover a remote A2A agent by URL. Fetches its Agent Card from ' +
+            '<url>/.well-known/agent.json and registers it in the local registry ' +
+            'for future task delegation.',
+        parameters: {
+            url: {
+                type: 'string',
+                description: 'Base URL of the remote agent (e.g. "http://other-agent:8080")',
+                required: true,
+            },
+        },
+        tier: 'free',
+        async execute(args) {
+            const url = String(args.url).trim();
+            if (!url)
+                return 'Error: url is required';
+            const card = await discoverAgent(url);
+            if (!card) {
+                return `Failed to discover agent at ${url}. Ensure the agent is running and exposes /.well-known/agent.json.`;
+            }
+            const lines = [
+                `Discovered: ${card.name} v${card.version}`,
+                `URL: ${card.url}`,
+                `Provider: ${card.provider.organization}`,
+                `Skills (${card.skills.length}):`,
+                ...card.skills.map(s => `  - ${s.id}: ${s.name} [${s.tags.join(', ')}]`),
+                '',
+                'Agent registered in local registry. Use a2a_send to delegate tasks.',
+            ];
+            return lines.join('\n');
+        },
+    });
+    // ── a2a_send ──
+    registerTool({
+        name: 'a2a_send',
+        description: 'Send a task to a remote A2A agent. Delegates work to another agent\'s ' +
+            'specialist via the A2A protocol. Optionally specify which agent skill to use.',
+        parameters: {
+            url: {
+                type: 'string',
+                description: 'Base URL of the remote agent',
+                required: true,
+            },
+            task: {
+                type: 'string',
+                description: 'The task prompt to send to the remote agent',
+                required: true,
+            },
+            agent: {
+                type: 'string',
+                description: 'Hint which specialist agent should handle the task (optional)',
+                required: false,
+            },
+        },
+        tier: 'free',
+        timeout: 180_000, // 3 minutes for remote task execution
+        async execute(args) {
+            const url = String(args.url).trim();
+            const task = String(args.task).trim();
+            const agent = args.agent ? String(args.agent).trim() : undefined;
+            if (!url || !task)
+                return 'Error: url and task are required';
+            const result = await delegateTask(url, task, { agent });
+            if (!result) {
+                return `Task delegation to ${url} failed. The remote agent may be down or the task execution failed.`;
+            }
+            return [
+                `=== Task Result from ${url} ===`,
+                result.text,
+                '',
+                result.metadata.agentUsed ? `Agent used: ${result.metadata.agentUsed}` : '',
+                result.metadata.model ? `Model: ${result.metadata.model}` : '',
+            ].filter(Boolean).join('\n');
+        },
+    });
+    // ── a2a_card ──
+    registerTool({
+        name: 'a2a_card',
+        description: 'Generate and display kbot\'s A2A Agent Card — the JSON descriptor that ' +
+            'other agents use to discover kbot\'s capabilities. Shows all 35 specialist ' +
+            'agents as skills with tags and descriptions.',
+        parameters: {
+            url: {
+                type: 'string',
+                description: 'Override the endpoint URL in the card (defaults to the current server URL)',
+                required: false,
+            },
+        },
+        tier: 'free',
+        async execute(args) {
+            const url = args.url ? String(args.url).trim() : undefined;
+            const card = buildAgentCard(url);
+            return JSON.stringify(card, null, 2);
+        },
+    });
+    // ── a2a_remove ──
+    registerTool({
+        name: 'a2a_remove',
+        description: 'Remove a remote A2A agent from the local discovery registry.',
+        parameters: {
+            url: {
+                type: 'string',
+                description: 'Base URL of the remote agent to remove',
+                required: true,
+            },
+        },
+        tier: 'free',
+        async execute(args) {
+            const url = String(args.url).trim();
+            if (!url)
+                return 'Error: url is required';
+            const removed = removeRemoteAgent(url);
+            return removed
+                ? `Removed ${url} from the A2A registry.`
+                : `Agent ${url} not found in the registry.`;
+        },
+    });
+    // ── a2a_list ──
+    registerTool({
+        name: 'a2a_list',
+        description: 'List all discovered remote A2A agents from the local registry.',
+        parameters: {},
+        tier: 'free',
+        async execute() {
+            const agents = listRemoteAgents();
+            if (agents.length === 0) {
+                return 'No remote agents discovered. Use a2a_discover to find agents.';
+            }
+            const lines = agents.map(a => {
+                const skills = a.card.skills.map(s => s.id).join(', ');
+                return [
+                    `${a.card.name} (${a.url})`,
+                    `  Skills: ${skills}`,
+                    `  Discovered: ${a.discoveredAt}`,
+                    a.lastContactedAt ? `  Last contact: ${a.lastContactedAt}` : '',
+                ].filter(Boolean).join('\n');
+            });
+            return `=== Discovered Remote Agents (${agents.length}) ===\n\n${lines.join('\n\n')}`;
+        },
+    });
+}
+//# sourceMappingURL=a2a.js.map

package/dist/tools/ai-analysis.d.ts

@@ -0,0 +1,2 @@
+export declare function registerAIAnalysisTools(): void;
+//# sourceMappingURL=ai-analysis.d.ts.map