vipcode 0.0.0-stage → 0.2.0

package/dist/commands.js

@@ -0,0 +1,119 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { readMarkdownDir } from "./frontmatter.js";
+import { GLOBAL_COMMANDS_DIR } from "./paths.js";
+import { truncate } from "./tools.js";
+const INIT_TEMPLATE = `Analiza este proyecto y crea (o mejora, si ya existe) el fichero AGENTS.md en la raíz, con las instrucciones que necesitaría otro agente de programación para trabajar aquí sin perder tiempo.
+
+Incluye solo lo que sea útil y concreto:
+- Para qué sirve el proyecto y su estructura de carpetas principal.
+- Cómo instalar dependencias, compilar, ejecutar, pasar los tests y el linter (comandos exactos, incluido cómo ejecutar un solo test).
+- Convenciones de código que se ven en el proyecto (estilo, nombres, idioma de los comentarios, cómo se organizan los ficheros).
+- Cosas que no son obvias y que conviene saber (variables de entorno, servicios externos, trampas conocidas).
+
+Antes de escribir, explora el proyecto (README, ficheros de configuración, package.json/pyproject/Makefile…, algunos ficheros de código).
+Si ya hay reglas en CLAUDE.md, .cursorrules, .cursor/rules o .github/copilot-instructions.md, incorpóralas.
+Escribe AGENTS.md en el idioma principal del proyecto (si dudas, en español), conciso: unas 20-60 líneas.
+$ARGUMENTS`;
+const REVIEW_TEMPLATE = `Revisa los cambios sin confirmar de este repositorio (usa \`git status\`, \`git diff\` y \`git diff --staged\`; si no hay cambios, revisa el último commit con \`git show\`).
+
+Busca, por orden de importancia: errores que romperían algo, casos límite no tratados, problemas de seguridad, código que no sigue el estilo del proyecto y cosas que se podrían simplificar.
+Para cada problema di el fichero y la línea, por qué es un problema y cómo lo arreglarías. No cambies nada: solo informa.
+$ARGUMENTS`;
+const BUILTIN = [
+    { name: "init", description: "Crea o mejora AGENTS.md con las instrucciones del proyecto", template: INIT_TEMPLATE, subtask: false, builtIn: true },
+    { name: "review", description: "Revisa los cambios sin confirmar (no modifica nada)", template: REVIEW_TEMPLATE, agent: "plan", subtask: false, builtIn: true },
+];
+// Comandos integrados + ~/.vipcode/commands + .vipcode/commands y .opencode/command(s) del proyecto + "commands" del config
+export function loadCommands(root, config) {
+    const commands = new Map();
+    for (const command of BUILTIN) {
+        commands.set(command.name, { ...command });
+    }
+    const dirs = [
+        GLOBAL_COMMANDS_DIR,
+        path.join(root, ".opencode", "command"),
+        path.join(root, ".opencode", "commands"),
+        path.join(root, ".vipcode", "commands"),
+    ];
+    for (const entry of readMarkdownDir(dirs)) {
+        const data = entry.data;
+        commands.set(entry.name, {
+            name: entry.name,
+            description: String(data.description || `Comando ${entry.name}`),
+            template: entry.body,
+            agent: data.agent ? String(data.agent) : undefined,
+            model: data.model ? String(data.model) : undefined,
+            subtask: Boolean(data.subtask),
+            builtIn: false,
+            source: entry.file,
+        });
+    }
+    for (const [name, input] of Object.entries(config.commands || {})) {
+        if (!input || typeof input.template !== "string") {
+            continue;
+        }
+        commands.set(name, {
+            name,
+            description: input.description || `Comando ${name}`,
+            template: input.template,
+            agent: input.agent,
+            model: input.model,
+            subtask: Boolean(input.subtask),
+            builtIn: false,
+        });
+    }
+    return [...commands.values()];
+}
+// Separa los argumentos respetando las comillas: a "b c" d → [a, b c, d]
+export function splitArgs(text) {
+    const result = [];
+    const pattern = /"([^"]*)"|'([^']*)'|(\S+)/g;
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+        result.push(match[1] ?? match[2] ?? match[3]);
+    }
+    return result;
+}
+function runShell(command, cwd) {
+    return new Promise((resolve) => {
+        let shell = "bash";
+        let args = ["-lc", command];
+        if (process.platform === "win32") {
+            shell = "cmd.exe";
+            args = ["/c", command];
+        }
+        const child = spawn(shell, args, { cwd, stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, GIT_PAGER: "cat", PAGER: "cat" } });
+        let output = "";
+        const timer = setTimeout(() => child.kill("SIGTERM"), 30000);
+        child.stdout.on("data", (d) => (output += d.toString()));
+        child.stderr.on("data", (d) => (output += d.toString()));
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            resolve(`(no se pudo ejecutar: ${err.message})`);
+        });
+        child.on("close", () => {
+            clearTimeout(timer);
+            resolve(truncate(output.trim(), 10000));
+        });
+    });
+}
+// Rellena la plantilla: $ARGUMENTS, $1…$9 y !`comando` (se sustituye por su salida)
+export async function expandCommand(command, args, root) {
+    const parts = splitArgs(args);
+    let text = command.template;
+    const usesArgs = /\$ARGUMENTS|\$\d/.test(text);
+    // Con función para que un "$&" dentro de los argumentos no se interprete
+    text = text.replace(/\$ARGUMENTS/g, () => args);
+    text = text.replace(/\$(\d)/g, (_match, n) => parts[Number(n) - 1] ?? "");
+    if (!usesArgs && args.trim() !== "") {
+        text += `\n\n${args}`;
+    }
+    const shellPattern = /!`([^`]+)`/g;
+    const commands = [...text.matchAll(shellPattern)];
+    for (const match of commands) {
+        const output = await runShell(match[1], root);
+        text = text.replace(match[0], () => output);
+    }
+    return text.trim();
+}

package/dist/config.js

@@ -0,0 +1,225 @@
+import fs from "node:fs";
+import path from "node:path";
+import { CONFIG_PATH, HOME_DIR } from "./paths.js";
+export { CONFIG_PATH, HOME_DIR, SESSIONS_DIR, STATE_PATH } from "./paths.js";
+export const DEFAULT_PERMISSION = {
+    edit: "ask",
+    bash: {
+        "*": "ask",
+        "git status*": "allow",
+        "git diff*": "allow",
+        "git log*": "allow",
+        "git show*": "allow",
+        "ls*": "allow",
+        pwd: "allow",
+    },
+    webfetch: "ask",
+    mcp: "ask",
+};
+export const DEFAULT_CONFIG = {
+    providers: [],
+    disabledProviders: [],
+    enabledProviders: [],
+    order: [],
+    model: "",
+    maxSteps: 50,
+    autoCompactTokens: 90000,
+    bashTimeoutMs: 120000,
+    maxWaitMs: 90000,
+    permission: DEFAULT_PERMISSION,
+    mcp: {},
+    lsp: {},
+    agents: {},
+    commands: {},
+    instructions: [],
+    snapshot: true,
+    autoUpdateModels: true,
+    checkUpdates: true,
+    keyless: true,
+    ranking: { enabled: true, metric: "coding", anonymousLast: false },
+    skills: { enabled: true, paths: [], disabled: [], external: true },
+    showReasoning: true,
+};
+// Proveedor de internet que se puede usar sin clave (los locales no cuentan)
+export function isAnonymous(provider) {
+    return Boolean(provider.noKey && !provider.local);
+}
+// Lo que se escribe la primera vez en ~/.vipcode/config.json para que sea fácil de editar
+const TEMPLATE = {
+    model: "",
+    order: [],
+    disabledProviders: [],
+    providers: [],
+    permission: DEFAULT_PERMISSION,
+    mcp: {},
+    lsp: {},
+    agents: {},
+    commands: {},
+    instructions: [],
+    maxSteps: DEFAULT_CONFIG.maxSteps,
+    autoCompactTokens: DEFAULT_CONFIG.autoCompactTokens,
+    bashTimeoutMs: DEFAULT_CONFIG.bashTimeoutMs,
+    maxWaitMs: DEFAULT_CONFIG.maxWaitMs,
+    snapshot: true,
+    autoUpdateModels: true,
+    keyless: true,
+    ranking: DEFAULT_CONFIG.ranking,
+    showReasoning: true,
+};
+// Avisos de la carga del config para enseñarlos al arrancar
+export const configNotices = [];
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// Mezcla objetos en profundidad; los arrays y los valores simples se sustituyen
+export function deepMerge(base, override) {
+    if (!isObject(base) || !isObject(override)) {
+        return override;
+    }
+    const result = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+        if (value === undefined) {
+            continue;
+        }
+        if (isObject(value) && isObject(result[key])) {
+            result[key] = deepMerge(result[key], value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function mergeModels(base, override) {
+    const result = base.map((model) => ({ ...model }));
+    for (const model of override) {
+        const index = result.findIndex((existing) => existing.id === model.id);
+        if (index >= 0) {
+            result[index] = { ...result[index], ...model };
+        }
+        else {
+            result.push({ ...model });
+        }
+    }
+    return result;
+}
+export function mergeProvider(base, override) {
+    let models = base.models;
+    if (Array.isArray(override.models)) {
+        if (override.replaceModels) {
+            models = override.models.map((model) => ({ ...model }));
+        }
+        else {
+            models = mergeModels(base.models, override.models);
+        }
+    }
+    return {
+        ...base,
+        ...override,
+        headers: { ...(base.headers || {}), ...(override.headers || {}) },
+        models,
+    };
+}
+export function mergeProviders(base, override) {
+    const result = base.map((provider) => ({ ...provider }));
+    for (const provider of override) {
+        if (!provider || typeof provider.name !== "string") {
+            continue;
+        }
+        const index = result.findIndex((existing) => existing.name === provider.name);
+        if (index >= 0) {
+            result[index] = mergeProvider(result[index], provider);
+        }
+        else {
+            result.push({ ...provider, models: provider.models || [] });
+        }
+    }
+    return result;
+}
+function mergeConfig(base, override) {
+    const result = { ...base };
+    const target = result;
+    for (const [key, value] of Object.entries(override)) {
+        if (value === undefined || key.startsWith("$")) {
+            continue;
+        }
+        if (key === "providers" && Array.isArray(value)) {
+            result.providers = mergeProviders(base.providers, value);
+        }
+        else if ((key === "instructions" || key === "disabledProviders") && Array.isArray(value)) {
+            target[key] = [...new Set([...target[key], ...value])];
+        }
+        else if (key === "lsp" && value === false) {
+            result.lsp = false;
+        }
+        else if (["permission", "mcp", "lsp", "agents", "commands", "ranking", "skills"].includes(key) && isObject(value)) {
+            target[key] = deepMerge(target[key] || {}, value);
+        }
+        else {
+            target[key] = value;
+        }
+    }
+    return result;
+}
+// El config.json que creaba la versión 0.1 traía la lista de proveedores entera (ya anticuada)
+function isOldGeneratedConfig(raw) {
+    const oldKeys = ["providers", "maxSteps", "autoCompactTokens", "bashTimeoutMs", "maxWaitMs"];
+    if (Object.keys(raw).some((key) => !oldKeys.includes(key))) {
+        return false;
+    }
+    const providers = raw.providers;
+    if (!Array.isArray(providers)) {
+        return false;
+    }
+    const names = providers.map((p) => p.name).join(",");
+    if (names !== "gemini,openrouter,cerebras,groq,mistral,github,ollama") {
+        return false;
+    }
+    return (raw.maxSteps === 40 && raw.autoCompactTokens === 90000 && raw.bashTimeoutMs === 120000 && raw.maxWaitMs === 90000);
+}
+function readJson(file) {
+    try {
+        const data = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (!isObject(data)) {
+            throw new Error("no es un objeto JSON");
+        }
+        return data;
+    }
+    catch (err) {
+        throw new Error(`No se pudo leer ${file}: ${err.message}`);
+    }
+}
+// Config del proyecto: vipcode.json o .vipcode/config.json en la carpeta donde ejecutas vipcode
+export function projectConfigFiles(root) {
+    const candidates = [path.join(root, "vipcode.json"), path.join(root, ".vipcode", "config.json")];
+    return candidates.filter((file) => path.resolve(file) !== path.resolve(CONFIG_PATH) && fs.existsSync(file));
+}
+// Cambia un valor de tu config global (~/.vipcode/config.json) sin tocar el resto
+export function setGlobalConfigValue(key, value) {
+    loadConfig();
+    const raw = readJson(CONFIG_PATH);
+    raw[key] = value;
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(raw, null, 2));
+}
+export function loadConfig(root = process.cwd()) {
+    fs.mkdirSync(HOME_DIR, { recursive: true });
+    // La primera vez creamos el config con los valores por defecto para que puedas editarlo
+    if (!fs.existsSync(CONFIG_PATH)) {
+        fs.writeFileSync(CONFIG_PATH, JSON.stringify(TEMPLATE, null, 2));
+    }
+    let raw = readJson(CONFIG_PATH);
+    if (isOldGeneratedConfig(raw)) {
+        fs.copyFileSync(CONFIG_PATH, `${CONFIG_PATH}.bak`);
+        fs.writeFileSync(CONFIG_PATH, JSON.stringify(TEMPLATE, null, 2));
+        raw = readJson(CONFIG_PATH);
+        configNotices.push(`He actualizado ${CONFIG_PATH} al formato nuevo (copia del antiguo en config.json.bak).`);
+    }
+    let config = mergeConfig(DEFAULT_CONFIG, raw);
+    for (const file of projectConfigFiles(root)) {
+        config = mergeConfig(config, readJson(file));
+    }
+    if (!Array.isArray(config.providers)) {
+        config.providers = [];
+    }
+    return config;
+}

package/dist/debug.js

@@ -0,0 +1,32 @@
+import fs from "node:fs";
+import { DEBUG_LOG_PATH, HOME_DIR } from "./paths.js";
+// Con VIPCODE_DEBUG=1 se apunta en ~/.vipcode/debug.log lo que pasa por dentro (peticiones, errores…)
+const enabled = process.env.VIPCODE_DEBUG === "1" || process.env.VIPCODE_DEBUG === "true";
+export function debugLog(...parts) {
+    if (!enabled) {
+        return;
+    }
+    const text = parts
+        .map((part) => {
+        if (typeof part === "string") {
+            return part;
+        }
+        if (part instanceof Error) {
+            return part.stack || part.message;
+        }
+        try {
+            return JSON.stringify(part);
+        }
+        catch {
+            return String(part);
+        }
+    })
+        .join(" ");
+    try {
+        fs.mkdirSync(HOME_DIR, { recursive: true });
+        fs.appendFileSync(DEBUG_LOG_PATH, `[${new Date().toISOString()}] ${text}\n`);
+    }
+    catch {
+        // no es grave si no se puede escribir el log
+    }
+}

package/dist/discovery.js

@@ -0,0 +1,277 @@
+import fs from "node:fs";
+import { readAuth, resolveCredentials } from "./auth.js";
+import { CATALOG, RETIRED_PROVIDERS } from "./catalog.js";
+import { configNotices, isAnonymous, mergeProvider } from "./config.js";
+import { debugLog } from "./debug.js";
+import { HOME_DIR, MODELS_CACHE_PATH } from "./paths.js";
+// Modelos que no sirven para chatear (embeddings, voz, imágenes, vídeo…)
+const NON_CHAT = /embed|bge-|minilm|rerank|guard|safety|moderation|whisper|tts|transcri|speech|audio-|native-audio|image|imagen|flux|diffusion|sdxl|video|veo|lyria|ocr|retriever|reward|nvclip|clip-|cosmos|bevformer|sparsedrive|streampetr|detector|studiovoice|riva|canary|parakeet|paligemma|grounding|aqa|deplot|kosmos|fuyu|neva|translate|computer-use|robotics|-live|usdcode|usdvalidate|usdsearch/i;
+export function readDiscovery() {
+    try {
+        const data = JSON.parse(fs.readFileSync(MODELS_CACHE_PATH, "utf8"));
+        if (data && typeof data === "object" && data.providers) {
+            return data;
+        }
+    }
+    catch {
+        // todavía no se ha descubierto nada
+    }
+    return { updated: 0, providers: {} };
+}
+function writeDiscovery(cache) {
+    try {
+        fs.mkdirSync(HOME_DIR, { recursive: true });
+        fs.writeFileSync(MODELS_CACHE_PATH, JSON.stringify(cache, null, 2));
+    }
+    catch {
+        // no es grave si no se puede guardar
+    }
+}
+export function discoveryIsStale(maxAgeMs = 24 * 60 * 60 * 1000) {
+    return Date.now() - readDiscovery().updated > maxAgeMs;
+}
+// Junta los modelos del catálogo con los descubiertos, manteniendo el orden del catálogo
+function combine(provider, discovered, handAdded = new Set()) {
+    const ids = new Set(discovered.map((model) => model.id));
+    let base = provider.models;
+    if (provider.pruneMissing) {
+        // Los que has puesto tú en la config no se quitan nunca
+        base = base.filter((model) => ids.has(model.id) || handAdded.has(model.id));
+    }
+    const known = new Set(provider.models.map((model) => model.id));
+    const extra = discovered.filter((model) => !known.has(model.id));
+    return [...base, ...extra];
+}
+function cloneProvider(provider) {
+    return { ...provider, models: provider.models.map((model) => ({ ...model })) };
+}
+// Lista final de proveedores: tus proveedores propios primero, luego el catálogo con tus cambios
+export function buildProviders(config, local = {}) {
+    const cache = readDiscovery();
+    const catalog = CATALOG.map(cloneProvider);
+    const custom = [];
+    const handAdded = new Map();
+    for (const user of config.providers) {
+        if (!user || typeof user.name !== "string") {
+            continue;
+        }
+        handAdded.set(user.name, new Set((user.models || []).map((model) => model.id)));
+        if (RETIRED_PROVIDERS[user.name] && String(user.baseURL || "").includes("models.github.ai")) {
+            const notice = `Ignoro el proveedor "${user.name}" de tu config: ${RETIRED_PROVIDERS[user.name]}.`;
+            if (!configNotices.includes(notice)) {
+                configNotices.push(notice);
+            }
+            continue;
+        }
+        const index = catalog.findIndex((provider) => provider.name === user.name);
+        if (index >= 0) {
+            catalog[index] = mergeProvider(catalog[index], user);
+        }
+        else {
+            custom.push({ ...user, custom: true, models: (user.models || []).map((model) => ({ ...model })) });
+        }
+    }
+    let list = [...custom, ...catalog];
+    list = list.map((provider) => {
+        const result = cloneProvider(provider);
+        const found = cache.providers[provider.name];
+        if (found && found.models.length > 0 && !provider.replaceModels) {
+            result.models = combine(result, found.models, handAdded.get(provider.name));
+        }
+        if (local[provider.name]) {
+            result.models = combine(result, local[provider.name]);
+        }
+        result.models = result.models.filter((model) => !model.disabled);
+        // Con "keyless": false, los anónimos solo se usan si les has puesto clave
+        if (config.keyless === false && isAnonymous(result)) {
+            result.noKey = false;
+        }
+        return result;
+    });
+    const disabled = new Set(config.disabledProviders || []);
+    const enabledOnly = new Set(config.enabledProviders || []);
+    return list.filter((provider) => {
+        if (disabled.has(provider.name) || provider.enabled === false) {
+            return false;
+        }
+        if (enabledOnly.size > 0 && !enabledOnly.has(provider.name)) {
+            return false;
+        }
+        return true;
+    });
+}
+async function fetchJson(url, credentials, provider, timeoutMs, signal) {
+    const headers = { accept: "application/json", ...(provider.headers || {}) };
+    if (credentials && credentials.apiKey !== "no-key") {
+        headers.authorization = `Bearer ${credentials.apiKey}`;
+    }
+    const signals = [AbortSignal.timeout(timeoutMs)];
+    if (signal) {
+        signals.push(signal);
+    }
+    const response = await fetch(url, { headers, signal: AbortSignal.any(signals) });
+    if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        throw new Error(`HTTP ${response.status} ${body.slice(0, 160)}`);
+    }
+    return response.json();
+}
+function contextOf(item, provider, known) {
+    const candidates = [
+        item.context_window,
+        item.max_context_length,
+        item.context_length,
+        item.max_model_len,
+        item.max_input_tokens,
+        item.limits?.max_input_tokens,
+        item.top_provider?.context_length,
+        item.context_window?.tokens,
+    ];
+    let context = known?.context || candidates.find((value) => typeof value === "number" && value > 0) || provider.defaultContext || 32000;
+    if (provider.contextCap) {
+        context = Math.min(context, provider.contextCap);
+    }
+    return context;
+}
+function isFreeModel(item, provider) {
+    const id = String(item.id || "");
+    if (provider.discover === "kilo") {
+        return item.isFree === true;
+    }
+    if (provider.discover === "llm7") {
+        // Los de pago van en el nivel "pro" y solo se usan pagando por consumo
+        return item.tier !== "pro" && item.usage_based_only !== true;
+    }
+    if (provider.discover === "openrouter") {
+        if (id.endsWith(":free")) {
+            return true;
+        }
+        const prompt = item.pricing?.prompt;
+        const completion = item.pricing?.completion;
+        return prompt !== undefined && Number(prompt) === 0 && Number(completion) === 0;
+    }
+    return /(^|[:/-])free$/i.test(id);
+}
+function supportsTools(item, provider) {
+    if (provider.discover === "openrouter" || provider.discover === "kilo") {
+        return Array.isArray(item.supported_parameters) && item.supported_parameters.includes("tools");
+    }
+    if (item.capabilities && typeof item.capabilities.function_calling === "boolean") {
+        return item.capabilities.function_calling;
+    }
+    if (item.capabilities && typeof item.capabilities.tools === "boolean") {
+        return item.capabilities.tools;
+    }
+    if (typeof item.tools_calling === "boolean") {
+        return item.tools_calling;
+    }
+    return true;
+}
+function supportsVision(item, known) {
+    const modalities = item.architecture?.input_modalities || item.input_modalities || item.modalities?.input;
+    if (Array.isArray(modalities)) {
+        return modalities.includes("image");
+    }
+    if (item.capabilities && typeof item.capabilities.vision === "boolean") {
+        return item.capabilities.vision;
+    }
+    return Boolean(known?.vision);
+}
+// Convierte la respuesta de /models en nuestra lista de modelos
+export function parseModels(json, provider) {
+    const items = Array.isArray(json?.data) ? json.data : Array.isArray(json) ? json : [];
+    const filter = provider.modelFilter ? new RegExp(provider.modelFilter, "i") : null;
+    const result = [];
+    const seen = new Set();
+    for (const item of items) {
+        let id = String(item?.id || item?.name || "");
+        if (id.startsWith("models/")) {
+            id = id.slice("models/".length);
+        }
+        if (!id || seen.has(id) || NON_CHAT.test(id) || id === "openrouter/auto") {
+            continue;
+        }
+        if (filter && !filter.test(id)) {
+            continue;
+        }
+        if (item.active === false || item.object === "embedding") {
+            continue;
+        }
+        // Modelos que no escriben texto (vectores, voz, imágenes): OVHcloud les pone max_completion_tokens 0 y LLM7 otro model_type
+        if (item.max_completion_tokens === 0 || (typeof item.model_type === "string" && item.model_type !== "chat")) {
+            continue;
+        }
+        if (item.deprecation && Date.parse(item.deprecation) < Date.now()) {
+            continue;
+        }
+        if (provider.freeOnly && !isFreeModel(item, provider)) {
+            continue;
+        }
+        if (!supportsTools(item, provider)) {
+            continue;
+        }
+        const inputs = item.architecture?.input_modalities;
+        if (Array.isArray(inputs) && !inputs.includes("text")) {
+            continue;
+        }
+        const known = provider.models.find((model) => model.id === id);
+        seen.add(id);
+        result.push({ id, context: contextOf(item, provider, known), vision: supportsVision(item, known) });
+    }
+    return result;
+}
+// Pide /models a cada proveedor con clave y guarda los modelos nuevos
+export async function refreshModels(providers, options = {}) {
+    const auth = readAuth();
+    const cache = readDiscovery();
+    const summary = { updated: [], failed: [] };
+    const targets = providers.filter((provider) => {
+        if (!provider.discover || provider.local) {
+            return false;
+        }
+        if (options.only && options.only.length > 0 && !options.only.includes(provider.name)) {
+            return false;
+        }
+        return resolveCredentials(provider, auth) !== null;
+    });
+    await Promise.allSettled(targets.map(async (provider) => {
+        const credentials = resolveCredentials(provider, auth);
+        const base = (credentials?.baseURL || provider.baseURL).replace(/\/+$/, "");
+        try {
+            const json = await fetchJson(`${base}/models`, credentials, provider, 20000, options.signal);
+            const models = parseModels(json, provider);
+            if (models.length === 0) {
+                throw new Error("no devolvió ningún modelo útil");
+            }
+            const before = new Set((cache.providers[provider.name]?.models || provider.models).map((model) => model.id));
+            cache.providers[provider.name] = { updated: Date.now(), models };
+            summary.updated.push({ name: provider.name, count: models.length, added: models.map((model) => model.id).filter((id) => !before.has(id)) });
+        }
+        catch (err) {
+            debugLog("descubrimiento", provider.name, err);
+            summary.failed.push({ name: provider.name, error: err.message });
+        }
+    }));
+    cache.updated = Date.now();
+    writeDiscovery(cache);
+    return summary;
+}
+// Comprueba deprisa qué servidores locales (Ollama, LM Studio…) están encendidos y qué modelos tienen
+export async function detectLocal(providers, timeoutMs = 500) {
+    const found = {};
+    await Promise.allSettled(providers
+        .filter((provider) => provider.local && provider.enabled !== false)
+        .map(async (provider) => {
+        try {
+            const json = await fetchJson(`${provider.baseURL.replace(/\/+$/, "")}/models`, null, provider, timeoutMs);
+            const models = parseModels(json, provider);
+            if (models.length > 0) {
+                found[provider.name] = models;
+            }
+        }
+        catch {
+            // no está encendido
+        }
+    }));
+    return found;
+}