@gabrielsmartin/orbit-sdk 0.1.1 → 0.2.0

package/README.md

@@ -1,15 +1,13 @@
-# @gabrielsmartin/orbit-sdk
+# orbit-ai
 
 > Stop blasting every query at GPT-4o. Route intelligently. Save 85%.
 
-`@gabrielsmartin/orbit-sdk` 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.
+`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 @gabrielsmartin/orbit-sdk
+npm install orbit-ai
 ```
 
-**Built by [Gabriel Martin](https://www.linkedin.com/in/gabrielsmartin) · [orbit-model-flow.base44.app](https://orbit-model-flow.base44.app)**
-
 ---
 
 ## The problem
@@ -20,145 +18,185 @@ You're probably doing this:
 const res = await openai.chat.completions.create({
   model: "gpt-4o",  // $30/1M tokens — every single query
   messages
-});
+})
 ```
 
-You're overpaying by 85%. "Write a haiku" does not need GPT-4o. "What is 2+2?" does not need GPT-4o. Only ~15% of real queries actually require your most expensive model.
+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.
 
-## The solution
+---
 
-```javascript
-import orbit from '@gabrielsmartin/orbit-sdk'
+## How it works
 
-const decision = orbit.route("write a haiku about recursion")
-// → Claude Sonnet | creative_claude | saved 50%
+Every query gets fingerprinted across **8 axes** in under 1ms:
 
-const decision2 = orbit.route("what is 2+2?")
-// → Gemini 2.5 Flash | cost_gemini | saved 98%
+| 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) |
 
-const decision3 = orbit.route("I've been feeling really anxious")
-// → Claude Sonnet | ethics_first | (never routes sensitive content to cheap models)
-```
+Then it routes to the right model. Invisibly.
 
 ---
 
-## How it works
+## Usage
 
-Every query is fingerprinted across **8 axes** in under 1ms:
-
-| Axis | What it detects |
-|------|----------------|
-| `complexity` | Depth of reasoning required |
-| `creativity` | Open-ended vs. factual generation |
-| `emotional_weight` | Sensitive or crisis content |
-| `recency` | Need for real-time / live web data |
-| `context_load` | Long-document or multi-turn depth |
-| `speed` | Latency sensitivity |
-| `domain` | Code, legal, medical, creative, general |
-| `cost_tolerance` | Budget flexibility signal |
-
-Then the SMM (Selective Model Matching) engine routes:
-
-| Signal | → Model | Why |
-|--------|---------|-----|
-| Emotional weight > 6 | Claude Sonnet | Ethics-first. Always. |
-| Domain = legal/medical | Claude Sonnet | Long-context + safety |
-| Recency > 7 | Grok | Real-time web access |
-| Creativity > 5 | Claude Sonnet | Best open-ended generation |
-| Complexity < 5 | Gemini 2.5 Flash | 98% cheaper, 95% quality |
-| Trivial query | GPT-4o Mini | 99% cheaper than GPT-4o |
+### Zero-config routing decision
 
----
+```javascript
+import orbit from 'orbit-ai'
 
-## API
+// Get the routing decision
+const decision = orbit.route("write a haiku about recursion")
 
-```javascript
-import orbit, { OrbitClient, fingerprint } from '@gabrielsmartin/orbit-sdk'
+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 }
+```
 
-// Route a query
-const result = orbit.route(queryText)
-// Returns: { model, reason, savings: { reductionPct, estimatedCost, premiumCost } }
+### With your own API keys
 
-// Get session stats
-const stats = orbit.stats()
-// Returns: { queries_routed, total_savings, total_savings_formatted, breakdown }
+```javascript
+import { OrbitClient } from 'orbit-ai'
 
-// Custom config
-const client = new OrbitClient({
-  default_model: 'claude_sonnet',
-  blocked_models: ['gpt4o'],  // never route here
-  always_log: true,
+const orbit = new OrbitClient({
+  cost_tolerance: 'low',  // 'low' | 'medium' | 'high'
+  log: true,              // logs routing decisions to console
 })
 
-// Raw fingerprint
-const fp = fingerprint("write a poem about loss")
-// Returns: { complexity, creativity, emotional_weight, recency, context_load, speed, domain, cost_tolerance }
-```
+// 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'
+```
 
-## Results
+### 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)
 ```
