@gabrielsmartin/orbit-sdk 0.2.3 → 0.3.1

package/index.js

@@ -1,14 +1,167 @@
 /**
- * @gabrielsmartin/orbit-sdk
- * Intelligent AI model routing — routes every query to the optimal model in <1ms
+ * orbit-ai · v0.3.0
+ * Intelligent AI model routing with signal-aware priority bias.
+ * Drop in. Save 85%.
  * 
- * 777 · 555 · 333
+ * https://orbitai.gtll.app
  * github.com/gtllco/orbit
+ * npm: @gabrielsmartin/orbit-sdk
+ * 
+ * 777 · 555 · 333
  */
 
-export { fingerprint, route, calculateSavings, MODEL_MATRIX, OrbitClient } from './src/index.js';
+import { fingerprint } from './fingerprint.js';
+import { route, calculateSavings, MODEL_MATRIX } from './router.js';
+import { applySignalBias, inferSignalFromEvent, formatSignalResponse, SIGNAL_DESCRIPTIONS } from './signal.js';
+
+export { fingerprint, route, calculateSavings, MODEL_MATRIX };
+export { applySignalBias, inferSignalFromEvent, formatSignalResponse, SIGNAL_DESCRIPTIONS };
+
+/**
+ * OrbitClient — the main class
+ * Now with signal-aware routing (777 · 555 · 333)
+ * 
+ * @example
+ * import { OrbitClient } from '@gabrielsmartin/orbit-sdk'
+ * const orbit = new OrbitClient()
+ * 
+ * // Without signal — standard 8-axis routing
+ * const result = orbit.route("summarize this contract")
+ * 
+ * // With signal — priority-aware routing
+ * const result = orbit.route("write the Q1 investor memo", { signal: "777" })
+ * // → Claude Sonnet mandatory. This is final form.
+ * 
+ * const result = orbit.route("what's a business model nobody's tried?", { signal: "555" })
+ * // → Grok or Claude Sonnet. Destabilize the expected.
+ * 
+ * const result = orbit.route("is this email spam?", { signal: "333" })
+ * // → Gemini Flash. Strip cost. Foundation doesn't need premium.
+ */
+export class OrbitClient {
+  constructor(config = {}) {
+    this.config = {
+      cost_tolerance: config.cost_tolerance || 'medium', // 'low' | 'medium' | 'high'
+      blocked_models: config.blocked_models || [],
+      api_key: config.apiKey || config.api_key || null,
+      log: config.log !== false,
+      on_route: config.on_route || null,
+      // Provider API keys (optional — falls back to env vars)
+      anthropic_key: config.anthropic_key || null,
+      openai_key: config.openai_key || null,
+      google_key: config.google_key || null,
+    };
+
+    this._stats = {
+      total_queries: 0,
+      total_savings: 0,
+      model_usage: {},
+      signal_usage: { '777': 0, '555': 0, '333': 0, none: 0 },
+    };
+  }
+
+  /**
+   * Route a query to the optimal model.
+   * Signal codes bias routing before model selection.
+   * 
+   * @param {string} text - The query text
+   * @param {Object} options - Override options for this query
+   * @param {string} [options.signal] - "777" | "555" | "333" | null
+   * @param {string} [options.cost_tolerance] - "low" | "medium" | "high"
+   * @param {number} [options.estimated_tokens] - Token estimate for cost calc
+   * @returns {Object} decision - { model, reason, rule, scores, savings, signal_applied, signal_reason, estimated_cost }
+   */
+  route(text, options = {}) {
+    // 1. Fingerprint
+    const rawScores = fingerprint(text);
+
+    // 2. Apply cost_tolerance override
+    if (options.cost_tolerance) {
+      rawScores.cost_tolerance = options.cost_tolerance === 'low' ? 2
+        : options.cost_tolerance === 'high' ? 9 : 5;
+    }
 
-// Default export — zero-config instance
-import { OrbitClient } from './src/index.js';
+    // 3. Apply signal bias (777 / 555 / 333)
+    const signal = options.signal || null;
+    const scores = applySignalBias(rawScores, signal);
+
+    // 4. Route
+    const config = { ...this.config, ...options };
+    const decision = route(scores, config);
+
+    // 5. Calculate savings and cost
+    const estimatedTokens = options.estimated_tokens || 500;
+    const savings = calculateSavings(decision.model, estimatedTokens);
+    const estimatedCost = `$${savings.actualCost.toFixed(5)}`;
+
+    // 6. Format signal metadata
+    const signalMeta = formatSignalResponse(scores, decision);
+
+    const result = {
+      model: decision.model,
+      reason: decision.reason,
+      rule: decision.rule,
+      scores: rawScores, // return original scores, not biased
+      signal_applied: signalMeta.signal_applied,
+      signal_reason: signalMeta.signal_reason || null,
+      savings,
+      estimated_cost: estimatedCost,
+      timestamp: new Date().toISOString(),
+    };
+
+    // Update 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;
+    this._stats.signal_usage[signal || 'none']++;
+
+    // Log routing decision
+    if (this.config.log) {
+      const signalTag = signal ? ` [signal:${signal}]` : '';
+      console.log(`[ORBIT]${signalTag} → ${decision.model.name} | ${decision.rule} | ${estimatedCost} (saved ${savings.reductionPct}%)`);
+    }
+
+    if (this.config.on_route) this.config.on_route(result);
+    return result;
+  }
+
+  /**
+   * Get cumulative stats for this session — including per-signal breakdown
+   */
+  stats() {
+    return {
+      ...this._stats,
+      total_savings_formatted: `$${this._stats.total_savings.toFixed(4)}`,
+    };
+  }
+
+  /**
+   * Fingerprint a query without routing
+   */
+  fingerprint(text) {
+    return fingerprint(text);
+  }
+
+  /**
+   * Apply signal bias to an existing fingerprint
+   * Useful for building custom routing logic on top of ORBIT
+   */
+  applySignal(fingerprint, signal_code) {
+    return applySignalBias(fingerprint, signal_code);
+  }
+
+  /**
+   * Infer signal from a neural hub event priority
+   * coral1 events tagged 777/555/333 auto-translate to signal codes
+   */
+  signalFromEvent(eventPriority) {
+    return inferSignalFromEvent(eventPriority);
+  }
+}
+
+/**
+ * Default singleton client
+ */
 const orbit = new OrbitClient();
 export default orbit;

