caplyr 0.1.9 → 0.2.1

package/dist/index.js

@@ -32,41 +32,40 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/logger.ts
-var DEFAULT_MAX_BUFFER = 500;
-var activeShippers = /* @__PURE__ */ new Set();
-var processHandlersRegistered = false;
-function registerProcessHandlers() {
-  if (processHandlersRegistered) return;
-  if (typeof process === "undefined" || !process.on) return;
-  processHandlersRegistered = true;
-  process.on("beforeExit", () => {
-    for (const shipper of activeShippers) {
-      shipper.flush().catch(() => {
-      });
-    }
-  });
-}
 var LogShipper = class {
   constructor(config) {
     this.buffer = [];
     this.timer = null;
-    this.endpoint = config.endpoint ?? "https://caplyr.com";
+    this.endpoint = config.endpoint ?? "https://api.caplyr.com";
     this.apiKey = config.apiKey;
     this.batchSize = config.batchSize ?? 10;
     this.flushInterval = config.flushInterval ?? 3e4;
-    this.maxBufferSize = config.maxBufferSize ?? DEFAULT_MAX_BUFFER;
     this.onError = config.onError;
     this.timer = setInterval(() => this.flush(), this.flushInterval);
-    if (this.timer.unref) this.timer.unref();
-    activeShippers.add(this);
-    registerProcessHandlers();
+    if (typeof process !== "undefined" && process.on) {
+      const flushAndExit = () => {
+        this.flush().finally(() => {
+        });
+      };
+      process.on("beforeExit", () => this.flush());
+      process.on("SIGTERM", flushAndExit);
+      process.on("SIGINT", flushAndExit);
+    }
   }
+  /**
+   * Add a log entry to the buffer.
+   * Auto-flushes when batch size is reached.
+   */
   push(log) {
     this.buffer.push(log);
     if (this.buffer.length >= this.batchSize) {
       this.flush();
     }
   }
+  /**
+   * Flush all buffered logs to the backend.
+   * Non-blocking — errors are swallowed and reported via onError.
+   */
   async flush() {
     if (this.buffer.length === 0) return;
     const batch = this.buffer.splice(0);
@@ -81,34 +80,30 @@ var LogShipper = class {
         signal: AbortSignal.timeout(1e4)
       });
       if (!res.ok) {
-        this.requeueFailed(batch);
-        this.onError?.(new Error(`Ingest failed: ${res.status} ${res.statusText}`));
+        this.buffer.unshift(...batch);
+        throw new Error(`Ingest failed: ${res.status} ${res.statusText}`);
       }
     } catch (err) {
-      this.requeueFailed(batch);
       this.onError?.(err instanceof Error ? err : new Error(String(err)));
     }
   }
   /**
-   * Re-queue failed logs, dropping oldest if buffer would exceed max size.
+   * Stop the periodic flush timer.
+   * Call this when tearing down the SDK.
    */
-  requeueFailed(batch) {
-    const available = this.maxBufferSize - this.buffer.length;
-    if (available <= 0) return;
-    const toKeep = batch.slice(-available);
-    this.buffer.unshift(...toKeep);
-  }
-  async destroy() {
+  destroy() {
     if (this.timer) {
       clearInterval(this.timer);
       this.timer = null;
     }
-    await this.flush();
-    activeShippers.delete(this);
+    this.flush();
   }
-  /** @deprecated Use destroy() instead */
   async shutdown() {
-    return this.destroy();
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    await this.flush();
   }
 };
 