-$ node --input-type=module << 'EOF'
-import orbit from '@gabrielsmartin/orbit-sdk'
 
-orbit.route("write a haiku about recursion")
-// [ORBIT] → Claude Sonnet | creative_claude | saved $0.00750 (50% reduction)
+### Session stats
 
-orbit.route("what is 2+2?")
-// [ORBIT] → Gemini 2.5 Flash | cost_gemini | saved $0.01475 (98% reduction)
+```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, ... }
+```
 
-orbit.route("architect a distributed cache for 10M users")
-// [ORBIT] → Claude Sonnet | default | saved $0.00750 (50% reduction)
+### Fingerprint only (no routing)
 
-console.log(orbit.stats())
-// { queries_routed: 3, total_savings_formatted: '$0.0298' }
-EOF
+```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,
+//   ...
+// }
 ```
 
-Validated by **RouteLLM (UC Berkeley / ICLR 2025)**: intelligent routing achieves **85% cost reduction** while maintaining **95% of GPT-4o quality**.
-
 ---
 
-## Hosted API (coming soon)
+## Model matrix
 
-The SDK routes decisions client-side (no API key needed, zero latency). A **hosted API with analytics dashboard** is coming for teams that want:
+| 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 |
 
-- Cross-session savings tracking
-- Routing policy editor
-- Team analytics
-- A/B cost testing
-- Custom model matrix
+---
+
+## The math
 
