@johpaz/hive-agents 0.0.35 → 0.0.36

package/packages/core/src/gateway/llm-local/client.ts

@@ -0,0 +1,94 @@
+/**
+ * Hive Local LLM — Cliente interno
+ * Usado por los agentes y skills para generar texto vía WebSocket
+ */
+
+export interface GenerateOptions {
+  prompt: string
+  model?: "e2b_iq3" | "e4b_iq3" | "e2b_q8" | "e4b_q8"
+  imagePath?: string
+  audioPath?: string
+  nPredict?: number
+  timeout?: number
+}
+
+function getBaseURL(): string {
+  if (typeof globalThis !== "undefined" && "window" in globalThis) {
+    const win = (globalThis as any).window
+    const protocol = win.location.protocol === "https:" ? "wss:" : "ws:"
+    return `${protocol}//${win.location.host}`
+  }
+  return process.env.HIVE_LOCAL_WS_URL ?? "ws://localhost:3000"
+}
+
+const BASE_URL = getBaseURL()
+const WS_URL = `${BASE_URL}/ws/llm`
+
+/** Verifica si el servidor local está disponible */
+export async function isLocalLLMAvailable(): Promise<boolean> {
+  try {
+    const httpUrl = BASE_URL.replace(/^ws/, "http")
+    const res = await fetch(`${httpUrl}/api/llm/status`, {
+      signal: AbortSignal.timeout(1000),
+    })
+    return res.ok
+  } catch {
+    return false
+  }
+}
+
+/** Genera texto vía WebSocket con streaming */
+export async function* generateLocal(options: GenerateOptions): AsyncGenerator<string> {
+  const ws = new WebSocket(WS_URL)
+
+  await new Promise<void>((resolve, reject) => {
+    ws.onopen = () => resolve()
+    ws.onerror = () => reject(new Error("No se pudo conectar a hive-local"))
+  })
+
+  ws.send(JSON.stringify({
+    type: "generate",
+    prompt: options.prompt,
+    model: options.model ?? "e2b_iq3",
+    imagePath: options.imagePath,
+    audioPath: options.audioPath,
+    nPredict: options.nPredict ?? 512,
+  }))
+
+  const timeout = options.timeout ?? 60_000
+  const timeoutId = setTimeout(() => ws.close(1000, "timeout"), timeout)
+
+  try {
+    while (true) {
+      const message = await new Promise<string>((resolve, reject) => {
+        ws.onmessage = (event) => resolve(event.data as string)
+        ws.onerror = () => reject(new Error("WebSocket error"))
+        ws.onclose = () => reject(new Error("WebSocket cerrado"))
+      })
+
+      const data = JSON.parse(message)
+
+      if (data.type === "token") {
+        yield data.text
+      } else if (data.type === "done") {
+        break
+      } else if (data.type === "error") {
+        throw new Error(data.message)
+      }
+    }
+  } finally {
+    clearTimeout(timeoutId)
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.close()
+    }
+  }
+}
+
+/** Genera texto completo (no streaming, retorna string) */
+export async function generateLocalComplete(options: GenerateOptions): Promise<string> {
+  const tokens: string[] = []
+  for await (const token of generateLocal(options)) {
+    tokens.push(token)
+  }
+  return tokens.join(" ")
+}

package/packages/core/src/gateway/llm-local/detector.ts

