noosphere 0.5.0 → 0.8.0

package/dist/index.cjs

@@ -20,10 +20,16 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AudioCraftProvider: () => AudioCraftProvider,
+  HfLocalProvider: () => HfLocalProvider,
   Noosphere: () => Noosphere,
   NoosphereError: () => NoosphereError,
+  OllamaProvider: () => OllamaProvider,
+  OpenAICompatProvider: () => OpenAICompatProvider,
   PROVIDER_IDS: () => PROVIDER_IDS,
   PROVIDER_LOGOS: () => PROVIDER_LOGOS,
+  WhisperLocalProvider: () => WhisperLocalProvider,
+  detectOpenAICompatServers: () => detectOpenAICompatServers,
   getAllProviderLogos: () => getAllProviderLogos,
   getProviderLogo: () => getProviderLogo
 });
@@ -336,20 +342,22 @@ var Registry = class {
     const cached = this.modelCache.get(provider);
     return cached?.models.find((m) => m.id === modelId) ?? null;
   }
-  async syncProvider(providerId) {
+  async syncProvider(providerId, modality) {
     const provider = this.providers.get(providerId);
     if (!provider) return 0;
-    const models = await provider.listModels();
+    if (modality && !provider.modalities.includes(modality)) return 0;
+    const models = await provider.listModels(modality);
     this.modelCache.set(providerId, { models, syncedAt: Date.now() });
     return models.length;
   }
-  async syncAll() {
+  async syncAll(modality) {
     const byProvider = {};
     const errors = [];
     let synced = 0;
     for (const provider of this.providers.values()) {
+      if (modality && !provider.modalities.includes(modality)) continue;
       try {
-        const count = await this.syncProvider(provider.id);
+        const count = await this.syncProvider(provider.id, modality);
         byProvider[provider.id] = count;
         synced += count;
       } catch (err) {
@@ -418,7 +426,7 @@ var UsageTracker = class {
       filtered = filtered.filter((e) => e.modality === options.modality);
     }
     const byProvider = {};
-    const byModality = { llm: 0, image: 0, video: 0, tts: 0 };
+    const byModality = { llm: 0, image: 0, video: 0, tts: 0, stt: 0, music: 0, embedding: 0 };
     let totalCost = 0;
     for (const event of filtered) {
       totalCost += event.cost;
@@ -1043,11 +1051,55 @@ var ComfyUIProvider = class {
     }
   }
   async listModels(modality) {
+    const models = [];
+    const logo = getProviderLogo("comfyui");
     try {
-      const res = await fetch(`${this.baseUrl}/object_info`);
-      if (!res.ok) return [];
-      const models = [];
-      const logo = getProviderLogo("comfyui");
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 5e3);
+      try {
+        const res = await fetch(`${this.baseUrl}/object_info`, { signal: controller.signal });
+        if (res.ok) {
+          const objectInfo = await res.json();
+          const ckptNode = objectInfo?.["CheckpointLoaderSimple"];
+          const ckptNames = ckptNode?.input?.required?.ckpt_name?.[0] ?? [];
+          for (const name of ckptNames) {
+            if (modality && modality !== "image") continue;
+            models.push({
+              id: `comfyui-ckpt-${name}`,
+              provider: "comfyui",
+              name: `ComfyUI: ${name}`,
+              modality: "image",
+              local: true,
+              cost: { price: 0, unit: "free" },
+              logo,
+              status: "installed",
+              localInfo: { sizeBytes: 0, runtime: "comfyui" },
+              capabilities: { maxWidth: 2048, maxHeight: 2048, supportsNegativePrompt: true }
+            });
+          }
+          const loraNode = objectInfo?.["LoraLoader"];
+          const loraNames = loraNode?.input?.required?.lora_name?.[0] ?? [];
+          for (const name of loraNames) {
+            if (modality && modality !== "image") continue;
+            models.push({
+              id: `comfyui-lora-${name}`,
+              provider: "comfyui",
+              name: `LoRA: ${name}`,
+              modality: "image",
+              local: true,
+              cost: { price: 0, unit: "free" },
+              logo,
+              status: "installed",
+              localInfo: { sizeBytes: 0, runtime: "comfyui" }
+            });
+          }
+        }
+      } finally {
+        clearTimeout(timer);
+      }
+    } catch {
+    }
+    if (models.length === 0) {
       if (!modality || modality === "image") {
         models.push({
           id: "comfyui-txt2img",
@@ -1072,10 +1124,44 @@ var ComfyUIProvider = class {
           capabilities: { maxDuration: 10, supportsImageToVideo: true }
         });
       }
-      return models;
-    } catch {
-      return [];
     }
+    if (!modality || modality === "image") {
+      try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 5e3);
+        try {
+          const res = await fetch(
+            "https://civitai.com/api/v1/models?types=Checkpoint&sort=Highest%20Rated&limit=50&nsfw=false",
+            { signal: controller.signal }
+          );
+          if (res.ok) {
+            const data = await res.json();
+            for (const item of data.items ?? []) {
+              const version = item.modelVersions?.[0];
+              models.push({
+                id: `civitai-${item.id}`,
+                provider: "comfyui",
+                name: item.name ?? `CivitAI Model ${item.id}`,
+                description: item.description ? item.description.replace(/<[^>]+>/g, "").trim().slice(0, 300) || void 0 : void 0,
+                modality: "image",
+                local: true,
+                cost: { price: 0, unit: "free" },
+                logo,
+                status: "available",
+                localInfo: {
+                  sizeBytes: version?.files?.[0]?.sizeKB ? version.files[0].sizeKB * 1024 : 0,
+                  runtime: "comfyui"
+                }
+              });
+            }
+          }
+        } finally {
+          clearTimeout(timer);
+        }
+      } catch {
+      }
+    }
+    return models;
   }
   async image(options) {
     const start = Date.now();
@@ -1415,6 +1501,1043 @@ var HuggingFaceProvider = class {
   }
 };
 
+// src/providers/ollama.ts
+var OLLAMA_FAMILY_TO_PROVIDER = {
+  "llama": "meta",
+  "codellama": "meta",
+  "gemma": "google",
+  "gemma2": "google",
+  "gemma3": "google",
+  "qwen": "qwen",
+  "qwen2": "qwen",
+  "qwen2.5": "qwen",
+  "qwen3": "qwen",
+  "deepseek": "deepseek",
+  "deepcoder": "deepseek",
+  "deepscaler": "deepseek",
+  "qwq": "qwen",
+  "phi": "microsoft",
+  "phi3": "microsoft",
+  "phi4": "microsoft",
+  "mistral": "mistral",
+  "mixtral": "mistral",
+  "codestral": "mistral",
+  "ministral": "mistral",
+  "nemotron": "nvidia",
+  "command": "cohere",
+  "command-r": "cohere",
+  "gpt-oss": "openai",
+  "starcoder": "huggingface",
+  "falcon": "meta",
+  "glm": "zai",
+  "granite": "ibm",
+  "olmo": "meta",
+  "yi": "zai",
+  "minimax": "minimax",
+  "kimi": "meta",
+  "dolphin": "ollama",
+  "wizard": "ollama",
+  "nomic": "ollama",
+  "mxbai": "ollama",
+  "bge": "ollama",
+  "all-minilm": "ollama",
+  "moondream": "ollama"
+};
+var VISION_MODELS = /* @__PURE__ */ new Set([
+  "llava",
+  "moondream",
+  "minicpm-v",
+  "llama3.2-vision",
+  "qwen2.5vl",
+  "gemma3",
+  "llava-llama3",
+  "llava-phi3",
+  "bakllava"
+]);
+function inferLogoProvider(modelName, _family) {
+  const base = modelName.split(":")[0].toLowerCase().replace(/^[^/]+\//, "");
+  const sortedPrefixes = Object.entries(OLLAMA_FAMILY_TO_PROVIDER).sort((a, b) => b[0].length - a[0].length);
+  for (const [prefix, provider] of sortedPrefixes) {
+    if (base === prefix || base.startsWith(prefix)) return provider;
+  }
+  return "ollama";
+}
+function supportsVision(modelName) {
+  const base = modelName.split(":")[0].toLowerCase();
+  for (const v of VISION_MODELS) {
+    if (base === v || base.startsWith(v)) return true;
+  }
+  return false;
+}
+async function fetchJson(url, options) {
+  const timeoutMs = options?.timeoutMs ?? 5e3;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, { ...options, signal: controller.signal });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    return await res.json();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function fetchOllamaDescriptions() {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 5e3);
+  try {
+    const res = await fetch("https://ollama.com/library", { signal: controller.signal });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const html = await res.text();
+    const descriptions = /* @__PURE__ */ new Map();
+    const cardRegex = /href="\/library\/([^"]+)"[\s\S]*?<p[^>]*>([\s\S]*?)<\/p>/g;
+    let match;
+    while ((match = cardRegex.exec(html)) !== null) {
+      const modelName = match[1].trim();
+      const desc = match[2].replace(/<[^>]*>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/\s+/g, " ").trim();
+      if (modelName && desc) {
+        descriptions.set(modelName, desc);
+      }
+    }
+    return descriptions;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var OllamaProvider = class {
+  id = "ollama";
+  name = "Ollama (Local)";
+  modalities = ["llm"];
+  isLocal = true;
+  baseUrl;
+  constructor(config) {
+    const host = config?.host ?? "http://localhost";
+    const port = config?.port ?? 11434;
+    const cleanHost = host.replace(/\/+$/, "");
+    const hasPort = /:\d+$/.test(cleanHost);
+    this.baseUrl = hasPort ? cleanHost : `${cleanHost}:${port}`;
+  }
+  async ping() {
+    try {
+      await fetchJson(`${this.baseUrl}/api/version`, { timeoutMs: 2e3 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async listModels(_modality) {
+    if (_modality && _modality !== "llm") return [];
+    const [localData, catalogData, runningData, descriptions] = await Promise.all([
+      fetchJson(`${this.baseUrl}/api/tags`, { timeoutMs: 5e3 }).catch(() => null),
+      fetchJson("https://ollama.com/api/tags", { timeoutMs: 5e3 }).catch(() => null),
+      fetchJson(`${this.baseUrl}/api/ps`, { timeoutMs: 5e3 }).catch(() => null),
+      fetchOllamaDescriptions().catch(() => /* @__PURE__ */ new Map())
+    ]);
+    const runningNames = /* @__PURE__ */ new Set();
+    if (runningData?.models) {
+      for (const m of runningData.models) {
+        runningNames.add(m.name);
+        runningNames.add(m.model);
+      }
+    }
+    const models = /* @__PURE__ */ new Map();
+    if (localData?.models) {
+      for (const m of localData.models) {
+        const isRunning = runningNames.has(m.name) || runningNames.has(m.model);
+        models.set(m.name, this.toModelInfo(m, isRunning ? "running" : "installed", true, descriptions));
+      }
+    }
+    if (catalogData?.models) {
+      for (const m of catalogData.models) {
+        const name = m.name;
+        if (!models.has(name)) {
+          models.set(name, this.toModelInfo(m, "available", false, descriptions));
+        }
+      }
+    }
+    return Array.from(models.values());
+  }
+  toModelInfo(m, status, isLocal, descriptions) {
+    const name = m.name ?? m.model ?? "unknown";
+    const family = m.details?.family;
+    const logoProvider = inferLogoProvider(name, family);
+    const baseName = name.split(":")[0];
+    const description = descriptions?.get(baseName);
+    return {
+      id: name,
+      provider: "ollama",
+      name,
+      ...description ? { description } : {},
+      modality: "llm",
+      local: true,
+      cost: { price: 0, unit: "free" },
+      logo: getProviderLogo(logoProvider),
+      status,
+      localInfo: {
+        sizeBytes: m.size ?? 0,
+        family: family ?? m.details?.family,
+        parameterSize: m.details?.parameter_size,
+        quantization: m.details?.quantization_level,
+        format: m.details?.format,
+        digest: m.digest,
+        modifiedAt: m.modified_at,
+        running: status === "running",
+        runtime: "ollama"
+      },
+      capabilities: {
+        contextWindow: 128e3,
+        supportsVision: supportsVision(name),
+        supportsStreaming: true
+      }
+    };
+  }
+  async chat(options) {
+    const start = Date.now();
+    const messages = options.messages.map((m) => ({
+      role: m.role,
+      content: m.content
+    }));
+    const body = {
+      model: options.model ?? "llama3.2",
+      messages,
+      stream: false
+    };
+    if (options.temperature !== void 0 || options.maxTokens !== void 0) {
+      body.options = {};
+      if (options.temperature !== void 0) body.options.temperature = options.temperature;
+      if (options.maxTokens !== void 0) body.options.num_predict = options.maxTokens;
+    }
+    const res = await fetch(`${this.baseUrl}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      throw new Error(`Ollama chat failed: ${res.status} ${await res.text()}`);
+    }
+    const data = await res.json();
+    return {
+      content: data.message?.content ?? "",
+      provider: "ollama",
+      model: options.model ?? "llama3.2",
+      modality: "llm",
+      latencyMs: Date.now() - start,
+      usage: {
+        cost: 0,
+        input: data.prompt_eval_count ?? 0,
+        output: data.eval_count ?? 0,
+        unit: "tokens"
+      }
+    };
+  }
+  stream(options) {
+    const self = this;
+    const start = Date.now();
+    let aborted = false;
+    let resolveResult = null;
+    let rejectResult = null;
+    const resultPromise = new Promise((resolve, reject) => {
+      resolveResult = resolve;
+      rejectResult = reject;
+    });
+    const messages = options.messages.map((m) => ({
+      role: m.role,
+      content: m.content
+    }));
+    const body = {
+      model: options.model ?? "llama3.2",
+      messages,
+      stream: true
+    };
+    if (options.temperature !== void 0 || options.maxTokens !== void 0) {
+      body.options = {};
+      if (options.temperature !== void 0) body.options.temperature = options.temperature;
+      if (options.maxTokens !== void 0) body.options.num_predict = options.maxTokens;
+    }
+    const asyncIterator = {
+      async *[Symbol.asyncIterator]() {
+        try {
+          const res = await fetch(`${self.baseUrl}/api/chat`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body)
+          });
+          if (!res.ok) {
+            throw new Error(`Ollama stream failed: ${res.status} ${await res.text()}`);
+          }
+          const reader = res.body.getReader();
+          const decoder = new TextDecoder();
+          let fullContent = "";
+          let finalData = null;
+          let buffer = "";
+          while (!aborted) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+              if (!line.trim()) continue;
+              try {
+                const chunk = JSON.parse(line);
+                if (chunk.message?.content) {
+                  fullContent += chunk.message.content;
+                  yield { type: "text_delta", delta: chunk.message.content };
+                }
+                if (chunk.done) {
+                  finalData = chunk;
+                }
+              } catch {
+              }
+            }
+          }
+          const result = {
+            content: fullContent,
+            provider: "ollama",
+            model: options.model ?? "llama3.2",
+            modality: "llm",
+            latencyMs: Date.now() - start,
+            usage: {
+              cost: 0,
+              input: finalData?.prompt_eval_count ?? 0,
+              output: finalData?.eval_count ?? 0,
+              unit: "tokens"
+            }
+          };
+          resolveResult?.(result);
+          yield { type: "done", result };
+        } catch (err) {
+          const error = err instanceof Error ? err : new Error(String(err));
+          rejectResult?.(error);
+          yield { type: "error", error };
+        }
+      }
+    };
+    return {
+      [Symbol.asyncIterator]: () => asyncIterator[Symbol.asyncIterator](),
+      result: () => resultPromise,
+      abort: () => {
+        aborted = true;
+      }
+    };
+  }
+  // --- Extra model management methods ---
+  async *pullModel(name) {
+    const res = await fetch(`${this.baseUrl}/api/pull`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name, stream: true })
+    });
+    if (!res.ok) {
+      throw new Error(`Ollama pull failed: ${res.status} ${await res.text()}`);
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          yield JSON.parse(line);
+        } catch {
+        }
+      }
+    }
+  }
+  async deleteModel(name) {
+    const res = await fetch(`${this.baseUrl}/api/delete`, {
+      method: "DELETE",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name })
+    });
+    if (!res.ok) {
+      throw new Error(`Ollama delete failed: ${res.status} ${await res.text()}`);
+    }
+  }
+  async showModel(name) {
+    const res = await fetch(`${this.baseUrl}/api/show`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name })
+    });
+    if (!res.ok) {
+      throw new Error(`Ollama show failed: ${res.status} ${await res.text()}`);
+    }
+    return await res.json();
+  }
+  async getRunningModels() {
+    const data = await fetchJson(`${this.baseUrl}/api/ps`, { timeoutMs: 5e3 });
+    return data?.models ?? [];
+  }
+};
+
+// src/utils/parse-readme.ts
+async function fetchReadmeDescription(modelId, timeoutMs = 5e3) {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const res = await fetch(
+        `https://huggingface.co/${modelId}/raw/main/README.md`,
+        { signal: controller.signal }
+      );
+      if (!res.ok) return void 0;
+      const text = await res.text();
+      return parseReadmeDescription(text);
+    } finally {
+      clearTimeout(timer);
+    }
+  } catch {
+    return void 0;
+  }
+}
+function parseReadmeDescription(readme) {
+  const withoutFrontmatter = readme.replace(/^---[\s\S]*?---\s*/, "");
+  const lines = withoutFrontmatter.split("\n");
+  let paragraph = "";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      if (paragraph) break;
+      continue;
+    }
+    if (trimmed.startsWith("#")) {
+      if (paragraph) break;
+      continue;
+    }
+    if (/^\[?!\[/.test(trimmed) || /^</.test(trimmed)) continue;
+    if (/^\[.*\]\(.*\)$/.test(trimmed)) continue;
+    paragraph += (paragraph ? " " : "") + trimmed;
+  }
+  if (!paragraph) return void 0;
+  paragraph = paragraph.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/<[^>]+>/g, "").trim();
+  if (!paragraph) return void 0;
+  if (paragraph.length > 300) paragraph = paragraph.slice(0, 297) + "...";
+  return paragraph;
+}
+
+// src/providers/hf-local.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var import_node_os = require("os");
+var FETCH_TIMEOUT_MS3 = 5e3;
+var HF_HUB_API2 = "https://huggingface.co/api/models";
+var HF_ORG_TO_LOGO_PROVIDER = {
+  "meta-llama": "meta",
+  "facebook": "meta",
+  "google": "google",
+  "microsoft": "microsoft",
+  "nvidia": "nvidia",
+  "mistralai": "mistral",
+  "Qwen": "qwen",
+  "deepseek-ai": "deepseek",
+  "openai": "openai",
+  "CohereForAI": "cohere",
+  "rhasspy": "piper",
+  "stabilityai": "huggingface",
+  "black-forest-labs": "huggingface",
+  "tiiuae": "huggingface",
+  "allenai": "huggingface",
+  "Salesforce": "huggingface"
+};
+var PIPELINE_TAG_TO_MODALITY = {
+  "text-to-image": "image",
+  "text-to-video": "video",
+  "text-to-audio": "music",
+  "text-to-speech": "tts",
+  "automatic-speech-recognition": "stt"
+};
+var CATALOG_QUERIES = [
+  { pipeline_tag: "text-to-image", limit: 50 },
+  { pipeline_tag: "text-to-video", limit: 30 },
+  { pipeline_tag: "text-to-audio", limit: 30 },
+  { pipeline_tag: "text-to-speech", limit: 30 },
+  { pipeline_tag: "automatic-speech-recognition", limit: 30 },
+  { pipeline_tag: "text-to-image", limit: 100, library: "diffusers" }
+];
+async function fetchJsonTimeout(url, timeoutMs = FETCH_TIMEOUT_MS3) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, { signal: controller.signal });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var HfLocalProvider = class {
+  id = "hf-local";
+  name = "HuggingFace Local Models";
+  modalities = ["image", "video", "tts", "stt", "music"];
+  isLocal = true;
+  cachedModels = null;
+  async ping() {
+    return true;
+  }
+  async listModels(modality) {
+    if (!this.cachedModels) {
+      const [catalog, installed] = await Promise.all([
+        this.fetchCatalog(),
+        this.scanLocalCache()
+      ]);
+      const modelMap = /* @__PURE__ */ new Map();
+      for (const m of catalog) modelMap.set(m.id, m);
+      for (const m of installed) modelMap.set(m.id, m);
+      this.cachedModels = Array.from(modelMap.values());
+    }
+    if (modality) return this.cachedModels.filter((m) => m.modality === modality);
+    return this.cachedModels;
+  }
+  async fetchCatalog() {
+    const seen = /* @__PURE__ */ new Set();
+    const entries = [];
+    const results = await Promise.allSettled(
+      CATALOG_QUERIES.map(async (q) => {
+        const params = new URLSearchParams({
+          pipeline_tag: q.pipeline_tag,
+          sort: "downloads",
+          limit: String(q.limit)
+        });
+        if (q.library) params.set("library", q.library);
+        return fetchJsonTimeout(`${HF_HUB_API2}?${params}`);
+      })
+    );
+    for (const result of results) {
+      if (result.status !== "fulfilled" || !Array.isArray(result.value)) continue;
+      for (const entry of result.value) {
+        const id = entry.id ?? entry.modelId;
+        if (!id || seen.has(id)) continue;
+        seen.add(id);
+        entries.push({
+          id,
+          pipelineTag: entry.pipeline_tag ?? "",
+          libraryName: entry.library_name
+        });
+      }
+    }
+    const descriptionMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < entries.length; i += 10) {
+      const batch = entries.slice(i, i + 10);
+      const descs = await Promise.allSettled(
+        batch.map(async (e) => {
+          const desc = await fetchReadmeDescription(e.id);
+          return { id: e.id, desc };
+        })
+      );
+      for (const d of descs) {
+        if (d.status === "fulfilled" && d.value.desc) {
+          descriptionMap.set(d.value.id, d.value.desc);
+        }
+      }
+    }
+    const models = [];
+    for (const e of entries) {
+      const modality = PIPELINE_TAG_TO_MODALITY[e.pipelineTag] ?? "image";
+      const org = e.id.includes("/") ? e.id.split("/")[0] : void 0;
+      const logoProvider = org ? HF_ORG_TO_LOGO_PROVIDER[org] ?? "huggingface" : "huggingface";
+      models.push({
+        id: e.id,
+        provider: "hf-local",
+        name: e.id.split("/").pop() ?? e.id,
+        modality,
+        local: true,
+        cost: { price: 0, unit: "free" },
+        logo: getProviderLogo(logoProvider),
+        description: descriptionMap.get(e.id),
+        status: "available",
+        localInfo: {
+          sizeBytes: 0,
+          runtime: "huggingface",
+          family: e.libraryName
+        },
+        capabilities: {}
+      });
+    }
+    return models;
+  }
+  async scanLocalCache() {
+    const models = [];
+    const cacheDir = (0, import_node_path.join)((0, import_node_os.homedir)(), ".cache", "huggingface", "hub");
+    try {
+      const entries = await (0, import_promises.readdir)(cacheDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory() || !entry.name.startsWith("models--")) continue;
+        const parts = entry.name.replace("models--", "").split("--");
+        const modelId = parts.join("/");
+        const modelDir = (0, import_node_path.join)(cacheDir, entry.name);
+        let snapshotHash;
+        try {
+          snapshotHash = (await (0, import_promises.readFile)((0, import_node_path.join)(modelDir, "refs", "main"), "utf-8")).trim();
+        } catch {
+          continue;
+        }
+        let pipelineTag = "";
+        const snapshotDir = (0, import_node_path.join)(modelDir, "snapshots", snapshotHash);
+        try {
+          const modelIndex = JSON.parse(await (0, import_promises.readFile)((0, import_node_path.join)(snapshotDir, "model_index.json"), "utf-8"));
+          if (modelIndex._class_name?.includes("Stable") || modelIndex._class_name?.includes("Flux")) {
+            pipelineTag = "text-to-image";
+          } else if (modelIndex._class_name?.includes("Video") || modelIndex._class_name?.includes("Animate")) {
+            pipelineTag = "text-to-video";
+          }
+        } catch {
+          try {
+            const config = JSON.parse(await (0, import_promises.readFile)((0, import_node_path.join)(snapshotDir, "config.json"), "utf-8"));
+            if (config.task_specific_params?.["text-to-image"]) pipelineTag = "text-to-image";
+            else if (config.model_type?.includes("whisper")) pipelineTag = "automatic-speech-recognition";
+          } catch {
+          }
+        }
+        const modality = PIPELINE_TAG_TO_MODALITY[pipelineTag] ?? "image";
+        const org = modelId.includes("/") ? modelId.split("/")[0] : void 0;
+        const logoProvider = org ? HF_ORG_TO_LOGO_PROVIDER[org] ?? "huggingface" : "huggingface";
+        models.push({
+          id: modelId,
+          provider: "hf-local",
+          name: modelId.split("/").pop() ?? modelId,
+          modality,
+          local: true,
+          cost: { price: 0, unit: "free" },
+          logo: getProviderLogo(logoProvider),
+          status: "installed",
+          localInfo: {
+            sizeBytes: 0,
+            runtime: "huggingface",
+            diskPath: snapshotDir
+          }
+        });
+      }
+    } catch {
+    }
+    return models;
+  }
+};
+
+// src/providers/whisper-local.ts
+var import_node_child_process = require("child_process");
+var import_promises2 = require("fs/promises");
+var import_node_path2 = require("path");
+var import_node_os2 = require("os");
+var WHISPER_MODELS = ["tiny", "base", "small", "medium", "large", "large-v2", "large-v3", "turbo"];
+var WHISPER_HF_REPOS = {
+  "tiny": "openai/whisper-tiny",
+  "base": "openai/whisper-base",
+  "small": "openai/whisper-small",
+  "medium": "openai/whisper-medium",
+  "large": "openai/whisper-large",
+  "large-v2": "openai/whisper-large-v2",
+  "large-v3": "openai/whisper-large-v3",
+  "turbo": "openai/whisper-large-v3-turbo"
+};
+async function fetchWhisperDescriptions() {
+  const descriptions = /* @__PURE__ */ new Map();
+  const fetches = Object.entries(WHISPER_HF_REPOS).map(async ([size, repo]) => {
+    const desc = await fetchReadmeDescription(repo, 8e3);
+    if (desc) descriptions.set(size, desc);
+  });
+  await Promise.allSettled(fetches);
+  return descriptions;
+}
+function runPython(code, timeoutMs = 5e3) {
+  return new Promise((resolve, reject) => {
+    const proc = (0, import_node_child_process.execFile)("python3", ["-c", code], { timeout: timeoutMs }, (err, stdout) => {
+      if (err) reject(err);
+      else resolve(stdout.trim());
+    });
+  });
+}
+async function fileExists(path) {
+  try {
+    await (0, import_promises2.access)(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var WhisperLocalProvider = class {
+  id = "whisper-local";
+  name = "Whisper (Local)";
+  modalities = ["stt"];
+  isLocal = true;
+  runtime = null;
+  async ping() {
+    return await this.detectRuntime() !== null;
+  }
+  async detectRuntime() {
+    if (this.runtime) return this.runtime;
+    try {
+      await runPython('import faster_whisper; print("ok")');
+      this.runtime = "faster-whisper";
+      return this.runtime;
+    } catch {
+    }
+    try {
+      await runPython("import whisper; print(whisper.__version__)");
+      this.runtime = "whisper";
+      return this.runtime;
+    } catch {
+    }
+    return null;
+  }
+  async listModels(_modality) {
+    if (_modality && _modality !== "stt") return [];
+    const runtime = await this.detectRuntime();
+    if (!runtime) return [];
+    const descMap = await fetchWhisperDescriptions().catch(() => /* @__PURE__ */ new Map());
+    const logo = getProviderLogo("openai");
+    const models = [];
+    for (const name of WHISPER_MODELS) {
+      const installed = await this.isModelCached(name, runtime);
+      models.push({
+        id: `whisper-${name}`,
+        provider: "whisper-local",
+        name: `Whisper ${name}`,
+        description: descMap.get(name),
+        modality: "stt",
+        local: true,
+        cost: { price: 0, unit: "free" },
+        logo,
+        status: installed ? "installed" : "available",
+        localInfo: {
+          sizeBytes: 0,
+          runtime
+        }
+      });
+    }
+    return models;
+  }
+  async isModelCached(name, runtime) {
+    if (runtime === "whisper") {
+      return fileExists((0, import_node_path2.join)((0, import_node_os2.homedir)(), ".cache", "whisper", `${name}.pt`));
+    }
+    const hfDir = (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".cache", "huggingface", "hub", `models--Systran--faster-whisper-${name}`);
+    return fileExists(hfDir);
+  }
+  async transcribe(options) {
+    const runtime = await this.detectRuntime();
+    if (!runtime) throw new Error("Whisper is not installed");
+    const model = options.model?.replace("whisper-", "") ?? "base";
+    const lang = options.language ? `--language ${options.language}` : "";
+    const task = options.task ?? "transcribe";
+    if (runtime === "faster-whisper") {
+      const code = `
+import json, sys
+from faster_whisper import WhisperModel
+model = WhisperModel("${model}")
+segments, info = model.transcribe("${options.audio}", task="${task}"${options.language ? `, language="${options.language}"` : ""})
+segs = [{"start": s.start, "end": s.end, "text": s.text} for s in segments]
+print(json.dumps({"text": " ".join(s["text"] for s in segs), "language": info.language, "duration": info.duration, "segments": segs}))
+`;
+      const output = await runPython(code, 12e4);
+      return JSON.parse(output);
+    } else {
+      const code = `
+import json, whisper
+model = whisper.load_model("${model}")
+result = model.transcribe("${options.audio}", task="${task}"${options.language ? `, language="${options.language}"` : ""})
+segs = [{"start": s["start"], "end": s["end"], "text": s["text"]} for s in result.get("segments", [])]
+print(json.dumps({"text": result["text"], "language": result.get("language", ""), "duration": 0, "segments": segs}))
+`;
+      const output = await runPython(code, 12e4);
+      return JSON.parse(output);
+    }
+  }
+};
+
+// src/providers/audiocraft.ts
+var import_node_child_process2 = require("child_process");
+var import_promises3 = require("fs/promises");
+var import_node_path3 = require("path");
+var import_node_os3 = require("os");
+var AUDIOCRAFT_MODELS = [
+  { id: "musicgen-small", name: "MusicGen Small" },
+  { id: "musicgen-medium", name: "MusicGen Medium" },
+  { id: "musicgen-large", name: "MusicGen Large" },
+  { id: "musicgen-melody", name: "MusicGen Melody" },
+  { id: "audiogen-medium", name: "AudioGen Medium" }
+];
+var AUDIOCRAFT_HF_REPOS = {
+  "musicgen-small": "facebook/musicgen-small",
+  "musicgen-medium": "facebook/musicgen-medium",
+  "musicgen-large": "facebook/musicgen-large",
+  "musicgen-melody": "facebook/musicgen-melody",
+  "audiogen-medium": "facebook/audiogen-medium"
+};
+async function fetchAudioCraftDescriptions() {
+  const descriptions = /* @__PURE__ */ new Map();
+  const fetches = Object.entries(AUDIOCRAFT_HF_REPOS).map(async ([id, repo]) => {
+    const desc = await fetchReadmeDescription(repo, 8e3);
+    if (desc) descriptions.set(id, desc);
+  });
+  await Promise.allSettled(fetches);
+  return descriptions;
+}
+function runPython2(code, timeoutMs = 5e3) {
+  return new Promise((resolve, reject) => {
+    (0, import_node_child_process2.execFile)("python3", ["-c", code], { timeout: timeoutMs }, (err, stdout) => {
+      if (err) reject(err);
+      else resolve(stdout.trim());
+    });
+  });
+}
+async function fileExists2(path) {
+  try {
+    await (0, import_promises3.access)(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var AudioCraftProvider = class {
+  id = "audiocraft";
+  name = "AudioCraft (Local)";
+  modalities = ["music"];
+  isLocal = true;
+  detected = null;
+  async ping() {
+    if (this.detected !== null) return this.detected;
+    try {
+      await runPython2('import audiocraft; print("ok")');
+      this.detected = true;
+    } catch {
+      this.detected = false;
+    }
+    return this.detected;
+  }
+  async listModels(_modality) {
+    if (_modality && _modality !== "music") return [];
+    if (!await this.ping()) return [];
+    const descMap = await fetchAudioCraftDescriptions().catch(() => /* @__PURE__ */ new Map());
+    const logo = getProviderLogo("meta");
+    const models = [];
+    for (const m of AUDIOCRAFT_MODELS) {
+      const hfDir = (0, import_node_path3.join)((0, import_node_os3.homedir)(), ".cache", "huggingface", "hub", `models--facebook--${m.id}`);
+      const installed = await fileExists2(hfDir);
+      models.push({
+        id: m.id,
+        provider: "audiocraft",
+        name: m.name,
+        description: descMap.get(m.id),
+        modality: "music",
+        local: true,
+        cost: { price: 0, unit: "free" },
+        logo,
+        status: installed ? "installed" : "available",
+        localInfo: {
+          sizeBytes: 0,
+          runtime: "audiocraft"
+        }
+      });
+    }
+    return models;
+  }
+};
+
+// src/providers/openai-compat.ts
+var FETCH_TIMEOUT_MS4 = 5e3;
+var KNOWN_LOCAL_SERVERS = [
+  { port: 8080, name: "llama.cpp / LocalAI", id: "llamacpp" },
+  { port: 1234, name: "LM Studio", id: "lmstudio" },
+  { port: 8e3, name: "vLLM", id: "vllm" },
+  { port: 5e3, name: "TabbyAPI", id: "tabbyapi" },
+  { port: 5001, name: "KoboldCpp", id: "koboldcpp" },
+  { port: 1337, name: "Jan", id: "jan" }
+];
+async function fetchJsonTimeout2(url, headers, timeoutMs = FETCH_TIMEOUT_MS4) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, { signal: controller.signal, headers });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var OpenAICompatProvider = class {
+  id;
+  name;
+  modalities = ["llm"];
+  isLocal = true;
+  baseUrl;
+  headers;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.id = config.id ?? `openai-compat-${new URL(config.baseUrl).port}`;
+    this.name = config.name ?? `OpenAI-Compatible (${this.baseUrl})`;
+    this.headers = { "Content-Type": "application/json" };
+    if (config.apiKey) {
+      this.headers["Authorization"] = `Bearer ${config.apiKey}`;
+    }
+  }
+  async ping() {
+    const data = await fetchJsonTimeout2(`${this.baseUrl}/v1/models`, this.headers, 2e3);
+    return data !== null;
+  }
+  async listModels(_modality) {
+    if (_modality && _modality !== "llm") return [];
+    const data = await fetchJsonTimeout2(`${this.baseUrl}/v1/models`, this.headers);
+    if (!data?.data || !Array.isArray(data.data)) return [];
+    const logo = getProviderLogo("openai");
+    return data.data.map((m) => ({
+      id: m.id,
+      provider: this.id,
+      name: m.id,
+      modality: "llm",
+      local: true,
+      cost: { price: 0, unit: "free" },
+      logo,
+      status: "running",
+      localInfo: {
+        sizeBytes: 0,
+        runtime: this.id
+      },
+      capabilities: {
+        supportsStreaming: true
+      }
+    }));
+  }
+  async chat(options) {
+    const start = Date.now();
+    const model = options.model ?? "default";
+    const body = {
+      model,
+      messages: options.messages,
+      stream: false
+    };
+    if (options.temperature !== void 0) body.temperature = options.temperature;
+    if (options.maxTokens !== void 0) body.max_tokens = options.maxTokens;
+    if (options.jsonMode) body.response_format = { type: "json_object" };
+    const res = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) throw new Error(`OpenAI-compat chat failed: ${res.status} ${await res.text()}`);
+    const data = await res.json();
+    const choice = data.choices?.[0];
+    return {
+      content: choice?.message?.content ?? "",
+      provider: this.id,
+      model,
+      modality: "llm",
+      latencyMs: Date.now() - start,
+      usage: {
+        cost: 0,
+        input: data.usage?.prompt_tokens ?? 0,
+        output: data.usage?.completion_tokens ?? 0,
+        unit: "tokens"
+      }
+    };
+  }
+  stream(options) {
+    const self = this;
+    const start = Date.now();
+    let aborted = false;
+    let resolveResult = null;
+    let rejectResult = null;
+    const resultPromise = new Promise((resolve, reject) => {
+      resolveResult = resolve;
+      rejectResult = reject;
+    });
+    const model = options.model ?? "default";
+    const body = {
+      model,
+      messages: options.messages,
+      stream: true
+    };
+    if (options.temperature !== void 0) body.temperature = options.temperature;
+    if (options.maxTokens !== void 0) body.max_tokens = options.maxTokens;
+    const asyncIterator = {
+      async *[Symbol.asyncIterator]() {
+        try {
+          const res = await fetch(`${self.baseUrl}/v1/chat/completions`, {
+            method: "POST",
+            headers: self.headers,
+            body: JSON.stringify(body)
+          });
+          if (!res.ok) throw new Error(`Stream failed: ${res.status} ${await res.text()}`);
+          const reader = res.body.getReader();
+          const decoder = new TextDecoder();
+          let fullContent = "";
+          let buffer = "";
+          while (!aborted) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+              if (!line.startsWith("data: ") || line === "data: [DONE]") continue;
+              try {
+                const chunk = JSON.parse(line.slice(6));
+                const delta = chunk.choices?.[0]?.delta?.content;
+                if (delta) {
+                  fullContent += delta;
+                  yield { type: "text_delta", delta };
+                }
+              } catch {
+              }
+            }
+          }
+          const result = {
+            content: fullContent,
+            provider: self.id,
+            model,
+            modality: "llm",
+            latencyMs: Date.now() - start,
+            usage: { cost: 0, unit: "tokens" }
+          };
+          resolveResult?.(result);
+          yield { type: "done", result };
+        } catch (err) {
+          const error = err instanceof Error ? err : new Error(String(err));
+          rejectResult?.(error);
+          yield { type: "error", error };
+        }
+      }
+    };
+    return {
+      [Symbol.asyncIterator]: () => asyncIterator[Symbol.asyncIterator](),
+      result: () => resultPromise,
+      abort: () => {
+        aborted = true;
+      }
+    };
+  }
+};
+async function detectOpenAICompatServers() {
+  const providers = [];
+  const results = await Promise.allSettled(
+    KNOWN_LOCAL_SERVERS.map(async (server) => {
+      const baseUrl = `http://localhost:${server.port}`;
+      const provider = new OpenAICompatProvider({
+        baseUrl,
+        name: server.name,
+        id: server.id
+      });
+      const ok = await provider.ping();
+      if (ok) return provider;
+      return null;
+    })
+  );
+  for (const result of results) {
+    if (result.status === "fulfilled" && result.value) {
+      providers.push(result.value);
+    }
+  }
+  return providers;
+}
+
 // src/noosphere.ts
 var Noosphere = class {
   config;
@@ -1597,14 +2720,38 @@ var Noosphere = class {
     if (!this.initialized) await this.init();
     return this.registry.getModel(provider, modelId);
   }
-  async syncModels() {
+  async syncModels(modality) {
     if (!this.initialized) await this.init();
-    return this.registry.syncAll();
+    return this.registry.syncAll(modality);
   }
   // --- Tracking Methods ---
   getUsage(options) {
     return this.tracker.getSummary(options);
   }
+  // --- Local Model Management ---
+  async installModel(name) {
+    if (!this.initialized) await this.init();
+    const provider = this.registry.getProvider("ollama");
+    if (!provider) throw new NoosphereError("Ollama provider not available", { code: "PROVIDER_UNAVAILABLE", provider: "ollama", modality: "llm" });
+    return provider.pullModel(name);
+  }
+  async uninstallModel(name) {
+    if (!this.initialized) await this.init();
+    const provider = this.registry.getProvider("ollama");
+    if (!provider) throw new NoosphereError("Ollama provider not available", { code: "PROVIDER_UNAVAILABLE", provider: "ollama", modality: "llm" });
+    await provider.deleteModel(name);
+  }
+  async getHardware() {
+    if (!this.initialized) await this.init();
+    const provider = this.registry.getProvider("ollama");
+    if (!provider) return { ollama: false, runningModels: [] };
+    try {
+      const runningModels = await provider.getRunningModels();
+      return { ollama: true, runningModels };
+    } catch {
+      return { ollama: false, runningModels: [] };
+    }
+  }
   // --- Lifecycle ---
   async dispose() {
     for (const provider of this.registry.getAllProviders()) {
@@ -1655,10 +2802,21 @@ var Noosphere = class {
           return false;
         }
       };
+      const ollamaCfg = local["ollama"];
       const comfyuiCfg = local["comfyui"];
       const piperCfg = local["piper"];
       const kokoroCfg = local["kokoro"];
       await Promise.allSettled([
+        // Ollama — auto-detect even without explicit config
+        (async () => {
+          const host = ollamaCfg?.host ?? "http://localhost";
+          const port = ollamaCfg?.port ?? 11434;
+          const provider = new OllamaProvider({ host, port });
+          const ok = await provider.ping();
+          if (ok) {
+            this.registry.addProvider(provider);
+          }
+        })(),
         // ComfyUI
         (async () => {
           if (comfyuiCfg?.enabled) {
@@ -1685,6 +2843,29 @@ var Noosphere = class {
               this.registry.addProvider(new LocalTTSProvider({ id: "kokoro", name: "Kokoro TTS", host: kokoroCfg.host, port: kokoroCfg.port }));
             }
           }
+        })(),
+        // HuggingFace local model catalog
+        (async () => {
+          this.registry.addProvider(new HfLocalProvider());
+        })(),
+        // Whisper local STT
+        (async () => {
+          const whisper = new WhisperLocalProvider();
+          const ok = await whisper.ping();
+          if (ok) this.registry.addProvider(whisper);
+        })(),
+        // AudioCraft local music generation
+        (async () => {
+          const audiocraft = new AudioCraftProvider();
+          const ok = await audiocraft.ping();
+          if (ok) this.registry.addProvider(audiocraft);
+        })(),
+        // Auto-detect OpenAI-compatible servers
+        (async () => {
+          const servers = await detectOpenAICompatServers();
+          for (const server of servers) {
+            this.registry.addProvider(server);
+          }
         })()
       ]);
     }
@@ -1777,10 +2958,16 @@ var Noosphere = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AudioCraftProvider,
+  HfLocalProvider,
   Noosphere,
   NoosphereError,
+  OllamaProvider,
+  OpenAICompatProvider,
   PROVIDER_IDS,
   PROVIDER_LOGOS,
+  WhisperLocalProvider,
+  detectOpenAICompatServers,
   getAllProviderLogos,
   getProviderLogo
 });