@diogonzafe/tokenwatch 0.1.6 → 0.1.8

package/dist/index.d.ts

@@ -1,89 +1,5 @@
-interface ModelPrice {
-    /** USD per 1 million input tokens */
-    input: number;
-    /** USD per 1 million output tokens */
-    output: number;
-    /** Maximum context window (input tokens) for this model */
-    maxInputTokens?: number;
-}
-type PriceMap = Record<string, ModelPrice>;
-interface PricesFile {
-    updated_at: string;
-    source: string;
-    models: PriceMap;
-}
-interface TrackerConfig {
-    /** 'memory' (default) or 'sqlite' */
-    storage?: 'memory' | 'sqlite';
-    /** USD threshold — fires webhookUrl when totalCostUSD exceeds this */
-    alertThreshold?: number;
-    /** Discord / Slack / generic webhook URL */
-    webhookUrl?: string;
-    /** Fetch fresh prices from remote GitHub source (default: true) */
-    syncPrices?: boolean;
-    /** Per-model price overrides — highest priority */
-    customPrices?: PriceMap;
-}
-interface UsageEntry {
-    model: string;
-    inputTokens: number;
-    outputTokens: number;
-    costUSD: number;
-    sessionId?: string;
-    userId?: string;
-    timestamp: string;
-}
-interface ModelStats {
-    costUSD: number;
-    calls: number;
-    tokens: {
-        input: number;
-        output: number;
-    };
-}
-interface SessionStats {
-    costUSD: number;
-    calls: number;
-}
-interface UserStats {
-    costUSD: number;
-    calls: number;
-}
-interface Report {
-    totalCostUSD: number;
-    totalTokens: {
-        input: number;
-        output: number;
-    };
-    byModel: Record<string, ModelStats>;
-    bySession: Record<string, SessionStats>;
-    byUser: Record<string, UserStats>;
-    period: {
-        from: string;
-        to: string;
-    };
-}
-interface IStorage {
-    record(entry: UsageEntry): void;
-    getAll(): UsageEntry[];
-    clearAll(): void;
-    clearSession(sessionId: string): void;
-}
-interface Tracker {
-    /** Accumulate a usage entry (called by providers) */
-    track(entry: Omit<UsageEntry, 'costUSD' | 'timestamp'>): void;
-    getReport(): Report;
-    reset(): void;
-    resetSession(sessionId: string): void;
-    exportJSON(): string;
-    exportCSV(): string;
-    /** Returns price and context window info for a model, or null if unknown */
-    getModelInfo(model: string): ModelPrice | null;
-}
-interface TrackingMeta {
-    __sessionId?: string;
-    __userId?: string;
-}
+import { T as TrackerConfig, a as Tracker, b as TrackingMeta } from './index-Cy_sl3FI.js';
+export { I as IStorage, M as ModelPrice, c as ModelStats, P as PriceMap, d as PricesFile, R as Report, S as SessionStats, U as UsageEntry, e as UserStats } from './index-Cy_sl3FI.js';
 
 declare function createTracker(config?: TrackerConfig): Tracker;
 
