@dexto/core 1.4.0 → 1.5.1

package/dist/llm/providers/local/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../src/llm/providers/local/errors.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAC;AAMzE;;GAEG;AACH,eAAO,MAAM,eAAe;6BAEC,iBAAiB;kCAWZ,MAAM,GAAG,iBAAiB;qBAWvC,iBAAiB;4BAYV,MAAM,SAAS,MAAM,GAAG,iBAAiB;iCAWpC,MAAM,GAAG,iBAAiB;0BAWjC,MAAM,YAAY,MAAM,UAAU,MAAM,GAAG,iBAAiB;mCAWnD,MAAM,YAAY,MAAM,aAAa,MAAM,GAAG,iBAAiB;4BAatE,MAAM,GAAG,iBAAiB;2BAY3B,MAAM,GAAG,iBAAiB;gCAWrB,MAAM,GAAG,iBAAiB;6BAW7B,MAAM,SAAS,MAAM,GAAG,iBAAiB;0BAW5C,MAAM,YAAY,MAAM,GAAG,iBAAiB;6BAWzC,MAAM,aAAa,MAAM,gBAAgB,MAAM,GAAG,iBAAiB;uBAYzE,iBAAiB;8BAWV,MAAM,YAAY,MAAM,aAAa,MAAM,GAAG,iBAAiB;0BAWnE,MAAM,GAAG,iBAAiB;0BAY1B,MAAM,GAAG,iBAAiB;mCAWjB,MAAM,GAAG,iBAAiB;gCAW7B,MAAM,SAAS,MAAM,GAAG,iBAAiB;0BAW/C,MAAM,GAAG,iBAAiB;CAUnD,CAAC"}

package/dist/llm/providers/local/errors.js