@@ -118,6 +113,7 @@ var Heartbeat = class {
     this.timer = null;
     this.consecutiveFailures = 0;
     this.maxFailuresBeforeDegraded = 3;
+    /** Current budget status from the backend */
     this.budgetStatus = {
       daily_used: 0,
       daily_limit: null,
@@ -126,20 +122,38 @@ var Heartbeat = class {
       status: "ACTIVE",
       kill_switch_active: false
     };
+    /** Current protection status */
     this.status = "ACTIVE";
-    this.lastHeartbeatAt = null;
     this.endpoint = config.endpoint ?? "https://caplyr.com";
     this.apiKey = config.apiKey;
     this.interval = config.heartbeatInterval ?? 6e4;
-    this.budget = config.budget;
     this.onStatusChange = config.onStatusChange;
     this.onError = config.onError;
   }
+  /**
+   * Apply local budget limits from config.
+   * These act as client-side enforcement even if the server
+   * doesn't return limits (e.g. during heartbeat failures).
+   */
+  applyLocalLimits(budget) {
+    if (budget.daily !== void 0) {
+      this.budgetStatus.daily_limit = budget.daily;
+    }
+    if (budget.monthly !== void 0) {
+      this.budgetStatus.monthly_limit = budget.monthly;
+    }
+  }
+  /**
+   * Start the heartbeat loop.
+   * Immediately sends first heartbeat, then repeats on interval.
+   */
   start() {
     this.beat();
     this.timer = setInterval(() => this.beat(), this.interval);
-    if (this.timer.unref) this.timer.unref();
   }
+  /**
+   * Send a single heartbeat and update local state.
+   */
   async beat() {
     try {
       const res = await fetch(`${this.endpoint}/api/heartbeat`, {
@@ -148,17 +162,15 @@ var Heartbeat = class {
           "Content-Type": "application/json",
           "Authorization": `Bearer ${this.apiKey}`
         },
-        body: JSON.stringify({
-          timestamp: Date.now(),
-          ...this.budget && { budget: this.budget }
-        }),
+        body: JSON.stringify({ timestamp: Date.now() }),
         signal: AbortSignal.timeout(5e3)
       });
-      if (!res.ok) throw new Error(`Heartbeat failed: ${res.status}`);
+      if (!res.ok) {
+        throw new Error(`Heartbeat failed: ${res.status}`);
+      }
       const data = await res.json();
       this.budgetStatus = data;
       this.consecutiveFailures = 0;
-      this.lastHeartbeatAt = Date.now();
       const newStatus = data.kill_switch_active ? "OFF" : data.status;
       if (newStatus !== this.status) {
         this.status = newStatus;
@@ -173,18 +185,32 @@ var Heartbeat = class {
       }
     }
   }
+  /**
+   * Update local budget tracking (called after each request).
+   * This provides real-time budget awareness between heartbeats.
+   */
   trackSpend(cost) {
     this.budgetStatus.daily_used += cost;
     this.budgetStatus.monthly_used += cost;
   }
+  /**
+   * Check if the monthly budget is exceeded.
+   */
   isMonthlyBudgetExceeded() {
     if (this.budgetStatus.monthly_limit === null) return false;
     return this.budgetStatus.monthly_used >= this.budgetStatus.monthly_limit;
   }
+  /**
+   * Check if the daily budget is exceeded.
+   */
   isDailyBudgetExceeded() {
     if (this.budgetStatus.daily_limit === null) return false;
     return this.budgetStatus.daily_used >= this.budgetStatus.daily_limit;
   }
+  /**
+   * Check if the downgrade threshold is reached.
+   * Returns true if usage exceeds the given threshold (0-1) of any budget.
+   */
   isDowngradeThresholdReached(threshold) {
     if (this.budgetStatus.monthly_limit !== null && this.budgetStatus.monthly_used >= this.budgetStatus.monthly_limit * threshold) {
       return true;
@@ -194,9 +220,15 @@ var Heartbeat = class {
     }
     return false;
   }
+  /**
+   * Check if the kill switch is active.
+   */
   isKillSwitchActive() {
     return this.budgetStatus.kill_switch_active;
   }
+  /**
+   * Stop the heartbeat loop.
+   */
   destroy() {
     if (this.timer) {
       clearInterval(this.timer);
@@ -211,6 +243,7 @@ var MODEL_PRICING = {
   "claude-opus-4-20250514": { input: 15, output: 75 },
   "claude-sonnet-4-20250514": { input: 3, output: 15 },
   "claude-haiku-4-5-20251001": { input: 0.8, output: 4 },
+  // Aliases
   "claude-opus-4": { input: 15, output: 75 },
   "claude-sonnet-4": { input: 3, output: 15 },
   "claude-3-5-sonnet-20241022": { input: 3, output: 15 },
@@ -228,11 +261,13 @@ var MODEL_PRICING = {
   "o3-mini": { input: 1.1, output: 4.4 }
 };
 var DEFAULT_FALLBACKS = {
+  // Anthropic downgrades
   "claude-opus-4-20250514": "claude-sonnet-4-20250514",
   "claude-opus-4": "claude-sonnet-4",
   "claude-sonnet-4-20250514": "claude-haiku-4-5-20251001",
   "claude-sonnet-4": "claude-haiku-4-5-20251001",
   "claude-3-5-sonnet-20241022": "claude-haiku-4-5-20251001",
+  // OpenAI downgrades
   "gpt-4o": "gpt-4o-mini",
   "gpt-4o-2024-11-20": "gpt-4o-mini",
   "gpt-4-turbo": "gpt-4o-mini",
@@ -252,7 +287,9 @@ function getDefaultFallback(model) {
 }
 function registerModel(model, pricing, fallback) {
   MODEL_PRICING[model] = pricing;
-  if (fallback) DEFAULT_FALLBACKS[model] = fallback;
+  if (fallback) {
+    DEFAULT_FALLBACKS[model] = fallback;
+  }
 }
 function isKnownModel(model) {
   return model in MODEL_PRICING;
@@ -261,182 +298,160 @@ function getModelPricing(model) {
   return MODEL_PRICING[model] ?? null;
 }
 
-// src/utils.ts
+// src/interceptors/anthropic.ts
 var idCounter = 0;
 function generateId() {
-  return `caplyr_${Date.now()}_${process.pid ?? 0}_${++idCounter}`;
-}
-function getNextResetTime(reason) {
-  const now = /* @__PURE__ */ new Date();
-  if (reason.includes("daily")) {
-    const tomorrow = new Date(now);
-    tomorrow.setDate(tomorrow.getDate() + 1);
-    tomorrow.setHours(0, 0, 0, 0);
-    return tomorrow.toISOString();
-  }
-  const nextMonth = new Date(now.getFullYear(), now.getMonth() + 1, 1);
-  return nextMonth.toISOString();
-}
-
-// src/interceptors/enforce.ts
-function enforcePreCall(model, config, heartbeat, shipper, provider, startTime) {
-  const dashboardUrl = `${config.dashboardUrl.replace(/\/dashboard\/?$/, "")}/dashboard`;
-  const downgradeThreshold = config.downgradeThreshold ?? 0.8;
-  config._onRequest?.();
-  if (heartbeat.isKillSwitchActive()) {
-    const reason = "kill_switch_active";
-    const blockError = {
-      code: "KILL_SWITCH_ACTIVE",
-      message: "Caplyr kill switch is active. All AI API calls are halted.",
-      budget_used: heartbeat.budgetStatus.monthly_used,
-      budget_limit: heartbeat.budgetStatus.monthly_limit ?? 0,
-      dashboard_url: dashboardUrl
-    };
-    pushBlockedLog(shipper, provider, model, startTime, reason, config.endpoint_tag);
-    config.onEnforcement?.({
-      type: "kill_switch",
-      timestamp: Date.now(),
-      reason: blockError.message,
-      budget_used: blockError.budget_used,
-      budget_limit: blockError.budget_limit
-    });
-    throw Object.assign(new Error(blockError.message), { caplyr: blockError });
-  }
-  if (config.mode === "cost_protect") {
-    if (heartbeat.isMonthlyBudgetExceeded() || heartbeat.isDailyBudgetExceeded()) {
-      const reason = heartbeat.isDailyBudgetExceeded() ? "daily_budget_exceeded" : "monthly_budget_exceeded";
-      const blockError = {
-        code: "BUDGET_EXCEEDED",
-        message: `AI budget exceeded. ${reason.replace(/_/g, " ")}.`,
-        budget_used: heartbeat.budgetStatus.monthly_used,
-        budget_limit: heartbeat.budgetStatus.monthly_limit ?? 0,
-        retry_after: getNextResetTime(reason),
-        dashboard_url: dashboardUrl
-      };
-      pushBlockedLog(shipper, provider, model, startTime, reason, config.endpoint_tag);
-      throw Object.assign(new Error(blockError.message), { caplyr: blockError });
-    }
-    if (heartbeat.isDowngradeThresholdReached(downgradeThreshold)) {
-      const fallback = config.fallback ?? getDefaultFallback(model);
-      if (fallback && fallback !== model) {
-        config.onEnforcement?.({
-          type: "downgrade",
-          timestamp: Date.now(),
-          reason: `Budget at ${Math.round(downgradeThreshold * 100)}% \u2014 downgraded ${model} \u2192 ${fallback}`,
-          original_model: model,
-          fallback_model: fallback,
-          budget_used: heartbeat.budgetStatus.monthly_used,
-          budget_limit: heartbeat.budgetStatus.monthly_limit ?? 0,
-          estimated_savings: 0
-        });
-        return {
-          proceed: true,
-          model: fallback,
-          downgraded: true,
-          originalModel: model,
-          enforcementReason: "auto_downgrade_threshold"
-        };
-      }
-    }
-  }
-  return { proceed: true, model, downgraded: false };
-}
-function logSuccess(shipper, provider, model, startTime, inputTokens, outputTokens, enforcement, heartbeat, config) {
-  const cost = calculateCost(model, inputTokens, outputTokens);
-  heartbeat.trackSpend(cost);
-  shipper.push({
-    id: generateId(),
-    timestamp: startTime,
-    provider,
-    model,
-    input_tokens: inputTokens,
-    output_tokens: outputTokens,
-    cost,
-    latency_ms: Date.now() - startTime,
-    endpoint_tag: config.endpoint_tag,
-    downgraded: enforcement.downgraded,
-    original_model: enforcement.originalModel,
-    blocked: false,
-    enforcement_reason: enforcement.enforcementReason
-  });
-  return cost;
+  return `caplyr_${Date.now()}_${++idCounter}`;
 }
-function logProviderError(shipper, provider, model, startTime, enforcement, config) {
-  shipper.push({
-    id: generateId(),
-    timestamp: startTime,
-    provider,
-    model,
-    input_tokens: 0,
-    output_tokens: 0,
-    cost: 0,
-    latency_ms: Date.now() - startTime,
-    endpoint_tag: config.endpoint_tag,
-    downgraded: enforcement.downgraded,
-    original_model: enforcement.originalModel,
-    blocked: false,
-    enforcement_reason: "provider_error"
-  });
-}
-function pushBlockedLog(shipper, provider, model, startTime, reason, endpointTag) {
-  shipper.push({
-    id: generateId(),
-    timestamp: startTime,
-    provider,
-    model,
-    input_tokens: 0,
-    output_tokens: 0,
-    cost: 0,
-    latency_ms: Date.now() - startTime,
-    endpoint_tag: endpointTag,
-    downgraded: false,
-    blocked: true,
-    enforcement_reason: reason
-  });
-}
-
-// src/interceptors/anthropic.ts
 function wrapAnthropic(client, config, shipper, heartbeat) {
+  const downgradeThreshold = config.downgradeThreshold ?? 0.8;
+  const dashboardUrl = `${config.endpoint ?? "https://app.caplyr.com"}/dashboard`;
   const messagesProxy = new Proxy(client.messages, {
     get(target, prop, receiver) {
       if (prop === "create") {
         return async function caplyrInterceptedCreate(params, options) {
           const startTime = Date.now();
-          const enforcement = enforcePreCall(
-            params.model,
-            config,
-            heartbeat,
-            shipper,
-            "anthropic",
-            startTime
-          );
-          const requestParams = enforcement.downgraded ? { ...params, model: enforcement.model } : params;
+          let model = params.model;
+          let downgraded = false;
+          let originalModel;
+          let blocked = false;
+          let enforcementReason;
+          if (heartbeat.isKillSwitchActive()) {
+            blocked = true;
+            enforcementReason = "kill_switch_active";
+            const blockError = {
+              code: "KILL_SWITCH_ACTIVE",
+              message: "Caplyr kill switch is active. All AI API calls are halted.",
+              budget_used: heartbeat.budgetStatus.monthly_used,
+              budget_limit: heartbeat.budgetStatus.monthly_limit ?? 0,
+              dashboard_url: dashboardUrl
+            };
+            shipper.push({
+              id: generateId(),
+              timestamp: startTime,
+              provider: "anthropic",
+              model,
+              input_tokens: 0,
+              output_tokens: 0,
+              cost: 0,
+              latency_ms: Date.now() - startTime,
+              endpoint_tag: config.endpoint_tag,
+              downgraded: false,
+              blocked: true,
+              enforcement_reason: enforcementReason
+            });
+            if (config.mode === "alert_only") {
+            } else {
+              throw Object.assign(new Error(blockError.message), {
+                caplyr: blockError
+              });
+            }
+          }
+          if (config.mode === "cost_protect") {
+            if (heartbeat.isMonthlyBudgetExceeded() || heartbeat.isDailyBudgetExceeded()) {
+              blocked = true;
+              enforcementReason = heartbeat.isDailyBudgetExceeded() ? "daily_budget_exceeded" : "monthly_budget_exceeded";
+              const blockError = {
+                code: "BUDGET_EXCEEDED",
+                message: `AI budget exceeded. ${enforcementReason.replace(/_/g, " ")}.`,
+                budget_used: heartbeat.budgetStatus.monthly_used,
+                budget_limit: heartbeat.budgetStatus.monthly_limit ?? 0,
+                retry_after: getNextResetTime(enforcementReason),
+                dashboard_url: dashboardUrl
+              };
+              shipper.push({
+                id: generateId(),
+                timestamp: startTime,
+                provider: "anthropic",
+                model,
+                input_tokens: 0,
+                output_tokens: 0,
+                cost: 0,
+                latency_ms: Date.now() - startTime,
+                endpoint_tag: config.endpoint_tag,
+                downgraded: false,
+                blocked: true,
+                enforcement_reason: enforcementReason
+              });
+              throw Object.assign(new Error(blockError.message), {
+                caplyr: blockError
+              });
+            }
+            if (heartbeat.isDowngradeThresholdReached(downgradeThreshold)) {
+              const fallback = config.fallback ?? getDefaultFallback(model);
+              if (fallback && fallback !== model) {
+                originalModel = model;
+                model = fallback;
+                downgraded = true;
+                enforcementReason = "auto_downgrade_threshold";
+                config.onEnforcement?.({
+                  type: "downgrade",
+                  timestamp: Date.now(),
+                  reason: `Budget at ${Math.round(downgradeThreshold * 100)}% \u2014 downgraded ${originalModel} \u2192 ${model}`,
+                  original_model: originalModel,
+                  fallback_model: model,
+                  budget_used: heartbeat.budgetStatus.monthly_used,
+                  budget_limit: heartbeat.budgetStatus.monthly_limit ?? 0,
+                  estimated_savings: 0
+                  // Calculated after response
+                });
+              }
+            }
+          }
+          const requestParams = downgraded ? { ...params, model } : params;
           try {
-            const response = await target.create.call(target, requestParams, options);
+            const response = await target.create.call(
+              target,
+              requestParams,
+              options
+            );
+            const latency = Date.now() - startTime;
             const inputTokens = response?.usage?.input_tokens ?? 0;
             const outputTokens = response?.usage?.output_tokens ?? 0;
-            logSuccess(
-              shipper,
-              "anthropic",
-              enforcement.model,
-              startTime,
-              inputTokens,
-              outputTokens,
-              enforcement,
-              heartbeat,
-              config
-            );
+            const cost = calculateCost(model, inputTokens, outputTokens);
+            heartbeat.trackSpend(cost);
+            let estimatedSavings = 0;
+            if (downgraded && originalModel) {
+              const originalCost = calculateCost(
+                originalModel,
+                inputTokens,
+                outputTokens
+              );
+              estimatedSavings = originalCost - cost;
+            }
+            shipper.push({
+              id: generateId(),
+              timestamp: startTime,
+              provider: "anthropic",
+              model,
+              input_tokens: inputTokens,
+              output_tokens: outputTokens,
+              cost,
+              latency_ms: latency,
+              endpoint_tag: config.endpoint_tag,
+              downgraded,
+              original_model: originalModel,
+              blocked: false,
+              enforcement_reason: enforcementReason
+            });
             return response;
           } catch (err) {
             if (err?.caplyr) throw err;
-            logProviderError(
-              shipper,
-              "anthropic",
-              enforcement.model,
-              startTime,
-              enforcement,
-              config
-            );
+            shipper.push({
+              id: generateId(),
+              timestamp: startTime,
+              provider: "anthropic",
+              model,
+              input_tokens: 0,
+              output_tokens: 0,
+              cost: 0,
+              latency_ms: Date.now() - startTime,
+              endpoint_tag: config.endpoint_tag,
+              downgraded,
+              original_model: originalModel,
+              blocked: false,
+              enforcement_reason: "provider_error"
+            });
             throw err;
           }
         };
@@ -446,55 +461,170 @@ function wrapAnthropic(client, config, shipper, heartbeat) {
   });
   return new Proxy(client, {
     get(target, prop, receiver) {
-      if (prop === "messages") return messagesProxy;
+      if (prop === "messages") {
+        return messagesProxy;
+      }
       return Reflect.get(target, prop, receiver);
     }
   });
 }
+function getNextResetTime(reason) {
+  const now = /* @__PURE__ */ new Date();
+  if (reason.includes("daily")) {
+    const tomorrow = new Date(now);
+    tomorrow.setDate(tomorrow.getDate() + 1);
+    tomorrow.setHours(0, 0, 0, 0);
+    return tomorrow.toISOString();
+  }
+  const nextMonth = new Date(now.getFullYear(), now.getMonth() + 1, 1);
+  return nextMonth.toISOString();
+}
 
 // src/interceptors/openai.ts
+var idCounter2 = 0;
+function generateId2() {
+  return `caplyr_${Date.now()}_${++idCounter2}`;
+}
 function wrapOpenAI(client, config, shipper, heartbeat) {
+  const downgradeThreshold = config.downgradeThreshold ?? 0.8;
+  const dashboardUrl = `${config.endpoint ?? "https://app.caplyr.com"}/dashboard`;
   const completionsProxy = new Proxy(client.chat.completions, {
     get(target, prop, receiver) {
       if (prop === "create") {
         return async function caplyrInterceptedCreate(params, options) {
           const startTime = Date.now();
-          const enforcement = enforcePreCall(
-            params.model,
-            config,
-            heartbeat,
-            shipper,
-            "openai",
-            startTime
-          );
-          const requestParams = enforcement.downgraded ? { ...params, model: enforcement.model } : params;
+          let model = params.model;
+          let downgraded = false;
+          let originalModel;
+          let blocked = false;
+          let enforcementReason;
+          if (heartbeat.isKillSwitchActive()) {
+            blocked = true;
+            enforcementReason = "kill_switch_active";
+            const blockError = {
+              code: "KILL_SWITCH_ACTIVE",
+              message: "Caplyr kill switch is active. All AI API calls are halted.",
+              budget_used: heartbeat.budgetStatus.monthly_used,
+              budget_limit: heartbeat.budgetStatus.monthly_limit ?? 0,
+              dashboard_url: dashboardUrl
+            };
+            shipper.push({
+              id: generateId2(),
+              timestamp: startTime,
+              provider: "openai",
+              model,
+              input_tokens: 0,
+              output_tokens: 0,
+              cost: 0,
+              latency_ms: Date.now() - startTime,
+              endpoint_tag: config.endpoint_tag,
+              downgraded: false,
+              blocked: true,
+              enforcement_reason: enforcementReason
+            });
+            if (config.mode === "alert_only") {
+            } else {
+              throw Object.assign(new Error(blockError.message), {
+                caplyr: blockError
+              });
+            }
+          }
+          if (config.mode === "cost_protect") {
+            if (heartbeat.isMonthlyBudgetExceeded() || heartbeat.isDailyBudgetExceeded()) {
+              blocked = true;
+              enforcementReason = heartbeat.isDailyBudgetExceeded() ? "daily_budget_exceeded" : "monthly_budget_exceeded";
+              const blockError = {
+                code: "BUDGET_EXCEEDED",
+                message: `AI budget exceeded. ${enforcementReason.replace(/_/g, " ")}.`,
+                budget_used: heartbeat.budgetStatus.monthly_used,
+                budget_limit: heartbeat.budgetStatus.monthly_limit ?? 0,
+                retry_after: getNextResetTime2(enforcementReason),
+                dashboard_url: dashboardUrl
+              };
+              shipper.push({
+                id: generateId2(),
+                timestamp: startTime,
+                provider: "openai",
+                model,
+                input_tokens: 0,
+                output_tokens: 0,
+                cost: 0,
+                latency_ms: Date.now() - startTime,
+                endpoint_tag: config.endpoint_tag,
+                downgraded: false,
+                blocked: true,
+                enforcement_reason: enforcementReason
+              });
+              throw Object.assign(new Error(blockError.message), {
+                caplyr: blockError
+              });
+            }
+            if (heartbeat.isDowngradeThresholdReached(downgradeThreshold)) {
+              const fallback = config.fallback ?? getDefaultFallback(model);
+              if (fallback && fallback !== model) {
+                originalModel = model;
+                model = fallback;
+                downgraded = true;
+                enforcementReason = "auto_downgrade_threshold";
+                config.onEnforcement?.({
+                  type: "downgrade",
+                  timestamp: Date.now(),
+                  reason: `Budget at ${Math.round(downgradeThreshold * 100)}% \u2014 downgraded ${originalModel} \u2192 ${model}`,
+                  original_model: originalModel,
+                  fallback_model: model,
+                  budget_used: heartbeat.budgetStatus.monthly_used,
+                  budget_limit: heartbeat.budgetStatus.monthly_limit ?? 0,
+                  estimated_savings: 0
+                });
+              }
+            }
+          }
+          const requestParams = downgraded ? { ...params, model } : params;
           try {
-            const response = await target.create.call(target, requestParams, options);
+            const response = await target.create.call(
+              target,
+              requestParams,
+              options
+            );
+            const latency = Date.now() - startTime;
             const usage = response?.usage;
             const inputTokens = usage?.prompt_tokens ?? 0;
             const outputTokens = usage?.completion_tokens ?? 0;
-            logSuccess(
-              shipper,
-              "openai",
-              enforcement.model,
-              startTime,
-              inputTokens,
-              outputTokens,
-              enforcement,
-              heartbeat,
-              config
-            );
+            const cost = calculateCost(model, inputTokens, outputTokens);
+            heartbeat.trackSpend(cost);
+            shipper.push({
+              id: generateId2(),
+              timestamp: startTime,
+              provider: "openai",
+              model,
+              input_tokens: inputTokens,
+              output_tokens: outputTokens,
+              cost,
+              latency_ms: latency,
+              endpoint_tag: config.endpoint_tag,
+              downgraded,
+              original_model: originalModel,
+              blocked: false,
+              enforcement_reason: enforcementReason
+            });
             return response;
           } catch (err) {
             if (err?.caplyr) throw err;
-            logProviderError(
-              shipper,
-              "openai",
-              enforcement.model,
-              startTime,
-              enforcement,
-              config
-            );
+            shipper.push({
+              id: generateId2(),
+              timestamp: startTime,
+              provider: "openai",
+              model,
+              input_tokens: 0,
+              output_tokens: 0,
+              cost: 0,
+              latency_ms: Date.now() - startTime,
+              endpoint_tag: config.endpoint_tag,
+              downgraded,
+              original_model: originalModel,
+              blocked: false,
+              enforcement_reason: "provider_error"
+            });
             throw err;
           }
         };
@@ -504,17 +634,32 @@ function wrapOpenAI(client, config, shipper, heartbeat) {
   });
   const chatProxy = new Proxy(client.chat, {
     get(target, prop, receiver) {
-      if (prop === "completions") return completionsProxy;
+      if (prop === "completions") {
+        return completionsProxy;
+      }
       return Reflect.get(target, prop, receiver);
     }
   });
   return new Proxy(client, {
     get(target, prop, receiver) {
-      if (prop === "chat") return chatProxy;
+      if (prop === "chat") {
+        return chatProxy;
+      }
       return Reflect.get(target, prop, receiver);
     }
   });
 }
+function getNextResetTime2(reason) {
+  const now = /* @__PURE__ */ new Date();
+  if (reason.includes("daily")) {
+    const tomorrow = new Date(now);
+    tomorrow.setDate(tomorrow.getDate() + 1);
+    tomorrow.setHours(0, 0, 0, 0);
+    return tomorrow.toISOString();
+  }
+  const nextMonth = new Date(now.getFullYear(), now.getMonth() + 1, 1);
+  return nextMonth.toISOString();
+}
 
 // src/protect.ts
 function detectProvider(client) {
@@ -529,28 +674,32 @@ function detectProvider(client) {
 var instances = /* @__PURE__ */ new Map();
 function protect(client, config) {
   if (!config.apiKey) {
-    throw new Error("Caplyr: apiKey is required. Get yours at https://app.caplyr.com");
+    throw new Error(
+      "Caplyr: apiKey is required. Get yours at https://app.caplyr.com"
+    );
   }
-  const mode = config.mode ?? (config.budget ? "cost_protect" : "alert_only");
+  const userWantsProtect = config.budget && !config.mode;
   const resolvedConfig = {
-    ...config,
-    mode,
-    downgradeThreshold: config.downgradeThreshold ?? 0.8,
-    dashboardUrl: config.dashboardUrl ?? "https://app.caplyr.com"
+    mode: userWantsProtect ? "cost_protect" : "alert_only",
+    downgradeThreshold: 0.8,
+    batchSize: 10,
+    flushInterval: 3e4,
+    heartbeatInterval: 6e4,
+    ...config
   };
   let shared = instances.get(resolvedConfig.apiKey);
   if (!shared) {
     const shipper2 = new LogShipper(resolvedConfig);
     const heartbeat2 = new Heartbeat(resolvedConfig);
     heartbeat2.start();
-    shared = { shipper: shipper2, heartbeat: heartbeat2, mode, requestCount: 0 };
+    shared = { shipper: shipper2, heartbeat: heartbeat2 };
     instances.set(resolvedConfig.apiKey, shared);
   }
   const { shipper, heartbeat } = shared;
-  const sharedRef = shared;
-  resolvedConfig._onRequest = () => {
-    sharedRef.requestCount++;
-  };
+  if (resolvedConfig.budget) {
+    const budgetConfig = typeof resolvedConfig.budget === "number" ? { monthly: resolvedConfig.budget } : resolvedConfig.budget;
+    heartbeat.applyLocalLimits(budgetConfig);
+  }
   const provider = detectProvider(client);
   switch (provider) {
     case "anthropic":
@@ -559,26 +708,30 @@ function protect(client, config) {
       return wrapOpenAI(client, resolvedConfig, shipper, heartbeat);
     default:
       throw new Error(
-        "Caplyr: Unrecognized AI client. Supported providers: Anthropic, OpenAI. Make sure you're passing a client instance (e.g., new Anthropic() or new OpenAI())."
+        `Caplyr: Unrecognized AI client. Supported providers: Anthropic, OpenAI. Make sure you're passing a client instance (e.g., new Anthropic() or new OpenAI()).`
       );
   }
 }
 function getStatus(apiKey) {
-  return instances.get(apiKey)?.heartbeat.status ?? "OFF";
+  const shared = instances.get(apiKey);
+  return shared?.heartbeat.status ?? "OFF";
 }
 function getState(apiKey) {
   const shared = instances.get(apiKey);
   if (!shared) return null;
-  const { heartbeat, mode, requestCount } = shared;
+  const { heartbeat } = shared;
   return {
     status: heartbeat.status,
-    mode,
+    mode: "alert_only",
+    // Will be stored properly in next iteration
     budget_daily_used: heartbeat.budgetStatus.daily_used,
     budget_monthly_used: heartbeat.budgetStatus.monthly_used,
     kill_switch_active: heartbeat.budgetStatus.kill_switch_active,
-    last_heartbeat: heartbeat.lastHeartbeatAt,
-    request_count: requestCount,
-    total_cost: heartbeat.budgetStatus.monthly_used
+    last_heartbeat: Date.now(),
+    request_count: 0,
+    // Will be tracked in next iteration
+    total_cost: heartbeat.budgetStatus.monthly_used,
+    total_savings: 0
   };
 }
 async function shutdown(apiKey) {
@@ -586,16 +739,14 @@ async function shutdown(apiKey) {
     const shared = instances.get(apiKey);
     if (shared) {
       shared.heartbeat.destroy();
-      await shared.shipper.destroy();
+      shared.shipper.destroy();
       instances.delete(apiKey);
     }
   } else {
-    const promises = [];
-    for (const [, shared] of instances) {
+    for (const [key, shared] of instances) {
       shared.heartbeat.destroy();
-      promises.push(shared.shipper.destroy());
+      shared.shipper.destroy();
     }
-    await Promise.all(promises);
     instances.clear();
   }
 }