@gabrielsmartin/orbit-sdk 0.4.4 → 0.5.1

package/README.md

@@ -1,12 +1,12 @@
 # @gabrielsmartin/orbit-sdk
 
-> Stop blasting every query at GPT-4o. Route intelligently. Save up to 98%.
+> The AI operating system layer. Route intelligently. Save up to 98%.
 
-A small, fast, rule-based router for choosing between LLMs. Open source. No magic. ~200 lines of tuned heuristics that you can fork and customize.
+Every query has a fingerprint. Complexity, creativity, urgency, domain, emotional weight. Right now you're blasting every one of them at GPT-4o. ORBIT reads the fingerprint in milliseconds and picks the right model — automatically, invisibly, without you thinking about it.
 
-**What it is:** ORBIT reads your query, classifies it across 8 axes, and tells you which model to use. You make the API call — ORBIT just picks the model.
+**What it is:** ORBIT classifies queries across 8 axes and tells you which model to use. You make the API call. ORBIT picks the model. Zero proxy. Zero black box. Fully deterministic — you can read every routing rule in `fingerprint.js`.
 
-**What it isn't:** a proxy, a black box, or a neural network. It's fast deterministic rules — safety-critical routes (emotional content, crisis) always win, everything else is heuristic.
+**What it isn't:** a proxy, an API wrapper, or a neural network. It's fast, auditable rules — safety-critical routes (emotional content, crisis) always win, everything else is heuristic.
 
 ```bash
 npm install @gabrielsmartin/orbit-sdk
@@ -37,7 +37,7 @@ import orbit from '@gabrielsmartin/orbit-sdk'
 // Route a query — returns decision instantly, no network call
 const { model, reason, savings } = orbit.route("write a haiku about recursion")
 // model.name → "Claude Sonnet"
-// model.id   → "claude-sonnet-3-5"
+// model.id   → "claude-sonnet-4-6"
 // reason     → "High creativity — Claude Sonnet for open-ended generation."
 // savings.reductionPct → 50
 
@@ -141,31 +141,44 @@ const stats = orbit.stats()
 
 ## Hosted API
 
-Free to try, no auth required:
+Sign up at [orbitai.gtll.app](https://orbitai.gtll.app) to get your API key, then:
 
 ```bash
 curl -X POST https://api.gtll.app/orbitRoute \
   -H "Content-Type: application/json" \
