noosphere 0.9.0 → 0.9.1

package/README.md

@@ -16,6 +16,8 @@ One import. Every model. Every modality.
 - **30+ HuggingFace tasks** — LLM, image, TTS, translation, summarization, classification, and more
 - **Local-first architecture** — Auto-detects Ollama, ComfyUI, Whisper, AudioCraft, Piper, and Kokoro on your machine
 - **Org-aware logos** — HuggingFace models show the real org logo (Meta, Google, NVIDIA) instead of generic HF logo
+- **Pre-request token counting** — Count tokens before sending, for ALL providers (OpenAI/Groq/Ollama via tiktoken, Google/Anthropic via API)
+- **Full pi-ai access** — Agent loop with tool calling, preprocessor (compaction hook), `calculateCost`, direct stream/complete APIs — all re-exported
 - **Agentic capabilities** — Tool use, function calling, reasoning/thinking, vision, and agent loops via Pi-AI
 - **Failover & retry** — Automatic retries with exponential backoff and cross-provider failover
 - **Usage tracking** — Real-time cost, latency, and token tracking across all providers
@@ -629,6 +631,102 @@ Noosphere auto-detects all local runtimes on startup:
 
 ---
 
+## Pre-Request Token Counting
+
+Count tokens **before** sending a request to any provider. Know the cost upfront.
+
+```typescript
+// Via Noosphere instance (auto-routes by model)
+const result = await ai.countTokens({
+  messages: [
+    { role: 'system', content: 'You are a helpful assistant.' },
+    { role: 'user', content: 'Explain quantum computing.' },
+  ],
+  model: 'gpt-4o',
+});
+console.log(result.tokens);   // 26
+console.log(result.method);   // "tiktoken" (instant, local)
+console.log(result.provider); // "openai"
+
+// Google — exact count via API
+const google = await ai.countTokens({
+  messages: [{ role: 'user', content: 'Hello!' }],
+  model: 'gemini-2.5-flash',
+});
+console.log(google.tokens);   // 3
+console.log(google.method);   // "api" (exact)
+```
+
+**Token counting by provider:**
+
+| Provider | Method | Speed | Accuracy |
+|---|---|---|---|
+| **OpenAI** (GPT-4o, o1, o3, o4, GPT-5) | tiktoken (local) | Instant | Exact |
+| **Google** (Gemini) | `/countTokens` API | ~200ms | Exact |
+| **Anthropic** (Claude) | `/messages/count_tokens` API | ~200ms | Exact |
+| **Groq** (Llama, Mixtral, Gemma) | tiktoken (local) | Instant | Exact |
+| **Cerebras** (Llama) | tiktoken (local) | Instant | Exact |
+| **Mistral** (Mistral, Mixtral, Codestral) | tiktoken (local) | Instant | Close approx |
+| **xAI** (Grok) | tiktoken (local) | Instant | Close approx |
+| **OpenRouter** (all models) | tiktoken (local) | Instant | Close approx |
+| **Ollama** (all local models) | tiktoken (local) | Instant | Close approx |
+
+You can also use standalone functions without a Noosphere instance:
+
+```typescript
+import {
+  countTokensOpenAI, countTokensGoogle, countTokensAnthropic,
+  countTokensGroq, countTokensMistral, countTokensXai,
+  countTokensCerebras, countTokensOpenRouter, countTokensOllama,
+} from 'noosphere';
+
+// Local (instant, no API key needed)
+const tokens = countTokensOpenAI(messages, 'gpt-4o');       // 26
+const groq   = countTokensGroq(messages, 'llama-3.3-70b');  // 26
+const ollama = countTokensOllama(messages, 'qwen3:8b');     // 26
+
+// API-based (exact, needs key)
+const google = await countTokensGoogle(messages, GEMINI_KEY, 'gemini-2.5-flash');     // 16
+const claude = await countTokensAnthropic(messages, ANTHROPIC_KEY, 'claude-sonnet-4-20250514'); // exact
+```
+
+---
+
+## Agent Loop & pi-ai Access
+
+Noosphere re-exports the full [pi-ai](https://github.com/nicholasgriffintn/pi-ai) library for direct access to agent loops, tool calling, cost calculation, and streaming APIs.
+
+```typescript
+import {
+  agentLoop, calculateCost,
+  piStream, piComplete, piStreamSimple, piCompleteSimple,
+  setApiKey, getApiKey, getPiModel, getPiModels, getPiProviders,
+} from 'noosphere';
+
+// Agent loop with tool calling and preprocessor (compaction hook)
+import type { AgentLoopConfig, AgentContext, AgentTool } from 'noosphere';
+
+const config: AgentLoopConfig = {
+  model: getPiModel('openai', 'gpt-4o'),
+  // Preprocessor runs before each LLM call — use for context compaction
+  preprocessor: async (messages) => {
+    // Truncate old messages, summarize, etc.
+    if (messages.length > 50) {
+      return messages.slice(-20); // keep last 20
+    }
+    return messages;
+  },
+};
+
+// Calculate cost before sending
+const model = getPiModel('openai', 'gpt-4o');
+const usage = { input: 1000, output: 500, cacheRead: 0, cacheWrite: 0 };
+const cost = calculateCost(model, usage);
+console.log(cost.total); // $0.00625
+```
+
+---
+
 ## Configuration
 
 API keys are resolved from the constructor config or environment variables (config takes priority):

package/dist/index.cjs

@@ -31,9 +31,30 @@ __export(index_exports, {
   PROVIDER_IDS: () => PROVIDER_IDS,
   PROVIDER_LOGOS: () => PROVIDER_LOGOS,
   WhisperLocalProvider: () => WhisperLocalProvider,
+  agentLoop: () => import_pi_ai3.agentLoop,
+  calculateCost: () => import_pi_ai4.calculateCost,
+  countTokens: () => countTokens,
+  countTokensAnthropic: () => countTokensAnthropic,
+  countTokensCerebras: () => countTokensCerebras,
+  countTokensGoogle: () => countTokensGoogle,
+  countTokensGroq: () => countTokensGroq,
+  countTokensMistral: () => countTokensMistral,
+  countTokensOllama: () => countTokensOllama,
+  countTokensOpenAI: () => countTokensOpenAI,
+  countTokensOpenRouter: () => countTokensOpenRouter,
+  countTokensXai: () => countTokensXai,
   detectOpenAICompatServers: () => detectOpenAICompatServers,
   getAllProviderLogos: () => getAllProviderLogos,
-  getProviderLogo: () => getProviderLogo
+  getApiKey: () => import_pi_ai6.getApiKey,
+  getPiModel: () => import_pi_ai4.getModel,
+  getPiModels: () => import_pi_ai4.getModels,
+  getPiProviders: () => import_pi_ai4.getProviders,
+  getProviderLogo: () => getProviderLogo,
+  piComplete: () => import_pi_ai5.complete,
+  piCompleteSimple: () => import_pi_ai5.completeSimple,
+  piStream: () => import_pi_ai5.stream,
+  piStreamSimple: () => import_pi_ai5.streamSimple,
+  setApiKey: () => import_pi_ai6.setApiKey
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -140,6 +161,136 @@ function resolveConfig(input) {
   };
 }
 
+// src/token-counter.ts
+var import_tiktoken = require("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 = (0, import_tiktoken.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 = [
@@ -2972,7 +3123,7 @@ var GoogleMediaProvider = class {
     };
   }
   async video(options) {
-    const model = options.model ?? "veo-3.0-generate-001";
+    const model = options.model ?? "veo-2.0-generate-001";
     const start = Date.now();
     const body = {
       instances: [{ prompt: options.prompt }],
@@ -3007,10 +3158,15 @@ var GoogleMediaProvider = class {
       if (!pollRes.ok) continue;
       const status = await pollRes.json();
       if (status.done) {
-        const videoBase64 = status.response?.generatedSamples?.[0]?.video?.bytesBase64Encoded;
-        if (videoBase64) {
+        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(videoBase64, "base64"),
+            buffer: Buffer.from(video.bytesBase64Encoded, "base64"),
             provider: "google-media",
             model,
             modality: "video",
@@ -3019,16 +3175,32 @@ var GoogleMediaProvider = class {
             media: { format: "mp4", duration: options.duration }
           };
         }
-        const videoUrl = status.response?.generatedSamples?.[0]?.video?.uri;
-        return {
-          url: videoUrl,
-          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`);
@@ -3225,6 +3397,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();
@@ -3459,6 +3637,12 @@ var Noosphere = class {
     await this.tracker.record(event);
   }
 };
+
+// src/index.ts
+var import_pi_ai3 = require("@mariozechner/pi-ai");
+var import_pi_ai4 = require("@mariozechner/pi-ai");
+var import_pi_ai5 = require("@mariozechner/pi-ai");
+var import_pi_ai6 = require("@mariozechner/pi-ai");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AudioCraftProvider,
@@ -3472,8 +3656,29 @@ var Noosphere = class {
   PROVIDER_IDS,
   PROVIDER_LOGOS,
   WhisperLocalProvider,
+  agentLoop,
+  calculateCost,
+  countTokens,
+  countTokensAnthropic,
+  countTokensCerebras,
+  countTokensGoogle,
+  countTokensGroq,
+  countTokensMistral,
+  countTokensOllama,
+  countTokensOpenAI,
+  countTokensOpenRouter,
+  countTokensXai,
   detectOpenAICompatServers,
   getAllProviderLogos,
-  getProviderLogo
+  getApiKey,
+  getPiModel,
+  getPiModels,
+  getPiProviders,
+  getProviderLogo,
+  piComplete,
+  piCompleteSimple,
+  piStream,
+  piStreamSimple,
+  setApiKey
 });
 //# sourceMappingURL=index.cjs.map