@diogonzafe/tokenwatch 0.1.0

package/dist/index.cjs

@@ -0,0 +1,599 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  createTracker: () => createTracker,
+  wrapAnthropic: () => wrapAnthropic,
+  wrapDeepSeek: () => wrapOpenAI,
+  wrapGemini: () => wrapGemini,
+  wrapOpenAI: () => wrapOpenAI
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/core/tracker.ts
+var import_zod = require("zod");
+
+// src/core/pricing.ts
+function resolvePrice(model, layers) {
+  const { customPrices, remotePrices, bundledPrices: bundledPrices2 } = layers;
+  const found = lookupInMap(model, customPrices) ?? lookupInMap(model, remotePrices) ?? lookupInMap(model, bundledPrices2);
+  if (found) return found;
+  console.warn(
+    `[tokenwatch] Unknown model "${model}". Cost will be recorded as $0. Add it via customPrices or update prices with: tokenwatch sync`
+  );
+  return { input: 0, output: 0 };
+}
+function lookupInMap(model, map) {
+  if (!map) return void 0;
+  if (model in map) return map[model];
+  for (const key of Object.keys(map)) {
+    if (model.startsWith(key) || key.startsWith(model)) {
+      return map[key];
+    }
+  }
+  return void 0;
+}
+function calculateCost(inputTokens, outputTokens, price) {
+  return inputTokens / 1e6 * price.input + outputTokens / 1e6 * price.output;
+}
+
+// src/core/storage.ts
+var import_node_module = require("module");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var import_node_fs = require("fs");
+var import_meta = {};
+var MemoryStorage = class {
+  entries = [];
+  record(entry) {
+    this.entries.push(entry);
+  }
+  getAll() {
+    return [...this.entries];
+  }
+  clearAll() {
+    this.entries = [];
+  }
+  clearSession(sessionId) {
+    this.entries = this.entries.filter((e) => e.sessionId !== sessionId);
+  }
+};
+var DB_DIR = (0, import_node_path.join)((0, import_node_os.homedir)(), ".tokenwatch");
+var DB_PATH = (0, import_node_path.join)(DB_DIR, "usage.db");
+var SqliteStorage = class {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  db;
+  constructor(dbPath = DB_PATH) {
+    let BetterSqlite3;
+    try {
+      const req = typeof globalThis.require === "function" ? (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        globalThis.require
+      ) : (0, import_node_module.createRequire)(import_meta.url);
+      BetterSqlite3 = req("better-sqlite3");
+    } catch {
+      throw new Error(
+        "[tokenwatch] SQLite storage requires better-sqlite3. Run: npm install better-sqlite3"
+      );
+    }
+    (0, import_node_fs.mkdirSync)(DB_DIR, { recursive: true });
+    this.db = new BetterSqlite3(dbPath);
+    this.migrate();
+  }
+  migrate() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS usage (
+        id            INTEGER PRIMARY KEY AUTOINCREMENT,
+        model         TEXT    NOT NULL,
+        input_tokens  INTEGER NOT NULL,
+        output_tokens INTEGER NOT NULL,
+        cost_usd      REAL    NOT NULL,
+        session_id    TEXT,
+        user_id       TEXT,
+        timestamp     TEXT    NOT NULL
+      )
+    `);
+  }
+  record(entry) {
+    this.db.prepare(
+      `INSERT INTO usage
+         (model, input_tokens, output_tokens, cost_usd, session_id, user_id, timestamp)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      entry.model,
+      entry.inputTokens,
+      entry.outputTokens,
+      entry.costUSD,
+      entry.sessionId ?? null,
+      entry.userId ?? null,
+      entry.timestamp
+    );
+  }
+  getAll() {
+    const rows = this.db.prepare("SELECT * FROM usage").all();
+    return rows.map((r) => ({
+      model: r.model,
+      inputTokens: r.input_tokens,
+      outputTokens: r.output_tokens,
+      costUSD: r.cost_usd,
+      ...r.session_id != null && { sessionId: r.session_id },
+      ...r.user_id != null && { userId: r.user_id },
+      timestamp: r.timestamp
+    }));
+  }
+  clearAll() {
+    this.db.exec("DELETE FROM usage");
+  }
+  clearSession(sessionId) {
+    this.db.prepare("DELETE FROM usage WHERE session_id = ?").run(sessionId);
+  }
+};
+function createStorage(type) {
+  if (type === "sqlite") return new SqliteStorage();
+  return new MemoryStorage();
+}
+
+// src/core/sync.ts
+var import_promises = require("fs/promises");
+var import_node_fs2 = require("fs");
+var import_node_os2 = require("os");
+var import_node_path2 = require("path");
+var CACHE_DIR = (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".tokenwatch");
+var CACHE_FILE = (0, import_node_path2.join)(CACHE_DIR, "prices.json");
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var REMOTE_URL = "https://raw.githubusercontent.com/diogonzafe/tokenwatch/main/prices.json";
+async function fetchRemotePrices(url = REMOTE_URL) {
+  try {
+    const res = await fetch(url, { signal: AbortSignal.timeout(8e3) });
+    if (!res.ok) return null;
+    const data = await res.json();
+    if (!data?.models) return null;
+    await persistCache(data);
+    return data.models;
+  } catch {
+    return null;
+  }
+}
+async function loadCachedPrices() {
+  if (!(0, import_node_fs2.existsSync)(CACHE_FILE)) return null;
+  try {
+    const raw = await (0, import_promises.readFile)(CACHE_FILE, "utf8");
+    const data = JSON.parse(raw);
+    const age = Date.now() - (data._cachedAt ?? 0);
+    if (age > CACHE_TTL_MS) return null;
+    return data.models ?? null;
+  } catch {
+    return null;
+  }
+}
+async function persistCache(data) {
+  try {
+    await (0, import_promises.mkdir)(CACHE_DIR, { recursive: true });
+    const payload = { ...data, _cachedAt: Date.now() };
+    await (0, import_promises.writeFile)(CACHE_FILE, JSON.stringify(payload, null, 2), "utf8");
+  } catch {
+  }
+}
+async function getRemotePrices() {
+  const cached = await loadCachedPrices();
+  if (cached) return cached;
+  return fetchRemotePrices();
+}
+
+// prices.json
+var prices_default = {
+  updated_at: "2026-04-16",
+  source: "https://raw.githubusercontent.com/diogonzafe/tokenwatch/main/prices.json",
+  models: {
+    "gpt-4o": { input: 2.5, output: 10 },
+    "gpt-4o-mini": { input: 0.15, output: 0.6 },
+    "gpt-5": { input: 1.25, output: 10 },
+    "gpt-5-mini": { input: 0.25, output: 2 },
+    "gpt-5-nano": { input: 0.05, output: 0.4 },
+    "claude-opus-4-6": { input: 5, output: 25 },
+    "claude-sonnet-4-6": { input: 3, output: 15 },
+    "claude-haiku-4-5": { input: 1, output: 5 },
+    "gemini-2.5-pro": { input: 1.25, output: 10 },
+    "gemini-2.5-flash": { input: 0.3, output: 2.5 },
+    "deepseek-chat": { input: 0.28, output: 0.42 },
+    "deepseek-reasoner": { input: 0.55, output: 2.19 }
+  }
+};
+
+// src/core/tracker.ts
+var bundledPrices = prices_default.models;
+var ModelPriceSchema = import_zod.z.object({
+  input: import_zod.z.number().nonnegative(),
+  output: import_zod.z.number().nonnegative()
+});
+var TrackerConfigSchema = import_zod.z.object({
+  storage: import_zod.z.enum(["memory", "sqlite"]).optional().default("memory"),
+  alertThreshold: import_zod.z.number().positive().optional(),
+  webhookUrl: import_zod.z.string().url().optional(),
+  syncPrices: import_zod.z.boolean().optional().default(true),
+  customPrices: import_zod.z.record(import_zod.z.string(), ModelPriceSchema).optional()
+});
+function createTracker(config = {}) {
+  const parsed = TrackerConfigSchema.safeParse(config);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new Error(`[tokenwatch] Invalid config:
+${issues}`);
+  }
+  const {
+    storage: storageType,
+    alertThreshold,
+    webhookUrl,
+    syncPrices,
+    customPrices
+  } = parsed.data;
+  const storage = createStorage(storageType);
+  let remotePrices;
+  if (syncPrices) {
+    getRemotePrices().then((result) => {
+      if (result) remotePrices = result;
+    }).catch(() => {
+    });
+  }
+  let alertFired = false;
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  function resolveModelPrice(model) {
+    return resolvePrice(model, {
+      bundledPrices,
+      ...customPrices !== void 0 && { customPrices },
+      ...remotePrices !== void 0 && { remotePrices }
+    });
+  }
+  function track(entry) {
+    const price = resolveModelPrice(entry.model);
+    const costUSD = calculateCost(entry.inputTokens, entry.outputTokens, price);
+    const full = {
+      ...entry,
+      costUSD,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    storage.record(full);
+    maybeFireAlert();
+  }
+  function maybeFireAlert() {
+    if (!alertThreshold || !webhookUrl || alertFired) return;
+    const total = computeTotal(storage.getAll());
+    if (total >= alertThreshold) {
+      alertFired = true;
+      const payload = {
+        text: `[tokenwatch] Alert: total cost reached $${total.toFixed(4)} USD (threshold: $${alertThreshold})`
+      };
+      fetch(webhookUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload)
+      }).catch(() => {
+      });
+    }
+  }
+  function getReport() {
+    const entries = storage.getAll();
+    const byModel = {};
+    const bySession = {};
+    const byUser = {};
+    let totalInput = 0;
+    let totalOutput = 0;
+    let totalCost = 0;
+    let lastTimestamp = startedAt;
+    for (const e of entries) {
+      totalInput += e.inputTokens;
+      totalOutput += e.outputTokens;
+      totalCost += e.costUSD;
+      if (e.timestamp > lastTimestamp) lastTimestamp = e.timestamp;
+      const m = byModel[e.model] ??= { costUSD: 0, calls: 0, tokens: { input: 0, output: 0 } };
+      m.costUSD += e.costUSD;
+      m.calls += 1;
+      m.tokens.input += e.inputTokens;
+      m.tokens.output += e.outputTokens;
+      if (e.sessionId) {
+        const s = bySession[e.sessionId] ??= { costUSD: 0, calls: 0 };
+        s.costUSD += e.costUSD;
+        s.calls += 1;
+      }
+      if (e.userId) {
+        const u = byUser[e.userId] ??= { costUSD: 0, calls: 0 };
+        u.costUSD += e.costUSD;
+        u.calls += 1;
+      }
+    }
+    return {
+      totalCostUSD: totalCost,
+      totalTokens: { input: totalInput, output: totalOutput },
+      byModel,
+      bySession,
+      byUser,
+      period: { from: startedAt, to: lastTimestamp }
+    };
+  }
+  function reset() {
+    storage.clearAll();
+    alertFired = false;
+  }
+  function resetSession(sessionId) {
+    storage.clearSession(sessionId);
+  }
+  function exportJSON() {
+    return JSON.stringify(getReport(), null, 2);
+  }
+  function exportCSV() {
+    const entries = storage.getAll();
+    const header = "timestamp,model,inputTokens,outputTokens,costUSD,sessionId,userId";
+    const rows = entries.map(
+      (e) => [
+        e.timestamp,
+        e.model,
+        e.inputTokens,
+        e.outputTokens,
+        e.costUSD.toFixed(8),
+        e.sessionId ?? "",
+        e.userId ?? ""
+      ].join(",")
+    );
+    return [header, ...rows].join("\n");
+  }
+  return { track, getReport, reset, resetSession, exportJSON, exportCSV };
+}
+function computeTotal(entries) {
+  return entries.reduce((sum, e) => sum + e.costUSD, 0);
+}
+
+// src/providers/openai.ts
+function extractMeta(params) {
+  const { __sessionId, __userId, ...cleaned } = params;
+  return {
+    cleaned,
+    sessionId: typeof __sessionId === "string" ? __sessionId : void 0,
+    userId: typeof __userId === "string" ? __userId : void 0
+  };
+}
+function extractUsage(usage) {
+  if (!usage) return { inputTokens: 0, outputTokens: 0 };
+  return {
+    inputTokens: usage.prompt_tokens ?? usage.input_tokens ?? 0,
+    outputTokens: usage.completion_tokens ?? usage.output_tokens ?? 0
+  };
+}
+function trackWithMeta(tracker, model, inputTokens, outputTokens, sessionId, userId) {
+  tracker.track({
+    model,
+    inputTokens,
+    outputTokens,
+    ...sessionId !== void 0 && { sessionId },
+    ...userId !== void 0 && { userId }
+  });
+}
+async function* wrapStream(stream, model, sessionId, userId, tracker) {
+  let lastChunk;
+  for await (const chunk of stream) {
+    lastChunk = chunk;
+    yield chunk;
+  }
+  if (lastChunk?.usage) {
+    const { inputTokens, outputTokens } = extractUsage(lastChunk.usage);
+    trackWithMeta(tracker, model, inputTokens, outputTokens, sessionId, userId);
+  }
+}
+function wrapOpenAI(client, tracker) {
+  const proxiedCompletions = new Proxy(client.chat.completions, {
+    get(target, prop) {
+      if (prop !== "create")
+        return target[prop];
+      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;
+        }
+        if (result && typeof result === "object" && Symbol.asyncIterator in result) {
+          return wrapStream(
+            result,
+            model,
+            sessionId,
+            userId,
+            tracker
+          );
+        }
+        const completion = result;
+        const { inputTokens, outputTokens } = extractUsage(completion.usage);
+        trackWithMeta(
+          tracker,
+          completion.model ?? model,
+          inputTokens,
+          outputTokens,
+          sessionId,
+          userId
+        );
+        return result;
+      };
+    }
+  });
+  const proxiedChat = new Proxy(client.chat, {
+    get(target, prop) {
+      if (prop === "completions") return proxiedCompletions;
+      return target[prop];
+    }
+  });
+  return new Proxy(client, {
+    get(target, prop) {
+      if (prop === "chat") return proxiedChat;
+      return target[prop];
+    }
+  });
+}
+
+// src/providers/anthropic.ts
+function extractMeta2(params) {
+  const { __sessionId, __userId, ...cleaned } = params;
+  return {
+    cleaned,
+    sessionId: typeof __sessionId === "string" ? __sessionId : void 0,
+    userId: typeof __userId === "string" ? __userId : void 0
+  };
+}
+function extractUsage2(usage) {
+  if (!usage) return { inputTokens: 0, outputTokens: 0 };
+  return {
+    inputTokens: usage.input_tokens ?? 0,
+    outputTokens: usage.output_tokens ?? 0
+  };
+}
+function trackWithMeta2(tracker, model, inputTokens, outputTokens, sessionId, userId) {
+  tracker.track({
+    model,
+    inputTokens,
+    outputTokens,
+    ...sessionId !== void 0 && { sessionId },
+    ...userId !== void 0 && { userId }
+  });
+}
+async function* wrapStream2(stream, model, sessionId, userId, tracker) {
+  let inputTokens = 0;
+  let outputTokens = 0;
+  for await (const event of stream) {
+    yield event;
+    if (event.type === "message_start" && event.message?.usage) {
+      inputTokens = event.message.usage.input_tokens ?? 0;
+    }
+    if (event.type === "message_delta" && event.usage) {
+      outputTokens = event.usage.output_tokens ?? 0;
+    }
+  }
+  if (inputTokens > 0 || outputTokens > 0) {
+    trackWithMeta2(tracker, model, inputTokens, outputTokens, sessionId, userId);
+  }
+}
+function wrapAnthropic(client, tracker) {
+  const proxiedMessages = new Proxy(client.messages, {
+    get(target, prop) {
+      if (prop !== "create")
+        return target[prop];
+      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;
+        }
+        if (result && typeof result === "object" && Symbol.asyncIterator in result) {
+          return wrapStream2(
+            result,
+            model,
+            sessionId,
+            userId,
+            tracker
+          );
+        }
+        const message = result;
+        const { inputTokens, outputTokens } = extractUsage2(message.usage);
+        trackWithMeta2(
+          tracker,
+          message.model ?? model,
+          inputTokens,
+          outputTokens,
+          sessionId,
+          userId
+        );
+        return result;
+      };
+    }
+  });
+  return new Proxy(client, {
+    get(target, prop) {
+      if (prop === "messages") return proxiedMessages;
+      return target[prop];
+    }
+  });
+}
+
+// src/providers/gemini.ts
+function wrapGemini(client, tracker) {
+  return new Proxy(client, {
+    get(target, prop) {
+      if (prop !== "getGenerativeModel")
+        return target[prop];
+      return function(modelParams) {
+        const modelInstance = target.getGenerativeModel(modelParams);
+        const modelId = modelParams.model;
+        return new Proxy(modelInstance, {
+          get(mTarget, mProp) {
+            if (mProp === "generateContent") {
+              return async function(params) {
+                let result;
+                try {
+                  result = await mTarget.generateContent(params);
+                } catch (err) {
+                  throw err;
+                }
+                const meta = result.response.usageMetadata;
+                tracker.track({
+                  model: modelId,
+                  inputTokens: meta?.promptTokenCount ?? 0,
+                  outputTokens: meta?.candidatesTokenCount ?? 0
+                });
+                return result;
+              };
+            }
+            if (mProp === "generateContentStream") {
+              return async function(params) {
+                let streamResult;
+                try {
+                  streamResult = await mTarget.generateContentStream(params);
+                } catch (err) {
+                  throw err;
+                }
+                streamResult.response.then((res) => {
+                  const meta = res.usageMetadata;
+                  tracker.track({
+                    model: modelId,
+                    inputTokens: meta?.promptTokenCount ?? 0,
+                    outputTokens: meta?.candidatesTokenCount ?? 0
+                  });
+                }).catch(() => {
+                });
+                return streamResult;
+              };
+            }
+            return mTarget[mProp];
+          }
+        });
+      };
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTracker,
+  wrapAnthropic,
+  wrapDeepSeek,
+  wrapGemini,
+  wrapOpenAI
+});
+//# sourceMappingURL=index.cjs.map