-  -d '{"query": "write a haiku about recursion"}'
+  -H "x-neural-secret: your-api-key" \
+  -d '{"complexity": 7, "domain": "code", "signal": "777", "api_key": "orbit_..."}'
 ```
 
 **Pricing:**
 
 | Tier | Price | Limit |
 |------|-------|-------|
-| Free | $0/mo | 100 queries/day |
-| Pro | **$9/mo** · founding rate, locked forever | Unlimited |
-| Team | **$49/mo** · founding rate, locked forever | Unlimited · 5 seats |
+| Free | $0/mo | 1,000 queries/month |
+| Pro | $19/mo | Unlimited · all models |
+| Team | $99/mo | Unlimited · 5 seats |
 
-→ [Get Pro](https://buy.stripe.com/7sY14mdHYbTE3DT4PIbwk00) · [Get Team](https://buy.stripe.com/9B67sKfQ6bTE0rHgyqbwk01)
+→ **[Upgrade to Pro — $19/mo](https://buy.stripe.com/6oE5kF3Yz5Co06s9AB)** · [Get Team](https://buy.stripe.com/9B67sKfQ6bTE0rHgyqbwk01)
+
+Dashboard + usage stats at [orbitai.gtll.app](https://orbitai.gtll.app)
 
 ---
 
+## The Resonance Vision
+
+ORBIT is the open-source core of **Resonance** — the AI operating system layer.
+
+Every enterprise AI team is bleeding on token costs. A 50-person team running 1,000 queries/day at GPT-4o spends ~$202,500/year on tokens. With signal-aware routing, that drops to ~$57,700. Resonance captures 15% of savings — you keep the rest.
+
+The signal layer is what makes this defensible. `777` queries generate ground-truth labels: "this type of query needs Claude." `333` labels: "this can run on Gemini Flash." At scale, that's a cross-model performance database no individual model provider can build. Only a model-agnostic layer builds this moat.
+
+**ORBIT is the open-source foundation. The routing engine learns from every signal.**
+
 ## Research backing
 
 - **RouteLLM (ICLR 2025, UC Berkeley):** intelligent routing achieves 85% cost reduction at 95% quality vs always-GPT-4o
-- **OpenRouter** ($500M+ valuation) proves the market. ORBIT adds the classification layer.
-- **Martian** (Accenture-backed) proves enterprises pay for routing. ORBIT is the open version.
+- **OpenRouter** ($500M+ valuation) proves the market exists. ORBIT adds the classification layer OpenRouter doesn't have.
+- **Martian** (Accenture-backed) proves enterprises pay for routing intelligence. ORBIT is the open, developer-first version.
 
 ---
 
@@ -173,8 +186,10 @@ curl -X POST https://api.gtll.app/orbitRoute \
 
 - [x] v0.1.x — 8-axis classification, 6-model routing matrix
 - [x] v0.3.x — Signal-aware routing (777/555/333), hosted gateway
-- [ ] v0.4.0 — API key gated usage dashboard
-- [ ] v0.5.0 — Embedding-based fallback for ambiguous queries
+- [x] v0.4.x — API key gated usage dashboard
+- [x] v0.5.0 — Embedding-based fallback for ambiguous queries + Pro tier unlock
+- [ ] v0.6.0 — Multi-provider streaming passthrough (OpenAI / Anthropic / Gemini)
+- [ ] v0.7.0 — Team API keys + usage aggregation dashboard
 - [ ] v1.0.0 — Enterprise API + savings-share pricing
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gabrielsmartin/orbit-sdk",
-  "version": "0.4.4",
+  "version": "0.5.1",
   "description": "Rule-based LLM router. Classifies queries across 8 axes and picks the optimal model. Fast, deterministic, zero dependencies.",
   "type": "module",
   "main": "src/index.js",
@@ -13,10 +13,12 @@
   },
   "files": [
     "src",
+    "scripts",
     "README.md"
   ],
   "scripts": {
-    "test": "node test.js"
+    "test": "node test.js",
+    "postinstall": "node scripts/postinstall.cjs"
   },
   "keywords": [
     "ai",
@@ -26,6 +28,7 @@
     "anthropic",
     "gemini",
     "orbit",
+    "resonance",
     "cost-optimization",
     "model-routing",
     "selective-model-matching",
@@ -33,7 +36,9 @@
     "claude",
     "gemini-flash",
     "grok",
-    "ai-infrastructure"
+    "ai-infrastructure",
+    "token-optimization",
+    "llm-router"
   ],
   "author": "Gabriel Martin <gabriel@gtll.app>",
   "license": "MIT",
@@ -41,7 +46,7 @@
     "type": "git",
     "url": "https://github.com/gtllco/orbit.git"
   },
-  "homepage": "https://orbitai.gtll.app",
+  "homepage": "https://github.com/gtllco/orbit",
   "bugs": {
     "url": "https://github.com/gtllco/orbit/issues"
   },

package/scripts/postinstall.cjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+'use strict';
+
+// Fires on `npm install @gabrielsmartin/orbit-sdk`
+// Captures install signal → ORBIT gateway → Supabase
+// Non-blocking, silently fails, no PII
+
+const https = require('https');
+const os = require('os');
+
+const payload = JSON.stringify({
+  action: 'npm_install',
+  package: '@gabrielsmartin/orbit-sdk',
+  version: require('../package.json').version,
+  node: process.version,
+  platform: process.platform,
+  arch: process.arch,
+  ts: new Date().toISOString(),
+});
+
+const req = https.request({
+  hostname: 'api.gtll.app',
+  path: '/npmPing',
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) },
+  timeout: 3000,
+}, () => {});
+
+req.on('error', () => {});
+req.on('timeout', () => req.destroy());
+req.write(payload);
+req.end();
+
+console.log('\n\x1b[35m  ⊙ ORBIT SDK installed\x1b[0m');
+console.log('\x1b[2m  Get your free API key + routing analytics:\x1b[0m');
+console.log('\x1b[36m  https://orbitai.gtll.app\x1b[0m\n');

package/src/fingerprint.js

@@ -9,7 +9,11 @@
 const COMPLEXITY_SIGNALS = [
   'architect','distributed','implement','design','optimize','analyze',
   'complex','system','algorithm','concurrent','scale','infrastructure',
-  'microservice','kubernetes','terraform','recursive','refactor'
+  'microservice','kubernetes','terraform','recursive','refactor',
+  'rate limit','concurren','async','thread','cache','shard','partition',
+  'replicate','encrypt','auth','oauth','webhook','pipeline','stream',
+  'batch','migration','rollback','schema','index','transaction','latency',
+  'throughput','bottleneck','profil','benchmark','test','spec'
 ];
 
 const CREATIVITY_SIGNALS = [
@@ -46,11 +50,11 @@ export function fingerprint(text) {
 
   // Complexity (0-10): reasoning depth required
   const complexitySignals = COMPLEXITY_SIGNALS.filter(s => t.includes(s)).length;
-  const questionDepth = (t.match(/\b(why|how|explain|compare|tradeoff|pros|cons|difference|analyze)\b/g) || []).length;
+  const questionDepth = (t.match(/\b(why|how|explain|compare|tradeoff|tradeoffs|versus|vs|pros|cons|difference|analyze|evaluate|review|audit)\b/g) || []).length;
   const complexity = Math.min(10, Math.round(
-    complexitySignals * 2 +
+    complexitySignals * 2.5 +
     questionDepth * 1.5 +
-    (wordCount > 30 ? 3 : wordCount > 15 ? 1.5 : 0)
+    (wordCount > 20 ? 3 : wordCount > 10 ? 1.5 : 0)
   ));
 
   // Creativity (0-10): open-ended vs deterministic

package/src/index.d.ts

@@ -32,12 +32,15 @@ export interface SavingsInfo {
 }
 
 export interface RoutingDecision {
-  model: ModelInfo;
+  model: ModelInfo | null;
   reason: string;
   rule: string;
-  scores: QueryScores;
-  savings: SavingsInfo;
+  signal: '777' | '555' | '333' | null;
+  signal_reason: string | null;
+  scores: QueryScores | null;
+  savings: SavingsInfo | null;
   timestamp: string;
+  blocked: boolean;
 }
 
 export interface OrbitConfig {
@@ -55,6 +58,7 @@ export interface RouteOptions {
   cost_tolerance?: 'low' | 'medium' | 'high';
   estimated_tokens?: number;
   blocked_models?: string[];
+  signal?: '777' | '555' | '333' | null;
 }
 
 export interface SessionStats {

package/src/index.js

@@ -2,7 +2,7 @@
  * @gabrielsmartin/orbit-sdk
  * Rule-based LLM router. Fast, deterministic, zero dependencies.
  * Picks the right model — you make the API call.
- * 
+ *
  * https://github.com/gtllco/orbit
  * 777 · 555 · 333
  */
@@ -13,13 +13,14 @@ import { route, calculateSavings, MODEL_MATRIX } from './router.js';
 export { fingerprint, applySignalBias, route, calculateSavings, MODEL_MATRIX };
 
 const GATEWAY_URL = 'https://api.gtll.app/orbitSignup';
+const ANON_QUERY_LIMIT = 10;
 
 /**
  * OrbitClient — the main class
- * 
+ *
  * @example
  * import { OrbitClient } from '@gabrielsmartin/orbit-sdk'
- * 
+ *
  * const orbit = new OrbitClient({ apiKey: 'your-key' })
  * const { model, reason, scores } = orbit.route("explain quantum entanglement")
  * // → { model: { name: 'Claude Sonnet', id: 'claude-sonnet-3-5', ... }, reason: '...', ... }
@@ -46,12 +47,30 @@ export class OrbitClient {
   /**
    * Route a query to the optimal model (local, <1ms).
    * ORBIT picks the model — your code makes the API call.
-   * 
+   *
    * @param {string} text - The query or prompt text
    * @param {Object} options - Per-query overrides: { cost_tolerance, signal, estimated_tokens, blocked_models }
-   * @returns {{ model, reason, rule, scores, savings, timestamp }}
+   * @returns {{ model, reason, rule, scores, savings, timestamp, blocked }}
    */
   route(text, options = {}) {
+    this._stats.total_queries++;
+
+    // Hard gate: unauthenticated users blocked after ANON_QUERY_LIMIT queries
+    if (!this.config.apiKey && this._stats.total_queries > ANON_QUERY_LIMIT) {
+      this._telemetry(text, { model: null, rule: 'unauthenticated_limit', scores: null, savings: null }, 'unauthenticated_limit').catch(() => {});
+      return {
+        model: null,
+        reason: 'Rate limit — get a free API key at orbitai.gtll.app',
+        rule: 'unauthenticated_limit',
+        signal: null,
+        signal_reason: null,
+        scores: null,
+        savings: null,
+        timestamp: new Date().toISOString(),
+        blocked: true,
+      };
+    }
+
     let scores = fingerprint(text);
 
     if (options.cost_tolerance) {
@@ -77,52 +96,53 @@ export class OrbitClient {
       scores,
       savings,
       timestamp: new Date().toISOString(),
+      blocked: false,
     };
 
-    // Stats
-    this._stats.total_queries++;
     this._stats.total_savings += savings.savings;
     const modelName = decision.model.name;
     this._stats.model_usage[modelName] = (this._stats.model_usage[modelName] || 0) + 1;
 
     if (this.config.log) {
       console.log(`[ORBIT] → ${decision.model.name} | ${decision.rule} | saved $${savings.savings.toFixed(5)} (${savings.reductionPct}% vs GPT-4o)`);
-
-    // Nudge unauthenticated users toward API key
-    if (!this.config.apiKey && this._stats.total_queries === 3) {
-      console.warn(`[ORBIT] Free tier: 100 API queries/day. Get your key → https://api.gtll.app/orbitSignup (POST { action: "get_key", email })`);
     }
