@lov3kaizen/agentsea-costs 0.5.1

package/dist/index.d.ts

@@ -0,0 +1,1607 @@
+import { EventEmitter } from 'eventemitter3';
+
+type AIProvider = 'anthropic' | 'openai' | 'google' | 'azure' | 'bedrock' | 'cohere' | 'mistral' | 'replicate' | 'custom';
+interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+}
+interface CostBreakdown {
+    inputCost: number;
+    outputCost: number;
+    cacheReadCost?: number;
+    cacheCost?: number;
+    totalCost: number;
+    currency: string;
+}
+interface CostRecord {
+    id: string;
+    timestamp: Date;
+    provider: AIProvider;
+    model: string;
+    tokens: TokenUsage;
+    cost: CostBreakdown;
+    latencyMs?: number;
+    success: boolean;
+    error?: string;
+    attribution?: CostAttribution;
+    metadata?: Record<string, unknown>;
+}
+interface CostAttribution {
+    userId?: string;
+    agentId?: string;
+    sessionId?: string;
+    projectId?: string;
+    teamId?: string;
+    environment?: string;
+    feature?: string;
+    labels?: Record<string, string>;
+}
+interface CostSummary {
+    periodStart: Date;
+    periodEnd: Date;
+    totalCost: number;
+    totalTokens: number;
+    inputTokens: number;
+    outputTokens: number;
+    requestCount: number;
+    successCount: number;
+    errorCount: number;
+    avgCostPerRequest: number;
+    avgTokensPerRequest: number;
+    avgLatencyMs?: number;
+    currency: string;
+}
+interface CostByDimension {
+    dimension: string;
+    value: string;
+    totalCost: number;
+    totalTokens: number;
+    requestCount: number;
+    percentage: number;
+}
+interface CostTrendPoint {
+    timestamp: Date;
+    cost: number;
+    tokens: number;
+    requests: number;
+}
+type TimeGranularity = 'minute' | 'hour' | 'day' | 'week' | 'month';
+interface CostQueryFilter {
+    startDate?: Date;
+    endDate?: Date;
+    providers?: AIProvider[];
+    models?: string[];
+    userIds?: string[];
+    agentIds?: string[];
+    sessionIds?: string[];
+    projectIds?: string[];
+    teamIds?: string[];
+    environment?: string;
+    features?: string[];
+    labels?: Record<string, string>;
+    success?: boolean;
+}
+interface CostQueryOptions extends CostQueryFilter {
+    groupBy?: string;
+    granularity?: TimeGranularity;
+    limit?: number;
+    offset?: number;
+    sortBy?: 'cost' | 'tokens' | 'requests' | 'timestamp';
+    sortOrder?: 'asc' | 'desc';
+}
+interface CostManagerConfig {
+    currency?: string;
+    autoFlushInterval?: number;
+    bufferSize?: number;
+    realTimeTracking?: boolean;
+    defaultAttribution?: Partial<CostAttribution>;
+}
+interface CostEvents {
+    'cost:recorded': CostRecord;
+    'cost:batch': {
+        records: CostRecord[];
+    };
+    'budget:warning': {
+        budgetId: string;
+        usage: number;
+        limit: number;
+    };
+    'budget:exceeded': {
+        budgetId: string;
+        usage: number;
+        limit: number;
+    };
+    'alert:triggered': {
+        alertId: string;
+        type: string;
+        message: string;
+    };
+    error: {
+        message: string;
+        cause?: unknown;
+    };
+}
+
+interface PricingTier {
+    minTokens: number;
+    maxTokens?: number;
+    inputPrice: number;
+    outputPrice: number;
+}
+interface ModelPricing {
+    model: string;
+    provider: AIProvider;
+    displayName?: string;
+    inputPricePerMillion: number;
+    outputPricePerMillion: number;
+    cacheReadPricePerMillion?: number;
+    cacheWritePricePerMillion?: number;
+    tiers?: PricingTier[];
+    contextWindow?: number;
+    maxOutputTokens?: number;
+    effectiveDate?: Date;
+    currency: string;
+    deprecated?: boolean;
+    capabilities?: ModelCapabilities;
+}
+interface ModelCapabilities {
+    vision?: boolean;
+    functionCalling?: boolean;
+    streaming?: boolean;
+    jsonMode?: boolean;
+    systemMessage?: boolean;
+    extendedThinking?: boolean;
+    computerUse?: boolean;
+}
+interface PricingRegistryConfig {
+    autoUpdate?: boolean;
+    updateInterval?: number;
+    remotePricingUrl?: string;
+    customPricing?: ModelPricing[];
+    defaultCurrency?: string;
+}
+interface TokenCountRequest {
+    text: string;
+    model?: string;
+    provider?: AIProvider;
+}
+interface TokenCountResult {
+    tokens: number;
+    model: string;
+    estimatedInputCost?: number;
+    characters: number;
+    words: number;
+}
+interface CostEstimateRequest {
+    input: string | number;
+    estimatedOutputTokens?: number;
+    model: string;
+    provider?: AIProvider;
+    includeCache?: boolean;
+}
+interface CostEstimateResult {
+    estimatedCost: number;
+    inputTokens: number;
+    outputTokens: number;
+    breakdown: {
+        inputCost: number;
+        outputCost: number;
+        cacheCost?: number;
+    };
+    model: string;
+    provider: AIProvider;
+    currency: string;
+    confidence: number;
+}
+interface ProviderPricingSummary {
+    provider: AIProvider;
+    modelCount: number;
+    minInputPrice: number;
+    maxInputPrice: number;
+    minOutputPrice: number;
+    maxOutputPrice: number;
+    models: string[];
+}
+interface PricingComparison {
+    modelA: string;
+    modelB: string;
+    inputPriceDiff: number;
+    outputPriceDiff: number;
+    percentageDiff: number;
+    cheaperModel: string;
+    estimatedSavings?: number;
+}
+
+type BudgetPeriod = 'hourly' | 'daily' | 'weekly' | 'monthly' | 'quarterly' | 'yearly' | 'custom';
+type BudgetScope = 'global' | 'user' | 'agent' | 'project' | 'team' | 'feature' | 'model' | 'provider';
+type BudgetAction = 'warn' | 'throttle' | 'block' | 'notify';
+type BudgetStatus = 'active' | 'paused' | 'exceeded' | 'expired';
+interface BudgetConfig {
+    id: string;
+    name: string;
+    description?: string;
+    limit: number;
+    currency: string;
+    period: BudgetPeriod;
+    scope: BudgetScope;
+    scopeId?: string;
+    warningThresholds?: number[];
+    actions?: BudgetThresholdAction[];
+    resetSchedule?: string;
+    rollover?: boolean;
+    maxRollover?: number;
+    filters?: BudgetFilter;
+    enabled: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface BudgetThresholdAction {
+    threshold: number;
+    action: BudgetAction;
+    notifyEmails?: string[];
+    webhookUrl?: string;
+    message?: string;
+}
+interface BudgetFilter {
+    providers?: AIProvider[];
+    models?: string[];
+    userIds?: string[];
+    agentIds?: string[];
+    projectIds?: string[];
+    features?: string[];
+    environment?: string;
+}
+interface BudgetUsage {
+    budgetId: string;
+    currentUsage: number;
+    limit: number;
+    usagePercentage: number;
+    remaining: number;
+    periodStart: Date;
+    periodEnd: Date;
+    timeRemaining: number;
+    projectedUsage?: number;
+    projectedExceed?: boolean;
+    status: BudgetStatus;
+    triggeredThresholds: number[];
+    rolloverIn?: number;
+}
+interface BudgetCheckRequest {
+    estimatedCost: number;
+    attribution?: CostAttribution;
+    budgetIds?: string[];
+}
+interface BudgetCheckResult {
+    allowed: boolean;
+    reason?: string;
+    matchingBudgets: BudgetUsage[];
+    exceededBudgets: string[];
+    warningBudgets: string[];
+    action: BudgetAction | 'allow';
+}
+interface BudgetHistoryEntry {
+    budgetId: string;
+    periodStart: Date;
+    periodEnd: Date;
+    usage: number;
+    limit: number;
+    usagePercentage: number;
+    exceeded: boolean;
+    rolloverIn?: number;
+    rolloverOut?: number;
+}
+interface BudgetAlert {
+    id: string;
+    budgetId: string;
+    budgetName: string;
+    type: 'warning' | 'exceeded' | 'reset';
+    threshold?: number;
+    usage: number;
+    limit: number;
+    percentage: number;
+    message: string;
+    timestamp: Date;
+    acknowledged: boolean;
+    acknowledgedBy?: string;
+    acknowledgedAt?: Date;
+}
+interface BudgetManagerConfig {
+    enforceOnRequest?: boolean;
+    defaultAction?: BudgetAction | 'allow';
+    checkInterval?: number;
+    enableProjections?: boolean;
+    alertWebhookUrl?: string;
+    alertEmails?: string[];
+}
+interface CreateBudgetRequest {
+    name: string;
+    description?: string;
+    limit: number;
+    currency?: string;
+    period: BudgetPeriod;
+    scope: BudgetScope;
+    scopeId?: string;
+    warningThresholds?: number[];
+    actions?: BudgetThresholdAction[];
+    filters?: BudgetFilter;
+    rollover?: boolean;
+    maxRollover?: number;
+}
+interface UpdateBudgetRequest {
+    name?: string;
+    description?: string;
+    limit?: number;
+    warningThresholds?: number[];
+    actions?: BudgetThresholdAction[];
+    enabled?: boolean;
+    filters?: BudgetFilter;
+}
+
+type AttributionDimension = 'user' | 'agent' | 'session' | 'project' | 'team' | 'feature' | 'model' | 'provider' | 'environment' | 'label';
+type AttributionRuleType = 'direct' | 'proportional' | 'fixed' | 'percentage' | 'custom';
+interface AttributionRule {
+    id: string;
+    name: string;
+    description?: string;
+    type: AttributionRuleType;
+    priority: number;
+    conditions: AttributionCondition[];
+    targets: AttributionTarget[];
+    enabled: boolean;
+    createdAt: Date;
+}
+interface AttributionCondition {
+    dimension: AttributionDimension;
+    operator: 'equals' | 'contains' | 'startsWith' | 'endsWith' | 'regex' | 'in';
+    value: string | string[];
+}
+interface AttributionTarget {
+    dimension: AttributionDimension;
+    value: string;
+    percentage?: number;
+    fixedAmount?: number;
+}
+interface AttributedCost {
+    costRecordId: string;
+    dimension: AttributionDimension;
+    dimensionValue: string;
+    attributedCost: number;
+    attributionPercentage: number;
+    ruleId?: string;
+    timestamp: Date;
+}
+interface AttributionSummary {
+    dimension: AttributionDimension;
+    breakdown: AttributionBreakdown[];
+    totalCost: number;
+    periodStart: Date;
+    periodEnd: Date;
+}
+interface AttributionBreakdown {
+    value: string;
+    displayName?: string;
+    cost: number;
+    tokens: number;
+    requests: number;
+    percentage: number;
+    trend?: 'up' | 'down' | 'stable';
+    change?: number;
+    changePercentage?: number;
+}
+interface AttributionQueryOptions {
+    dimension: AttributionDimension;
+    startDate?: Date;
+    endDate?: Date;
+    values?: string[];
+    groupBy?: AttributionDimension;
+    granularity?: TimeGranularity;
+    limit?: number;
+    includeSubDimensions?: boolean;
+}
+interface AttributionTrend {
+    dimension: AttributionDimension;
+    value: string;
+    dataPoints: AttributionTrendPoint[];
+    trend: 'up' | 'down' | 'stable';
+    avgCost: number;
+    totalCost: number;
+}
+interface AttributionTrendPoint {
+    timestamp: Date;
+    cost: number;
+    tokens: number;
+    requests: number;
+}
+interface CostAllocationPolicy {
+    id: string;
+    name: string;
+    description?: string;
+    sourceDimension: AttributionDimension;
+    targetDimension: AttributionDimension;
+    method: 'equal' | 'proportional' | 'usage-based' | 'custom';
+    weights?: Record<string, number>;
+    active: boolean;
+}
+interface AttributionReport {
+    id: string;
+    name: string;
+    period: {
+        start: Date;
+        end: Date;
+    };
+    dimensions: AttributionDimension[];
+    summary: {
+        totalCost: number;
+        totalTokens: number;
+        totalRequests: number;
+        uniqueUsers?: number;
+        uniqueAgents?: number;
+        uniqueProjects?: number;
+    };
+    breakdowns: Record<AttributionDimension, AttributionBreakdown[]>;
+    topConsumers: {
+        dimension: AttributionDimension;
+        value: string;
+        cost: number;
+        percentage: number;
+    }[];
+    generatedAt: Date;
+}
+interface AttributionEngineConfig {
+    defaultRules?: AttributionRule[];
+    autoAttribute?: boolean;
+    defaultPolicy?: CostAllocationPolicy;
+    cacheResults?: boolean;
+    cacheTtl?: number;
+}
+interface ChargebackRecord {
+    id: string;
+    billingPeriod: {
+        start: Date;
+        end: Date;
+    };
+    costCenter: string;
+    totalCharge: number;
+    currency: string;
+    lineItems: ChargebackLineItem[];
+    status: 'pending' | 'approved' | 'rejected' | 'invoiced';
+    generatedAt: Date;
+    approvedBy?: string;
+    approvedAt?: Date;
+}
+interface ChargebackLineItem {
+    description: string;
+    dimension: AttributionDimension;
+    dimensionValue: string;
+    quantity: number;
+    unit: string;
+    unitCost: number;
+    totalCost: number;
+    costRecordIds: string[];
+}
+
+type TimeRangePreset = 'today' | 'yesterday' | 'last7days' | 'last30days' | 'thisMonth' | 'lastMonth' | 'thisQuarter' | 'lastQuarter' | 'thisYear' | 'lastYear' | 'custom';
+interface AnalyticsQuery {
+    preset?: TimeRangePreset;
+    startDate?: Date;
+    endDate?: Date;
+    granularity?: TimeGranularity;
+    groupBy?: AttributionDimension[];
+    filters?: AnalyticsFilter;
+    metrics?: AnalyticsMetric[];
+    comparePrevious?: boolean;
+}
+interface AnalyticsFilter {
+    providers?: AIProvider[];
+    models?: string[];
+    userIds?: string[];
+    agentIds?: string[];
+    projectIds?: string[];
+    teamIds?: string[];
+    features?: string[];
+    environment?: string;
+    labels?: Record<string, string>;
+}
+type AnalyticsMetric = 'totalCost' | 'inputCost' | 'outputCost' | 'totalTokens' | 'inputTokens' | 'outputTokens' | 'requestCount' | 'errorRate' | 'avgCostPerRequest' | 'avgTokensPerRequest' | 'avgLatency' | 'p50Latency' | 'p95Latency' | 'p99Latency';
+interface AnalyticsResult {
+    query: AnalyticsQuery;
+    timeRange: {
+        start: Date;
+        end: Date;
+    };
+    summary: AnalyticsSummary;
+    timeSeries?: AnalyticsTimeSeries[];
+    breakdowns?: Record<AttributionDimension, CostByDimension[]>;
+    comparison?: AnalyticsComparison;
+}
+interface AnalyticsSummary {
+    totalCost: number;
+    inputCost: number;
+    outputCost: number;
+    totalTokens: number;
+    inputTokens: number;
+    outputTokens: number;
+    requestCount: number;
+    successCount: number;
+    errorCount: number;
+    errorRate: number;
+    avgCostPerRequest: number;
+    avgTokensPerRequest: number;
+    avgLatency?: number;
+    p50Latency?: number;
+    p95Latency?: number;
+    p99Latency?: number;
+    currency: string;
+}
+interface AnalyticsTimeSeries {
+    timestamp: Date;
+    metrics: Partial<AnalyticsSummary>;
+}
+interface AnalyticsComparison {
+    previousPeriod: {
+        start: Date;
+        end: Date;
+    };
+    previous: AnalyticsSummary;
+    changes: {
+        totalCost: ChangeMetric;
+        totalTokens: ChangeMetric;
+        requestCount: ChangeMetric;
+        avgCostPerRequest: ChangeMetric;
+        errorRate: ChangeMetric;
+    };
+}
+interface ChangeMetric {
+    absolute: number;
+    percentage: number;
+    trend: 'up' | 'down' | 'stable';
+}
+interface ForecastConfig {
+    horizon: number;
+    granularity: TimeGranularity;
+    includeConfidenceInterval?: boolean;
+    confidenceLevel?: number;
+    method?: ForecastMethod;
+    detectSeasonality?: boolean;
+}
+type ForecastMethod = 'linear' | 'exponential' | 'moving-average' | 'holt-winters' | 'auto';
+interface ForecastResult {
+    metric: AnalyticsMetric;
+    method: ForecastMethod;
+    historical: ForecastDataPoint[];
+    forecast: ForecastDataPoint[];
+    seasonality?: SeasonalityInfo;
+    accuracy?: ForecastAccuracy;
+    generatedAt: Date;
+}
+interface ForecastDataPoint {
+    timestamp: Date;
+    value: number;
+    lowerBound?: number;
+    upperBound?: number;
+    isForecast: boolean;
+}
+interface SeasonalityInfo {
+    period: number;
+    unit: TimeGranularity;
+    strength: number;
+    pattern?: string;
+}
+interface ForecastAccuracy {
+    mae: number;
+    mape: number;
+    rmse: number;
+    r2: number;
+}
+interface AnomalyDetectionConfig {
+    sensitivity?: number;
+    minDataPoints?: number;
+    method?: 'zscore' | 'iqr' | 'isolation-forest' | 'auto';
+    metrics?: AnalyticsMetric[];
+}
+interface Anomaly {
+    id: string;
+    metric: AnalyticsMetric;
+    timestamp: Date;
+    actualValue: number;
+    expectedValue: number;
+    deviation: number;
+    zScore: number;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    description: string;
+    dimensions?: Record<AttributionDimension, string>;
+    detectedAt: Date;
+    acknowledged: boolean;
+}
+interface DashboardWidget {
+    id: string;
+    type: 'metric' | 'chart' | 'table' | 'trend' | 'breakdown' | 'forecast';
+    title: string;
+    config: Record<string, unknown>;
+    position: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+}
+interface DashboardConfig {
+    id: string;
+    name: string;
+    description?: string;
+    widgets: DashboardWidget[];
+    defaultTimeRange: TimeRangePreset;
+    refreshInterval?: number;
+    owner?: string;
+    sharedWith?: string[];
+}
+
+type AlertType = 'budget' | 'threshold' | 'anomaly' | 'spike' | 'trend' | 'forecast' | 'error-rate' | 'custom';
+type AlertSeverity = 'info' | 'warning' | 'error' | 'critical';
+type AlertStatus = 'active' | 'acknowledged' | 'resolved' | 'snoozed';
+type NotificationChannel = 'email' | 'slack' | 'webhook' | 'pagerduty' | 'teams' | 'discord';
+interface AlertRule {
+    id: string;
+    name: string;
+    description?: string;
+    type: AlertType;
+    severity: AlertSeverity;
+    condition: AlertCondition;
+    channels: NotificationConfig[];
+    cooldown?: number;
+    enabled: boolean;
+    tags?: string[];
+    createdAt: Date;
+    updatedAt: Date;
+    createdBy?: string;
+}
+interface AlertCondition {
+    metric: AnalyticsMetric;
+    operator: 'gt' | 'gte' | 'lt' | 'lte' | 'eq' | 'ne' | 'change_gt' | 'change_lt';
+    threshold: number;
+    window?: {
+        duration: number;
+        unit: 'minutes' | 'hours' | 'days';
+    };
+    aggregation?: 'sum' | 'avg' | 'min' | 'max' | 'count';
+    filters?: AlertFilter;
+    comparisonPeriod?: 'previous_period' | 'same_period_last_week' | 'same_period_last_month';
+}
+interface AlertFilter {
+    providers?: AIProvider[];
+    models?: string[];
+    dimensions?: Record<AttributionDimension, string[]>;
+    environment?: string;
+}
+interface NotificationConfig {
+    channel: NotificationChannel;
+    config: NotificationChannelConfig;
+    includeDetails?: boolean;
+    messageTemplate?: string;
+}
+type NotificationChannelConfig = EmailNotificationConfig | SlackNotificationConfig | WebhookNotificationConfig | PagerDutyNotificationConfig | TeamsNotificationConfig | DiscordNotificationConfig;
+interface EmailNotificationConfig {
+    type: 'email';
+    recipients: string[];
+    cc?: string[];
+    subjectTemplate?: string;
+}
+interface SlackNotificationConfig {
+    type: 'slack';
+    webhookUrl: string;
+    channel?: string;
+    username?: string;
+    iconEmoji?: string;
+    mentionUsers?: string[];
+}
+interface WebhookNotificationConfig {
+    type: 'webhook';
+    url: string;
+    method?: 'POST' | 'PUT';
+    headers?: Record<string, string>;
+    includePayload?: boolean;
+}
+interface PagerDutyNotificationConfig {
+    type: 'pagerduty';
+    integrationKey: string;
+    serviceId?: string;
+    escalationPolicy?: string;
+}
+interface TeamsNotificationConfig {
+    type: 'teams';
+    webhookUrl: string;
+}
+interface DiscordNotificationConfig {
+    type: 'discord';
+    webhookUrl: string;
+    username?: string;
+    avatarUrl?: string;
+}
+interface Alert {
+    id: string;
+    ruleId: string;
+    ruleName: string;
+    type: AlertType;
+    severity: AlertSeverity;
+    status: AlertStatus;
+    triggeredAt: Date;
+    resolvedAt?: Date;
+    acknowledgedAt?: Date;
+    acknowledgedBy?: string;
+    snoozedUntil?: Date;
+    message: string;
+    details: AlertDetails;
+    notifications: NotificationRecord[];
+}
+interface AlertDetails {
+    metric: AnalyticsMetric;
+    currentValue: number;
+    threshold: number;
+    window?: {
+        start: Date;
+        end: Date;
+    };
+    dimensions?: Record<AttributionDimension, string>;
+    trend?: {
+        previous: number;
+        change: number;
+        changePercent: number;
+    };
+    context?: Record<string, unknown>;
+}
+interface NotificationRecord {
+    channel: NotificationChannel;
+    sentAt: Date;
+    success: boolean;
+    error?: string;
+    response?: string;
+}
+interface AlertSummary {
+    total: number;
+    byStatus: Record<AlertStatus, number>;
+    bySeverity: Record<AlertSeverity, number>;
+    byType: Record<AlertType, number>;
+    activeCritical: number;
+    meanTimeToAcknowledge?: number;
+    meanTimeToResolve?: number;
+}
+interface AlertManagerConfig {
+    enabled?: boolean;
+    defaultCooldown?: number;
+    globalChannels?: NotificationConfig[];
+    maxAlertsPerHour?: number;
+    autoResolveAfter?: number;
+    retentionDays?: number;
+}
+interface CreateAlertRuleRequest {
+    name: string;
+    description?: string;
+    type: AlertType;
+    severity: AlertSeverity;
+    condition: AlertCondition;
+    channels: NotificationConfig[];
+    cooldown?: number;
+    tags?: string[];
+}
+interface AlertQueryOptions {
+    status?: AlertStatus[];
+    severity?: AlertSeverity[];
+    type?: AlertType[];
+    ruleIds?: string[];
+    startDate?: Date;
+    endDate?: Date;
+    limit?: number;
+    offset?: number;
+    sortBy?: 'triggeredAt' | 'severity' | 'status';
+    sortOrder?: 'asc' | 'desc';
+}
+
+interface CostStorageAdapter {
+    initialize(): Promise<void>;
+    close(): Promise<void>;
+    saveCostRecord(record: CostRecord): Promise<void>;
+    saveCostRecords(records: CostRecord[]): Promise<void>;
+    getCostRecord(id: string): Promise<CostRecord | null>;
+    queryCostRecords(options: CostQueryOptions): Promise<CostRecord[]>;
+    getCostSummary(options: CostQueryOptions): Promise<CostSummary>;
+    getCostsByDimension(dimension: string, options: CostQueryOptions): Promise<CostByDimension[]>;
+    getCostTrends(options: CostQueryOptions): Promise<CostTrendPoint[]>;
+    deleteCostRecords(ids: string[]): Promise<number>;
+    deleteCostRecordsByFilter(options: CostQueryOptions): Promise<number>;
+    saveBudget(budget: BudgetConfig): Promise<void>;
+    getBudget(id: string): Promise<BudgetConfig | null>;
+    listBudgets(options?: {
+        scope?: string;
+        scopeId?: string;
+        enabled?: boolean;
+    }): Promise<BudgetConfig[]>;
+    updateBudget(id: string, updates: Partial<BudgetConfig>): Promise<void>;
+    deleteBudget(id: string): Promise<boolean>;
+    getBudgetUsage(budgetId: string): Promise<BudgetUsage>;
+    saveBudgetHistory(entry: BudgetHistoryEntry): Promise<void>;
+    getBudgetHistory(budgetId: string, limit?: number): Promise<BudgetHistoryEntry[]>;
+    saveBudgetAlert(alert: BudgetAlert): Promise<void>;
+    getBudgetAlerts(budgetId: string): Promise<BudgetAlert[]>;
+    saveAttributedCost(attributed: AttributedCost): Promise<void>;
+    saveAttributedCosts(attributed: AttributedCost[]): Promise<void>;
+    getAttributionSummary(dimension: string, options: CostQueryOptions): Promise<AttributionSummary>;
+    saveAlertRule(rule: AlertRule): Promise<void>;
+    getAlertRule(id: string): Promise<AlertRule | null>;
+    listAlertRules(options?: {
+        enabled?: boolean;
+    }): Promise<AlertRule[]>;
+    updateAlertRule(id: string, updates: Partial<AlertRule>): Promise<void>;
+    deleteAlertRule(id: string): Promise<boolean>;
+    saveAlert(alert: Alert): Promise<void>;
+    getAlert(id: string): Promise<Alert | null>;
+    queryAlerts(options?: {
+        status?: string[];
+        severity?: string[];
+        startDate?: Date;
+        endDate?: Date;
+        limit?: number;
+        offset?: number;
+    }): Promise<Alert[]>;
+    updateAlert(id: string, updates: Partial<Alert>): Promise<void>;
+    cleanup(olderThan: Date): Promise<number>;
+    getStats(): Promise<StorageStats>;
+    optimize(): Promise<void>;
+}
+interface StorageStats {
+    costRecordCount: number;
+    budgetCount: number;
+    alertRuleCount: number;
+    alertCount: number;
+    storageSizeBytes?: number;
+    oldestRecord?: Date;
+    newestRecord?: Date;
+    indexes?: IndexInfo[];
+}
+interface IndexInfo {
+    name: string;
+    table: string;
+    columns: string[];
+    sizeBytes?: number;
+}
+interface SQLiteStorageConfig {
+    path: string;
+    walMode?: boolean;
+    busyTimeout?: number;
+    foreignKeys?: boolean;
+    synchronous?: 'off' | 'normal' | 'full' | 'extra';
+    cacheSize?: number;
+    autoVacuum?: 'none' | 'full' | 'incremental';
+}
+interface PostgresStorageConfig {
+    connection: string | PostgresConnectionConfig;
+    schema?: string;
+    poolSize?: number;
+    connectionTimeout?: number;
+    idleTimeout?: number;
+    ssl?: boolean | PostgresSSLConfig;
+}
+interface PostgresConnectionConfig {
+    host: string;
+    port?: number;
+    database: string;
+    user: string;
+    password: string;
+}
+interface PostgresSSLConfig {
+    rejectUnauthorized?: boolean;
+    ca?: string;
+    cert?: string;
+    key?: string;
+}
+interface BufferStorageConfig {
+    maxRecords?: number;
+    autoFlushInterval?: number;
+    onFlush?: (records: CostRecord[]) => Promise<void>;
+}
+interface StorageMigration {
+    version: number;
+    name: string;
+    up: (adapter: CostStorageAdapter) => Promise<void>;
+    down: (adapter: CostStorageAdapter) => Promise<void>;
+}
+type StorageFactoryOptions = {
+    type: 'sqlite';
+    config: SQLiteStorageConfig;
+} | {
+    type: 'postgres';
+    config: PostgresStorageConfig;
+} | {
+    type: 'buffer';
+    config?: BufferStorageConfig;
+} | {
+    type: 'custom';
+    adapter: CostStorageAdapter;
+};
+
+type OptimizationCategory = 'model-selection' | 'prompt-optimization' | 'caching' | 'batching' | 'rate-limiting' | 'usage-pattern' | 'provider-switch' | 'feature-optimization';
+type ImpactLevel = 'low' | 'medium' | 'high' | 'critical';
+type EffortLevel = 'trivial' | 'easy' | 'medium' | 'hard';
+type OptimizationStatus = 'identified' | 'in_progress' | 'implemented' | 'dismissed' | 'verified';
+interface OptimizationRecommendation {
+    id: string;
+    title: string;
+    description: string;
+    category: OptimizationCategory;
+    impact: ImpactLevel;
+    effort: EffortLevel;
+    estimatedSavings: number;
+    confidence: number;
+    priorityScore: number;
+    affectedDimension?: AttributionDimension;
+    affectedValue?: string;
+    currentState: OptimizationCurrentState;
+    recommendedAction: OptimizationAction;
+    implementationSteps?: string[];
+    risks?: string[];
+    status: OptimizationStatus;
+    createdAt: Date;
+    updatedAt: Date;
+    implementedAt?: Date;
+    verifiedSavings?: number;
+}
+interface OptimizationCurrentState {
+    currentCost: number;
+    currentUsage: {
+        requests: number;
+        tokens: number;
+        avgTokensPerRequest: number;
+    };
+    period: {
+        start: Date;
+        end: Date;
+    };
+    context?: Record<string, unknown>;
+}
+interface OptimizationAction {
+    type: OptimizationActionType;
+    targetModel?: string;
+    targetProvider?: AIProvider;
+    parameters?: Record<string, unknown>;
+    expectedCost: number;
+    expectedSavingsPercent: number;
+}
+type OptimizationActionType = 'switch-model' | 'switch-provider' | 'enable-caching' | 'implement-batching' | 'optimize-prompts' | 'reduce-output-tokens' | 'implement-rate-limiting' | 'remove-redundant-calls' | 'consolidate-requests' | 'adjust-parameters' | 'custom';
+interface ModelSwitchRecommendation extends OptimizationRecommendation {
+    category: 'model-selection';
+    currentModel: string;
+    currentProvider: AIProvider;
+    recommendedModel: string;
+    recommendedProvider: AIProvider;
+    qualityComparison: {
+        qualityDelta: number;
+        metrics?: {
+            name: string;
+            current: number;
+            expected: number;
+        }[];
+    };
+    latencyComparison?: {
+        currentAvgMs: number;
+        expectedAvgMs: number;
+        delta: number;
+    };
+}
+interface CachingRecommendation extends OptimizationRecommendation {
+    category: 'caching';
+    potentialHitRate: number;
+    cacheablePercent: number;
+    patterns: CacheablePattern[];
+    recommendedTtl?: number;
+}
+interface CacheablePattern {
+    pattern: string;
+    count: number;
+    repetitionCost: number;
+    sample?: string;
+}
+interface PromptOptimizationRecommendation extends OptimizationRecommendation {
+    category: 'prompt-optimization';
+    currentAvgInputTokens: number;
+    targetAvgInputTokens: number;
+    techniques: PromptOptimizationTechnique[];
+}
+interface PromptOptimizationTechnique {
+    name: string;
+    description: string;
+    potentialReduction: number;
+    before?: string;
+    after?: string;
+}
+interface OptimizationAnalyzerConfig {
+    minSavingsThreshold?: number;
+    analysisPeriod?: number;
+    categories?: OptimizationCategory[];
+    minConfidence?: number;
+    includeLowImpact?: boolean;
+    modelQualityMappings?: Record<string, number>;
+}
+interface OptimizationAnalysisResult {
+    analyzedAt: Date;
+    period: {
+        start: Date;
+        end: Date;
+    };
+    totalCurrentCost: number;
+    totalPotentialSavings: number;
+    savingsPercentage: number;
+    recommendations: OptimizationRecommendation[];
+    byCategory: {
+        category: OptimizationCategory;
+        count: number;
+        totalSavings: number;
+    }[];
+    topOpportunities: OptimizationRecommendation[];
+    quickWins: OptimizationRecommendation[];
+}
+interface OptimizationTracking {
+    recommendationId: string;
+    statusHistory: {
+        status: OptimizationStatus;
+        timestamp: Date;
+        by?: string;
+        notes?: string;
+    }[];
+    costBefore?: number;
+    costAfter?: number;
+    actualSavings?: number;
+    verificationPeriod?: {
+        start: Date;
+        end: Date;
+    };
+}
+interface OptimizationABTest {
+    id: string;
+    recommendationId: string;
+    control: {
+        model: string;
+        provider: AIProvider;
+        parameters?: Record<string, unknown>;
+    };
+    treatment: {
+        model: string;
+        provider: AIProvider;
+        parameters?: Record<string, unknown>;
+    };
+    trafficSplit: number;
+    metrics: string[];
+    status: 'draft' | 'running' | 'paused' | 'completed';
+    startDate?: Date;
+    endDate?: Date;
+    results?: OptimizationABTestResults;
+}
+interface OptimizationABTestResults {
+    sampleSizes: {
+        control: number;
+        treatment: number;
+    };
+    cost: {
+        control: number;
+        treatment: number;
+        savings: number;
+        savingsPercent: number;
+        pValue?: number;
+        isSignificant: boolean;
+    };
+    quality?: {
+        metric: string;
+        control: number;
+        treatment: number;
+        pValue?: number;
+        isSignificant: boolean;
+    }[];
+    latency?: {
+        controlAvgMs: number;
+        treatmentAvgMs: number;
+        pValue?: number;
+        isSignificant: boolean;
+    };
+    recommendation: 'adopt' | 'reject' | 'extend-test' | 'inconclusive';
+}
+
+declare class ModelPricingRegistry {
+    private pricing;
+    private config;
+    private updateTimer?;
+    constructor(config?: PricingRegistryConfig);
+    private loadDefaultPricing;
+    private getKey;
+    registerModel(pricing: ModelPricing): void;
+    getPricing(provider: AIProvider, model: string): ModelPricing | null;
+    getPricingByModel(model: string): ModelPricing | null;
+    calculateCost(provider: AIProvider, model: string, inputTokens: number, outputTokens: number, options?: {
+        cacheReadTokens?: number;
+        cacheWriteTokens?: number;
+    }): {
+        inputCost: number;
+        outputCost: number;
+        cacheReadCost: number;
+        cacheCost: number;
+        totalCost: number;
+        currency: string;
+    };
+    listModels(provider?: AIProvider): ModelPricing[];
+    listProviders(): AIProvider[];
+    getProviderSummary(provider: AIProvider): ProviderPricingSummary | null;
+    comparePricing(modelA: string, modelB: string, sampleTokens?: {
+        input: number;
+        output: number;
+    }): PricingComparison | null;
+    findCheapestModel(options?: {
+        provider?: AIProvider;
+        minContextWindow?: number;
+        requireVision?: boolean;
+        requireFunctionCalling?: boolean;
+        weightInput?: number;
+        weightOutput?: number;
+    }): ModelPricing | null;
+    private startAutoUpdate;
+    stopAutoUpdate(): void;
+    updateFromRemote(): Promise<void>;
+    exportPricing(): ModelPricing[];
+    importPricing(data: ModelPricing[], replace?: boolean): void;
+    clear(): void;
+    reset(): void;
+}
+
+declare class TokenCounter {
+    private pricingRegistry;
+    private cache;
+    private maxCacheSize;
+    constructor(pricingRegistry: ModelPricingRegistry, options?: {
+        maxCacheSize?: number;
+    });
+    countTokens(request: TokenCountRequest): Promise<TokenCountResult>;
+    private countWithTiktoken;
+    private countApproximate;
+    private buildResult;
+    private detectProvider;
+    estimateCost(request: CostEstimateRequest): Promise<CostEstimateResult>;
+    countTokensBatch(texts: string[], options?: {
+        model?: string;
+        provider?: AIProvider;
+    }): Promise<TokenCountResult[]>;
+    countMessagesTokens(messages: Array<{
+        role: string;
+        content: string;
+    }>, options?: {
+        model?: string;
+        provider?: AIProvider;
+    }): Promise<{
+        totalTokens: number;
+        perMessage: Array<{
+            role: string;
+            tokens: number;
+        }>;
+        overhead: number;
+    }>;
+    private setCached;
+    clearCache(): void;
+    getCacheStats(): {
+        size: number;
+        maxSize: number;
+        hitRate: number;
+    };
+}
+declare function countTokens(text: string, options?: {
+    model?: string;
+    provider?: AIProvider;
+}): Promise<number>;
+declare function countTokensApprox(text: string, charsPerToken?: number): number;
+
+interface CostTrackerConfig {
+    pricingRegistry: ModelPricingRegistry;
+    storage?: CostStorageAdapter;
+    defaultAttribution?: Partial<CostAttribution>;
+    autoFlushInterval?: number;
+    bufferSize?: number;
+    realTimeEvents?: boolean;
+}
+interface TrackOptions {
+    provider: AIProvider;
+    model: string;
+    tokens: TokenUsage;
+    latencyMs?: number;
+    success?: boolean;
+    error?: string;
+    attribution?: CostAttribution;
+    metadata?: Record<string, unknown>;
+    timestamp?: Date;
+}
+declare class CostTracker extends EventEmitter<CostEvents> {
+    private pricingRegistry;
+    private storage?;
+    private defaultAttribution?;
+    private buffer;
+    private bufferSize;
+    private autoFlushTimer?;
+    private realTimeEvents;
+    constructor(config: CostTrackerConfig);
+    track(options: TrackOptions): Promise<CostRecord>;
+    trackAnthropicResponse(response: {
+        model: string;
+        usage?: {
+            input_tokens: number;
+            output_tokens: number;
+            cache_read_input_tokens?: number;
+            cache_creation_input_tokens?: number;
+        };
+    }, options?: {
+        latencyMs?: number;
+        attribution?: CostAttribution;
+        metadata?: Record<string, unknown>;
+    }): Promise<CostRecord>;
+    trackOpenAIResponse(response: {
+        model: string;
+        usage?: {
+            prompt_tokens: number;
+            completion_tokens: number;
+            total_tokens: number;
+        };
+    }, options?: {
+        latencyMs?: number;
+        attribution?: CostAttribution;
+        metadata?: Record<string, unknown>;
+    }): Promise<CostRecord>;
+    trackError(options: {
+        provider: AIProvider;
+        model: string;
+        error: string;
+        estimatedInputTokens?: number;
+        latencyMs?: number;
+        attribution?: CostAttribution;
+        metadata?: Record<string, unknown>;
+    }): Promise<CostRecord>;
+    private calculateCost;
+    private mergeAttribution;
+    flush(): Promise<number>;
+    getBuffer(): CostRecord[];
+    getBufferSize(): number;
+    clearBuffer(): void;
+    setDefaultAttribution(attribution: Partial<CostAttribution>): void;
+    scoped(attribution: Partial<CostAttribution>): ScopedCostTracker;
+    close(): Promise<void>;
+}
+declare class ScopedCostTracker {
+    private parent;
+    private scopeAttribution;
+    constructor(parent: CostTracker, attribution: Partial<CostAttribution>);
+    track(options: Omit<TrackOptions, 'attribution'> & {
+        attribution?: Partial<CostAttribution>;
+    }): Promise<CostRecord>;
+    trackAnthropicResponse(response: Parameters<CostTracker['trackAnthropicResponse']>[0], options?: Omit<NonNullable<Parameters<CostTracker['trackAnthropicResponse']>[1]>, 'attribution'> & {
+        attribution?: Partial<CostAttribution>;
+    }): Promise<CostRecord>;
+    trackOpenAIResponse(response: Parameters<CostTracker['trackOpenAIResponse']>[0], options?: Omit<NonNullable<Parameters<CostTracker['trackOpenAIResponse']>[1]>, 'attribution'> & {
+        attribution?: Partial<CostAttribution>;
+    }): Promise<CostRecord>;
+    scoped(attribution: Partial<CostAttribution>): ScopedCostTracker;
+}
+
+interface CostManagerOptions extends CostManagerConfig {
+    storage?: CostStorageAdapter;
+    pricingRegistry?: ModelPricingRegistry;
+}
+declare class CostManager extends EventEmitter<CostEvents> {
+    private storage?;
+    private pricingRegistry;
+    private tokenCounter;
+    private tracker;
+    private config;
+    private initialized;
+    constructor(options?: CostManagerOptions);
+    initialize(): Promise<void>;
+    close(): Promise<void>;
+    track(options: TrackOptions): Promise<CostRecord>;
+    trackAnthropicResponse(response: Parameters<CostTracker['trackAnthropicResponse']>[0], options?: Parameters<CostTracker['trackAnthropicResponse']>[1]): Promise<CostRecord>;
+    trackOpenAIResponse(response: Parameters<CostTracker['trackOpenAIResponse']>[0], options?: Parameters<CostTracker['trackOpenAIResponse']>[1]): Promise<CostRecord>;
+    trackError(options: Parameters<CostTracker['trackError']>[0]): Promise<CostRecord>;
+    scoped(attribution: Partial<CostAttribution>): ScopedCostTracker;
+    flush(): Promise<number>;
+    countTokens(text: string, options?: {
+        model?: string;
+        provider?: AIProvider;
+    }): Promise<number>;
+    estimateCost(input: string | number, options: {
+        model: string;
+        provider?: AIProvider;
+        estimatedOutputTokens?: number;
+    }): Promise<{
+        estimatedCost: number;
+        inputTokens: number;
+        outputTokens: number;
+        currency: string;
+    }>;
+    getPricingRegistry(): ModelPricingRegistry;
+    getTokenCounter(): TokenCounter;
+    calculateCost(provider: AIProvider, model: string, tokens: TokenUsage): {
+        totalCost: number;
+        inputCost: number;
+        outputCost: number;
+        currency: string;
+    };
+    getSummary(options?: CostQueryOptions): Promise<CostSummary>;
+    getCostsByDimension(dimension: string, options?: CostQueryOptions): Promise<CostByDimension[]>;
+    getCostTrends(options?: CostQueryOptions): Promise<CostTrendPoint[]>;
+    queryRecords(options?: CostQueryOptions): Promise<CostRecord[]>;
+    getRecord(id: string): Promise<CostRecord | null>;
+    getTotalCost(options?: CostQueryOptions): Promise<number>;
+    getTotalTokens(options?: CostQueryOptions): Promise<number>;
+    getRequestCount(options?: CostQueryOptions): Promise<number>;
+    getErrorRate(options?: CostQueryOptions): Promise<number>;
+    getAvgCostPerRequest(options?: CostQueryOptions): Promise<number>;
+    getTopModels(options?: CostQueryOptions & {
+        limit?: number;
+    }): Promise<CostByDimension[]>;
+    getTopUsers(options?: CostQueryOptions & {
+        limit?: number;
+    }): Promise<CostByDimension[]>;
+    getTopFeatures(options?: CostQueryOptions & {
+        limit?: number;
+    }): Promise<CostByDimension[]>;
+    cleanup(olderThan: Date): Promise<number>;
+    getStorageStats(): Promise<{
+        recordCount: number;
+        storageSizeBytes?: number;
+        oldestRecord?: Date;
+        newestRecord?: Date;
+    }>;
+    optimizeStorage(): Promise<void>;
+    exportRecords(options?: CostQueryOptions): Promise<{
+        records: CostRecord[];
+        summary: CostSummary;
+        exportedAt: Date;
+    }>;
+    importRecords(records: CostRecord[]): Promise<number>;
+}
+declare function createCostManager(options?: CostManagerOptions): CostManager;
+
+interface BudgetEvents {
+    'budget:created': BudgetConfig;
+    'budget:updated': {
+        budgetId: string;
+        updates: Partial<BudgetConfig>;
+    };
+    'budget:deleted': string;
+    'budget:warning': BudgetAlert;
+    'budget:exceeded': BudgetAlert;
+    'budget:reset': {
+        budgetId: string;
+        previousUsage: number;
+    };
+    error: {
+        message: string;
+        cause?: unknown;
+    };
+}
+declare class BudgetManager extends EventEmitter<BudgetEvents> {
+    private budgets;
+    private usage;
+    private resetJobs;
+    private storage?;
+    private config;
+    constructor(config?: BudgetManagerConfig, storage?: CostStorageAdapter);
+    initialize(): Promise<void>;
+    createBudget(request: CreateBudgetRequest): Promise<BudgetConfig>;
+    updateBudget(budgetId: string, updates: UpdateBudgetRequest): Promise<BudgetConfig>;
+    deleteBudget(budgetId: string): Promise<boolean>;
+    getBudget(budgetId: string): BudgetConfig | null;
+    listBudgets(options?: {
+        scope?: BudgetScope;
+        scopeId?: string;
+        enabled?: boolean;
+    }): BudgetConfig[];
+    getUsage(budgetId: string): Promise<BudgetUsage | null>;
+    checkBudget(request: BudgetCheckRequest): Promise<BudgetCheckResult>;
+    recordCost(cost: number, attribution?: CostAttribution): Promise<void>;
+    private findMatchingBudgets;
+    private initializeUsage;
+    private refreshUsage;
+    private checkThresholds;
+    private executeAction;
+    private updateProjections;
+    private scheduleReset;
+    private resetBudget;
+    private getPeriodDates;
+    private getTimeRemaining;
+    private getCronPattern;
+    close(): void;
+}
+
+declare class BufferStorage implements CostStorageAdapter {
+    private records;
+    private budgets;
+    private budgetHistory;
+    private budgetAlerts;
+    private attributedCosts;
+    private alertRules;
+    private alerts;
+    private config;
+    private flushTimer?;
+    constructor(config?: BufferStorageConfig);
+    initialize(): Promise<void>;
+    close(): Promise<void>;
+    saveCostRecord(record: CostRecord): Promise<void>;
+    saveCostRecords(records: CostRecord[]): Promise<void>;
+    getCostRecord(id: string): Promise<CostRecord | null>;
+    queryCostRecords(options: CostQueryOptions): Promise<CostRecord[]>;
+    getCostSummary(options: CostQueryOptions): Promise<CostSummary>;
+    getCostsByDimension(dimension: string, options: CostQueryOptions): Promise<CostByDimension[]>;
+    getCostTrends(options: CostQueryOptions): Promise<CostTrendPoint[]>;
+    deleteCostRecords(ids: string[]): Promise<number>;
+    deleteCostRecordsByFilter(options: CostQueryOptions): Promise<number>;
+    saveBudget(budget: BudgetConfig): Promise<void>;
+    getBudget(id: string): Promise<BudgetConfig | null>;
+    listBudgets(options?: {
+        scope?: string;
+        scopeId?: string;
+        enabled?: boolean;
+    }): Promise<BudgetConfig[]>;
+    updateBudget(id: string, updates: Partial<BudgetConfig>): Promise<void>;
+    deleteBudget(id: string): Promise<boolean>;
+    getBudgetUsage(budgetId: string): Promise<BudgetUsage>;
+    saveBudgetHistory(entry: BudgetHistoryEntry): Promise<void>;
+    getBudgetHistory(budgetId: string, limit?: number): Promise<BudgetHistoryEntry[]>;
+    saveBudgetAlert(alert: BudgetAlert): Promise<void>;
+    getBudgetAlerts(budgetId: string): Promise<BudgetAlert[]>;
+    saveAttributedCost(attributed: AttributedCost): Promise<void>;
+    saveAttributedCosts(attributed: AttributedCost[]): Promise<void>;
+    getAttributionSummary(dimension: string, options: CostQueryOptions): Promise<AttributionSummary>;
+    saveAlertRule(rule: AlertRule): Promise<void>;
+    getAlertRule(id: string): Promise<AlertRule | null>;
+    listAlertRules(options?: {
+        enabled?: boolean;
+    }): Promise<AlertRule[]>;
+    updateAlertRule(id: string, updates: Partial<AlertRule>): Promise<void>;
+    deleteAlertRule(id: string): Promise<boolean>;
+    saveAlert(alert: Alert): Promise<void>;
+    getAlert(id: string): Promise<Alert | null>;
+    queryAlerts(options?: {
+        status?: string[];
+        severity?: string[];
+        startDate?: Date;
+        endDate?: Date;
+        limit?: number;
+        offset?: number;
+    }): Promise<Alert[]>;
+    updateAlert(id: string, updates: Partial<Alert>): Promise<void>;
+    cleanup(olderThan: Date): Promise<number>;
+    getStats(): Promise<StorageStats>;
+    optimize(): Promise<void>;
+    private enforceLimit;
+    private applyFilters;
+    private applySort;
+    private applyPagination;
+    private getDimensionValue;
+    private getBucketTime;
+    private matchesBudgetScope;
+    private getPeriodStart;
+    private getPeriodEnd;
+    clear(): void;
+}
+
+interface CostProviderEvents {
+    'cost:recorded': CostRecord;
+    'cost:batch': {
+        records: CostRecord[];
+    };
+    'budget:warning': {
+        budgetId: string;
+        message: string;
+    };
+    'budget:exceeded': {
+        budgetId: string;
+        message: string;
+    };
+    error: {
+        message: string;
+        cause?: unknown;
+    };
+}
+interface CostProviderConfig {
+    storage?: CostStorageAdapter;
+    costManagerOptions?: CostManagerOptions;
+    budgetManagerOptions?: BudgetManagerConfig;
+    enforceBudgets?: boolean;
+    defaultAttribution?: Partial<CostAttribution>;
+}
+interface AgentCostContext {
+    agentId: string;
+    sessionId?: string;
+    userId?: string;
+    labels?: Record<string, string>;
+}
+declare class CostProvider extends EventEmitter<CostProviderEvents> {
+    private costManager;
+    private budgetManager?;
+    private enforceBudgets;
+    private defaultAttribution?;
+    private initialized;
+    constructor(config?: CostProviderConfig);
+    initialize(): Promise<void>;
+    close(): Promise<void>;
+    createAgentTracker(context: AgentCostContext): AgentCostTracker;
+    track(provider: AIProvider, model: string, inputTokens: number, outputTokens: number, options?: {
+        latencyMs?: number;
+        success?: boolean;
+        error?: string;
+        attribution?: Partial<CostAttribution>;
+        metadata?: Record<string, unknown>;
+    }): Promise<CostRecord>;
+    checkBudget(estimatedCost: number, attribution?: Partial<CostAttribution>): Promise<BudgetCheckResult>;
+    getSummary(options?: {
+        startDate?: Date;
+        endDate?: Date;
+        agentId?: string;
+        userId?: string;
+    }): Promise<CostSummary>;
+    getCostManager(): CostManager;
+    getBudgetManager(): BudgetManager | undefined;
+    estimateCost(input: string | number, model: string, options?: {
+        provider?: AIProvider;
+        estimatedOutputTokens?: number;
+    }): Promise<number>;
+    private setupEventForwarding;
+}
+declare class AgentCostTracker {
+    private tracker;
+    private budgetManager?;
+    private enforceBudgets;
+    constructor(tracker: ScopedCostTracker, budgetManager?: BudgetManager, enforceBudgets?: boolean);
+    track(provider: AIProvider, model: string, inputTokens: number, outputTokens: number, options?: {
+        latencyMs?: number;
+        success?: boolean;
+        error?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<CostRecord>;
+    trackAnthropicResponse(response: {
+        model: string;
+        usage?: {
+            input_tokens: number;
+            output_tokens: number;
+            cache_read_input_tokens?: number;
+            cache_creation_input_tokens?: number;
+        };
+    }, options?: {
+        latencyMs?: number;
+        metadata?: Record<string, unknown>;
+    }): Promise<CostRecord>;
+    trackOpenAIResponse(response: {
+        model: string;
+        usage?: {
+            prompt_tokens: number;
+            completion_tokens: number;
+            total_tokens: number;
+        };
+    }, options?: {
+        latencyMs?: number;
+        metadata?: Record<string, unknown>;
+    }): Promise<CostRecord>;
+    checkBudget(estimatedCost: number): Promise<BudgetCheckResult>;
+    wrap<TArgs extends unknown[], TResult extends {
+        model: string;
+        usage?: {
+            input_tokens?: number;
+            output_tokens?: number;
+            prompt_tokens?: number;
+            completion_tokens?: number;
+        };
+    }>(fn: (...args: TArgs) => Promise<TResult>, options: {
+        provider: AIProvider;
+        extractUsage?: (result: TResult) => {
+            inputTokens: number;
+            outputTokens: number;
+        };
+    }): (...args: TArgs) => Promise<TResult>;
+    scoped(attribution: Partial<CostAttribution>): AgentCostTracker;
+}
+declare function createCostProvider(config?: CostProviderConfig): CostProvider;
+
+export { type AIProvider, type AgentCostContext, AgentCostTracker, type Alert, type AlertCondition, type AlertDetails, type AlertFilter, type AlertManagerConfig, type AlertQueryOptions, type AlertRule, type AlertSeverity, type AlertStatus, type AlertSummary, type AlertType, type AnalyticsComparison, type AnalyticsFilter, type AnalyticsMetric, type AnalyticsQuery, type AnalyticsResult, type AnalyticsSummary, type AnalyticsTimeSeries, type Anomaly, type AnomalyDetectionConfig, type AttributedCost, type AttributionBreakdown, type AttributionCondition, type AttributionDimension, type AttributionEngineConfig, type AttributionQueryOptions, type AttributionReport, type AttributionRule, type AttributionRuleType, type AttributionSummary, type AttributionTarget, type AttributionTrend, type AttributionTrendPoint, type BudgetAction, type BudgetAlert, type BudgetCheckRequest, type BudgetCheckResult, type BudgetConfig, type BudgetEvents, type BudgetFilter, type BudgetHistoryEntry, BudgetManager, type BudgetManagerConfig, type BudgetPeriod, type BudgetScope, type BudgetStatus, type BudgetThresholdAction, type BudgetUsage, BufferStorage, type BufferStorageConfig, type CacheablePattern, type CachingRecommendation, type ChangeMetric, type ChargebackLineItem, type ChargebackRecord, type CostAllocationPolicy, type CostAttribution, type CostBreakdown, type CostByDimension, type CostEstimateRequest, type CostEstimateResult, type CostEvents, CostManager, type CostManagerConfig, type CostManagerOptions, CostProvider, type CostProviderConfig, type CostProviderEvents, type CostQueryFilter, type CostQueryOptions, type CostRecord, type CostStorageAdapter, type CostSummary, CostTracker, type CostTrackerConfig, type CostTrendPoint, type CreateAlertRuleRequest, type CreateBudgetRequest, type DashboardConfig, type DashboardWidget, type DiscordNotificationConfig, type EffortLevel, type EmailNotificationConfig, type ForecastAccuracy, type ForecastConfig, type ForecastDataPoint, type ForecastMethod, type ForecastResult, type ImpactLevel, type IndexInfo, type ModelCapabilities, type ModelPricing, ModelPricingRegistry, type ModelSwitchRecommendation, type NotificationChannel, type NotificationChannelConfig, type NotificationConfig, type NotificationRecord, type OptimizationABTest, type OptimizationABTestResults, type OptimizationAction, type OptimizationActionType, type OptimizationAnalysisResult, type OptimizationAnalyzerConfig, type OptimizationCategory, type OptimizationCurrentState, type OptimizationRecommendation, type OptimizationStatus, type OptimizationTracking, type PagerDutyNotificationConfig, type PostgresConnectionConfig, type PostgresSSLConfig, type PostgresStorageConfig, type PricingComparison, type PricingRegistryConfig, type PricingTier, type PromptOptimizationRecommendation, type PromptOptimizationTechnique, type ProviderPricingSummary, type SQLiteStorageConfig, ScopedCostTracker, type SeasonalityInfo, type SlackNotificationConfig, type StorageFactoryOptions, type StorageMigration, type StorageStats, type TeamsNotificationConfig, type TimeGranularity, type TimeRangePreset, type TokenCountRequest, type TokenCountResult, TokenCounter, type TokenUsage, type TrackOptions, type UpdateBudgetRequest, type WebhookNotificationConfig, countTokens, countTokensApprox, createCostManager, createCostProvider };