vibezcheck 0.1.0

package/dist/index.js

@@ -0,0 +1,1458 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AnthropicStreamAccumulator: () => AnthropicStreamAccumulator,
+  ApiKeyAuth: () => ApiKeyAuth,
+  BillingHelper: () => BillingHelper,
+  CustomerCache: () => CustomerCache,
+  CustomerManager: () => CustomerManager,
+  MODEL_PRICING_TABLE: () => MODEL_PRICING_TABLE,
+  MeterBatcher: () => MeterBatcher,
+  VibezCheckClient: () => VibezCheckClient,
+  VibezMeter: () => VibezMeter,
+  calculateCost: () => calculateCost,
+  calculateUsageCost: () => calculateUsageCost,
+  createApiKeyAuth: () => createApiKeyAuth,
+  createBillingHelper: () => createBillingHelper,
+  createCustomerManager: () => createCustomerManager,
+  createMeter: () => createMeter,
+  createVibezCheck: () => createVibezCheck,
+  detectAndExtractUsage: () => detectAndExtractUsage,
+  extractAnthropicResponseUsage: () => extractAnthropicResponseUsage,
+  extractAuthToken: () => extractAuthToken,
+  extractGeminiResponseUsage: () => extractGeminiResponseUsage,
+  extractGenericResponseUsage: () => extractGenericResponseUsage,
+  extractOpenAIResponseUsage: () => extractOpenAIResponseUsage,
+  getModelPricing: () => getModelPricing,
+  inspectOpenAIStreamChunk: () => inspectOpenAIStreamChunk,
+  meteredModel: () => meteredModel,
+  normalizeModelKey: () => normalizeModelKey,
+  registerModelPricing: () => registerModelPricing,
+  trackTokens: () => trackTokens,
+  vibes: () => vibes,
+  vibescheck: () => vibescheck,
+  vibez: () => vibez,
+  vibezcheck: () => vibezcheck,
+  withBilling: () => withBilling,
+  wrapAnthropicStream: () => wrapAnthropicStream,
+  wrapGeminiStream: () => wrapGeminiStream,
+  wrapOpenAIStream: () => wrapOpenAIStream,
+  wrapStream: () => wrapStream,
+  wrapUniversalStream: () => wrapUniversalStream
+});
+module.exports = __toCommonJS(src_exports);
+var import_stripe5 = __toESM(require("stripe"));
+
+// src/meter/client.ts
+var import_stripe = __toESM(require("stripe"));
+
+// src/meter/batcher.ts
+var MeterBatcher = class {
+  queue = [];
+  timer = null;
+  isFlushing = false;
+  maxBatchSize;
+  flushIntervalMs;
+  stripeClient;
+  eventName;
+  onUsageCallback;
+  onErrorCallback;
+  debug;
+  // In-memory ledger for local stats
+  totalRequests = 0;
+  totalTokens = 0;
+  totalInputTokens = 0;
+  totalOutputTokens = 0;
+  totalReasoningTokens = 0;
+  totalCostUSD = 0;
+  byModel = {};
+  constructor(options = {}) {
+    this.stripeClient = options.stripe;
+    this.eventName = options.eventName || "token-billing-tokens";
+    this.maxBatchSize = options.batching?.maxBatchSize ?? 50;
+    this.flushIntervalMs = options.batching?.flushIntervalMs ?? 50;
+    this.onUsageCallback = options.onUsage;
+    this.onErrorCallback = options.onError;
+    this.debug = options.debug ?? false;
+  }
+  /**
+   * Enqueue a usage event for batch dispatching
+   */
+  enqueue(event) {
+    this.recordInLedger(event);
+    if (this.onUsageCallback) {
+      try {
+        const res = this.onUsageCallback(event);
+        if (res instanceof Promise) {
+          res.catch((err) => {
+            if (this.debug) console.error("[vibezcheck] Error in onUsage callback:", err);
+          });
+        }
+      } catch (err) {
+        if (this.debug) console.error("[vibezcheck] Error in onUsage callback:", err);
+      }
+    }
+    if (!this.stripeClient) {
+      if (this.debug) {
+        console.log(
+          `[vibezcheck:local] \u{1F4CA} ${event.model} | Tokens: ${event.usage.totalTokens} | Cost: $${event.cost.totalUSD.toFixed(6)}`
+        );
+      }
+      return;
+    }
+    this.queue.push(event);
+    if (this.queue.length >= this.maxBatchSize) {
+      this.flush().catch((err) => {
+        if (this.debug) console.error("[vibezcheck] Batch flush error:", err);
+      });
+    } else if (!this.timer) {
+      this.timer = setTimeout(() => {
+        this.timer = null;
+        this.flush().catch((err) => {
+          if (this.debug) console.error("[vibezcheck] Debounce flush error:", err);
+        });
+      }, this.flushIntervalMs);
+    }
+  }
+  /**
+   * Immediately flush all queued events to Stripe
+   */
+  async flush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (this.queue.length === 0 || !this.stripeClient || this.isFlushing) {
+      return;
+    }
+    this.isFlushing = true;
+    const eventsToSend = [...this.queue];
+    this.queue = [];
+    try {
+      await this.sendEventsToStripe(eventsToSend);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      if (this.debug) {
+        console.error("[vibezcheck] Failed to send meter events to Stripe:", err);
+      }
+      if (this.onErrorCallback) {
+        this.onErrorCallback(err, eventsToSend);
+      }
+    } finally {
+      this.isFlushing = false;
+      if (this.queue.length > 0) {
+        this.flush().catch(() => {
+        });
+      }
+    }
+  }
+  /**
+   * Sends events to Stripe Billing Meter Events API
+   */
+  async sendEventsToStripe(events) {
+    if (!this.stripeClient) return;
+    for (const event of events) {
+      const customerId = event.customerId;
+      if (!customerId) {
+        continue;
+      }
+      const timestamp = event.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+      const model = `${event.provider}/${event.model}`;
+      if (event.usage.inputTokens > 0) {
+        try {
+          await this.stripeClient.v2.billing.meterEvents.create({
+            event_name: this.eventName,
+            timestamp,
+            payload: {
+              stripe_customer_id: customerId,
+              value: event.usage.inputTokens.toString(),
+              model,
+              token_type: "input",
+              cached_tokens: (event.usage.cachedTokens ?? 0).toString(),
+              ...event.metadata ? event.metadata : {}
+            }
+          });
+        } catch (e) {
+          if (this.debug) console.warn("[vibezcheck] Input meter event error:", e);
+        }
+      }
+      if (event.usage.outputTokens > 0) {
+        try {
+          await this.stripeClient.v2.billing.meterEvents.create({
+            event_name: this.eventName,
+            timestamp,
+            payload: {
+              stripe_customer_id: customerId,
+              value: event.usage.outputTokens.toString(),
+              model,
+              token_type: "output",
+              reasoning_tokens: (event.usage.reasoningTokens ?? 0).toString(),
+              visible_tokens: (event.usage.visibleOutputTokens ?? event.usage.outputTokens).toString(),
+              ...event.metadata ? event.metadata : {}
+            }
+          });
+        } catch (e) {
+          if (this.debug) console.warn("[vibezcheck] Output meter event error:", e);
+        }
+      }
+    }
+  }
+  /**
+   * Updates internal in-memory ledger
+   */
+  recordInLedger(event) {
+    this.totalRequests += 1;
+    this.totalTokens += event.usage.totalTokens;
+    this.totalInputTokens += event.usage.inputTokens;
+    this.totalOutputTokens += event.usage.outputTokens;
+    this.totalReasoningTokens += event.usage.reasoningTokens ?? 0;
+    this.totalCostUSD += event.cost.totalUSD;
+    const modelKey = event.model;
+    if (!this.byModel[modelKey]) {
+      this.byModel[modelKey] = { requests: 0, tokens: 0, costUSD: 0 };
+    }
+    this.byModel[modelKey].requests += 1;
+    this.byModel[modelKey].tokens += event.usage.totalTokens;
+    this.byModel[modelKey].costUSD += event.cost.totalUSD;
+  }
+  /**
+   * Get in-memory usage summary
+   */
+  getSummary() {
+    return {
+      totalRequests: this.totalRequests,
+      totalTokens: this.totalTokens,
+      totalInputTokens: this.totalInputTokens,
+      totalOutputTokens: this.totalOutputTokens,
+      totalReasoningTokens: this.totalReasoningTokens,
+      totalCostUSD: Number(this.totalCostUSD.toFixed(6)),
+      byModel: { ...this.byModel }
+    };
+  }
+  /**
+   * Reset in-memory ledger
+   */
+  resetLedger() {
+    this.totalRequests = 0;
+    this.totalTokens = 0;
+    this.totalInputTokens = 0;
+    this.totalOutputTokens = 0;
+    this.totalReasoningTokens = 0;
+    this.totalCostUSD = 0;
+    this.byModel = {};
+  }
+};
+
+// src/meter/extractors/openai.ts
+function extractOpenAIResponseUsage(response) {
+  if (!response || typeof response !== "object") return null;
+  if ("choices" in response && "usage" in response && response.usage) {
+    const rawUsage = response.usage;
+    const model = response.model || "gpt-4o";
+    const inputTokens = rawUsage.prompt_tokens ?? 0;
+    const outputTokens = rawUsage.completion_tokens ?? 0;
+    const reasoningTokens = rawUsage.completion_tokens_details?.reasoning_tokens ?? 0;
+    const cachedTokens = rawUsage.prompt_tokens_details?.cached_tokens ?? 0;
+    return {
+      model,
+      provider: "openai",
+      usage: {
+        inputTokens,
+        outputTokens,
+        totalTokens: inputTokens + outputTokens,
+        reasoningTokens: reasoningTokens > 0 ? reasoningTokens : void 0,
+        visibleOutputTokens: Math.max(0, outputTokens - reasoningTokens),
+        cachedTokens: cachedTokens > 0 ? cachedTokens : void 0
+      }
+    };
+  }
+  if ("data" in response && "usage" in response && response.usage && "model" in response) {
+    const rawUsage = response.usage;
+    const inputTokens = rawUsage.prompt_tokens ?? 0;
+    return {
+      model: response.model || "text-embedding-3-small",
+      provider: "openai",
+      usage: {
+        inputTokens,
+        outputTokens: 0,
+        totalTokens: inputTokens
+      }
+    };
+  }
+  if ("status" in response && "usage" in response && response.usage) {
+    const rawUsage = response.usage;
+    const model = response.model || "gpt-5.6-sol";
+    const inputTokens = rawUsage.input_tokens ?? rawUsage.prompt_tokens ?? 0;
+    const outputTokens = rawUsage.output_tokens ?? rawUsage.completion_tokens ?? 0;
+    const reasoningTokens = rawUsage.output_token_details?.reasoning_tokens ?? rawUsage.completion_tokens_details?.reasoning_tokens ?? 0;
+    const cachedTokens = rawUsage.input_token_details?.cached_tokens ?? rawUsage.prompt_tokens_details?.cached_tokens ?? 0;
+    return {
+      model,
+      provider: "openai",
+      usage: {
+        inputTokens,
+        outputTokens,
+        totalTokens: inputTokens + outputTokens,
+        reasoningTokens: reasoningTokens > 0 ? reasoningTokens : void 0,
+        visibleOutputTokens: Math.max(0, outputTokens - reasoningTokens),
+        cachedTokens: cachedTokens > 0 ? cachedTokens : void 0
+      }
+    };
+  }
+  return null;
+}
+function inspectOpenAIStreamChunk(chunk) {
+  if (!chunk || typeof chunk !== "object") return {};
+  const model = chunk.model;
+  if (chunk.usage) {
+    const rawUsage = chunk.usage;
+    const inputTokens = rawUsage.prompt_tokens ?? rawUsage.input_tokens ?? 0;
+    const outputTokens = rawUsage.completion_tokens ?? rawUsage.output_tokens ?? 0;
+    const reasoningTokens = rawUsage.completion_tokens_details?.reasoning_tokens ?? rawUsage.output_token_details?.reasoning_tokens ?? 0;
+    const cachedTokens = rawUsage.prompt_tokens_details?.cached_tokens ?? rawUsage.input_token_details?.cached_tokens ?? 0;
+    return {
+      model,
+      usage: {
+        inputTokens,
+        outputTokens,
+        totalTokens: inputTokens + outputTokens,
+        reasoningTokens: reasoningTokens > 0 ? reasoningTokens : void 0,
+        visibleOutputTokens: Math.max(0, outputTokens - reasoningTokens),
+        cachedTokens: cachedTokens > 0 ? cachedTokens : void 0
+      }
+    };
+  }
+  if (chunk.type === "response.completed" || chunk.type === "response.done") {
+    if (chunk.response?.usage) {
+      const rawUsage = chunk.response.usage;
+      const inputTokens = rawUsage.input_tokens ?? 0;
+      const outputTokens = rawUsage.output_tokens ?? 0;
+      const reasoningTokens = rawUsage.output_token_details?.reasoning_tokens ?? 0;
+      const cachedTokens = rawUsage.input_token_details?.cached_tokens ?? 0;
+      return {
+        model: chunk.response.model || model,
+        usage: {
+          inputTokens,
+          outputTokens,
+          totalTokens: inputTokens + outputTokens,
+          reasoningTokens: reasoningTokens > 0 ? reasoningTokens : void 0,
+          visibleOutputTokens: Math.max(0, outputTokens - reasoningTokens),
+          cachedTokens: cachedTokens > 0 ? cachedTokens : void 0
+        }
+      };
+    }
+  }
+  return { model };
+}
+
+// src/meter/extractors/anthropic.ts
+function extractAnthropicResponseUsage(response) {
+  if (!response || typeof response !== "object") return null;
+  if (response.type === "message" || "content" in response && "usage" in response) {
+    const rawUsage = response.usage || {};
+    const model = response.model || "claude-3-7-sonnet";
+    const inputTokens = rawUsage.input_tokens ?? 0;
+    const outputTokens = rawUsage.output_tokens ?? 0;
+    const cachedTokens = rawUsage.cache_read_input_tokens ?? 0;
+    const cacheWriteTokens = rawUsage.cache_creation_input_tokens ?? 0;
+    let reasoningTokens = void 0;
+    if (Array.isArray(response.content)) {
+      const thinkingBlocks = response.content.filter((b) => b.type === "thinking");
+      if (thinkingBlocks.length > 0) {
+        reasoningTokens = rawUsage.thinking_tokens ?? void 0;
+      }
+    }
+    return {
+      model,
+      provider: "anthropic",
+      usage: {
+        inputTokens,
+        outputTokens,
+        totalTokens: inputTokens + outputTokens,
+        reasoningTokens,
+        visibleOutputTokens: reasoningTokens !== void 0 ? Math.max(0, outputTokens - reasoningTokens) : outputTokens,
+        cachedTokens: cachedTokens > 0 ? cachedTokens : void 0,
+        cacheWriteTokens: cacheWriteTokens > 0 ? cacheWriteTokens : void 0
+      }
+    };
+  }
+  return null;
+}
+var AnthropicStreamAccumulator = class {
+  model = "claude-3-7-sonnet";
+  inputTokens = 0;
+  outputTokens = 0;
+  cachedTokens = 0;
+  cacheWriteTokens = 0;
+  reasoningTokens = 0;
+  processEvent(event) {
+    if (!event || typeof event !== "object") return;
+    if (event.type === "message_start" && event.message) {
+      if (event.message.model) {
+        this.model = event.message.model;
+      }
+      if (event.message.usage) {
+        this.inputTokens = event.message.usage.input_tokens ?? 0;
+        this.cachedTokens = event.message.usage.cache_read_input_tokens ?? 0;
+        this.cacheWriteTokens = event.message.usage.cache_creation_input_tokens ?? 0;
+      }
+    }
+    if (event.type === "message_delta" && event.usage) {
+      this.outputTokens = event.usage.output_tokens ?? 0;
+      if (event.usage.thinking_tokens) {
+        this.reasoningTokens = event.usage.thinking_tokens;
+      }
+    }
+    if (event.type === "content_block_start" && event.content_block?.type === "thinking") {
+    }
+  }
+  getUsage() {
+    return {
+      model: this.model,
+      provider: "anthropic",
+      usage: {
+        inputTokens: this.inputTokens,
+        outputTokens: this.outputTokens,
+        totalTokens: this.inputTokens + this.outputTokens,
+        reasoningTokens: this.reasoningTokens > 0 ? this.reasoningTokens : void 0,
+        visibleOutputTokens: this.reasoningTokens > 0 ? Math.max(0, this.outputTokens - this.reasoningTokens) : this.outputTokens,
+        cachedTokens: this.cachedTokens > 0 ? this.cachedTokens : void 0,
+        cacheWriteTokens: this.cacheWriteTokens > 0 ? this.cacheWriteTokens : void 0
+      }
+    };
+  }
+};
+
+// src/meter/extractors/gemini.ts
+function extractGeminiResponseUsage(response, fallbackModel = "gemini-3.7-flash") {
+  if (!response || typeof response !== "object") return null;
+  const usageMetadata = response.usageMetadata || response.response?.usageMetadata;
+  if (usageMetadata) {
+    const inputTokens = usageMetadata.promptTokenCount ?? 0;
+    const baseOutputTokens = usageMetadata.candidatesTokenCount ?? 0;
+    const thoughtsTokenCount = usageMetadata.thoughtsTokenCount ?? usageMetadata.reasoningTokenCount ?? 0;
+    const cachedTokens = usageMetadata.cachedContentTokenCount ?? 0;
+    const totalOutput = baseOutputTokens + thoughtsTokenCount;
+    const model = response.model || response.response?.model || fallbackModel;
+    return {
+      model,
+      provider: "google",
+      usage: {
+        inputTokens,
+        outputTokens: totalOutput,
+        totalTokens: inputTokens + totalOutput,
+        reasoningTokens: thoughtsTokenCount > 0 ? thoughtsTokenCount : void 0,
+        visibleOutputTokens: baseOutputTokens,
+        cachedTokens: cachedTokens > 0 ? cachedTokens : void 0
+      }
+    };
+  }
+  return null;
+}
+
+// src/meter/extractors/generic.ts
+function extractGenericResponseUsage(response, fallbackModel = "generic-llm", fallbackProvider = "generic") {
+  if (!response || typeof response !== "object") return null;
+  const usage = response.usage || response.token_usage || response.usageMetadata;
+  if (usage) {
+    const inputTokens = usage.prompt_tokens ?? usage.input_tokens ?? usage.promptTokenCount ?? usage.prompt_eval_count ?? 0;
+    const outputTokens = usage.completion_tokens ?? usage.output_tokens ?? usage.candidatesTokenCount ?? usage.eval_count ?? 0;
+    const reasoningTokens = usage.reasoning_tokens ?? usage.thoughtsTokenCount ?? usage.completion_tokens_details?.reasoning_tokens ?? 0;
+    const cachedTokens = usage.prompt_tokens_details?.cached_tokens ?? usage.cached_tokens ?? usage.cachedContentTokenCount ?? 0;
+    const model = response.model || fallbackModel;
+    const provider = response.provider || fallbackProvider;
+    return {
+      model,
+      provider,
+      usage: {
+        inputTokens,
+        outputTokens,
+        totalTokens: inputTokens + outputTokens,
+        reasoningTokens: reasoningTokens > 0 ? reasoningTokens : void 0,
+        visibleOutputTokens: Math.max(0, outputTokens - reasoningTokens),
+        cachedTokens: cachedTokens > 0 ? cachedTokens : void 0
+      }
+    };
+  }
+  return null;
+}
+
+// src/meter/extractors/index.ts
+function detectAndExtractUsage(response, fallbackModel, fallbackProvider) {
+  if (!response || typeof response !== "object") return null;
+  const openaiResult = extractOpenAIResponseUsage(response);
+  if (openaiResult) return openaiResult;
+  const anthropicResult = extractAnthropicResponseUsage(response);
+  if (anthropicResult) return anthropicResult;
+  const geminiResult = extractGeminiResponseUsage(response, fallbackModel);
+  if (geminiResult) return geminiResult;
+  const genericResult = extractGenericResponseUsage(response, fallbackModel, fallbackProvider);
+  if (genericResult) return genericResult;
+  return null;
+}
+
+// src/pricing/table.ts
+var MODEL_PRICING_TABLE = {
+  // --- OpenAI ---
+  "gpt-5.6-sol": { inputPer1M: 4, outputPer1M: 20, cachedInputPer1M: 0.4 },
+  "gpt-5.6-terra": { inputPer1M: 2, outputPer1M: 12, cachedInputPer1M: 0.2 },
+  "gpt-5.6-luna": { inputPer1M: 0.2, outputPer1M: 1.2, cachedInputPer1M: 0.02 },
+  "gpt-5": { inputPer1M: 4, outputPer1M: 20, cachedInputPer1M: 0.4 },
+  "gpt-5-mini": { inputPer1M: 0.2, outputPer1M: 1.2, cachedInputPer1M: 0.02 },
+  "o1": { inputPer1M: 15, outputPer1M: 60, cachedInputPer1M: 7.5 },
+  "o1-mini": { inputPer1M: 1.1, outputPer1M: 4.4, cachedInputPer1M: 0.55 },
+  "o3": { inputPer1M: 15, outputPer1M: 60, cachedInputPer1M: 7.5 },
+  "o3-mini": { inputPer1M: 1.1, outputPer1M: 4.4, cachedInputPer1M: 0.55 },
+  "gpt-4o": { inputPer1M: 2.5, outputPer1M: 10, cachedInputPer1M: 1.25 },
+  "gpt-4o-mini": { inputPer1M: 0.15, outputPer1M: 0.6, cachedInputPer1M: 0.075 },
+  "gpt-4.1": { inputPer1M: 2, outputPer1M: 8, cachedInputPer1M: 1 },
+  "gpt-4.1-nano": { inputPer1M: 0.1, outputPer1M: 0.4, cachedInputPer1M: 0.05 },
+  "text-embedding-3-small": { inputPer1M: 0.02, outputPer1M: 0 },
+  "text-embedding-3-large": { inputPer1M: 0.13, outputPer1M: 0 },
+  // --- Anthropic ---
+  "claude-3-7-sonnet": { inputPer1M: 0.59, outputPer1M: 2.93, cachedInputPer1M: 0.3 },
+  "claude-sonnet-5": { inputPer1M: 2, outputPer1M: 10, cachedInputPer1M: 0.3 },
+  "claude-3-5-sonnet": { inputPer1M: 3, outputPer1M: 15, cachedInputPer1M: 0.3 },
+  "claude-3-5-haiku": { inputPer1M: 0.8, outputPer1M: 4, cachedInputPer1M: 0.08 },
+  "haiku-4.5": { inputPer1M: 1, outputPer1M: 5, cachedInputPer1M: 0.1 },
+  "claude-opus-5": { inputPer1M: 5, outputPer1M: 25, cachedInputPer1M: 1.5 },
+  "claude-3-opus": { inputPer1M: 15, outputPer1M: 75, cachedInputPer1M: 1.5 },
+  // --- Google Gemini ---
+  "gemini-3.7-flash": { inputPer1M: 0.75, outputPer1M: 3.75, cachedInputPer1M: 0.18 },
+  "gemini-3.1-pro": { inputPer1M: 2, outputPer1M: 12, cachedInputPer1M: 0.5 },
+  "gemini-3.5-flash": { inputPer1M: 1.5, outputPer1M: 9, cachedInputPer1M: 0.38 },
+  "gemini-3.1-flash-lite": { inputPer1M: 0.25, outputPer1M: 1.5, cachedInputPer1M: 0.06 },
+  "gemini-2.0-flash": { inputPer1M: 0.1, outputPer1M: 0.4, cachedInputPer1M: 0.025 },
+  "gemini-1.5-pro": { inputPer1M: 1.25, outputPer1M: 5, cachedInputPer1M: 0.3125 },
+  "gemini-1.5-flash": { inputPer1M: 0.075, outputPer1M: 0.3, cachedInputPer1M: 0.01875 },
+  // --- xAI Grok ---
+  "grok-4.6": { inputPer1M: 3, outputPer1M: 15 },
+  "grok-2": { inputPer1M: 2, outputPer1M: 10 },
+  "grok-2-vision": { inputPer1M: 2, outputPer1M: 10 },
+  "grok-beta": { inputPer1M: 5, outputPer1M: 15 },
+  // --- Mistral ---
+  "mistral-large-3": { inputPer1M: 2, outputPer1M: 6 },
+  "mistral-large-latest": { inputPer1M: 2, outputPer1M: 6 },
+  "codestral-latest": { inputPer1M: 0.3, outputPer1M: 0.9 },
+  "mistral-small-latest": { inputPer1M: 0.2, outputPer1M: 0.6 },
+  "ministral-8b-latest": { inputPer1M: 0.1, outputPer1M: 0.1 },
+  // --- Groq LPUs ---
+  "llama-3.3-70b-versatile": { inputPer1M: 0.59, outputPer1M: 0.79 },
+  "llama-3.1-8b-instant": { inputPer1M: 0.05, outputPer1M: 0.08 },
+  "deepseek-r1-distill-llama-70b": { inputPer1M: 0.75, outputPer1M: 0.99 },
+  "qwen-2.5-32b": { inputPer1M: 0.29, outputPer1M: 0.39 },
+  // --- DeepSeek ---
+  "deepseek-v4-pro": { inputPer1M: 0.66, outputPer1M: 1.98, cachedInputPer1M: 0.15 },
+  "deepseek-v4-flash": { inputPer1M: 0.22, outputPer1M: 0.66, cachedInputPer1M: 0.05 },
+  "deepseek-chat": { inputPer1M: 0.22, outputPer1M: 0.66, cachedInputPer1M: 0.05 },
+  "deepseek-reasoner": { inputPer1M: 0.66, outputPer1M: 1.98, cachedInputPer1M: 0.15 },
+  // --- Cohere ---
+  "command-r-plus": { inputPer1M: 2.5, outputPer1M: 10 },
+  "command-r": { inputPer1M: 0.15, outputPer1M: 0.6 }
+};
+var customPricingRegistry = {};
+function normalizeModelKey(rawModel) {
+  if (!rawModel) return "unknown";
+  let model = rawModel.toLowerCase().trim();
+  if (model.includes("/")) {
+    model = model.split("/")[1] || model;
+  }
+  model = model.replace(/-\d{8}$/, "");
+  model = model.replace(/-\d{4}-\d{2}-\d{2}$/, "");
+  return model;
+}
+function getModelPricing(modelName) {
+  const normalized = normalizeModelKey(modelName);
+  if (customPricingRegistry[normalized]) {
+    return customPricingRegistry[normalized];
+  }
+  if (customPricingRegistry[modelName]) {
+    return customPricingRegistry[modelName];
+  }
+  if (MODEL_PRICING_TABLE[normalized]) {
+    return MODEL_PRICING_TABLE[normalized];
+  }
+  if (MODEL_PRICING_TABLE[modelName]) {
+    return MODEL_PRICING_TABLE[modelName];
+  }
+  return {
+    inputPer1M: 1,
+    outputPer1M: 3,
+    cachedInputPer1M: 0.5
+  };
+}
+function registerModelPricing(modelName, rates) {
+  const normalized = normalizeModelKey(modelName);
+  customPricingRegistry[normalized] = rates;
+  customPricingRegistry[modelName] = rates;
+}
+
+// src/pricing/calculator.ts
+function calculateCost(params) {
+  const rates = getModelPricing(params.model);
+  const inputTokens = params.inputTokens ?? 0;
+  const outputTokens = params.outputTokens ?? 0;
+  const reasoningTokens = params.reasoningTokens ?? 0;
+  const cachedTokens = params.cachedTokens ?? 0;
+  const regularInputTokens = Math.max(0, inputTokens - cachedTokens);
+  const regularInputCost = regularInputTokens / 1e6 * rates.inputPer1M;
+  const cachedRate = rates.cachedInputPer1M ?? rates.inputPer1M * 0.5;
+  const cachedInputCost = cachedTokens / 1e6 * cachedRate;
+  const inputCostUSD = regularInputCost + cachedInputCost;
+  const outputCostUSD = outputTokens / 1e6 * rates.outputPer1M;
+  const reasoningRate = rates.reasoningPer1M ?? rates.outputPer1M;
+  const reasoningCostUSD = reasoningTokens / 1e6 * reasoningRate;
+  const standardCacheCost = cachedTokens / 1e6 * rates.inputPer1M;
+  const cachedDiscountUSD = Math.max(0, standardCacheCost - cachedInputCost);
+  const totalUSD = inputCostUSD + outputCostUSD;
+  const markup = params.markupMultiplier ?? 1;
+  const retailUSD = markup !== 1 ? totalUSD * markup : void 0;
+  return {
+    inputCostUSD: Number(inputCostUSD.toFixed(8)),
+    outputCostUSD: Number(outputCostUSD.toFixed(8)),
+    reasoningCostUSD: reasoningTokens > 0 ? Number(reasoningCostUSD.toFixed(8)) : void 0,
+    cachedDiscountUSD: cachedTokens > 0 ? Number(cachedDiscountUSD.toFixed(8)) : void 0,
+    totalUSD: Number(totalUSD.toFixed(8)),
+    retailUSD: retailUSD ? Number(retailUSD.toFixed(8)) : void 0,
+    currency: rates.currency || "USD"
+  };
+}
+function calculateUsageCost(model, usage, markupMultiplier) {
+  return calculateCost({
+    model,
+    inputTokens: usage.inputTokens,
+    outputTokens: usage.outputTokens,
+    reasoningTokens: usage.reasoningTokens,
+    cachedTokens: usage.cachedTokens,
+    cacheWriteTokens: usage.cacheWriteTokens,
+    markupMultiplier
+  });
+}
+
+// src/meter/stream.ts
+function wrapOpenAIStream(stream, options, onComplete) {
+  let detectedModel = options.model || "gpt-4o";
+  let finalUsage = null;
+  const wrappedAsyncIterable = {
+    async *[Symbol.asyncIterator]() {
+      try {
+        for await (const chunk of stream) {
+          const inspected = inspectOpenAIStreamChunk(chunk);
+          if (inspected.model) {
+            detectedModel = inspected.model;
+          }
+          if (inspected.usage) {
+            finalUsage = inspected.usage;
+          }
+          yield chunk;
+        }
+      } finally {
+        if (finalUsage) {
+          const cost = calculateUsageCost(detectedModel, finalUsage);
+          const customerId = typeof options.customer === "string" ? options.customer : options.customer?.id || options.customerId;
+          const event = {
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            model: detectedModel,
+            provider: "openai",
+            usage: finalUsage,
+            cost,
+            customerId,
+            metadata: options.metadata
+          };
+          onComplete(event);
+          if (options.onUsage) {
+            options.onUsage(event);
+          }
+        }
+      }
+    }
+  };
+  return wrappedAsyncIterable;
+}
+function wrapAnthropicStream(stream, options, onComplete) {
+  const accumulator = new AnthropicStreamAccumulator();
+  const wrappedAsyncIterable = {
+    async *[Symbol.asyncIterator]() {
+      try {
+        for await (const event of stream) {
+          accumulator.processEvent(event);
+          yield event;
+        }
+      } finally {
+        const extracted = accumulator.getUsage();
+        const model = options.model || extracted.model;
+        const cost = calculateUsageCost(model, extracted.usage);
+        const customerId = typeof options.customer === "string" ? options.customer : options.customer?.id || options.customerId;
+        const usageEvent = {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          model,
+          provider: "anthropic",
+          usage: extracted.usage,
+          cost,
+          customerId,
+          metadata: options.metadata
+        };
+        onComplete(usageEvent);
+        if (options.onUsage) {
+          options.onUsage(usageEvent);
+        }
+      }
+    }
+  };
+  return wrappedAsyncIterable;
+}
+function wrapGeminiStream(result, options, onComplete) {
+  if (!result || !result.stream) return result;
+  const originalStream = result.stream;
+  const model = options.model || "gemini-3.7-flash";
+  let lastChunkWithUsage = null;
+  const wrappedStream = (async function* () {
+    try {
+      for await (const chunk of originalStream) {
+        if (chunk.usageMetadata) {
+          lastChunkWithUsage = chunk;
+        }
+        yield chunk;
+      }
+    } finally {
+      if (lastChunkWithUsage) {
+        const extracted = extractGeminiResponseUsage(lastChunkWithUsage, model);
+        if (extracted) {
+          const cost = calculateUsageCost(extracted.model, extracted.usage);
+          const customerId = typeof options.customer === "string" ? options.customer : options.customer?.id || options.customerId;
+          const event = {
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            model: extracted.model,
+            provider: "google",
+            usage: extracted.usage,
+            cost,
+            customerId,
+            metadata: options.metadata
+          };
+          onComplete(event);
+          if (options.onUsage) {
+            options.onUsage(event);
+          }
+        }
+      }
+    }
+  })();
+  return {
+    ...result,
+    stream: wrappedStream
+  };
+}
+function wrapUniversalStream(stream, options = {}, onComplete) {
+  if (!stream || typeof stream !== "object") return stream;
+  if ("stream" in stream && "response" in stream) {
+    return wrapGeminiStream(stream, options, onComplete);
+  }
+  if (Symbol.asyncIterator in stream) {
+    if (options.provider === "anthropic") {
+      return wrapAnthropicStream(stream, options, onComplete);
+    }
+    return wrapOpenAIStream(stream, options, onComplete);
+  }
+  return stream;
+}
+
+// src/meter/client.ts
+var VibezMeter = class {
+  batcher;
+  stripeClient;
+  markupMultiplier;
+  constructor(options = {}) {
+    this.markupMultiplier = options.markupMultiplier;
+    if (options.stripe) {
+      this.stripeClient = options.stripe;
+    } else if (options.apiKey || process.env.STRIPE_SECRET_KEY) {
+      const key = options.apiKey || process.env.STRIPE_SECRET_KEY;
+      this.stripeClient = new import_stripe.default(key, {
+        appInfo: {
+          name: "vibezcheck",
+          version: "0.1.0",
+          url: "https://vibezcheck.xyz"
+        }
+      });
+    }
+    this.batcher = new MeterBatcher({
+      ...options,
+      stripe: this.stripeClient
+    });
+  }
+  /**
+   * Track token usage from a non-streaming response object (OpenAI, Anthropic, Gemini, etc.)
+   */
+  trackUsage(response, options = {}) {
+    const extracted = detectAndExtractUsage(response, options.model, options.provider);
+    if (!extracted) {
+      return null;
+    }
+    const model = options.model || extracted.model;
+    const cost = calculateUsageCost(model, extracted.usage, this.markupMultiplier);
+    const customerId = typeof options.customer === "string" ? options.customer : options.customer?.id || options.customerId;
+    const event = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      model,
+      provider: extracted.provider,
+      usage: extracted.usage,
+      cost,
+      customerId,
+      metadata: options.metadata
+    };
+    this.batcher.enqueue(event);
+    return event;
+  }
+  /**
+   * Wrap any LLM stream (OpenAI, Anthropic, Gemini) with zero added latency
+   */
+  wrapStream(stream, options = {}) {
+    return wrapUniversalStream(stream, options, (event) => {
+      this.batcher.enqueue(event);
+    });
+  }
+  /**
+   * Directly record token usage manually
+   */
+  recordUsage(options) {
+    const inputTokens = options.inputTokens ?? 0;
+    const outputTokens = options.outputTokens ?? 0;
+    const reasoningTokens = options.reasoningTokens;
+    const cachedTokens = options.cachedTokens;
+    const usage = {
+      inputTokens,
+      outputTokens,
+      totalTokens: inputTokens + outputTokens,
+      reasoningTokens,
+      visibleOutputTokens: reasoningTokens !== void 0 ? Math.max(0, outputTokens - reasoningTokens) : outputTokens,
+      cachedTokens
+    };
+    const cost = calculateUsageCost(options.model, usage, this.markupMultiplier);
+    const customerId = typeof options.customer === "string" ? options.customer : options.customer?.id || options.customerId;
+    const event = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      model: options.model,
+      provider: options.provider || "custom",
+      usage,
+      cost,
+      customerId,
+      metadata: options.metadata
+    };
+    this.batcher.enqueue(event);
+    return event;
+  }
+  /**
+   * Flush pending events to Stripe (vital for Serverless & Edge environments)
+   */
+  async flush() {
+    await this.batcher.flush();
+  }
+  /**
+   * Get in-memory aggregated usage statistics
+   */
+  getUsageSummary() {
+    return this.batcher.getSummary();
+  }
+  /**
+   * Reset in-memory ledger
+   */
+  resetSummary() {
+    this.batcher.resetLedger();
+  }
+};
+function createMeter(options = {}) {
+  return new VibezMeter(options);
+}
+
+// src/ai-sdk/with-billing.ts
+function withBilling(model, options = {}) {
+  if (!model || typeof model !== "object") {
+    return model;
+  }
+  const meter = options.meter || createMeter({
+    apiKey: options.stripeApiKey,
+    eventName: options.eventName
+  });
+  const customerId = typeof options.customer === "string" ? options.customer : options.customer?.id || options.customerId;
+  const modelId = model.modelId || "unknown-model";
+  const provider = model.provider?.replace(/^@ai-sdk\//, "") || "ai-sdk";
+  const handleUsage = (rawUsage) => {
+    if (!rawUsage) return;
+    const inputTokens = rawUsage.promptTokens ?? rawUsage.inputTokens ?? 0;
+    const outputTokens = rawUsage.completionTokens ?? rawUsage.outputTokens ?? 0;
+    const reasoningTokens = rawUsage.reasoningTokens ?? rawUsage.completionTokensDetails?.reasoningTokens ?? rawUsage.outputTokenDetails?.reasoningTokens ?? 0;
+    const cachedTokens = rawUsage.promptTokensDetails?.cachedTokens ?? rawUsage.inputTokenDetails?.cachedTokens ?? 0;
+    const usage = {
+      inputTokens,
+      outputTokens,
+      totalTokens: inputTokens + outputTokens,
+      reasoningTokens: reasoningTokens > 0 ? reasoningTokens : void 0,
+      visibleOutputTokens: Math.max(0, outputTokens - reasoningTokens),
+      cachedTokens: cachedTokens > 0 ? cachedTokens : void 0
+    };
+    const cost = calculateUsageCost(modelId, usage);
+    const event = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      model: modelId,
+      provider,
+      usage,
+      cost,
+      customerId,
+      metadata: options.metadata
+    };
+    meter.recordUsage({
+      model: modelId,
+      provider,
+      inputTokens,
+      outputTokens,
+      reasoningTokens: usage.reasoningTokens,
+      cachedTokens: usage.cachedTokens,
+      customerId,
+      metadata: options.metadata
+    });
+    if (options.onUsage) {
+      options.onUsage(event);
+    }
+  };
+  return new Proxy(model, {
+    get(target, prop, receiver) {
+      const originalValue = Reflect.get(target, prop, receiver);
+      if (prop === "doGenerate" && typeof originalValue === "function") {
+        return async function(...args) {
+          const result = await originalValue.apply(target, args);
+          if (result && result.usage) {
+            handleUsage(result.usage);
+          }
+          return result;
+        };
+      }
+      if (prop === "doStream" && typeof originalValue === "function") {
+        return async function(...args) {
+          const result = await originalValue.apply(target, args);
+          if (!result || !result.stream) {
+            return result;
+          }
+          const originalStream = result.stream;
+          if (typeof originalStream.getReader === "function") {
+            const reader = originalStream.getReader();
+            const transformedStream = new ReadableStream({
+              async start(controller) {
+                try {
+                  while (true) {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                      controller.close();
+                      break;
+                    }
+                    if (value && typeof value === "object") {
+                      if (value.type === "finish" && value.usage) {
+                        handleUsage(value.usage);
+                      }
+                    }
+                    controller.enqueue(value);
+                  }
+                } catch (err) {
+                  controller.error(err);
+                }
+              }
+            });
+            return {
+              ...result,
+              stream: transformedStream
+            };
+          }
+          if (Symbol.asyncIterator in originalStream) {
+            const wrappedAsyncIterable = {
+              async *[Symbol.asyncIterator]() {
+                for await (const chunk of originalStream) {
+                  if (chunk && typeof chunk === "object") {
+                    if (chunk.type === "finish" && chunk.usage) {
+                      handleUsage(chunk.usage);
+                    }
+                  }
+                  yield chunk;
+                }
+              }
+            };
+            return {
+              ...result,
+              stream: wrappedAsyncIterable
+            };
+          }
+          return result;
+        };
+      }
+      return originalValue;
+    }
+  });
+}
+var meteredModel = withBilling;
+
+// src/customers/manager.ts
+var import_stripe2 = __toESM(require("stripe"));
+
+// src/customers/cache.ts
+var CustomerCache = class {
+  cache = /* @__PURE__ */ new Map();
+  defaultTtlMs;
+  constructor(defaultTtlMs = 1e3 * 60 * 60) {
+    this.defaultTtlMs = defaultTtlMs;
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      return null;
+    }
+    return entry.customerId;
+  }
+  set(key, customerId, ttlMs) {
+    const expiresAt = Date.now() + (ttlMs ?? this.defaultTtlMs);
+    this.cache.set(key, { customerId, expiresAt });
+  }
+  delete(key) {
+    this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+};
+
+// src/customers/manager.ts
+var CustomerManager = class {
+  stripe;
+  cache;
+  constructor(options = {}) {
+    if (options.stripe) {
+      this.stripe = options.stripe;
+    } else {
+      const apiKey = options.apiKey || process.env.STRIPE_SECRET_KEY;
+      if (!apiKey) {
+        throw new Error("[vibezcheck] Stripe API key required for customer management.");
+      }
+      this.stripe = new import_stripe2.default(apiKey);
+    }
+    this.cache = new CustomerCache(options.cacheTtlMs);
+  }
+  /**
+   * Retrieves existing Stripe Customer or automatically provisions a new one
+   */
+  async getOrCreate(params) {
+    const cacheKey = params.userId || params.email;
+    if (cacheKey) {
+      const cachedId = this.cache.get(cacheKey);
+      if (cachedId) {
+        return {
+          id: cachedId,
+          isNew: false,
+          customer: { id: cachedId }
+        };
+      }
+    }
+    if (params.userId) {
+      try {
+        const searchResult = await this.stripe.customers.search({
+          query: `metadata['vibez_user_id']:'${params.userId}'`,
+          limit: 1
+        });
+        if (searchResult.data.length > 0) {
+          const customer = searchResult.data[0];
+          if (cacheKey) this.cache.set(cacheKey, customer.id);
+          if (params.email) this.cache.set(params.email, customer.id);
+          return { id: customer.id, isNew: false, customer };
+        }
+      } catch {
+      }
+    }
+    if (params.email) {
+      const listResult = await this.stripe.customers.list({
+        email: params.email,
+        limit: 1
+      });
+      if (listResult.data.length > 0) {
+        const customer = listResult.data[0];
+        if (cacheKey) this.cache.set(cacheKey, customer.id);
+        if (params.userId) this.cache.set(params.userId, customer.id);
+        return { id: customer.id, isNew: false, customer };
+      }
+    }
+    const newCustomer = await this.stripe.customers.create({
+      email: params.email,
+      name: params.name,
+      metadata: {
+        vibez_user_id: params.userId,
+        created_by: "vibezcheck",
+        ...params.metadata || {}
+      }
+    });
+    if (cacheKey) this.cache.set(cacheKey, newCustomer.id);
+    if (params.userId) this.cache.set(params.userId, newCustomer.id);
+    if (params.email) this.cache.set(params.email, newCustomer.id);
+    return { id: newCustomer.id, isNew: true, customer: newCustomer };
+  }
+  /**
+   * Clears in-memory resolution cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+};
+function createCustomerManager(options = {}) {
+  return new CustomerManager(options);
+}
+
+// src/auth/keys.ts
+var crypto = __toESM(require("crypto"));
+var import_stripe3 = __toESM(require("stripe"));
+var ApiKeyAuth = class {
+  stripe;
+  constructor(stripe) {
+    this.stripe = stripe;
+  }
+  /**
+   * Hashes a raw API key using SHA-256
+   */
+  hashKey(rawKey) {
+    return crypto.createHash("sha256").update(rawKey).digest("hex");
+  }
+  /**
+   * Generates a new secure vz_live_... API key
+   */
+  async createApiKey(params) {
+    const randomBytes2 = crypto.randomBytes(24).toString("hex");
+    const apiKey = `vz_live_${randomBytes2}`;
+    const keyId = `key_${crypto.randomBytes(8).toString("hex")}`;
+    const keyHash = this.hashKey(apiKey);
+    const record = {
+      keyId,
+      keyHash,
+      customerId: params.customerId,
+      userId: params.userId,
+      name: params.name,
+      scopes: params.scopes,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (this.stripe && params.customerId) {
+      try {
+        await this.stripe.customers.update(params.customerId, {
+          metadata: {
+            [`vibez_key_${keyId}`]: JSON.stringify({
+              hash: keyHash,
+              name: params.name,
+              scopes: params.scopes,
+              created: record.createdAt
+            })
+          }
+        });
+      } catch {
+      }
+    }
+    return { apiKey, keyId, record };
+  }
+  /**
+   * Validates a raw key against an expected hash
+   */
+  verifyKeyHash(rawKey, expectedHash) {
+    const computedHash = this.hashKey(rawKey);
+    return crypto.timingSafeEqual(Buffer.from(computedHash), Buffer.from(expectedHash));
+  }
+};
+function createApiKeyAuth(options = {}) {
+  let stripeClient = options.stripe;
+  if (!stripeClient && (options.apiKey || process.env.STRIPE_SECRET_KEY)) {
+    stripeClient = new import_stripe3.default(options.apiKey || process.env.STRIPE_SECRET_KEY);
+  }
+  return new ApiKeyAuth(stripeClient);
+}
+
+// src/auth/verify.ts
+function extractAuthToken(reqOrHeader) {
+  if (!reqOrHeader) return null;
+  let authHeader = null;
+  if (typeof reqOrHeader === "string") {
+    authHeader = reqOrHeader;
+  } else if ("headers" in reqOrHeader && typeof reqOrHeader.headers?.get === "function") {
+    authHeader = reqOrHeader.headers.get("authorization") || reqOrHeader.headers.get("x-api-key");
+  } else if (typeof reqOrHeader.get === "function") {
+    authHeader = reqOrHeader.get("authorization") || reqOrHeader.get("x-api-key");
+  } else if (typeof reqOrHeader === "object") {
+    const raw = reqOrHeader["authorization"] || reqOrHeader["Authorization"] || reqOrHeader["x-api-key"] || reqOrHeader["X-API-Key"];
+    authHeader = Array.isArray(raw) ? raw[0] : raw;
+  }
+  if (!authHeader) return null;
+  if (authHeader.startsWith("Bearer ")) {
+    return authHeader.substring(7).trim();
+  }
+  return authHeader.trim();
+}
+
+// src/billing/sessions.ts
+var import_stripe4 = __toESM(require("stripe"));
+var BillingHelper = class {
+  stripe;
+  constructor(options = {}) {
+    if (options.stripe) {
+      this.stripe = options.stripe;
+    } else {
+      const apiKey = options.apiKey || process.env.STRIPE_SECRET_KEY;
+      if (!apiKey) {
+        throw new Error("[vibezcheck] Stripe API key required for billing operations.");
+      }
+      this.stripe = new import_stripe4.default(apiKey);
+    }
+  }
+  /**
+   * Creates a Stripe Customer Portal session URL where users can manage cards, view usage & invoices
+   */
+  async createPortalSession(params) {
+    const session = await this.stripe.billingPortal.sessions.create({
+      customer: params.customerId,
+      return_url: params.returnUrl
+    });
+    return session.url;
+  }
+  /**
+   * Creates a Stripe Checkout session to subscribe a customer to a metered pricing tier
+   */
+  async createCheckoutSession(params) {
+    const session = await this.stripe.checkout.sessions.create({
+      customer: params.customerId,
+      customer_email: !params.customerId ? params.customerEmail : void 0,
+      line_items: [
+        {
+          price: params.priceId,
+          quantity: 1
+        }
+      ],
+      mode: params.mode || "subscription",
+      success_url: `${params.returnUrl}?session_id={CHECKOUT_SESSION_ID}&status=success`,
+      cancel_url: `${params.returnUrl}?status=cancelled`,
+      metadata: params.metadata
+    });
+    if (!session.url) {
+      throw new Error("[vibezcheck] Failed to generate checkout session URL.");
+    }
+    return session.url;
+  }
+  /**
+   * Creates a Checkout session for topping up prepaid credit wallet balance
+   */
+  async createTopUpSession(params) {
+    const session = await this.stripe.checkout.sessions.create({
+      customer: params.customerId,
+      line_items: [
+        {
+          price_data: {
+            currency: params.currency || "usd",
+            unit_amount: params.amountCents,
+            product_data: {
+              name: "AI Token Credits Top-Up",
+              description: `Add $${(params.amountCents / 100).toFixed(2)} in AI inference credits`
+            }
+          },
+          quantity: 1
+        }
+      ],
+      mode: "payment",
+      success_url: `${params.returnUrl}?status=success&amount=${params.amountCents}`,
+      cancel_url: `${params.returnUrl}?status=cancelled`,
+      metadata: {
+        type: "vibezcheck_topup",
+        customerId: params.customerId,
+        amountCents: params.amountCents.toString()
+      }
+    });
+    if (!session.url) {
+      throw new Error("[vibezcheck] Failed to generate top-up checkout URL.");
+    }
+    return session.url;
+  }
+};
+function createBillingHelper(options = {}) {
+  return new BillingHelper(options);
+}
+
+// src/meter/index.ts
+var defaultMeter = createMeter();
+function wrapStream(stream, options) {
+  return defaultMeter.wrapStream(stream, options);
+}
+function trackTokens(response, options) {
+  return defaultMeter.trackUsage(response, options);
+}
+
+// src/index.ts
+var VibezCheckClient = class {
+  meter;
+  customers;
+  auth;
+  billing;
+  stripeClient;
+  constructor(config = {}) {
+    const apiKey = config.apiKey || process.env.STRIPE_SECRET_KEY;
+    if (apiKey) {
+      this.stripeClient = config.stripe || new import_stripe5.default(apiKey);
+    }
+    this.meter = new VibezMeter({
+      ...config,
+      stripe: this.stripeClient
+    });
+    if (this.stripeClient) {
+      this.customers = new CustomerManager({ stripe: this.stripeClient });
+      this.auth = new ApiKeyAuth(this.stripeClient);
+      this.billing = new BillingHelper({ stripe: this.stripeClient });
+    }
+  }
+  /**
+   * 1-Line Zero-Latency Stream Wrapper for OpenAI, Anthropic, Gemini, etc.
+   */
+  wrapStream(stream, options) {
+    return this.meter.wrapStream(stream, options);
+  }
+  /**
+   * Track token usage from a non-streaming response object
+   */
+  track(response, options) {
+    return this.meter.trackUsage(response, options);
+  }
+  /**
+   * 1-Line Wrapper for Vercel AI SDK LanguageModel
+   */
+  withBilling(model, options) {
+    return withBilling(model, {
+      ...options,
+      meter: this.meter
+    });
+  }
+  /**
+   * 1-Line Universal Stream Responder for API Routes (Next.js, Express, Hono)
+   */
+  async stream(params) {
+    const OpenAI = (await import("openai")).default;
+    const openai = new OpenAI();
+    const responseStream = await openai.chat.completions.create({
+      model: params.model,
+      messages: params.messages,
+      stream: true,
+      stream_options: { include_usage: true },
+      temperature: params.temperature
+    });
+    const meteredStream = this.wrapStream(responseStream, {
+      customer: params.customer,
+      model: params.model
+    });
+    const encoder = new TextEncoder();
+    const readable = new ReadableStream({
+      async start(controller) {
+        try {
+          for await (const chunk of meteredStream) {
+            const text = chunk.choices?.[0]?.delta?.content || "";
+            if (text) {
+              controller.enqueue(encoder.encode(text));
+            }
+          }
+          controller.close();
+        } catch (err) {
+          controller.error(err);
+        }
+      }
+    });
+    return new Response(readable, {
+      headers: {
+        "Content-Type": "text/plain; charset=utf-8",
+        "Transfer-Encoding": "chunked"
+      }
+    });
+  }
+  /**
+   * Flush pending meter events (vital for serverless runtimes)
+   */
+  async flush() {
+    await this.meter.flush();
+  }
+  /**
+   * In-memory usage statistics
+   */
+  getUsageSummary() {
+    return this.meter.getUsageSummary();
+  }
+};
+function createVibezCheck(config = {}) {
+  return new VibezCheckClient(config);
+}
+var vibezcheck = createVibezCheck;
+var vibescheck = createVibezCheck;
+var vibez = createVibezCheck();
+var vibes = vibez;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AnthropicStreamAccumulator,
+  ApiKeyAuth,
+  BillingHelper,
+  CustomerCache,
+  CustomerManager,
+  MODEL_PRICING_TABLE,
+  MeterBatcher,
+  VibezCheckClient,
+  VibezMeter,
+  calculateCost,
+  calculateUsageCost,
+  createApiKeyAuth,
+  createBillingHelper,
+  createCustomerManager,
+  createMeter,
+  createVibezCheck,
+  detectAndExtractUsage,
+  extractAnthropicResponseUsage,
+  extractAuthToken,
+  extractGeminiResponseUsage,
+  extractGenericResponseUsage,
+  extractOpenAIResponseUsage,
+  getModelPricing,
+  inspectOpenAIStreamChunk,
+  meteredModel,
+  normalizeModelKey,
+  registerModelPricing,
+  trackTokens,
+  vibes,
+  vibescheck,
+  vibez,
+  vibezcheck,
+  withBilling,
+  wrapAnthropicStream,
+  wrapGeminiStream,
+  wrapOpenAIStream,
+  wrapStream,
+  wrapUniversalStream
+});
+//# sourceMappingURL=index.js.map