+
+    // Nudge unauthenticated users at query 5
+    if (!this.config.apiKey && this._stats.total_queries === 5) {
+      console.warn(`\n\x1b[35m[ORBIT] You've routed 5 queries — unlock full analytics + higher limits.\x1b[0m`);
+      console.warn(`\x1b[36m  → https://orbitai.gtll.app\x1b[0m\n`);
+      this._telemetry(text, result, 'unauthenticated_nudge').catch(() => {});
     }
 
     if (this.config.on_route) {
       this.config.on_route(result);
     }
 
-    // Fire telemetry to gateway (non-blocking, best-effort)
-    if (this.config.apiKey) {
-      this._telemetry(text, result).catch(() => {});
-    }
+    // Fire telemetry on every query (non-blocking, best-effort)
+    this._telemetry(text, result).catch(() => {});
 
     return result;
   }
 
   /**
    * Send a routing decision to the ORBIT gateway for usage tracking.
-   * Only fires if apiKey is set. Non-blocking.
+   * Non-blocking, best-effort.
    * @private
    */
-  async _telemetry(query, decision) {
+  async _telemetry(query, decision, event_type = 'sdk_route') {
     try {
       await fetch(GATEWAY_URL, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({
-          query,
-          api_key: this.config.apiKey,
-          model_selected: decision.model.name,
-          rule: decision.rule,
-          signal: decision.scores?.signal || null,
-          savings_pct: decision.savings.reductionPct,
+          action: event_type,
+          api_key: this.config.apiKey || null,
+          model_selected: decision.model?.name || null,
+          rule: decision.rule || null,
+          signal: decision.scores?.signal_applied || null,
+          savings_pct: decision.savings?.reductionPct || null,
+          total_queries: this._stats.total_queries,
+          sdk_version: '0.5.0',
         }),
       });
     } catch (_) {
@@ -151,7 +171,7 @@ export class OrbitClient {
 
 /**
  * Default singleton client — zero config, ready to use
- * 
+ *
  * @example
  * import orbit from '@gabrielsmartin/orbit-sdk'
  * const { model, reason } = orbit.route("write a haiku about recursion")