noosphere 0.8.0 → 0.9.1

package/dist/index.js

@@ -108,6 +108,136 @@ function resolveConfig(input) {
   };
 }
 
+// src/token-counter.ts
+import { encoding_for_model } from "tiktoken";
+var TIKTOKEN_MODEL_MAP = {
+  "gpt-4o": "gpt-4o",
+  "gpt-4o-mini": "gpt-4o-mini",
+  "gpt-4-turbo": "gpt-4-turbo",
+  "gpt-4": "gpt-4",
+  "gpt-3.5-turbo": "gpt-3.5-turbo"
+};
+function resolveTiktokenModel(model) {
+  if (model in TIKTOKEN_MODEL_MAP) return TIKTOKEN_MODEL_MAP[model];
+  for (const [prefix, tikModel] of Object.entries(TIKTOKEN_MODEL_MAP)) {
+    if (model.startsWith(prefix)) return tikModel;
+  }
+  return "gpt-4o";
+}
+function countWithTiktoken(messages, model) {
+  const tikModel = resolveTiktokenModel(model);
+  const enc = encoding_for_model(tikModel);
+  let tokens = 0;
+  for (const msg of messages) {
+    tokens += 4;
+    tokens += enc.encode(msg.role).length;
+    tokens += enc.encode(msg.content).length;
+  }
+  tokens += 2;
+  enc.free();
+  return tokens;
+}
+function countTokensOpenAI(messages, model = "gpt-4o") {
+  return countWithTiktoken(messages, model);
+}
+async function countTokensGoogle(messages, apiKey, model = "gemini-2.5-flash") {
+  const contents = messages.map((m) => ({
+    role: m.role === "assistant" ? "model" : "user",
+    parts: [{ text: m.content }]
+  }));
+  const res = await fetch(
+    `https://generativelanguage.googleapis.com/v1beta/models/${model}:countTokens?key=${apiKey}`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ contents })
+    }
+  );
+  if (!res.ok) {
+    throw new Error(`Google countTokens failed (${res.status}): ${await res.text()}`);
+  }
+  const data = await res.json();
+  return data.totalTokens;
+}
+async function countTokensAnthropic(messages, apiKey, model = "claude-sonnet-4-20250514") {
+  const anthropicMessages = messages.filter((m) => m.role !== "system").map((m) => ({ role: m.role, content: m.content }));
+  const systemPrompt = messages.find((m) => m.role === "system")?.content;
+  const body = {
+    model,
+    messages: anthropicMessages
+  };
+  if (systemPrompt) body.system = systemPrompt;
+  const res = await fetch("https://api.anthropic.com/v1/messages/count_tokens", {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01",
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    throw new Error(`Anthropic countTokens failed (${res.status}): ${await res.text()}`);
+  }
+  const data = await res.json();
+  return data.input_tokens;
+}
+function countTokensGroq(messages, model = "llama-3.3-70b-versatile") {
+  return countWithTiktoken(messages, model);
+}
+function countTokensMistral(messages, model = "mistral-large-latest") {
+  return countWithTiktoken(messages, model);
+}
+function countTokensXai(messages, model = "grok-3") {
+  return countWithTiktoken(messages, model);
+}
+function countTokensCerebras(messages, model = "llama-3.3-70b") {
+  return countWithTiktoken(messages, model);
+}
+function countTokensOpenRouter(messages, model = "openai/gpt-4o") {
+  return countWithTiktoken(messages, model);
+}
+function countTokensOllama(messages, model = "llama3.2") {
+  return countWithTiktoken(messages, model);
+}
+var PROVIDER_MODEL_PREFIXES = [
+  { prefixes: ["gemini", "imagen", "veo"], provider: "google" },
+  { prefixes: ["claude"], provider: "anthropic" },
+  { prefixes: ["gpt-", "o1", "o3", "o4", "chatgpt", "dall-e", "gpt-image", "tts-", "whisper", "sora"], provider: "openai" },
+  { prefixes: ["grok"], provider: "xai" },
+  { prefixes: ["mistral", "mixtral", "codestral", "ministral"], provider: "mistral" },
+  { prefixes: ["llama", "gemma", "qwen", "deepseek", "phi"], provider: "groq" }
+];
+function inferProvider(model) {
+  const lower = model.toLowerCase();
+  for (const { prefixes, provider } of PROVIDER_MODEL_PREFIXES) {
+    for (const prefix of prefixes) {
+      if (lower.startsWith(prefix)) return provider;
+    }
+  }
+  return "unknown";
+}
+async function countTokens(options, apiKeys) {
+  const model = options.model ?? "gpt-4o";
+  const provider = options.provider ?? inferProvider(model);
+  if (provider === "google" && apiKeys?.google) {
+    const tokens2 = await countTokensGoogle(options.messages, apiKeys.google, model);
+    return { tokens: tokens2, model, provider: "google", method: "api" };
+  }
+  if (provider === "anthropic" && apiKeys?.anthropic) {
+    const tokens2 = await countTokensAnthropic(options.messages, apiKeys.anthropic, model);
+    return { tokens: tokens2, model, provider: "anthropic", method: "api" };
+  }
+  const tokens = countWithTiktoken(options.messages, model);
+  const resolvedProvider = provider === "unknown" ? "openai" : provider;
+  return {
+    tokens,
+    model,
+    provider: resolvedProvider,
+    method: provider === "openai" ? "tiktoken" : "tiktoken"
+  };
+}
+
 // src/logos.ts
 var CDN_BASE = "https://blockchainstarter.nyc3.digitaloceanspaces.com/noosphere/logos";
 var PROVIDER_IDS = [
@@ -2508,6 +2638,522 @@ async function detectOpenAICompatServers() {
   return providers;
 }
 
+// src/providers/openai-media.ts
+var OPENAI_API_BASE = "https://api.openai.com/v1";
+var FETCH_TIMEOUT_MS5 = 8e3;
+var MODEL_PREFIX_MAP = [
+  { prefix: "dall-e-", modality: "image" },
+  { prefix: "gpt-image-", modality: "image" },
+  { prefix: "sora-", modality: "video" },
+  { prefix: "tts-", modality: "tts" },
+  { prefix: "whisper-", modality: "stt" }
+];
+function classifyModel(id) {
+  for (const { prefix, modality } of MODEL_PREFIX_MAP) {
+    if (id.startsWith(prefix)) return modality;
+  }
+  return null;
+}
+var OpenAIMediaProvider = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  id = "openai-media";
+  name = "OpenAI (Image, Video, TTS, STT)";
+  modalities = ["image", "video", "tts", "stt"];
+  isLocal = false;
+  modelsCache = null;
+  async ping() {
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS5);
+      try {
+        const res = await fetch(`${OPENAI_API_BASE}/models`, {
+          headers: { Authorization: `Bearer ${this.apiKey}` },
+          signal: controller.signal
+        });
+        return res.ok;
+      } finally {
+        clearTimeout(timer);
+      }
+    } catch {
+      return false;
+    }
+  }
+  async listModels(modality) {
+    if (this.modelsCache) {
+      return modality ? this.modelsCache.filter((m) => m.modality === modality) : this.modelsCache;
+    }
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS5);
+      let data;
+      try {
+        const res = await fetch(`${OPENAI_API_BASE}/models`, {
+          headers: { Authorization: `Bearer ${this.apiKey}` },
+          signal: controller.signal
+        });
+        if (!res.ok) return [];
+        data = await res.json();
+      } finally {
+        clearTimeout(timer);
+      }
+      const entries = data?.data ?? [];
+      const logo = getProviderLogo("openai");
+      const models = [];
+      for (const entry of entries) {
+        const mod = classifyModel(entry.id);
+        if (!mod) continue;
+        const info = {
+          id: entry.id,
+          provider: "openai-media",
+          name: entry.id,
+          modality: mod,
+          local: false,
+          cost: { price: 0, unit: "per_request" },
+          logo,
+          description: entry.description,
+          capabilities: this.getCapabilities(entry.id, mod)
+        };
+        models.push(info);
+      }
+      this.modelsCache = models;
+      return modality ? models.filter((m) => m.modality === modality) : models;
+    } catch {
+      return [];
+    }
+  }
+  async image(options) {
+    const model = options.model ?? "gpt-image-1";
+    const width = options.width ?? 1024;
+    const height = options.height ?? 1024;
+    const start = Date.now();
+    const isGptImage = model.startsWith("gpt-image-");
+    const body = {
+      model,
+      prompt: options.prompt,
+      n: 1,
+      size: `${width}x${height}`
+    };
+    if (!isGptImage) {
+      body.response_format = "url";
+    }
+    const res = await fetch(`${OPENAI_API_BASE}/images/generations`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const errorBody = await res.text();
+      throw new Error(`OpenAI image generation failed (${res.status}): ${errorBody}`);
+    }
+    const data = await res.json();
+    const item = data?.data?.[0];
+    const result = {
+      provider: "openai-media",
+      model,
+      modality: "image",
+      latencyMs: Date.now() - start,
+      usage: {
+        cost: 0,
+        unit: "per_image"
+      },
+      media: {
+        width,
+        height,
+        format: "png"
+      }
+    };
+    if (item?.b64_json) {
+      result.buffer = Buffer.from(item.b64_json, "base64");
+    } else if (item?.url) {
+      result.url = item.url;
+    }
+    return result;
+  }
+  async speak(options) {
+    const model = options.model ?? "tts-1";
+    const voice = options.voice ?? "alloy";
+    const format = options.format ?? "mp3";
+    const speed = options.speed ?? 1;
+    const start = Date.now();
+    const body = {
+      model,
+      input: options.text,
+      voice,
+      response_format: format,
+      speed
+    };
+    const res = await fetch(`${OPENAI_API_BASE}/audio/speech`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const errorBody = await res.text();
+      throw new Error(`OpenAI TTS failed (${res.status}): ${errorBody}`);
+    }
+    const arrayBuffer = await res.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+    return {
+      buffer,
+      provider: "openai-media",
+      model,
+      modality: "tts",
+      latencyMs: Date.now() - start,
+      usage: {
+        cost: 0,
+        input: options.text.length,
+        unit: "per_1k_chars"
+      },
+      media: {
+        format
+      }
+    };
+  }
+  async video(options) {
+    const model = options.model ?? "sora-2";
+    const start = Date.now();
+    const body = {
+      model,
+      prompt: options.prompt,
+      n: 1
+    };
+    if (options.duration) body.duration = options.duration;
+    if (options.width && options.height) body.size = `${options.width}x${options.height}`;
+    const res = await fetch(`${OPENAI_API_BASE}/videos/generations`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const errorBody = await res.text();
+      throw new Error(`OpenAI video generation failed (${res.status}): ${errorBody}`);
+    }
+    const data = await res.json();
+    const videoUrl = data?.data?.[0]?.url;
+    return {
+      url: videoUrl,
+      provider: "openai-media",
+      model,
+      modality: "video",
+      latencyMs: Date.now() - start,
+      usage: {
+        cost: 0,
+        unit: "per_video"
+      },
+      media: {
+        duration: options.duration,
+        width: options.width,
+        height: options.height
+      }
+    };
+  }
+  getCapabilities(id, modality) {
+    if (modality === "image") {
+      return {
+        maxWidth: id.startsWith("dall-e-3") ? 1792 : 1024,
+        maxHeight: id.startsWith("dall-e-3") ? 1792 : 1024
+      };
+    }
+    if (modality === "tts") {
+      return {
+        voices: ["alloy", "ash", "coral", "echo", "fable", "onyx", "nova", "sage", "shimmer"]
+      };
+    }
+    if (modality === "video") {
+      return {
+        maxDuration: id.includes("pro") ? 20 : 10,
+        supportsStreaming: false
+      };
+    }
+    if (modality === "stt") {
+      return {
+        languages: ["en", "zh", "de", "es", "ru", "ko", "fr", "ja", "pt", "tr", "pl", "ca", "nl", "ar", "sv", "it", "id", "hi", "fi", "vi", "he", "uk", "el", "ms", "cs", "ro", "da", "hu", "ta", "no", "th", "ur", "hr", "bg", "lt", "la", "mi", "ml", "cy", "sk", "te", "fa", "lv", "bn", "sr", "az", "sl", "kn", "et", "mk", "br", "eu", "is", "hy", "ne", "mn", "bs", "kk", "sq", "sw", "gl", "mr", "pa", "si", "km", "sn", "yo", "so", "af", "oc", "ka", "be", "tg", "sd", "gu", "am", "yi", "lo", "uz", "fo", "ht", "ps", "tk", "nn", "mt", "sa", "lb", "my", "bo", "tl", "mg", "as", "tt", "haw", "ln", "ha", "ba", "jw", "su"]
+      };
+    }
+    return void 0;
+  }
+};
+
+// src/providers/google-media.ts
+var GOOGLE_API_BASE = "https://generativelanguage.googleapis.com/v1beta";
+var FETCH_TIMEOUT_MS6 = 8e3;
+var GOOGLE_TTS_VOICES = [
+  "Aoede",
+  "Charon",
+  "Fenrir",
+  "Kore",
+  "Puck",
+  "Leda",
+  "Orus",
+  "Perseus",
+  "Zephyr",
+  "Callirrhoe"
+];
+function classifyGoogleModel(model) {
+  const name = (model.name ?? "").replace("models/", "");
+  const methods = model.supportedGenerationMethods ?? [];
+  if (name.startsWith("imagen") && methods.includes("predict")) return "image";
+  if (name.startsWith("veo") && methods.includes("predictLongRunning")) return "video";
+  if (name.includes("-tts") && methods.includes("generateContent")) return "tts";
+  return null;
+}
+var GoogleMediaProvider = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  id = "google-media";
+  name = "Google (Image, Video, TTS)";
+  modalities = ["image", "video", "tts"];
+  isLocal = false;
+  modelsCache = null;
+  async ping() {
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS6);
+      try {
+        const res = await fetch(`${GOOGLE_API_BASE}/models?key=${this.apiKey}`, {
+          signal: controller.signal
+        });
+        return res.ok;
+      } finally {
+        clearTimeout(timer);
+      }
+    } catch {
+      return false;
+    }
+  }
+  async listModels(modality) {
+    if (this.modelsCache) {
+      return modality ? this.modelsCache.filter((m) => m.modality === modality) : this.modelsCache;
+    }
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS6);
+      let data;
+      try {
+        const res = await fetch(`${GOOGLE_API_BASE}/models?key=${this.apiKey}`, {
+          signal: controller.signal
+        });
+        if (!res.ok) return [];
+        data = await res.json();
+      } finally {
+        clearTimeout(timer);
+      }
+      const entries = data?.models ?? [];
+      const logo = getProviderLogo("google");
+      const models = [];
+      for (const entry of entries) {
+        const modality2 = classifyGoogleModel(entry);
+        if (!modality2) continue;
+        const fullName = entry.name ?? "";
+        const modelId = fullName.startsWith("models/") ? fullName.slice("models/".length) : fullName;
+        const info = {
+          id: modelId,
+          provider: "google-media",
+          name: entry.displayName ?? modelId,
+          modality: modality2,
+          local: false,
+          cost: { price: 0, unit: modality2 === "video" ? "per_video" : "per_image" },
+          logo,
+          description: entry.description,
+          capabilities: modality2 === "video" ? { maxDuration: 8, supportsStreaming: false } : modality2 === "tts" ? { voices: GOOGLE_TTS_VOICES } : void 0
+        };
+        models.push(info);
+      }
+      this.modelsCache = models;
+      return modality ? models.filter((m) => m.modality === modality) : models;
+    } catch {
+      return [];
+    }
+  }
+  async image(options) {
+    const model = options.model ?? "imagen-4.0-generate-001";
+    const start = Date.now();
+    const body = {
+      instances: [{ prompt: options.prompt }],
+      parameters: {
+        sampleCount: 1
+      }
+    };
+    const res = await fetch(
+      `${GOOGLE_API_BASE}/models/${model}:predict?key=${this.apiKey}`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      }
+    );
+    if (!res.ok) {
+      const errorBody = await res.text();
+      throw new Error(`Google image generation failed (${res.status}): ${errorBody}`);
+    }
+    const data = await res.json();
+    const base64 = data?.predictions?.[0]?.bytesBase64Encoded ?? data?.generatedImages?.[0]?.image?.imageBytes;
+    if (!base64) {
+      throw new Error("Google image generation returned no image data");
+    }
+    const buffer = Buffer.from(base64, "base64");
+    return {
+      buffer,
+      provider: "google-media",
+      model,
+      modality: "image",
+      latencyMs: Date.now() - start,
+      usage: {
+        cost: 0,
+        unit: "per_image"
+      },
+      media: {
+        format: "png"
+      }
+    };
+  }
+  async speak(options) {
+    const model = options.model ?? "gemini-2.5-flash-preview-tts";
+    const voice = options.voice ?? "Kore";
+    const start = Date.now();
+    const body = {
+      contents: [{ parts: [{ text: options.text }] }],
+      generationConfig: {
+        response_modalities: ["AUDIO"],
+        speech_config: {
+          voiceConfig: {
+            prebuiltVoiceConfig: { voiceName: voice }
+          }
+        }
+      }
+    };
+    const res = await fetch(
+      `${GOOGLE_API_BASE}/models/${model}:generateContent?key=${this.apiKey}`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      }
+    );
+    if (!res.ok) {
+      const errorBody = await res.text();
+      throw new Error(`Google TTS failed (${res.status}): ${errorBody}`);
+    }
+    const data = await res.json();
+    const inlineData = data?.candidates?.[0]?.content?.parts?.[0]?.inlineData;
+    if (!inlineData?.data) {
+      throw new Error("Google TTS returned no audio data");
+    }
+    const buffer = Buffer.from(inlineData.data, "base64");
+    return {
+      buffer,
+      provider: "google-media",
+      model,
+      modality: "tts",
+      latencyMs: Date.now() - start,
+      usage: {
+        cost: 0,
+        input: options.text.length,
+        unit: "per_1k_chars"
+      },
+      media: {
+        format: "wav"
+        // Google returns PCM L16, essentially WAV
+      }
+    };
+  }
+  async video(options) {
+    const model = options.model ?? "veo-2.0-generate-001";
+    const start = Date.now();
+    const body = {
+      instances: [{ prompt: options.prompt }],
+      parameters: {
+        sampleCount: 1
+      }
+    };
+    if (options.duration) body.parameters.durationSeconds = options.duration;
+    const res = await fetch(
+      `${GOOGLE_API_BASE}/models/${model}:predictLongRunning?key=${this.apiKey}`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      }
+    );
+    if (!res.ok) {
+      const errorBody = await res.text();
+      throw new Error(`Google video generation failed (${res.status}): ${errorBody}`);
+    }
+    const operation = await res.json();
+    const operationName = operation?.name;
+    if (!operationName) {
+      throw new Error("Google video generation returned no operation name");
+    }
+    const deadline = Date.now() + 3e5;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 5e3));
+      const pollRes = await fetch(
+        `${GOOGLE_API_BASE}/${operationName}?key=${this.apiKey}`
+      );
+      if (!pollRes.ok) continue;
+      const status = await pollRes.json();
+      if (status.done) {
+        if (status.error) {
+          throw new Error(`Google video generation error: ${status.error.message ?? JSON.stringify(status.error)}`);
+        }
+        const resp = status.response ?? {};
+        const samples = resp.generateVideoResponse?.generatedSamples ?? resp.generatedSamples ?? [];
+        const video = samples[0]?.video;
+        if (video?.bytesBase64Encoded) {
+          return {
+            buffer: Buffer.from(video.bytesBase64Encoded, "base64"),
+            provider: "google-media",
+            model,
+            modality: "video",
+            latencyMs: Date.now() - start,
+            usage: { cost: 0, unit: "per_video" },
+            media: { format: "mp4", duration: options.duration }
+          };
+        }
+        if (video?.uri) {
+          const separator = video.uri.includes("?") ? "&" : "?";
+          const videoRes = await fetch(`${video.uri}${separator}key=${this.apiKey}`, { redirect: "follow" });
+          if (videoRes.ok) {
+            const buffer = Buffer.from(await videoRes.arrayBuffer());
+            return {
+              buffer,
+              provider: "google-media",
+              model,
+              modality: "video",
+              latencyMs: Date.now() - start,
+              usage: { cost: 0, unit: "per_video" },
+              media: { format: "mp4", duration: options.duration }
+            };
+          }
+          return {
+            url: video.uri,
+            provider: "google-media",
+            model,
+            modality: "video",
+            latencyMs: Date.now() - start,
+            usage: { cost: 0, unit: "per_video" },
+            media: { format: "mp4", duration: options.duration }
+          };
+        }
+        throw new Error("Google video generation completed but returned no video data");
+      }
+    }
+    throw new Error(`Google video generation timed out after 5 minutes`);
+  }
+};
+
 // src/noosphere.ts
 var Noosphere = class {
   config;
@@ -2698,6 +3344,12 @@ var Noosphere = class {
   getUsage(options) {
     return this.tracker.getSummary(options);
   }
+  async countTokens(options) {
+    const keys = {};
+    if (this.config.keys?.google) keys.google = this.config.keys.google;
+    if (this.config.keys?.anthropic) keys.anthropic = this.config.keys.anthropic;
+    return countTokens(options, keys);
+  }
   // --- Local Model Management ---
   async installModel(name) {
     if (!this.initialized) await this.init();
@@ -2750,6 +3402,12 @@ var Noosphere = class {
     if (hasAnyLLMKey) {
       this.registry.addProvider(new PiAiProvider(llmKeys));
     }
+    if (keys.openai) {
+      this.registry.addProvider(new OpenAIMediaProvider(keys.openai));
+    }
+    if (keys.google) {
+      this.registry.addProvider(new GoogleMediaProvider(keys.google));
+    }
     if (keys.fal) {
       this.registry.addProvider(new FalProvider(keys.fal));
     }
@@ -2926,18 +3584,47 @@ var Noosphere = class {
     await this.tracker.record(event);
   }
 };
+
+// src/index.ts
+import { agentLoop } from "@mariozechner/pi-ai";
+import { calculateCost, getModel, getModels as getModels2, getProviders as getProviders2 } from "@mariozechner/pi-ai";
+import { stream as stream2, complete as complete2, streamSimple, completeSimple } from "@mariozechner/pi-ai";
+import { setApiKey as setApiKey2, getApiKey } from "@mariozechner/pi-ai";
 export {
   AudioCraftProvider,
+  GoogleMediaProvider,
   HfLocalProvider,
   Noosphere,
   NoosphereError,
   OllamaProvider,
   OpenAICompatProvider,
+  OpenAIMediaProvider,
   PROVIDER_IDS,
   PROVIDER_LOGOS,
   WhisperLocalProvider,
+  agentLoop,
+  calculateCost,
+  countTokens,
+  countTokensAnthropic,
+  countTokensCerebras,
+  countTokensGoogle,
+  countTokensGroq,
+  countTokensMistral,
+  countTokensOllama,
+  countTokensOpenAI,
+  countTokensOpenRouter,
+  countTokensXai,
   detectOpenAICompatServers,
   getAllProviderLogos,
-  getProviderLogo
+  getApiKey,
+  getModel as getPiModel,
+  getModels2 as getPiModels,
+  getProviders2 as getPiProviders,
+  getProviderLogo,
+  complete2 as piComplete,
+  completeSimple as piCompleteSimple,
+  stream2 as piStream,
+  streamSimple as piStreamSimple,
+  setApiKey2 as setApiKey
 };
 //# sourceMappingURL=index.js.map