slash-tokens 0.2.0 → 1.0.0

package/README.md

@@ -1,128 +1,26 @@
 # /slash-tokens
 
-Token budget estimation in 4.8 KB WASM. Sub-millisecond. Zero dependencies.
+Pre-flight checks for API calls. 4.8 KB WASM. Sub-millisecond. Zero dependencies.
 
-I don't count tokens. I slash them.
-
-## Install
+**Fly First. Pay Economy.**
 
 ```bash
 npm install slash-tokens
 ```
 
-## Use
-
 ```js
-import { slash } from 'slash-tokens'
-
-const tokens = slash('Your content here')
-
-if (tokens > 128_000) trim(content)     // Context window gate
-const cost = tokens * PRICE_PER_TOKEN   // Cost estimation
-```
+import { preflight } from 'slash-tokens'
 
-One function. Returns a number. That's the entire API.
-
-## Scan your project
-
-```bash
-bunx slash-tokens
+const check = preflight(prompt, 'claude-opus')
+// tokens: 47,000 | cost: $0.71 | 11 cheaper options | save 99%
 ```
 
-Finds every AI API call in your codebase and estimates your token burn:
-
-```
-  ⚡ /slash
-  Token burn analysis
-
-  Scanned 47 files in 3ms
-
-  CALL SITES
-  ────────────────────────────────────────────────────────
-  src/api/chat.ts:24       Anthropic    ~2,400 tok/call
-  src/api/summary.ts:11    OpenAI       ~8,200 tok/call
-  src/lib/agent.ts:88      Vercel AI    ~1,100 tok/call
-
-  DAILY BURN (100 calls/site/day)
-  ────────────────────────────────────────────────────────
-  Input tokens:    1,520,000
-  Output tokens:   3,040,000  (estimated)
-  Total:           4,560,000 tokens/day
-
-  MONTHLY COST ($3/$15 per MTok)
-  ────────────────────────────────────────────────────────
-  Total:           $1,504.80/mo
-
-  ⚡ SLASH SAVINGS (10% gate efficiency)
-  ────────────────────────────────────────────────────────
-  Annual savings:  $1,805.76/yr
-```
-
-Detects: OpenAI, Anthropic, Vercel AI, LangChain, Gemini, Bedrock, Grok, Cohere, Mistral.
-
-## How it works
-
-Single-pass byte classification over your content. No vocabulary tables. No BPE decode. Classifies content type (prose, code, JSON, YAML, mixed), applies a calibrated chars-per-token ratio, adds a safety margin.
-
-Budget gate — better to say "doesn't fit" than overflow. The API returns exact counts after the call. Pre-call, you only need go/no-go.
-
-## Numbers
-
-| | js-tiktoken | gpt-tokenizer | slash-tokens |
-|---|---|---|---|
-| Size | ~1 MB | 300 KB+ | **4.8 KB** |
-| Cold start | Heavy | Moderate | **Sub-ms** |
-| Edge-ready | Painful | Difficult | **Native** |
-| Models | GPT only | GPT only | **Any model** |
-| Dependencies | npm tree | npm tree | **Zero** |
-| Allocations | Many | Many | **Zero** |
-
-## Runtime support
-
-Works everywhere WASM runs:
-
-- Node.js
-- Bun
-- Deno
-- Cloudflare Workers
-- Vercel Edge
-- Browser
-
-## API
-
-### `slash(content: string): number`
-
-Estimate token count for a string. Returns `u32`.
+Or one line — every API call pre-flighted automatically:
 
 ```js
-slash('')                    // 0
-slash('hello')               // 1
-slash(longDocument)          // 4,283
+import 'slash-tokens/auto'
 ```
 