@@ -0,0 +1,217 @@
+import "../../../chunk-PTJYTZNU.js";
+import { DextoRuntimeError } from "../../../errors/DextoRuntimeError.js";
+import { ErrorType } from "../../../errors/types.js";
+import { LocalModelErrorCode } from "./error-codes.js";
+const SCOPE = "local-models";
+const LocalModelError = {
+  // Installation errors
+  nodeLlamaNotInstalled() {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.NODE_LLAMA_NOT_INSTALLED,
+      SCOPE,
+      ErrorType.NOT_FOUND,
+      'node-llama-cpp is not installed. Run `dexto setup` and select "local" provider to install it.',
+      {},
+      'Run `dexto setup` and select "local" provider to install local model support'
+    );
+  },
+  nodeLlamaInstallFailed(error) {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.NODE_LLAMA_INSTALL_FAILED,
+      SCOPE,
+      ErrorType.THIRD_PARTY,
+      `Failed to install node-llama-cpp: ${error}`,
+      { error },
+      "Check your Node.js version and try again. CMake may be required for your platform."
+    );
+  },
+  cmakeNotFound() {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.CMAKE_NOT_FOUND,
+      SCOPE,
+      ErrorType.NOT_FOUND,
+      "CMake is required to build node-llama-cpp from source but was not found.",
+      {},
+      "Install CMake: brew install cmake (macOS), apt install cmake (Linux), or download from cmake.org (Windows)"
+    );
+  },
+  // Download errors
+  downloadFailed(modelId, error) {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.DOWNLOAD_FAILED,
+      SCOPE,
+      ErrorType.THIRD_PARTY,
+      `Failed to download model '${modelId}': ${error}`,
+      { modelId, error },
+      "Check your internet connection and try again"
+    );
+  },
+  downloadInterrupted(modelId) {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.DOWNLOAD_INTERRUPTED,
+      SCOPE,
+      ErrorType.THIRD_PARTY,
+      `Download of model '${modelId}' was interrupted`,
+      { modelId },
+      "Run the download command again to resume"
+    );
+  },
+  hashMismatch(modelId, expected, actual) {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.DOWNLOAD_HASH_MISMATCH,
+      SCOPE,
+      ErrorType.USER,
+      `Downloaded model '${modelId}' has invalid hash. Expected: ${expected}, Got: ${actual}`,
+      { modelId, expected, actual },
+      "Delete the file and download again"
+    );
+  },
+  insufficientDiskSpace(modelId, required, available) {
+    const requiredGB = (required / (1024 * 1024 * 1024)).toFixed(1);
+    const availableGB = (available / (1024 * 1024 * 1024)).toFixed(1);
+    return new DextoRuntimeError(
+      LocalModelErrorCode.INSUFFICIENT_DISK_SPACE,
+      SCOPE,
+      ErrorType.USER,
+      `Insufficient disk space to download '${modelId}'. Required: ${requiredGB}GB, Available: ${availableGB}GB`,
+      { modelId, required, available },
+      "Free up disk space or choose a smaller model"
+    );
+  },
+  hfAuthRequired(modelId) {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.HF_AUTH_REQUIRED,
+      SCOPE,
+      ErrorType.FORBIDDEN,
+      `Model '${modelId}' is a gated model and requires HuggingFace authentication`,
+      { modelId },
+      "Set HF_TOKEN environment variable or run `huggingface-cli login`"
+    );
+  },
+  // Model errors
+  modelNotFound(modelId) {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.MODEL_NOT_FOUND,
+      SCOPE,
+      ErrorType.NOT_FOUND,
+      `Model '${modelId}' not found in local model registry`,
+      { modelId },
+      'Run `dexto setup` and select "local" to see available models'
+    );
+  },
+  modelNotDownloaded(modelId) {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.MODEL_NOT_DOWNLOADED,
+      SCOPE,
+      ErrorType.NOT_FOUND,
+      `Model '${modelId}' is not downloaded. Download it first.`,
+      { modelId },
+      'Run `dexto setup` and select "local" to download models'
+    );
+  },
+  modelLoadFailed(modelId, error) {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.MODEL_LOAD_FAILED,
+      SCOPE,
+      ErrorType.THIRD_PARTY,
+      `Failed to load model '${modelId}': ${error}`,
+      { modelId, error },
+      "The model file may be corrupted. Try re-downloading it."
+    );
+  },
+  modelCorrupt(modelId, filePath) {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.MODEL_CORRUPT,
+      SCOPE,
+      ErrorType.USER,
+      `Model file for '${modelId}' appears to be corrupted`,
+      { modelId, filePath },
+      `Delete ${filePath} and download the model again`
+    );
+  },
+  contextTooLarge(modelId, requested, maxSupported) {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.CONTEXT_TOO_LARGE,
+      SCOPE,
+      ErrorType.USER,
+      `Requested context size ${requested} exceeds model's maximum of ${maxSupported}`,
+      { modelId, requested, maxSupported },
+      `Use a context size of ${maxSupported} or less`
+    );
+  },
+  // GPU errors
+  gpuNotAvailable() {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.GPU_NOT_AVAILABLE,
+      SCOPE,
+      ErrorType.NOT_FOUND,
+      "No GPU acceleration available. Running on CPU.",
+      {},
+      "For better performance, ensure GPU drivers are installed"
+    );
+  },
+  insufficientVRAM(modelId, required, available) {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.INSUFFICIENT_VRAM,
+      SCOPE,
+      ErrorType.USER,
+      `Model '${modelId}' requires ${required}GB VRAM but only ${available}GB available`,
+      { modelId, required, available },
+      "Use a smaller quantization or reduce GPU layers"
+    );
+  },
+  gpuDriverError(error) {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.GPU_DRIVER_ERROR,
+      SCOPE,
+      ErrorType.THIRD_PARTY,
+      `GPU driver error: ${error}`,
+      { error },
+      "Update your GPU drivers"
+    );
+  },
+  // Ollama errors
+  ollamaNotRunning(url) {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.OLLAMA_NOT_RUNNING,
+      SCOPE,
+      ErrorType.THIRD_PARTY,
+      `Ollama server is not running at ${url}`,
+      { url },
+      "Start Ollama with `ollama serve` or ensure it is running"
+    );
+  },
+  ollamaModelNotFound(modelName) {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.OLLAMA_MODEL_NOT_FOUND,
+      SCOPE,
+      ErrorType.NOT_FOUND,
+      `Model '${modelName}' not found on Ollama server`,
+      { modelName },
+      `Pull the model with \`ollama pull ${modelName}\``
+    );
+  },
+  ollamaPullFailed(modelName, error) {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.OLLAMA_PULL_FAILED,
+      SCOPE,
+      ErrorType.THIRD_PARTY,
+      `Failed to pull model '${modelName}' from Ollama: ${error}`,
+      { modelName, error },
+      "Check your internet connection and Ollama server status"
+    );
+  },
+  ollamaApiError(error) {
+    return new DextoRuntimeError(
+      LocalModelErrorCode.OLLAMA_API_ERROR,
+      SCOPE,
+      ErrorType.THIRD_PARTY,
+      `Ollama API error: ${error}`,
+      { error },
+      "Check Ollama server logs for details"
+    );
+  }
+};
+export {
+  LocalModelError
+};

package/dist/llm/providers/local/gpu-detector.cjs