@@ -0,0 +1,321 @@
+/**
+ * Hive Local LLM — Detector de GPU
+ * Detecta Vulkan, CUDA, Metal o fallback a CPU
+ *
+ * Estrategias para Vulkan (en orden):
+ *  1) vulkaninfo --summary   (si está instalado)
+ *  2) ICD JSON files + /sys/class/drm  (sin herramientas extra)
+ *  3) lspci                  (último recurso)
+ */
+
+export type GPUBackend = "cuda" | "vulkan" | "metal" | "rocm" | "none"
+export type PlatformArch = "linux-x64" | "linux-arm64" | "windows-x64" | "macos-x64" | "macos-arm64"
+export type GPUType = "iGPU" | "dGPU"
+
+export interface GPUInfo {
+  backend: GPUBackend
+  deviceName?: string
+  vramMB?: number
+  gpuType?: GPUType
+  platform: PlatformArch
+}
+
+function detectPlatform(): PlatformArch {
+  const os = process.platform
+  const arch = process.arch
+
+  if (os === "linux" && arch === "x64") return "linux-x64"
+  if (os === "linux" && arch === "arm64") return "linux-arm64"
+  if (os === "win32" && arch === "x64") return "windows-x64"
+  if (os === "darwin" && arch === "x64") return "macos-x64"
+  if (os === "darwin" && arch === "arm64") return "macos-arm64"
+
+  throw new Error(`Plataforma no soportada: ${os}/${arch}`)
+}
+
+/** Intenta detectar CUDA via nvidia-smi */
+async function detectCUDA(): Promise<{ deviceName: string; vramMB: number } | null> {
+  try {
+    const proc = Bun.spawn(["nvidia-smi", "--query-gpu=name,memory.total", "--format=csv,noheader"], {
+      stdout: "pipe",
+      stderr: "pipe",
+    })
+    const output = await new Response(proc.stdout).text()
+    const exitCode = await proc.exited
+    if (exitCode !== 0) return null
+
+    const line = output.trim().split("\n")[0]
+    if (!line) return null
+    const match = line.match(/^(.+?),\s*(\d+)\s*MiB/)
+    if (!match) return null
+
+    return { deviceName: match[1].trim(), vramMB: parseInt(match[2], 10) }
+  } catch {
+    return null
+  }
+}
+
+/** Lee un archivo del sistema de forma segura */
+async function readSysFile(path: string): Promise<string | null> {
+  try {
+    const file = Bun.file(path)
+    if (!(await file.exists())) return null
+    return (await file.text()).trim()
+  } catch {
+    return null
+  }
+}
+
+/** Mapea vendor ID hex a nombre legible */
+function vendorName(vendorId: string): string {
+  const map: Record<string, string> = {
+    "0x1002": "AMD",
+    "0x8086": "Intel",
+    "0x10de": "NVIDIA",
+    "0x1af4": "VirtIO",
+  }
+  return map[vendorId.toLowerCase()] ?? vendorId
+}
+
+/** Nombres amigables para cada ICD conocido */
+const KNOWN_ICDS: Record<string, string> = {
+  intel_icd: "Intel Graphics",
+  radeon_icd: "AMD Radeon",
+  amd_icd: "AMD Radeon",
+  nvidia_icd: "NVIDIA GPU",
+  nouveau_icd: "NVIDIA (nouveau)",
+  lvp_icd: "llvmpipe (Software)",
+  dzn_icd: "Microsoft DirectX (dzn)",
+  virtio_icd: "VirtIO GPU",
+  asahi_icd: "Apple Silicon GPU",
+}
+
+const SOFTWARE_ICDS = ["lvp_icd", "dzn_icd"]
+
+/** Detecta Vulkan con 3 estrategias en cascada */
+async function detectVulkan(): Promise<{
+  deviceName: string
+  vramMB?: number
+  gpuType?: GPUType
+} | null> {
+  // ── Estrategia 1: vulkaninfo (más preciso, si está instalado) ────────────────
+  try {
+    const proc = Bun.spawn(["vulkaninfo", "--summary"], { stdout: "pipe", stderr: "pipe" })
+    const output = await new Response(proc.stdout).text()
+    const exitCode = await proc.exited
+    if (exitCode === 0) {
+      const deviceMatch = output.match(/deviceName\s*=\s*(.+)/)
+      if (deviceMatch) return { deviceName: deviceMatch[1].trim() }
+    }
+  } catch {
+    // vulkaninfo no instalado → siguiente estrategia
+  }
+
+  // ── Estrategia 2: ICD JSON files + /sys/class/drm ───────────────────────────
+  if (process.platform === "linux") {
+    const icdDirs = ["/usr/share/vulkan/icd.d", "/etc/vulkan/icd.d"]
+
+    for (const dir of icdDirs) {
+      let files: string[] = []
+      try {
+        const glob = new Bun.Glob("*.json")
+        files = await Array.fromAsync(glob.scan({ cwd: dir, absolute: true }))
+      } catch {
+        continue
+      }
+
+      if (files.length === 0) continue
+
+      // Ordenar: hardware primero, software al final
+      files.sort((a, b) => {
+        const swA = SOFTWARE_ICDS.some(k => a.includes(k)) ? 1 : 0
+        const swB = SOFTWARE_ICDS.some(k => b.includes(k)) ? 1 : 0
+        return swA - swB
+      })
+
+      // Recopilar tarjetas DRM disponibles una sola vez
+      let drmCards: string[] = []
+      try {
+        const drmGlob = new Bun.Glob("card*")
+        const all = await Array.fromAsync(drmGlob.scan({ cwd: "/sys/class/drm", absolute: true }))
+        drmCards = all.filter(c => /\/card\d+$/.test(c))
+      } catch {
+        // sin acceso a sysfs
+      }
+
+      // Procesar cada ICD
+      const hwResults: Array<{ deviceName: string; vramMB?: number; gpuType?: GPUType }> = []
+      const swResults: Array<{ deviceName: string }> = []
+
+      for (const filePath of files) {
+        const text = await readSysFile(filePath)
+        if (!text) continue
+
+        let icd: { ICD?: { library_path?: string } } = {}
+        try { icd = JSON.parse(text) } catch { continue }
+
+        const libPath = icd?.ICD?.library_path
+        if (!libPath) continue
+
+        // Verificar que la librería existe en el sistema
+        if (!(await Bun.file(libPath).exists())) continue
+
+        const baseName = filePath.split("/").pop()?.replace(/\.x86_64\.json$|\.arm64\.json$|\.json$/, "") ?? ""
+        const isSoftware = SOFTWARE_ICDS.some(k => baseName.includes(k))
+        const matchedKey = Object.keys(KNOWN_ICDS).find(k => baseName.includes(k))
+        let deviceName = matchedKey ? KNOWN_ICDS[matchedKey] : baseName
+
+        if (isSoftware) {
+          swResults.push({ deviceName })
+          continue
+        }
+
+        // Enriquecer con DRM sysfs
+        let vramMB: number | undefined
+        let gpuType: GPUType | undefined
+        let foundMatch = false
+
+        for (const cardPath of drmCards) {
+          const vendor = await readSysFile(`${cardPath}/device/vendor`)
+          if (!vendor) continue
+
+          const vName = vendorName(vendor)
+
+          // ¿Coincide este card con el ICD actual?
+          const matches =
+            (baseName.includes("intel") && vName === "Intel") ||
+            (baseName.includes("radeon") && vName === "AMD") ||
+            (baseName.includes("amd") && vName === "AMD") ||
+            (baseName.includes("nvidia") && vName === "NVIDIA") ||
+            (baseName.includes("nouveau") && vName === "NVIDIA") ||
+            (baseName.includes("virtio") && vName === "VirtIO")
+
+          if (!matches) continue
+          foundMatch = true
+
+          // VRAM desde sysfs (AMD expone mem_info_vram_total en bytes)
+          const vramRaw = await readSysFile(`${cardPath}/device/mem_info_vram_total`)
+          if (vramRaw) {
+            const bytes = parseInt(vramRaw, 10)
+            vramMB = Math.round(bytes / (1024 * 1024))
+            gpuType = bytes >= 512 * 1024 * 1024 ? "dGPU" : "iGPU"
+          }
+
+          // Enriquecer nombre con tipo de GPU
+          if (gpuType === "iGPU") {
+            deviceName = `${vName} iGPU (integrada)`
+          } else if (gpuType === "dGPU") {
+            deviceName = `${vName} GPU (dedicada)`
+          }
+
+          break
+        }
+
+        if (foundMatch) hwResults.push({ deviceName, vramMB, gpuType })
+      }
+
+      // Retornar el primer resultado de hardware real encontrado
+      if (hwResults.length > 0) return hwResults[0]
+      // Si no hay hardware, reportar software renderer
+      if (swResults.length > 0) return swResults[0]
+    }
+  }
+
+  // ── Estrategia 3: lspci (último recurso) ────────────────────────────────────
+  try {
+    const proc = Bun.spawn(["lspci"], { stdout: "pipe", stderr: "pipe" })
+    const output = await new Response(proc.stdout).text()
+    const exitCode = await proc.exited
+    if (exitCode === 0) {
+      const match = output.match(/(?:VGA|3D|Display)[^:]*:\s*(.+)/i)
+      if (match) return { deviceName: match[1].trim() }
+    }
+  } catch {
+    // lspci no disponible
+  }
+
+  return null
+}
+
+/** Detecta Metal en macOS */
+async function detectMetal(): Promise<{ deviceName: string } | null> {
+  if (process.platform !== "darwin") return null
+  return { deviceName: "Apple Metal" }
+}
+
+/** Detección completa de GPU y plataforma */
+export async function detectGPU(): Promise<GPUInfo> {
+  const platform = detectPlatform()
+
+  const cuda = await detectCUDA()
+  if (cuda) return { backend: "cuda", ...cuda, platform }
+
+  const vulkan = await detectVulkan()
+  if (vulkan) return { backend: "vulkan", ...vulkan, platform }
+
+  const metal = await detectMetal()
+  if (metal) return { backend: "metal", ...metal, platform }
+
+  return { backend: "none", platform }
+}
+
+/** Devuelve el nombre del binario según GPU y plataforma (legacy hive-cli) */
+export function getHiveCLIBinaryName(gpu: GPUInfo): string {
+  const { backend } = gpu
+  const backendPart = backend === "none" ? "cpu" : backend
+  const os = process.platform === "win32" ? "windows" : (process.platform === "darwin" ? "darwin" : "linux")
+  const arch = process.arch === "x64" ? "amd64" : (process.arch === "arm64" ? "arm64" : process.arch)
+  const ext = os === "windows" ? ".exe" : ""
+  return `hive-cli-${os}-${arch}-${backendPart}${ext}`
+}
+
+export const HIVE_CLI_RELEASE_BASE = "https://github.com/johpaz/hive-cli/releases/download"
+export const HIVE_CLI_VERSION = "v0.0.1"
+
+export function getHiveCLIDownloadURL(binaryName: string): string {
+  return `${HIVE_CLI_RELEASE_BASE}/${HIVE_CLI_VERSION}/${binaryName}`
+}
+
+/** 
+ * Devuelve el sufijo del binario oficial de llama.cpp según GPU y plataforma
+ * Basado en GUIA-SERVIDOR.md
+ */
+export function getLlamaServerSuffix(gpu: GPUInfo): string {
+  const { backend, platform } = gpu
+  
+  switch (platform) {
+    case "linux-x64":
+      if (backend === "vulkan") return "bin-ubuntu-vulkan-x64"
+      if (backend === "cuda") return "bin-ubuntu-cuda-x64" // Nota: el oficial suele ser vulkan/cpu/rocm/sycl en ubuntu
+      if (backend === "rocm") return "bin-ubuntu-rocm-7.2-x64"
+      return "bin-ubuntu-x64"
+      
+    case "linux-arm64":
+      if (backend === "vulkan") return "bin-ubuntu-vulkan-arm64"
+      return "bin-ubuntu-arm64"
+      
+    case "windows-x64":
+      if (backend === "cuda") return "bin-win-cuda-12.4-x64"
+      if (backend === "vulkan") return "bin-win-vulkan-x64"
+      return "bin-win-cpu-x64"
+      
+    case "macos-arm64":
+      return "bin-macos-arm64"
+      
+    case "macos-x64":
+      return "bin-macos-x64"
+      
+    default:
+      return "bin-ubuntu-x64"
+  }
+}
+
+export const LLAMA_CPP_RELEASE_BASE = "https://github.com/ggml-org/llama.cpp/releases/download"
+export const LLAMA_CPP_DEFAULT_VER = "b9025"
+
+export function getLlamaServerDownloadURL(suffix: string, version: string = LLAMA_CPP_DEFAULT_VER): string {
+  const isWin = suffix.includes("win")
+  const ext = isWin ? "zip" : "tar.gz"
+  const filename = `llama-${version}-${suffix}.${ext}`
+  return `${LLAMA_CPP_RELEASE_BASE}/${version}/${filename}`
+}

