@kernel.chat/kbot 3.69.1 → 3.71.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/integrations/ableton-bridge.d.ts

@@ -0,0 +1,158 @@
+/**
+ * ableton-bridge.ts — kbot ↔ AbletonBridge TCP Client
+ *
+ * Connects to AbletonBridge (https://github.com/hidingwill/AbletonBridge),
+ * a 353-tool Remote Script that exposes Ableton's full Browser API
+ * via a TCP server on localhost:9001.
+ *
+ * Protocol:
+ *   Send:    {"id": 1, "method": "search_browser", "params": {...}}\n
+ *   Receive: {"id": 1, "result": {...}}\n
+ *
+ * Fallback chain (used by tools):
+ *   1. AbletonBridge (port 9001) — full browser API
+ *   2. KBotBridge (port 9998) — kbot's own Remote Script
+ *   3. Error with install instructions
+ *
+ * Follows the same singleton + newline-delimited JSON pattern as AbletonM4L.
+ */
+export interface BrowserItem {
+    name: string;
+    uri: string;
+    isLoadable: boolean;
+    isDevice: boolean;
+    isFolder: boolean;
+}
+export interface Preset {
+    name: string;
+    uri: string;
+}
+export interface Device {
+    name: string;
+    className: string;
+    index: number;
+}
+export interface BridgeCommand {
+    id: number;
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface BridgeResponse {
+    id: number;
+    result?: unknown;
+    error?: string;
+}
+export declare class AbletonBridgeClient {
+    private static instance;
+    private socket;
+    private connected;
+    private pending;
+    private nextId;
+    private buffer;
+    static PORT: number;
+    static HOST: string;
+    static TIMEOUT: number;
+    static CONNECT_TIMEOUT: number;
+    private constructor();
+    /**
+     * Get the singleton instance.
+     */
+    static getInstance(): AbletonBridgeClient;
+    /**
+     * Connect to AbletonBridge TCP server.
+     * Returns true if connected and responds to a ping/handshake.
+     */
+    connect(): Promise<boolean>;
+    /**
+     * Check if connected.
+     */
+    isConnected(): boolean;
+    /**
+     * Disconnect from the bridge.
+     */
+    disconnect(): void;
+    /**
+     * Send a method call and wait for a response.
+     */
+    send(method: string, params?: Record<string, unknown>): Promise<BridgeResponse>;
+    private handleResponse;
+    private handleDisconnect;
+    /**
+     * Search Ableton's browser for items matching a query.
+     * Optionally filter by category: "instruments", "audio_effects", "midi_effects",
+     * "drums", "sounds", "packs", "plugins", "samples", "presets".
+     */
+    searchBrowser(query: string, category?: string): Promise<BrowserItem[]>;
+    /**
+     * Load a device onto a track by its browser URI.
+     */
+    loadDevice(trackIndex: number, uri: string): Promise<boolean>;
+    /**
+     * Search for a device by name and load the first loadable match onto a track.
+     * Optionally filter by category to narrow results.
+     */
+    loadDeviceByName(trackIndex: number, name: string, category?: string): Promise<boolean>;
+    /**
+     * List presets available for a device by its URI.
+     */
+    listPresets(deviceUri: string): Promise<Preset[]>;
+    /**
+     * Load a preset onto a device on a specific track.
+     */
+    loadPreset(trackIndex: number, deviceIndex: number, presetUri: string): Promise<boolean>;
+    /**
+     * Get the effect/device chain on a track.
+     */
+    getEffectChain(trackIndex: number): Promise<Device[]>;
+}
+/**
+ * Lightweight TCP probe for the kbot Remote Script on port 9998.
+ * Uses the same newline-delimited JSON protocol as AbletonM4L.
+ */
+export declare class KBotRemoteClient {
+    private static instance;
+    private socket;
+    private connected;
+    private pending;
+    private nextId;
+    private buffer;
+    static PORT: number;
+    static HOST: string;
+    static TIMEOUT: number;
+    static CONNECT_TIMEOUT: number;
+    private constructor();
+    static getInstance(): KBotRemoteClient;
+    connect(): Promise<boolean>;
+    isConnected(): boolean;
+    disconnect(): void;
+    send(cmd: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Load a device by name via the kbot Remote Script's search. */
+    loadDevice(trackIndex: number, name: string): Promise<boolean>;
+    /** Search the browser via the kbot Remote Script. */
+    searchBrowser(query: string): Promise<BrowserItem[]>;
+    private handleResponse;
+    private handleDisconnect;
+}
+/**
+ * Try to connect to AbletonBridge (port 9001).
+ * Returns the connected client or null if unavailable.
+ */
+export declare function tryAbletonBridge(): Promise<AbletonBridgeClient | null>;
+/**
+ * Try to connect to KBotBridge Remote Script (port 9998).
+ * Returns the connected client or null if unavailable.
+ */
+export declare function tryKBotRemote(): Promise<KBotRemoteClient | null>;
+/**
+ * Get any available bridge, trying AbletonBridge first, then KBotBridge.
+ * Returns { bridge, type } or null if neither is available.
+ */
+export declare function getAvailableBridge(): Promise<{
+    bridge: AbletonBridgeClient | KBotRemoteClient;
+    type: 'ableton-bridge' | 'kbot-remote';
+} | null>;
+/**
+ * Format a helpful error message when no bridge is available.
+ */
+export declare function formatBridgeError(): string;
+//# sourceMappingURL=ableton-bridge.d.ts.map