@@ -167,4 +83,4 @@ interface GenAILike {
  */
 declare function wrapGemini<T extends GenAILike>(client: T, tracker: Tracker): T;
 
-export { type IStorage, type ModelPrice, type ModelStats, type PriceMap, type PricesFile, type Report, type SessionStats, type Tracker, type TrackerConfig, type TrackingMeta, type UsageEntry, type UserStats, createTracker, wrapAnthropic, wrapOpenAI as wrapDeepSeek, wrapGemini, wrapOpenAI };
+export { Tracker, TrackerConfig, TrackingMeta, createTracker, wrapAnthropic, wrapOpenAI as wrapDeepSeek, wrapGemini, wrapOpenAI };

package/dist/index.js

@@ -1338,7 +1338,9 @@ var ModelPriceSchema = z.object({
   maxInputTokens: z.number().positive().optional()
 });
 var TrackerConfigSchema = z.object({
-  storage: z.enum(["memory", "sqlite"]).optional().default("memory"),
+  storage: z.union([z.enum(["memory", "sqlite"]), z.custom((v) => {
+    return v !== null && typeof v === "object" && typeof v.record === "function" && typeof v.getAll === "function" && typeof v.clearAll === "function" && typeof v.clearSession === "function";
+  })]).optional().default("memory"),
   alertThreshold: z.number().positive().optional(),
   webhookUrl: z.string().url().optional(),
   syncPrices: z.boolean().optional().default(true),
@@ -1352,13 +1354,13 @@ function createTracker(config = {}) {
 ${issues}`);
   }
   const {
-    storage: storageType,
+    storage: storageOption,
     alertThreshold,
     webhookUrl,
     syncPrices,
     customPrices
   } = parsed.data;
-  const storage = createStorage(storageType);
+  const storage = typeof storageOption === "object" ? storageOption : createStorage(storageOption);
   let remotePrices;
   if (syncPrices) {
     getRemotePrices().then((result) => {
@@ -1388,9 +1390,13 @@ ${issues}`);
   }
   function maybeFireAlert() {
     if (!alertThreshold || !webhookUrl || alertFired) return;
-    const total = computeTotal(storage.getAll());
-    if (total >= alertThreshold) {
-      alertFired = true;
+    alertFired = true;
+    Promise.resolve(storage.getAll()).then((entries) => {
+      const total = computeTotal(entries);
+      if (total < alertThreshold) {
+        alertFired = false;
+        return;
+      }
       const payload = {
         text: `[tokenwatch] Alert: total cost reached $${total.toFixed(4)} USD (threshold: $${alertThreshold})`
       };
@@ -1400,10 +1406,12 @@ ${issues}`);
         body: JSON.stringify(payload)
       }).catch(() => {
       });
-    }
+    }).catch(() => {
+      alertFired = false;
+    });
   }
-  function getReport() {
-    const entries = storage.getAll();
+  async function getReport() {
+    const entries = await Promise.resolve(storage.getAll());
     const byModel = {};
     const bySession = {};
     const byUser = {};
@@ -1441,18 +1449,18 @@ ${issues}`);
       period: { from: startedAt, to: lastTimestamp }
     };
   }
-  function reset() {
-    storage.clearAll();
+  async function reset() {
+    await Promise.resolve(storage.clearAll());
     alertFired = false;
   }
-  function resetSession(sessionId) {
-    storage.clearSession(sessionId);
+  async function resetSession(sessionId) {
+    await Promise.resolve(storage.clearSession(sessionId));
   }
-  function exportJSON() {
-    return JSON.stringify(getReport(), null, 2);
+  async function exportJSON() {
+    return JSON.stringify(await getReport(), null, 2);
   }
-  function exportCSV() {
-    const entries = storage.getAll();
+  async function exportCSV() {
+    const entries = await Promise.resolve(storage.getAll());
     const header = "timestamp,model,inputTokens,outputTokens,costUSD,sessionId,userId";
     const rows = entries.map(
       (e) => [
@@ -1527,12 +1535,7 @@ function wrapOpenAI(client, tracker) {
       return async function(params) {
         const { cleaned, sessionId, userId } = extractMeta(params);
         const model = typeof cleaned["model"] === "string" ? cleaned["model"] : "unknown";
-        let result;
-        try {
-          result = await target.create(cleaned);
-        } catch (err) {
-          throw err;
-        }
+        const result = await target.create(cleaned);
         if (result && typeof result === "object" && Symbol.asyncIterator in result) {
           return wrapStream(
             result,
@@ -1617,12 +1620,7 @@ function wrapAnthropic(client, tracker) {
       return async function(params) {
         const { cleaned, sessionId, userId } = extractMeta2(params);
         const model = typeof cleaned["model"] === "string" ? cleaned["model"] : "unknown";
-        let result;
-        try {
-          result = await target.create(cleaned);
-        } catch (err) {
-          throw err;
-        }
+        const result = await target.create(cleaned);
         if (result && typeof result === "object" && Symbol.asyncIterator in result) {
           return wrapStream2(
             result,
@@ -1667,12 +1665,7 @@ function wrapGemini(client, tracker) {
           get(mTarget, mProp) {
             if (mProp === "generateContent") {
               return async function(params) {
-                let result;
-                try {
-                  result = await mTarget.generateContent(params);
-                } catch (err) {
-                  throw err;
-                }
+                const result = await mTarget.generateContent(params);
                 const meta = result.response.usageMetadata;
                 tracker.track({
                   model: modelId,
@@ -1684,12 +1677,7 @@ function wrapGemini(client, tracker) {
             }
             if (mProp === "generateContentStream") {
               return async function(params) {
-                let streamResult;
-                try {
-                  streamResult = await mTarget.generateContentStream(params);
-                } catch (err) {
-                  throw err;
-                }
+                const streamResult = await mTarget.generateContentStream(params);
                 streamResult.response.then((res) => {
                   const meta = res.usageMetadata;
                   tracker.track({