@@ -0,0 +1,214 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var gpu_detector_exports = {};
+__export(gpu_detector_exports, {
+  detectGPU: () => detectGPU,
+  formatGPUInfo: () => formatGPUInfo,
+  getAvailableBackends: () => getAvailableBackends,
+  isBackendAvailable: () => isBackendAvailable
+});
+module.exports = __toCommonJS(gpu_detector_exports);
+var import_child_process = require("child_process");
+var import_util = require("util");
+var os = __toESM(require("os"), 1);
+const execAsync = (0, import_util.promisify)(import_child_process.exec);
+async function detectGPU() {
+  const platform = os.platform();
+  if (platform === "darwin") {
+    const metalInfo = await detectMetal();
+    if (metalInfo.available) {
+      return metalInfo;
+    }
+  }
+  if (platform === "linux" || platform === "win32") {
+    const cudaInfo = await detectCUDA();
+    if (cudaInfo.available) {
+      return cudaInfo;
+    }
+    const vulkanInfo = await detectVulkan();
+    if (vulkanInfo.available) {
+      return vulkanInfo;
+    }
+  }
+  return {
+    backend: "cpu",
+    available: true,
+    deviceName: `${os.cpus()[0]?.model ?? "Unknown CPU"}`
+  };
+}
+async function detectMetal() {
+  try {
+    const { stdout } = await execAsync("system_profiler SPDisplaysDataType -json 2>/dev/null");
+    const data = JSON.parse(stdout);
+    const gpuData = data?.SPDisplaysDataType?.[0];
+    if (gpuData) {
+      const chipName = gpuData.sppci_model ?? gpuData._name ?? "Apple GPU";
+      const isAppleSilicon = chipName.toLowerCase().includes("apple") || chipName.toLowerCase().includes("m1") || chipName.toLowerCase().includes("m2") || chipName.toLowerCase().includes("m3") || chipName.toLowerCase().includes("m4");
+      const result = {
+        backend: "metal",
+        available: true,
+        deviceName: chipName
+      };
+      if (isAppleSilicon) {
+        result.vramMB = Math.round(os.totalmem() / (1024 * 1024));
+      } else if (gpuData.sppci_vram) {
+        const vramMatch = gpuData.sppci_vram.match(/(\d+)\s*(GB|MB)/i);
+        if (vramMatch) {
+          result.vramMB = parseInt(vramMatch[1]) * (vramMatch[2].toUpperCase() === "GB" ? 1024 : 1);
+        }
+      }
+      return result;
+    }
+  } catch {
+  }
+  return {
+    backend: "metal",
+    available: false
+  };
+}
+async function detectCUDA() {
+  try {
+    const { stdout } = await execAsync(
+      "nvidia-smi --query-gpu=name,memory.total,driver_version --format=csv,noheader,nounits 2>/dev/null"
+    );
+    const lines = stdout.trim().split("\n");
+    if (lines.length > 0 && lines[0]) {
+      const [name, memoryMB, driverVersion] = lines[0].split(", ").map((s) => s.trim());
+      const result = {
+        backend: "cuda",
+        available: true
+      };
+      if (name) {
+        result.deviceName = name;
+      }
+      if (memoryMB) {
+        result.vramMB = parseInt(memoryMB);
+      }
+      if (driverVersion) {
+        result.driverVersion = driverVersion;
+      }
+      return result;
+    }
+  } catch {
+  }
+  return {
+    backend: "cuda",
+    available: false
+  };
+}
+async function detectVulkan() {
+  try {
+    const { stdout } = await execAsync("vulkaninfo --summary 2>/dev/null");
+    const deviceMatch = stdout.match(/deviceName\s*=\s*(.+)/);
+    const deviceName = deviceMatch?.[1]?.trim() ?? "Vulkan GPU";
+    const result = {
+      backend: "vulkan",
+      available: true,
+      deviceName
+    };
+    const heapMatch = stdout.match(/heapSize\s*=\s*(\d+)/);
+    if (heapMatch) {
+      result.vramMB = Math.round(parseInt(heapMatch[1]) / (1024 * 1024));
+    }
+    return result;
+  } catch {
+  }
+  if (os.platform() === "linux") {
+    try {
+      const { stdout } = await execAsync('lspci | grep -i "vga\\|3d\\|display" 2>/dev/null');
+      if (stdout.includes("AMD") || stdout.includes("Intel") || stdout.includes("Radeon")) {
+        const deviceMatch = stdout.match(/: (.+)/);
+        return {
+          backend: "vulkan",
+          available: true,
+          deviceName: deviceMatch?.[1]?.trim() ?? "GPU (Vulkan)"
+        };
+      }
+    } catch {
+    }
+  }
+  return {
+    backend: "vulkan",
+    available: false
+  };
+}
+function formatGPUInfo(info) {
+  if (!info.available) {
+    return `${info.backend.toUpperCase()} not available`;
+  }
+  const parts = [info.deviceName ?? info.backend.toUpperCase()];
+  if (info.vramMB) {
+    const vramGB = (info.vramMB / 1024).toFixed(1);
+    parts.push(`${vramGB}GB`);
+  }
+  if (info.driverVersion) {
+    parts.push(`Driver: ${info.driverVersion}`);
+  }
+  return parts.join(" \u2022 ");
+}
+async function isBackendAvailable(backend) {
+  switch (backend) {
+    case "metal":
+      return (await detectMetal()).available;
+    case "cuda":
+      return (await detectCUDA()).available;
+    case "vulkan":
+      return (await detectVulkan()).available;
+    case "cpu":
+      return true;
+    default:
+      return false;
+  }
+}
+async function getAvailableBackends() {
+  const backends = [];
+  const platform = os.platform();
+  if (platform === "darwin") {
+    if ((await detectMetal()).available) {
+      backends.push("metal");
+    }
+  }
+  if (platform === "linux" || platform === "win32") {
+    if ((await detectCUDA()).available) {
+      backends.push("cuda");
+    }
+    if ((await detectVulkan()).available) {
+      backends.push("vulkan");
+    }
+  }
+  backends.push("cpu");
+  return backends;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectGPU,
+  formatGPUInfo,
+  getAvailableBackends,
+  isBackendAvailable
+});