package/package.json

@@ -1,49 +1,34 @@
 {
   "name": "@gabrielsmartin/orbit-sdk",
-  "version": "0.2.3",
-  "description": "Intelligent AI model routing. Drop-in replacement for OpenAI/Anthropic SDKs. Routes every query to the optimal model automatically.",
-  "main": "index.js",
-  "types": "index.d.ts",
+  "version": "0.3.1",
+  "description": "Intelligent AI model routing with signal-aware priority bias. 777·555·333.",
+  "type": "module",
+  "main": "./index.js",
+  "module": "./index.js",
+  "exports": {
+    ".": {
+      "import": "./index.js",
+      "default": "./index.js"
+    }
+  },
   "files": [
-    "index.js",
-    "index.d.ts",
-    "src/",
-    "README.md"
+    "*.js",
+    "index.d.ts"
   ],
-  "scripts": {
-    "test": "node test.js"
-  },
   "keywords": [
     "ai",
-    "llm",
     "routing",
-    "openai",
-    "anthropic",
-    "gemini",
+    "llm",
     "orbit",
-    "cost-optimization",
-    "model-routing"
+    "model-selection",
+    "anthropic",
+    "openai",
+    "gemini"
   ],
-  "author": "Gabriel Martin <admin@gtll.app>",
+  "author": "Gabriel Martin",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/gtllco/orbit"
-  },
-  "homepage": "https://orbit-sdk.base44.app",
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org",
-    "access": "public"
-  },
-  "module": "index.js",
-  "type": "module",
-  "exports": {
-    ".": {
-      "import": "./index.js",
-      "types": "./index.d.ts"
-    }
-  },
-  "engines": {
-    "node": ">=18.0.0"
+    "url": "https://github.com/gtllco/orbit.git"
   }
 }

