@kalaa/node 1.0.3 → 1.0.5

package/costmeter.js

@@ -1,26 +1,8 @@
-// ═══════════════════════════════════════════════════════════════════
-//  costmeter.js — drop-in AI cost tracking SDK
-//
-//  Two-line setup, paste anywhere, order doesn't matter:
-//
-//     const costmeter = require('costmeter');
-//     costmeter.observe();
-//
-//  Put COSTMETER_KEY=cm_live_xxx in your .env and you're done.
-//
-//  observe() patches the OpenAI module at the class level (so any client
-//  you create, whenever you create it, is already instrumented) and, if
-//  Express is installed, auto-inserts route-attribution middleware. No
-//  app.use, no "after express.json", no manual instrument call.
-//
-//  It never touches a database, never computes cost, and never sits in
-//  the path of your AI calls — if ingest is unreachable, events are
-//  dropped silently and your app is unaffected.
-// ═══════════════════════════════════════════════════════════════════
-
 const { AsyncLocalStorage } = require('async_hooks');
 const crypto = require('crypto');
 const http = require('http');
+const { Worker } = require('worker_threads');
+const path = require('path');
 
 const als = new AsyncLocalStorage();
 
@@ -181,38 +163,58 @@ function getOrSetAnonId(req) {
   }
   return null;
 }
-// Best-effort byte size of the audio input, without reading the whole file.
-// Real duration from the audio container's own metadata (wav/mp3/m4a/webm all
-// expose this in their header — no decoding, no guessing). This is the
-// actual value Whisper bills against, just read client-side instead of
-// waiting for the API to hand it back (which it only does with verbose_json).
+
 async function getRealAudioDuration(file) {
-  let mm;
-  try { mm = require('music-metadata'); } catch { return null; } // not installed — degrade below
+  let input;
   try {
-    let metadata;
     if (Buffer.isBuffer(file)) {
-      metadata = await mm.parseBuffer(file);
+      input = { type: 'buffer', data: file };
     } else if (file?.path) {
-      metadata = await mm.parseFile(file.path);
+      input = { type: 'path', data: file.path };
     } else if (file?.arrayBuffer) { // Blob/File
-      const buf = Buffer.from(await file.arrayBuffer());
-      metadata = await mm.parseBuffer(buf);
+      input = { type: 'buffer', data: Buffer.from(await file.arrayBuffer()) };
     } else {
       return null;
     }
-    const seconds = metadata?.format?.duration;
-    return typeof seconds === 'number' && seconds > 0 ? Math.round(seconds) : null;
   } catch (e) {
     log('duration read failed:', e.message);
     return null;
   }
+
+  
+  return new Promise((resolve) => {
+    let settled = false;
+    let worker;
+    try {
+      worker = new Worker(path.join(__dirname, 'duration-worker.js'), { workerData: input });
+    } catch (e) {
+      log('duration worker spawn failed:', e.message);
+      return resolve(null);
+    }
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      worker.terminate();
+      log('duration worker timed out — likely a malformed file, degrading to null');
+      resolve(null);
+    }, 3000);
+    worker.once('message', (msg) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      worker.terminate();
+      resolve(msg?.seconds ?? null);
+    });
+    worker.once('error', () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(null);
+    });
+  });
 }
 
-// Rough seconds-from-bytes estimate. Whisper input is typically compressed
-// (mp3/m4a) around ~128kbps voice audio ≈ 16KB/sec. This is intentionally
-// conservative — good enough for cost visibility, not billing-grade exact.
-// ── USAGE NORMALIZATION (raw tokens only — backend prices) ──────────
+
 function normalizeUsage(provider, usage = {}) {
   if (provider === 'anthropic') {
     return {
@@ -260,9 +262,7 @@ function track({ step, provider = 'openai', model = '', usage = {}, latencyMs =
   } catch (err) { log('track error:', err.message); }
 }
 
-// Wraps a streaming completion so usage is captured on completion, without
-// altering what the caller receives — every chunk still flows through
-// exactly as OpenAI sent it.
+
 function wrapStreamForUsage(streamPromise, { _step, _user, model, t0 }) {
   return streamPromise.then(stream => {
     const origIterator = stream[Symbol.asyncIterator].bind(stream);
@@ -301,10 +301,7 @@ function wrapStreamForUsage(streamPromise, { _step, _user, model, t0 }) {
   });
 }
 
-// Anthropic streams usage across two events, not one: message_start carries
-// input_tokens, message_delta carries the final output_tokens. Same tap
-// pattern as OpenAI — caller's iteration is untouched, we just watch what
-// passes through.
+
 function wrapAnthropicStreamForUsage(stream, { _step, _user, model, t0 }) {
   const origIterator = stream[Symbol.asyncIterator].bind(stream);
   let inputTokens = 0, cachedTokens = 0, cacheWriteTokens = 0, outputTokens = 0;
@@ -354,20 +351,15 @@ function wrapAnthropicStreamForUsage(stream, { _step, _user, model, t0 }) {
   return stream;
 }
 
-// ── MODULE-LEVEL PATCHING (order-independent instrumentation) ───────
-// Patches the OpenAI class prototype so EVERY client — created before or
-// after observe() — is instrumented. No need to hand us the client.
 function patchOpenAIModule() {
   let OpenAIMod;
-  try { OpenAIMod = require('openai'); } catch { return; } // not installed, skip
+  try { OpenAIMod = require('openai'); } catch (e) { log('openai require() failed:', e.message); return; }
+  log('openai require() succeeded, module keys:', Object.keys(OpenAIMod).slice(0, 10).join(','));
   const OpenAI = OpenAIMod.OpenAI || OpenAIMod.default || OpenAIMod;
-  if (!OpenAI || typeof OpenAI !== 'function') return;
-  if (OpenAI.__cm_patched) return;
+  if (!OpenAI || typeof OpenAI !== 'function') { log('openai class did not resolve to a function, typeof:', typeof OpenAI); return; }
+  if (OpenAI.__cm_patched) { log('openai already patched, skipping'); return; }
+
 
-  // The create() methods live on the Completions / Transcriptions class
-  // PROTOTYPES, not on each instance. Patch the prototype ONCE and every
-  // client — created before or after observe() — inherits the wrapper.
-  // We spin up a throwaway client (no network) just to reach those classes.
   let Completions, Transcriptions;
   try {
     const probe = new OpenAI({ apiKey: 'cm_probe' });
@@ -441,11 +433,7 @@ function patchAnthropicModule() {
   if (!Anthropic || typeof Anthropic !== 'function') return;
   if (Anthropic.__cm_patched) return;
 
-  // Same strategy as OpenAI: messages.create() lives on the Messages class
-  // PROTOTYPE. Patch it once and every client — constructed before or after
-  // observe(), via any import style — inherits the wrapper. No constructor
-  // swapping: the SDK's module exports are non-writable, so reassigning
-  // Mod.Anthropic silently does nothing.
+
   let Messages;
   try {
     const probe = new Anthropic({ apiKey: 'cm_probe' });

package/package.json

@@ -1,6 +1,6 @@
 {
 "name": "@kalaa/node",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Drop-in AI cost tracking for Node.js and TypeScript. Auto-instruments OpenAI, Anthropic, and Gemini at the class level, with zero code at each call site.",
   "main": "costmeter.js",
   "types": "costmeter.d.ts",