-### `slashBytes(bytes: Uint8Array): number`
-
-Estimate token count from raw bytes. Skips `TextEncoder` overhead.
-
-## What this is not
-
-This is not a tokenizer. It doesn't decode BPE. It doesn't reproduce exact token counts. No tokenizer can — Claude, Grok, and Gemini vocabularies are not public.
-
-This is a **budget gate**. It answers "does this fit?" with 96-98% accuracy in sub-millisecond time. The 2-4% margin is intentional — overestimate, never underestimate.
-
-## Engine
-
-4,865 bytes of Zig-compiled WASM (`wasm32-freestanding`). No allocator. No floats. No heap. Base64-embedded — no separate `.wasm` file to load.
-
-Built from [xai-faf-zig](https://github.com/Wolfe-Jam/xai-faf-zig). 172 tests including 65 adversarial (CJK, emoji, binary, base64, threshold boundaries).
-
-## Links
-
-- [slashtokens.com](https://slashtokens.com) — product site
-- [mcpaas.live/slash](https://mcpaas.live/slash) — live one-pager
-- [npm](https://www.npmjs.com/package/slash-tokens)
-- [xai-faf-zig](https://github.com/Wolfe-Jam/xai-faf-zig) — WASM engine source
-
-## License
+Full docs, examples, and model pricing at **[GitHub](https://github.com/Wolfe-Jam/slash-tokens)**
 
-MIT
+[slashtokens.com](https://slashtokens.com) | MIT

package/dist/auto.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/auto.js

@@ -0,0 +1,30 @@
+import { patchFetch, onIntercept } from './intercept.js';
+import { report } from './transact.js';
+import { hasKey } from './config.js';
+// Auto mode: import this file and every LLM call is pre-flighted.
+// Usage: import 'slash-tokens/auto'
+//
+// No key: console logging only (free forever)
+// With key (init or SLASH_KEY): flight records sent to API
+//
+// Auto mode observes every call — it doesn't block.
+// The data shows what you're spending and what you COULD save.
+// When you start acting on preflight results (skip/reduce/route),
+// the savings become real.
+patchFetch();
+onIntercept((event) => {
+    const status = event.fits ? 'OK' : 'OVER LIMIT';
+    console.log(`[slash] ${event.provider} ${event.model} | ${event.tokens.toLocaleString()} tokens | $${event.cost.toFixed(4)} | ${status}`);
+    // If key is configured, log the flight record (non-blocking)
+    if (hasKey() && event.tokens > 0) {
+        report({
+            tokens_estimated: event.tokens,
+            tokens_saved: 0,
+            model: event.model,
+            action: 'routed',
+            cost_saved_usd: 0,
+        }).catch(() => {
+            // Silent — never break the app for billing failures
+        });
+    }
+});

package/dist/config.d.ts

@@ -4,3 +4,4 @@ export declare function init(opts: {
 }): void;
 export declare function resolveKey(perCallKey?: string): string;
 export declare function getEndpoint(): string;
+export declare function hasKey(): boolean;

package/dist/config.js

@@ -16,3 +16,6 @@ export function resolveKey(perCallKey) {
 export function getEndpoint() {
     return _endpoint;
 }
+export function hasKey() {
+    return !!(_key || process.env.SLASH_KEY);
+}

package/dist/index.d.ts

@@ -1,5 +1,9 @@
 export { slash, slashBytes } from './slash.js';
+export { preflight } from './preflight.js';
+export type { PreflightResult, Alternative } from './preflight.js';
+export { MODELS, listModels } from './models.js';
+export type { ModelInfo } from './models.js';
 export { report } from './transact.js';
 export type { ReportOptions, ReportResult } from './transact.js';
-export { init } from './config.js';
+export { init, hasKey } from './config.js';
 export { resolveKey } from './config.js';

package/dist/index.js

@@ -1,7 +1,11 @@
 // Core estimation
 export { slash, slashBytes } from './slash.js';
+// Pre-flight checks
+export { preflight } from './preflight.js';
+// Model intelligence
+export { MODELS, listModels } from './models.js';
 // Transaction reporting
 export { report } from './transact.js';
 // Configuration
-export { init } from './config.js';
+export { init, hasKey } from './config.js';
 export { resolveKey } from './config.js';

package/dist/intercept.d.ts

@@ -0,0 +1,11 @@
+export interface InterceptEvent {
+    endpoint: string;
+    provider: string;
+    model: string;
+    tokens: number;
+    cost: number;
+    fits: boolean;
+    timestamp: string;
+}
+export declare function onIntercept(handler: (event: InterceptEvent) => void): void;
+export declare function patchFetch(): void;

package/dist/intercept.js

@@ -0,0 +1,120 @@
+import { slash } from './slash.js';
+import { getModel } from './models.js';
+// AI API endpoint detection — same patterns as scanner, runtime version
+const AI_ENDPOINTS = [
+    {
+        pattern: /api\.anthropic\.com/,
+        provider: 'Anthropic',
+        modelExtractor: (body) => body?.model || 'claude-sonnet',
+    },
+    {
+        pattern: /api\.openai\.com/,
+        provider: 'OpenAI',
+        modelExtractor: (body) => body?.model || 'gpt-4o',
+    },
+    {
+        pattern: /generativelanguage\.googleapis\.com/,
+        provider: 'Google',
+        modelExtractor: (body) => 'gemini-2.0-flash',
+    },
+    {
+        pattern: /api\.x\.ai/,
+        provider: 'xAI',
+        modelExtractor: (body) => body?.model || 'grok-3',
+    },
+];
+// Normalize model names to our pricing table keys
+function normalizeModel(raw) {
+    const lower = raw.toLowerCase();
+    if (lower.includes('opus'))
+        return 'claude-opus';
+    if (lower.includes('sonnet'))
+        return 'claude-sonnet';
+    if (lower.includes('haiku'))
+        return 'claude-haiku';
+    if (lower.includes('grok') && lower.includes('mini'))
+        return 'grok-3-mini';
+    if (lower.includes('grok'))
+        return 'grok-3';
+    if (lower.includes('gemini') && lower.includes('pro'))
+        return 'gemini-2.0-pro';
+    if (lower.includes('gemini'))
+        return 'gemini-2.0-flash';
+    if (lower.includes('4o-mini') || lower.includes('4o_mini'))
+        return 'gpt-4o-mini';
+    if (lower.includes('4o'))
+        return 'gpt-4o';
+    if (lower.includes('4.1') && lower.includes('nano'))
+        return 'gpt-4.1-nano';
+    if (lower.includes('4.1') && lower.includes('mini'))
+        return 'gpt-4.1-mini';
+    if (lower.includes('4.1'))
+        return 'gpt-4.1';
+    return raw;
+}
+// Extract message content from request body
+function extractContent(body) {
+    if (!body)
+        return '';
+    // Anthropic: { messages: [{ content: "..." }] }
+    // OpenAI: { messages: [{ content: "..." }] }
+    if (body.messages && Array.isArray(body.messages)) {
+        return body.messages
+            .map((m) => typeof m.content === 'string' ? m.content : JSON.stringify(m.content))
+            .join('\n');
+    }
+    // Anthropic: { prompt: "..." }
+    if (typeof body.prompt === 'string')
+        return body.prompt;
+    // Google: { contents: [{ parts: [{ text: "..." }] }] }
+    if (body.contents && Array.isArray(body.contents)) {
+        return body.contents
+            .flatMap((c) => c.parts || [])
+            .map((p) => p.text || '')
+            .join('\n');
+    }
+    return JSON.stringify(body);
+}
+let _onIntercept = null;
+export function onIntercept(handler) {
+    _onIntercept = handler;
+}
+export function patchFetch() {
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = async function slashFetch(input, init) {
+        const url = typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
+        // Check if this is an AI API call
+        const match = AI_ENDPOINTS.find(ep => ep.pattern.test(url));
+        if (match && init?.body) {
+            try {
+                const bodyStr = typeof init.body === 'string' ? init.body : undefined;
+                if (bodyStr) {
+                    const body = JSON.parse(bodyStr);
+                    const content = extractContent(body);
+                    const rawModel = match.modelExtractor(body);
+                    const model = normalizeModel(rawModel);
+                    const tokens = slash(content);
+                    const info = getModel(model);
+                    const cost = info ? Math.round(((tokens / 1000000) * info.input) * 1000000) / 1000000 : 0;
+                    const fits = info ? tokens <= info.context : true;
+                    const event = {
+                        endpoint: url,
+                        provider: match.provider,
+                        model,
+                        tokens,
+                        cost,
+                        fits,
+                        timestamp: new Date().toISOString(),
+                    };
+                    if (_onIntercept) {
+                        _onIntercept(event);
+                    }
+                }
+            }
+            catch {
+                // Non-blocking — never break the actual API call
+            }
+        }
+        return originalFetch(input, init);
+    };
+}

package/dist/models.d.ts

@@ -0,0 +1,8 @@
+export interface ModelInfo {
+    input: number;
+    output: number;
+    context: number;
+}
+export declare const MODELS: Record<string, ModelInfo>;
+export declare function getModel(name: string): ModelInfo | undefined;
+export declare function listModels(): string[];

package/dist/models.js

@@ -0,0 +1,24 @@
+export const MODELS = {
+    // Anthropic
+    'claude-opus': { input: 15.00, output: 75.00, context: 200000 },
+    'claude-sonnet': { input: 3.00, output: 15.00, context: 200000 },
+    'claude-haiku': { input: 0.25, output: 1.25, context: 200000 },
+    // xAI
+    'grok-3': { input: 5.00, output: 15.00, context: 131072 },
+    'grok-3-mini': { input: 0.30, output: 0.50, context: 131072 },
+    // Google
+    'gemini-2.0-flash': { input: 0.10, output: 0.40, context: 1048576 },
+    'gemini-2.0-pro': { input: 1.25, output: 5.00, context: 1048576 },
+    // OpenAI
+    'gpt-4o': { input: 2.50, output: 10.00, context: 128000 },
+    'gpt-4o-mini': { input: 0.15, output: 0.60, context: 128000 },
+    'gpt-4.1': { input: 2.00, output: 8.00, context: 1047576 },
+    'gpt-4.1-mini': { input: 0.40, output: 1.60, context: 1047576 },
+    'gpt-4.1-nano': { input: 0.10, output: 0.40, context: 1047576 },
+};
+export function getModel(name) {
+    return MODELS[name] || MODELS[name.toLowerCase()];
+}
+export function listModels() {
+    return Object.keys(MODELS);
+}

package/dist/preflight.d.ts

@@ -0,0 +1,16 @@
+export interface Alternative {
+    model: string;
+    cost: number;
+    savings: number;
+    savingsPercent: number;
+}
+export interface PreflightResult {
+    tokens: number;
+    cost: number;
+    fits: boolean;
+    model: string;
+    context: number;
+    utilization: number;
+    options: Alternative[];
+}
+export declare function preflight(content: string, model: string): PreflightResult;

package/dist/preflight.js

@@ -0,0 +1,27 @@
+import { slash } from './slash.js';
+import { getModel, MODELS } from './models.js';
+export function preflight(content, model) {
+    const tokens = slash(content);
+    const info = getModel(model);
+    if (!info) {
+        throw new Error(`Unknown model: "${model}". Available: ${Object.keys(MODELS).join(', ')}`);
+    }
+    const cost = Math.round(((tokens / 1000000) * info.input) * 1000000) / 1000000;
+    const fits = tokens <= info.context;
+    const utilization = Math.round((tokens / info.context) * 10000) / 10000;
+    const options = Object.entries(MODELS)
+        .filter(([m]) => m !== model)
+        .filter(([_, v]) => v.context >= tokens)
+        .map(([m, v]) => {
+        const altCost = Math.round(((tokens / 1000000) * v.input) * 1000000) / 1000000;
+        return {
+            model: m,
+            cost: altCost,
+            savings: Math.round((cost - altCost) * 1000000) / 1000000,
+            savingsPercent: cost > 0 ? Math.round(((cost - altCost) / cost) * 10000) / 100 : 0,
+        };
+    })
+        .filter(o => o.savings > 0)
+        .sort((a, b) => a.cost - b.cost);
+    return { tokens, cost, fits, model, context: info.context, utilization, options };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "slash-tokens",
-  "version": "0.2.0",
-  "description": "Token budget estimation in 4.8 KB WASM. Sub-millisecond. Zero dependencies. I don't count tokens. I slash them.",
+  "version": "1.0.0",
+  "description": "Pre-flight checks for API calls. 4.8 KB WASM. Sub-millisecond. Zero dependencies. Fly First. Pay Economy.",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,6 +13,10 @@
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
+    },
+    "./auto": {
+      "import": "./dist/auto.js",
+      "types": "./dist/auto.d.ts"
     }
   },
   "files": ["dist"],