noosphere 0.4.1 → 0.7.0

package/dist/index.js

@@ -109,20 +109,7 @@ function resolveConfig(input) {
 }
 
 // src/logos.ts
-import { fileURLToPath } from "url";
-import { dirname, join, resolve } from "path";
-import { existsSync } from "fs";
-var _assetsDir = null;
-function assetsDir() {
-  if (_assetsDir) return _assetsDir;
-  try {
-    const __filename = fileURLToPath(import.meta.url);
-    _assetsDir = resolve(dirname(__filename), "..", "assets", "logos");
-  } catch {
-    _assetsDir = resolve(__dirname, "..", "assets", "logos");
-  }
-  return _assetsDir;
-}
+var CDN_BASE = "https://blockchainstarter.nyc3.digitaloceanspaces.com/noosphere/logos";
 var PROVIDER_IDS = [
   // Cloud LLM
   "openai",
@@ -170,6 +157,40 @@ var PROVIDER_IDS = [
   "nebius",
   "novita"
 ];
+var HAS_SVG = /* @__PURE__ */ new Set([
+  "openai",
+  "anthropic",
+  "google",
+  "groq",
+  "mistral",
+  "xai",
+  "openrouter",
+  "cerebras",
+  "huggingface",
+  "ollama",
+  "meta",
+  "deepseek",
+  "microsoft",
+  "nvidia",
+  "qwen",
+  "cohere",
+  "perplexity",
+  "amazon",
+  "baidu",
+  "together",
+  "fireworks-ai",
+  "replicate",
+  "nebius",
+  "novita",
+  "comfyui",
+  "fal",
+  "kokoro",
+  "piper",
+  "sambanova",
+  "pi-ai",
+  "zai"
+  // NO SVG: bytedance, tencent, xiaomi, ibm, ai21, inflection, upstage, minimax
+]);
 var _cache = /* @__PURE__ */ new Map();
 function getProviderLogo(providerId) {
   if (!providerId) return void 0;
@@ -192,13 +213,12 @@ function getProviderLogo(providerId) {
     }
   }
   if (!matchedId) return void 0;
-  const dir = assetsDir();
-  const svgPath = join(dir, "svg", `${matchedId}.svg`);
-  const pngPath = join(dir, "png", `${matchedId}.png`);
-  const logo = {};
-  if (existsSync(svgPath)) logo.svg = svgPath;
-  if (existsSync(pngPath)) logo.png = pngPath;
-  if (!logo.svg && !logo.png) return void 0;
+  const logo = {
+    png: `${CDN_BASE}/png/${matchedId}.png`
+  };
+  if (HAS_SVG.has(matchedId)) {
+    logo.svg = `${CDN_BASE}/svg/${matchedId}.svg`;
+  }
   _cache.set(providerId, logo);
   return logo;
 }