-**[Join the waitlist →](https://orbit-model-flow.base44.app/#waitlist)**
+Validated by [RouteLLM (UC Berkeley · ICLR 2025)](https://arxiv.org/abs/2406.18665): intelligent routing achieves **85% cost reduction** while maintaining 95% of quality.
 
-Free tier: 100 queries/day · Pro: $19/mo unlimited · Team: $99/mo
+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**
 
 ---
 
-## Research backing
+## Live demo
 
-- **RouteLLM** — UC Berkeley / ICLR 2025: *"Routing between weak and strong LLMs reduces costs by 85% while maintaining 95% quality."*
-- **OpenRouter** ($500M+ valuation) proves the market exists. ORBIT adds the intelligence layer they're missing.
-- **Martian** (Accenture-backed) proves enterprises pay for routing. ORBIT is the frictionless version.
+[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] v0.1.0 — 8-axis fingerprinting + 6-model routing matrix
-- [ ] v0.2.0 — Hosted API with API key auth + rate limiting
-- [ ] v0.3.0 — Analytics dashboard
-- [ ] v0.4.0 — Chrome extension
-- [ ] v1.0.0 — Enterprise API + savings-share pricing
+- [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 © [Gabriel Martin](https://www.linkedin.com/in/gabrielsmartin)
+MIT · Built by [Gabriel Martin](https://github.com/gabrielsmartin)
+
+*"Every model has a gravitational pull. ORBIT decides which one you need."*
 
-**[Live demo](https://orbit-model-flow.base44.app) · [GitHub](https://github.com/gabrielsmartin/orbit) · [npm](https://www.npmjs.com/package/@gabrielsmartin/orbit-sdk) · [LinkedIn](https://www.linkedin.com/in/gabrielsmartin)**
+777 · 555 · 333

package/index.js

@@ -0,0 +1,139 @@
+/**
+ * orbit-ai SDK v0.1.0
+ * Drop-in replacement for OpenAI / Anthropic SDK calls
+ * Routes every query to the optimal model via ORBIT SMM engine
+ *
+ * Usage:
+ *   import { orbit } from 'orbit-ai'
+ *   const res = await orbit.query("your query here")
+ *
+ * ORBIT Technologies · orbit-model-flow.base44.app
+ * 777 · 333
+ */
+
+const ORBIT_API = "https://orbit-model-flow.base44.app/api/functions/routeQuery";
+
+class OrbitClient {
+  constructor(config = {}) {
+    this.apiKey = config.apiKey || process.env.ORBIT_API_KEY;
+    this.costTolerance = config.costTolerance || "low";
+    this.verbose = config.verbose || false;
+  }
+
+  /**
+   * Route a query to the optimal model
+   * @param {string} queryText - The query to route
+   * @param {object} options - Optional overrides
+   * @returns {OrbitResponse}
+   */
+  async query(queryText, options = {}) {
+    const fp = this._fingerprint(queryText);
+    const { model, reasoning } = options.model
+      ? { model: options.model, reasoning: "Manual override" }
+      : this._route(fp);
+
+    if (this.verbose) {
+      console.log(`[ORBIT] Fingerprint:`, fp);
+      console.log(`[ORBIT] Selected: ${model} — ${reasoning}`);
+    }
+
+    return {
+      model,
+      reasoning,
+      fingerprint: fp,
+      estimated_cost: this._estimateCost(model, queryText.length),
+      premium_cost: this._estimateCost("gpt4o", queryText.length),
+      get savings() { return Math.max(0, this.premium_cost - this.estimated_cost); },
+    };
+  }
+
+  /**
+   * Drop-in OpenAI compatibility
+   * orbit.openai.chat.completions.create({ model: "gpt-4o", messages })
+   * → routes to optimal model, returns same response shape
+   */
+  get openai() {
+    return {
+      chat: {
+        completions: {
+          create: async (params) => {
+            const queryText = params.messages?.map(m => m.content).join(" ") || "";
+            const routing = await this.query(queryText, { costTolerance: params._orbitCostTolerance });
+            // In production: actually call the selected model here
+            return { ...routing, choices: [], _orbit_routed: true };
+          }
+        }
+      }
+    };
+  }
+
+  /** 8-axis query fingerprinting */
+  _fingerprint(text) {
+    const t = text.toLowerCase();
+    const words = t.split(/\s+/).length;
+
+    const complexity = Math.min(10, Math.round(
+      (t.match(/\b(architect|distributed|implement|design|optimize|analyze|complex|system|algorithm|concurrent|scale)\b/g)?.length || 0) * 2 +
+      (words > 20 ? 3 : words > 10 ? 1.5 : 0) +
+      (t.match(/\b(why|how|explain|compare|tradeoff)\b/g)?.length || 0) * 1.5
+    ));
+    const creativity = Math.min(10, Math.round(
+      (t.match(/\b(write|create|generate|poem|story|haiku|imagine|creative|brainstorm)\b/g)?.length || 0) * 2.5
+    ));
+    const recency = Math.min(10, Math.round(
+      (t.match(/\b(latest|current|today|news|trending|recent|now|live)\b/g)?.length || 0) * 3
+    ));
+    const emotional_weight = Math.min(10, Math.round(
+      (t.match(/\b(anxious|depressed|sad|crisis|suicide|hurt|lonely|overwhelmed|mental health)\b/g)?.length || 0) * 4 +
+      (t.match(/\b(help|struggling|hard|difficult|pain)\b/g)?.length || 0) * 1.5
+    ));
+    const context_load = Math.min(10, Math.round(
+      (words > 100 ? 9 : words > 50 ? 7 : words > 20 ? 4 : 1) +
+      (t.match(/\b(document|paper|report|summarize)\b/g)?.length || 0) * 2
+    ));
+    const speed = Math.min(10, Math.round(
+      (t.match(/\b(quick|fast|brief|short|simple|just|tldr)\b/g)?.length || 0) * 2.5 +
+      (complexity < 3 ? 3 : 0)
+    ));
+
+    let domain = "general";
+    if (t.match(/\b(code|function|algorithm|javascript|python|api|sql|bug|deploy)\b/)) domain = "code";
+    else if (t.match(/\b(poem|story|haiku|creative|write|lyrics|fiction)\b/)) domain = "creative";
+    else if (t.match(/\b(research|study|paper|science|analysis|data|statistics)\b/)) domain = "research";
+    else if (t.match(/\b(legal|law|contract|liability|compliance)\b/)) domain = "legal";
+    else if (t.match(/\b(medical|health|diagnosis|symptoms|treatment|clinical)\b/)) domain = "medical";
+
+    const cost_tolerance = (complexity > 7 || domain === "legal" || domain === "medical")
+      ? "flexible" : this.costTolerance;
+
+    return { complexity, creativity, speed, recency, emotional_weight, context_load, domain, cost_tolerance };
+  }
+
+  /** SMM routing engine */
+  _route(fp) {
+    const { complexity, creativity, recency, emotional_weight, context_load, speed, domain, cost_tolerance } = fp;
+    if (emotional_weight > 6) return { model: "claude_sonnet", reasoning: "Emotional weight detected — Claude for ethics-first handling." };
+    if (domain === "legal" || domain === "medical") return { model: "claude_sonnet", reasoning: `Domain=${domain} — ethics-first.` };
+    if (context_load > 8) return { model: "claude_sonnet", reasoning: "High context load — Claude 200k window." };
+    if (complexity > 7 && domain === "code") return { model: "gpt4o", reasoning: "High complexity code — GPT-4o structured output." };
+    if (complexity > 8) return { model: "claude_sonnet", reasoning: "Extreme complexity — Claude Sonnet." };
+    if (recency > 7) return { model: "grok", reasoning: "High recency — Grok real-time web." };
+    if (recency > 5) return { model: "perplexity", reasoning: "Recency-sensitive — Perplexity cited search." };
+    if (creativity > 7) return { model: "claude_sonnet", reasoning: "High creativity — Claude Sonnet." };
+    if (speed > 7 && complexity < 5) return { model: "gemini_flash", reasoning: "Speed priority — Gemini Flash <200ms." };
+    if (cost_tolerance === "low" && complexity < 5) return { model: "gemini_flash", reasoning: "Low cost + simple — Gemini Flash $0.50/1M." };
+    if (complexity < 3 && creativity < 3) return { model: "gpt4o_mini", reasoning: "Trivial query — GPT-4o Mini." };
+    if (complexity < 5 && speed > 5) return { model: "claude_haiku", reasoning: "Moderate complexity + speed — Claude Haiku." };
+    return { model: "claude_sonnet", reasoning: "Multi-dimensional — Claude Sonnet default." };
+  }
+
+  _estimateCost(model, textLength) {
+    const COSTS = { claude_sonnet: 15, claude_haiku: 1, gemini_flash: 0.5, gpt4o: 30, gpt4o_mini: 0.3, grok: 10, perplexity: 5, llama3: 0.1 };
+    const tokens = Math.round(textLength / 4) + 150;
+    return (tokens / 1_000_000) * (COSTS[model] || 15);
+  }
+}
+
+export const orbit = new OrbitClient();
+export { OrbitClient };
+export default orbit;

package/package.json

@@ -1,18 +1,14 @@
 {
   "name": "@gabrielsmartin/orbit-sdk",
-  "version": "0.1.1",
-  "description": "Intelligent AI model routing. Drop-in replacement for OpenAI/Anthropic. Routes every query to the optimal model automatically.",
-  "type": "module",
-  "main": "src/index.js",
-  "types": "src/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./src/index.js",
-      "types": "./src/index.d.ts"
-    }
-  },
+  "version": "0.2.0",
+  "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",
   "files": [
-    "src",
+    "index.js",
+    "index.d.ts",
+    "fingerprint.js",
+    "router.js",
     "README.md"
   ],
   "scripts": {
@@ -27,26 +23,17 @@
     "gemini",
     "orbit",
     "cost-optimization",
-    "model-routing",
-    "selective-model-matching",
-    "gpt4",
-    "claude",
-    "gemini-flash",
-    "grok",
-    "ai-infrastructure"
+    "model-routing"
   ],
   "author": "Gabriel Martin <gabriel@gtll.app>",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/gabrielsmartin/orbit.git",
-    "directory": "sdk"
-  },
-  "homepage": "https://orbit-model-flow.base44.app",
-  "bugs": {
-    "url": "https://github.com/gabrielsmartin/orbit/issues"
+    "url": "https://github.com/gtllco/orbit"
   },
-  "engines": {
-    "node": ">=16"
+  "homepage": "https://orbit-sdk.base44.app",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
   }
 }

package/src/fingerprint.js

@@ -1,102 +0,0 @@
-/**
- * ORBIT · 8-Axis Query Fingerprinting Engine
- * Scores every query across 8 dimensions in <1ms
- * 
- * interval(n) = base / 2^n — Recursive Beat Engine
- * 777 · 555 · 333
- */
-
-const COMPLEXITY_SIGNALS = [
-  'architect','distributed','implement','design','optimize','analyze',
-  'complex','system','algorithm','concurrent','scale','infrastructure',
-  'microservice','kubernetes','terraform','recursive','refactor'
-];
-
-const CREATIVITY_SIGNALS = [
-  'write','create','generate','poem','story','haiku','imagine',
-  'creative','brainstorm','ideas','invent','compose','design','narrative'
-];
-
-const RECENCY_SIGNALS = [
-  'latest','today','current','news','now','recent','trending',
-  '2024','2025','2026','live','breaking','update','this week'
-];
-
-const EMOTIONAL_SIGNALS = [
-  'feel','feeling','anxious','anxiety','depressed','depression','overwhelmed',
-  'scared','lonely','hurt','grief','trauma','crisis','suicid','help me',
-  'relationship','breakup','divorce','mental health','therapy','struggling'
-];
-
-const CODE_SIGNALS = [
-  'code','function','class','api','debug','error','syntax','compile',
-  'deploy','database','query','algorithm','javascript','python','typescript',
-  'react','node','sql','git','docker','bug','fix','implement'
-];
-
-/**
- * Fingerprint a query across 8 axes
- * @param {string} text - The query text
- * @returns {Object} scores - 0-10 score for each axis
- */
-export function fingerprint(text) {
-  const t = text.toLowerCase();
-  const words = t.split(/\s+/);
-  const wordCount = words.length;
-
-  // 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 complexity = Math.min(10, Math.round(
-    complexitySignals * 2 +
-    questionDepth * 1.5 +
-    (wordCount > 30 ? 3 : wordCount > 15 ? 1.5 : 0)
-  ));
-
-  // Creativity (0-10): open-ended vs deterministic
-  const creativitySignals = CREATIVITY_SIGNALS.filter(s => t.includes(s)).length;
-  const creativity = Math.min(10, Math.round(creativitySignals * 2.5));
-
-  // Speed (0-10): latency sensitivity
-  const speedSignals = (t.match(/\b(quick|fast|brief|tldr|short|simple|summarize|quickly)\b/g) || []).length;
-  const speed = Math.min(10, Math.round(speedSignals * 3 + (wordCount < 8 ? 3 : 0)));
-
-  // Cost tolerance (0-10): inferred from query type (overridable)
-  // Default: medium. Will be set by user config.
-  const costTolerance = 5;
-
-  // Emotional weight (0-10): sensitivity of content
-  const emotionalSignals = EMOTIONAL_SIGNALS.filter(s => t.includes(s)).length;
-  const emotional_weight = Math.min(10, Math.round(emotionalSignals * 3));
-
-  // Recency (0-10): need for live/current data
-  const recencySignals = RECENCY_SIGNALS.filter(s => t.includes(s)).length;
-  const recency = Math.min(10, Math.round(recencySignals * 3.5));
-
-  // Context load (0-10): context window size needed
-  const context_load = Math.min(10, Math.round(
-    (wordCount > 100 ? 8 : wordCount > 50 ? 5 : wordCount > 20 ? 3 : 1)
-  ));
-
-  // Domain classification
-  const codeSignals = CODE_SIGNALS.filter(s => t.includes(s)).length;
-  let domain = 'general';
-  if (codeSignals >= 2) domain = 'code';
-  else if (creativity >= 6) domain = 'creative';
-  else if (recency >= 6) domain = 'current_events';
-  else if (emotional_weight >= 5) domain = 'emotional';
-  else if (t.match(/\b(legal|law|contract|lawsuit|rights|regulation)\b/)) domain = 'legal';
-  else if (t.match(/\b(medical|doctor|symptom|diagnosis|health|drug|medicine)\b/)) domain = 'medical';
-  else if (t.match(/\b(research|study|paper|academic|journal|cite|evidence)\b/)) domain = 'research';
-
-  return {
-    complexity,
-    creativity,
-    speed,
-    cost_tolerance: costTolerance,
-    emotional_weight,
-    recency,
-    context_load,
-    domain,
-  };
-}

package/src/index.d.ts

@@ -1,80 +0,0 @@
-/**
- * orbit-ai · TypeScript definitions
- * 777 · 555 · 333
- */
-
-export interface QueryScores {
-  complexity: number;        // 0-10
-  creativity: number;        // 0-10
-  speed: number;             // 0-10
-  cost_tolerance: number;    // 0-10
-  emotional_weight: number;  // 0-10
-  recency: number;           // 0-10
-  context_load: number;      // 0-10
-  domain: 'general' | 'code' | 'creative' | 'current_events' | 'emotional' | 'legal' | 'medical' | 'research';
-}
-
-export interface ModelInfo {
-  id: string;
-  name: string;
-  provider: 'anthropic' | 'openai' | 'google' | 'xai' | 'meta';
-  costPer1M: number;
-  strengths: string[];
-  maxContext: number;
-  tier: 'very_low' | 'low' | 'medium' | 'high';
-}
-
-export interface SavingsInfo {
-  premiumCost: number;
-  actualCost: number;
-  savings: number;
-  reductionPct: number;
-}
-
-export interface RoutingDecision {
-  model: ModelInfo;
-  reason: string;
-  rule: string;
-  scores: QueryScores;
-  savings: SavingsInfo;
-  timestamp: string;
-}
-
-export interface OrbitConfig {
-  apiKey?: string;
-  cost_tolerance?: 'low' | 'medium' | 'high';
-  blocked_models?: string[];
-  log?: boolean;
-  on_route?: (decision: RoutingDecision) => void;
-  anthropic_key?: string;
-  openai_key?: string;
-  google_key?: string;
-}
-
-export interface RouteOptions {
-  cost_tolerance?: 'low' | 'medium' | 'high';
-  estimated_tokens?: number;
-  blocked_models?: string[];
-}
-
-export interface SessionStats {
-  total_queries: number;
-  total_savings: number;
-  total_savings_formatted: string;
-  model_usage: Record<string, number>;
-}
-
-export declare class OrbitClient {
-  constructor(config?: OrbitConfig);
-  route(text: string, options?: RouteOptions): RoutingDecision;
-  fingerprint(text: string): QueryScores;
-  stats(): SessionStats;
-}
-
-export declare function fingerprint(text: string): QueryScores;
-export declare function route(scores: QueryScores, config?: OrbitConfig): { model: ModelInfo; reason: string; rule: string };
-export declare function calculateSavings(model: ModelInfo, estimatedTokens?: number): SavingsInfo;
-export declare const MODEL_MATRIX: Record<string, ModelInfo>;
-
-declare const orbit: OrbitClient;
-export default orbit;

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;

package/src/router.js

@@ -1,173 +0,0 @@
-/**
- * ORBIT · Selective Model Matching (SMM) Router
- * Routes queries to optimal models based on 8-axis fingerprints
- * 
- * Proprietary routing logic — open SDK, closed engine weights
- * 777 · 555 · 333
- */
-
-export const MODEL_MATRIX = {
-  claude_sonnet: {
-    id: 'claude-sonnet-4-5',
-    name: 'Claude Sonnet',
-    provider: 'anthropic',
-    costPer1M: 15,
-    strengths: ['nuance', 'long_context', 'ethics', 'reasoning'],
-    maxContext: 200000,
-    tier: 'medium',
-  },
-  claude_haiku: {
-    id: 'claude-haiku-3-5',
-    name: 'Claude Haiku',
-    provider: 'anthropic',
-    costPer1M: 1,
-    strengths: ['speed', 'efficiency', 'summaries'],
-    maxContext: 200000,
-    tier: 'low',
-  },
-  gemini_flash: {
-    id: 'gemini-2.5-flash',
-    name: 'Gemini 2.5 Flash',
-    provider: 'google',
-    costPer1M: 0.5,
-    strengths: ['speed', 'multimodal', 'cost', 'volume'],
-    maxContext: 1000000,
-    tier: 'very_low',
-  },
-  gpt4o: {
-    id: 'gpt-4o',
-    name: 'GPT-4o',
-    provider: 'openai',
-    costPer1M: 30,
-    strengths: ['broad_knowledge', 'instruction_following', 'structured_output'],
-    maxContext: 128000,
-    tier: 'high',
-  },
-  gpt4o_mini: {
-    id: 'gpt-4o-mini',
-    name: 'GPT-4o Mini',
-    provider: 'openai',
-    costPer1M: 0.3,
-    strengths: ['classification', 'simple_tasks', 'cost'],
-    maxContext: 128000,
-    tier: 'very_low',
-  },
-  grok: {
-    id: 'grok-2',
-    name: 'Grok',
-    provider: 'xai',
-    costPer1M: 10,
-    strengths: ['realtime_web', 'trending', 'social_intelligence'],
-    maxContext: 131072,
-    tier: 'medium',
-  },
-};
-
-/**
- * Core SMM routing logic
- * Returns the selected model + reasoning
- * 
- * @param {Object} scores - 8-axis fingerprint scores
- * @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
-  } = scores;
-
-  const blocked = config.blocked_models || [];
-  const preferLow = config.cost_tolerance === 'low' || cost_tolerance <= 3;
-  const preferHigh = config.cost_tolerance === 'high' || cost_tolerance >= 8;
-
-  // Rule 1: ETHICS FIRST — emotional/crisis queries always go to Claude
-  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.',
-      rule: 'ethics_first',
-    };
-  }
-
-  // Rule 2: Realtime / current events → Grok
-  if (recency >= 7 && !blocked.includes('grok')) {
-    return {
-      model: MODEL_MATRIX.grok,
-      reason: `High recency score (${recency}/10) — Grok has live web access for current events and trending topics.`,
-      rule: 'recency_grok',
-    };
-  }
-
-  // Rule 3: Long context load → Claude Sonnet (200k window)
-  if (context_load >= 8 && !blocked.includes('claude_sonnet')) {
-    return {
-      model: MODEL_MATRIX.claude_sonnet,
-      reason: `High context load (${context_load}/10) — Claude's 200k window is the only safe choice.`,
-      rule: 'context_claude',
-    };
-  }
-
-  // Rule 4: High complexity code/reasoning
-  if (complexity >= 7 && domain === 'code' && !blocked.includes('claude_sonnet')) {
-    return {
-      model: MODEL_MATRIX.claude_sonnet,
-      reason: `Complex code task (complexity ${complexity}/10) — Claude Sonnet for deep reasoning and long context.`,
-      rule: 'complex_code',
-    };
-  }
-
-  // Rule 5: High complexity general → GPT-4o (if cost tolerance allows)
-  if (complexity >= 7 && !preferLow && !blocked.includes('gpt4o')) {
-    return {
-      model: MODEL_MATRIX.gpt4o,
-      reason: `High complexity (${complexity}/10) — GPT-4o for broad knowledge and structured output.`,
-      rule: 'complex_gpt4o',
-    };
-  }
-
-  // Rule 6: Creative writing → Claude Sonnet
-  if (creativity >= 5 && !blocked.includes('claude_sonnet')) {
-    return {
-      model: MODEL_MATRIX.claude_sonnet,
-      reason: `High creativity score (${creativity}/10) — Claude Sonnet for nuanced creative writing.`,
-      rule: 'creative_claude',
-    };
-  }
-
-  // Rule 7: Cost sensitive OR simple queries → 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.`,
-      rule: 'cost_gemini',
-    };
-  }
-
-  // Rule 8: Medium complexity → Claude Haiku (fast + cheap + capable)
-  if (complexity <= 5 && !blocked.includes('claude_haiku')) {
-    return {
-      model: MODEL_MATRIX.claude_haiku,
-      reason: `Medium complexity (${complexity}/10) — Claude Haiku balances speed, cost, and quality.`,
-      rule: 'medium_haiku',
-    };
-  }
-
-  // Default: Claude Sonnet (safest general choice)
-  return {
-    model: MODEL_MATRIX.claude_sonnet,
-    reason: 'Default routing — Claude Sonnet for reliable, high-quality responses.',
-    rule: 'default',
-  };
-}
-
-/**
- * Calculate savings vs always using GPT-4o (premium baseline)
- */
-export function calculateSavings(selectedModel, estimatedTokens = 500) {
-  const premiumCost = (MODEL_MATRIX.gpt4o.costPer1M / 1_000_000) * estimatedTokens;
-  const actualCost = (selectedModel.costPer1M / 1_000_000) * estimatedTokens;
-  const savings = premiumCost - actualCost;
-  const reductionPct = Math.round((savings / premiumCost) * 100);
-  return { premiumCost, actualCost, savings, reductionPct };
-}