@relayplane/proxy 0.1.9 → 0.1.10

package/dist/index.mjs

@@ -1689,6 +1689,63 @@ var VERSION = "0.1.9";
 var recentRuns = [];
 var MAX_RECENT_RUNS = 100;
 var modelCounts = {};
+var tokenStats = {};
+var MODEL_PRICING2 = {
+  // Anthropic
+  "claude-3-haiku-20240307": { input: 0.25, output: 1.25 },
+  "claude-3-5-haiku-20241022": { input: 1, output: 5 },
+  "claude-3-5-haiku-latest": { input: 1, output: 5 },
+  "claude-3-5-sonnet-20241022": { input: 3, output: 15 },
+  "claude-sonnet-4-20250514": { input: 3, output: 15 },
+  "claude-3-opus-20240229": { input: 15, output: 75 },
+  "claude-opus-4-5-20250514": { input: 15, output: 75 },
+  // OpenAI
+  "gpt-4o": { input: 2.5, output: 10 },
+  "gpt-4o-mini": { input: 0.15, output: 0.6 },
+  "gpt-4-turbo": { input: 10, output: 30 },
+  // Defaults for unknown models
+  "default-cheap": { input: 1, output: 5 },
+  "default-expensive": { input: 15, output: 75 }
+};
+function trackTokens(model, inputTokens, outputTokens) {
+  if (!tokenStats[model]) {
+    tokenStats[model] = { inputTokens: 0, outputTokens: 0, requests: 0 };
+  }
+  tokenStats[model].inputTokens += inputTokens;
+  tokenStats[model].outputTokens += outputTokens;
+  tokenStats[model].requests += 1;
+}
+function calculateCosts() {
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let actualCostUsd = 0;
+  const byModel = {};
+  for (const [model, stats] of Object.entries(tokenStats)) {
+    totalInputTokens += stats.inputTokens;
+    totalOutputTokens += stats.outputTokens;
+    const pricing = MODEL_PRICING2[model] || MODEL_PRICING2["default-cheap"];
+    const cost = stats.inputTokens / 1e6 * pricing.input + stats.outputTokens / 1e6 * pricing.output;
+    actualCostUsd += cost;
+    byModel[model] = {
+      inputTokens: stats.inputTokens,
+      outputTokens: stats.outputTokens,
+      costUsd: parseFloat(cost.toFixed(4))
+    };
+  }
+  const opusPricing = MODEL_PRICING2["claude-opus-4-5-20250514"];
+  const opusCostUsd = totalInputTokens / 1e6 * opusPricing.input + totalOutputTokens / 1e6 * opusPricing.output;
+  const savingsUsd = opusCostUsd - actualCostUsd;
+  const savingsPercent = opusCostUsd > 0 ? (savingsUsd / opusCostUsd * 100).toFixed(1) + "%" : "0%";
+  return {
+    totalInputTokens,
+    totalOutputTokens,
+    actualCostUsd: parseFloat(actualCostUsd.toFixed(4)),
+    opusCostUsd: parseFloat(opusCostUsd.toFixed(4)),
+    savingsUsd: parseFloat(savingsUsd.toFixed(4)),
+    savingsPercent,
+    byModel
+  };
+}
 var serverStartTime = 0;
 var currentConfig = loadConfig();
 var DEFAULT_ENDPOINTS = {
@@ -2316,6 +2373,7 @@ function convertAnthropicStreamEvent(eventType, eventData, messageId, model, too
       return null;
   }
 }
