@warpmetrics/warp 0.0.7 → 0.0.9

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Warpmetrics
+Copyright (c) 2026 Warpmetrics
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -105,15 +105,6 @@ ref(response)  // 'wm_call_01jkx3ndef8mn2q7kpvhc4e9ws'
 ref('wm_run_01jkx3ndek0gh4r5tmqp9a3bcv')  // pass-through
 ```
 
-### `cost(target)`
-
-Get the estimated cost in USD for any target. Aggregates across all nested calls for runs and groups.
-
-```js
-cost(response)  // 0.0012
-cost(r)         // 0.0036 (sum of all calls in the run)
-```
-
 ### `flush()`
 
 Manually flush pending events. Events are auto-flushed on an interval and on process exit, but you can force it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@warpmetrics/warp",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "Measure your agents, not your LLM calls.",
   "type": "module",
   "main": "src/index.js",
@@ -18,6 +18,7 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
+    "preversion": "vitest run --coverage",
     "release:patch": "npm version patch && git push origin main --tags",
     "release:minor": "npm version minor && git push origin main --tags"
   },

package/src/core/registry.js

@@ -9,9 +9,3 @@ export const groupRegistry = new Map();
 
 /** @type {WeakMap<object, string>}  LLM response object → call id */
 export const responseRegistry = new WeakMap();
-
-/** @type {WeakMap<object, number>}  LLM response object → cost in USD */
-export const costRegistry = new WeakMap();
-
-/** @type {Map<string, number>}  call id → cost in USD (for aggregation) */
-export const costByCallId = new Map();

package/src/core/transport.js

@@ -21,6 +21,7 @@ const queue = {
   calls: [],
   links: [],
   outcomes: [],
+  acts: [],
 };
 
 let flushTimeout = null;
@@ -44,6 +45,7 @@ export function clearQueue() {
   queue.calls.length = 0;
   queue.links.length = 0;
   queue.outcomes.length = 0;
+  queue.acts.length = 0;
 }
 
 // ---------------------------------------------------------------------------
@@ -56,7 +58,7 @@ function enqueue(type, event) {
   queue[type].push(event);
 
   const total = queue.runs.length + queue.groups.length + queue.calls.length
-    + queue.links.length + queue.outcomes.length;
+    + queue.links.length + queue.outcomes.length + queue.acts.length;
 
   if (total >= config.maxBatchSize) {
     flush();
@@ -81,10 +83,11 @@ export async function flush() {
     calls: queue.calls.splice(0),
     links: queue.links.splice(0),
     outcomes: queue.outcomes.splice(0),
+    acts: queue.acts.splice(0),
   };
 
   const total = batch.runs.length + batch.groups.length + batch.calls.length
-    + batch.links.length + batch.outcomes.length;
+    + batch.links.length + batch.outcomes.length + batch.acts.length;
 
   if (total === 0) return;
 
@@ -100,10 +103,17 @@ export async function flush() {
       `[warpmetrics] Flushing ${total} events`
       + ` (runs=${batch.runs.length} groups=${batch.groups.length}`
       + ` calls=${batch.calls.length} links=${batch.links.length}`
-      + ` outcomes=${batch.outcomes.length})`
+      + ` outcomes=${batch.outcomes.length} acts=${batch.acts.length})`
     );
   }
 
+  const raw = JSON.stringify(batch);
+  const body = JSON.stringify({ d: Buffer.from(raw, 'utf-8').toString('base64') });
+
+  if (config.debug) {
+    console.log(`[warpmetrics] Payload size: ${(raw.length / 1024).toFixed(1)}KB → ${(body.length / 1024).toFixed(1)}KB (encoded)`);
+  }
+
   try {
     const res = await fetch(`${config.baseUrl}/v1/events`, {
       method: 'POST',
@@ -112,7 +122,7 @@ export async function flush() {
         'Authorization': `Bearer ${config.apiKey}`,
         'X-SDK-Version': SDK_VERSION,
       },
-      body: JSON.stringify(batch),
+      body,
     });
 
     if (!res.ok) {
@@ -122,7 +132,8 @@ export async function flush() {
 
     if (config.debug) {
       const result = await res.json();
-      console.log(`[warpmetrics] Flush OK — received=${result.received} processed=${result.processed}`);
+      const d = result.data || result;
+      console.log(`[warpmetrics] Flush OK — received=${d.received} processed=${d.processed}`);
     }
   } catch (err) {
     if (config.debug) {
@@ -134,6 +145,7 @@ export async function flush() {
     queue.calls.unshift(...batch.calls);
     queue.links.unshift(...batch.links);
     queue.outcomes.unshift(...batch.outcomes);
+    queue.acts.unshift(...batch.acts);
   }
 }
 
@@ -185,6 +197,15 @@ export function logOutcome(data) {
   });
 }
 
+export function logAct(data) {
+  enqueue('acts', {
+    targetId: data.targetId,
+    name: data.name,
+    metadata: data.metadata,
+    timestamp: new Date().toISOString(),
+  });
+}
+
 // ---------------------------------------------------------------------------
 // Auto-flush on process exit (Node.js only)
 // ---------------------------------------------------------------------------

package/src/core/utils.js

@@ -13,46 +13,3 @@ export function generateId(prefix) {
   return `wm_${prefix}_${ulid().toLowerCase()}`;
 }
 
-// ---------------------------------------------------------------------------
-// Pricing (per 1 M tokens, USD)
-// Best-effort — returns 0 for unknown models.
-// ---------------------------------------------------------------------------
-
-const PRICING = {
-  // OpenAI
-  'gpt-4o':                       { prompt: 2.50,  completion: 10.00 },
-  'gpt-4o-2024-11-20':            { prompt: 2.50,  completion: 10.00 },
-  'gpt-4o-mini':                  { prompt: 0.15,  completion: 0.60  },
-  'gpt-4o-mini-2024-07-18':       { prompt: 0.15,  completion: 0.60  },
-  'gpt-4-turbo':                  { prompt: 10.00, completion: 30.00 },
-  'gpt-4-turbo-preview':          { prompt: 10.00, completion: 30.00 },
-  'gpt-4':                        { prompt: 30.00, completion: 60.00 },
-  'gpt-3.5-turbo':                { prompt: 0.50,  completion: 1.50  },
-  'o1':                           { prompt: 15.00, completion: 60.00 },
-  'o1-mini':                      { prompt: 3.00,  completion: 12.00 },
-  'o3-mini':                      { prompt: 1.10,  completion: 4.40  },
-
-  // Anthropic
-  'claude-sonnet-4-5-20250514':   { prompt: 3.00,  completion: 15.00 },
-  'claude-opus-4-6':              { prompt: 15.00, completion: 75.00 },
-  'claude-3-5-sonnet-20241022':   { prompt: 3.00,  completion: 15.00 },
-  'claude-3-5-sonnet-latest':     { prompt: 3.00,  completion: 15.00 },
-  'claude-3-5-haiku-20241022':    { prompt: 0.80,  completion: 4.00  },
-  'claude-3-5-haiku-latest':      { prompt: 0.80,  completion: 4.00  },
-  'claude-3-opus-20240229':       { prompt: 15.00, completion: 75.00 },
-  'claude-3-haiku-20240307':      { prompt: 0.25,  completion: 1.25  },
-};
-
-/**
- * Estimate cost from model name and token counts.
- * Returns 0 for unknown models.
- * @param {string} model
- * @param {{ prompt: number, completion: number }} tokens
- * @returns {number} cost in USD
- */
-export function calculateCost(model, tokens) {
-  const p = PRICING[model];
-  if (!p) return 0;
-  return (tokens.prompt / 1_000_000) * p.prompt
-       + (tokens.completion / 1_000_000) * p.completion;
-}

package/src/core/warp.js

@@ -1,8 +1,8 @@
 // Warpmetrics SDK — warp()
 // Wraps an LLM client so every API call is automatically tracked.
 
-import { generateId, calculateCost } from './utils.js';
-import { responseRegistry, costRegistry, costByCallId } from './registry.js';
+import { generateId } from './utils.js';
+import { responseRegistry } from './registry.js';
 import { logCall, setConfig, getConfig } from './transport.js';
 import * as openai from '../providers/openai.js';
 import * as anthropic from '../providers/anthropic.js';
@@ -39,21 +39,18 @@ function createInterceptor(originalFn, context, provider) {
       }
 
       const ext  = provider.extract(result);
-      const cost = calculateCost(model, ext.tokens);
 
       logCall({
         id: callId, provider: provider.name, model, messages,
         response: ext.response,
         tools: tools ? tools.map(t => t.function?.name || t.name).filter(Boolean) : null,
         toolCalls: ext.toolCalls,
-        tokens: ext.tokens, cost, latency,
+        tokens: ext.tokens, latency,
         timestamp: new Date().toISOString(),
         status: 'success',
       });
 
       responseRegistry.set(result, callId);
-      costRegistry.set(result, cost);
-      costByCallId.set(callId, cost);
 
       return result;
     } catch (error) {
@@ -90,21 +87,17 @@ function wrapStream(stream, ctx) {
         ? ctx.provider.normalizeUsage(usage)
         : { prompt: 0, completion: 0, total: 0 };
 
-      const cost = calculateCost(ctx.model, tokens);
-
       logCall({
         id: ctx.callId, provider: ctx.provider.name, model: ctx.model, messages: ctx.messages,
         response: content,
         tools: ctx.tools ? ctx.tools.map(t => t.function?.name || t.name).filter(Boolean) : null,
-        tokens, cost,
+        tokens,
         latency: Date.now() - ctx.start,
         timestamp: new Date().toISOString(),
         status: 'success',
       });
 
       responseRegistry.set(wrapped, ctx.callId);
-      costRegistry.set(wrapped, cost);
-      costByCallId.set(ctx.callId, cost);
     },
   };
   return wrapped;
@@ -140,6 +133,14 @@ export function warp(client, options) {
     });
   }
 
+  const finalCfg = getConfig();
+  if (finalCfg.debug) {
+    const masked = finalCfg.apiKey
+      ? finalCfg.apiKey.slice(0, 10) + '...' + finalCfg.apiKey.slice(-4)
+      : '(none)';
+    console.log(`[warpmetrics] Config: baseUrl=${finalCfg.baseUrl} apiKey=${masked} enabled=${finalCfg.enabled} flushInterval=${finalCfg.flushInterval} maxBatchSize=${finalCfg.maxBatchSize}`);
+  }
+
   const provider = findProvider(client);
 
   if (!provider) {

package/src/index.d.ts

@@ -42,6 +42,7 @@ export interface OutcomeOptions {
   metadata?: Record<string, any>;
 }
 
+
 /**
  * Wrap an LLM client to automatically track every API call.
  * Pass options on the first call to configure the SDK; env vars are used as defaults.
@@ -64,11 +65,15 @@ export function outcome(
   options?: OutcomeOptions,
 ): void;
 
+/** Record an action taken on a tracked target (e.g. acting on feedback). */
+export function act(
+  target: Run | Group | object | string,
+  name: string,
+  metadata?: Record<string, any>,
+): void;
+
 /** Resolve any trackable target to its string ID. */
 export function ref(target: Run | Group | object | string): string | undefined;
 
-/** Get the cost in USD for any tracked target. */
-export function cost(target: Run | Group | object | string): number;
-
 /** Manually flush pending events to the API. */
 export function flush(): Promise<void>;

package/src/index.js

@@ -6,14 +6,13 @@
 //   group(label, options?)           — create a group
 //   add(target, ...items)            — add groups / calls to a run or group
 //   outcome(target, name, options?)  — record a result
+//   act(target, name, options?)      — record an action taken on a result
 //   ref(target)                      — get tracking ID
-//   cost(target)                     — get cost in USD
-
 export { warp } from './core/warp.js';
 export { run } from './trace/run.js';
 export { group } from './trace/group.js';
 export { add } from './trace/add.js';
 export { outcome } from './trace/outcome.js';
+export { act } from './trace/act.js';
 export { ref } from './trace/ref.js';
-export { cost } from './trace/cost.js';
 export { flush } from './core/transport.js';

package/src/providers/anthropic.js

@@ -9,11 +9,13 @@ export function detect(client) {
 export function extract(result) {
   const input  = result?.usage?.input_tokens || 0;
   const output = result?.usage?.output_tokens || 0;
+  const cacheWrite = result?.usage?.cache_creation_input_tokens || 0;
+  const cacheRead  = result?.usage?.cache_read_input_tokens || 0;
   return {
     response: Array.isArray(result?.content)
       ? result.content.filter(c => c.type === 'text').map(c => c.text).join('')
       : '',
-    tokens: { prompt: input, completion: output, total: input + output },
+    tokens: { prompt: input, completion: output, total: input + output, cacheWrite, cacheRead },
     toolCalls: null,
   };
 }
@@ -28,7 +30,9 @@ export function extractStreamDelta(chunk) {
 export function normalizeUsage(usage) {
   const prompt     = usage?.input_tokens || 0;
   const completion = usage?.output_tokens || 0;
-  return { prompt, completion, total: prompt + completion };
+  const cacheWrite = usage?.cache_creation_input_tokens || 0;
+  const cacheRead  = usage?.cache_read_input_tokens || 0;
+  return { prompt, completion, total: prompt + completion, cacheWrite, cacheRead };
 }
 
 export function proxy(client, intercept) {

package/src/providers/openai.js

@@ -16,12 +16,17 @@ function isResponsesAPI(result) {
 }
 
 function extractChatCompletions(result) {
+  const prompt     = result?.usage?.prompt_tokens || 0;
+  const completion = result?.usage?.completion_tokens || 0;
+  const cachedInput = result?.usage?.prompt_tokens_details?.cached_tokens || 0;
+
   return {
     response: result?.choices?.[0]?.message?.content || '',
     tokens: {
-      prompt:     result?.usage?.prompt_tokens || 0,
-      completion: result?.usage?.completion_tokens || 0,
-      total:      result?.usage?.total_tokens || 0,
+      prompt,
+      completion,
+      total: result?.usage?.total_tokens || 0,
+      cachedInput,
     },
     toolCalls: result?.choices?.[0]?.message?.tool_calls?.map(tc => ({
       id: tc.id,
@@ -40,12 +45,13 @@ function extractResponses(result) {
 
   const input  = result?.usage?.input_tokens || 0;
   const output = result?.usage?.output_tokens || 0;
+  const cachedInput = result?.usage?.input_tokens_details?.cached_tokens || 0;
 
   const fnCalls = (result?.output || []).filter(item => item.type === 'function_call');
 
   return {
     response: text,
-    tokens: { prompt: input, completion: output, total: input + output },
+    tokens: { prompt: input, completion: output, total: input + output, cachedInput },
     toolCalls: fnCalls.length > 0
       ? fnCalls.map(fc => ({ id: fc.id, name: fc.name, arguments: fc.arguments }))
       : null,
@@ -79,7 +85,9 @@ export function extractStreamDelta(chunk) {
 export function normalizeUsage(usage) {
   const prompt     = usage?.prompt_tokens || usage?.input_tokens || 0;
   const completion = usage?.completion_tokens || usage?.output_tokens || 0;
-  return { prompt, completion, total: prompt + completion };
+  const cachedInput = usage?.prompt_tokens_details?.cached_tokens
+    || usage?.input_tokens_details?.cached_tokens || 0;
+  return { prompt, completion, total: prompt + completion, cachedInput };
 }
 
 // ---------------------------------------------------------------------------

package/src/trace/act.js

@@ -0,0 +1,26 @@
+// Warpmetrics SDK — act()
+
+import { ref as getRef } from './ref.js';
+import { logAct, getConfig } from '../core/transport.js';
+
+/**
+ * Record an action taken on a tracked target (e.g. acting on feedback).
+ *
+ * @param {object | string} target — Run, Group, LLM response, or ref string
+ * @param {string} name            — action name ("improve-section", "refine-prompt")
+ * @param {Record<string, any>} [metadata] — arbitrary extra data
+ */
+export function act(target, name, metadata) {
+  const targetId = getRef(target);
+
+  if (!targetId) {
+    if (getConfig().debug) console.warn('[warpmetrics] act() — target not tracked.');
+    return;
+  }
+
+  logAct({
+    targetId,
+    name,
+    metadata: metadata || null,
+  });
+}

package/src/trace/cost.js

@@ -1,50 +0,0 @@
-// Warpmetrics SDK — cost()
-
-import { ref as getRef } from './ref.js';
-import { runRegistry, groupRegistry, costRegistry, costByCallId } from '../core/registry.js';
-
-/**
- * Get the cost in USD for any tracked target.
- *
- * - Response object → cost of that single call
- * - Run / Group      → sum of all nested calls
- * - Ref string       → lookup in registries
- *
- * @param {object | string} target
- * @returns {number} cost in USD
- */
-export function cost(target) {
-  // Response object — direct lookup
-  if (typeof target === 'object' && costRegistry.has(target)) {
-    return costRegistry.get(target);
-  }
-
-  const id = getRef(target);
-  if (!id) return 0;
-
-  // Single call by ref string
-  if (id.startsWith('wm_call_')) {
-    return costByCallId.get(id) || 0;
-  }
-
-  // Run or Group — aggregate
-  const container = runRegistry.get(id) || groupRegistry.get(id);
-  if (container) return sumCosts(container);
-
-  return 0;
-}
-
-function sumCosts(container) {
-  let total = 0;
-
-  for (const callId of container.calls) {
-    total += costByCallId.get(callId) || 0;
-  }
-
-  for (const groupId of container.groups) {
-    const g = groupRegistry.get(groupId);
-    if (g) total += sumCosts(g);
-  }
-
-  return total;
-}