@@ -374,7 +394,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;
@@ -601,8 +621,8 @@ var PiAiProvider = class {
     let aborted = false;
     let resolveResult = null;
     let rejectResult = null;
-    const resultPromise = new Promise((resolve2, reject) => {
-      resolveResult = resolve2;
+    const resultPromise = new Promise((resolve, reject) => {
+      resolveResult = resolve;
       rejectResult = reject;
     });
     const ensureModel = async () => {
@@ -999,11 +1019,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",
@@ -1028,10 +1092,43 @@ 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}`,
+                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();
@@ -1371,6 +1468,890 @@ 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);
+  }
+}
+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] = 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)
+    ]);
+    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));
+      }
+    }
+    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));
+        }
+      }
+    }
+    return Array.from(models.values());
+  }
+  toModelInfo(m, status, isLocal) {
+    const name = m.name ?? m.model ?? "unknown";
+    const family = m.details?.family;
+    const logoProvider = inferLogoProvider(name, family);
+    return {
+      id: name,
+      provider: "ollama",
+      name,
+      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/providers/hf-local.ts
+import { readdir, readFile } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+var FETCH_TIMEOUT_MS3 = 5e3;
+var HF_HUB_API2 = "https://huggingface.co/api/models";
+var PIPELINE_TAG_TO_MODALITY = {
+  "text-to-image": "image",
+  "text-to-video": "video",
+  "text-to-audio": "tts",
+  "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"];
+  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 models = [];
+    const logo = getProviderLogo("huggingface");
+    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);
+        const pipelineTag = entry.pipeline_tag ?? "";
+        const modality = PIPELINE_TAG_TO_MODALITY[pipelineTag] ?? "image";
+        models.push({
+          id,
+          provider: "hf-local",
+          name: id.split("/").pop() ?? id,
+          modality,
+          local: true,
+          cost: { price: 0, unit: "free" },
+          logo,
+          status: "available",
+          localInfo: {
+            sizeBytes: 0,
+            runtime: "huggingface",
+            family: entry.library_name
+          },
+          capabilities: {}
+        });
+      }
+    }
+    return models;
+  }
+  async scanLocalCache() {
+    const models = [];
+    const cacheDir = join(homedir(), ".cache", "huggingface", "hub");
+    const logo = getProviderLogo("huggingface");
+    try {
+      const entries = await 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 = join(cacheDir, entry.name);
+        let snapshotHash;
+        try {
+          snapshotHash = (await readFile(join(modelDir, "refs", "main"), "utf-8")).trim();
+        } catch {
+          continue;
+        }
+        let pipelineTag = "";
+        const snapshotDir = join(modelDir, "snapshots", snapshotHash);
+        try {
+          const modelIndex = JSON.parse(await readFile(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 readFile(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";
+        models.push({
+          id: modelId,
+          provider: "hf-local",
+          name: modelId.split("/").pop() ?? modelId,
+          modality,
+          local: true,
+          cost: { price: 0, unit: "free" },
+          logo,
+          status: "installed",
+          localInfo: {
+            sizeBytes: 0,
+            runtime: "huggingface",
+            diskPath: snapshotDir
+          }
+        });
+      }
+    } catch {
+    }
+    return models;
+  }
+};
+
+// src/providers/whisper-local.ts
+import { execFile } from "child_process";
+import { access } from "fs/promises";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var WHISPER_MODELS = ["tiny", "base", "small", "medium", "large", "large-v2", "large-v3", "turbo"];
+function runPython(code, timeoutMs = 5e3) {
+  return new Promise((resolve, reject) => {
+    const proc = execFile("python3", ["-c", code], { timeout: timeoutMs }, (err, stdout) => {
+      if (err) reject(err);
+      else resolve(stdout.trim());
+    });
+  });
+}
+async function fileExists(path) {
+  try {
+    await 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 logo = getProviderLogo("huggingface");
+    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}`,
+        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(join2(homedir2(), ".cache", "whisper", `${name}.pt`));
+    }
+    const hfDir = join2(homedir2(), ".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
+import { execFile as execFile2 } from "child_process";
+import { access as access2 } from "fs/promises";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "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" }
+];
+function runPython2(code, timeoutMs = 5e3) {
+  return new Promise((resolve, reject) => {
+    execFile2("python3", ["-c", code], { timeout: timeoutMs }, (err, stdout) => {
+      if (err) reject(err);
+      else resolve(stdout.trim());
+    });
+  });
+}
+async function fileExists2(path) {
+  try {
+    await access2(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 logo = getProviderLogo("meta");
+    const models = [];
+    for (const m of AUDIOCRAFT_MODELS) {
+      const hfDir = join3(homedir3(), ".cache", "huggingface", "hub", `models--facebook--${m.id}`);
+      const installed = await fileExists2(hfDir);
+      models.push({
+        id: m.id,
+        provider: "audiocraft",
+        name: m.name,
+        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;
@@ -1561,6 +2542,30 @@ var Noosphere = class {
   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()) {
@@ -1611,10 +2616,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) {
@@ -1641,6 +2657,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);
+          }
         })()
       ]);
     }
@@ -1691,7 +2730,7 @@ var Noosphere = class {
           break;
         }
         const delay = backoffMs * Math.pow(2, attempt);
-        await new Promise((resolve2) => setTimeout(resolve2, delay));
+        await new Promise((resolve) => setTimeout(resolve, delay));
       }
     }
     throw lastError ?? new NoosphereError("Generation failed", {
@@ -1732,10 +2771,16 @@ var Noosphere = class {
   }
 };
 export {
+  AudioCraftProvider,
+  HfLocalProvider,
   Noosphere,
   NoosphereError,
+  OllamaProvider,
+  OpenAICompatProvider,
   PROVIDER_IDS,
   PROVIDER_LOGOS,
+  WhisperLocalProvider,
+  detectOpenAICompatServers,
   getAllProviderLogos,
   getProviderLogo
 };