+var lastStreamingUsage = null;
 async function* convertAnthropicStream(response, model) {
   const reader = response.body?.getReader();
   if (!reader) {
@@ -2328,6 +2386,8 @@ async function* convertAnthropicStream(response, model) {
     currentToolIndex: 0,
     tools: /* @__PURE__ */ new Map()
   };
+  let streamInputTokens = 0;
+  let streamOutputTokens = 0;
   try {
     while (true) {
       const { done, value } = await reader.read();
@@ -2345,6 +2405,17 @@ async function* convertAnthropicStream(response, model) {
         } else if (line === "" && eventType && eventData) {
           try {
             const parsed = JSON.parse(eventData);
+            if (eventType === "message_start") {
+              const msg = parsed["message"];
+              if (msg?.usage?.input_tokens) {
+                streamInputTokens = msg.usage.input_tokens;
+              }
+            } else if (eventType === "message_delta") {
+              const usage = parsed["usage"];
+              if (usage?.output_tokens) {
+                streamOutputTokens = usage.output_tokens;
+              }
+            }
             const converted = convertAnthropicStreamEvent(eventType, parsed, messageId, model, toolState);
             if (converted) {
               yield converted;
@@ -2356,6 +2427,7 @@ async function* convertAnthropicStream(response, model) {
         }
       }
     }
+    lastStreamingUsage = { inputTokens: streamInputTokens, outputTokens: streamOutputTokens };
   } finally {
     reader.releaseLock();
   }
@@ -2453,23 +2525,32 @@ async function startProxy(config = {}) {
     }
     if (req.method === "GET" && pathname === "/stats") {
       const stats = relay.stats();
-      const savings = relay.savingsReport(30);
+      const costs = calculateCosts();
       const totalRuns = Object.values(modelCounts).reduce((a, b) => a + b, 0);
       const modelDistribution = {};
       for (const [model, count] of Object.entries(modelCounts)) {
+        const modelName = model.split("/")[1] || model;
+        const tokenData = costs.byModel[modelName];
         modelDistribution[model] = {
           count,
-          percentage: totalRuns > 0 ? (count / totalRuns * 100).toFixed(1) + "%" : "0%"
+          percentage: totalRuns > 0 ? (count / totalRuns * 100).toFixed(1) + "%" : "0%",
+          tokens: tokenData ? { input: tokenData.inputTokens, output: tokenData.outputTokens } : void 0,
+          costUsd: tokenData?.costUsd
         };
       }
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(JSON.stringify({
         totalRuns,
-        savings: {
-          estimatedSavingsPercent: savings.savingsPercent.toFixed(1) + "%",
-          actualCostUsd: savings.actualCost.toFixed(4),
-          baselineCostUsd: savings.baselineCost.toFixed(4),
-          savedUsd: savings.savings.toFixed(4)
+        tokens: {
+          input: costs.totalInputTokens,
+          output: costs.totalOutputTokens,
+          total: costs.totalInputTokens + costs.totalOutputTokens
+        },
+        costs: {
+          actualUsd: costs.actualCostUsd,
+          opusBaselineUsd: costs.opusCostUsd,
+          savingsUsd: costs.savingsUsd,
+          savingsPercent: costs.savingsPercent
         },
         modelDistribution,
         byTaskType: stats.byTaskType,
@@ -2725,6 +2806,11 @@ async function handleStreamingRequest(res, request, targetProvider, targetModel,
   const durationMs = Date.now() - startTime;
   const modelKey = `${targetProvider}/${targetModel}`;
   modelCounts[modelKey] = (modelCounts[modelKey] || 0) + 1;
+  if (lastStreamingUsage && (lastStreamingUsage.inputTokens > 0 || lastStreamingUsage.outputTokens > 0)) {
+    trackTokens(targetModel, lastStreamingUsage.inputTokens, lastStreamingUsage.outputTokens);
+    log(`Tokens: ${lastStreamingUsage.inputTokens} in, ${lastStreamingUsage.outputTokens} out`);
+    lastStreamingUsage = null;
+  }
   relay.run({
     prompt: promptText.slice(0, 500),
     taskType,
@@ -2816,6 +2902,11 @@ async function handleNonStreamingRequest(res, request, targetProvider, targetMod
   const durationMs = Date.now() - startTime;
   const modelKey = `${targetProvider}/${targetModel}`;
   modelCounts[modelKey] = (modelCounts[modelKey] || 0) + 1;
+  const usage = responseData["usage"];
+  if (usage?.prompt_tokens || usage?.completion_tokens) {
+    trackTokens(targetModel, usage.prompt_tokens ?? 0, usage.completion_tokens ?? 0);
+    log(`Tokens: ${usage.prompt_tokens ?? 0} in, ${usage.completion_tokens ?? 0} out`);
+  }
   try {
     const runResult = await relay.run({
       prompt: promptText.slice(0, 500),