package/packages/core/src/gateway/llm-local/downloader.ts

@@ -0,0 +1,216 @@
+/**
+ * Hive Local LLM — Downloader
+ * Descarga binarios desde GitHub releases y modelos desde HuggingFace
+ */
+
+import { existsSync, mkdirSync } from "fs"
+import { join, dirname } from "path"
+import { homedir } from "os"
+import { detectGPU, getHiveCLIBinaryName, getHiveCLIDownloadURL, getLlamaServerSuffix, getLlamaServerDownloadURL, LLAMA_CPP_DEFAULT_VER } from "./detector"
+
+const LLM_ROOT =
+  process.env.HIVE_LLM_ROOT ??
+  join(process.env.HIVE_HOME ?? join(homedir(), ".hive"), "llm-local")
+
+export const BIN_DIR = join(LLM_ROOT, "bin")
+export const MODELS_DIR = join(LLM_ROOT, "models")
+
+if (!existsSync(BIN_DIR)) mkdirSync(BIN_DIR, { recursive: true })
+if (!existsSync(MODELS_DIR)) mkdirSync(MODELS_DIR, { recursive: true })
+
+/** URLs de modelos en HuggingFace (Gemma 4 según GUIA-SERVIDOR.md) */
+export const HF_MODEL_URLS = {
+  mmproj: "https://huggingface.co/unsloth/gemma-4-E4B-it-GGUF/resolve/main/mmproj-BF16.gguf",
+  e2b_Q4_K_XL: "https://huggingface.co/unsloth/gemma-4-E2B-it-GGUF/resolve/main/gemma-4-E2B-it-UD-Q4_K_XL.gguf",
+  e4b_Q4_K_XL: "https://huggingface.co/unsloth/gemma-4-E4B-it-GGUF/resolve/main/gemma-4-E4B-it-UD-Q4_K_XL.gguf"
+}
+
+export type ModelId = "mmproj" | "e2b_Q4_K_XL" | "e4b_Q4_K_XL"
+
+/** Modelos que requieren proyector de visión (mmproj) */
+export const VISION_MODELS: ModelId[] = ["e4b_Q4_K_XL"]
+
+export const MODEL_FILES: Record<ModelId, string> = {
+  mmproj: "mmproj-BF16.gguf",
+  e2b_Q4_K_XL: "gemma-4-E2B-it-UD-Q4_K_XL.gguf",
+  e4b_Q4_K_XL: "gemma-4-E4B-it-UD-Q4_K_XL.gguf",
+}
+
+export function getModelPath(modelId: ModelId): string {
+  return join(MODELS_DIR, MODEL_FILES[modelId])
+}
+
+export function isModelDownloaded(modelId: ModelId): boolean {
+  return existsSync(getModelPath(modelId))
+}
+
+/** Descarga un archivo con progreso (streaming a disco para evitar OOM) */
+export async function downloadFile(
+  url: string,
+  dest: string,
+  onProgress?: (downloaded: number, total: number) => void
+): Promise<void> {
+  const res = await fetch(url)
+  if (!res.ok) throw new Error(`HTTP ${res.status} al descargar ${url}`)
+
+  const total = Number(res.headers.get("content-length") ?? 0)
+  const reader = res.body?.getReader()
+  if (!reader) throw new Error("No body en respuesta")
+
+  const writer = Bun.file(dest).writer()
+  let downloaded = 0
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+
+      writer.write(value)
+      downloaded += value.byteLength
+      if (onProgress) onProgress(downloaded, total)
+    }
+    await writer.end()
+  } catch (err) {
+    await writer.end()
+    throw err
+  }
+}
+
+/** Descarga el binario hive-cli si no existe */
+export async function installHiveCLI(): Promise<string> {
+  const gpu = await detectGPU()
+  const binaryName = getHiveCLIBinaryName(gpu)
+  const binaryPath = join(BIN_DIR, binaryName)
+
+  if (existsSync(binaryPath)) {
+    return binaryPath
+  }
+
+  console.log(`[hive-local] Instalando hive-cli para ${gpu.platform} + ${gpu.backend}...`)
+  const url = getHiveCLIDownloadURL(binaryName)
+
+  await downloadFile(url, binaryPath, (d, t) => {
+    const pct = t > 0 ? ((d / t) * 100).toFixed(1) : "?"
+    process.stdout.write(`\r  Descargando... ${pct}%`)
+  })
+  console.log("")
+
+  if (process.platform !== "win32") {
+    await Bun.spawn(["chmod", "+x", binaryPath]).exited
+  }
+
+  console.log(`[hive-local] ✓ hive-cli instalado en ${binaryPath}`)
+  return binaryPath
+}
+
+/** 
+ * Busca el binario llama-server sin descargarlo.
+ * Retorna la ruta si existe, o null si no está instalado.
+ */
+export async function findLlamaServerBinary(): Promise<string | null> {
+  const ext = process.platform === "win32" ? ".exe" : ""
+  const versionDir = join(BIN_DIR, `llama-${LLAMA_CPP_DEFAULT_VER}`)
+  const binaryPath = join(versionDir, `llama-server${ext}`)
+  return existsSync(binaryPath) ? binaryPath : null
+}
+
+/** 
+ * Instala llama-server oficial si no existe 
+ * Retorna la ruta al binario llama-server.
+ * ⚠️ Esta función DESCARGA el binario — solo llamar por acción explícita del usuario.
+ */
+export async function installLlamaServer(): Promise<string> {
+  const gpu = await detectGPU()
+  const suffix = getLlamaServerSuffix(gpu)
+  const version = LLAMA_CPP_DEFAULT_VER
+
+  // Directorio específico de la versión para evitar conflictos
+  const versionDir = join(BIN_DIR, `llama-${version}`)
+  const ext = process.platform === "win32" ? ".exe" : ""
+  const binaryPath = join(versionDir, `llama-server${ext}`)
+
+  if (existsSync(binaryPath)) {
+    return binaryPath
+  }
+
+  if (!existsSync(versionDir)) mkdirSync(versionDir, { recursive: true })
+
+  console.log(`[hive-local] Instalando llama-server ${version} para ${gpu.platform} + ${gpu.backend}...`)
+  const url = getLlamaServerDownloadURL(suffix, version)
+  const isZip = url.endsWith(".zip")
+  const archivePath = join(BIN_DIR, `llama-${version}-${suffix}.${isZip ? "zip" : "tar.gz"}`)
+
+  await downloadFile(url, archivePath, (d, t) => {
+    const pct = t > 0 ? ((d / t) * 100).toFixed(1) : "?"
+    process.stdout.write(`\r  Descargando binarios... ${pct}%`)
+  })
+  console.log("")
+
+  // Extraer
+  console.log(`[hive-local] Extrayendo binarios...`)
+  if (isZip) {
+    if (process.platform === "win32") {
+      await Bun.spawn(["powershell", "-Command", `Expand-Archive -Path "${archivePath}" -DestinationPath "${versionDir}" -Force`]).exited
+    } else {
+      await Bun.spawn(["unzip", "-o", archivePath, "-d", versionDir]).exited
+    }
+  } else {
+    // El tar.gz oficial contiene una carpeta llama-bXXXXX/
+    await Bun.spawn(["tar", "-xzf", archivePath, "-C", BIN_DIR]).exited
+  }
+
+  // Limpiar archivo descargado
+  try {
+    const { unlinkSync } = await import("fs")
+    unlinkSync(archivePath)
+  } catch { /* ignore */ }
+
+  if (process.platform !== "win32") {
+    // Dar permisos a todos los binarios extraídos
+    await Bun.spawn(["chmod", "-R", "+x", versionDir]).exited
+  }
+
+  console.log(`[hive-local] ✓ llama-server instalado en ${binaryPath}`)
+  return binaryPath
+}
+
+/** Descarga un modelo si no existe */
+export async function downloadModel(
+  modelId: ModelId,
+  onProgress?: (downloaded: number, total: number) => void
+): Promise<string> {
+  const dest = getModelPath(modelId)
+
+  if (existsSync(dest)) {
+    return dest
+  }
+
+  const url = HF_MODEL_URLS[modelId]
+  console.log(`[hive-local] Descargando modelo ${modelId}...`)
+
+  await downloadFile(url, dest, onProgress)
+  console.log(`[hive-local] ✓ Modelo ${modelId} descargado`)
+
+  // Advertir si el modelo requiere visión y no tenemos mmproj (NO descargar automáticamente)
+  if (VISION_MODELS.includes(modelId) && !isModelDownloaded("mmproj")) {
+    console.warn(`[hive-local] ⚠️ El modelo ${modelId} requiere el proyector de visión (mmproj). Descárgalo manualmente desde la UI.`)
+  }
+
+  return dest
+}
+
+/** Descarga mmproj en postinstall (ligero) */
+export async function installMMProj(): Promise<string> {
+  return downloadModel("mmproj")
+}
+
+/** Lista modelos disponibles localmente (solo modelos de texto/visión finales) */
+export function listLocalModels(): { id: ModelId; name: string; size: string; downloaded: boolean }[] {
+  const models: ModelId[] = ["e2b_Q4_K_XL", "e4b_Q4_K_XL"]
+  return models.map((id) => ({
+    id,
+    name: MODEL_FILES[id],
+    size: id.includes("Q4_K_XL") ? "~5-8 GB" : "~2-3 GB",
+    downloaded: isModelDownloaded(id),
+  }))
+}

