@diogonzafe/tokenwatch 0.1.17 → 0.2.1

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-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';
+import { T as TrackerConfig, a as Tracker, b as TrackingMeta } from './index-B_EmA3K7.js';
+export { F as FeatureStats, 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-B_EmA3K7.js';
 
 declare function createTracker(config?: TrackerConfig): Tracker;
 
@@ -9,23 +9,31 @@ interface CompletionsLike {
 interface ChatLike {
     completions: CompletionsLike;
 }
+interface EmbeddingsLike {
+    create(params: Record<string, unknown>): Promise<unknown>;
+}
 type OpenAILike = {
     chat: ChatLike;
+    embeddings?: EmbeddingsLike;
 } & Record<string, unknown>;
 type AugmentedCreate$1<TCreate extends (...args: any[]) => any> = (params: Parameters<TCreate>[0] & TrackingMeta) => ReturnType<TCreate>;
-type WrappedOpenAI<T extends OpenAILike> = Omit<T, 'chat'> & {
+type WrappedOpenAI<T extends OpenAILike> = Omit<T, 'chat' | 'embeddings'> & {
     chat: Omit<T['chat'], 'completions'> & {
         completions: Omit<T['chat']['completions'], 'create'> & {
             create: AugmentedCreate$1<T['chat']['completions']['create']>;
         };
     };
+    embeddings: T['embeddings'] extends EmbeddingsLike ? Omit<T['embeddings'], 'create'> & {
+        create: AugmentedCreate$1<T['embeddings']['create']>;
+    } : T['embeddings'];
 };
 /**
  * Wraps an OpenAI client (or any OpenAI-compatible client) to transparently
- * intercept chat.completions.create calls and report token usage to the tracker.
+ * intercept chat.completions.create and embeddings.create calls and report
+ * token usage to the tracker.
  *
- * The returned client is typed to accept __sessionId and __userId alongside the
- * normal params — no type cast required at the call site.
+ * The returned client is typed to accept __sessionId, __userId, and __feature
+ * alongside the normal params — no type cast required at the call site.
  */
 declare function wrapOpenAI<T extends OpenAILike>(client: T, tracker: Tracker): WrappedOpenAI<T>;
 
@@ -45,8 +53,12 @@ type WrappedAnthropic<T extends AnthropicLike> = Omit<T, 'messages'> & {
  * Wraps an Anthropic client to transparently intercept messages.create calls
  * and report token usage to the tracker.
  *
- * The returned client is typed to accept __sessionId and __userId alongside the
- * normal params — no type cast required at the call site.
+ * The returned client is typed to accept __sessionId, __userId, and __feature
+ * alongside the normal params — no type cast required at the call site.
+ *
+ * For extended thinking models, reasoningTokens is stored as an approximation
+ * (thinking block characters ÷ 4). It is informational only — thinking output
+ * is already included in outputTokens and is not double-counted in cost.
  */
 declare function wrapAnthropic<T extends AnthropicLike>(client: T, tracker: Tracker): WrappedAnthropic<T>;
 
@@ -79,6 +91,9 @@ interface GenAILike {
  * Wraps a GoogleGenerativeAI client to transparently intercept
  * generateContent / generateContentStream calls and report token usage.
  *
+ * Pass __feature in getGenerativeModel params to tag all calls from that model
+ * instance with a product feature name (appears in report.byFeature).
+ *
  * Returns the same type T that was passed in.
  */
 declare function wrapGemini<T extends GenAILike>(client: T, tracker: Tracker): T;

package/dist/index.js

@@ -74,29 +74,40 @@ var SqliteStorage = class {
   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
+        id               INTEGER PRIMARY KEY AUTOINCREMENT,
+        model            TEXT    NOT NULL,
+        input_tokens     INTEGER NOT NULL,
+        output_tokens    INTEGER NOT NULL,
+        reasoning_tokens INTEGER NOT NULL DEFAULT 0,
+        cost_usd         REAL    NOT NULL,
+        session_id       TEXT,
+        user_id          TEXT,
+        feature          TEXT,
+        timestamp        TEXT    NOT NULL
       )
     `);
+    const cols = this.db.prepare(`PRAGMA table_info(usage)`).all().map((c) => c.name);
+    if (!cols.includes("reasoning_tokens")) {
+      this.db.exec(`ALTER TABLE usage ADD COLUMN reasoning_tokens INTEGER NOT NULL DEFAULT 0`);
+    }
+    if (!cols.includes("feature")) {
+      this.db.exec(`ALTER TABLE usage ADD COLUMN feature TEXT`);
+    }
   }
   record(entry) {
     this.db.prepare(
       `INSERT INTO usage
-         (model, input_tokens, output_tokens, cost_usd, session_id, user_id, timestamp)
-         VALUES (?, ?, ?, ?, ?, ?, ?)`
+         (model, input_tokens, output_tokens, reasoning_tokens, cost_usd, session_id, user_id, feature, timestamp)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
     ).run(
       entry.model,
       entry.inputTokens,
       entry.outputTokens,
+      entry.reasoningTokens ?? 0,
       entry.costUSD,
       entry.sessionId ?? null,
       entry.userId ?? null,
+      entry.feature ?? null,
       entry.timestamp
     );
   }
@@ -106,9 +117,11 @@ var SqliteStorage = class {
       model: r.model,
       inputTokens: r.input_tokens,
       outputTokens: r.output_tokens,
+      ...r.reasoning_tokens > 0 && { reasoningTokens: r.reasoning_tokens },
       costUSD: r.cost_usd,
       ...r.session_id != null && { sessionId: r.session_id },
       ...r.user_id != null && { userId: r.user_id },
+      ...r.feature != null && { feature: r.feature },
       timestamp: r.timestamp
     }));
   }
@@ -1415,6 +1428,7 @@ ${issues}`);
     const byModel = {};
     const bySession = {};
     const byUser = {};
+    const byFeature = {};
     let totalInput = 0;
     let totalOutput = 0;
     let totalCost = 0;
@@ -1424,11 +1438,12 @@ ${issues}`);
       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 } };
+      const m = byModel[e.model] ??= { costUSD: 0, calls: 0, tokens: { input: 0, output: 0, reasoning: 0 } };
       m.costUSD += e.costUSD;
       m.calls += 1;
       m.tokens.input += e.inputTokens;
       m.tokens.output += e.outputTokens;
+      m.tokens.reasoning += e.reasoningTokens ?? 0;
       if (e.sessionId) {
         const s = bySession[e.sessionId] ??= { costUSD: 0, calls: 0 };
         s.costUSD += e.costUSD;
@@ -1439,6 +1454,11 @@ ${issues}`);
         u.costUSD += e.costUSD;
         u.calls += 1;
       }
+      if (e.feature) {
+        const f = byFeature[e.feature] ??= { costUSD: 0, calls: 0 };
+        f.costUSD += e.costUSD;
+        f.calls += 1;
+      }
     }
     return {
       totalCostUSD: totalCost,
@@ -1446,6 +1466,7 @@ ${issues}`);
       byModel,
       bySession,
       byUser,
+      byFeature,
       period: { from: startedAt, to: lastTimestamp }
     };
   }
@@ -1461,16 +1482,18 @@ ${issues}`);
   }
   async function exportCSV() {
     const entries = await Promise.resolve(storage.getAll());
-    const header = "timestamp,model,inputTokens,outputTokens,costUSD,sessionId,userId";
+    const header = "timestamp,model,inputTokens,outputTokens,reasoningTokens,costUSD,sessionId,userId,feature";
     const rows = entries.map(
       (e) => [
         csvEscape(e.timestamp),
         csvEscape(e.model),
         e.inputTokens,
         e.outputTokens,
+        e.reasoningTokens ?? 0,
         e.costUSD.toFixed(8),
         csvEscape(e.sessionId ?? ""),
-        csvEscape(e.userId ?? "")
+        csvEscape(e.userId ?? ""),
+        csvEscape(e.feature ?? "")
       ].join(",")
     );
     return [header, ...rows].join("\n");
@@ -1496,42 +1519,46 @@ function csvEscape(value) {
 
 // src/providers/openai.ts
 function extractMeta(params) {
-  const { __sessionId, __userId, ...cleaned } = params;
+  const { __sessionId, __userId, __feature, ...cleaned } = params;
   return {
     cleaned,
     sessionId: typeof __sessionId === "string" ? __sessionId : void 0,
-    userId: typeof __userId === "string" ? __userId : void 0
+    userId: typeof __userId === "string" ? __userId : void 0,
+    feature: typeof __feature === "string" ? __feature : void 0
   };
 }
 function extractUsage(usage) {
-  if (!usage) return { inputTokens: 0, outputTokens: 0 };
+  if (!usage) return { inputTokens: 0, outputTokens: 0, reasoningTokens: 0 };
   return {
     inputTokens: usage.prompt_tokens ?? usage.input_tokens ?? 0,
-    outputTokens: usage.completion_tokens ?? usage.output_tokens ?? 0
+    outputTokens: usage.completion_tokens ?? usage.output_tokens ?? 0,
+    reasoningTokens: usage.completion_tokens_details?.reasoning_tokens ?? 0
   };
 }
-function trackWithMeta(tracker, model, inputTokens, outputTokens, sessionId, userId) {
+function trackWithMeta(tracker, model, inputTokens, outputTokens, reasoningTokens, sessionId, userId, feature) {
   tracker.track({
     model,
     inputTokens,
-    outputTokens,
+    outputTokens: outputTokens + reasoningTokens,
+    ...reasoningTokens > 0 && { reasoningTokens },
     ...sessionId !== void 0 && { sessionId },
-    ...userId !== void 0 && { userId }
+    ...userId !== void 0 && { userId },
+    ...feature !== void 0 && { feature }
   });
 }
-async function* wrapStream(stream, model, sessionId, userId, tracker) {
+async function* wrapStream(stream, model, sessionId, userId, feature, tracker) {
   let lastChunk;
   for await (const chunk of stream) {
     lastChunk = chunk;
     yield chunk;
   }
-  const { inputTokens, outputTokens } = extractUsage(lastChunk?.usage);
+  const { inputTokens, outputTokens, reasoningTokens } = extractUsage(lastChunk?.usage);
   if (!lastChunk?.usage) {
     console.warn(
       `[tokenwatch] No usage data in stream for model "${model}". Cost recorded as $0. Pass stream_options: { include_usage: true } to get accurate costs.`
     );
   }
-  trackWithMeta(tracker, model, inputTokens, outputTokens, sessionId, userId);
+  trackWithMeta(tracker, model, inputTokens, outputTokens, reasoningTokens, sessionId, userId, feature);
 }
 function wrapOpenAI(client, tracker) {
   const proxiedCompletions = new Proxy(client.chat.completions, {
@@ -1539,7 +1566,7 @@ function wrapOpenAI(client, tracker) {
       if (prop !== "create")
         return target[prop];
       return async function(params) {
-        const { cleaned, sessionId, userId } = extractMeta(params);
+        const { cleaned, sessionId, userId, feature } = extractMeta(params);
         const model = typeof cleaned["model"] === "string" ? cleaned["model"] : "unknown";
         const result = await target.create(cleaned);
         if (result && typeof result === "object" && Symbol.asyncIterator in result) {
@@ -1548,18 +1575,21 @@ function wrapOpenAI(client, tracker) {
             model,
             sessionId,
             userId,
+            feature,
             tracker
           );
         }
         const completion = result;
-        const { inputTokens, outputTokens } = extractUsage(completion.usage);
+        const { inputTokens, outputTokens, reasoningTokens } = extractUsage(completion.usage);
         trackWithMeta(
           tracker,
           completion.model ?? model,
           inputTokens,
           outputTokens,
+          reasoningTokens,
           sessionId,
-          userId
+          userId,
+          feature
         );
         return result;
       };
@@ -1571,9 +1601,25 @@ function wrapOpenAI(client, tracker) {
       return target[prop];
     }
   });
+  const proxiedEmbeddings = client.embeddings ? new Proxy(client.embeddings, {
+    get(target, prop) {
+      if (prop !== "create")
+        return target[prop];
+      return async function(params) {
+        const { cleaned, sessionId, userId, feature } = extractMeta(params);
+        const model = typeof cleaned["model"] === "string" ? cleaned["model"] : "unknown";
+        const result = await target.create(cleaned);
+        const embedding = result;
+        const inputTokens = embedding.usage?.total_tokens ?? 0;
+        trackWithMeta(tracker, embedding.model ?? model, inputTokens, 0, 0, sessionId, userId, feature);
+        return result;
+      };
+    }
+  }) : void 0;
   return new Proxy(client, {
     get(target, prop) {
       if (prop === "chat") return proxiedChat;
+      if (prop === "embeddings") return proxiedEmbeddings;
       return target[prop];
     }
   });
@@ -1581,11 +1627,12 @@ function wrapOpenAI(client, tracker) {
 
 // src/providers/anthropic.ts
 function extractMeta2(params) {
-  const { __sessionId, __userId, ...cleaned } = params;
+  const { __sessionId, __userId, __feature, ...cleaned } = params;
   return {
     cleaned,
     sessionId: typeof __sessionId === "string" ? __sessionId : void 0,
-    userId: typeof __userId === "string" ? __userId : void 0
+    userId: typeof __userId === "string" ? __userId : void 0,
+    feature: typeof __feature === "string" ? __feature : void 0
   };
 }
 function extractUsage2(usage) {
@@ -1595,18 +1642,27 @@ function extractUsage2(usage) {
     outputTokens: usage.output_tokens ?? 0
   };
 }
-function trackWithMeta2(tracker, model, inputTokens, outputTokens, sessionId, userId) {
+function extractThinkingTokenApprox(content) {
+  if (!content) return 0;
+  const chars = content.filter((b) => b.type === "thinking").reduce((sum, b) => sum + (b.thinking?.length ?? 0), 0);
+  return chars > 0 ? Math.round(chars / 4) : 0;
+}
+function trackWithMeta2(tracker, model, inputTokens, outputTokens, reasoningTokens, sessionId, userId, feature) {
   tracker.track({
     model,
     inputTokens,
     outputTokens,
+    ...reasoningTokens > 0 && { reasoningTokens },
     ...sessionId !== void 0 && { sessionId },
-    ...userId !== void 0 && { userId }
+    ...userId !== void 0 && { userId },
+    ...feature !== void 0 && { feature }
   });
 }
-async function* wrapStream2(stream, model, sessionId, userId, tracker) {
+async function* wrapStream2(stream, model, sessionId, userId, feature, tracker) {
   let inputTokens = 0;
   let outputTokens = 0;
+  let currentBlockIsThinking = false;
+  let thinkingCharCount = 0;
   for await (const event of stream) {
     yield event;
     if (event.type === "message_start" && event.message?.usage) {
@@ -1615,8 +1671,18 @@ async function* wrapStream2(stream, model, sessionId, userId, tracker) {
     if (event.type === "message_delta" && event.usage) {
       outputTokens = event.usage.output_tokens ?? 0;
     }
+    if (event.type === "content_block_start") {
+      currentBlockIsThinking = event.content_block?.type === "thinking";
+    }
+    if (event.type === "content_block_stop") {
+      currentBlockIsThinking = false;
+    }
+    if (event.type === "content_block_delta" && currentBlockIsThinking && event.delta?.thinking) {
+      thinkingCharCount += event.delta.thinking.length;
+    }
   }
-  trackWithMeta2(tracker, model, inputTokens, outputTokens, sessionId, userId);
+  const reasoningTokens = thinkingCharCount > 0 ? Math.round(thinkingCharCount / 4) : 0;
+  trackWithMeta2(tracker, model, inputTokens, outputTokens, reasoningTokens, sessionId, userId, feature);
 }
 function wrapAnthropic(client, tracker) {
   const proxiedMessages = new Proxy(client.messages, {
@@ -1624,7 +1690,7 @@ function wrapAnthropic(client, tracker) {
       if (prop !== "create")
         return target[prop];
       return async function(params) {
-        const { cleaned, sessionId, userId } = extractMeta2(params);
+        const { cleaned, sessionId, userId, feature } = extractMeta2(params);
         const model = typeof cleaned["model"] === "string" ? cleaned["model"] : "unknown";
         const result = await target.create(cleaned);
         if (result && typeof result === "object" && Symbol.asyncIterator in result) {
@@ -1633,18 +1699,22 @@ function wrapAnthropic(client, tracker) {
             model,
             sessionId,
             userId,
+            feature,
             tracker
           );
         }
         const message = result;
         const { inputTokens, outputTokens } = extractUsage2(message.usage);
+        const reasoningTokens = extractThinkingTokenApprox(message.content);
         trackWithMeta2(
           tracker,
           message.model ?? model,
           inputTokens,
           outputTokens,
+          reasoningTokens,
           sessionId,
-          userId
+          userId,
+          feature
         );
         return result;
       };
@@ -1665,7 +1735,11 @@ function wrapGemini(client, tracker) {
       if (prop !== "getGenerativeModel")
         return target[prop];
       return function(modelParams) {
-        const modelInstance = target.getGenerativeModel(modelParams);
+        const { __sessionId, __userId, __feature, ...cleanedParams } = modelParams;
+        const feature = typeof __feature === "string" ? __feature : void 0;
+        const sessionId = typeof __sessionId === "string" ? __sessionId : void 0;
+        const userId = typeof __userId === "string" ? __userId : void 0;
+        const modelInstance = target.getGenerativeModel(cleanedParams);
         const modelId = modelParams.model;
         return new Proxy(modelInstance, {
           get(mTarget, mProp) {
@@ -1676,7 +1750,10 @@ function wrapGemini(client, tracker) {
                 tracker.track({
                   model: modelId,
                   inputTokens: meta?.promptTokenCount ?? 0,
-                  outputTokens: meta?.candidatesTokenCount ?? 0
+                  outputTokens: meta?.candidatesTokenCount ?? 0,
+                  ...sessionId !== void 0 && { sessionId },
+                  ...userId !== void 0 && { userId },
+                  ...feature !== void 0 && { feature }
                 });
                 return result;
               };
@@ -1689,7 +1766,10 @@ function wrapGemini(client, tracker) {
                   tracker.track({
                     model: modelId,
                     inputTokens: meta?.promptTokenCount ?? 0,
-                    outputTokens: meta?.candidatesTokenCount ?? 0
+                    outputTokens: meta?.candidatesTokenCount ?? 0,
+                    ...sessionId !== void 0 && { sessionId },
+                    ...userId !== void 0 && { userId },
+                    ...feature !== void 0 && { feature }
                   });
                 }).catch(() => {
                 });