noosphere 0.1.0 → 0.1.2

package/dist/index.cjs

@@ -0,0 +1,1318 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Noosphere: () => Noosphere,
+  NoosphereError: () => NoosphereError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var RETRYABLE_CODES = /* @__PURE__ */ new Set([
+  "PROVIDER_UNAVAILABLE",
+  "RATE_LIMITED",
+  "TIMEOUT",
+  "GENERATION_FAILED"
+]);
+var NoosphereError = class extends Error {
+  code;
+  provider;
+  modality;
+  model;
+  cause;
+  constructor(message, options) {
+    super(message);
+    this.name = "NoosphereError";
+    this.code = options.code;
+    this.provider = options.provider;
+    this.modality = options.modality;
+    this.model = options.model;
+    this.cause = options.cause;
+  }
+  isRetryable() {
+    return RETRYABLE_CODES.has(this.code);
+  }
+};
+
+// src/config.ts
+var ENV_KEY_MAP = {
+  openai: "OPENAI_API_KEY",
+  anthropic: "ANTHROPIC_API_KEY",
+  google: "GEMINI_API_KEY",
+  fal: "FAL_KEY",
+  openrouter: "OPENROUTER_API_KEY",
+  huggingface: "HUGGINGFACE_TOKEN",
+  groq: "GROQ_API_KEY",
+  mistral: "MISTRAL_API_KEY",
+  xai: "XAI_API_KEY"
+};
+var LOCAL_DEFAULTS = {
+  ollama: { host: "http://localhost", port: 11434, envHost: "OLLAMA_HOST", envPort: "OLLAMA_PORT" },
+  comfyui: { host: "http://localhost", port: 8188, envHost: "COMFYUI_HOST", envPort: "COMFYUI_PORT" },
+  piper: { host: "http://localhost", port: 5500, envHost: "PIPER_HOST", envPort: "PIPER_PORT" },
+  kokoro: { host: "http://localhost", port: 5501, envHost: "KOKORO_HOST", envPort: "KOKORO_PORT" }
+};
+var DEFAULT_RETRYABLE = [
+  "PROVIDER_UNAVAILABLE",
+  "RATE_LIMITED",
+  "TIMEOUT"
+];
+function resolveConfig(input) {
+  const keys = {};
+  for (const [name, envVar] of Object.entries(ENV_KEY_MAP)) {
+    keys[name] = input.keys?.[name] ?? process.env[envVar];
+  }
+  const local = {};
+  for (const [name, defaults] of Object.entries(LOCAL_DEFAULTS)) {
+    const cfgLocal = input.local?.[name];
+    const envPort = process.env[defaults.envPort];
+    const envHost = process.env[defaults.envHost];
+    local[name] = {
+      enabled: cfgLocal?.enabled ?? true,
+      host: cfgLocal?.host ?? envHost ?? defaults.host,
+      port: cfgLocal?.port ?? (envPort ? parseInt(envPort, 10) : defaults.port),
+      type: cfgLocal?.type
+    };
+  }
+  const autoDetectEnv = process.env.NOOSPHERE_AUTO_DETECT_LOCAL;
+  const cacheTTLEnv = process.env.NOOSPHERE_DISCOVERY_CACHE_TTL;
+  return {
+    keys,
+    local,
+    customLocal: input.local?.custom ?? [],
+    defaults: input.defaults ?? {},
+    autoDetectLocal: input.autoDetectLocal ?? (autoDetectEnv !== void 0 ? autoDetectEnv !== "false" : true),
+    discoveryCacheTTL: input.discoveryCacheTTL ?? (cacheTTLEnv ? parseInt(cacheTTLEnv, 10) : 60),
+    retry: {
+      maxRetries: input.retry?.maxRetries ?? 2,
+      backoffMs: input.retry?.backoffMs ?? 1e3,
+      retryableErrors: input.retry?.retryableErrors ?? DEFAULT_RETRYABLE,
+      failover: input.retry?.failover ?? true
+    },
+    timeout: {
+      llm: input.timeout?.llm ?? 3e4,
+      image: input.timeout?.image ?? 12e4,
+      video: input.timeout?.video ?? 3e5,
+      tts: input.timeout?.tts ?? 6e4
+    },
+    onUsage: input.onUsage
+  };
+}
+
+// src/registry.ts
+var Registry = class {
+  providers = /* @__PURE__ */ new Map();
+  modelCache = /* @__PURE__ */ new Map();
+  // providerId -> cached models
+  cacheTTLMs;
+  constructor(cacheTTLMinutes) {
+    this.cacheTTLMs = cacheTTLMinutes * 60 * 1e3;
+  }
+  addProvider(provider) {
+    this.providers.set(provider.id, provider);
+  }
+  getProvider(id) {
+    return this.providers.get(id);
+  }
+  getAllProviders() {
+    return Array.from(this.providers.values());
+  }
+  resolveProvider(modality, preferredId) {
+    if (preferredId) {
+      const p = this.providers.get(preferredId);
+      if (p && p.modalities.includes(modality)) return p;
+      return null;
+    }
+    let bestCloud = null;
+    for (const p of this.providers.values()) {
+      if (!p.modalities.includes(modality)) continue;
+      if (p.isLocal) return p;
+      if (!bestCloud) bestCloud = p;
+    }
+    return bestCloud;
+  }
+  resolveModel(modelId, modality) {
+    for (const [providerId, cached] of this.modelCache) {
+      const model = cached.models.find(
+        (m) => m.id === modelId && m.modality === modality
+      );
+      if (model) {
+        const provider = this.providers.get(providerId);
+        if (provider) return { provider, model };
+      }
+    }
+    return null;
+  }
+  getModels(modality) {
+    const all = [];
+    for (const cached of this.modelCache.values()) {
+      for (const model of cached.models) {
+        if (!modality || model.modality === modality) {
+          all.push(model);
+        }
+      }
+    }
+    return all;
+  }
+  getModel(provider, modelId) {
+    const cached = this.modelCache.get(provider);
+    return cached?.models.find((m) => m.id === modelId) ?? null;
+  }
+  async syncProvider(providerId) {
+    const provider = this.providers.get(providerId);
+    if (!provider) return 0;
+    const models = await provider.listModels();
+    this.modelCache.set(providerId, { models, syncedAt: Date.now() });
+    return models.length;
+  }
+  async syncAll() {
+    const byProvider = {};
+    const errors = [];
+    let synced = 0;
+    for (const provider of this.providers.values()) {
+      try {
+        const count = await this.syncProvider(provider.id);
+        byProvider[provider.id] = count;
+        synced += count;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        errors.push(`${provider.id}: ${msg}`);
+        byProvider[provider.id] = 0;
+      }
+    }
+    return { synced, byProvider, errors };
+  }
+  isCacheStale(providerId) {
+    const cached = this.modelCache.get(providerId);
+    if (!cached) return true;
+    return Date.now() - cached.syncedAt > this.cacheTTLMs;
+  }
+  clearCache() {
+    this.modelCache.clear();
+  }
+  getProviderInfos(modality) {
+    const infos = [];
+    for (const provider of this.providers.values()) {
+      if (modality && !provider.modalities.includes(modality)) continue;
+      const cached = this.modelCache.get(provider.id);
+      infos.push({
+        id: provider.id,
+        name: provider.name,
+        modalities: provider.modalities,
+        local: provider.isLocal,
+        status: "online",
+        // ping-based status is set externally
+        modelCount: cached?.models.length ?? 0
+      });
+    }
+    return infos;
+  }
+};
+
+// src/tracking.ts
+var UsageTracker = class {
+  events = [];
+  onUsage;
+  constructor(onUsage) {
+    this.onUsage = onUsage;
+  }
+  async record(event) {
+    this.events.push(event);
+    if (this.onUsage) {
+      await this.onUsage(event);
+    }
+  }
+  getSummary(options) {
+    let filtered = this.events;
+    if (options?.since) {
+      const since = new Date(options.since).getTime();
+      filtered = filtered.filter((e) => new Date(e.timestamp).getTime() >= since);
+    }
+    if (options?.until) {
+      const until = new Date(options.until).getTime();
+      filtered = filtered.filter((e) => new Date(e.timestamp).getTime() <= until);
+    }
+    if (options?.provider) {
+      filtered = filtered.filter((e) => e.provider === options.provider);
+    }
+    if (options?.modality) {
+      filtered = filtered.filter((e) => e.modality === options.modality);
+    }
+    const byProvider = {};
+    const byModality = { llm: 0, image: 0, video: 0, tts: 0 };
+    let totalCost = 0;
+    for (const event of filtered) {
+      totalCost += event.cost;
+      byProvider[event.provider] = (byProvider[event.provider] ?? 0) + event.cost;
+      byModality[event.modality] += event.cost;
+    }
+    return {
+      totalCost,
+      totalRequests: filtered.length,
+      byProvider,
+      byModality
+    };
+  }
+  clear() {
+    this.events = [];
+  }
+};
+
+// src/providers/pi-ai.ts
+var import_pi_ai = require("@mariozechner/pi-ai");
+var KNOWN_PROVIDERS = ["anthropic", "google", "openai", "xai", "groq", "cerebras", "openrouter", "zai"];
+var LOCAL_PROVIDERS = /* @__PURE__ */ new Set(["ollama"]);
+function extractText(msg) {
+  return msg.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+}
+function extractThinking(msg) {
+  const thinking = msg.content.filter((c) => c.type === "thinking").map((c) => c.thinking).join("");
+  return thinking || void 0;
+}
+var PiAiProvider = class {
+  id = "pi-ai";
+  name = "pi-ai (LLM Gateway)";
+  modalities = ["llm"];
+  isLocal = false;
+  keys;
+  constructor(keys) {
+    this.keys = {};
+    for (const [k, v] of Object.entries(keys)) {
+      if (v) {
+        this.keys[k] = v;
+        if (KNOWN_PROVIDERS.includes(k)) {
+          (0, import_pi_ai.setApiKey)(k, v);
+        } else {
+          (0, import_pi_ai.setApiKey)(k, v);
+        }
+      }
+    }
+  }
+  async ping() {
+    try {
+      (0, import_pi_ai.getProviders)();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async listModels(modality) {
+    if (modality && modality !== "llm") return [];
+    const models = [];
+    for (const provider of KNOWN_PROVIDERS) {
+      try {
+        const providerModels = (0, import_pi_ai.getModels)(provider);
+        for (const m of providerModels) {
+          models.push({
+            id: m.id,
+            provider: "pi-ai",
+            name: m.name || m.id,
+            modality: "llm",
+            local: LOCAL_PROVIDERS.has(String(m.provider)),
+            cost: {
+              price: m.cost.input ?? 0,
+              unit: m.cost.input > 0 ? "per_1m_tokens" : "free"
+            },
+            capabilities: {
+              contextWindow: m.contextWindow,
+              maxTokens: m.maxTokens,
+              supportsVision: m.input.includes("image"),
+              supportsStreaming: true
+            }
+          });
+        }
+      } catch {
+      }
+    }
+    return models;
+  }
+  async chat(options) {
+    const start = Date.now();
+    const { model, provider } = this.findModel(options.model);
+    if (!model || !provider) {
+      throw new Error(`Model not found: ${options.model ?? "default"}`);
+    }
+    const context = {
+      systemPrompt: options.messages.find((m) => m.role === "system")?.content,
+      messages: options.messages.filter((m) => m.role !== "system").map((m) => ({
+        role: m.role,
+        content: m.content,
+        timestamp: Date.now()
+      }))
+    };
+    const response = await (0, import_pi_ai.complete)(model, context);
+    const inputTokens = response.usage?.input ?? 0;
+    const outputTokens = response.usage?.output ?? 0;
+    return {
+      content: extractText(response),
+      thinking: extractThinking(response),
+      provider: "pi-ai",
+      model: response.model ?? options.model ?? "unknown",
+      modality: "llm",
+      latencyMs: Date.now() - start,
+      usage: {
+        cost: response.usage?.cost?.total ?? 0,
+        input: inputTokens,
+        output: outputTokens,
+        unit: "tokens"
+      }
+    };
+  }
+  stream(options) {
+    const start = Date.now();
+    const { model, provider } = this.findModel(options.model);
+    if (!model || !provider) {
+      throw new Error(`Model not found: ${options.model ?? "default"}`);
+    }
+    const context = {
+      systemPrompt: options.messages.find((m) => m.role === "system")?.content,
+      messages: options.messages.filter((m) => m.role !== "system").map((m) => ({
+        role: m.role,
+        content: m.content,
+        timestamp: Date.now()
+      }))
+    };
+    const piStream = (0, import_pi_ai.stream)(model, context);
+    const self = this;
+    let aborted = false;
+    let resolveResult = null;
+    let rejectResult = null;
+    const resultPromise = new Promise((resolve, reject) => {
+      resolveResult = resolve;
+      rejectResult = reject;
+    });
+    const asyncIterator = {
+      async *[Symbol.asyncIterator]() {
+        try {
+          for await (const chunk of piStream) {
+            if (aborted) break;
+            if (chunk.type === "text_delta") {
+              yield { type: "text_delta", delta: chunk.delta };
+            } else if (chunk.type === "thinking_delta") {
+              yield { type: "thinking_delta", delta: chunk.delta };
+            }
+          }
+          const final = await piStream.result();
+          const inputTokens = final.usage?.input ?? 0;
+          const outputTokens = final.usage?.output ?? 0;
+          const result = {
+            content: extractText(final),
+            thinking: extractThinking(final),
+            provider: "pi-ai",
+            model: final.model ?? options.model ?? "unknown",
+            modality: "llm",
+            latencyMs: Date.now() - start,
+            usage: {
+              cost: final.usage?.cost?.total ?? 0,
+              input: inputTokens,
+              output: outputTokens,
+              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;
+      }
+    };
+  }
+  findModel(modelId) {
+    for (const provider of KNOWN_PROVIDERS) {
+      try {
+        const models = (0, import_pi_ai.getModels)(provider);
+        const found = modelId ? models.find((m) => m.id === modelId) : models[0];
+        if (found) return { model: found, provider };
+      } catch {
+      }
+    }
+    return { model: null, provider: null };
+  }
+};
+
+// src/providers/fal.ts
+var import_client = require("@fal-ai/client");
+var FAL_PRICING_URL = "https://api.fal.ai/v1/models/pricing";
+var FalProvider = class {
+  id = "fal";
+  name = "fal.ai";
+  modalities = ["image", "video", "tts"];
+  isLocal = false;
+  apiKey;
+  pricingCache = /* @__PURE__ */ new Map();
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+    import_client.fal.config({ credentials: apiKey });
+  }
+  async ping() {
+    return !!this.apiKey;
+  }
+  async listModels(modality) {
+    try {
+      const res = await fetch(FAL_PRICING_URL, {
+        headers: { Authorization: `Key ${this.apiKey}` }
+      });
+      if (!res.ok) return [];
+      const data = await res.json();
+      this.pricingCache.clear();
+      const models = [];
+      for (const entry of data) {
+        const inferredModality = this.inferModality(entry.modelId, entry.unit);
+        if (modality && inferredModality !== modality) continue;
+        this.pricingCache.set(entry.modelId, { price: entry.price, unit: entry.unit });
+        models.push({
+          id: entry.modelId,
+          provider: "fal",
+          name: entry.modelId.replace("fal-ai/", ""),
+          modality: inferredModality,
+          local: false,
+          cost: { price: entry.price, unit: entry.unit }
+        });
+      }
+      return models;
+    } catch {
+      return [];
+    }
+  }
+  async image(options) {
+    const model = options.model ?? "fal-ai/flux/schnell";
+    const start = Date.now();
+    const response = await import_client.fal.subscribe(model, {
+      input: {
+        prompt: options.prompt,
+        negative_prompt: options.negativePrompt,
+        image_size: options.width && options.height ? { width: options.width, height: options.height } : void 0,
+        seed: options.seed,
+        num_inference_steps: options.steps,
+        guidance_scale: options.guidanceScale
+      }
+    });
+    const image = response.data?.images?.[0];
+    const pricing = this.pricingCache.get(model);
+    return {
+      url: image?.url,
+      provider: "fal",
+      model,
+      modality: "image",
+      latencyMs: Date.now() - start,
+      usage: {
+        cost: pricing?.price ?? 0,
+        unit: pricing?.unit ?? "per_image"
+      },
+      media: {
+        width: image?.width,
+        height: image?.height,
+        format: "png"
+      }
+    };
+  }
+  async video(options) {
+    const model = options.model ?? "fal-ai/kling-video/v2/master/text-to-video";
+    const start = Date.now();
+    const response = await import_client.fal.subscribe(model, {
+      input: {
+        prompt: options.prompt,
+        image_url: options.imageUrl,
+        duration: options.duration,
+        fps: options.fps
+      }
+    });
+    const video = response.data?.video;
+    const pricing = this.pricingCache.get(model);
+    return {
+      url: video?.url ?? response.data?.video_url,
+      provider: "fal",
+      model,
+      modality: "video",
+      latencyMs: Date.now() - start,
+      usage: {
+        cost: pricing?.price ?? 0,
+        unit: pricing?.unit ?? "per_second"
+      },
+      media: {
+        width: options.width,
+        height: options.height,
+        duration: options.duration,
+        format: "mp4",
+        fps: options.fps
+      }
+    };
+  }
+  async speak(options) {
+    const model = options.model ?? "fal-ai/kokoro/american-english";
+    const start = Date.now();
+    const response = await import_client.fal.run(model, {
+      input: {
+        text: options.text,
+        voice: options.voice,
+        speed: options.speed
+      }
+    });
+    const audioUrl = response.data?.audio_url ?? response.data?.audio?.url;
+    const pricing = this.pricingCache.get(model);
+    return {
+      url: audioUrl,
+      provider: "fal",
+      model,
+      modality: "tts",
+      latencyMs: Date.now() - start,
+      usage: {
+        cost: pricing?.price ?? 0,
+        input: options.text.length,
+        unit: pricing?.unit ?? "per_1k_chars"
+      },
+      media: {
+        format: options.format ?? "mp3"
+      }
+    };
+  }
+  inferModality(modelId, unit) {
+    if (unit.includes("char") || modelId.includes("tts") || modelId.includes("kokoro") || modelId.includes("elevenlabs")) return "tts";
+    if (unit.includes("second") || modelId.includes("video") || modelId.includes("kling") || modelId.includes("sora") || modelId.includes("veo")) return "video";
+    return "image";
+  }
+};
+
+// src/providers/comfyui.ts
+var DEFAULT_TXT2IMG_WORKFLOW = {
+  "3": {
+    class_type: "KSampler",
+    inputs: {
+      seed: 0,
+      steps: 20,
+      cfg: 7,
+      sampler_name: "euler",
+      scheduler: "normal",
+      denoise: 1,
+      model: ["4", 0],
+      positive: ["6", 0],
+      negative: ["7", 0],
+      latent_image: ["5", 0]
+    }
+  },
+  "4": { class_type: "CheckpointLoaderSimple", inputs: { ckpt_name: "sd_xl_base_1.0.safetensors" } },
+  "5": { class_type: "EmptyLatentImage", inputs: { width: 1024, height: 1024, batch_size: 1 } },
+  "6": { class_type: "CLIPTextEncode", inputs: { text: "", clip: ["4", 1] } },
+  "7": { class_type: "CLIPTextEncode", inputs: { text: "", clip: ["4", 1] } },
+  "8": { class_type: "VAEDecode", inputs: { samples: ["3", 0], vae: ["4", 2] } },
+  "9": { class_type: "SaveImage", inputs: { filename_prefix: "noosphere", images: ["8", 0] } }
+};
+var ComfyUIProvider = class {
+  id = "comfyui";
+  name = "ComfyUI";
+  modalities = ["image", "video"];
+  isLocal = true;
+  baseUrl;
+  constructor(config) {
+    this.baseUrl = `${config.host}:${config.port}`;
+  }
+  async ping() {
+    try {
+      const res = await fetch(`${this.baseUrl}/system_stats`);
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+  async listModels(modality) {
+    try {
+      const res = await fetch(`${this.baseUrl}/object_info`);
+      if (!res.ok) return [];
+      const models = [];
+      if (!modality || modality === "image") {
+        models.push({
+          id: "comfyui-txt2img",
+          provider: "comfyui",
+          name: "ComfyUI Text-to-Image",
+          modality: "image",
+          local: true,
+          cost: { price: 0, unit: "free" },
+          capabilities: { maxWidth: 2048, maxHeight: 2048, supportsNegativePrompt: true }
+        });
+      }
+      if (!modality || modality === "video") {
+        models.push({
+          id: "comfyui-txt2vid",
+          provider: "comfyui",
+          name: "ComfyUI Text-to-Video",
+          modality: "video",
+          local: true,
+          cost: { price: 0, unit: "free" },
+          capabilities: { maxDuration: 10, supportsImageToVideo: true }
+        });
+      }
+      return models;
+    } catch {
+      return [];
+    }
+  }
+  async image(options) {
+    const start = Date.now();
+    const workflow = structuredClone(DEFAULT_TXT2IMG_WORKFLOW);
+    workflow["6"].inputs.text = options.prompt;
+    workflow["7"].inputs.text = options.negativePrompt ?? "";
+    workflow["5"].inputs.width = options.width ?? 1024;
+    workflow["5"].inputs.height = options.height ?? 1024;
+    if (options.seed !== void 0) workflow["3"].inputs.seed = options.seed;
+    if (options.steps !== void 0) workflow["3"].inputs.steps = options.steps;
+    if (options.guidanceScale !== void 0) workflow["3"].inputs.cfg = options.guidanceScale;
+    const queueRes = await fetch(`${this.baseUrl}/prompt`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ prompt: workflow })
+    });
+    if (!queueRes.ok) throw new Error(`ComfyUI queue failed: ${queueRes.status}`);
+    const { prompt_id } = await queueRes.json();
+    const imageData = await this.pollForResult(prompt_id);
+    return {
+      buffer: Buffer.from(imageData),
+      provider: "comfyui",
+      model: options.model ?? "comfyui-txt2img",
+      modality: "image",
+      latencyMs: Date.now() - start,
+      usage: { cost: 0, unit: "free" },
+      media: {
+        width: options.width ?? 1024,
+        height: options.height ?? 1024,
+        format: "png"
+      }
+    };
+  }
+  async video(_options) {
+    throw new Error("ComfyUI video generation requires a configured AnimateDiff workflow");
+  }
+  async pollForResult(promptId, maxWaitMs = 3e5) {
+    const deadline = Date.now() + maxWaitMs;
+    while (Date.now() < deadline) {
+      const res = await fetch(`${this.baseUrl}/history/${promptId}`);
+      if (!res.ok) {
+        await new Promise((r) => setTimeout(r, 1e3));
+        continue;
+      }
+      const history = await res.json();
+      const entry = history[promptId];
+      if (!entry?.outputs) {
+        await new Promise((r) => setTimeout(r, 1e3));
+        continue;
+      }
+      for (const nodeOutput of Object.values(entry.outputs)) {
+        if (nodeOutput.images?.length > 0) {
+          const img = nodeOutput.images[0];
+          const imgRes = await fetch(
+            `${this.baseUrl}/view?filename=${img.filename}&subfolder=${img.subfolder}&type=${img.type}`
+          );
+          return imgRes.arrayBuffer();
+        }
+      }
+      await new Promise((r) => setTimeout(r, 1e3));
+    }
+    throw new Error(`ComfyUI generation timed out after ${maxWaitMs}ms`);
+  }
+};
+
+// src/providers/local-tts.ts
+var LocalTTSProvider = class {
+  id;
+  name;
+  modalities = ["tts"];
+  isLocal = true;
+  baseUrl;
+  constructor(config) {
+    this.id = config.id;
+    this.name = config.name;
+    this.baseUrl = `${config.host}:${config.port}`;
+  }
+  async ping() {
+    try {
+      const res = await fetch(`${this.baseUrl}/health`);
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+  async listModels(modality) {
+    if (modality && modality !== "tts") return [];
+    try {
+      let voices = [];
+      try {
+        const res = await fetch(`${this.baseUrl}/voices`);
+        if (res.ok) {
+          const data = await res.json();
+          if (Array.isArray(data)) {
+            voices = data;
+          }
+        }
+      } catch {
+        const res = await fetch(`${this.baseUrl}/v1/models`);
+        if (res.ok) {
+          const data = await res.json();
+          voices = data.data ?? [];
+        }
+      }
+      return voices.map((v) => ({
+        id: v.id,
+        provider: this.id,
+        name: v.name ?? v.id,
+        modality: "tts",
+        local: true,
+        cost: { price: 0, unit: "free" },
+        capabilities: { voices: voices.map((vv) => vv.id) }
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async speak(options) {
+    const start = Date.now();
+    const res = await fetch(`${this.baseUrl}/v1/audio/speech`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: options.model ?? "tts-1",
+        input: options.text,
+        voice: options.voice ?? "default",
+        speed: options.speed ?? 1,
+        response_format: options.format ?? "mp3"
+      })
+    });
+    if (!res.ok) {
+      throw new Error(`Local TTS failed: ${res.status} ${await res.text()}`);
+    }
+    const audioBuffer = Buffer.from(await res.arrayBuffer());
+    return {
+      buffer: audioBuffer,
+      provider: this.id,
+      model: options.model ?? options.voice ?? "default",
+      modality: "tts",
+      latencyMs: Date.now() - start,
+      usage: {
+        cost: 0,
+        input: options.text.length,
+        unit: "characters"
+      },
+      media: {
+        format: options.format ?? "mp3"
+      }
+    };
+  }
+};
+
+// src/providers/huggingface.ts
+var import_inference = require("@huggingface/inference");
+var HuggingFaceProvider = class {
+  id = "huggingface";
+  name = "HuggingFace Inference";
+  modalities = ["image", "tts", "llm"];
+  isLocal = false;
+  client;
+  constructor(token) {
+    this.client = new import_inference.HfInference(token);
+  }
+  async ping() {
+    return true;
+  }
+  async listModels(modality) {
+    const models = [];
+    if (!modality || modality === "image") {
+      models.push({
+        id: "stabilityai/stable-diffusion-xl-base-1.0",
+        provider: "huggingface",
+        name: "SDXL Base",
+        modality: "image",
+        local: false,
+        cost: { price: 0, unit: "free" }
+      });
+    }
+    if (!modality || modality === "tts") {
+      models.push({
+        id: "facebook/mms-tts-eng",
+        provider: "huggingface",
+        name: "MMS TTS English",
+        modality: "tts",
+        local: false,
+        cost: { price: 0, unit: "free" }
+      });
+    }
+    if (!modality || modality === "llm") {
+      models.push({
+        id: "meta-llama/Llama-3.1-8B-Instruct",
+        provider: "huggingface",
+        name: "Llama 3.1 8B",
+        modality: "llm",
+        local: false,
+        cost: { price: 0, unit: "free" }
+      });
+    }
+    return models;
+  }
+  async chat(options) {
+    const start = Date.now();
+    const model = options.model ?? "meta-llama/Llama-3.1-8B-Instruct";
+    const response = await this.client.chatCompletion({
+      model,
+      messages: options.messages,
+      temperature: options.temperature,
+      max_tokens: options.maxTokens
+    });
+    const choice = response.choices?.[0];
+    const usage = response.usage;
+    return {
+      content: choice?.message?.content ?? "",
+      provider: "huggingface",
+      model,
+      modality: "llm",
+      latencyMs: Date.now() - start,
+      usage: {
+        cost: 0,
+        input: usage?.prompt_tokens,
+        output: usage?.completion_tokens,
+        unit: "tokens"
+      }
+    };
+  }
+  async image(options) {
+    const start = Date.now();
+    const model = options.model ?? "stabilityai/stable-diffusion-xl-base-1.0";
+    const blob = await this.client.textToImage({
+      model,
+      inputs: options.prompt,
+      parameters: {
+        negative_prompt: options.negativePrompt,
+        width: options.width,
+        height: options.height,
+        guidance_scale: options.guidanceScale,
+        num_inference_steps: options.steps
+      }
+    }, { outputType: "blob" });
+    const buffer = Buffer.from(await blob.arrayBuffer());
+    return {
+      buffer,
+      provider: "huggingface",
+      model,
+      modality: "image",
+      latencyMs: Date.now() - start,
+      usage: { cost: 0, unit: "free" },
+      media: {
+        width: options.width ?? 1024,
+        height: options.height ?? 1024,
+        format: "png"
+      }
+    };
+  }
+  async speak(options) {
+    const start = Date.now();
+    const model = options.model ?? "facebook/mms-tts-eng";
+    const blob = await this.client.textToSpeech({
+      model,
+      inputs: options.text
+    });
+    const buffer = Buffer.from(await blob.arrayBuffer());
+    return {
+      buffer,
+      provider: "huggingface",
+      model,
+      modality: "tts",
+      latencyMs: Date.now() - start,
+      usage: {
+        cost: 0,
+        input: options.text.length,
+        unit: "characters"
+      },
+      media: { format: "wav" }
+    };
+  }
+};
+
+// src/noosphere.ts
+var Noosphere = class {
+  config;
+  registry;
+  tracker;
+  initialized = false;
+  constructor(config = {}) {
+    this.config = resolveConfig(config);
+    this.registry = new Registry(this.config.discoveryCacheTTL);
+    this.tracker = new UsageTracker(this.config.onUsage);
+  }
+  /** Register a custom provider adapter */
+  registerProvider(provider) {
+    this.registry.addProvider(provider);
+  }
+  // --- Generation Methods ---
+  async chat(options) {
+    if (!this.initialized) await this.init();
+    const provider = this.resolveProviderForModality("llm", options.provider, options.model);
+    if (!provider.chat) {
+      throw new NoosphereError(`Provider '${provider.id}' does not support chat`, {
+        code: "INVALID_INPUT",
+        provider: provider.id,
+        modality: "llm"
+      });
+    }
+    const start = Date.now();
+    try {
+      const result = await this.executeWithRetry(
+        "llm",
+        provider,
+        () => provider.chat(options),
+        (alt) => alt.chat ? () => alt.chat(options) : null
+      );
+      await this.trackUsage(result, options.metadata);
+      return result;
+    } catch (err) {
+      await this.trackError("llm", provider.id, options.model, start, err, options.metadata);
+      throw err;
+    }
+  }
+  stream(options) {
+    const self = this;
+    let innerStream;
+    let finalResult;
+    let providerRef;
+    const ensureInit = async () => {
+      if (!self.initialized) await self.init();
+      if (!providerRef) {
+        providerRef = self.resolveProviderForModality("llm", options.provider, options.model);
+        if (!providerRef.stream) {
+          throw new NoosphereError(`Provider '${providerRef.id}' does not support streaming`, {
+            code: "INVALID_INPUT",
+            provider: providerRef.id,
+            modality: "llm"
+          });
+        }
+        innerStream = providerRef.stream(options);
+      }
+    };
+    const wrappedIterator = {
+      async *[Symbol.asyncIterator]() {
+        await ensureInit();
+        try {
+          for await (const event of innerStream) {
+            if (event.type === "done" && event.result) {
+              finalResult = event.result;
+              await self.trackUsage(event.result, options.metadata);
+            }
+            yield event;
+          }
+        } catch (err) {
+          await self.trackError("llm", providerRef.id, options.model, Date.now(), err, options.metadata);
+          throw err;
+        }
+      }
+    };
+    return {
+      [Symbol.asyncIterator]: () => wrappedIterator[Symbol.asyncIterator](),
+      result: async () => {
+        if (finalResult) return finalResult;
+        for await (const event of wrappedIterator) {
+          if (event.type === "done" && event.result) return event.result;
+          if (event.type === "error" && event.error) throw event.error;
+        }
+        throw new NoosphereError("Stream ended without result", {
+          code: "GENERATION_FAILED",
+          provider: providerRef?.id ?? "unknown",
+          modality: "llm"
+        });
+      },
+      abort: () => innerStream?.abort()
+    };
+  }
+  async image(options) {
+    if (!this.initialized) await this.init();
+    const provider = this.resolveProviderForModality("image", options.provider, options.model);
+    if (!provider.image) {
+      throw new NoosphereError(`Provider '${provider.id}' does not support image generation`, {
+        code: "INVALID_INPUT",
+        provider: provider.id,
+        modality: "image"
+      });
+    }
+    const start = Date.now();
+    try {
+      const result = await this.executeWithRetry(
+        "image",
+        provider,
+        () => provider.image(options),
+        (alt) => alt.image ? () => alt.image(options) : null
+      );
+      await this.trackUsage(result, options.metadata);
+      return result;
+    } catch (err) {
+      await this.trackError("image", provider.id, options.model, start, err, options.metadata);
+      throw err;
+    }
+  }
+  async video(options) {
+    if (!this.initialized) await this.init();
+    const provider = this.resolveProviderForModality("video", options.provider, options.model);
+    if (!provider.video) {
+      throw new NoosphereError(`Provider '${provider.id}' does not support video generation`, {
+        code: "INVALID_INPUT",
+        provider: provider.id,
+        modality: "video"
+      });
+    }
+    const start = Date.now();
+    try {
+      const result = await this.executeWithRetry(
+        "video",
+        provider,
+        () => provider.video(options),
+        (alt) => alt.video ? () => alt.video(options) : null
+      );
+      await this.trackUsage(result, options.metadata);
+      return result;
+    } catch (err) {
+      await this.trackError("video", provider.id, options.model, start, err, options.metadata);
+      throw err;
+    }
+  }
+  async speak(options) {
+    if (!this.initialized) await this.init();
+    const provider = this.resolveProviderForModality("tts", options.provider, options.model);
+    if (!provider.speak) {
+      throw new NoosphereError(`Provider '${provider.id}' does not support TTS`, {
+        code: "INVALID_INPUT",
+        provider: provider.id,
+        modality: "tts"
+      });
+    }
+    const start = Date.now();
+    try {
+      const result = await this.executeWithRetry(
+        "tts",
+        provider,
+        () => provider.speak(options),
+        (alt) => alt.speak ? () => alt.speak(options) : null
+      );
+      await this.trackUsage(result, options.metadata);
+      return result;
+    } catch (err) {
+      await this.trackError("tts", provider.id, options.model, start, err, options.metadata);
+      throw err;
+    }
+  }
+  // --- Discovery Methods ---
+  async getProviders(modality) {
+    if (!this.initialized) await this.init();
+    return this.registry.getProviderInfos(modality);
+  }
+  async getModels(modality) {
+    if (!this.initialized) await this.init();
+    return this.registry.getModels(modality);
+  }
+  async getModel(provider, modelId) {
+    if (!this.initialized) await this.init();
+    return this.registry.getModel(provider, modelId);
+  }
+  async syncModels() {
+    if (!this.initialized) await this.init();
+    return this.registry.syncAll();
+  }
+  // --- Tracking Methods ---
+  getUsage(options) {
+    return this.tracker.getSummary(options);
+  }
+  // --- Lifecycle ---
+  async dispose() {
+    for (const provider of this.registry.getAllProviders()) {
+      if (provider.dispose) {
+        await provider.dispose();
+      }
+    }
+    this.registry.clearCache();
+    this.tracker.clear();
+  }
+  // --- Internal ---
+  async init() {
+    if (this.initialized) return;
+    this.initialized = true;
+    const { keys, local, autoDetectLocal } = this.config;
+    const llmKeys = {
+      openai: keys.openai,
+      anthropic: keys.anthropic,
+      google: keys.google,
+      openrouter: keys.openrouter,
+      groq: keys.groq,
+      mistral: keys.mistral,
+      xai: keys.xai
+    };
+    const hasAnyLLMKey = Object.values(llmKeys).some(Boolean);
+    if (hasAnyLLMKey) {
+      this.registry.addProvider(new PiAiProvider(llmKeys));
+    }
+    if (keys.fal) {
+      this.registry.addProvider(new FalProvider(keys.fal));
+    }
+    if (keys.huggingface) {
+      this.registry.addProvider(new HuggingFaceProvider(keys.huggingface));
+    }
+    if (autoDetectLocal) {
+      const PING_TIMEOUT_MS = 2e3;
+      const pingUrl = async (url) => {
+        try {
+          const controller = new AbortController();
+          const timer = setTimeout(() => controller.abort(), PING_TIMEOUT_MS);
+          try {
+            const res = await fetch(url, { signal: controller.signal });
+            return res.ok;
+          } finally {
+            clearTimeout(timer);
+          }
+        } catch {
+          return false;
+        }
+      };
+      const comfyuiCfg = local["comfyui"];
+      const piperCfg = local["piper"];
+      const kokoroCfg = local["kokoro"];
+      await Promise.allSettled([
+        // ComfyUI
+        (async () => {
+          if (comfyuiCfg?.enabled) {
+            const ok = await pingUrl(`${comfyuiCfg.host}:${comfyuiCfg.port}/system_stats`);
+            if (ok) {
+              this.registry.addProvider(new ComfyUIProvider({ host: comfyuiCfg.host, port: comfyuiCfg.port }));
+            }
+          }
+        })(),
+        // Piper TTS
+        (async () => {
+          if (piperCfg?.enabled) {
+            const ok = await pingUrl(`${piperCfg.host}:${piperCfg.port}/health`);
+            if (ok) {
+              this.registry.addProvider(new LocalTTSProvider({ id: "piper", name: "Piper TTS", host: piperCfg.host, port: piperCfg.port }));
+            }
+          }
+        })(),
+        // Kokoro TTS
+        (async () => {
+          if (kokoroCfg?.enabled) {
+            const ok = await pingUrl(`${kokoroCfg.host}:${kokoroCfg.port}/health`);
+            if (ok) {
+              this.registry.addProvider(new LocalTTSProvider({ id: "kokoro", name: "Kokoro TTS", host: kokoroCfg.host, port: kokoroCfg.port }));
+            }
+          }
+        })()
+      ]);
+    }
+  }
+  resolveProviderForModality(modality, preferredId, modelId) {
+    if (modelId && !preferredId) {
+      const resolved = this.registry.resolveModel(modelId, modality);
+      if (resolved) return resolved.provider;
+    }
+    if (!preferredId) {
+      const defaultCfg = this.config.defaults[modality];
+      if (defaultCfg) {
+        preferredId = defaultCfg.provider;
+      }
+    }
+    const provider = this.registry.resolveProvider(modality, preferredId);
+    if (!provider) {
+      throw new NoosphereError(
+        `No provider available for modality '${modality}'${preferredId ? ` (requested: ${preferredId})` : ""}`,
+        { code: "NO_PROVIDER", provider: preferredId ?? "none", modality }
+      );
+    }
+    return provider;
+  }
+  async executeWithRetry(modality, provider, fn, failoverFnFactory) {
+    const { maxRetries, backoffMs, retryableErrors, failover } = this.config.retry;
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        const isNoosphereErr = err instanceof NoosphereError;
+        const code = isNoosphereErr ? err.code : "GENERATION_FAILED";
+        const isRetryable = retryableErrors.includes(code) || code === "GENERATION_FAILED";
+        const allowsFailover = code !== "GENERATION_FAILED" && retryableErrors.includes(code);
+        if (!isRetryable || attempt === maxRetries) {
+          if (failover && allowsFailover && failoverFnFactory) {
+            const altProviders = this.registry.getAllProviders().filter((p) => p.id !== provider.id && p.modalities.includes(modality));
+            for (const alt of altProviders) {
+              try {
+                const altFn = failoverFnFactory(alt);
+                if (altFn) return await altFn();
+              } catch {
+              }
+            }
+          }
+          break;
+        }
+        const delay = backoffMs * Math.pow(2, attempt);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    throw lastError ?? new NoosphereError("Generation failed", {
+      code: "GENERATION_FAILED",
+      provider: provider.id,
+      modality
+    });
+  }
+  async trackUsage(result, metadata) {
+    const event = {
+      modality: result.modality,
+      provider: result.provider,
+      model: result.model,
+      cost: result.usage.cost,
+      latencyMs: result.latencyMs,
+      input: result.usage.input,
+      output: result.usage.output,
+      unit: result.usage.unit,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      success: true,
+      metadata
+    };
+    await this.tracker.record(event);
+  }
+  async trackError(modality, provider, model, startMs, err, metadata) {
+    const event = {
+      modality,
+      provider,
+      model: model ?? "unknown",
+      cost: 0,
+      latencyMs: Date.now() - startMs,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      success: false,
+      error: err instanceof Error ? err.message : String(err),
+      metadata
+    };
+    await this.tracker.record(event);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Noosphere,
+  NoosphereError
+});
+//# sourceMappingURL=index.cjs.map