vibezcheck 0.4.2 → 0.5.0

package/dist/ai-sdk/middleware.js

@@ -0,0 +1,1280 @@
+"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/ai-sdk/middleware.ts
+var middleware_exports = {};
+__export(middleware_exports, {
+  default: () => middleware_default,
+  vibezcheckMiddleware: () => vibezcheckMiddleware
+});
+module.exports = __toCommonJS(middleware_exports);
+
+// src/types.ts
+var VibezCircuitBreakerError = class extends Error {
+  event;
+  constructor(event) {
+    super(event.message);
+    this.name = "VibezCircuitBreakerError";
+    this.event = event;
+  }
+};
+
+// 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
+  };
+}
+
+// src/pricing/calculator.ts
+function calculateCost(params) {
+  let rates;
+  if (params.customRate) {
+    const outRate = params.customRate.out ?? params.customRate.output ?? 0;
+    rates = {
+      inputPer1M: params.customRate.in,
+      outputPer1M: outRate,
+      reasoningPer1M: params.customRate.reasoning ?? outRate,
+      cachedInputPer1M: params.customRate.cached ?? params.customRate.in * 0.15,
+      currency: "USD"
+    };
+  } else {
+    rates = getModelPricing(params.model);
+  }
+  const inputTokens = BigInt(Math.max(0, params.inputTokens ?? 0));
+  const outputTokens = BigInt(Math.max(0, params.outputTokens ?? 0));
+  const reasoningTokens = BigInt(Math.max(0, params.reasoningTokens ?? 0));
+  const cachedTokens = BigInt(Math.max(0, params.cachedTokens ?? 0));
+  const regularInputTokens = inputTokens > cachedTokens ? inputTokens - cachedTokens : 0n;
+  const rateInputNano = BigInt(Math.round(rates.inputPer1M * 1e3));
+  const cachedPer1M = rates.cachedInputPer1M ?? rates.inputPer1M * 0.15;
+  const rateCachedNano = BigInt(Math.round(cachedPer1M * 1e3));
+  const rateOutputNano = BigInt(Math.round(rates.outputPer1M * 1e3));
+  const reasoningPer1M = rates.reasoningPer1M ?? rates.outputPer1M;
+  const rateReasoningNano = BigInt(Math.round(reasoningPer1M * 1e3));
+  const regularInputCostNano = regularInputTokens * rateInputNano;
+  const cachedInputCostNano = cachedTokens * rateCachedNano;
+  const inputCostNano = regularInputCostNano + cachedInputCostNano;
+  const outputCostNano = outputTokens * rateOutputNano;
+  const reasoningCostNano = reasoningTokens * rateReasoningNano;
+  const standardCacheCostNano = cachedTokens * rateInputNano;
+  const cachedDiscountNano = standardCacheCostNano > cachedInputCostNano ? standardCacheCostNano - cachedInputCostNano : 0n;
+  const wholesaleNano = inputCostNano + outputCostNano;
+  const markup = params.markupMultiplier ?? 1;
+  let billedNano = wholesaleNano;
+  let hasRetail = false;
+  if (markup !== 1 || params.minimumChargeUSD !== void 0) {
+    hasRetail = true;
+    const markupMultiplierNano = BigInt(Math.round(markup * 1e3));
+    billedNano = wholesaleNano * markupMultiplierNano / 1000n;
+    if (params.minimumChargeUSD !== void 0 && params.minimumChargeUSD > 0) {
+      const minChargeNano = BigInt(Math.round(params.minimumChargeUSD * 1e9));
+      if (billedNano < minChargeNano) {
+        billedNano = minChargeNano;
+      }
+    }
+  }
+  const inputCostUSD = Number(inputCostNano) / 1e9;
+  const outputCostUSD = Number(outputCostNano) / 1e9;
+  const reasoningCostUSD = Number(reasoningCostNano) / 1e9;
+  const cachedDiscountUSD = Number(cachedDiscountNano) / 1e9;
+  const totalUSD = Number(wholesaleNano) / 1e9;
+  const wholesaleTotalUSD = totalUSD;
+  const billedUSD = Number(billedNano) / 1e9;
+  const profitUSD = Math.max(0, billedUSD - wholesaleTotalUSD);
+  const retailUSD = hasRetail ? billedUSD : void 0;
+  return {
+    inputCostUSD: Number(inputCostUSD.toFixed(8)),
+    outputCostUSD: Number(outputCostUSD.toFixed(8)),
+    reasoningCostUSD: reasoningTokens > 0n ? Number(reasoningCostUSD.toFixed(8)) : void 0,
+    cachedDiscountUSD: cachedTokens > 0n ? Number(cachedDiscountUSD.toFixed(8)) : void 0,
+    totalUSD: Number(totalUSD.toFixed(8)),
+    wholesaleTotalUSD: Number(wholesaleTotalUSD.toFixed(8)),
+    billedUSD: Number(billedUSD.toFixed(8)),
+    profitUSD: Number(profitUSD.toFixed(8)),
+    retailUSD: retailUSD !== void 0 ? Number(retailUSD.toFixed(8)) : void 0,
+    currency: rates.currency || "USD"
+  };
+}
+function calculateUsageCost(model, usage, optionsOrMarkup) {
+  const options = typeof optionsOrMarkup === "number" ? { markupMultiplier: optionsOrMarkup } : optionsOrMarkup || {};
+  return calculateCost({
+    model,
+    inputTokens: usage.inputTokens,
+    outputTokens: usage.outputTokens,
+    reasoningTokens: usage.reasoningTokens,
+    cachedTokens: usage.cachedTokens,
+    cacheWriteTokens: usage.cacheWriteTokens,
+    markupMultiplier: options.markupMultiplier,
+    minimumChargeUSD: options.minimumChargeUSD,
+    customRate: options.customRate
+  });
+}
+
+// src/customers/helpers.ts
+function normalizeCustomer(customer, extraCustomerId) {
+  if (!customer && !extraCustomerId) {
+    return {
+      customerId: void 0,
+      customerEmail: void 0,
+      customerObj: void 0,
+      customerMetadata: {}
+    };
+  }
+  if (typeof customer === "string") {
+    const isEmail = customer.includes("@");
+    const customerObj2 = {
+      id: customer,
+      email: isEmail ? customer : void 0
+    };
+    return {
+      customerId: customer,
+      customerEmail: isEmail ? customer : void 0,
+      customerObj: customerObj2,
+      customerMetadata: {}
+    };
+  }
+  const customerObj = customer || (extraCustomerId ? { id: extraCustomerId } : void 0);
+  const customerId = customerObj?.id || customerObj?.userId || extraCustomerId;
+  const customerEmail = customerObj?.email;
+  const customerMetadata = {};
+  if (customerObj) {
+    const orgId = customerObj.orgId || customerObj.organizationId;
+    if (orgId) customerMetadata.org_id = String(orgId);
+    const teamId = customerObj.teamId || customerObj.workspaceId;
+    if (teamId) customerMetadata.team_id = String(teamId);
+    if (customerObj.plan) customerMetadata.plan = String(customerObj.plan);
+    if (customerObj.tier) customerMetadata.tier = String(customerObj.tier);
+    if (customerObj.role) customerMetadata.role = String(customerObj.role);
+    if (customerObj.orgName) customerMetadata.org_name = String(customerObj.orgName);
+    if (customerObj.metadata) {
+      for (const [key, val] of Object.entries(customerObj.metadata)) {
+        if (val !== null && val !== void 0) {
+          customerMetadata[key] = val;
+        }
+      }
+    }
+  }
+  return {
+    customerId,
+    customerEmail,
+    customerObj,
+    customerMetadata
+  };
+}
+
+// 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 normalized = normalizeCustomer(options.customer, options.customerId);
+          const event = {
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            model: detectedModel,
+            provider: "openai",
+            usage: finalUsage,
+            cost,
+            customerId: normalized.customerId,
+            customerEmail: normalized.customerEmail,
+            customer: normalized.customerObj,
+            metadata: {
+              ...normalized.customerMetadata,
+              ...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 normalized = normalizeCustomer(options.customer, options.customerId);
+        const usageEvent = {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          model,
+          provider: "anthropic",
+          usage: extracted.usage,
+          cost,
+          customerId: normalized.customerId,
+          customerEmail: normalized.customerEmail,
+          customer: normalized.customerObj,
+          metadata: {
+            ...normalized.customerMetadata,
+            ...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 normalized = normalizeCustomer(options.customer, options.customerId);
+          const event = {
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            model: extracted.model,
+            provider: "google",
+            usage: extracted.usage,
+            cost,
+            customerId: normalized.customerId,
+            customerEmail: normalized.customerEmail,
+            customer: normalized.customerObj,
+            metadata: {
+              ...normalized.customerMetadata,
+              ...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.5.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 normalized = normalizeCustomer(options.customer, options.customerId);
+    const mergedMeta = {
+      ...normalized.customerMetadata,
+      ...options.metadata
+    };
+    const event = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      model,
+      provider: extracted.provider,
+      usage: extracted.usage,
+      cost,
+      customerId: normalized.customerId,
+      customerEmail: normalized.customerEmail,
+      customer: normalized.customerObj,
+      metadata: mergedMeta
+    };
+    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 normalized = normalizeCustomer(options.customer, options.customerId);
+    const mergedMeta = {
+      ...normalized.customerMetadata,
+      ...options.metadata
+    };
+    const event = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      model: options.model,
+      provider: options.provider || "custom",
+      usage,
+      cost,
+      customerId: normalized.customerId,
+      customerEmail: normalized.customerEmail,
+      customer: normalized.customerObj,
+      metadata: mergedMeta
+    };
+    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 normalized = normalizeCustomer(options.customer, options.customerId);
+  const customerId = normalized.customerId;
+  const customerEmail = normalized.customerEmail;
+  const customerObj = normalized.customerObj;
+  const customerMetadata = normalized.customerMetadata;
+  const modelId = model.modelId || "unknown-model";
+  const provider = model.provider?.replace(/^@ai-sdk\//, "") || "ai-sdk";
+  const maxCostPerCall = options.maxCostPerCallUSD !== void 0 ? options.maxCostPerCallUSD : 0.5;
+  const captureOnAbort = options.captureOnAbort !== false;
+  const scheduleFlush = () => {
+    try {
+      const flushPromise = meter.flush();
+      if (typeof globalThis !== "undefined") {
+        const g = globalThis;
+        if (typeof g.after === "function") {
+          g.after(() => flushPromise);
+          return;
+        }
+      }
+    } catch {
+    }
+  };
+  const handleUsage = (rawUsage, extraMeta) => {
+    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, {
+      markupMultiplier: options.pricing?.margin,
+      minimumChargeUSD: options.pricing?.minimumChargeUSD,
+      customRate: options.rate
+    });
+    if (maxCostPerCall > 0 && maxCostPerCall !== Infinity && cost.totalUSD > maxCostPerCall) {
+      const budgetEvent = {
+        reason: "cost_per_call_exceeded",
+        limit: maxCostPerCall,
+        current: cost.totalUSD,
+        model: modelId,
+        customerId,
+        message: `[vibezcheck] Circuit Breaker tripped: Call cost ($${cost.totalUSD.toFixed(4)}) exceeded budget ceiling ($${maxCostPerCall.toFixed(4)}).`
+      };
+      if (options.onBudgetExceeded) {
+        options.onBudgetExceeded(budgetEvent);
+      }
+      if (options.throwOnBudgetExceeded) {
+        throw new VibezCircuitBreakerError(budgetEvent);
+      }
+    }
+    if (options.maxTokensPerCall && usage.totalTokens > options.maxTokensPerCall) {
+      const budgetEvent = {
+        reason: "max_tokens_exceeded",
+        limit: options.maxTokensPerCall,
+        current: usage.totalTokens,
+        model: modelId,
+        customerId,
+        message: `[vibezcheck] Circuit Breaker tripped: Token count (${usage.totalTokens}) exceeded maxTokensPerCall limit (${options.maxTokensPerCall}).`
+      };
+      if (options.onBudgetExceeded) {
+        options.onBudgetExceeded(budgetEvent);
+      }
+      if (options.throwOnBudgetExceeded) {
+        throw new VibezCircuitBreakerError(budgetEvent);
+      }
+    }
+    const mergedMetadata = {
+      ...customerMetadata,
+      ...options.metadata,
+      ...extraMeta,
+      billingMode: options.billing?.mode || "postpaid"
+    };
+    const event = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      model: modelId,
+      provider,
+      usage,
+      cost,
+      customerId,
+      customerEmail,
+      customer: customerObj,
+      metadata: mergedMetadata
+    };
+    meter.recordUsage({
+      model: modelId,
+      provider,
+      inputTokens,
+      outputTokens,
+      reasoningTokens: usage.reasoningTokens,
+      cachedTokens: usage.cachedTokens,
+      customerId,
+      customer: customerObj,
+      metadata: event.metadata
+    });
+    if (options.onUsage) {
+      options.onUsage(event);
+    }
+    if (options.database) {
+      const dbTarget = options.database;
+      const executeDbWrite = async () => {
+        try {
+          const supabaseClient = typeof dbTarget === "object" && dbTarget !== null && typeof dbTarget.from === "function" ? dbTarget : typeof dbTarget === "object" && dbTarget !== null && typeof dbTarget.client?.from === "function" ? dbTarget.client : null;
+          if (supabaseClient) {
+            const tableName = dbTarget?.table || "vibez_usage";
+            await supabaseClient.from(tableName).insert({
+              customer_id: customerId,
+              user_id: customerObj?.userId || customerId,
+              model: modelId,
+              input_tokens: usage.inputTokens,
+              output_tokens: usage.outputTokens,
+              total_tokens: usage.totalTokens,
+              cached_tokens: usage.cachedTokens,
+              reasoning_tokens: usage.reasoningTokens,
+              cost_usd: cost.totalUSD,
+              created_at: event.timestamp,
+              metadata: event.metadata
+            });
+            return;
+          }
+          if (typeof dbTarget === "object" && dbTarget !== null && typeof dbTarget.save === "function") {
+            await dbTarget.save(event);
+            return;
+          }
+          if (typeof dbTarget === "function") {
+            await dbTarget(event);
+            return;
+          }
+        } catch (err) {
+          console.warn(`[vibezcheck] Database record failed safely:`, err?.message || err);
+        }
+      };
+      if (typeof globalThis !== "undefined" && typeof globalThis.after === "function") {
+        globalThis.after(() => executeDbWrite());
+      } else {
+        executeDbWrite().catch(() => {
+        });
+      }
+    }
+    if (options.billing?.charge && typeof options.billing.charge === "function") {
+      const chargeFn = options.billing.charge;
+      const executeCharge = async () => {
+        try {
+          await chargeFn(cost.totalUSD, event);
+        } catch (err) {
+          console.warn(`[vibezcheck] Custom charge handler failed safely:`, err?.message || err);
+        }
+      };
+      if (typeof globalThis !== "undefined" && typeof globalThis.after === "function") {
+        globalThis.after(() => executeCharge());
+      } else {
+        executeCharge().catch(() => {
+        });
+      }
+    } else if (options.billing?.provider && typeof options.billing.provider === "object" && typeof options.billing.provider.charge === "function") {
+      const providerCharge = options.billing.provider.charge;
+      const executeCharge = async () => {
+        try {
+          await providerCharge(cost.totalUSD, event);
+        } catch (err) {
+          console.warn(`[vibezcheck] Payment provider charge failed safely:`, err?.message || err);
+        }
+      };
+      if (typeof globalThis !== "undefined" && typeof globalThis.after === "function") {
+        globalThis.after(() => executeCharge());
+      } else {
+        executeCharge().catch(() => {
+        });
+      }
+    }
+    scheduleFlush();
+  };
+  const handler = {
+    get(target, prop, receiver) {
+      const originalValue = Reflect.get(target, prop, receiver);
+      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;
+          let streamCompleted = false;
+          let accumulatedChars = 0;
+          let estimatedInputTokens = 0;
+          try {
+            if (args[0]?.prompt) {
+              const str = typeof args[0].prompt === "string" ? args[0].prompt : JSON.stringify(args[0].prompt);
+              estimatedInputTokens = Math.ceil(str.length / 4);
+            }
+          } catch {
+          }
+          const abortSignal = args[0]?.abortSignal;
+          if (abortSignal && captureOnAbort) {
+            abortSignal.addEventListener(
+              "abort",
+              () => {
+                if (!streamCompleted && accumulatedChars > 0) {
+                  streamCompleted = true;
+                  const estimatedOutputTokens = Math.ceil(accumulatedChars / 3.8);
+                  handleUsage(
+                    {
+                      inputTokens: estimatedInputTokens,
+                      outputTokens: estimatedOutputTokens
+                    },
+                    { aborted: true, partial: true }
+                  );
+                }
+              },
+              { once: true }
+            );
+          }
+          const transformStream = new TransformStream({
+            transform(chunk, controller) {
+              controller.enqueue(chunk);
+              if (chunk.type === "text-delta" && chunk.textDelta) {
+                accumulatedChars += chunk.textDelta.length;
+              } else if (chunk.type === "reasoning" && (chunk.textDelta || chunk.reasoning)) {
+                accumulatedChars += (chunk.textDelta || chunk.reasoning || "").length;
+              }
+              if (chunk.type === "finish" && chunk.usage) {
+                streamCompleted = true;
+                handleUsage(chunk.usage);
+              }
+            },
+            flush() {
+              if (!streamCompleted && captureOnAbort && accumulatedChars > 0) {
+                streamCompleted = true;
+                const estimatedOutputTokens = Math.ceil(accumulatedChars / 3.8);
+                handleUsage(
+                  {
+                    inputTokens: estimatedInputTokens,
+                    outputTokens: estimatedOutputTokens
+                  },
+                  { aborted: true, partial: true }
+                );
+              }
+            }
+          });
+          return {
+            ...result,
+            stream: originalStream.pipeThrough(transformStream)
+          };
+        };
+      }
+      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;
+        };
+      }
+      return originalValue;
+    }
+  };
+  return new Proxy(model, handler);
+}
+
+// src/ai-sdk/middleware.ts
+function vibezcheckMiddleware(options = {}) {
+  return {
+    specificationVersion: "v1",
+    wrapGenerate: async ({ doGenerate, params, model }) => {
+      const metered = withBilling(model, options);
+      return metered.doGenerate(params);
+    },
+    wrapStream: async ({ doStream, params, model }) => {
+      const metered = withBilling(model, options);
+      return metered.doStream(params);
+    }
+  };
+}
+var middleware_default = vibezcheckMiddleware;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  vibezcheckMiddleware
+});
+//# sourceMappingURL=middleware.js.map