package/packages/core/src/gateway/llm-local/index.ts

@@ -0,0 +1,34 @@
+/**
+ * Hive Local LLM — Index
+ * Exporta todo el módulo
+ */
+
+export { detectGPU, getHiveCLIBinaryName, getHiveCLIDownloadURL, getLlamaServerSuffix, getLlamaServerDownloadURL } from "./detector"
+export type { GPUBackend, GPUInfo, PlatformArch } from "./detector"
+
+export {
+  installHiveCLI,
+  installLlamaServer,
+  findLlamaServerBinary,
+  downloadModel,
+  installMMProj,
+  listLocalModels,
+  isModelDownloaded,
+  getModelPath,
+  BIN_DIR,
+  MODELS_DIR,
+  HF_MODEL_URLS,
+} from "./downloader"
+export type { ModelId } from "./downloader"
+
+export { getModelConfig, buildLlamaServerArgs, buildHiveCLIArgs, getRecommendedModel } from "./models"
+export type { ModelConfig } from "./models"
+
+export { llamaManager } from "./manager"
+export type { ServerMode } from "./manager"
+
+export { handleLLMWebSocket, handleLLMStatus } from "./server"
+export type { LLMMessage } from "./server"
+
+export { isLocalLLMAvailable, generateLocal, generateLocalComplete } from "./client"
+export type { GenerateOptions } from "./client"