package/dist/llm/providers/local/gpu-detector.d.ts

@@ -0,0 +1,28 @@
+/**
+ * GPU detection for local model acceleration.
+ *
+ * Detects available GPU backends:
+ * - Metal: Apple Silicon (M1/M2/M3/M4 series)
+ * - CUDA: NVIDIA GPUs on Linux/Windows
+ * - Vulkan: Cross-platform fallback for AMD/Intel GPUs
+ * - CPU: Fallback when no GPU is available
+ */
+import type { GPUBackend, GPUInfo } from './types.js';
+/**
+ * Detect available GPU backend for the current system.
+ * Returns the best available option.
+ */
+export declare function detectGPU(): Promise<GPUInfo>;
+/**
+ * Get a human-readable summary of GPU detection results.
+ */
+export declare function formatGPUInfo(info: GPUInfo): string;
+/**
+ * Check if a specific backend is available.
+ */
+export declare function isBackendAvailable(backend: GPUBackend): Promise<boolean>;
+/**
+ * Get all available backends on the current system.
+ */
+export declare function getAvailableBackends(): Promise<GPUBackend[]>;
+//# sourceMappingURL=gpu-detector.d.ts.map

package/dist/llm/providers/local/gpu-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu-detector.d.ts","sourceRoot":"","sources":["../../../../src/llm/providers/local/gpu-detector.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAItD;;;GAGG;AACH,wBAAsB,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC,CA+BlD;AAmJD;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAiBnD;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CAa9E;AAED;;GAEG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC,CAuBlE"}

package/dist/llm/providers/local/gpu-detector.js

