slash-tokens 1.5.4 → 1.5.6

package/dist/cli.js

@@ -90,6 +90,13 @@ var AI_PATTERNS = [
   { name: "Cohere", regex: /from\s+['"]cohere|CohereClient|cohere\.chat/g },
   { name: "Mistral", regex: /from\s+['"]@mistralai|MistralClient/g }
 ];
+var SDK_REPRESENTATIVE_MODEL = {
+  Anthropic: "claude-sonnet",
+  OpenAI: "gpt-5.4",
+  Gemini: "gemini-3.1-pro",
+  Grok: "grok-4.20"
+};
+var UNKNOWN_SDK_REPRESENTATIVE_MODEL = "claude-sonnet";
 var SKIP_DIRS = new Set([
   "node_modules",
   ".git",
@@ -159,13 +166,15 @@ function findCallSites(filePath, content) {
       const endLine = Math.min(lines.length, lineNum + 20);
       const context = lines.slice(startLine, endLine).join(`
 `);
-      const tokensPerCall = slash(context);
+      const estimatedModel = SDK_REPRESENTATIVE_MODEL[pattern.name] ?? UNKNOWN_SDK_REPRESENTATIVE_MODEL;
+      const tokensPerCall = slash(context, estimatedModel);
       if (!sites.some((s) => s.line === lineNum && s.sdk === pattern.name)) {
         sites.push({
           file: filePath,
           line: lineNum,
           sdk: pattern.name,
-          tokensPerCall
+          tokensPerCall,
+          estimatedModel
         });
       }
     }
@@ -193,6 +202,24 @@ function scan(dir) {
   };
 }
 
+// src/models.ts
+var MODELS = {
+  "claude-opus": { input: 5, output: 25, context: 1e6 },
+  "claude-opus-4.7": { input: 5, output: 25, context: 1e6 },
+  "claude-sonnet": { input: 2, output: 10, context: 1e6 },
+  "claude-haiku": { input: 1, output: 5, context: 200000 },
+  "grok-4.20": { input: 1.25, output: 2.5, context: 1e6 },
+  "grok-4-1-fast": { input: 1.25, output: 2.5, context: 1e6 },
+  "gemini-3.1-pro": { input: 2, output: 12, context: 1e6 },
+  "gemini-2.5-flash": { input: 0.3, output: 2.5, context: 1e6 },
+  "gpt-5.4": { input: 2.5, output: 15, context: 1e6 },
+  "gpt-5.4-mini": { input: 0.75, output: 4.5, context: 128000 },
+  "gpt-5.4-nano": { input: 0.2, output: 1.25, context: 128000 }
+};
+function getModel(name) {
+  return MODELS[name] || MODELS[name.toLowerCase()];
+}
+
 // src/report.ts
 var R = "\x1B[0m";
 var B = "\x1B[1m";
@@ -231,9 +258,21 @@ function printReport(sites, filesScanned, timeMs, cwd) {
   const dailyInput = sites.reduce((sum, s) => sum + s.tokensPerCall * callsPerDay, 0);
   const dailyOutput = dailyInput * 2;
   const dailyTotal = dailyInput + dailyOutput;
-  const monthlyTotal = dailyTotal * 30;
-  const monthlyCostInput = dailyInput * 30 / 1e6 * 3;
-  const monthlyCostOutput = dailyOutput * 30 / 1e6 * 15;
+  let monthlyCostInput = 0;
+  let monthlyCostOutput = 0;
+  let unknownProviderSites = 0;
+  for (const site of sites) {
+    const info = getModel(site.estimatedModel);
+    if (!info)
+      continue;
+    if (site.estimatedModel === UNKNOWN_SDK_REPRESENTATIVE_MODEL && !["Anthropic"].includes(site.sdk)) {
+      unknownProviderSites++;
+    }
+    const siteDailyInput = site.tokensPerCall * callsPerDay;
+    const siteDailyOutput = siteDailyInput * 2;
+    monthlyCostInput += siteDailyInput * 30 / 1e6 * info.input;
+    monthlyCostOutput += siteDailyOutput * 30 / 1e6 * info.output;
+  }
   const monthlyCost = monthlyCostInput + monthlyCostOutput;
   console.log(`${ORANGE}  DAILY TOKEN VOLUME ${GRAY}(${callsPerDay} calls/site/day)${R}`);
   console.log(`${DIM}  ${"─".repeat(60)}${R}`);
@@ -241,11 +280,14 @@ function printReport(sites, filesScanned, timeMs, cwd) {
   console.log(`${WHITE}  Output tokens:   ${B}${formatNum(dailyOutput)}${R}  ${GRAY}(estimated)${R}`);
   console.log(`${WHITE}  Total:           ${ORANGE}${B}${formatNum(dailyTotal)} tokens/day${R}`);
   console.log("");
-  console.log(`${ORANGE}  MONTHLY COST ${GRAY}($3/$15 per MTok)${R}`);
+  console.log(`${ORANGE}  MONTHLY COST ${GRAY}(real per-provider pricing)${R}`);
   console.log(`${DIM}  ${"─".repeat(60)}${R}`);
   console.log(`${WHITE}  Input:           ${B}$${monthlyCostInput.toFixed(2)}/mo${R}`);
   console.log(`${WHITE}  Output:          ${B}$${monthlyCostOutput.toFixed(2)}/mo${R}`);
   console.log(`${WHITE}  Total:           ${ORANGE}${B}$${monthlyCost.toFixed(2)}/mo${R}`);
+  if (unknownProviderSites > 0) {
+    console.log(`${GRAY}  (${unknownProviderSites} call site${unknownProviderSites === 1 ? "" : "s"} use an assumed price — the detected SDK doesn't reveal the exact provider)${R}`);
+  }
   console.log("");
   const recoveryPct = 10;
   const monthlyRecovered = monthlyCost * recoveryPct / 100;

package/dist/patterns.d.ts

@@ -3,5 +3,7 @@ export interface Pattern {
     regex: RegExp;
 }
 export declare const AI_PATTERNS: Pattern[];
+export declare const SDK_REPRESENTATIVE_MODEL: Record<string, string>;
+export declare const UNKNOWN_SDK_REPRESENTATIVE_MODEL = "claude-sonnet";
 export declare const SKIP_DIRS: Set<string>;
 export declare const SCAN_EXTENSIONS: Set<string>;

package/dist/patterns.js

@@ -20,6 +20,31 @@ export const AI_PATTERNS = [
     // Mistral
     { name: 'Mistral', regex: /from\s+['"]@mistralai|MistralClient/g },
 ];
+// Representative model per detected SDK — the scanner only ever sees an
+// SDK name (a regex match on import/call syntax), never the actual model
+// string passed at runtime, so there's no way to know the exact model a
+// found call site uses. Fixed 2026-08-23: this used to mean every SDK got
+// the raw, uncalibrated token estimate AND one flat hardcoded $3/$15
+// "GPT-4o class" price regardless of provider — the product's own
+// top-of-funnel "here's what you'd save" numbers were both uncalibrated
+// and mispriced for every provider except whichever one happened to match
+// that flat rate by coincidence. Mapping each identified SDK to one real,
+// representative model lets the scanner apply that model's real
+// calibration factor and real price — still an approximation (we don't
+// know the exact model), but a real per-provider one instead of a single
+// guess applied to everyone.
+export const SDK_REPRESENTATIVE_MODEL = {
+    'Anthropic': 'claude-sonnet',
+    'OpenAI': 'gpt-5.4',
+    'Gemini': 'gemini-3.1-pro',
+    'Grok': 'grok-4.20',
+};
+// Fallback for SDKs that don't map to one specific provider (Vercel AI,
+// LangChain, and Bedrock can all wrap any underlying provider; raw
+// fetch-to-AI-endpoint and Cohere/Mistral have no pricing data in MODELS
+// at all). claude-sonnet is used as a documented, honest middle-of-the-
+// road placeholder — not a claim about which model is actually running.
+export const UNKNOWN_SDK_REPRESENTATIVE_MODEL = 'claude-sonnet';
 export const SKIP_DIRS = new Set([
     'node_modules', '.git', 'dist', 'build', '.next', '.nuxt', '.svelte-kit',
     'coverage', '.turbo', '.cache', '__pycache__', '.venv', 'venv',

package/dist/preflight.d.ts

@@ -48,8 +48,15 @@ export declare function preflight(content: string, model: string): PreflightResu
  *   - Cheapest SAME-PROVIDER alternative by input price. If two alternatives
  *     tie on price (unlikely but possible), returns the first encountered in
  *     PROVIDER_MODELS order.
- *   - Must agree with intercept.ts findCheapestRoute for identical inputs.
- *     Cross-function semantic test: given the same (provider, tokens, model),
- *     both functions return the same model name.
+ *   - Must agree with intercept.ts findCheapestRoute for identical inputs,
+ *     INCLUDING respecting the same init() config gates: shouldRoute()
+ *     (init({route: false}) must make this always return null, matching
+ *     patchFetch() never routing) and isModelAllowed() (init({models: [...]})
+ *     must exclude any candidate not in that list, matching
+ *     findCheapestRoute's real filtering). Fixed 2026-08-23 — this
+ *     function used to ignore both, so a call site previewing "what will
+ *     Slash route to" via preflightRoute() would show a route recommendation
+ *     that real traffic through patchFetch() would never actually take
+ *     under the same config, silently breaking the "matches exactly" promise.
  */
 export declare function preflightRoute(content: string, model: string): Alternative | null;

package/dist/preflight.js

@@ -1,6 +1,7 @@
 import { slash } from './slash.js';
 import { getModel, MODELS } from './models.js';
 import { PROVIDER_MODELS, providerOf } from './providers.js';
+import { shouldRoute, isModelAllowed } from './config.js';
 /**
  * Compute cost of a prompt of `tokens` tokens on the given ModelInfo.
  * Uses input-token price only (output is not known at preflight time).
@@ -69,11 +70,20 @@ export function preflight(content, model) {
  *   - Cheapest SAME-PROVIDER alternative by input price. If two alternatives
  *     tie on price (unlikely but possible), returns the first encountered in
  *     PROVIDER_MODELS order.
- *   - Must agree with intercept.ts findCheapestRoute for identical inputs.
- *     Cross-function semantic test: given the same (provider, tokens, model),
- *     both functions return the same model name.
+ *   - Must agree with intercept.ts findCheapestRoute for identical inputs,
+ *     INCLUDING respecting the same init() config gates: shouldRoute()
+ *     (init({route: false}) must make this always return null, matching
+ *     patchFetch() never routing) and isModelAllowed() (init({models: [...]})
+ *     must exclude any candidate not in that list, matching
+ *     findCheapestRoute's real filtering). Fixed 2026-08-23 — this
+ *     function used to ignore both, so a call site previewing "what will
+ *     Slash route to" via preflightRoute() would show a route recommendation
+ *     that real traffic through patchFetch() would never actually take
+ *     under the same config, silently breaking the "matches exactly" promise.
  */
 export function preflightRoute(content, model) {
+    if (!shouldRoute())
+        return null;
     const tokens = slash(content, model);
     const info = getModel(model);
     if (!info)
@@ -89,6 +99,8 @@ export function preflightRoute(content, model) {
     for (const m of providerModels) {
         if (m === model)
             continue;
+        if (!isModelAllowed(m))
+            continue; // user excluded this model
         const altInfo = getModel(m);
         if (!altInfo)
             continue;

package/dist/report.js

@@ -1,3 +1,5 @@
+import { getModel } from './models.js';
+import { UNKNOWN_SDK_REPRESENTATIVE_MODEL } from './patterns.js';
 // ANSI — zero deps
 const R = '\x1b[0m';
 const B = '\x1b[1m';
@@ -38,10 +40,26 @@ export function printReport(sites, filesScanned, timeMs, cwd) {
     const dailyInput = sites.reduce((sum, s) => sum + s.tokensPerCall * callsPerDay, 0);
     const dailyOutput = dailyInput * 2; // Estimate output at 2x input
     const dailyTotal = dailyInput + dailyOutput;
-    const monthlyTotal = dailyTotal * 30;
-    // Cost at $3/MTok input, $15/MTok output (GPT-4o class)
-    const monthlyCostInput = (dailyInput * 30 / 1000000) * 3;
-    const monthlyCostOutput = (dailyOutput * 30 / 1000000) * 15;
+    // Cost per site using its own representative model's REAL current price
+    // (see patterns.ts SDK_REPRESENTATIVE_MODEL) — fixed 2026-08-23: this
+    // used to be one flat hardcoded $3/$15 "GPT-4o class" rate applied to
+    // every site regardless of detected provider, understating cost by up
+    // to ~67% for premium providers and overstating it for cheap ones.
+    let monthlyCostInput = 0;
+    let monthlyCostOutput = 0;
+    let unknownProviderSites = 0;
+    for (const site of sites) {
+        const info = getModel(site.estimatedModel);
+        if (!info)
+            continue; // shouldn't happen — estimatedModel always maps to a real MODELS entry
+        if (site.estimatedModel === UNKNOWN_SDK_REPRESENTATIVE_MODEL && !['Anthropic'].includes(site.sdk)) {
+            unknownProviderSites++;
+        }
+        const siteDailyInput = site.tokensPerCall * callsPerDay;
+        const siteDailyOutput = siteDailyInput * 2;
+        monthlyCostInput += (siteDailyInput * 30 / 1000000) * info.input;
+        monthlyCostOutput += (siteDailyOutput * 30 / 1000000) * info.output;
+    }
     const monthlyCost = monthlyCostInput + monthlyCostOutput;
     console.log(`${ORANGE}  DAILY TOKEN VOLUME ${GRAY}(${callsPerDay} calls/site/day)${R}`);
     console.log(`${DIM}  ${'─'.repeat(60)}${R}`);
@@ -49,11 +67,14 @@ export function printReport(sites, filesScanned, timeMs, cwd) {
     console.log(`${WHITE}  Output tokens:   ${B}${formatNum(dailyOutput)}${R}  ${GRAY}(estimated)${R}`);
     console.log(`${WHITE}  Total:           ${ORANGE}${B}${formatNum(dailyTotal)} tokens/day${R}`);
     console.log('');
-    console.log(`${ORANGE}  MONTHLY COST ${GRAY}($3/$15 per MTok)${R}`);
+    console.log(`${ORANGE}  MONTHLY COST ${GRAY}(real per-provider pricing)${R}`);
     console.log(`${DIM}  ${'─'.repeat(60)}${R}`);
     console.log(`${WHITE}  Input:           ${B}$${monthlyCostInput.toFixed(2)}/mo${R}`);
     console.log(`${WHITE}  Output:          ${B}$${monthlyCostOutput.toFixed(2)}/mo${R}`);
     console.log(`${WHITE}  Total:           ${ORANGE}${B}$${monthlyCost.toFixed(2)}/mo${R}`);
+    if (unknownProviderSites > 0) {
+        console.log(`${GRAY}  (${unknownProviderSites} call site${unknownProviderSites === 1 ? '' : 's'} use an assumed price — the detected SDK doesn't reveal the exact provider)${R}`);
+    }
     console.log('');
     // Slash — sunk cost recovery (conservative 10% gate efficiency)
     const recoveryPct = 10;

package/dist/scanner.d.ts

@@ -3,6 +3,10 @@ export interface CallSite {
     line: number;
     sdk: string;
     tokensPerCall: number;
+    /** The representative model used to calibrate/price this site — see
+     * patterns.ts SDK_REPRESENTATIVE_MODEL. Not the actual runtime model
+     * (the scanner can't know that from source alone). */
+    estimatedModel: string;
 }
 export declare function scan(dir: string): {
     sites: CallSite[];

package/dist/scanner.js

@@ -1,7 +1,7 @@
 import { readdirSync, readFileSync, statSync } from 'fs';
 import { join, extname } from 'path';
 import { slash } from './slash.js';
-import { AI_PATTERNS, SKIP_DIRS, SCAN_EXTENSIONS } from './patterns.js';
+import { AI_PATTERNS, SKIP_DIRS, SCAN_EXTENSIONS, SDK_REPRESENTATIVE_MODEL, UNKNOWN_SDK_REPRESENTATIVE_MODEL, } from './patterns.js';
 function walkDir(dir, files) {
     let entries;
     try {
@@ -44,7 +44,8 @@ function findCallSites(filePath, content) {
             const startLine = Math.max(0, lineNum - 5);
             const endLine = Math.min(lines.length, lineNum + 20);
             const context = lines.slice(startLine, endLine).join('\n');
-            const tokensPerCall = slash(context);
+            const estimatedModel = SDK_REPRESENTATIVE_MODEL[pattern.name] ?? UNKNOWN_SDK_REPRESENTATIVE_MODEL;
+            const tokensPerCall = slash(context, estimatedModel);
             // Avoid duplicates at same location
             if (!sites.some(s => s.line === lineNum && s.sdk === pattern.name)) {
                 sites.push({
@@ -52,6 +53,7 @@ function findCallSites(filePath, content) {
                     line: lineNum,
                     sdk: pattern.name,
                     tokensPerCall,
+                    estimatedModel,
                 });
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slash-tokens",
-  "version": "1.5.4",
+  "version": "1.5.6",
   "description": "Token Optimization for Context Engineers. 4.8 KB WASM. Sub-millisecond. Zero dependencies.",
   "main": "dist/index.js",
   "module": "dist/index.js",