package/{src/router.js → router.js}

@@ -1,6 +1,6 @@
 /**
  * ORBIT · Selective Model Matching (SMM) Router
- * Routes queries to optimal models based on 8-axis fingerprints
+ * Routes queries to optimal models based on 8-axis fingerprints + signal codes
  * 
  * Proprietary routing logic — open SDK, closed engine weights
  * 777 · 555 · 333
@@ -8,7 +8,7 @@
 
 export const MODEL_MATRIX = {
   claude_sonnet: {
-    id: 'claude-sonnet-4-5',
+    id: 'claude-sonnet-4-6',
     name: 'Claude Sonnet',
     provider: 'anthropic',
     costPer1M: 15,
@@ -17,7 +17,7 @@ export const MODEL_MATRIX = {
     tier: 'medium',
   },
   claude_haiku: {
-    id: 'claude-haiku-3-5',
+    id: 'claude-haiku-4-5',
     name: 'Claude Haiku',
     provider: 'anthropic',
     costPer1M: 1,
@@ -64,34 +64,82 @@ export const MODEL_MATRIX = {
 };
 
 /**
- * Core SMM routing logic
+ * Core SMM routing logic — Signal-aware
  * Returns the selected model + reasoning
  * 
- * @param {Object} scores - 8-axis fingerprint scores
+ * @param {Object} scores - 8-axis fingerprint scores (post-signal-bias)
  * @param {Object} config - User config (cost_tolerance override, blocked_models, etc.)
  * @returns {Object} { model, reason, fallback }
  */
 export function route(scores, config = {}) {
   const {
     complexity, creativity, speed, emotional_weight,
-    recency, context_load, domain, cost_tolerance
+    recency, context_load, domain, cost_tolerance,
+    signal_code, variation_mode
   } = scores;
 
   const blocked = config.blocked_models || [];
-  const preferLow = config.cost_tolerance === 'low' || cost_tolerance <= 3;
-  const preferHigh = config.cost_tolerance === 'high' || cost_tolerance >= 8;
+  const preferLow = cost_tolerance <= 3;
+  const preferHigh = cost_tolerance >= 8;
 
-  // Rule 1: ETHICS FIRST — emotional/crisis queries always go to Claude
+  // ── SIGNAL OVERRIDES (applied before all other rules) ──────────────────────
+
+  // 777 — Completion Bias: cost_tolerance and complexity already raised by applySignalBias.
+  // But explicitly block sub-tier models when signal=777.
+  if (signal_code === '777') {
+    // Minimum floor: Claude Haiku. Prefer Sonnet if complexity >= 5.
+    if (complexity >= 5 && !blocked.includes('claude_sonnet')) {
+      return {
+        model: MODEL_MATRIX.claude_sonnet,
+        reason: `Completion bias (777) — complexity ${complexity}/10 meets threshold. Claude Sonnet mandatory. This output is final form.`,
+        rule: 'signal_777_sonnet',
+      };
+    }
+    // complexity < 5 but still 777: Claude Haiku minimum, no Gemini Flash/GPT-4o Mini
+    if (!blocked.includes('claude_haiku')) {
+      return {
+        model: MODEL_MATRIX.claude_haiku,
+        reason: `Completion bias (777) — complexity ${complexity}/10 below Sonnet threshold but 777 enforces Claude Haiku minimum. No sub-tier models on completion events.`,
+        rule: 'signal_777_haiku',
+      };
+    }
+  }
+
+  // 555 — Variation Bias: variation_mode=true, creativity and recency already boosted.
+  // Prefer Grok when recency is elevated. Otherwise prefer creative non-default models.
+  if (signal_code === '555') {
+    if (recency >= 5 && !blocked.includes('grok')) {
+      return {
+        model: MODEL_MATRIX.grok,
+        reason: `Variation bias (555) — recency boosted to ${recency}/10. Grok for live web intelligence and unexpected angles. Destabilize the expected.`,
+        rule: 'signal_555_grok',
+      };
+    }
+    if (creativity >= 6 && !blocked.includes('claude_sonnet')) {
+      return {
+        model: MODEL_MATRIX.claude_sonnet,
+        reason: `Variation bias (555) — creativity at ${creativity}/10. Claude Sonnet for nuanced, surprising creative output.`,
+        rule: 'signal_555_claude',
+      };
+    }
+  }
+
+  // 333 — Foundation Bias: cost_tolerance dropped to 1 by applySignalBias (unless emotional override).
+  // Emotional safety net is handled by ethics rule below — it fires first.
+
+  // ── CORE ROUTING RULES ─────────────────────────────────────────────────────
+
+  // Rule 1: ETHICS FIRST — emotional/crisis queries always go to Claude (even on 333)
   if (emotional_weight >= 6) {
     return {
       model: MODEL_MATRIX.claude_sonnet,
-      reason: 'Emotional weight detected — routing to Claude for ethics-first handling. Never use a cheap model for sensitive content.',
+      reason: `Emotional weight ${emotional_weight}/10 — routing to Claude for ethics-first handling. Never use a cheap model for sensitive content.${signal_code === '333' ? ' (333 foundation bias overridden by emotional safety rule)' : ''}`,
       rule: 'ethics_first',
     };
   }
 
   // Rule 2: Realtime / current events → Grok
-  if (recency >= 7 && !blocked.includes('grok')) {
+  if (recency >= 7 && !blocked.includes('grok') && signal_code !== '777') {
     return {
       model: MODEL_MATRIX.grok,
       reason: `High recency score (${recency}/10) — Grok has live web access for current events and trending topics.`,
@@ -100,7 +148,7 @@ export function route(scores, config = {}) {
   }
 
   // Rule 3: Long context load → Claude Sonnet (200k window)
-  if (context_load >= 8 && !blocked.includes('claude_sonnet')) {
+  if (context_load >= 8 && !blocked.includes('claude_sonnet') && signal_code !== '333') {
     return {
       model: MODEL_MATRIX.claude_sonnet,
       reason: `High context load (${context_load}/10) — Claude's 200k window is the only safe choice.`,
@@ -117,8 +165,8 @@ export function route(scores, config = {}) {
     };
   }
 
-  // Rule 5: High complexity general → GPT-4o (if cost tolerance allows)
-  if (complexity >= 7 && !preferLow && !blocked.includes('gpt4o')) {
+  // Rule 5: High complexity general → GPT-4o (if cost tolerance allows and not 777/333)
+  if (complexity >= 7 && !preferLow && !blocked.includes('gpt4o') && signal_code !== '777' && signal_code !== '333') {
     return {
       model: MODEL_MATRIX.gpt4o,
       reason: `High complexity (${complexity}/10) — GPT-4o for broad knowledge and structured output.`,
@@ -126,8 +174,8 @@ export function route(scores, config = {}) {
     };
   }
 
-  // Rule 6: Creative writing → Claude Sonnet
-  if (creativity >= 5 && !blocked.includes('claude_sonnet')) {
+  // Rule 6: Creative writing → Claude Sonnet (unless 333 forcing minimum)
+  if (creativity >= 5 && !blocked.includes('claude_sonnet') && !preferLow) {
     return {
       model: MODEL_MATRIX.claude_sonnet,
       reason: `High creativity score (${creativity}/10) — Claude Sonnet for nuanced creative writing.`,
@@ -135,11 +183,11 @@ export function route(scores, config = {}) {
     };
   }
 
-  // Rule 7: Cost sensitive OR simple queries → Gemini Flash
+  // Rule 7: Cost sensitive OR simple queries OR 333 foundation → Gemini Flash
   if ((preferLow || complexity <= 3) && !blocked.includes('gemini_flash')) {
     return {
       model: MODEL_MATRIX.gemini_flash,
-      reason: `Low complexity (${complexity}/10) — Gemini 2.5 Flash delivers 95% quality at 2% of GPT-4o cost.`,
+      reason: `${signal_code === '333' ? 'Foundation bias (333) — ' : ''}Low complexity (${complexity}/10) — Gemini 2.5 Flash delivers 95% quality at 2% of GPT-4o cost.`,
       rule: 'cost_gemini',
     };
   }

package/signal.js

@@ -0,0 +1,105 @@
+/**
+ * ORBIT · Signal Layer — Priority-Aware Routing Bias
+ * 
+ * Signal codes connect the routing layer to the agent network.
+ * A 777 event means something is landing — never cut corners.
+ * A 555 event means something is shifting — route to variation.
+ * A 333 event means ambient/background — route to minimum cost.
+ * 
+ * interval(n) = base / 2^n — Recursive Beat Engine
+ * 777 · 555 · 333
+ */
+
+/**
+ * Apply signal bias to a fingerprint before routing.
+ * Mutates a COPY of the fingerprint — never the original.
+ * 
+ * @param {Object} fingerprint - 8-axis fingerprint from fingerprint.js
+ * @param {string|null} signal_code - "777" | "555" | "333" | null
+ * @returns {Object} biased fingerprint + signal metadata
+ */
+export function applySignalBias(fingerprint, signal_code) {
+  // No signal = no change
+  if (!signal_code || !['777', '555', '333'].includes(signal_code)) {
+    return { ...fingerprint, signal_code: null, signal_applied: false };
+  }
+
+  const f = { ...fingerprint };
+
+  if (signal_code === '777') {
+    // Completion Bias — this output is final form. Never cut corners.
+    // Force quality floor: raise cost_tolerance and complexity minimums.
+    f.cost_tolerance = Math.max(f.cost_tolerance, 7);
+    f.complexity = Math.max(f.complexity, 6);
+    // Note: emotional_weight guard is handled in router — Claude always if emotional_weight >= 6 anyway
+    f.signal_code = '777';
+    f.signal_applied = true;
+    f.signal_reason = 'Completion bias — cost floor raised, complexity floor raised. Quality is non-negotiable on 777 events.';
+  }
+
+  if (signal_code === '555') {
+    // Variation Bias — something is shifting. Route to surprise.
+    // Boost creativity and recency to prefer Grok/Perplexity and non-default models.
+    f.creativity = Math.max(f.creativity, 6);
+    f.recency = Math.max(f.recency, 5);
+    f.variation_mode = true; // router reads this to prefer non-default choices
+    f.signal_code = '555';
+    f.signal_applied = true;
+    f.signal_reason = 'Variation bias — creativity and recency boosted. Routing to destabilize the expected.';
+  }
+
+  if (signal_code === '333') {
+    // Foundation Bias — ambient/background. Strip cost aggressively.
+    // Exception: emotional_weight >= 7 always upgrades (crisis never gets a cheap model).
+    if (f.emotional_weight < 7) {
+      f.cost_tolerance = 1; // force minimum cost
+      f.complexity = Math.min(f.complexity, 4); // cap complexity perception
+      f.signal_code = '333';
+      f.signal_applied = true;
+      f.signal_reason = 'Foundation bias — cost floor dropped to minimum. Routing to cheapest capable model.';
+    } else {
+      // Emotional override — even on 333, safety first
+      f.signal_code = '333';
+      f.signal_applied = true;
+      f.signal_reason = 'Foundation bias requested, but emotional_weight >= 7 — safety override active. Routing to Claude.';
+    }
+  }
+
+  return f;
+}
+
+/**
+ * Infer signal code from neural hub event priority.
+ * When coral1 fires an AgentEvent, the priority field maps directly to signal codes.
+ * This is how the neural hub auto-injects signal into ORBIT routing.
+ * 
+ * @param {string} eventPriority - "777" | "555" | "333" | "444"
+ * @returns {string|null} signal_code
+ */
+export function inferSignalFromEvent(eventPriority) {
+  const map = { '777': '777', '555': '555', '333': '333' };
+  return map[eventPriority] || null;
+}
+
+/**
+ * Format signal metadata for API responses.
+ * 
+ * @param {Object} biasedFingerprint - fingerprint after applySignalBias
+ * @param {Object} routingDecision - result from route()
+ * @returns {Object} signal metadata for API response
+ */
+export function formatSignalResponse(biasedFingerprint, routingDecision) {
+  if (!biasedFingerprint.signal_applied) {
+    return { signal_applied: null };
+  }
+  return {
+    signal_applied: biasedFingerprint.signal_code,
+    signal_reason: biasedFingerprint.signal_reason,
+  };
+}
+
+export const SIGNAL_DESCRIPTIONS = {
+  '777': 'Completion · Return · Alignment — This output is final form. Quality is mandatory.',
+  '555': 'Transformation · Breakthrough — This query is exploratory. Route to variation and surprise.',
+  '333': 'Foundation · Breath · Ground — This is ambient. Route to minimum cost. Strip everything.',
+};

package/README.md

@@ -1,202 +0,0 @@
-# orbit-ai
-
-> Stop blasting every query at GPT-4o. Route intelligently. Save 85%.
-
-`orbit-ai` is a drop-in routing layer that reads the fingerprint of every AI query and sends it to the optimal model — automatically, in under 1ms.
-
-```bash
-npm install orbit-ai
-```
-
----
-
-## The problem
-
-You're probably doing this:
-
-```javascript
-const res = await openai.chat.completions.create({
-  model: "gpt-4o",  // $30/1M tokens — every single query
-  messages
-})
-```
-
-GPT-4o costs **30x more per token** than Gemini Flash. For "what's 2+2?" — you're paying Ferrari prices to drive to the mailbox.
-
-ORBIT fixes this. One line.
-
----
-
-## How it works
-
-Every query gets fingerprinted across **8 axes** in under 1ms:
-
-| Axis | What it measures |
-|---|---|
-| **Complexity** | Depth of reasoning required |
-| **Creativity** | Open-ended vs deterministic |
-| **Emotional Weight** | Sensitivity — crisis queries always go to Claude |
-| **Recency** | Need for live/current data → Grok |
-| **Context Load** | Window size needed → Claude 200k |
-| **Speed** | Latency sensitivity |
-| **Domain** | Code · Creative · Medical · Legal · General |
-| **Cost Tolerance** | Budget tier (overridable) |
-
-Then it routes to the right model. Invisibly.
-
----
-
-## Usage
-
-### Zero-config routing decision
-
-```javascript
-import orbit from 'orbit-ai'
-
-// Get the routing decision
-const decision = orbit.route("write a haiku about recursion")
-
-console.log(decision.model.name)    // "Claude Sonnet"
-console.log(decision.reason)        // "High creativity score (8/10)..."
-console.log(decision.savings)       // { savings: 0.007245, reductionPct: 97 }
-```
-
-### With your own API keys
-
-```javascript
-import { OrbitClient } from 'orbit-ai'
-
-const orbit = new OrbitClient({
-  cost_tolerance: 'low',  // 'low' | 'medium' | 'high'
-  log: true,              // logs routing decisions to console
-})
-
-// Route the query
-const { model, reason, savings } = orbit.route("explain blockchain simply")
-// [ORBIT] → Gemini 2.5 Flash | cost_gemini | saved $0.01455 (97% reduction)
-
-// Now call the model yourself with your keys
-// model.id = 'gemini-2.5-flash', model.provider = 'google'
-```
-
-### Full pipeline example (with Anthropic SDK)
-
-```javascript
-import { OrbitClient } from 'orbit-ai'
-import Anthropic from '@anthropic-ai/sdk'
-import OpenAI from 'openai'
-import { GoogleGenerativeAI } from '@google/generative-ai'
-
-const orbit = new OrbitClient({ log: true })
-
-async function smartQuery(text) {
-  const { model, reason } = orbit.route(text)
-
-  if (model.provider === 'anthropic') {
-    const client = new Anthropic()
-    return client.messages.create({
-      model: model.id,
-      max_tokens: 1024,
-      messages: [{ role: 'user', content: text }]
-    })
-  }
-
-  if (model.provider === 'openai') {
-    const client = new OpenAI()
-    return client.chat.completions.create({
-      model: model.id,
-      messages: [{ role: 'user', content: text }]
-    })
-  }
-
-  if (model.provider === 'google') {
-    const client = new GoogleGenerativeAI(process.env.GOOGLE_API_KEY)
-    const genModel = client.getGenerativeModel({ model: model.id })
-    return genModel.generateContent(text)
-  }
-}
-
-// Routes each query to the optimal model
-await smartQuery("write a poem about the ocean")           // → Claude Sonnet
-await smartQuery("what's the latest news on AI funding?")  // → Grok
-await smartQuery("what is 2+2")                            // → Gemini Flash
-await smartQuery("I've been feeling really overwhelmed")   // → Claude Sonnet (ethics-first)
-```
-
-### Session stats
-
-```javascript
-const stats = orbit.stats()
-console.log(stats.total_savings_formatted)  // "$0.2341"
-console.log(stats.model_usage)              // { "Claude Sonnet": 4, "Gemini 2.5 Flash": 12, ... }
-```
-
-### Fingerprint only (no routing)
-
-```javascript
-import { fingerprint } from 'orbit-ai'
-
-const scores = fingerprint("architect a distributed caching system for 10M users")
-// {
-//   complexity: 9,
-//   creativity: 0,
-//   domain: 'code',
-//   emotional_weight: 0,
-//   recency: 0,
-//   context_load: 3,
-//   ...
-// }
-```
-
----
-
-## Model matrix
-
-| Model | Provider | Cost/1M | Best for |
-|---|---|---|---|
-| Claude Sonnet | Anthropic | $15 | Complex reasoning · Ethics · Long context |
-| Claude Haiku | Anthropic | $1 | Speed · Summaries · Medium tasks |
-| Gemini 2.5 Flash | Google | $0.50 | High volume · Simple queries · Cost |
-| GPT-4o | OpenAI | $30 | Structured output · Broad knowledge |
-| GPT-4o Mini | OpenAI | $0.30 | Classification · Filler tasks |
-| Grok | xAI | $10 | Trending · Real-time web |
-
----
-
-## The math
-
-Validated by [RouteLLM (UC Berkeley · ICLR 2025)](https://arxiv.org/abs/2406.18665): intelligent routing achieves **85% cost reduction** while maintaining 95% of quality.
-
-For a team running 100k queries/month at GPT-4o:
-- Without ORBIT: **$1,500/month**
-- With ORBIT: **~$225/month**
-- Savings: **$1,275/month · $15,300/year**
-
----
-
-## Live demo
-
-[orbit-model-flow.base44.app](https://orbit-model-flow.base44.app) — route a real query, see the fingerprint radar, watch the savings counter.
-
----
-
-## Roadmap
-
-- [x] 8-axis fingerprinting engine
-- [x] 6-model routing matrix
-- [x] TypeScript types
-- [ ] Streaming support
-- [ ] Custom model matrix (bring your own models)
-- [ ] Automatic provider failover
-- [ ] Usage analytics dashboard integration
-- [ ] Browser extension
-
----
-
-## License
-
-MIT · Built by [Gabriel Martin](https://github.com/gabrielsmartin)
-
-*"Every model has a gravitational pull. ORBIT decides which one you need."*
-
-777 · 555 · 333

package/src/index.js

@@ -1,122 +0,0 @@
-/**
- * orbit-ai · v0.1.0
- * Intelligent AI model routing. Drop in. Save 85%.
- * 
- * https://orbit-model-flow.base44.app
- * github.com/gabrielsmartin/orbit
- * 
- * 777 · 555 · 333
- */
-
-import { fingerprint } from './fingerprint.js';
-import { route, calculateSavings, MODEL_MATRIX } from './router.js';
-
-export { fingerprint, route, calculateSavings, MODEL_MATRIX };
-
-/**
- * OrbitClient — the main class
- * 
- * @example
- * import { OrbitClient } from 'orbit-ai'
- * const orbit = new OrbitClient({ apiKey: 'your-orbit-key' })
- * const result = await orbit.query("explain quantum entanglement simply")
- */
-export class OrbitClient {
-  constructor(config = {}) {
-    this.config = {
-      cost_tolerance: config.cost_tolerance || 'medium', // 'low' | 'medium' | 'high'
-      blocked_models: config.blocked_models || [],
-      api_key: config.apiKey || config.api_key || null,
-      log: config.log !== false, // log routing decisions by default
-      on_route: config.on_route || null, // callback: (decision) => void
-      // Provider API keys (optional — falls back to env vars)
-      anthropic_key: config.anthropic_key || null,
-      openai_key: config.openai_key || null,
-      google_key: config.google_key || null,
-    };
-
-    this._stats = {
-      total_queries: 0,
-      total_savings: 0,
-      model_usage: {},
-    };
-  }
-
-  /**
-   * Route a query to the optimal model
-   * Returns the routing decision — you call the model yourself with your keys
-   * 
-   * @param {string} text - The query text
-   * @param {Object} options - Override options for this query
-   * @returns {Object} decision - { model, reason, rule, scores, savings }
-   */
-  route(text, options = {}) {
-    const scores = fingerprint(text);
-
-    // Allow per-query cost_tolerance override
-    if (options.cost_tolerance) {
-      scores.cost_tolerance = options.cost_tolerance === 'low' ? 2
-        : options.cost_tolerance === 'high' ? 9 : 5;
-    }
-
-    const config = { ...this.config, ...options };
-    const decision = route(scores, config);
-    const savings = calculateSavings(decision.model, options.estimated_tokens || 500);
-
-    const result = {
-      model: decision.model,
-      reason: decision.reason,
-      rule: decision.rule,
-      scores,
-      savings,
-      timestamp: new Date().toISOString(),
-    };
-
-    // Update 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;
-
-    // Log routing decision
-    if (this.config.log) {
-      console.log(`[ORBIT] → ${decision.model.name} | ${decision.rule} | saved $${savings.savings.toFixed(5)} (${savings.reductionPct}% reduction)`);
-    }
-
-    // Fire callback
-    if (this.config.on_route) {
-      this.config.on_route(result);
-    }
-
-    return result;
-  }
-
-  /**
-   * Get cumulative stats for this session
-   */
-  stats() {
-    return {
-      ...this._stats,
-      total_savings_formatted: `$${this._stats.total_savings.toFixed(4)}`,
-    };
-  }
-
-  /**
-   * Fingerprint a query without routing
-   * Useful for debugging or building custom routing logic on top
-   */
-  fingerprint(text) {
-    return fingerprint(text);
-  }
-}
-
-/**
- * Default singleton client — zero config, ready to use
- * 
- * @example
- * import orbit from 'orbit-ai'
- * const decision = orbit.route("write a haiku about recursion")
- * // → { model: { name: 'Claude Sonnet', ... }, reason: '...', savings: { ... } }
- */
-const orbit = new OrbitClient();
-export default orbit;