@lov3kaizen/agentsea-costs 0.5.1

package/dist/index.js

@@ -0,0 +1,2867 @@
+import { EventEmitter } from 'eventemitter3';
+import { nanoid } from 'nanoid';
+import { Cron } from 'croner';
+
+// src/core/CostManager.ts
+
+// src/pricing/ModelPricingRegistry.ts
+var DEFAULT_PRICING = [
+  // Anthropic Models
+  {
+    model: "claude-3-5-sonnet-20241022",
+    provider: "anthropic",
+    displayName: "Claude 3.5 Sonnet",
+    inputPricePerMillion: 3,
+    outputPricePerMillion: 15,
+    cacheReadPricePerMillion: 0.3,
+    cacheWritePricePerMillion: 3.75,
+    contextWindow: 2e5,
+    maxOutputTokens: 8192,
+    currency: "USD",
+    capabilities: {
+      vision: true,
+      functionCalling: true,
+      streaming: true,
+      jsonMode: true,
+      systemMessage: true,
+      computerUse: true
+    }
+  },
+  {
+    model: "claude-3-5-haiku-20241022",
+    provider: "anthropic",
+    displayName: "Claude 3.5 Haiku",
+    inputPricePerMillion: 0.8,
+    outputPricePerMillion: 4,
+    cacheReadPricePerMillion: 0.08,
+    cacheWritePricePerMillion: 1,
+    contextWindow: 2e5,
+    maxOutputTokens: 8192,
+    currency: "USD",
+    capabilities: {
+      vision: true,
+      functionCalling: true,
+      streaming: true,
+      jsonMode: true,
+      systemMessage: true
+    }
+  },
+  {
+    model: "claude-3-opus-20240229",
+    provider: "anthropic",
+    displayName: "Claude 3 Opus",
+    inputPricePerMillion: 15,
+    outputPricePerMillion: 75,
+    cacheReadPricePerMillion: 1.5,
+    cacheWritePricePerMillion: 18.75,
+    contextWindow: 2e5,
+    maxOutputTokens: 4096,
+    currency: "USD",
+    capabilities: {
+      vision: true,
+      functionCalling: true,
+      streaming: true,
+      jsonMode: true,
+      systemMessage: true
+    }
+  },
+  {
+    model: "claude-3-sonnet-20240229",
+    provider: "anthropic",
+    displayName: "Claude 3 Sonnet",
+    inputPricePerMillion: 3,
+    outputPricePerMillion: 15,
+    contextWindow: 2e5,
+    maxOutputTokens: 4096,
+    currency: "USD",
+    capabilities: {
+      vision: true,
+      functionCalling: true,
+      streaming: true,
+      jsonMode: true,
+      systemMessage: true
+    }
+  },
+  {
+    model: "claude-3-haiku-20240307",
+    provider: "anthropic",
+    displayName: "Claude 3 Haiku",
+    inputPricePerMillion: 0.25,
+    outputPricePerMillion: 1.25,
+    cacheReadPricePerMillion: 0.03,
+    cacheWritePricePerMillion: 0.3,
+    contextWindow: 2e5,
+    maxOutputTokens: 4096,
+    currency: "USD",
+    capabilities: {
+      vision: true,
+      functionCalling: true,
+      streaming: true,
+      jsonMode: true,
+      systemMessage: true
+    }
+  },
+  // OpenAI Models
+  {
+    model: "gpt-4o",
+    provider: "openai",
+    displayName: "GPT-4o",
+    inputPricePerMillion: 2.5,
+    outputPricePerMillion: 10,
+    contextWindow: 128e3,
+    maxOutputTokens: 16384,
+    currency: "USD",
+    capabilities: {
+      vision: true,
+      functionCalling: true,
+      streaming: true,
+      jsonMode: true,
+      systemMessage: true
+    }
+  },
+  {
+    model: "gpt-4o-mini",
+    provider: "openai",
+    displayName: "GPT-4o Mini",
+    inputPricePerMillion: 0.15,
+    outputPricePerMillion: 0.6,
+    contextWindow: 128e3,
+    maxOutputTokens: 16384,
+    currency: "USD",
+    capabilities: {
+      vision: true,
+      functionCalling: true,
+      streaming: true,
+      jsonMode: true,
+      systemMessage: true
+    }
+  },
+  {
+    model: "gpt-4-turbo",
+    provider: "openai",
+    displayName: "GPT-4 Turbo",
+    inputPricePerMillion: 10,
+    outputPricePerMillion: 30,
+    contextWindow: 128e3,
+    maxOutputTokens: 4096,
+    currency: "USD",
+    capabilities: {
+      vision: true,
+      functionCalling: true,
+      streaming: true,
+      jsonMode: true,
+      systemMessage: true
+    }
+  },
+  {
+    model: "gpt-3.5-turbo",
+    provider: "openai",
+    displayName: "GPT-3.5 Turbo",
+    inputPricePerMillion: 0.5,
+    outputPricePerMillion: 1.5,
+    contextWindow: 16385,
+    maxOutputTokens: 4096,
+    currency: "USD",
+    capabilities: {
+      functionCalling: true,
+      streaming: true,
+      jsonMode: true,
+      systemMessage: true
+    }
+  },
+  {
+    model: "o1-preview",
+    provider: "openai",
+    displayName: "o1 Preview",
+    inputPricePerMillion: 15,
+    outputPricePerMillion: 60,
+    contextWindow: 128e3,
+    maxOutputTokens: 32768,
+    currency: "USD",
+    capabilities: {
+      streaming: true,
+      extendedThinking: true
+    }
+  },
+  {
+    model: "o1-mini",
+    provider: "openai",
+    displayName: "o1 Mini",
+    inputPricePerMillion: 3,
+    outputPricePerMillion: 12,
+    contextWindow: 128e3,
+    maxOutputTokens: 65536,
+    currency: "USD",
+    capabilities: {
+      streaming: true,
+      extendedThinking: true
+    }
+  },
+  // Google Models
+  {
+    model: "gemini-1.5-pro",
+    provider: "google",
+    displayName: "Gemini 1.5 Pro",
+    inputPricePerMillion: 1.25,
+    outputPricePerMillion: 5,
+    contextWindow: 2e6,
+    maxOutputTokens: 8192,
+    currency: "USD",
+    capabilities: {
+      vision: true,
+      functionCalling: true,
+      streaming: true,
+      jsonMode: true,
+      systemMessage: true
+    }
+  },
+  {
+    model: "gemini-1.5-flash",
+    provider: "google",
+    displayName: "Gemini 1.5 Flash",
+    inputPricePerMillion: 0.075,
+    outputPricePerMillion: 0.3,
+    contextWindow: 1e6,
+    maxOutputTokens: 8192,
+    currency: "USD",
+    capabilities: {
+      vision: true,
+      functionCalling: true,
+      streaming: true,
+      jsonMode: true,
+      systemMessage: true
+    }
+  },
+  {
+    model: "gemini-2.0-flash-exp",
+    provider: "google",
+    displayName: "Gemini 2.0 Flash",
+    inputPricePerMillion: 0,
+    outputPricePerMillion: 0,
+    contextWindow: 1e6,
+    maxOutputTokens: 8192,
+    currency: "USD",
+    capabilities: {
+      vision: true,
+      functionCalling: true,
+      streaming: true,
+      jsonMode: true,
+      systemMessage: true
+    }
+  },
+  // Mistral Models
+  {
+    model: "mistral-large-latest",
+    provider: "mistral",
+    displayName: "Mistral Large",
+    inputPricePerMillion: 2,
+    outputPricePerMillion: 6,
+    contextWindow: 128e3,
+    maxOutputTokens: 4096,
+    currency: "USD",
+    capabilities: {
+      functionCalling: true,
+      streaming: true,
+      jsonMode: true,
+      systemMessage: true
+    }
+  },
+  {
+    model: "mistral-small-latest",
+    provider: "mistral",
+    displayName: "Mistral Small",
+    inputPricePerMillion: 0.2,
+    outputPricePerMillion: 0.6,
+    contextWindow: 32e3,
+    maxOutputTokens: 4096,
+    currency: "USD",
+    capabilities: {
+      functionCalling: true,
+      streaming: true,
+      jsonMode: true,
+      systemMessage: true
+    }
+  },
+  {
+    model: "codestral-latest",
+    provider: "mistral",
+    displayName: "Codestral",
+    inputPricePerMillion: 0.2,
+    outputPricePerMillion: 0.6,
+    contextWindow: 32e3,
+    maxOutputTokens: 4096,
+    currency: "USD",
+    capabilities: {
+      streaming: true,
+      systemMessage: true
+    }
+  },
+  // Cohere Models
+  {
+    model: "command-r-plus",
+    provider: "cohere",
+    displayName: "Command R+",
+    inputPricePerMillion: 2.5,
+    outputPricePerMillion: 10,
+    contextWindow: 128e3,
+    maxOutputTokens: 4096,
+    currency: "USD",
+    capabilities: {
+      functionCalling: true,
+      streaming: true,
+      systemMessage: true
+    }
+  },
+  {
+    model: "command-r",
+    provider: "cohere",
+    displayName: "Command R",
+    inputPricePerMillion: 0.15,
+    outputPricePerMillion: 0.6,
+    contextWindow: 128e3,
+    maxOutputTokens: 4096,
+    currency: "USD",
+    capabilities: {
+      functionCalling: true,
+      streaming: true,
+      systemMessage: true
+    }
+  }
+];
+var ModelPricingRegistry = class {
+  pricing = /* @__PURE__ */ new Map();
+  config;
+  updateTimer;
+  constructor(config = {}) {
+    this.config = {
+      autoUpdate: config.autoUpdate ?? false,
+      updateInterval: config.updateInterval ?? 24 * 60 * 60 * 1e3,
+      // 24 hours
+      defaultCurrency: config.defaultCurrency ?? "USD",
+      ...config
+    };
+    this.loadDefaultPricing();
+    if (config.customPricing) {
+      for (const pricing of config.customPricing) {
+        this.registerModel(pricing);
+      }
+    }
+    if (this.config.autoUpdate && this.config.remotePricingUrl) {
+      this.startAutoUpdate();
+    }
+  }
+  /**
+   * Load default pricing data
+   */
+  loadDefaultPricing() {
+    for (const pricing of DEFAULT_PRICING) {
+      const key = this.getKey(pricing.provider, pricing.model);
+      this.pricing.set(key, pricing);
+    }
+  }
+  /**
+   * Generate key for pricing lookup
+   */
+  getKey(provider, model) {
+    return `${provider}:${model}`;
+  }
+  /**
+   * Register or update model pricing
+   */
+  registerModel(pricing) {
+    const key = this.getKey(pricing.provider, pricing.model);
+    this.pricing.set(key, {
+      ...pricing,
+      effectiveDate: pricing.effectiveDate ?? /* @__PURE__ */ new Date()
+    });
+  }
+  /**
+   * Get pricing for a model
+   */
+  getPricing(provider, model) {
+    const key = this.getKey(provider, model);
+    return this.pricing.get(key) ?? null;
+  }
+  /**
+   * Get pricing by model name (auto-detect provider)
+   */
+  getPricingByModel(model) {
+    for (const pricing of this.pricing.values()) {
+      if (pricing.model === model) {
+        return pricing;
+      }
+    }
+    for (const pricing of this.pricing.values()) {
+      if (pricing.model.includes(model) || model.includes(pricing.model)) {
+        return pricing;
+      }
+    }
+    return null;
+  }
+  /**
+   * Calculate cost for token usage
+   */
+  calculateCost(provider, model, inputTokens, outputTokens, options) {
+    const pricing = this.getPricing(provider, model);
+    if (!pricing) {
+      throw new Error(`No pricing found for ${provider}:${model}`);
+    }
+    const inputCost = inputTokens / 1e6 * pricing.inputPricePerMillion;
+    const outputCost = outputTokens / 1e6 * pricing.outputPricePerMillion;
+    const cacheReadCost = options?.cacheReadTokens ? options.cacheReadTokens / 1e6 * (pricing.cacheReadPricePerMillion ?? 0) : 0;
+    const cacheCost = options?.cacheWriteTokens ? options.cacheWriteTokens / 1e6 * (pricing.cacheWritePricePerMillion ?? 0) : 0;
+    return {
+      inputCost,
+      outputCost,
+      cacheReadCost,
+      cacheCost,
+      totalCost: inputCost + outputCost + cacheReadCost + cacheCost,
+      currency: pricing.currency
+    };
+  }
+  /**
+   * List all models for a provider
+   */
+  listModels(provider) {
+    const models = [];
+    for (const pricing of this.pricing.values()) {
+      if (!provider || pricing.provider === provider) {
+        models.push(pricing);
+      }
+    }
+    return models.sort((a, b) => a.model.localeCompare(b.model));
+  }
+  /**
+   * List all providers
+   */
+  listProviders() {
+    const providers = /* @__PURE__ */ new Set();
+    for (const pricing of this.pricing.values()) {
+      providers.add(pricing.provider);
+    }
+    return Array.from(providers).sort();
+  }
+  /**
+   * Get provider pricing summary
+   */
+  getProviderSummary(provider) {
+    const models = this.listModels(provider);
+    if (models.length === 0) {
+      return null;
+    }
+    const inputPrices = models.map((m) => m.inputPricePerMillion);
+    const outputPrices = models.map((m) => m.outputPricePerMillion);
+    return {
+      provider,
+      modelCount: models.length,
+      minInputPrice: Math.min(...inputPrices),
+      maxInputPrice: Math.max(...inputPrices),
+      minOutputPrice: Math.min(...outputPrices),
+      maxOutputPrice: Math.max(...outputPrices),
+      models: models.map((m) => m.model)
+    };
+  }
+  /**
+   * Compare pricing between two models
+   */
+  comparePricing(modelA, modelB, sampleTokens) {
+    const pricingA = this.getPricingByModel(modelA);
+    const pricingB = this.getPricingByModel(modelB);
+    if (!pricingA || !pricingB) {
+      return null;
+    }
+    const inputDiff = pricingA.inputPricePerMillion - pricingB.inputPricePerMillion;
+    const outputDiff = pricingA.outputPricePerMillion - pricingB.outputPricePerMillion;
+    const avgPriceA = (pricingA.inputPricePerMillion + pricingA.outputPricePerMillion) / 2;
+    const avgPriceB = (pricingB.inputPricePerMillion + pricingB.outputPricePerMillion) / 2;
+    const percentageDiff = (avgPriceA - avgPriceB) / avgPriceB * 100;
+    let estimatedSavings;
+    if (sampleTokens) {
+      const costA = sampleTokens.input / 1e6 * pricingA.inputPricePerMillion + sampleTokens.output / 1e6 * pricingA.outputPricePerMillion;
+      const costB = sampleTokens.input / 1e6 * pricingB.inputPricePerMillion + sampleTokens.output / 1e6 * pricingB.outputPricePerMillion;
+      estimatedSavings = Math.abs(costA - costB);
+    }
+    return {
+      modelA,
+      modelB,
+      inputPriceDiff: inputDiff,
+      outputPriceDiff: outputDiff,
+      percentageDiff,
+      cheaperModel: avgPriceA < avgPriceB ? modelA : modelB,
+      estimatedSavings
+    };
+  }
+  /**
+   * Find cheapest model with required capabilities
+   */
+  findCheapestModel(options) {
+    const weightInput = options?.weightInput ?? 0.5;
+    const weightOutput = options?.weightOutput ?? 0.5;
+    let cheapest = null;
+    let cheapestScore = Infinity;
+    for (const pricing of this.pricing.values()) {
+      if (options?.provider && pricing.provider !== options.provider) {
+        continue;
+      }
+      if (options?.minContextWindow && pricing.contextWindow && pricing.contextWindow < options.minContextWindow) {
+        continue;
+      }
+      if (options?.requireVision && !pricing.capabilities?.vision) {
+        continue;
+      }
+      if (options?.requireFunctionCalling && !pricing.capabilities?.functionCalling) {
+        continue;
+      }
+      if (pricing.deprecated) {
+        continue;
+      }
+      const score = pricing.inputPricePerMillion * weightInput + pricing.outputPricePerMillion * weightOutput;
+      if (score < cheapestScore) {
+        cheapestScore = score;
+        cheapest = pricing;
+      }
+    }
+    return cheapest;
+  }
+  /**
+   * Start auto-update timer
+   */
+  startAutoUpdate() {
+    if (this.updateTimer) {
+      return;
+    }
+    this.updateTimer = setInterval(() => {
+      void (async () => {
+        try {
+          await this.updateFromRemote();
+        } catch {
+        }
+      })();
+    }, this.config.updateInterval);
+  }
+  /**
+   * Stop auto-update timer
+   */
+  stopAutoUpdate() {
+    if (this.updateTimer) {
+      clearInterval(this.updateTimer);
+      this.updateTimer = void 0;
+    }
+  }
+  /**
+   * Update pricing from remote source
+   */
+  async updateFromRemote() {
+    if (!this.config.remotePricingUrl) {
+      throw new Error("No remote pricing URL configured");
+    }
+    const response = await fetch(this.config.remotePricingUrl);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch pricing: ${response.statusText}`);
+    }
+    const data = await response.json();
+    for (const pricing of data) {
+      this.registerModel(pricing);
+    }
+  }
+  /**
+   * Export all pricing data
+   */
+  exportPricing() {
+    return Array.from(this.pricing.values());
+  }
+  /**
+   * Import pricing data
+   */
+  importPricing(data, replace = false) {
+    if (replace) {
+      this.pricing.clear();
+    }
+    for (const pricing of data) {
+      this.registerModel(pricing);
+    }
+  }
+  /**
+   * Clear all pricing data
+   */
+  clear() {
+    this.pricing.clear();
+  }
+  /**
+   * Reload default pricing
+   */
+  reset() {
+    this.clear();
+    this.loadDefaultPricing();
+  }
+};
+
+// src/pricing/TokenCounter.ts
+var cl100kEncoder = null;
+async function getEncoder() {
+  if (!cl100kEncoder) {
+    try {
+      const tiktoken = await import('tiktoken');
+      cl100kEncoder = tiktoken.get_encoding("cl100k_base");
+    } catch {
+      return null;
+    }
+  }
+  return cl100kEncoder;
+}
+var PROVIDER_STRATEGIES = {
+  openai: { encoding: "tiktoken", charsPerToken: 4 },
+  anthropic: { encoding: "approximate", charsPerToken: 3.5 },
+  google: { encoding: "approximate", charsPerToken: 4 },
+  azure: { encoding: "tiktoken", charsPerToken: 4 },
+  bedrock: { encoding: "approximate", charsPerToken: 3.5 },
+  cohere: { encoding: "approximate", charsPerToken: 4 },
+  mistral: { encoding: "approximate", charsPerToken: 4 },
+  replicate: { encoding: "approximate", charsPerToken: 4 },
+  custom: { encoding: "approximate", charsPerToken: 4 }
+};
+var TokenCounter = class {
+  pricingRegistry;
+  cache = /* @__PURE__ */ new Map();
+  maxCacheSize;
+  constructor(pricingRegistry, options) {
+    this.pricingRegistry = pricingRegistry;
+    this.maxCacheSize = options?.maxCacheSize ?? 1e3;
+  }
+  /**
+   * Count tokens in text
+   */
+  async countTokens(request) {
+    const { text, model, provider } = request;
+    const effectiveProvider = provider ?? this.detectProvider(model);
+    const cacheKey = `${effectiveProvider}:${text.substring(0, 100)}:${text.length}`;
+    const cached = this.cache.get(cacheKey);
+    if (cached !== void 0) {
+      return this.buildResult(
+        text,
+        cached,
+        model ?? "default",
+        effectiveProvider
+      );
+    }
+    let tokens;
+    const strategy = PROVIDER_STRATEGIES[effectiveProvider];
+    if (strategy.encoding === "tiktoken") {
+      tokens = await this.countWithTiktoken(text, strategy.charsPerToken);
+    } else {
+      tokens = this.countApproximate(text, strategy.charsPerToken);
+    }
+    this.setCached(cacheKey, tokens);
+    return this.buildResult(
+      text,
+      tokens,
+      model ?? "default",
+      effectiveProvider
+    );
+  }
+  /**
+   * Count tokens using tiktoken
+   */
+  async countWithTiktoken(text, fallbackCharsPerToken) {
+    const encoder = await getEncoder();
+    if (encoder) {
+      try {
+        const encoded = encoder.encode(text);
+        return encoded.length;
+      } catch {
+      }
+    }
+    return this.countApproximate(text, fallbackCharsPerToken);
+  }
+  /**
+   * Count tokens using approximation
+   */
+  countApproximate(text, charsPerToken) {
+    let adjustedLength = 0;
+    for (let i = 0; i < text.length; i++) {
+      const char = text[i];
+      const code = char.charCodeAt(0);
+      if (/[\s.,!?;:'"]/.test(char)) {
+        adjustedLength += 0.5;
+      } else if (/\d/.test(char)) {
+        adjustedLength += 0.7;
+      } else if (code > 127) {
+        adjustedLength += 2;
+      } else {
+        adjustedLength += 1;
+      }
+    }
+    return Math.ceil(adjustedLength / charsPerToken);
+  }
+  /**
+   * Build token count result
+   */
+  buildResult(text, tokens, model, _provider) {
+    const words = text.split(/\s+/).filter((w) => w.length > 0).length;
+    const characters = text.length;
+    let estimatedInputCost;
+    const pricing = this.pricingRegistry.getPricingByModel(model);
+    if (pricing) {
+      estimatedInputCost = tokens / 1e6 * pricing.inputPricePerMillion;
+    }
+    return {
+      tokens,
+      model,
+      estimatedInputCost,
+      characters,
+      words
+    };
+  }
+  /**
+   * Detect provider from model name
+   */
+  detectProvider(model) {
+    if (!model) return "openai";
+    const modelLower = model.toLowerCase();
+    if (modelLower.includes("claude")) return "anthropic";
+    if (modelLower.includes("gpt") || modelLower.includes("o1"))
+      return "openai";
+    if (modelLower.includes("gemini")) return "google";
+    if (modelLower.includes("mistral") || modelLower.includes("codestral"))
+      return "mistral";
+    if (modelLower.includes("command")) return "cohere";
+    return "openai";
+  }
+  /**
+   * Estimate cost for a request
+   */
+  async estimateCost(request) {
+    const { input, estimatedOutputTokens = 500, model, provider } = request;
+    let inputTokens;
+    if (typeof input === "number") {
+      inputTokens = input;
+    } else {
+      const countResult = await this.countTokens({
+        text: input,
+        model,
+        provider
+      });
+      inputTokens = countResult.tokens;
+    }
+    const effectiveProvider = provider ?? this.detectProvider(model);
+    const pricing = this.pricingRegistry.getPricing(effectiveProvider, model);
+    if (!pricing) {
+      throw new Error(`No pricing found for ${effectiveProvider}:${model}`);
+    }
+    const inputCost = inputTokens / 1e6 * pricing.inputPricePerMillion;
+    const outputCost = estimatedOutputTokens / 1e6 * pricing.outputPricePerMillion;
+    const cacheCost = request.includeCache ? inputTokens / 1e6 * (pricing.cacheWritePricePerMillion ?? 0) : void 0;
+    const estimatedCost = inputCost + outputCost + (cacheCost ?? 0);
+    const confidence = estimatedOutputTokens === 500 ? 0.7 : 0.85;
+    return {
+      estimatedCost,
+      inputTokens,
+      outputTokens: estimatedOutputTokens,
+      breakdown: {
+        inputCost,
+        outputCost,
+        cacheCost
+      },
+      model,
+      provider: effectiveProvider,
+      currency: pricing.currency,
+      confidence
+    };
+  }
+  /**
+   * Batch count tokens
+   */
+  async countTokensBatch(texts, options) {
+    return Promise.all(
+      texts.map(
+        (text) => this.countTokens({
+          text,
+          model: options?.model,
+          provider: options?.provider
+        })
+      )
+    );
+  }
+  /**
+   * Count tokens for messages (chat format)
+   */
+  async countMessagesTokens(messages, options) {
+    const perMessage = [];
+    let totalContent = 0;
+    for (const message of messages) {
+      const result = await this.countTokens({
+        text: message.content,
+        model: options?.model,
+        provider: options?.provider
+      });
+      perMessage.push({ role: message.role, tokens: result.tokens });
+      totalContent += result.tokens;
+    }
+    const overhead = messages.length * 4 + 3;
+    const totalTokens = totalContent + overhead;
+    return {
+      totalTokens,
+      perMessage,
+      overhead
+    };
+  }
+  /**
+   * Set cached value
+   */
+  setCached(key, value) {
+    if (this.cache.size >= this.maxCacheSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+  /**
+   * Clear cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+  /**
+   * Get cache stats
+   */
+  getCacheStats() {
+    return {
+      size: this.cache.size,
+      maxSize: this.maxCacheSize,
+      hitRate: 0
+      // Would need to track hits/misses for accurate rate
+    };
+  }
+};
+async function countTokens(text, options) {
+  const provider = options?.provider ?? "openai";
+  const strategy = PROVIDER_STRATEGIES[provider];
+  if (strategy.encoding === "tiktoken") {
+    const encoder = await getEncoder();
+    if (encoder) {
+      try {
+        return encoder.encode(text).length;
+      } catch {
+      }
+    }
+  }
+  return Math.ceil(text.length / strategy.charsPerToken);
+}
+function countTokensApprox(text, charsPerToken = 4) {
+  return Math.ceil(text.length / charsPerToken);
+}
+var CostTracker = class extends EventEmitter {
+  pricingRegistry;
+  storage;
+  defaultAttribution;
+  buffer = [];
+  bufferSize;
+  autoFlushTimer;
+  realTimeEvents;
+  constructor(config) {
+    super();
+    this.pricingRegistry = config.pricingRegistry;
+    this.storage = config.storage;
+    this.defaultAttribution = config.defaultAttribution;
+    this.bufferSize = config.bufferSize ?? 100;
+    this.realTimeEvents = config.realTimeEvents ?? true;
+    if (config.autoFlushInterval && config.autoFlushInterval > 0) {
+      this.autoFlushTimer = setInterval(() => {
+        this.flush().catch((err) => {
+          this.emit("error", { message: "Auto-flush failed", cause: err });
+        });
+      }, config.autoFlushInterval);
+    }
+  }
+  /**
+   * Track an API call
+   */
+  async track(options) {
+    const cost = this.calculateCost(
+      options.provider,
+      options.model,
+      options.tokens
+    );
+    const record = {
+      id: nanoid(),
+      timestamp: options.timestamp ?? /* @__PURE__ */ new Date(),
+      provider: options.provider,
+      model: options.model,
+      tokens: options.tokens,
+      cost,
+      latencyMs: options.latencyMs,
+      success: options.success ?? true,
+      error: options.error,
+      attribution: this.mergeAttribution(options.attribution),
+      metadata: options.metadata
+    };
+    this.buffer.push(record);
+    if (this.realTimeEvents) {
+      this.emit("cost:recorded", record);
+    }
+    if (this.buffer.length >= this.bufferSize) {
+      await this.flush();
+    }
+    return record;
+  }
+  /**
+   * Track from Anthropic API response
+   */
+  async trackAnthropicResponse(response, options) {
+    const usage = response.usage ?? { input_tokens: 0, output_tokens: 0 };
+    return this.track({
+      provider: "anthropic",
+      model: response.model,
+      tokens: {
+        inputTokens: usage.input_tokens,
+        outputTokens: usage.output_tokens,
+        totalTokens: usage.input_tokens + usage.output_tokens,
+        cacheReadTokens: usage.cache_read_input_tokens,
+        cacheWriteTokens: usage.cache_creation_input_tokens
+      },
+      latencyMs: options?.latencyMs,
+      attribution: options?.attribution,
+      metadata: options?.metadata
+    });
+  }
+  /**
+   * Track from OpenAI API response
+   */
+  async trackOpenAIResponse(response, options) {
+    const usage = response.usage ?? {
+      prompt_tokens: 0,
+      completion_tokens: 0,
+      total_tokens: 0
+    };
+    return this.track({
+      provider: "openai",
+      model: response.model,
+      tokens: {
+        inputTokens: usage.prompt_tokens,
+        outputTokens: usage.completion_tokens,
+        totalTokens: usage.total_tokens
+      },
+      latencyMs: options?.latencyMs,
+      attribution: options?.attribution,
+      metadata: options?.metadata
+    });
+  }
+  /**
+   * Track a failed request
+   */
+  async trackError(options) {
+    return this.track({
+      provider: options.provider,
+      model: options.model,
+      tokens: {
+        inputTokens: options.estimatedInputTokens ?? 0,
+        outputTokens: 0,
+        totalTokens: options.estimatedInputTokens ?? 0
+      },
+      latencyMs: options.latencyMs,
+      success: false,
+      error: options.error,
+      attribution: options.attribution,
+      metadata: options.metadata
+    });
+  }
+  /**
+   * Calculate cost for token usage
+   */
+  calculateCost(provider, model, tokens) {
+    try {
+      const result = this.pricingRegistry.calculateCost(
+        provider,
+        model,
+        tokens.inputTokens,
+        tokens.outputTokens,
+        {
+          cacheReadTokens: tokens.cacheReadTokens,
+          cacheWriteTokens: tokens.cacheWriteTokens
+        }
+      );
+      return {
+        inputCost: result.inputCost,
+        outputCost: result.outputCost,
+        cacheReadCost: result.cacheReadCost,
+        cacheCost: result.cacheCost,
+        totalCost: result.totalCost,
+        currency: result.currency
+      };
+    } catch {
+      return {
+        inputCost: 0,
+        outputCost: 0,
+        totalCost: 0,
+        currency: "USD"
+      };
+    }
+  }
+  /**
+   * Merge attribution with defaults
+   */
+  mergeAttribution(attribution) {
+    if (!attribution && !this.defaultAttribution) {
+      return void 0;
+    }
+    return {
+      ...this.defaultAttribution,
+      ...attribution,
+      labels: {
+        ...this.defaultAttribution?.labels,
+        ...attribution?.labels
+      }
+    };
+  }
+  /**
+   * Flush buffer to storage
+   */
+  async flush() {
+    if (this.buffer.length === 0) {
+      return 0;
+    }
+    const records = [...this.buffer];
+    this.buffer = [];
+    if (this.storage) {
+      await this.storage.saveCostRecords(records);
+    }
+    this.emit("cost:batch", { records });
+    return records.length;
+  }
+  /**
+   * Get buffered records
+   */
+  getBuffer() {
+    return [...this.buffer];
+  }
+  /**
+   * Get buffer size
+   */
+  getBufferSize() {
+    return this.buffer.length;
+  }
+  /**
+   * Clear buffer without flushing
+   */
+  clearBuffer() {
+    this.buffer = [];
+  }
+  /**
+   * Set default attribution
+   */
+  setDefaultAttribution(attribution) {
+    this.defaultAttribution = attribution;
+  }
+  /**
+   * Create a scoped tracker with preset attribution
+   */
+  scoped(attribution) {
+    return new ScopedCostTracker(this, attribution);
+  }
+  /**
+   * Close tracker
+   */
+  async close() {
+    if (this.autoFlushTimer) {
+      clearInterval(this.autoFlushTimer);
+      this.autoFlushTimer = void 0;
+    }
+    await this.flush();
+  }
+};
+var ScopedCostTracker = class _ScopedCostTracker {
+  parent;
+  scopeAttribution;
+  constructor(parent, attribution) {
+    this.parent = parent;
+    this.scopeAttribution = attribution;
+  }
+  /**
+   * Track an API call with scoped attribution
+   */
+  async track(options) {
+    return this.parent.track({
+      ...options,
+      attribution: {
+        ...this.scopeAttribution,
+        ...options.attribution,
+        labels: {
+          ...this.scopeAttribution.labels,
+          ...options.attribution?.labels
+        }
+      }
+    });
+  }
+  /**
+   * Track Anthropic response
+   */
+  async trackAnthropicResponse(response, options) {
+    return this.parent.trackAnthropicResponse(response, {
+      ...options,
+      attribution: {
+        ...this.scopeAttribution,
+        ...options?.attribution
+      }
+    });
+  }
+  /**
+   * Track OpenAI response
+   */
+  async trackOpenAIResponse(response, options) {
+    return this.parent.trackOpenAIResponse(response, {
+      ...options,
+      attribution: {
+        ...this.scopeAttribution,
+        ...options?.attribution
+      }
+    });
+  }
+  /**
+   * Create a nested scope
+   */
+  scoped(attribution) {
+    return new _ScopedCostTracker(this.parent, {
+      ...this.scopeAttribution,
+      ...attribution,
+      labels: {
+        ...this.scopeAttribution.labels,
+        ...attribution.labels
+      }
+    });
+  }
+};
+
+// src/core/CostManager.ts
+var CostManager = class extends EventEmitter {
+  storage;
+  pricingRegistry;
+  tokenCounter;
+  tracker;
+  config;
+  initialized = false;
+  constructor(options = {}) {
+    super();
+    this.config = {
+      currency: options.currency ?? "USD",
+      autoFlushInterval: options.autoFlushInterval ?? 3e4,
+      // 30 seconds
+      bufferSize: options.bufferSize ?? 100,
+      realTimeTracking: options.realTimeTracking ?? true,
+      defaultAttribution: options.defaultAttribution
+    };
+    this.storage = options.storage;
+    this.pricingRegistry = options.pricingRegistry ?? new ModelPricingRegistry();
+    this.tokenCounter = new TokenCounter(this.pricingRegistry);
+    this.tracker = new CostTracker({
+      pricingRegistry: this.pricingRegistry,
+      storage: this.storage,
+      defaultAttribution: this.config.defaultAttribution,
+      autoFlushInterval: this.config.autoFlushInterval,
+      bufferSize: this.config.bufferSize,
+      realTimeEvents: this.config.realTimeTracking
+    });
+    this.tracker.on("cost:recorded", (record) => {
+      this.emit("cost:recorded", record);
+    });
+    this.tracker.on("cost:batch", (records) => {
+      this.emit("cost:batch", records);
+    });
+    this.tracker.on("error", (error) => {
+      this.emit("error", error);
+    });
+  }
+  /**
+   * Initialize the cost manager
+   */
+  async initialize() {
+    if (this.initialized) return;
+    if (this.storage) {
+      await this.storage.initialize();
+    }
+    this.initialized = true;
+  }
+  /**
+   * Close the cost manager
+   */
+  async close() {
+    await this.tracker.close();
+    if (this.storage) {
+      await this.storage.close();
+    }
+    this.initialized = false;
+  }
+  // ==================== Tracking ====================
+  /**
+   * Track an API call
+   */
+  async track(options) {
+    return this.tracker.track(options);
+  }
+  /**
+   * Track from Anthropic API response
+   */
+  async trackAnthropicResponse(response, options) {
+    return this.tracker.trackAnthropicResponse(response, options);
+  }
+  /**
+   * Track from OpenAI API response
+   */
+  async trackOpenAIResponse(response, options) {
+    return this.tracker.trackOpenAIResponse(response, options);
+  }
+  /**
+   * Track a failed request
+   */
+  async trackError(options) {
+    return this.tracker.trackError(options);
+  }
+  /**
+   * Create a scoped tracker
+   */
+  scoped(attribution) {
+    return this.tracker.scoped(attribution);
+  }
+  /**
+   * Flush pending records to storage
+   */
+  async flush() {
+    return this.tracker.flush();
+  }
+  // ==================== Token Counting ====================
+  /**
+   * Count tokens in text
+   */
+  async countTokens(text, options) {
+    const result = await this.tokenCounter.countTokens({
+      text,
+      model: options?.model,
+      provider: options?.provider
+    });
+    return result.tokens;
+  }
+  /**
+   * Estimate cost before making a request
+   */
+  async estimateCost(input, options) {
+    const result = await this.tokenCounter.estimateCost({
+      input,
+      model: options.model,
+      provider: options.provider,
+      estimatedOutputTokens: options.estimatedOutputTokens
+    });
+    return {
+      estimatedCost: result.estimatedCost,
+      inputTokens: result.inputTokens,
+      outputTokens: result.outputTokens,
+      currency: result.currency
+    };
+  }
+  // ==================== Pricing ====================
+  /**
+   * Get pricing registry
+   */
+  getPricingRegistry() {
+    return this.pricingRegistry;
+  }
+  /**
+   * Get token counter
+   */
+  getTokenCounter() {
+    return this.tokenCounter;
+  }
+  /**
+   * Calculate cost for token usage
+   */
+  calculateCost(provider, model, tokens) {
+    const result = this.pricingRegistry.calculateCost(
+      provider,
+      model,
+      tokens.inputTokens,
+      tokens.outputTokens,
+      {
+        cacheReadTokens: tokens.cacheReadTokens,
+        cacheWriteTokens: tokens.cacheWriteTokens
+      }
+    );
+    return {
+      totalCost: result.totalCost,
+      inputCost: result.inputCost,
+      outputCost: result.outputCost,
+      currency: result.currency
+    };
+  }
+  // ==================== Queries ====================
+  /**
+   * Get cost summary
+   */
+  async getSummary(options = {}) {
+    if (!this.storage) {
+      throw new Error("Storage adapter required for queries");
+    }
+    return this.storage.getCostSummary(options);
+  }
+  /**
+   * Get costs by dimension
+   */
+  async getCostsByDimension(dimension, options = {}) {
+    if (!this.storage) {
+      throw new Error("Storage adapter required for queries");
+    }
+    return this.storage.getCostsByDimension(dimension, options);
+  }
+  /**
+   * Get cost trends
+   */
+  async getCostTrends(options = {}) {
+    if (!this.storage) {
+      throw new Error("Storage adapter required for queries");
+    }
+    return this.storage.getCostTrends(options);
+  }
+  /**
+   * Query cost records
+   */
+  async queryRecords(options = {}) {
+    if (!this.storage) {
+      throw new Error("Storage adapter required for queries");
+    }
+    return this.storage.queryCostRecords(options);
+  }
+  /**
+   * Get a specific cost record
+   */
+  async getRecord(id) {
+    if (!this.storage) {
+      throw new Error("Storage adapter required for queries");
+    }
+    return this.storage.getCostRecord(id);
+  }
+  // ==================== Statistics ====================
+  /**
+   * Get total cost for a time period
+   */
+  async getTotalCost(options = {}) {
+    const summary = await this.getSummary(options);
+    return summary.totalCost;
+  }
+  /**
+   * Get total tokens for a time period
+   */
+  async getTotalTokens(options = {}) {
+    const summary = await this.getSummary(options);
+    return summary.totalTokens;
+  }
+  /**
+   * Get request count for a time period
+   */
+  async getRequestCount(options = {}) {
+    const summary = await this.getSummary(options);
+    return summary.requestCount;
+  }
+  /**
+   * Get error rate for a time period
+   */
+  async getErrorRate(options = {}) {
+    const summary = await this.getSummary(options);
+    if (summary.requestCount === 0) return 0;
+    return summary.errorCount / summary.requestCount;
+  }
+  /**
+   * Get average cost per request
+   */
+  async getAvgCostPerRequest(options = {}) {
+    const summary = await this.getSummary(options);
+    return summary.avgCostPerRequest;
+  }
+  // ==================== Top Consumers ====================
+  /**
+   * Get top models by cost
+   */
+  async getTopModels(options = {}) {
+    const results = await this.getCostsByDimension("model", options);
+    return results.sort((a, b) => b.totalCost - a.totalCost).slice(0, options.limit ?? 10);
+  }
+  /**
+   * Get top users by cost
+   */
+  async getTopUsers(options = {}) {
+    const results = await this.getCostsByDimension("user", options);
+    return results.sort((a, b) => b.totalCost - a.totalCost).slice(0, options.limit ?? 10);
+  }
+  /**
+   * Get top features by cost
+   */
+  async getTopFeatures(options = {}) {
+    const results = await this.getCostsByDimension("feature", options);
+    return results.sort((a, b) => b.totalCost - a.totalCost).slice(0, options.limit ?? 10);
+  }
+  // ==================== Maintenance ====================
+  /**
+   * Cleanup old records
+   */
+  async cleanup(olderThan) {
+    if (!this.storage) {
+      throw new Error("Storage adapter required for cleanup");
+    }
+    return this.storage.cleanup(olderThan);
+  }
+  /**
+   * Get storage stats
+   */
+  async getStorageStats() {
+    if (!this.storage) {
+      return { recordCount: 0 };
+    }
+    const stats = await this.storage.getStats();
+    return {
+      recordCount: stats.costRecordCount,
+      storageSizeBytes: stats.storageSizeBytes,
+      oldestRecord: stats.oldestRecord,
+      newestRecord: stats.newestRecord
+    };
+  }
+  /**
+   * Optimize storage
+   */
+  async optimizeStorage() {
+    if (!this.storage) {
+      throw new Error("Storage adapter required for optimization");
+    }
+    await this.storage.optimize();
+  }
+  // ==================== Export/Import ====================
+  /**
+   * Export cost records
+   */
+  async exportRecords(options = {}) {
+    const [records, summary] = await Promise.all([
+      this.queryRecords(options),
+      this.getSummary(options)
+    ]);
+    return {
+      records,
+      summary,
+      exportedAt: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Import cost records
+   */
+  async importRecords(records) {
+    if (!this.storage) {
+      throw new Error("Storage adapter required for import");
+    }
+    await this.storage.saveCostRecords(records);
+    return records.length;
+  }
+};
+function createCostManager(options) {
+  return new CostManager(options);
+}
+var BudgetManager = class extends EventEmitter {
+  budgets = /* @__PURE__ */ new Map();
+  usage = /* @__PURE__ */ new Map();
+  resetJobs = /* @__PURE__ */ new Map();
+  storage;
+  config;
+  constructor(config = {}, storage) {
+    super();
+    this.config = {
+      enforceOnRequest: config.enforceOnRequest ?? true,
+      defaultAction: config.defaultAction ?? "allow",
+      checkInterval: config.checkInterval ?? 6e4,
+      // 1 minute
+      enableProjections: config.enableProjections ?? true,
+      ...config
+    };
+    this.storage = storage;
+  }
+  /**
+   * Initialize from storage
+   */
+  async initialize() {
+    if (this.storage) {
+      const budgets = await this.storage.listBudgets();
+      for (const budget of budgets) {
+        this.budgets.set(budget.id, budget);
+        this.scheduleReset(budget);
+      }
+      for (const budget of this.budgets.values()) {
+        await this.refreshUsage(budget.id);
+      }
+    }
+  }
+  /**
+   * Create a new budget
+   */
+  async createBudget(request) {
+    const budget = {
+      id: nanoid(),
+      name: request.name,
+      description: request.description,
+      limit: request.limit,
+      currency: request.currency ?? "USD",
+      period: request.period,
+      scope: request.scope,
+      scopeId: request.scopeId,
+      warningThresholds: request.warningThresholds ?? [50, 80, 90],
+      actions: request.actions,
+      filters: request.filters,
+      rollover: request.rollover ?? false,
+      maxRollover: request.maxRollover,
+      enabled: true,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.budgets.set(budget.id, budget);
+    const usage = this.initializeUsage(budget);
+    this.usage.set(budget.id, usage);
+    this.scheduleReset(budget);
+    if (this.storage) {
+      await this.storage.saveBudget(budget);
+    }
+    this.emit("budget:created", budget);
+    return budget;
+  }
+  /**
+   * Update a budget
+   */
+  async updateBudget(budgetId, updates) {
+    const budget = this.budgets.get(budgetId);
+    if (!budget) {
+      throw new Error(`Budget not found: ${budgetId}`);
+    }
+    const updated = {
+      ...budget,
+      ...updates,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.budgets.set(budgetId, updated);
+    if (updates.enabled !== void 0 || updates.limit) {
+      this.scheduleReset(updated);
+    }
+    if (this.storage) {
+      await this.storage.updateBudget(budgetId, updated);
+    }
+    this.emit("budget:updated", { budgetId, updates });
+    return updated;
+  }
+  /**
+   * Delete a budget
+   */
+  async deleteBudget(budgetId) {
+    const budget = this.budgets.get(budgetId);
+    if (!budget) {
+      return false;
+    }
+    const job = this.resetJobs.get(budgetId);
+    if (job) {
+      job.stop();
+      this.resetJobs.delete(budgetId);
+    }
+    this.budgets.delete(budgetId);
+    this.usage.delete(budgetId);
+    if (this.storage) {
+      await this.storage.deleteBudget(budgetId);
+    }
+    this.emit("budget:deleted", budgetId);
+    return true;
+  }
+  /**
+   * Get a budget
+   */
+  getBudget(budgetId) {
+    return this.budgets.get(budgetId) ?? null;
+  }
+  /**
+   * List all budgets
+   */
+  listBudgets(options) {
+    let budgets = Array.from(this.budgets.values());
+    if (options?.scope) {
+      budgets = budgets.filter((b) => b.scope === options.scope);
+    }
+    if (options?.scopeId) {
+      budgets = budgets.filter((b) => b.scopeId === options.scopeId);
+    }
+    if (options?.enabled !== void 0) {
+      budgets = budgets.filter((b) => b.enabled === options.enabled);
+    }
+    return budgets;
+  }
+  /**
+   * Get budget usage
+   */
+  async getUsage(budgetId) {
+    const budget = this.budgets.get(budgetId);
+    if (!budget) {
+      return null;
+    }
+    await this.refreshUsage(budgetId);
+    return this.usage.get(budgetId) ?? null;
+  }
+  /**
+   * Check if a request is within budget
+   */
+  async checkBudget(request) {
+    const matchingBudgets = [];
+    const exceededBudgets = [];
+    const warningBudgets = [];
+    const budgetsToCheck = request.budgetIds ? request.budgetIds.map((id) => this.budgets.get(id)).filter(Boolean) : this.findMatchingBudgets(request.attribution);
+    for (const budget of budgetsToCheck) {
+      if (!budget.enabled) continue;
+      await this.refreshUsage(budget.id);
+      const usage = this.usage.get(budget.id);
+      if (!usage) continue;
+      matchingBudgets.push(usage);
+      const projectedUsage = usage.currentUsage + request.estimatedCost;
+      const projectedPercentage = projectedUsage / usage.limit * 100;
+      if (projectedPercentage >= 100) {
+        exceededBudgets.push(budget.id);
+      } else if (projectedPercentage >= (budget.warningThresholds?.[0] ?? 50)) {
+        warningBudgets.push(budget.id);
+      }
+    }
+    let action = "allow";
+    let reason;
+    if (exceededBudgets.length > 0) {
+      const budget = this.budgets.get(exceededBudgets[0]);
+      const budgetAction = budget?.actions?.find((a) => a.threshold >= 100);
+      if (budgetAction?.action === "block") {
+        action = "block";
+        reason = `Budget limit exceeded for "${budget?.name}"`;
+      } else if (budgetAction?.action === "throttle") {
+        action = "throttle";
+        reason = `Budget limit exceeded for "${budget?.name}"`;
+      } else {
+        action = this.config.defaultAction ?? "allow";
+        if (action !== "allow") {
+          reason = `Budget limit exceeded for "${budget?.name}"`;
+        }
+      }
+    }
+    return {
+      allowed: action === "allow" || action === "warn",
+      reason,
+      matchingBudgets,
+      exceededBudgets,
+      warningBudgets,
+      action
+    };
+  }
+  /**
+   * Record cost against budgets
+   */
+  async recordCost(cost, attribution) {
+    const matchingBudgets = this.findMatchingBudgets(attribution);
+    for (const budget of matchingBudgets) {
+      if (!budget.enabled) continue;
+      const usage = this.usage.get(budget.id);
+      if (!usage) continue;
+      usage.currentUsage += cost;
+      usage.remaining = Math.max(0, usage.limit - usage.currentUsage);
+      usage.usagePercentage = usage.currentUsage / usage.limit * 100;
+      await this.checkThresholds(budget, usage);
+      if (this.config.enableProjections) {
+        this.updateProjections(usage);
+      }
+    }
+  }
+  /**
+   * Find budgets matching attribution
+   */
+  findMatchingBudgets(attribution) {
+    const matching = [];
+    for (const budget of this.budgets.values()) {
+      if (!budget.enabled) continue;
+      if (budget.scope === "global") {
+        matching.push(budget);
+        continue;
+      }
+      if (!attribution) continue;
+      let matches = false;
+      switch (budget.scope) {
+        case "user":
+          matches = budget.scopeId === attribution.userId;
+          break;
+        case "agent":
+          matches = budget.scopeId === attribution.agentId;
+          break;
+        case "project":
+          matches = budget.scopeId === attribution.projectId;
+          break;
+        case "team":
+          matches = budget.scopeId === attribution.teamId;
+          break;
+        case "feature":
+          matches = budget.scopeId === attribution.feature;
+          break;
+      }
+      if (!matches) continue;
+      if (budget.filters) {
+        if (budget.filters.environment && budget.filters.environment !== attribution.environment) {
+          continue;
+        }
+      }
+      matching.push(budget);
+    }
+    return matching;
+  }
+  /**
+   * Initialize usage for a budget
+   */
+  initializeUsage(budget) {
+    const period = this.getPeriodDates(budget.period);
+    return {
+      budgetId: budget.id,
+      currentUsage: 0,
+      limit: budget.limit,
+      usagePercentage: 0,
+      remaining: budget.limit,
+      periodStart: period.start,
+      periodEnd: period.end,
+      timeRemaining: this.getTimeRemaining(period.end),
+      status: "active",
+      triggeredThresholds: []
+    };
+  }
+  /**
+   * Refresh usage from storage
+   */
+  async refreshUsage(budgetId) {
+    const budget = this.budgets.get(budgetId);
+    if (!budget) return;
+    let usage = this.usage.get(budgetId);
+    if (!usage) {
+      usage = this.initializeUsage(budget);
+      this.usage.set(budgetId, usage);
+    }
+    usage.timeRemaining = this.getTimeRemaining(usage.periodEnd);
+    if (this.storage) {
+      const queryOptions = {
+        startDate: usage.periodStart,
+        endDate: usage.periodEnd
+      };
+      if (budget.scope !== "global" && budget.scopeId) {
+        switch (budget.scope) {
+          case "user":
+            queryOptions.userIds = [budget.scopeId];
+            break;
+          case "agent":
+            queryOptions.agentIds = [budget.scopeId];
+            break;
+          case "project":
+            queryOptions.projectIds = [budget.scopeId];
+            break;
+          case "team":
+            queryOptions.teamIds = [budget.scopeId];
+            break;
+          case "feature":
+            queryOptions.features = [budget.scopeId];
+            break;
+        }
+      }
+      try {
+        const summary = await this.storage.getCostSummary(queryOptions);
+        usage.currentUsage = summary.totalCost;
+        usage.remaining = Math.max(0, budget.limit - usage.currentUsage);
+        usage.usagePercentage = usage.currentUsage / budget.limit * 100;
+        if (usage.usagePercentage >= 100) {
+          usage.status = "exceeded";
+        } else if (!budget.enabled) {
+          usage.status = "paused";
+        } else {
+          usage.status = "active";
+        }
+      } catch {
+      }
+    }
+  }
+  /**
+   * Check thresholds and emit alerts
+   */
+  async checkThresholds(budget, usage) {
+    if (!budget.warningThresholds) return;
+    for (const threshold of budget.warningThresholds) {
+      if (usage.usagePercentage >= threshold && !usage.triggeredThresholds.includes(threshold)) {
+        usage.triggeredThresholds.push(threshold);
+        const alert = {
+          id: nanoid(),
+          budgetId: budget.id,
+          budgetName: budget.name,
+          type: threshold >= 100 ? "exceeded" : "warning",
+          threshold,
+          usage: usage.currentUsage,
+          limit: usage.limit,
+          percentage: usage.usagePercentage,
+          message: threshold >= 100 ? `Budget "${budget.name}" has been exceeded (${usage.usagePercentage.toFixed(1)}%)` : `Budget "${budget.name}" has reached ${threshold}% (${usage.usagePercentage.toFixed(1)}%)`,
+          timestamp: /* @__PURE__ */ new Date(),
+          acknowledged: false
+        };
+        if (this.storage) {
+          await this.storage.saveBudgetAlert(alert);
+        }
+        if (threshold >= 100) {
+          this.emit("budget:exceeded", alert);
+        } else {
+          this.emit("budget:warning", alert);
+        }
+        const action = budget.actions?.find((a) => a.threshold === threshold);
+        if (action) {
+          await this.executeAction(action, alert);
+        }
+      }
+    }
+  }
+  /**
+   * Execute threshold action
+   */
+  async executeAction(action, alert) {
+    if (action.notifyEmails && action.notifyEmails.length > 0) {
+      console.log(
+        `Would send email to ${action.notifyEmails.join(", ")}:`,
+        alert.message
+      );
+    }
+    if (action.webhookUrl) {
+      try {
+        await fetch(action.webhookUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(alert)
+        });
+      } catch {
+        this.emit("error", {
+          message: `Failed to send webhook to ${action.webhookUrl}`
+        });
+      }
+    }
+  }
+  /**
+   * Update projections
+   */
+  updateProjections(usage) {
+    if (usage.timeRemaining <= 0) return;
+    const elapsedMs = Date.now() - usage.periodStart.getTime();
+    const totalMs = usage.periodEnd.getTime() - usage.periodStart.getTime();
+    if (elapsedMs <= 0) return;
+    const rate = usage.currentUsage / elapsedMs;
+    usage.projectedUsage = rate * totalMs;
+    usage.projectedExceed = usage.projectedUsage > usage.limit;
+  }
+  /**
+   * Schedule budget reset
+   */
+  scheduleReset(budget) {
+    const existingJob = this.resetJobs.get(budget.id);
+    if (existingJob) {
+      existingJob.stop();
+    }
+    if (!budget.enabled) return;
+    const pattern = this.getCronPattern(budget.period, budget.resetSchedule);
+    if (!pattern) return;
+    const job = new Cron(pattern, async () => {
+      await this.resetBudget(budget.id);
+    });
+    this.resetJobs.set(budget.id, job);
+  }
+  /**
+   * Reset a budget
+   */
+  async resetBudget(budgetId) {
+    const budget = this.budgets.get(budgetId);
+    if (!budget) return;
+    const usage = this.usage.get(budgetId);
+    if (!usage) return;
+    const previousUsage = usage.currentUsage;
+    if (this.storage) {
+      const historyEntry = {
+        budgetId,
+        periodStart: usage.periodStart,
+        periodEnd: usage.periodEnd,
+        usage: previousUsage,
+        limit: usage.limit,
+        usagePercentage: usage.usagePercentage,
+        exceeded: previousUsage > usage.limit,
+        rolloverIn: usage.rolloverIn,
+        rolloverOut: budget.rollover ? Math.min(usage.remaining, budget.maxRollover ?? Infinity) : void 0
+      };
+      await this.storage.saveBudgetHistory(historyEntry);
+    }
+    let newLimit = budget.limit;
+    if (budget.rollover && usage.remaining > 0) {
+      const rolloverAmount = Math.min(
+        usage.remaining,
+        budget.maxRollover ?? Infinity
+      );
+      newLimit += rolloverAmount;
+    }
+    const period = this.getPeriodDates(budget.period);
+    usage.currentUsage = 0;
+    usage.limit = newLimit;
+    usage.remaining = newLimit;
+    usage.usagePercentage = 0;
+    usage.periodStart = period.start;
+    usage.periodEnd = period.end;
+    usage.timeRemaining = this.getTimeRemaining(period.end);
+    usage.status = "active";
+    usage.triggeredThresholds = [];
+    usage.projectedUsage = void 0;
+    usage.projectedExceed = void 0;
+    this.emit("budget:reset", { budgetId, previousUsage });
+  }
+  /**
+   * Get period dates
+   */
+  getPeriodDates(period) {
+    const now = /* @__PURE__ */ new Date();
+    let start;
+    let end;
+    switch (period) {
+      case "hourly":
+        start = new Date(
+          now.getFullYear(),
+          now.getMonth(),
+          now.getDate(),
+          now.getHours()
+        );
+        end = new Date(start.getTime() + 60 * 60 * 1e3);
+        break;
+      case "daily":
+        start = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        end = new Date(start.getTime() + 24 * 60 * 60 * 1e3);
+        break;
+      case "weekly": {
+        const dayOfWeek = now.getDay();
+        start = new Date(
+          now.getFullYear(),
+          now.getMonth(),
+          now.getDate() - dayOfWeek
+        );
+        end = new Date(start.getTime() + 7 * 24 * 60 * 60 * 1e3);
+        break;
+      }
+      case "monthly":
+        start = new Date(now.getFullYear(), now.getMonth(), 1);
+        end = new Date(now.getFullYear(), now.getMonth() + 1, 1);
+        break;
+      case "quarterly": {
+        const quarter = Math.floor(now.getMonth() / 3);
+        start = new Date(now.getFullYear(), quarter * 3, 1);
+        end = new Date(now.getFullYear(), (quarter + 1) * 3, 1);
+        break;
+      }
+      case "yearly":
+        start = new Date(now.getFullYear(), 0, 1);
+        end = new Date(now.getFullYear() + 1, 0, 1);
+        break;
+      default:
+        start = new Date(now.getFullYear(), now.getMonth(), 1);
+        end = new Date(now.getFullYear(), now.getMonth() + 1, 1);
+    }
+    return { start, end };
+  }
+  /**
+   * Get time remaining in period
+   */
+  getTimeRemaining(endDate) {
+    return Math.max(0, endDate.getTime() - Date.now());
+  }
+  /**
+   * Get cron pattern for period
+   */
+  getCronPattern(period, customSchedule) {
+    if (customSchedule) return customSchedule;
+    switch (period) {
+      case "hourly":
+        return "0 * * * *";
+      // Every hour at minute 0
+      case "daily":
+        return "0 0 * * *";
+      // Every day at midnight
+      case "weekly":
+        return "0 0 * * 0";
+      // Every Sunday at midnight
+      case "monthly":
+        return "0 0 1 * *";
+      // First of every month
+      case "quarterly":
+        return "0 0 1 1,4,7,10 *";
+      // First of Jan, Apr, Jul, Oct
+      case "yearly":
+        return "0 0 1 1 *";
+      // First of January
+      default:
+        return null;
+    }
+  }
+  /**
+   * Close budget manager
+   */
+  close() {
+    for (const job of this.resetJobs.values()) {
+      job.stop();
+    }
+    this.resetJobs.clear();
+  }
+};
+
+// src/storage/adapters/BufferStorage.ts
+var BufferStorage = class {
+  records = /* @__PURE__ */ new Map();
+  budgets = /* @__PURE__ */ new Map();
+  budgetHistory = /* @__PURE__ */ new Map();
+  budgetAlerts = /* @__PURE__ */ new Map();
+  attributedCosts = [];
+  alertRules = /* @__PURE__ */ new Map();
+  alerts = /* @__PURE__ */ new Map();
+  config;
+  flushTimer;
+  constructor(config = {}) {
+    this.config = {
+      maxRecords: config.maxRecords ?? 1e4,
+      autoFlushInterval: config.autoFlushInterval ?? 0,
+      onFlush: config.onFlush
+    };
+    if (this.config.autoFlushInterval && this.config.autoFlushInterval > 0) {
+      this.flushTimer = setInterval(() => {
+        void (async () => {
+          if (this.config.onFlush) {
+            const records = Array.from(this.records.values());
+            await this.config.onFlush(records);
+          }
+        })();
+      }, this.config.autoFlushInterval);
+    }
+  }
+  async initialize() {
+  }
+  close() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+    }
+    return Promise.resolve();
+  }
+  // ==================== Cost Records ====================
+  saveCostRecord(record) {
+    this.enforceLimit();
+    this.records.set(record.id, record);
+    return Promise.resolve();
+  }
+  async saveCostRecords(records) {
+    for (const record of records) {
+      await this.saveCostRecord(record);
+    }
+  }
+  getCostRecord(id) {
+    return Promise.resolve(this.records.get(id) ?? null);
+  }
+  queryCostRecords(options) {
+    let results = Array.from(this.records.values());
+    results = this.applyFilters(results, options);
+    results = this.applySort(results, options);
+    results = this.applyPagination(results, options);
+    return Promise.resolve(results);
+  }
+  async getCostSummary(options) {
+    const records = await this.queryCostRecords(options);
+    const summary = {
+      periodStart: options.startDate ?? /* @__PURE__ */ new Date(0),
+      periodEnd: options.endDate ?? /* @__PURE__ */ new Date(),
+      totalCost: 0,
+      totalTokens: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      requestCount: records.length,
+      successCount: 0,
+      errorCount: 0,
+      avgCostPerRequest: 0,
+      avgTokensPerRequest: 0,
+      currency: "USD"
+    };
+    let totalLatency = 0;
+    let latencyCount = 0;
+    for (const record of records) {
+      summary.totalCost += record.cost.totalCost;
+      summary.totalTokens += record.tokens.totalTokens;
+      summary.inputTokens += record.tokens.inputTokens;
+      summary.outputTokens += record.tokens.outputTokens;
+      if (record.success) {
+        summary.successCount++;
+      } else {
+        summary.errorCount++;
+      }
+      if (record.latencyMs) {
+        totalLatency += record.latencyMs;
+        latencyCount++;
+      }
+    }
+    if (summary.requestCount > 0) {
+      summary.avgCostPerRequest = summary.totalCost / summary.requestCount;
+      summary.avgTokensPerRequest = summary.totalTokens / summary.requestCount;
+    }
+    if (latencyCount > 0) {
+      summary.avgLatencyMs = totalLatency / latencyCount;
+    }
+    return summary;
+  }
+  async getCostsByDimension(dimension, options) {
+    const records = await this.queryCostRecords(options);
+    const groups = /* @__PURE__ */ new Map();
+    let totalCost = 0;
+    for (const record of records) {
+      const value = this.getDimensionValue(record, dimension);
+      if (!value) continue;
+      const existing = groups.get(value) ?? { cost: 0, tokens: 0, count: 0 };
+      existing.cost += record.cost.totalCost;
+      existing.tokens += record.tokens.totalTokens;
+      existing.count++;
+      groups.set(value, existing);
+      totalCost += record.cost.totalCost;
+    }
+    return Array.from(groups.entries()).map(([value, data]) => ({
+      dimension,
+      value,
+      totalCost: data.cost,
+      totalTokens: data.tokens,
+      requestCount: data.count,
+      percentage: totalCost > 0 ? data.cost / totalCost * 100 : 0
+    }));
+  }
+  async getCostTrends(options) {
+    const records = await this.queryCostRecords(options);
+    const granularity = options.granularity ?? "day";
+    const buckets = /* @__PURE__ */ new Map();
+    for (const record of records) {
+      const bucketTime = this.getBucketTime(record.timestamp, granularity);
+      const existing = buckets.get(bucketTime) ?? {
+        timestamp: new Date(bucketTime),
+        cost: 0,
+        tokens: 0,
+        requests: 0
+      };
+      existing.cost += record.cost.totalCost;
+      existing.tokens += record.tokens.totalTokens;
+      existing.requests++;
+      buckets.set(bucketTime, existing);
+    }
+    return Array.from(buckets.values()).sort(
+      (a, b) => a.timestamp.getTime() - b.timestamp.getTime()
+    );
+  }
+  deleteCostRecords(ids) {
+    let deleted = 0;
+    for (const id of ids) {
+      if (this.records.delete(id)) {
+        deleted++;
+      }
+    }
+    return Promise.resolve(deleted);
+  }
+  async deleteCostRecordsByFilter(options) {
+    const toDelete = await this.queryCostRecords(options);
+    return this.deleteCostRecords(toDelete.map((r) => r.id));
+  }
+  // ==================== Budgets ====================
+  saveBudget(budget) {
+    this.budgets.set(budget.id, budget);
+    return Promise.resolve();
+  }
+  getBudget(id) {
+    return Promise.resolve(this.budgets.get(id) ?? null);
+  }
+  listBudgets(options) {
+    let budgets = Array.from(this.budgets.values());
+    if (options?.scope) {
+      budgets = budgets.filter((b) => b.scope === options.scope);
+    }
+    if (options?.scopeId) {
+      budgets = budgets.filter((b) => b.scopeId === options.scopeId);
+    }
+    if (options?.enabled !== void 0) {
+      budgets = budgets.filter((b) => b.enabled === options.enabled);
+    }
+    return Promise.resolve(budgets);
+  }
+  updateBudget(id, updates) {
+    const budget = this.budgets.get(id);
+    if (budget) {
+      this.budgets.set(id, { ...budget, ...updates });
+    }
+    return Promise.resolve();
+  }
+  deleteBudget(id) {
+    return Promise.resolve(this.budgets.delete(id));
+  }
+  getBudgetUsage(budgetId) {
+    const budget = this.budgets.get(budgetId);
+    if (!budget) {
+      throw new Error(`Budget not found: ${budgetId}`);
+    }
+    const now = /* @__PURE__ */ new Date();
+    const periodStart = this.getPeriodStart(budget.period, now);
+    const records = Array.from(this.records.values()).filter(
+      (r) => r.timestamp >= periodStart && this.matchesBudgetScope(r, budget)
+    );
+    const currentUsage = records.reduce((sum, r) => sum + r.cost.totalCost, 0);
+    return Promise.resolve({
+      budgetId,
+      currentUsage,
+      limit: budget.limit,
+      usagePercentage: currentUsage / budget.limit * 100,
+      remaining: Math.max(0, budget.limit - currentUsage),
+      periodStart,
+      periodEnd: this.getPeriodEnd(budget.period, periodStart),
+      timeRemaining: this.getPeriodEnd(budget.period, periodStart).getTime() - now.getTime(),
+      status: currentUsage >= budget.limit ? "exceeded" : "active",
+      triggeredThresholds: []
+    });
+  }
+  saveBudgetHistory(entry) {
+    const existing = this.budgetHistory.get(entry.budgetId) ?? [];
+    existing.push(entry);
+    this.budgetHistory.set(entry.budgetId, existing);
+    return Promise.resolve();
+  }
+  getBudgetHistory(budgetId, limit) {
+    const history = this.budgetHistory.get(budgetId) ?? [];
+    return Promise.resolve(limit ? history.slice(-limit) : history);
+  }
+  saveBudgetAlert(alert) {
+    const existing = this.budgetAlerts.get(alert.budgetId) ?? [];
+    existing.push(alert);
+    this.budgetAlerts.set(alert.budgetId, existing);
+    return Promise.resolve();
+  }
+  getBudgetAlerts(budgetId) {
+    return Promise.resolve(this.budgetAlerts.get(budgetId) ?? []);
+  }
+  // ==================== Attribution ====================
+  saveAttributedCost(attributed) {
+    this.attributedCosts.push(attributed);
+    return Promise.resolve();
+  }
+  saveAttributedCosts(attributed) {
+    this.attributedCosts.push(...attributed);
+    return Promise.resolve();
+  }
+  getAttributionSummary(dimension, options) {
+    const costs = this.attributedCosts.filter(
+      (c) => c.dimension === dimension && (!options.startDate || c.timestamp >= options.startDate) && (!options.endDate || c.timestamp <= options.endDate)
+    );
+    const groups = /* @__PURE__ */ new Map();
+    let totalCost = 0;
+    for (const cost of costs) {
+      const existing = groups.get(cost.dimensionValue) ?? {
+        cost: 0,
+        tokens: 0,
+        requests: 0
+      };
+      existing.cost += cost.attributedCost;
+      existing.requests++;
+      groups.set(cost.dimensionValue, existing);
+      totalCost += cost.attributedCost;
+    }
+    return Promise.resolve({
+      dimension,
+      breakdown: Array.from(groups.entries()).map(([value, data]) => ({
+        value,
+        cost: data.cost,
+        tokens: data.tokens,
+        requests: data.requests,
+        percentage: totalCost > 0 ? data.cost / totalCost * 100 : 0
+      })),
+      totalCost,
+      periodStart: options.startDate ?? /* @__PURE__ */ new Date(0),
+      periodEnd: options.endDate ?? /* @__PURE__ */ new Date()
+    });
+  }
+  // ==================== Alerts ====================
+  saveAlertRule(rule) {
+    this.alertRules.set(rule.id, rule);
+    return Promise.resolve();
+  }
+  getAlertRule(id) {
+    return Promise.resolve(this.alertRules.get(id) ?? null);
+  }
+  listAlertRules(options) {
+    let rules = Array.from(this.alertRules.values());
+    if (options?.enabled !== void 0) {
+      rules = rules.filter((r) => r.enabled === options.enabled);
+    }
+    return Promise.resolve(rules);
+  }
+  updateAlertRule(id, updates) {
+    const rule = this.alertRules.get(id);
+    if (rule) {
+      this.alertRules.set(id, { ...rule, ...updates });
+    }
+    return Promise.resolve();
+  }
+  deleteAlertRule(id) {
+    return Promise.resolve(this.alertRules.delete(id));
+  }
+  saveAlert(alert) {
+    this.alerts.set(alert.id, alert);
+    return Promise.resolve();
+  }
+  getAlert(id) {
+    return Promise.resolve(this.alerts.get(id) ?? null);
+  }
+  queryAlerts(options) {
+    let alerts = Array.from(this.alerts.values());
+    if (options?.status) {
+      alerts = alerts.filter((a) => options.status.includes(a.status));
+    }
+    if (options?.severity) {
+      alerts = alerts.filter((a) => options.severity.includes(a.severity));
+    }
+    if (options?.startDate) {
+      alerts = alerts.filter((a) => a.triggeredAt >= options.startDate);
+    }
+    if (options?.endDate) {
+      alerts = alerts.filter((a) => a.triggeredAt <= options.endDate);
+    }
+    alerts.sort((a, b) => b.triggeredAt.getTime() - a.triggeredAt.getTime());
+    if (options?.offset) {
+      alerts = alerts.slice(options.offset);
+    }
+    if (options?.limit) {
+      alerts = alerts.slice(0, options.limit);
+    }
+    return Promise.resolve(alerts);
+  }
+  updateAlert(id, updates) {
+    const alert = this.alerts.get(id);
+    if (alert) {
+      this.alerts.set(id, { ...alert, ...updates });
+    }
+    return Promise.resolve();
+  }
+  // ==================== Maintenance ====================
+  cleanup(olderThan) {
+    const toDelete = [];
+    for (const [id, record] of this.records) {
+      if (record.timestamp < olderThan) {
+        toDelete.push(id);
+      }
+    }
+    for (const id of toDelete) {
+      this.records.delete(id);
+    }
+    return Promise.resolve(toDelete.length);
+  }
+  getStats() {
+    const records = Array.from(this.records.values());
+    let oldestRecord;
+    let newestRecord;
+    for (const record of records) {
+      if (!oldestRecord || record.timestamp < oldestRecord) {
+        oldestRecord = record.timestamp;
+      }
+      if (!newestRecord || record.timestamp > newestRecord) {
+        newestRecord = record.timestamp;
+      }
+    }
+    return Promise.resolve({
+      costRecordCount: this.records.size,
+      budgetCount: this.budgets.size,
+      alertRuleCount: this.alertRules.size,
+      alertCount: this.alerts.size,
+      oldestRecord,
+      newestRecord
+    });
+  }
+  async optimize() {
+  }
+  // ==================== Helper Methods ====================
+  enforceLimit() {
+    if (this.config.maxRecords && this.records.size >= this.config.maxRecords) {
+      const sorted = Array.from(this.records.entries()).sort(
+        (a, b) => a[1].timestamp.getTime() - b[1].timestamp.getTime()
+      );
+      const toRemove = sorted.slice(
+        0,
+        Math.floor(this.config.maxRecords * 0.1)
+      );
+      for (const [id] of toRemove) {
+        this.records.delete(id);
+      }
+    }
+  }
+  applyFilters(records, options) {
+    return records.filter((record) => {
+      if (options.startDate && record.timestamp < options.startDate)
+        return false;
+      if (options.endDate && record.timestamp > options.endDate) return false;
+      if (options.providers && !options.providers.includes(record.provider))
+        return false;
+      if (options.models && !options.models.includes(record.model))
+        return false;
+      if (options.userIds && !options.userIds.includes(record.attribution?.userId ?? ""))
+        return false;
+      if (options.agentIds && !options.agentIds.includes(record.attribution?.agentId ?? ""))
+        return false;
+      if (options.sessionIds && !options.sessionIds.includes(record.attribution?.sessionId ?? ""))
+        return false;
+      if (options.projectIds && !options.projectIds.includes(record.attribution?.projectId ?? ""))
+        return false;
+      if (options.teamIds && !options.teamIds.includes(record.attribution?.teamId ?? ""))
+        return false;
+      if (options.features && !options.features.includes(record.attribution?.feature ?? ""))
+        return false;
+      if (options.environment && record.attribution?.environment !== options.environment)
+        return false;
+      if (options.success !== void 0 && record.success !== options.success)
+        return false;
+      return true;
+    });
+  }
+  applySort(records, options) {
+    const sortBy = options.sortBy ?? "timestamp";
+    const sortOrder = options.sortOrder ?? "desc";
+    return records.sort((a, b) => {
+      let comparison = 0;
+      switch (sortBy) {
+        case "cost":
+          comparison = a.cost.totalCost - b.cost.totalCost;
+          break;
+        case "tokens":
+          comparison = a.tokens.totalTokens - b.tokens.totalTokens;
+          break;
+        case "timestamp":
+        default:
+          comparison = a.timestamp.getTime() - b.timestamp.getTime();
+          break;
+      }
+      return sortOrder === "asc" ? comparison : -comparison;
+    });
+  }
+  applyPagination(records, options) {
+    let result = records;
+    if (options.offset) {
+      result = result.slice(options.offset);
+    }
+    if (options.limit) {
+      result = result.slice(0, options.limit);
+    }
+    return result;
+  }
+  getDimensionValue(record, dimension) {
+    switch (dimension) {
+      case "provider":
+        return record.provider;
+      case "model":
+        return record.model;
+      case "user":
+        return record.attribution?.userId;
+      case "agent":
+        return record.attribution?.agentId;
+      case "session":
+        return record.attribution?.sessionId;
+      case "project":
+        return record.attribution?.projectId;
+      case "team":
+        return record.attribution?.teamId;
+      case "feature":
+        return record.attribution?.feature;
+      case "environment":
+        return record.attribution?.environment;
+      default:
+        return record.attribution?.labels?.[dimension];
+    }
+  }
+  getBucketTime(date, granularity) {
+    const d = new Date(date);
+    switch (granularity) {
+      case "minute":
+        d.setSeconds(0, 0);
+        break;
+      case "hour":
+        d.setMinutes(0, 0, 0);
+        break;
+      case "day":
+        d.setHours(0, 0, 0, 0);
+        break;
+      case "week": {
+        const day = d.getDay();
+        d.setDate(d.getDate() - day);
+        d.setHours(0, 0, 0, 0);
+        break;
+      }
+      case "month":
+        d.setDate(1);
+        d.setHours(0, 0, 0, 0);
+        break;
+    }
+    return d.getTime();
+  }
+  matchesBudgetScope(record, budget) {
+    if (budget.scope === "global") return true;
+    switch (budget.scope) {
+      case "user":
+        return record.attribution?.userId === budget.scopeId;
+      case "agent":
+        return record.attribution?.agentId === budget.scopeId;
+      case "project":
+        return record.attribution?.projectId === budget.scopeId;
+      case "team":
+        return record.attribution?.teamId === budget.scopeId;
+      case "feature":
+        return record.attribution?.feature === budget.scopeId;
+      case "model":
+        return record.model === budget.scopeId;
+      case "provider":
+        return record.provider === budget.scopeId;
+      default:
+        return false;
+    }
+  }
+  getPeriodStart(period, now) {
+    const d = new Date(now);
+    switch (period) {
+      case "hourly":
+        d.setMinutes(0, 0, 0);
+        break;
+      case "daily":
+        d.setHours(0, 0, 0, 0);
+        break;
+      case "weekly":
+        d.setDate(d.getDate() - d.getDay());
+        d.setHours(0, 0, 0, 0);
+        break;
+      case "monthly":
+        d.setDate(1);
+        d.setHours(0, 0, 0, 0);
+        break;
+      case "quarterly":
+        d.setMonth(Math.floor(d.getMonth() / 3) * 3, 1);
+        d.setHours(0, 0, 0, 0);
+        break;
+      case "yearly":
+        d.setMonth(0, 1);
+        d.setHours(0, 0, 0, 0);
+        break;
+    }
+    return d;
+  }
+  getPeriodEnd(period, start) {
+    const d = new Date(start);
+    switch (period) {
+      case "hourly":
+        d.setHours(d.getHours() + 1);
+        break;
+      case "daily":
+        d.setDate(d.getDate() + 1);
+        break;
+      case "weekly":
+        d.setDate(d.getDate() + 7);
+        break;
+      case "monthly":
+        d.setMonth(d.getMonth() + 1);
+        break;
+      case "quarterly":
+        d.setMonth(d.getMonth() + 3);
+        break;
+      case "yearly":
+        d.setFullYear(d.getFullYear() + 1);
+        break;
+    }
+    return d;
+  }
+  /**
+   * Clear all data
+   */
+  clear() {
+    this.records.clear();
+    this.budgets.clear();
+    this.budgetHistory.clear();
+    this.budgetAlerts.clear();
+    this.attributedCosts = [];
+    this.alertRules.clear();
+    this.alerts.clear();
+  }
+};
+var CostProvider = class extends EventEmitter {
+  costManager;
+  budgetManager;
+  enforceBudgets;
+  defaultAttribution;
+  initialized = false;
+  constructor(config = {}) {
+    super();
+    this.enforceBudgets = config.enforceBudgets ?? false;
+    this.defaultAttribution = config.defaultAttribution;
+    this.costManager = new CostManager({
+      ...config.costManagerOptions,
+      storage: config.storage,
+      defaultAttribution: config.defaultAttribution
+    });
+    if (this.enforceBudgets) {
+      this.budgetManager = new BudgetManager(
+        config.budgetManagerOptions ?? {},
+        config.storage
+      );
+    }
+    this.setupEventForwarding();
+  }
+  /**
+   * Initialize the provider
+   */
+  async initialize() {
+    if (this.initialized) return;
+    await this.costManager.initialize();
+    if (this.budgetManager) {
+      await this.budgetManager.initialize();
+    }
+    this.initialized = true;
+  }
+  /**
+   * Close the provider
+   */
+  async close() {
+    await this.costManager.close();
+    if (this.budgetManager) {
+      this.budgetManager.close();
+    }
+    this.initialized = false;
+  }
+  /**
+   * Create an agent cost tracker
+   */
+  createAgentTracker(context) {
+    return new AgentCostTracker(
+      this.costManager.scoped({
+        agentId: context.agentId,
+        sessionId: context.sessionId,
+        userId: context.userId,
+        labels: context.labels
+      }),
+      this.budgetManager,
+      this.enforceBudgets
+    );
+  }
+  /**
+   * Track an API call
+   */
+  async track(provider, model, inputTokens, outputTokens, options) {
+    return this.costManager.track({
+      provider,
+      model,
+      tokens: {
+        inputTokens,
+        outputTokens,
+        totalTokens: inputTokens + outputTokens
+      },
+      latencyMs: options?.latencyMs,
+      success: options?.success ?? true,
+      error: options?.error,
+      attribution: options?.attribution,
+      metadata: options?.metadata
+    });
+  }
+  /**
+   * Check budget before making a call
+   */
+  async checkBudget(estimatedCost, attribution) {
+    if (!this.budgetManager) {
+      return {
+        allowed: true,
+        matchingBudgets: [],
+        exceededBudgets: [],
+        warningBudgets: [],
+        action: "allow"
+      };
+    }
+    return this.budgetManager.checkBudget({
+      estimatedCost,
+      attribution: {
+        ...this.defaultAttribution,
+        ...attribution
+      }
+    });
+  }
+  /**
+   * Get cost summary
+   */
+  async getSummary(options) {
+    return this.costManager.getSummary({
+      startDate: options?.startDate,
+      endDate: options?.endDate,
+      agentIds: options?.agentId ? [options.agentId] : void 0,
+      userIds: options?.userId ? [options.userId] : void 0
+    });
+  }
+  /**
+   * Get cost manager
+   */
+  getCostManager() {
+    return this.costManager;
+  }
+  /**
+   * Get budget manager
+   */
+  getBudgetManager() {
+    return this.budgetManager;
+  }
+  /**
+   * Estimate cost for a request
+   */
+  async estimateCost(input, model, options) {
+    const result = await this.costManager.estimateCost(input, {
+      model,
+      provider: options?.provider,
+      estimatedOutputTokens: options?.estimatedOutputTokens
+    });
+    return result.estimatedCost;
+  }
+  /**
+   * Setup event forwarding
+   */
+  setupEventForwarding() {
+    this.costManager.on("cost:recorded", (record) => {
+      this.emit("cost:recorded", record);
+    });
+    this.costManager.on("cost:batch", (batch) => {
+      this.emit("cost:batch", batch);
+    });
+    this.costManager.on("error", (error) => {
+      this.emit("error", error);
+    });
+    if (this.budgetManager) {
+      this.budgetManager.on("budget:warning", (alert) => {
+        this.emit("budget:warning", {
+          budgetId: alert.budgetId,
+          message: alert.message
+        });
+      });
+      this.budgetManager.on("budget:exceeded", (alert) => {
+        this.emit("budget:exceeded", {
+          budgetId: alert.budgetId,
+          message: alert.message
+        });
+      });
+    }
+  }
+};
+var AgentCostTracker = class _AgentCostTracker {
+  tracker;
+  budgetManager;
+  enforceBudgets;
+  constructor(tracker, budgetManager, enforceBudgets = false) {
+    this.tracker = tracker;
+    this.budgetManager = budgetManager;
+    this.enforceBudgets = enforceBudgets;
+  }
+  /**
+   * Track an API call
+   */
+  async track(provider, model, inputTokens, outputTokens, options) {
+    return this.tracker.track({
+      provider,
+      model,
+      tokens: {
+        inputTokens,
+        outputTokens,
+        totalTokens: inputTokens + outputTokens
+      },
+      latencyMs: options?.latencyMs,
+      success: options?.success ?? true,
+      error: options?.error,
+      metadata: options?.metadata
+    });
+  }
+  /**
+   * Track Anthropic response
+   */
+  async trackAnthropicResponse(response, options) {
+    return this.tracker.trackAnthropicResponse(response, options);
+  }
+  /**
+   * Track OpenAI response
+   */
+  async trackOpenAIResponse(response, options) {
+    return this.tracker.trackOpenAIResponse(response, options);
+  }
+  /**
+   * Check budget before making a call
+   */
+  async checkBudget(estimatedCost) {
+    if (!this.budgetManager) {
+      return {
+        allowed: true,
+        matchingBudgets: [],
+        exceededBudgets: [],
+        warningBudgets: [],
+        action: "allow"
+      };
+    }
+    return this.budgetManager.checkBudget({
+      estimatedCost
+    });
+  }
+  /**
+   * Wrap an async function with cost tracking
+   */
+  wrap(fn, options) {
+    return async (...args) => {
+      const startTime = Date.now();
+      try {
+        const result = await fn(...args);
+        const latencyMs = Date.now() - startTime;
+        let inputTokens = 0;
+        let outputTokens = 0;
+        if (options.extractUsage) {
+          const usage = options.extractUsage(result);
+          inputTokens = usage.inputTokens;
+          outputTokens = usage.outputTokens;
+        } else if (result.usage) {
+          inputTokens = result.usage.input_tokens ?? result.usage.prompt_tokens ?? 0;
+          outputTokens = result.usage.output_tokens ?? result.usage.completion_tokens ?? 0;
+        }
+        await this.track(
+          options.provider,
+          result.model,
+          inputTokens,
+          outputTokens,
+          { latencyMs }
+        );
+        return result;
+      } catch (error) {
+        const latencyMs = Date.now() - startTime;
+        await this.tracker.track({
+          provider: options.provider,
+          model: "unknown",
+          tokens: {
+            inputTokens: 0,
+            outputTokens: 0,
+            totalTokens: 0
+          },
+          latencyMs,
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        throw error;
+      }
+    };
+  }
+  /**
+   * Create a nested scope
+   */
+  scoped(attribution) {
+    return new _AgentCostTracker(
+      this.tracker.scoped(attribution),
+      this.budgetManager,
+      this.enforceBudgets
+    );
+  }
+};
+function createCostProvider(config = {}) {
+  return new CostProvider(config);
+}
+
+export { AgentCostTracker, BudgetManager, BufferStorage, CostManager, CostProvider, CostTracker, ModelPricingRegistry, ScopedCostTracker, TokenCounter, countTokens, countTokensApprox, createCostManager, createCostProvider };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map