@@ -0,0 +1,178 @@
+import "../../../chunk-PTJYTZNU.js";
+import { exec } from "child_process";
+import { promisify } from "util";
+import * as os from "os";
+const execAsync = promisify(exec);
+async function detectGPU() {
+  const platform = os.platform();
+  if (platform === "darwin") {
+    const metalInfo = await detectMetal();
+    if (metalInfo.available) {
+      return metalInfo;
+    }
+  }
+  if (platform === "linux" || platform === "win32") {
+    const cudaInfo = await detectCUDA();
+    if (cudaInfo.available) {
+      return cudaInfo;
+    }
+    const vulkanInfo = await detectVulkan();
+    if (vulkanInfo.available) {
+      return vulkanInfo;
+    }
+  }
+  return {
+    backend: "cpu",
+    available: true,
+    deviceName: `${os.cpus()[0]?.model ?? "Unknown CPU"}`
+  };
+}
+async function detectMetal() {
+  try {
+    const { stdout } = await execAsync("system_profiler SPDisplaysDataType -json 2>/dev/null");
+    const data = JSON.parse(stdout);
+    const gpuData = data?.SPDisplaysDataType?.[0];
+    if (gpuData) {
+      const chipName = gpuData.sppci_model ?? gpuData._name ?? "Apple GPU";
+      const isAppleSilicon = chipName.toLowerCase().includes("apple") || chipName.toLowerCase().includes("m1") || chipName.toLowerCase().includes("m2") || chipName.toLowerCase().includes("m3") || chipName.toLowerCase().includes("m4");
+      const result = {
+        backend: "metal",
+        available: true,
+        deviceName: chipName
+      };
+      if (isAppleSilicon) {
+        result.vramMB = Math.round(os.totalmem() / (1024 * 1024));
+      } else if (gpuData.sppci_vram) {
+        const vramMatch = gpuData.sppci_vram.match(/(\d+)\s*(GB|MB)/i);
+        if (vramMatch) {
+          result.vramMB = parseInt(vramMatch[1]) * (vramMatch[2].toUpperCase() === "GB" ? 1024 : 1);
+        }
+      }
+      return result;
+    }
+  } catch {
+  }
+  return {
+    backend: "metal",
+    available: false
+  };
+}
+async function detectCUDA() {
+  try {
+    const { stdout } = await execAsync(
+      "nvidia-smi --query-gpu=name,memory.total,driver_version --format=csv,noheader,nounits 2>/dev/null"
+    );
+    const lines = stdout.trim().split("\n");
+    if (lines.length > 0 && lines[0]) {
+      const [name, memoryMB, driverVersion] = lines[0].split(", ").map((s) => s.trim());
+      const result = {
+        backend: "cuda",
+        available: true
+      };
+      if (name) {
+        result.deviceName = name;
+      }
+      if (memoryMB) {
+        result.vramMB = parseInt(memoryMB);
+      }
+      if (driverVersion) {
+        result.driverVersion = driverVersion;
+      }
+      return result;
+    }
+  } catch {
+  }
+  return {
+    backend: "cuda",
+    available: false
+  };
+}
+async function detectVulkan() {
+  try {
+    const { stdout } = await execAsync("vulkaninfo --summary 2>/dev/null");
+    const deviceMatch = stdout.match(/deviceName\s*=\s*(.+)/);
+    const deviceName = deviceMatch?.[1]?.trim() ?? "Vulkan GPU";
+    const result = {
+      backend: "vulkan",
+      available: true,
+      deviceName
+    };
+    const heapMatch = stdout.match(/heapSize\s*=\s*(\d+)/);
+    if (heapMatch) {
+      result.vramMB = Math.round(parseInt(heapMatch[1]) / (1024 * 1024));
+    }
+    return result;
+  } catch {
+  }
+  if (os.platform() === "linux") {
+    try {
+      const { stdout } = await execAsync('lspci | grep -i "vga\\|3d\\|display" 2>/dev/null');
+      if (stdout.includes("AMD") || stdout.includes("Intel") || stdout.includes("Radeon")) {
+        const deviceMatch = stdout.match(/: (.+)/);
+        return {
+          backend: "vulkan",
+          available: true,
+          deviceName: deviceMatch?.[1]?.trim() ?? "GPU (Vulkan)"
+        };
+      }
+    } catch {
+    }
+  }
+  return {
+    backend: "vulkan",
+    available: false
+  };
+}
+function formatGPUInfo(info) {
+  if (!info.available) {
+    return `${info.backend.toUpperCase()} not available`;
+  }
+  const parts = [info.deviceName ?? info.backend.toUpperCase()];
+  if (info.vramMB) {
+    const vramGB = (info.vramMB / 1024).toFixed(1);
+    parts.push(`${vramGB}GB`);
+  }
+  if (info.driverVersion) {
+    parts.push(`Driver: ${info.driverVersion}`);
+  }
+  return parts.join(" \u2022 ");
+}
+async function isBackendAvailable(backend) {
+  switch (backend) {
+    case "metal":
+      return (await detectMetal()).available;
+    case "cuda":
+      return (await detectCUDA()).available;
+    case "vulkan":
+      return (await detectVulkan()).available;
+    case "cpu":
+      return true;
+    default:
+      return false;
+  }
+}
+async function getAvailableBackends() {
+  const backends = [];
+  const platform = os.platform();
+  if (platform === "darwin") {
+    if ((await detectMetal()).available) {
+      backends.push("metal");
+    }
+  }
+  if (platform === "linux" || platform === "win32") {
+    if ((await detectCUDA()).available) {
+      backends.push("cuda");
+    }
+    if ((await detectVulkan()).available) {
+      backends.push("vulkan");
+    }
+  }
+  backends.push("cpu");
+  return backends;
+}
+export {
+  detectGPU,
+  formatGPUInfo,
+  getAvailableBackends,
+  isBackendAvailable
+};