@relayplane/proxy 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2685 @@
+// src/proxy.ts
+import * as http from "http";
+
+// src/storage/store.ts
+import Database from "better-sqlite3";
+
+// node_modules/nanoid/index.js
+import crypto from "crypto";
+
+// node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// node_modules/nanoid/index.js
+var POOL_SIZE_MULTIPLIER = 128;
+var pool;
+var poolOffset;
+var fillPool = (bytes) => {
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+    crypto.randomFillSync(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    crypto.randomFillSync(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+};
+var nanoid = (size = 21) => {
+  fillPool(size |= 0);
+  let id = "";
+  for (let i = poolOffset - size; i < poolOffset; i++) {
+    id += urlAlphabet[pool[i] & 63];
+  }
+  return id;
+};
+
+// src/storage/store.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+// src/storage/schema.ts
+var SCHEMA_SQL = `
+-- Runs table: stores all LLM invocations
+CREATE TABLE IF NOT EXISTS runs (
+  id TEXT PRIMARY KEY,
+  prompt TEXT NOT NULL,
+  system_prompt TEXT,
+  task_type TEXT NOT NULL,
+  model TEXT NOT NULL,
+  success INTEGER NOT NULL,
+  output TEXT,
+  error TEXT,
+  duration_ms INTEGER NOT NULL,
+  tokens_in INTEGER,
+  tokens_out INTEGER,
+  cost_usd REAL,
+  metadata TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+-- Index for task type queries
+CREATE INDEX IF NOT EXISTS idx_runs_task_type ON runs(task_type);
+
+-- Index for model queries
+CREATE INDEX IF NOT EXISTS idx_runs_model ON runs(model);
+
+-- Index for time-based queries
+CREATE INDEX IF NOT EXISTS idx_runs_created_at ON runs(created_at);
+
+-- Outcomes table: stores user feedback on runs
+CREATE TABLE IF NOT EXISTS outcomes (
+  id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL REFERENCES runs(id) ON DELETE CASCADE,
+  success INTEGER NOT NULL,
+  quality TEXT,
+  latency_satisfactory INTEGER,
+  cost_satisfactory INTEGER,
+  feedback TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  UNIQUE(run_id)
+);
+
+-- Index for run lookups
+CREATE INDEX IF NOT EXISTS idx_outcomes_run_id ON outcomes(run_id);
+
+-- Routing rules table: stores routing preferences
+CREATE TABLE IF NOT EXISTS routing_rules (
+  id TEXT PRIMARY KEY,
+  task_type TEXT NOT NULL UNIQUE,
+  preferred_model TEXT NOT NULL,
+  source TEXT NOT NULL DEFAULT 'default',
+  confidence REAL,
+  sample_count INTEGER,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+-- Index for task type lookups
+CREATE INDEX IF NOT EXISTS idx_routing_rules_task_type ON routing_rules(task_type);
+
+-- Suggestions table: stores routing improvement suggestions
+CREATE TABLE IF NOT EXISTS suggestions (
+  id TEXT PRIMARY KEY,
+  task_type TEXT NOT NULL,
+  current_model TEXT NOT NULL,
+  suggested_model TEXT NOT NULL,
+  reason TEXT NOT NULL,
+  confidence REAL NOT NULL,
+  expected_improvement TEXT NOT NULL,
+  sample_count INTEGER NOT NULL,
+  accepted INTEGER,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  accepted_at TEXT
+);
+
+-- Index for task type lookups
+CREATE INDEX IF NOT EXISTS idx_suggestions_task_type ON suggestions(task_type);
+
+-- Index for pending suggestions
+CREATE INDEX IF NOT EXISTS idx_suggestions_accepted ON suggestions(accepted);
+
+-- Schema version table for migrations
+CREATE TABLE IF NOT EXISTS schema_version (
+  version INTEGER PRIMARY KEY,
+  applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+-- Insert initial schema version
+INSERT OR IGNORE INTO schema_version (version) VALUES (1);
+`;
+var DEFAULT_ROUTING_RULES = [
+  { taskType: "code_generation", preferredModel: "anthropic:claude-3-5-haiku-latest" },
+  { taskType: "code_review", preferredModel: "anthropic:claude-3-5-haiku-latest" },
+  { taskType: "summarization", preferredModel: "anthropic:claude-3-5-haiku-latest" },
+  { taskType: "analysis", preferredModel: "anthropic:claude-3-5-haiku-latest" },
+  { taskType: "creative_writing", preferredModel: "anthropic:claude-3-5-haiku-latest" },
+  { taskType: "data_extraction", preferredModel: "anthropic:claude-3-5-haiku-latest" },
+  { taskType: "translation", preferredModel: "anthropic:claude-3-5-haiku-latest" },
+  { taskType: "question_answering", preferredModel: "anthropic:claude-3-5-haiku-latest" },
+  { taskType: "general", preferredModel: "anthropic:claude-3-5-haiku-latest" }
+];
+function generateSeedSQL() {
+  const values = DEFAULT_ROUTING_RULES.map((rule, index) => {
+    const id = `default-${rule.taskType}`;
+    return `('${id}', '${rule.taskType}', '${rule.preferredModel}', 'default', NULL, NULL, datetime('now'), datetime('now'))`;
+  }).join(",\n  ");
+  return `
+INSERT OR IGNORE INTO routing_rules (id, task_type, preferred_model, source, confidence, sample_count, created_at, updated_at)
+VALUES
+  ${values};
+`;
+}
+
+// src/storage/store.ts
+function getDefaultDbPath() {
+  return path.join(os.homedir(), ".relayplane", "data.db");
+}
+var Store = class {
+  db;
+  dbPath;
+  /**
+   * Creates a new Store instance.
+   *
+   * @param dbPath - Path to the SQLite database file. Defaults to ~/.relayplane/data.db
+   */
+  constructor(dbPath) {
+    this.dbPath = dbPath ?? getDefaultDbPath();
+    const dir = path.dirname(this.dbPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    this.db = new Database(this.dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    this.initializeSchema();
+  }
+  /**
+   * Initializes the database schema.
+   */
+  initializeSchema() {
+    this.db.exec(SCHEMA_SQL);
+    this.db.exec(generateSeedSQL());
+  }
+  /**
+   * Closes the database connection.
+   */
+  close() {
+    this.db.close();
+  }
+  /**
+   * Gets the database path.
+   */
+  getDbPath() {
+    return this.dbPath;
+  }
+  // ============================================================================
+  // Runs
+  // ============================================================================
+  /**
+   * Records a new run.
+   */
+  recordRun(run) {
+    const id = nanoid();
+    const stmt = this.db.prepare(`
+      INSERT INTO runs (id, prompt, system_prompt, task_type, model, success, output, error, duration_ms, tokens_in, tokens_out, cost_usd, metadata, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
+    `);
+    stmt.run(
+      id,
+      run.prompt,
+      run.systemPrompt,
+      run.taskType,
+      run.model,
+      run.success ? 1 : 0,
+      run.output,
+      run.error,
+      run.durationMs,
+      run.tokensIn,
+      run.tokensOut,
+      run.costUsd,
+      run.metadata
+    );
+    return id;
+  }
+  /**
+   * Gets a run by ID.
+   */
+  getRun(id) {
+    const stmt = this.db.prepare(`
+      SELECT id, prompt, system_prompt as systemPrompt, task_type as taskType, model, success, output, error, duration_ms as durationMs, tokens_in as tokensIn, tokens_out as tokensOut, cost_usd as costUsd, metadata, created_at as createdAt
+      FROM runs
+      WHERE id = ?
+    `);
+    const row = stmt.get(id);
+    if (!row) return null;
+    return {
+      ...row,
+      success: Boolean(row.success)
+    };
+  }
+  /**
+   * Gets runs with optional filters.
+   */
+  getRuns(options) {
+    const conditions = [];
+    const params = [];
+    if (options?.taskType) {
+      conditions.push("task_type = ?");
+      params.push(options.taskType);
+    }
+    if (options?.model) {
+      conditions.push("model = ?");
+      params.push(options.model);
+    }
+    if (options?.from) {
+      conditions.push("created_at >= ?");
+      params.push(options.from);
+    }
+    if (options?.to) {
+      conditions.push("created_at <= ?");
+      params.push(options.to);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limit = options?.limit ?? 100;
+    const offset = options?.offset ?? 0;
+    const stmt = this.db.prepare(`
+      SELECT id, prompt, system_prompt as systemPrompt, task_type as taskType, model, success, output, error, duration_ms as durationMs, tokens_in as tokensIn, tokens_out as tokensOut, cost_usd as costUsd, metadata, created_at as createdAt
+      FROM runs
+      ${whereClause}
+      ORDER BY created_at DESC
+      LIMIT ? OFFSET ?
+    `);
+    params.push(limit, offset);
+    const rows = stmt.all(...params);
+    return rows.map((row) => ({
+      ...row,
+      success: Boolean(row.success)
+    }));
+  }
+  /**
+   * Counts runs with optional filters.
+   */
+  countRuns(options) {
+    const conditions = [];
+    const params = [];
+    if (options?.taskType) {
+      conditions.push("task_type = ?");
+      params.push(options.taskType);
+    }
+    if (options?.model) {
+      conditions.push("model = ?");
+      params.push(options.model);
+    }
+    if (options?.from) {
+      conditions.push("created_at >= ?");
+      params.push(options.from);
+    }
+    if (options?.to) {
+      conditions.push("created_at <= ?");
+      params.push(options.to);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const stmt = this.db.prepare(`
+      SELECT COUNT(*) as count
+      FROM runs
+      ${whereClause}
+    `);
+    const row = stmt.get(...params);
+    return row.count;
+  }
+  // ============================================================================
+  // Outcomes
+  // ============================================================================
+  /**
+   * Records an outcome for a run.
+   */
+  recordOutcome(outcome) {
+    const id = nanoid();
+    const stmt = this.db.prepare(`
+      INSERT INTO outcomes (id, run_id, success, quality, latency_satisfactory, cost_satisfactory, feedback, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'))
+      ON CONFLICT(run_id) DO UPDATE SET
+        success = excluded.success,
+        quality = excluded.quality,
+        latency_satisfactory = excluded.latency_satisfactory,
+        cost_satisfactory = excluded.cost_satisfactory,
+        feedback = excluded.feedback,
+        created_at = datetime('now')
+    `);
+    stmt.run(
+      id,
+      outcome.runId,
+      outcome.success ? 1 : 0,
+      outcome.quality,
+      outcome.latencySatisfactory != null ? outcome.latencySatisfactory ? 1 : 0 : null,
+      outcome.costSatisfactory != null ? outcome.costSatisfactory ? 1 : 0 : null,
+      outcome.feedback
+    );
+    return id;
+  }
+  /**
+   * Gets an outcome for a run.
+   */
+  getOutcome(runId) {
+    const stmt = this.db.prepare(`
+      SELECT id, run_id as runId, success, quality, latency_satisfactory as latencySatisfactory, cost_satisfactory as costSatisfactory, feedback, created_at as createdAt
+      FROM outcomes
+      WHERE run_id = ?
+    `);
+    const row = stmt.get(runId);
+    if (!row) return null;
+    return {
+      ...row,
+      success: Boolean(row.success),
+      latencySatisfactory: row.latencySatisfactory != null ? Boolean(row.latencySatisfactory) : null,
+      costSatisfactory: row.costSatisfactory != null ? Boolean(row.costSatisfactory) : null
+    };
+  }
+  /**
+   * Gets outcomes with optional filters.
+   */
+  getOutcomes(options) {
+    const conditions = [];
+    const params = [];
+    if (options?.taskType) {
+      conditions.push("r.task_type = ?");
+      params.push(options.taskType);
+    }
+    if (options?.model) {
+      conditions.push("r.model = ?");
+      params.push(options.model);
+    }
+    if (options?.from) {
+      conditions.push("o.created_at >= ?");
+      params.push(options.from);
+    }
+    if (options?.to) {
+      conditions.push("o.created_at <= ?");
+      params.push(options.to);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limit = options?.limit ?? 100;
+    const stmt = this.db.prepare(`
+      SELECT o.id, o.run_id as runId, o.success, o.quality, o.latency_satisfactory as latencySatisfactory, o.cost_satisfactory as costSatisfactory, o.feedback, o.created_at as createdAt, r.task_type as taskType, r.model
+      FROM outcomes o
+      JOIN runs r ON o.run_id = r.id
+      ${whereClause}
+      ORDER BY o.created_at DESC
+      LIMIT ?
+    `);
+    params.push(limit);
+    const rows = stmt.all(...params);
+    return rows.map((row) => ({
+      ...row,
+      success: Boolean(row.success),
+      latencySatisfactory: row.latencySatisfactory != null ? Boolean(row.latencySatisfactory) : null,
+      costSatisfactory: row.costSatisfactory != null ? Boolean(row.costSatisfactory) : null
+    }));
+  }
+  // ============================================================================
+  // Routing Rules
+  // ============================================================================
+  /**
+   * Gets a routing rule for a task type.
+   */
+  getRule(taskType) {
+    const stmt = this.db.prepare(`
+      SELECT id, task_type as taskType, preferred_model as preferredModel, source, confidence, sample_count as sampleCount, created_at as createdAt, updated_at as updatedAt
+      FROM routing_rules
+      WHERE task_type = ?
+    `);
+    return stmt.get(taskType) ?? null;
+  }
+  /**
+   * Sets a routing rule for a task type.
+   */
+  setRule(taskType, preferredModel, source, confidence, sampleCount) {
+    const existingRule = this.getRule(taskType);
+    const id = existingRule?.id ?? nanoid();
+    const stmt = this.db.prepare(`
+      INSERT INTO routing_rules (id, task_type, preferred_model, source, confidence, sample_count, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))
+      ON CONFLICT(task_type) DO UPDATE SET
+        preferred_model = excluded.preferred_model,
+        source = excluded.source,
+        confidence = excluded.confidence,
+        sample_count = excluded.sample_count,
+        updated_at = datetime('now')
+    `);
+    stmt.run(id, taskType, preferredModel, source, confidence ?? null, sampleCount ?? null);
+    return id;
+  }
+  /**
+   * Lists all routing rules.
+   */
+  listRules() {
+    const stmt = this.db.prepare(`
+      SELECT id, task_type as taskType, preferred_model as preferredModel, source, confidence, sample_count as sampleCount, created_at as createdAt, updated_at as updatedAt
+      FROM routing_rules
+      ORDER BY task_type
+    `);
+    return stmt.all();
+  }
+  /**
+   * Deletes a routing rule and resets to default.
+   */
+  deleteRule(taskType) {
+    const defaultRule = DEFAULT_ROUTING_RULES.find((r) => r.taskType === taskType);
+    if (!defaultRule) return false;
+    this.setRule(taskType, defaultRule.preferredModel, "default");
+    return true;
+  }
+  // ============================================================================
+  // Suggestions
+  // ============================================================================
+  /**
+   * Records a suggestion.
+   */
+  recordSuggestion(suggestion) {
+    const id = nanoid();
+    const stmt = this.db.prepare(`
+      INSERT INTO suggestions (id, task_type, current_model, suggested_model, reason, confidence, expected_improvement, sample_count, accepted, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
+    `);
+    stmt.run(
+      id,
+      suggestion.taskType,
+      suggestion.currentModel,
+      suggestion.suggestedModel,
+      suggestion.reason,
+      suggestion.confidence,
+      suggestion.expectedImprovement,
+      suggestion.sampleCount,
+      suggestion.accepted ?? null
+    );
+    return id;
+  }
+  /**
+   * Gets a suggestion by ID.
+   */
+  getSuggestion(id) {
+    const stmt = this.db.prepare(`
+      SELECT id, task_type as taskType, current_model as currentModel, suggested_model as suggestedModel, reason, confidence, expected_improvement as expectedImprovement, sample_count as sampleCount, accepted, created_at as createdAt, accepted_at as acceptedAt
+      FROM suggestions
+      WHERE id = ?
+    `);
+    const row = stmt.get(id);
+    if (!row) return null;
+    return {
+      ...row,
+      accepted: row.accepted != null ? Boolean(row.accepted) : null
+    };
+  }
+  /**
+   * Gets pending (unaccepted) suggestions.
+   */
+  getPendingSuggestions() {
+    const stmt = this.db.prepare(`
+      SELECT id, task_type as taskType, current_model as currentModel, suggested_model as suggestedModel, reason, confidence, expected_improvement as expectedImprovement, sample_count as sampleCount, accepted, created_at as createdAt, accepted_at as acceptedAt
+      FROM suggestions
+      WHERE accepted IS NULL
+      ORDER BY confidence DESC
+    `);
+    const rows = stmt.all();
+    return rows.map((row) => ({
+      ...row,
+      accepted: row.accepted != null ? Boolean(row.accepted) : null
+    }));
+  }
+  /**
+   * Accepts a suggestion.
+   */
+  acceptSuggestion(id) {
+    const suggestion = this.getSuggestion(id);
+    if (!suggestion) return false;
+    const updateStmt = this.db.prepare(`
+      UPDATE suggestions
+      SET accepted = 1, accepted_at = datetime('now')
+      WHERE id = ?
+    `);
+    updateStmt.run(id);
+    this.setRule(
+      suggestion.taskType,
+      suggestion.suggestedModel,
+      "learned",
+      suggestion.confidence,
+      suggestion.sampleCount
+    );
+    return true;
+  }
+  /**
+   * Rejects a suggestion.
+   */
+  rejectSuggestion(id) {
+    const stmt = this.db.prepare(`
+      UPDATE suggestions
+      SET accepted = 0, accepted_at = datetime('now')
+      WHERE id = ?
+    `);
+    const result = stmt.run(id);
+    return result.changes > 0;
+  }
+  // ============================================================================
+  // Statistics
+  // ============================================================================
+  /**
+   * Gets aggregated statistics.
+   */
+  getStats(options) {
+    const conditions = [];
+    const params = [];
+    if (options?.from) {
+      conditions.push("created_at >= ?");
+      params.push(options.from);
+    }
+    if (options?.to) {
+      conditions.push("created_at <= ?");
+      params.push(options.to);
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const overallStmt = this.db.prepare(`
+      SELECT 
+        COUNT(*) as totalRuns,
+        SUM(success) as successfulRuns,
+        AVG(duration_ms) as avgDurationMs
+      FROM runs
+      ${whereClause}
+    `);
+    const overall = overallStmt.get(...params);
+    const byTaskTypeStmt = this.db.prepare(`
+      SELECT 
+        task_type as taskType,
+        COUNT(*) as runs,
+        AVG(success) as successRate,
+        AVG(duration_ms) as avgDurationMs
+      FROM runs
+      ${whereClause}
+      GROUP BY task_type
+    `);
+    const byTaskTypeRows = byTaskTypeStmt.all(...params);
+    const byTaskType = {};
+    for (const row of byTaskTypeRows) {
+      byTaskType[row.taskType] = {
+        runs: row.runs,
+        successRate: row.successRate,
+        avgDurationMs: row.avgDurationMs
+      };
+    }
+    const byModelStmt = this.db.prepare(`
+      SELECT 
+        model,
+        COUNT(*) as runs,
+        AVG(success) as successRate,
+        AVG(duration_ms) as avgDurationMs
+      FROM runs
+      ${whereClause}
+      GROUP BY model
+    `);
+    const byModelRows = byModelStmt.all(...params);
+    const byModel = {};
+    for (const row of byModelRows) {
+      byModel[row.model] = {
+        runs: row.runs,
+        successRate: row.successRate,
+        avgDurationMs: row.avgDurationMs
+      };
+    }
+    return {
+      totalRuns: overall.totalRuns,
+      successfulRuns: overall.successfulRuns ?? 0,
+      avgDurationMs: overall.avgDurationMs ?? 0,
+      byTaskType,
+      byModel
+    };
+  }
+  /**
+   * Gets statistics for learning (outcomes joined with runs).
+   */
+  getLearningStats(taskType) {
+    const stmt = this.db.prepare(`
+      SELECT 
+        r.model,
+        COUNT(*) as runs,
+        AVG(r.success) as successRate,
+        AVG(r.duration_ms) as avgDurationMs,
+        AVG(CASE WHEN o.success IS NOT NULL THEN o.success ELSE r.success END) as outcomeSuccessRate
+      FROM runs r
+      LEFT JOIN outcomes o ON r.id = o.run_id
+      WHERE r.task_type = ?
+      GROUP BY r.model
+      HAVING runs >= 5
+    `);
+    return stmt.all(taskType);
+  }
+};
+
+// src/routing/inference.ts
+var TASK_PATTERNS = {
+  code_generation: [
+    { pattern: /\b(write|create|generate|implement|build|code|develop|make)\b.{0,50}\b(function|class|code|script|program|method|module|api|endpoint|component)\b/i, weight: 10 },
+    { pattern: /\b(write|create|generate)\b.{0,30}\b(python|javascript|typescript|java|go|rust|c\+\+|ruby|php|swift)\b/i, weight: 10 },
+    { pattern: /\bcreate a.{0,30}(that|which|to)\b/i, weight: 5 },
+    { pattern: /\bimplement\b.{0,50}\b(algorithm|logic|feature)\b/i, weight: 8 },
+    { pattern: /\bcode\s+for\b/i, weight: 7 },
+    { pattern: /\bwrite me\b.{0,30}\b(code|script|function)\b/i, weight: 9 },
+    { pattern: /```[\w]*\n/i, weight: 3 }
+    // Code blocks suggest code context
+  ],
+  code_review: [
+    { pattern: /\b(review|analyze|check|audit|inspect|evaluate|assess|critique)\b.{0,30}\b(code|function|class|script|implementation|pull request|pr|diff)\b/i, weight: 10 },
+    { pattern: /\b(what'?s? wrong|find\s+(bugs?|issues?|problems?|errors?))\b.{0,30}\b(code|function|this)\b/i, weight: 9 },
+    { pattern: /\b(improve|optimize|refactor)\b.{0,30}\b(code|function|this)\b/i, weight: 7 },
+    { pattern: /\blook\s+(at|over)\s+(this|my)\s+code\b/i, weight: 8 },
+    { pattern: /\bcode\s+review\b/i, weight: 10 },
+    { pattern: /\bcan you (check|review)\b/i, weight: 5 }
+  ],
+  summarization: [
+    { pattern: /\b(summarize|summarise|summary|tldr|tl;dr|recap|condense|brief|overview)\b/i, weight: 10 },
+    { pattern: /\b(give|provide|write)\s+(me\s+)?(a\s+)?(brief|short|quick|concise)\s+(summary|overview)\b/i, weight: 9 },
+    { pattern: /\bshorten\s+(this|the)\b/i, weight: 6 },
+    { pattern: /\bin\s+(brief|short|a nutshell)\b/i, weight: 7 },
+    { pattern: /\bkey\s+(points?|takeaways?)\b/i, weight: 8 },
+    { pattern: /\bmain\s+(ideas?|points?)\b/i, weight: 7 }
+  ],
+  analysis: [
+    { pattern: /\b(analyze|analyse|analysis|examine|investigate|assess|evaluate|study)\b/i, weight: 8 },
+    { pattern: /\b(compare|contrast|differentiate|distinguish)\b.{0,30}\b(between|and)\b/i, weight: 9 },
+    { pattern: /\b(pros?\s+and\s+cons?|advantages?\s+and\s+disadvantages?|strengths?\s+and\s+weaknesses?)\b/i, weight: 9 },
+    { pattern: /\b(what\s+are|explain)\s+(the\s+)?(implications?|consequences?|effects?|impacts?)\b/i, weight: 8 },
+    { pattern: /\bbreak\s*down\b/i, weight: 6 },
+    { pattern: /\bdeep\s*dive\b/i, weight: 7 },
+    { pattern: /\bcritical(ly)?\s+(analysis|evaluation|assessment)\b/i, weight: 9 }
+  ],
+  creative_writing: [
+    { pattern: /\b(write|create|compose|craft|author)\b.{0,30}\b(story|poem|essay|article|blog|post|narrative|fiction|novel|song|lyrics)\b/i, weight: 10 },
+    { pattern: /\b(creative|imaginative|fictional)\s+(writing|story|piece)\b/i, weight: 10 },
+    { pattern: /\bonce upon a time\b/i, weight: 8 },
+    { pattern: /\b(write|tell)\s+(me\s+)?(a\s+)?(short\s+)?story\b/i, weight: 9 },
+    { pattern: /\b(brainstorm|ideate)\b.{0,30}\b(ideas?|concepts?|themes?)\b/i, weight: 7 },
+    { pattern: /\bwrite\s+(in|like)\s+(the\s+)?style\s+of\b/i, weight: 8 },
+    { pattern: /\b(catchy|creative|engaging)\s+(title|headline|tagline|slogan)\b/i, weight: 7 }
+  ],
+  data_extraction: [
+    { pattern: /\b(extract|parse|pull|get|retrieve|find|identify)\b.{0,30}\b(data|information|details?|values?|fields?|entities?|names?|numbers?|dates?|emails?|phones?|addresses?)\b/i, weight: 10 },
+    { pattern: /\b(convert|transform)\b.{0,30}\b(to|into)\s+(json|csv|xml|yaml|table|structured)\b/i, weight: 9 },
+    { pattern: /\bstructured\s+(data|output|format)\b/i, weight: 8 },
+    { pattern: /\bnamed\s+entity\s+(recognition|extraction)\b/i, weight: 10 },
+    { pattern: /\b(scrape|crawl)\b/i, weight: 6 },
+    { pattern: /\bjson\s+(output|format|schema)\b/i, weight: 7 }
+  ],
+  translation: [
+    { pattern: /\b(translate|translation|translator)\b/i, weight: 10 },
+    { pattern: /\b(convert|change)\b.{0,20}\b(to|into)\s+(english|spanish|french|german|chinese|japanese|korean|portuguese|italian|russian|arabic|hindi|dutch)\b/i, weight: 9 },
+    { pattern: /\b(in|to)\s+(english|spanish|french|german|chinese|japanese|korean|portuguese|italian|russian|arabic|hindi|dutch)\b/i, weight: 6 },
+    { pattern: /\bfrom\s+(english|spanish|french|german|chinese|japanese|korean|portuguese|italian|russian|arabic|hindi|dutch)\s+to\b/i, weight: 10 },
+    { pattern: /\blocalize|localization\b/i, weight: 7 }
+  ],
+  question_answering: [
+    { pattern: /^(what|who|where|when|why|how|which|is|are|does|do|can|could|would|should|will|did)\s/i, weight: 7 },
+    { pattern: /\?$/i, weight: 5 },
+    { pattern: /\b(explain|describe|define|what\s+is|what\s+are|tell\s+me\s+about)\b/i, weight: 8 },
+    { pattern: /\b(answer|respond|reply)\b.{0,20}\b(question|query)\b/i, weight: 9 },
+    { pattern: /\bfaq\b/i, weight: 8 },
+    { pattern: /\bi\s+(want|need)\s+to\s+know\b/i, weight: 6 },
+    { pattern: /\bcan\s+you\s+(tell|explain|help)\b/i, weight: 5 }
+  ],
+  general: [
+    // Catch-all patterns with low weights
+    { pattern: /./i, weight: 1 }
+  ]
+};
+function inferTaskType(prompt) {
+  const normalizedPrompt = prompt.trim().toLowerCase();
+  const scores = {
+    code_generation: 0,
+    code_review: 0,
+    summarization: 0,
+    analysis: 0,
+    creative_writing: 0,
+    data_extraction: 0,
+    translation: 0,
+    question_answering: 0,
+    general: 0
+  };
+  for (const [taskType, patterns] of Object.entries(TASK_PATTERNS)) {
+    for (const { pattern, weight } of patterns) {
+      if (pattern.test(prompt)) {
+        scores[taskType] += weight;
+      }
+    }
+  }
+  let maxScore = 0;
+  let inferredType = "general";
+  for (const [taskType, score] of Object.entries(scores)) {
+    if (score > maxScore) {
+      maxScore = score;
+      inferredType = taskType;
+    }
+  }
+  if (maxScore <= 1) {
+    return "general";
+  }
+  return inferredType;
+}
+function getInferenceConfidence(prompt, taskType) {
+  const patterns = TASK_PATTERNS[taskType];
+  if (!patterns) return 0;
+  let totalWeight = 0;
+  let maxPossibleWeight = 0;
+  for (const { pattern, weight } of patterns) {
+    maxPossibleWeight += weight;
+    if (pattern.test(prompt)) {
+      totalWeight += weight;
+    }
+  }
+  if (maxPossibleWeight === 0) return 0;
+  return Math.min(totalWeight / maxPossibleWeight, 0.95);
+}
+
+// src/routing/engine.ts
+var RoutingEngine = class {
+  store;
+  /**
+   * Creates a new RoutingEngine.
+   *
+   * @param store - The storage instance to use
+   */
+  constructor(store) {
+    this.store = store;
+  }
+  /**
+   * Infers the task type from a prompt.
+   *
+   * @param prompt - The prompt to analyze
+   * @returns The inferred task type
+   */
+  inferTaskType(prompt) {
+    return inferTaskType(prompt);
+  }
+  /**
+   * Gets the inference confidence for a task type.
+   *
+   * @param prompt - The prompt to analyze
+   * @param taskType - The task type to check
+   * @returns Confidence score (0-1)
+   */
+  getInferenceConfidence(prompt, taskType) {
+    return getInferenceConfidence(prompt, taskType);
+  }
+  /**
+   * Gets the routing rule for a task type.
+   *
+   * @param taskType - The task type to get the rule for
+   * @returns The routing rule, or null if not found
+   */
+  get(taskType) {
+    const record = this.store.getRule(taskType);
+    if (!record) return null;
+    return {
+      id: record.id,
+      taskType: record.taskType,
+      preferredModel: record.preferredModel,
+      source: record.source,
+      confidence: record.confidence ?? void 0,
+      sampleCount: record.sampleCount ?? void 0,
+      createdAt: record.createdAt,
+      updatedAt: record.updatedAt
+    };
+  }
+  /**
+   * Sets a routing rule for a task type.
+   *
+   * @param taskType - The task type to set the rule for
+   * @param preferredModel - The preferred model (format: "provider:model")
+   * @param source - How the rule was created
+   * @param options - Optional confidence and sample count
+   * @returns The rule ID
+   */
+  set(taskType, preferredModel, source = "user", options) {
+    return this.store.setRule(
+      taskType,
+      preferredModel,
+      source,
+      options?.confidence,
+      options?.sampleCount
+    );
+  }
+  /**
+   * Lists all routing rules.
+   *
+   * @returns Array of all routing rules
+   */
+  list() {
+    const records = this.store.listRules();
+    return records.map((record) => ({
+      id: record.id,
+      taskType: record.taskType,
+      preferredModel: record.preferredModel,
+      source: record.source,
+      confidence: record.confidence ?? void 0,
+      sampleCount: record.sampleCount ?? void 0,
+      createdAt: record.createdAt,
+      updatedAt: record.updatedAt
+    }));
+  }
+  /**
+   * Deletes a routing rule and resets to default.
+   *
+   * @param taskType - The task type to reset
+   * @returns True if the rule was reset
+   */
+  delete(taskType) {
+    return this.store.deleteRule(taskType);
+  }
+  /**
+   * Gets the preferred model for a task type.
+   *
+   * @param taskType - The task type
+   * @returns The preferred model string, or a default
+   */
+  getPreferredModel(taskType) {
+    const rule = this.get(taskType);
+    return rule?.preferredModel ?? "local:llama3.2";
+  }
+  /**
+   * Parses a model string into provider and model name.
+   *
+   * @param modelString - The model string (format: "provider:model")
+   * @returns Object with provider and model
+   */
+  parseModel(modelString) {
+    const parts = modelString.split(":");
+    if (parts.length < 2) {
+      return { provider: "local", model: modelString };
+    }
+    return { provider: parts[0], model: parts.slice(1).join(":") };
+  }
+  /**
+   * Resolves the model to use for a prompt.
+   *
+   * @param prompt - The prompt to analyze
+   * @param overrideTaskType - Optional task type override
+   * @param overrideModel - Optional model override
+   * @returns Object with resolved taskType, model, provider, and confidence
+   */
+  resolve(prompt, overrideTaskType, overrideModel) {
+    const taskType = overrideTaskType ?? this.inferTaskType(prompt);
+    const confidence = this.getInferenceConfidence(prompt, taskType);
+    let model;
+    if (overrideModel) {
+      model = overrideModel;
+    } else {
+      model = this.getPreferredModel(taskType);
+    }
+    const { provider, model: modelName } = this.parseModel(model);
+    return {
+      taskType,
+      model,
+      provider,
+      modelName,
+      confidence
+    };
+  }
+};
+
+// src/learning/outcomes.ts
+var OutcomeRecorder = class {
+  store;
+  /**
+   * Creates a new OutcomeRecorder.
+   *
+   * @param store - The storage instance to use
+   */
+  constructor(store) {
+    this.store = store;
+  }
+  /**
+   * Records an outcome for a run.
+   *
+   * @param input - The outcome input
+   * @returns The recorded outcome
+   * @throws If the run ID is not found
+   */
+  record(input) {
+    const run = this.store.getRun(input.runId);
+    if (!run) {
+      throw new Error(`Run not found: ${input.runId}`);
+    }
+    const id = this.store.recordOutcome({
+      runId: input.runId,
+      success: input.success,
+      quality: input.quality ?? null,
+      latencySatisfactory: input.latencySatisfactory ?? null,
+      costSatisfactory: input.costSatisfactory ?? null,
+      feedback: input.feedback ?? null
+    });
+    const outcome = this.store.getOutcome(input.runId);
+    if (!outcome) {
+      throw new Error("Failed to record outcome");
+    }
+    return {
+      id: outcome.id,
+      runId: outcome.runId,
+      success: outcome.success,
+      quality: outcome.quality ?? void 0,
+      latencySatisfactory: outcome.latencySatisfactory ?? void 0,
+      costSatisfactory: outcome.costSatisfactory ?? void 0,
+      feedback: outcome.feedback ?? void 0,
+      recordedAt: outcome.createdAt
+    };
+  }
+  /**
+   * Gets an outcome for a run.
+   *
+   * @param runId - The run ID
+   * @returns The outcome, or null if not found
+   */
+  get(runId) {
+    const outcome = this.store.getOutcome(runId);
+    if (!outcome) return null;
+    return {
+      id: outcome.id,
+      runId: outcome.runId,
+      success: outcome.success,
+      quality: outcome.quality ?? void 0,
+      latencySatisfactory: outcome.latencySatisfactory ?? void 0,
+      costSatisfactory: outcome.costSatisfactory ?? void 0,
+      feedback: outcome.feedback ?? void 0,
+      recordedAt: outcome.createdAt
+    };
+  }
+  /**
+   * Gets outcome statistics for a task type.
+   *
+   * @param taskType - The task type to get stats for
+   * @returns Outcome statistics
+   */
+  getTaskStats(taskType) {
+    const outcomes = this.store.getOutcomes({ taskType, limit: 1e3 });
+    if (outcomes.length === 0) {
+      return {
+        totalOutcomes: 0,
+        successRate: 0,
+        qualityDistribution: {},
+        latencySatisfactionRate: 0,
+        costSatisfactionRate: 0
+      };
+    }
+    let successCount = 0;
+    let latencySatisfiedCount = 0;
+    let latencyRatedCount = 0;
+    let costSatisfiedCount = 0;
+    let costRatedCount = 0;
+    const qualityDistribution = {};
+    for (const outcome of outcomes) {
+      if (outcome.success) successCount++;
+      if (outcome.quality) {
+        qualityDistribution[outcome.quality] = (qualityDistribution[outcome.quality] ?? 0) + 1;
+      }
+      if (outcome.latencySatisfactory != null) {
+        latencyRatedCount++;
+        if (outcome.latencySatisfactory) latencySatisfiedCount++;
+      }
+      if (outcome.costSatisfactory != null) {
+        costRatedCount++;
+        if (outcome.costSatisfactory) costSatisfiedCount++;
+      }
+    }
+    return {
+      totalOutcomes: outcomes.length,
+      successRate: successCount / outcomes.length,
+      qualityDistribution,
+      latencySatisfactionRate: latencyRatedCount > 0 ? latencySatisfiedCount / latencyRatedCount : 0,
+      costSatisfactionRate: costRatedCount > 0 ? costSatisfiedCount / costRatedCount : 0
+    };
+  }
+};
+
+// src/learning/savings.ts
+var MODEL_PRICING = {
+  // Anthropic models
+  "claude-3-5-haiku-latest": { input: 0.25, output: 1.25 },
+  "claude-3-5-haiku-20241022": { input: 0.25, output: 1.25 },
+  "claude-3-5-sonnet-latest": { input: 3, output: 15 },
+  "claude-3-5-sonnet-20241022": { input: 3, output: 15 },
+  "claude-sonnet-4-20250514": { input: 3, output: 15 },
+  "claude-3-opus-latest": { input: 15, output: 75 },
+  "claude-3-opus-20240229": { input: 15, output: 75 },
+  "claude-opus-4-5-20250514": { input: 15, output: 75 },
+  // OpenAI models
+  "gpt-4o": { input: 2.5, output: 10 },
+  "gpt-4o-mini": { input: 0.15, output: 0.6 },
+  "gpt-4.1": { input: 2, output: 8 },
+  "gpt-4-turbo": { input: 10, output: 30 },
+  // Google models
+  "gemini-1.5-flash": { input: 0.075, output: 0.3 },
+  "gemini-1.5-pro": { input: 1.25, output: 5 },
+  "gemini-2.0-flash": { input: 0.1, output: 0.4 },
+  // xAI models
+  "grok-2": { input: 2, output: 10 },
+  "grok-2-latest": { input: 2, output: 10 },
+  // Moonshot models
+  "moonshot-v1-8k": { input: 0.1, output: 0.1 },
+  "moonshot-v1-32k": { input: 0.2, output: 0.2 }
+};
+var BASELINE_MODEL = "claude-3-opus-latest";
+function calculateCost(model, tokensIn, tokensOut) {
+  const modelName = model.includes(":") ? model.split(":")[1] : model;
+  const pricing = MODEL_PRICING[modelName] ?? MODEL_PRICING[model] ?? { input: 1, output: 3 };
+  const inputCost = tokensIn / 1e6 * pricing.input;
+  const outputCost = tokensOut / 1e6 * pricing.output;
+  return inputCost + outputCost;
+}
+function getModelPricing(model) {
+  const modelName = model.includes(":") ? model.split(":")[1] : model;
+  return MODEL_PRICING[modelName] ?? MODEL_PRICING[model] ?? null;
+}
+function calculateSavings(store, days = 30) {
+  const to = /* @__PURE__ */ new Date();
+  const from = /* @__PURE__ */ new Date();
+  from.setDate(from.getDate() - days);
+  const fromStr = from.toISOString();
+  const toStr = to.toISOString();
+  const runs = store.getRuns({
+    from: fromStr,
+    to: toStr,
+    limit: 1e5
+    // Get all runs
+  });
+  const byModel = {};
+  const byTaskType = {};
+  let totalTokensIn = 0;
+  let totalTokensOut = 0;
+  let actualCost = 0;
+  let baselineCost = 0;
+  const baselinePricing = MODEL_PRICING[BASELINE_MODEL] ?? { input: 15, output: 75 };
+  for (const run of runs) {
+    const tokensIn = run.tokensIn ?? 0;
+    const tokensOut = run.tokensOut ?? 0;
+    const modelName = run.model.includes(":") ? run.model.split(":")[1] ?? run.model : run.model;
+    const runCost = calculateCost(run.model, tokensIn, tokensOut);
+    actualCost += runCost;
+    const baselineRunCost = tokensIn / 1e6 * (baselinePricing?.input ?? 15) + tokensOut / 1e6 * (baselinePricing?.output ?? 75);
+    baselineCost += baselineRunCost;
+    totalTokensIn += tokensIn;
+    totalTokensOut += tokensOut;
+    if (!byModel[modelName]) {
+      byModel[modelName] = {
+        runs: 0,
+        tokensIn: 0,
+        tokensOut: 0,
+        cost: 0,
+        successRate: 0,
+        avgLatencyMs: 0
+      };
+    }
+    const modelStats = byModel[modelName];
+    modelStats.runs++;
+    modelStats.tokensIn += tokensIn;
+    modelStats.tokensOut += tokensOut;
+    modelStats.cost += runCost;
+    modelStats.avgLatencyMs += run.durationMs;
+    if (run.success) {
+      modelStats.successRate++;
+    }
+    if (!byTaskType[run.taskType]) {
+      byTaskType[run.taskType] = { runs: 0, cost: 0, totalCost: 0 };
+    }
+    const taskStats = byTaskType[run.taskType];
+    taskStats.runs++;
+    taskStats.totalCost += runCost;
+  }
+  for (const model of Object.keys(byModel)) {
+    const stats = byModel[model];
+    stats.successRate = stats.runs > 0 ? stats.successRate / stats.runs : 0;
+    stats.avgLatencyMs = stats.runs > 0 ? stats.avgLatencyMs / stats.runs : 0;
+  }
+  const byTaskTypeFinal = {};
+  for (const [taskType, stats] of Object.entries(byTaskType)) {
+    byTaskTypeFinal[taskType] = {
+      runs: stats.runs,
+      cost: stats.totalCost,
+      avgCostPerRun: stats.runs > 0 ? stats.totalCost / stats.runs : 0
+    };
+  }
+  const savings = baselineCost - actualCost;
+  const savingsPercent = baselineCost > 0 ? savings / baselineCost * 100 : 0;
+  return {
+    periodDays: days,
+    period: {
+      from: fromStr,
+      to: toStr
+    },
+    totalRuns: runs.length,
+    totalTokensIn,
+    totalTokensOut,
+    actualCost,
+    baselineCost,
+    savings: Math.max(0, savings),
+    // Don't report negative savings
+    savingsPercent: Math.max(0, savingsPercent),
+    byModel,
+    byTaskType: byTaskTypeFinal
+  };
+}
+
+// src/learning/patterns.ts
+var MIN_RUNS_FOR_SUGGESTION = 10;
+var MIN_CONFIDENCE_THRESHOLD = 0.6;
+var MIN_IMPROVEMENT_THRESHOLD = 0.1;
+var MIN_COST_IMPROVEMENT_THRESHOLD = 0.2;
+var PatternDetector = class {
+  store;
+  /**
+   * Creates a new PatternDetector.
+   *
+   * @param store - The storage instance to use
+   */
+  constructor(store) {
+    this.store = store;
+  }
+  /**
+   * Analyzes a task type and generates suggestions if appropriate.
+   *
+   * @param taskType - The task type to analyze
+   * @returns Array of suggestions
+   */
+  analyzeTaskType(taskType) {
+    const stats = this.store.getLearningStats(taskType);
+    if (stats.length < 2) {
+      return [];
+    }
+    const currentRule = this.store.getRule(taskType);
+    if (!currentRule) return [];
+    const currentModel = currentRule.preferredModel;
+    const currentStats = stats.find((s) => s.model === currentModel);
+    if (!currentStats) return [];
+    const currentModelName = currentModel.includes(":") ? currentModel.split(":")[1] : currentModel;
+    const currentPricing = MODEL_PRICING[currentModelName];
+    const suggestions = [];
+    for (const modelStats of stats) {
+      if (modelStats.model === currentModel) continue;
+      if (modelStats.runs < MIN_RUNS_FOR_SUGGESTION) continue;
+      const successImprovement = modelStats.outcomeSuccessRate - currentStats.outcomeSuccessRate;
+      const latencyImprovement = (currentStats.avgDurationMs - modelStats.avgDurationMs) / currentStats.avgDurationMs;
+      const suggestedModelName = modelStats.model.includes(":") ? modelStats.model.split(":")[1] : modelStats.model;
+      const suggestedPricing = MODEL_PRICING[suggestedModelName];
+      let costImprovement = 0;
+      if (currentPricing && suggestedPricing) {
+        const currentAvgCost = (currentPricing.input + currentPricing.output) / 2;
+        const suggestedAvgCost = (suggestedPricing.input + suggestedPricing.output) / 2;
+        costImprovement = (currentAvgCost - suggestedAvgCost) / currentAvgCost;
+      }
+      const isSignificantlyBetter = successImprovement > MIN_IMPROVEMENT_THRESHOLD || successImprovement >= 0 && latencyImprovement > MIN_IMPROVEMENT_THRESHOLD || successImprovement >= -0.05 && costImprovement > MIN_COST_IMPROVEMENT_THRESHOLD;
+      if (!isSignificantlyBetter) continue;
+      const sampleConfidence = Math.min(modelStats.runs / 50, 1);
+      const improvementConfidence = Math.min(
+        Math.abs(successImprovement) / 0.3 + Math.abs(latencyImprovement) / 0.5 + Math.abs(costImprovement) / 0.5,
+        1
+      );
+      const confidence = (sampleConfidence + improvementConfidence) / 2;
+      if (confidence < MIN_CONFIDENCE_THRESHOLD) continue;
+      const reasons = [];
+      if (successImprovement > 0) {
+        reasons.push(`${(successImprovement * 100).toFixed(0)}% higher success rate`);
+      }
+      if (latencyImprovement > 0) {
+        reasons.push(`${(latencyImprovement * 100).toFixed(0)}% faster`);
+      }
+      if (costImprovement > 0) {
+        reasons.push(`${(costImprovement * 100).toFixed(0)}% cheaper`);
+      }
+      const suggestion = {
+        id: nanoid(),
+        taskType,
+        currentModel,
+        suggestedModel: modelStats.model,
+        reason: reasons.join(", "),
+        confidence,
+        expectedImprovement: {
+          successRate: successImprovement > 0 ? successImprovement : void 0,
+          latency: latencyImprovement > 0 ? latencyImprovement : void 0,
+          cost: costImprovement > 0 ? costImprovement : void 0
+        },
+        sampleCount: modelStats.runs,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      suggestions.push(suggestion);
+    }
+    suggestions.sort((a, b) => b.confidence - a.confidence);
+    return suggestions;
+  }
+  /**
+   * Analyzes all task types and generates suggestions.
+   *
+   * @returns Array of all suggestions across task types
+   */
+  analyzeAll() {
+    const taskTypes = [
+      "code_generation",
+      "code_review",
+      "summarization",
+      "analysis",
+      "creative_writing",
+      "data_extraction",
+      "translation",
+      "question_answering",
+      "general"
+    ];
+    const allSuggestions = [];
+    for (const taskType of taskTypes) {
+      const suggestions = this.analyzeTaskType(taskType);
+      allSuggestions.push(...suggestions);
+    }
+    allSuggestions.sort((a, b) => b.confidence - a.confidence);
+    return allSuggestions;
+  }
+  /**
+   * Stores suggestions in the database.
+   *
+   * @param suggestions - The suggestions to store
+   * @returns Array of suggestion IDs
+   */
+  storeSuggestions(suggestions) {
+    const ids = [];
+    for (const suggestion of suggestions) {
+      const id = this.store.recordSuggestion({
+        taskType: suggestion.taskType,
+        currentModel: suggestion.currentModel,
+        suggestedModel: suggestion.suggestedModel,
+        reason: suggestion.reason,
+        confidence: suggestion.confidence,
+        expectedImprovement: JSON.stringify(suggestion.expectedImprovement),
+        sampleCount: suggestion.sampleCount,
+        accepted: null
+      });
+      ids.push(id);
+    }
+    return ids;
+  }
+  /**
+   * Generates and stores new suggestions, returning only new ones.
+   *
+   * @returns Array of new suggestions
+   */
+  generateSuggestions() {
+    const suggestions = this.analyzeAll();
+    const pending = this.store.getPendingSuggestions();
+    const existingKeys = new Set(
+      pending.map((s) => `${s.taskType}:${s.suggestedModel}`)
+    );
+    const newSuggestions = suggestions.filter(
+      (s) => !existingKeys.has(`${s.taskType}:${s.suggestedModel}`)
+    );
+    this.storeSuggestions(newSuggestions);
+    return newSuggestions;
+  }
+};
+
+// src/relay.ts
+var RelayPlane = class {
+  store;
+  _routing;
+  outcomeRecorder;
+  patternDetector;
+  config;
+  adapterRegistry = null;
+  /**
+   * Creates a new RelayPlane instance.
+   *
+   * @param config - Configuration options
+   */
+  constructor(config = {}) {
+    this.config = {
+      dbPath: config.dbPath ?? getDefaultDbPath(),
+      defaultProvider: config.defaultProvider ?? "local",
+      defaultModel: config.defaultModel ?? "llama3.2",
+      providers: config.providers ?? {}
+    };
+    this.store = new Store(this.config.dbPath);
+    this._routing = new RoutingEngine(this.store);
+    this.outcomeRecorder = new OutcomeRecorder(this.store);
+    this.patternDetector = new PatternDetector(this.store);
+  }
+  /**
+   * Gets the routing engine for direct access.
+   */
+  get routing() {
+    return this._routing;
+  }
+  /**
+   * Runs a prompt through the appropriate model.
+   *
+   * @param input - The run input
+   * @returns The run result
+   */
+  async run(input) {
+    const startTime = Date.now();
+    const resolved = this._routing.resolve(input.prompt, input.taskType, input.model);
+    const adapter = await this.getAdapter(resolved.provider);
+    if (!adapter) {
+      const runId2 = this.store.recordRun({
+        prompt: input.prompt,
+        systemPrompt: input.systemPrompt ?? null,
+        taskType: resolved.taskType,
+        model: resolved.model,
+        success: false,
+        output: null,
+        error: `No adapter configured for provider: ${resolved.provider}`,
+        durationMs: Date.now() - startTime,
+        tokensIn: null,
+        tokensOut: null,
+        costUsd: null,
+        metadata: input.metadata ? JSON.stringify(input.metadata) : null
+      });
+      return {
+        runId: runId2,
+        success: false,
+        error: `No adapter configured for provider: ${resolved.provider}`,
+        taskType: resolved.taskType,
+        model: resolved.model,
+        durationMs: Date.now() - startTime,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    const providerConfig = this.config.providers?.[resolved.provider];
+    const apiKey = providerConfig?.apiKey ?? this.getEnvApiKey(resolved.provider);
+    const fullInput = input.systemPrompt ? `${input.systemPrompt}
+
+${input.prompt}` : input.prompt;
+    const result = await adapter.execute({
+      model: resolved.modelName,
+      input: fullInput,
+      apiKey: apiKey ?? "",
+      baseUrl: providerConfig?.baseUrl
+    });
+    const durationMs = Date.now() - startTime;
+    const tokensIn = result.tokensIn ?? 0;
+    const tokensOut = result.tokensOut ?? 0;
+    const costUsd = calculateCost(resolved.model, tokensIn, tokensOut);
+    const runId = this.store.recordRun({
+      prompt: input.prompt,
+      systemPrompt: input.systemPrompt ?? null,
+      taskType: resolved.taskType,
+      model: resolved.model,
+      success: result.success,
+      output: result.output ?? null,
+      error: result.error?.message ?? null,
+      durationMs,
+      tokensIn: result.tokensIn ?? null,
+      tokensOut: result.tokensOut ?? null,
+      costUsd: costUsd > 0 ? costUsd : null,
+      metadata: input.metadata ? JSON.stringify(input.metadata) : null
+    });
+    return {
+      runId,
+      success: result.success,
+      output: result.output,
+      error: result.error?.message,
+      taskType: resolved.taskType,
+      model: resolved.model,
+      durationMs,
+      tokensIn: result.tokensIn,
+      tokensOut: result.tokensOut,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Gets an adapter for a provider.
+   * Note: In the standalone proxy package, adapters are not used.
+   * The proxy handles provider calls directly via HTTP.
+   */
+  async getAdapter(_provider) {
+    return null;
+  }
+  /**
+   * Gets an API key from environment variables.
+   */
+  getEnvApiKey(provider) {
+    const envVars = {
+      openai: "OPENAI_API_KEY",
+      anthropic: "ANTHROPIC_API_KEY",
+      google: "GOOGLE_API_KEY",
+      xai: "XAI_API_KEY",
+      moonshot: "MOONSHOT_API_KEY",
+      local: ""
+    };
+    const envVar = envVars[provider];
+    return envVar ? process.env[envVar] : void 0;
+  }
+  /**
+   * Records an outcome for a run.
+   *
+   * @param runId - The run ID
+   * @param outcome - The outcome details
+   * @returns The recorded outcome
+   */
+  recordOutcome(runId, outcome) {
+    return this.outcomeRecorder.record({
+      runId,
+      ...outcome
+    });
+  }
+  /**
+   * Gets an outcome for a run.
+   *
+   * @param runId - The run ID
+   * @returns The outcome, or null if not found
+   */
+  getOutcome(runId) {
+    return this.outcomeRecorder.get(runId);
+  }
+  /**
+   * Gets statistics for runs.
+   *
+   * @param options - Optional filters
+   * @returns Statistics object
+   */
+  stats(options) {
+    const raw = this.store.getStats(options);
+    const byTaskType = {};
+    const taskTypes = [
+      "code_generation",
+      "code_review",
+      "summarization",
+      "analysis",
+      "creative_writing",
+      "data_extraction",
+      "translation",
+      "question_answering",
+      "general"
+    ];
+    for (const taskType of taskTypes) {
+      const taskStats = raw.byTaskType[taskType];
+      byTaskType[taskType] = {
+        taskType,
+        totalRuns: taskStats?.runs ?? 0,
+        successfulRuns: Math.round((taskStats?.runs ?? 0) * (taskStats?.successRate ?? 0)),
+        successRate: taskStats?.successRate ?? 0,
+        avgDurationMs: taskStats?.avgDurationMs ?? 0,
+        byModel: {}
+      };
+    }
+    for (const [model, modelStats] of Object.entries(raw.byModel)) {
+      for (const taskType of taskTypes) {
+        if (!byTaskType[taskType].byModel[model]) {
+          byTaskType[taskType].byModel[model] = {
+            runs: 0,
+            successRate: 0,
+            avgDurationMs: 0
+          };
+        }
+      }
+    }
+    return {
+      totalRuns: raw.totalRuns,
+      overallSuccessRate: raw.totalRuns > 0 ? raw.successfulRuns / raw.totalRuns : 0,
+      byTaskType,
+      period: {
+        from: options?.from ?? "",
+        to: options?.to ?? (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+  }
+  /**
+   * Gets a savings report.
+   *
+   * @param days - Number of days to include (default: 30)
+   * @returns Savings report
+   */
+  savingsReport(days = 30) {
+    return calculateSavings(this.store, days);
+  }
+  /**
+   * Gets routing improvement suggestions.
+   *
+   * @returns Array of suggestions
+   */
+  getSuggestions() {
+    const pending = this.store.getPendingSuggestions();
+    return pending.map((record) => ({
+      id: record.id,
+      taskType: record.taskType,
+      currentModel: record.currentModel,
+      suggestedModel: record.suggestedModel,
+      reason: record.reason,
+      confidence: record.confidence,
+      expectedImprovement: JSON.parse(record.expectedImprovement),
+      sampleCount: record.sampleCount,
+      createdAt: record.createdAt,
+      accepted: record.accepted ?? void 0,
+      acceptedAt: record.acceptedAt ?? void 0
+    }));
+  }
+  /**
+   * Generates new suggestions based on current data.
+   *
+   * @returns Array of newly generated suggestions
+   */
+  generateSuggestions() {
+    return this.patternDetector.generateSuggestions();
+  }
+  /**
+   * Accepts a suggestion and updates routing.
+   *
+   * @param suggestionId - The suggestion ID to accept
+   * @returns True if successful
+   */
+  acceptSuggestion(suggestionId) {
+    return this.store.acceptSuggestion(suggestionId);
+  }
+  /**
+   * Rejects a suggestion.
+   *
+   * @param suggestionId - The suggestion ID to reject
+   * @returns True if successful
+   */
+  rejectSuggestion(suggestionId) {
+    return this.store.rejectSuggestion(suggestionId);
+  }
+  /**
+   * Closes the RelayPlane instance and releases resources.
+   */
+  close() {
+    this.store.close();
+  }
+};
+
+// src/proxy.ts
+var DEFAULT_ENDPOINTS = {
+  anthropic: {
+    baseUrl: "https://api.anthropic.com/v1",
+    apiKeyEnv: "ANTHROPIC_API_KEY"
+  },
+  openai: {
+    baseUrl: "https://api.openai.com/v1",
+    apiKeyEnv: "OPENAI_API_KEY"
+  },
+  google: {
+    baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+    apiKeyEnv: "GEMINI_API_KEY"
+  },
+  xai: {
+    baseUrl: "https://api.x.ai/v1",
+    apiKeyEnv: "XAI_API_KEY"
+  },
+  moonshot: {
+    baseUrl: "https://api.moonshot.cn/v1",
+    apiKeyEnv: "MOONSHOT_API_KEY"
+  }
+};
+var MODEL_MAPPING = {
+  // Anthropic models (using correct API model IDs)
+  "claude-opus-4-5": { provider: "anthropic", model: "claude-opus-4-5-20250514" },
+  "claude-sonnet-4": { provider: "anthropic", model: "claude-sonnet-4-20250514" },
+  "claude-3-5-sonnet": { provider: "anthropic", model: "claude-3-5-sonnet-20241022" },
+  "claude-3-5-haiku": { provider: "anthropic", model: "claude-3-5-haiku-20241022" },
+  haiku: { provider: "anthropic", model: "claude-3-5-haiku-20241022" },
+  sonnet: { provider: "anthropic", model: "claude-3-5-sonnet-20241022" },
+  opus: { provider: "anthropic", model: "claude-3-opus-20240229" },
+  // OpenAI models
+  "gpt-4o": { provider: "openai", model: "gpt-4o" },
+  "gpt-4o-mini": { provider: "openai", model: "gpt-4o-mini" },
+  "gpt-4.1": { provider: "openai", model: "gpt-4.1" }
+};
+var DEFAULT_ROUTING = {
+  code_generation: { provider: "anthropic", model: "claude-3-5-haiku-latest" },
+  code_review: { provider: "anthropic", model: "claude-3-5-haiku-latest" },
+  summarization: { provider: "anthropic", model: "claude-3-5-haiku-latest" },
+  analysis: { provider: "anthropic", model: "claude-3-5-haiku-latest" },
+  creative_writing: { provider: "anthropic", model: "claude-3-5-haiku-latest" },
+  data_extraction: { provider: "anthropic", model: "claude-3-5-haiku-latest" },
+  translation: { provider: "anthropic", model: "claude-3-5-haiku-latest" },
+  question_answering: { provider: "anthropic", model: "claude-3-5-haiku-latest" },
+  general: { provider: "anthropic", model: "claude-3-5-haiku-latest" }
+};
+function extractPromptText(messages) {
+  return messages.map((msg) => {
+    if (typeof msg.content === "string") return msg.content;
+    if (Array.isArray(msg.content)) {
+      return msg.content.map((c) => {
+        const part = c;
+        return part.type === "text" ? part.text ?? "" : "";
+      }).join(" ");
+    }
+    return "";
+  }).join("\n");
+}
+async function forwardToAnthropic(request, targetModel, apiKey, betaHeaders) {
+  const anthropicBody = buildAnthropicBody(request, targetModel, false);
+  const headers = {
+    "Content-Type": "application/json",
+    "x-api-key": apiKey,
+    "anthropic-version": "2023-06-01"
+  };
+  if (betaHeaders) {
+    headers["anthropic-beta"] = betaHeaders;
+  }
+  const response = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers,
+    body: JSON.stringify(anthropicBody)
+  });
+  return response;
+}
+async function forwardToAnthropicStream(request, targetModel, apiKey, betaHeaders) {
+  const anthropicBody = buildAnthropicBody(request, targetModel, true);
+  const headers = {
+    "Content-Type": "application/json",
+    "x-api-key": apiKey,
+    "anthropic-version": "2023-06-01"
+  };
+  if (betaHeaders) {
+    headers["anthropic-beta"] = betaHeaders;
+  }
+  const response = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers,
+    body: JSON.stringify(anthropicBody)
+  });
+  return response;
+}
+function convertMessagesToAnthropic(messages) {
+  const result = [];
+  for (const msg of messages) {
+    const m = msg;
+    if (m.role === "system") continue;
+    if (m.role === "tool") {
+      result.push({
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: m.tool_call_id,
+            content: typeof m.content === "string" ? m.content : JSON.stringify(m.content)
+          }
+        ]
+      });
+      continue;
+    }
+    if (m.role === "assistant" && m.tool_calls && m.tool_calls.length > 0) {
+      const content = [];
+      if (m.content && typeof m.content === "string") {
+        content.push({ type: "text", text: m.content });
+      }
+      for (const tc of m.tool_calls) {
+        content.push({
+          type: "tool_use",
+          id: tc.id,
+          name: tc.function.name,
+          input: JSON.parse(tc.function.arguments || "{}")
+        });
+      }
+      result.push({ role: "assistant", content });
+      continue;
+    }
+    result.push({
+      role: m.role === "assistant" ? "assistant" : "user",
+      content: m.content
+    });
+  }
+  return result;
+}
+function buildAnthropicBody(request, targetModel, stream) {
+  const anthropicMessages = convertMessagesToAnthropic(request.messages);
+  const systemMessage = request.messages.find((m) => m.role === "system");
+  const anthropicBody = {
+    model: targetModel,
+    messages: anthropicMessages,
+    max_tokens: request.max_tokens ?? 4096,
+    stream
+  };
+  if (systemMessage) {
+    anthropicBody["system"] = systemMessage.content;
+  }
+  if (request.temperature !== void 0) {
+    anthropicBody["temperature"] = request.temperature;
+  }
+  if (request.tools && Array.isArray(request.tools)) {
+    anthropicBody["tools"] = convertToolsToAnthropic(request.tools);
+  }
+  if (request.tool_choice) {
+    anthropicBody["tool_choice"] = convertToolChoiceToAnthropic(request.tool_choice);
+  }
+  return anthropicBody;
+}
+function convertToolsToAnthropic(tools) {
+  return tools.map((tool) => {
+    const t = tool;
+    if (t.type === "function" && t.function) {
+      return {
+        name: t.function.name,
+        description: t.function.description,
+        input_schema: t.function.parameters || { type: "object", properties: {} }
+      };
+    }
+    return tool;
+  });
+}
+function convertToolChoiceToAnthropic(toolChoice) {
+  if (toolChoice === "auto") return { type: "auto" };
+  if (toolChoice === "none") return { type: "none" };
+  if (toolChoice === "required") return { type: "any" };
+  const tc = toolChoice;
+  if (tc.type === "function" && tc.function?.name) {
+    return { type: "tool", name: tc.function.name };
+  }
+  return toolChoice;
+}
+async function forwardToOpenAI(request, targetModel, apiKey) {
+  const openaiBody = {
+    ...request,
+    model: targetModel,
+    stream: false
+  };
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(openaiBody)
+  });
+  return response;
+}
+async function forwardToOpenAIStream(request, targetModel, apiKey) {
+  const openaiBody = {
+    ...request,
+    model: targetModel,
+    stream: true
+  };
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(openaiBody)
+  });
+  return response;
+}
+async function forwardToXAI(request, targetModel, apiKey) {
+  const xaiBody = {
+    ...request,
+    model: targetModel,
+    stream: false
+  };
+  const response = await fetch("https://api.x.ai/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(xaiBody)
+  });
+  return response;
+}
+async function forwardToXAIStream(request, targetModel, apiKey) {
+  const xaiBody = {
+    ...request,
+    model: targetModel,
+    stream: true
+  };
+  const response = await fetch("https://api.x.ai/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(xaiBody)
+  });
+  return response;
+}
+async function forwardToMoonshot(request, targetModel, apiKey) {
+  const moonshotBody = {
+    ...request,
+    model: targetModel,
+    stream: false
+  };
+  const response = await fetch("https://api.moonshot.cn/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(moonshotBody)
+  });
+  return response;
+}
+async function forwardToMoonshotStream(request, targetModel, apiKey) {
+  const moonshotBody = {
+    ...request,
+    model: targetModel,
+    stream: true
+  };
+  const response = await fetch("https://api.moonshot.cn/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(moonshotBody)
+  });
+  return response;
+}
+function convertMessagesToGemini(messages) {
+  const geminiContents = [];
+  for (const msg of messages) {
+    if (msg.role === "system") continue;
+    const role = msg.role === "assistant" ? "model" : "user";
+    if (typeof msg.content === "string") {
+      geminiContents.push({
+        role,
+        parts: [{ text: msg.content }]
+      });
+    } else if (Array.isArray(msg.content)) {
+      const parts = msg.content.map((part) => {
+        const p = part;
+        if (p.type === "text") {
+          return { text: p.text };
+        }
+        if (p.type === "image_url" && p.image_url?.url) {
+          const url = p.image_url.url;
+          if (url.startsWith("data:")) {
+            const match = url.match(/^data:([^;]+);base64,(.+)$/);
+            if (match) {
+              return {
+                inline_data: {
+                  mime_type: match[1],
+                  data: match[2]
+                }
+              };
+            }
+          }
+          return { text: `[Image: ${url}]` };
+        }
+        return { text: "" };
+      });
+      geminiContents.push({ role, parts });
+    }
+  }
+  return geminiContents;
+}
+async function forwardToGemini(request, targetModel, apiKey) {
+  const systemMessage = request.messages.find((m) => m.role === "system");
+  const geminiContents = convertMessagesToGemini(request.messages);
+  const geminiBody = {
+    contents: geminiContents,
+    generationConfig: {
+      maxOutputTokens: request.max_tokens ?? 4096
+    }
+  };
+  if (request.temperature !== void 0) {
+    geminiBody["generationConfig"]["temperature"] = request.temperature;
+  }
+  if (systemMessage && typeof systemMessage.content === "string") {
+    geminiBody["systemInstruction"] = {
+      parts: [{ text: systemMessage.content }]
+    };
+  }
+  const response = await fetch(
+    `https://generativelanguage.googleapis.com/v1beta/models/${targetModel}:generateContent?key=${apiKey}`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(geminiBody)
+    }
+  );
+  return response;
+}
+async function forwardToGeminiStream(request, targetModel, apiKey) {
+  const systemMessage = request.messages.find((m) => m.role === "system");
+  const geminiContents = convertMessagesToGemini(request.messages);
+  const geminiBody = {
+    contents: geminiContents,
+    generationConfig: {
+      maxOutputTokens: request.max_tokens ?? 4096
+    }
+  };
+  if (request.temperature !== void 0) {
+    geminiBody["generationConfig"]["temperature"] = request.temperature;
+  }
+  if (systemMessage && typeof systemMessage.content === "string") {
+    geminiBody["systemInstruction"] = {
+      parts: [{ text: systemMessage.content }]
+    };
+  }
+  const response = await fetch(
+    `https://generativelanguage.googleapis.com/v1beta/models/${targetModel}:streamGenerateContent?alt=sse&key=${apiKey}`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(geminiBody)
+    }
+  );
+  return response;
+}
+function convertGeminiResponse(geminiData, model) {
+  const candidate = geminiData.candidates?.[0];
+  const text = candidate?.content?.parts?.map((p) => p.text ?? "").join("") ?? "";
+  let finishReason = "stop";
+  if (candidate?.finishReason === "MAX_TOKENS") {
+    finishReason = "length";
+  } else if (candidate?.finishReason === "SAFETY") {
+    finishReason = "content_filter";
+  }
+  return {
+    id: `chatcmpl-${Date.now()}`,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1e3),
+    model,
+    choices: [
+      {
+        index: 0,
+        message: {
+          role: "assistant",
+          content: text
+        },
+        finish_reason: finishReason
+      }
+    ],
+    usage: {
+      prompt_tokens: geminiData.usageMetadata?.promptTokenCount ?? 0,
+      completion_tokens: geminiData.usageMetadata?.candidatesTokenCount ?? 0,
+      total_tokens: (geminiData.usageMetadata?.promptTokenCount ?? 0) + (geminiData.usageMetadata?.candidatesTokenCount ?? 0)
+    }
+  };
+}
+function convertGeminiStreamEvent(eventData, messageId, model, isFirst) {
+  const candidate = eventData.candidates?.[0];
+  const text = candidate?.content?.parts?.map((p) => p.text ?? "").join("") ?? "";
+  const choice = {
+    index: 0,
+    delta: {},
+    finish_reason: null
+  };
+  if (isFirst) {
+    choice["delta"] = { role: "assistant", content: text };
+  } else if (text) {
+    choice["delta"] = { content: text };
+  }
+  if (candidate?.finishReason) {
+    let finishReason = "stop";
+    if (candidate.finishReason === "MAX_TOKENS") {
+      finishReason = "length";
+    } else if (candidate.finishReason === "SAFETY") {
+      finishReason = "content_filter";
+    }
+    choice["finish_reason"] = finishReason;
+  }
+  const chunk = {
+    id: messageId,
+    object: "chat.completion.chunk",
+    created: Math.floor(Date.now() / 1e3),
+    model,
+    choices: [choice]
+  };
+  return `data: ${JSON.stringify(chunk)}
+
+`;
+}
+async function* convertGeminiStream(response, model) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("No response body");
+  }
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const messageId = `chatcmpl-${Date.now()}`;
+  let isFirst = true;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          const jsonStr = line.slice(6);
+          if (jsonStr.trim() === "[DONE]") {
+            yield "data: [DONE]\n\n";
+            continue;
+          }
+          try {
+            const parsed = JSON.parse(jsonStr);
+            const converted = convertGeminiStreamEvent(parsed, messageId, model, isFirst);
+            if (converted) {
+              yield converted;
+              isFirst = false;
+            }
+          } catch {
+          }
+        }
+      }
+    }
+    yield "data: [DONE]\n\n";
+  } finally {
+    reader.releaseLock();
+  }
+}
+function convertAnthropicResponse(anthropicData) {
+  const textBlocks = anthropicData.content?.filter((c) => c.type === "text") ?? [];
+  const toolBlocks = anthropicData.content?.filter((c) => c.type === "tool_use") ?? [];
+  const textContent = textBlocks.map((c) => c.text ?? "").join("");
+  const message = {
+    role: "assistant",
+    content: textContent || null
+  };
+  if (toolBlocks.length > 0) {
+    message["tool_calls"] = toolBlocks.map((block) => ({
+      id: block.id || `call_${Date.now()}`,
+      type: "function",
+      function: {
+        name: block.name,
+        arguments: typeof block.input === "string" ? block.input : JSON.stringify(block.input ?? {})
+      }
+    }));
+  }
+  let finishReason = "stop";
+  if (anthropicData.stop_reason === "tool_use") {
+    finishReason = "tool_calls";
+  } else if (anthropicData.stop_reason === "end_turn") {
+    finishReason = "stop";
+  } else if (anthropicData.stop_reason) {
+    finishReason = anthropicData.stop_reason;
+  }
+  return {
+    id: anthropicData.id || `chatcmpl-${Date.now()}`,
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1e3),
+    model: anthropicData.model,
+    choices: [
+      {
+        index: 0,
+        message,
+        finish_reason: finishReason
+      }
+    ],
+    usage: {
+      prompt_tokens: anthropicData.usage?.input_tokens ?? 0,
+      completion_tokens: anthropicData.usage?.output_tokens ?? 0,
+      total_tokens: (anthropicData.usage?.input_tokens ?? 0) + (anthropicData.usage?.output_tokens ?? 0)
+    }
+  };
+}
+function convertAnthropicStreamEvent(eventType, eventData, messageId, model, toolState) {
+  const choice = { index: 0, delta: {}, finish_reason: null };
+  const baseChunk = {
+    id: messageId,
+    object: "chat.completion.chunk",
+    created: Math.floor(Date.now() / 1e3),
+    model,
+    choices: [choice]
+  };
+  switch (eventType) {
+    case "message_start": {
+      const msg = eventData["message"];
+      baseChunk.id = msg?.["id"] || messageId;
+      choice.delta = { role: "assistant", content: "" };
+      return `data: ${JSON.stringify(baseChunk)}
+
+`;
+    }
+    case "content_block_start": {
+      const contentBlock = eventData["content_block"];
+      const blockIndex = eventData["index"];
+      if (contentBlock?.["type"] === "tool_use") {
+        const toolId = contentBlock["id"];
+        const toolName = contentBlock["name"];
+        toolState.tools.set(blockIndex ?? toolState.currentToolIndex, {
+          id: toolId,
+          name: toolName,
+          arguments: ""
+        });
+        toolState.currentToolIndex = blockIndex ?? toolState.currentToolIndex;
+        choice.delta = {
+          tool_calls: [{
+            index: blockIndex ?? 0,
+            id: toolId,
+            type: "function",
+            function: { name: toolName, arguments: "" }
+          }]
+        };
+        return `data: ${JSON.stringify(baseChunk)}
+
+`;
+      }
+      return null;
+    }
+    case "content_block_delta": {
+      const delta = eventData["delta"];
+      const blockIndex = eventData["index"];
+      if (delta?.["type"] === "text_delta") {
+        choice.delta = { content: delta["text"] };
+        return `data: ${JSON.stringify(baseChunk)}
+
+`;
+      }
+      if (delta?.["type"] === "input_json_delta") {
+        const partialJson = delta["partial_json"] || "";
+        const tool = toolState.tools.get(blockIndex ?? toolState.currentToolIndex);
+        if (tool) {
+          tool.arguments += partialJson;
+        }
+        choice.delta = {
+          tool_calls: [{
+            index: blockIndex ?? 0,
+            function: { arguments: partialJson }
+          }]
+        };
+        return `data: ${JSON.stringify(baseChunk)}
+
+`;
+      }
+      return null;
+    }
+    case "message_delta": {
+      const delta = eventData["delta"];
+      const stopReason = delta?.["stop_reason"];
+      if (stopReason === "tool_use") {
+        choice.finish_reason = "tool_calls";
+      } else if (stopReason === "end_turn") {
+        choice.finish_reason = "stop";
+      } else {
+        choice.finish_reason = stopReason || "stop";
+      }
+      choice.delta = {};
+      return `data: ${JSON.stringify(baseChunk)}
+
+`;
+    }
+    case "message_stop": {
+      return "data: [DONE]\n\n";
+    }
+    default:
+      return null;
+  }
+}
+async function* convertAnthropicStream(response, model) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("No response body");
+  }
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let messageId = `chatcmpl-${Date.now()}`;
+  const toolState = {
+    currentToolIndex: 0,
+    tools: /* @__PURE__ */ new Map()
+  };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      let eventType = "";
+      let eventData = "";
+      for (const line of lines) {
+        if (line.startsWith("event: ")) {
+          eventType = line.slice(7).trim();
+        } else if (line.startsWith("data: ")) {
+          eventData = line.slice(6);
+        } else if (line === "" && eventType && eventData) {
+          try {
+            const parsed = JSON.parse(eventData);
+            const converted = convertAnthropicStreamEvent(eventType, parsed, messageId, model, toolState);
+            if (converted) {
+              yield converted;
+            }
+          } catch {
+          }
+          eventType = "";
+          eventData = "";
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function* pipeOpenAIStream(response) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("No response body");
+  }
+  const decoder = new TextDecoder();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      yield decoder.decode(value, { stream: true });
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function parsePreferredModel(preferredModel) {
+  const [provider, model] = preferredModel.split(":");
+  if (!provider || !model) return null;
+  const validProviders = ["openai", "anthropic", "google", "xai", "moonshot", "local"];
+  if (!validProviders.includes(provider)) return null;
+  return { provider, model };
+}
+function resolveExplicitModel(modelName) {
+  if (MODEL_MAPPING[modelName]) {
+    return MODEL_MAPPING[modelName];
+  }
+  if (modelName.startsWith("claude-")) {
+    return { provider: "anthropic", model: modelName };
+  }
+  if (modelName.startsWith("gpt-") || modelName.startsWith("o1-") || modelName.startsWith("o3-") || modelName.startsWith("chatgpt-") || modelName.startsWith("text-") || modelName.startsWith("dall-e") || modelName.startsWith("whisper") || modelName.startsWith("tts-")) {
+    return { provider: "openai", model: modelName };
+  }
+  if (modelName.startsWith("gemini-") || modelName.startsWith("palm-")) {
+    return { provider: "google", model: modelName };
+  }
+  if (modelName.startsWith("grok-")) {
+    return { provider: "xai", model: modelName };
+  }
+  if (modelName.startsWith("moonshot-")) {
+    return { provider: "moonshot", model: modelName };
+  }
+  if (modelName.includes("/")) {
+    const [provider, model] = modelName.split("/");
+    const validProviders = ["openai", "anthropic", "google", "xai", "moonshot", "local"];
+    if (provider && model && validProviders.includes(provider)) {
+      return { provider, model };
+    }
+  }
+  return null;
+}
+async function startProxy(config = {}) {
+  const port = config.port ?? 3001;
+  const host = config.host ?? "127.0.0.1";
+  const verbose = config.verbose ?? false;
+  const relay = new RelayPlane({ dbPath: config.dbPath });
+  const log = (msg) => {
+    if (verbose) console.log(`[relayplane] ${msg}`);
+  };
+  const server = http.createServer(async (req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    if (req.method !== "POST" || !req.url?.includes("/chat/completions")) {
+      if (req.method === "GET" && req.url?.includes("/models")) {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            object: "list",
+            data: [
+              { id: "relayplane:auto", object: "model", owned_by: "relayplane" },
+              { id: "relayplane:cost", object: "model", owned_by: "relayplane" },
+              { id: "relayplane:quality", object: "model", owned_by: "relayplane" }
+            ]
+          })
+        );
+        return;
+      }
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Not found" }));
+      return;
+    }
+    let body = "";
+    for await (const chunk of req) {
+      body += chunk;
+    }
+    let request;
+    try {
+      request = JSON.parse(body);
+    } catch {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Invalid JSON" }));
+      return;
+    }
+    const isStreaming = request.stream === true;
+    const requestedModel = request.model;
+    let routingMode = "auto";
+    let targetModel = "";
+    let targetProvider = "anthropic";
+    if (requestedModel.startsWith("relayplane:")) {
+      if (requestedModel.includes(":cost")) {
+        routingMode = "cost";
+      } else if (requestedModel.includes(":quality")) {
+        routingMode = "quality";
+      }
+    } else {
+      routingMode = "passthrough";
+      const resolved = resolveExplicitModel(requestedModel);
+      if (resolved) {
+        targetProvider = resolved.provider;
+        targetModel = resolved.model;
+        log(`Pass-through mode: ${requestedModel} \u2192 ${targetProvider}/${targetModel}`);
+      } else {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: `Unknown model: ${requestedModel}` }));
+        return;
+      }
+    }
+    log(`Received request for model: ${requestedModel} (mode: ${routingMode}, stream: ${isStreaming})`);
+    const promptText = extractPromptText(request.messages);
+    const taskType = inferTaskType(promptText);
+    const confidence = getInferenceConfidence(promptText, taskType);
+    log(`Inferred task: ${taskType} (confidence: ${confidence.toFixed(2)})`);
+    if (routingMode !== "passthrough") {
+      const rule = relay.routing.get(taskType);
+      if (rule && rule.preferredModel) {
+        const parsed = parsePreferredModel(rule.preferredModel);
+        if (parsed) {
+          targetProvider = parsed.provider;
+          targetModel = parsed.model;
+          log(`Using learned rule: ${rule.preferredModel}`);
+        } else {
+          const defaultRoute = DEFAULT_ROUTING[taskType];
+          targetProvider = defaultRoute.provider;
+          targetModel = defaultRoute.model;
+        }
+      } else {
+        const defaultRoute = DEFAULT_ROUTING[taskType];
+        targetProvider = defaultRoute.provider;
+        targetModel = defaultRoute.model;
+      }
+      if (routingMode === "cost") {
+        const simpleTasks = ["summarization", "data_extraction", "translation", "question_answering"];
+        if (simpleTasks.includes(taskType)) {
+          targetModel = "claude-3-5-haiku-latest";
+          targetProvider = "anthropic";
+        }
+      } else if (routingMode === "quality") {
+        const qualityModel = process.env["RELAYPLANE_QUALITY_MODEL"] || "claude-3-5-sonnet-latest";
+        targetModel = qualityModel;
+        targetProvider = "anthropic";
+      }
+    }
+    log(`Routing to: ${targetProvider}/${targetModel}`);
+    const apiKeyEnv = DEFAULT_ENDPOINTS[targetProvider]?.apiKeyEnv ?? `${targetProvider.toUpperCase()}_API_KEY`;
+    const apiKey = process.env[apiKeyEnv];
+    if (!apiKey) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: `Missing ${apiKeyEnv} environment variable` }));
+      return;
+    }
+    const startTime = Date.now();
+    const betaHeaders = req.headers["anthropic-beta"];
+    if (isStreaming) {
+      await handleStreamingRequest(
+        res,
+        request,
+        targetProvider,
+        targetModel,
+        apiKey,
+        relay,
+        promptText,
+        taskType,
+        confidence,
+        routingMode,
+        startTime,
+        log,
+        betaHeaders
+      );
+    } else {
+      await handleNonStreamingRequest(
+        res,
+        request,
+        targetProvider,
+        targetModel,
+        apiKey,
+        relay,
+        promptText,
+        taskType,
+        confidence,
+        routingMode,
+        startTime,
+        log,
+        betaHeaders
+      );
+    }
+  });
+  return new Promise((resolve, reject) => {
+    server.on("error", reject);
+    server.listen(port, host, () => {
+      console.log(`RelayPlane proxy listening on http://${host}:${port}`);
+      console.log(`  Models: relayplane:auto, relayplane:cost, relayplane:quality`);
+      console.log(`  Endpoint: POST /v1/chat/completions`);
+      console.log(`  Streaming: \u2705 Enabled`);
+      resolve(server);
+    });
+  });
+}
+async function handleStreamingRequest(res, request, targetProvider, targetModel, apiKey, relay, promptText, taskType, confidence, routingMode, startTime, log, betaHeaders) {
+  let providerResponse;
+  try {
+    switch (targetProvider) {
+      case "anthropic":
+        providerResponse = await forwardToAnthropicStream(request, targetModel, apiKey, betaHeaders);
+        break;
+      case "google":
+        providerResponse = await forwardToGeminiStream(request, targetModel, apiKey);
+        break;
+      case "xai":
+        providerResponse = await forwardToXAIStream(request, targetModel, apiKey);
+        break;
+      case "moonshot":
+        providerResponse = await forwardToMoonshotStream(request, targetModel, apiKey);
+        break;
+      default:
+        providerResponse = await forwardToOpenAIStream(request, targetModel, apiKey);
+    }
+    if (!providerResponse.ok) {
+      const errorData = await providerResponse.json();
+      res.writeHead(providerResponse.status, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(errorData));
+      return;
+    }
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: `Provider error: ${errorMsg}` }));
+    return;
+  }
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    "Connection": "keep-alive"
+  });
+  try {
+    switch (targetProvider) {
+      case "anthropic":
+        for await (const chunk of convertAnthropicStream(providerResponse, targetModel)) {
+          res.write(chunk);
+        }
+        break;
+      case "google":
+        for await (const chunk of convertGeminiStream(providerResponse, targetModel)) {
+          res.write(chunk);
+        }
+        break;
+      default:
+        for await (const chunk of pipeOpenAIStream(providerResponse)) {
+          res.write(chunk);
+        }
+    }
+  } catch (err) {
+    log(`Streaming error: ${err}`);
+  }
+  const durationMs = Date.now() - startTime;
+  relay.run({
+    prompt: promptText.slice(0, 500),
+    taskType,
+    model: `${targetProvider}:${targetModel}`
+  }).then((runResult) => {
+    log(`Completed streaming in ${durationMs}ms, runId: ${runResult.runId}`);
+  }).catch((err) => {
+    log(`Failed to record run: ${err}`);
+  });
+  res.end();
+}
+async function handleNonStreamingRequest(res, request, targetProvider, targetModel, apiKey, relay, promptText, taskType, confidence, routingMode, startTime, log, betaHeaders) {
+  let providerResponse;
+  let responseData;
+  try {
+    switch (targetProvider) {
+      case "anthropic": {
+        providerResponse = await forwardToAnthropic(request, targetModel, apiKey, betaHeaders);
+        const rawData = await providerResponse.json();
+        if (!providerResponse.ok) {
+          res.writeHead(providerResponse.status, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(rawData));
+          return;
+        }
+        responseData = convertAnthropicResponse(rawData);
+        break;
+      }
+      case "google": {
+        providerResponse = await forwardToGemini(request, targetModel, apiKey);
+        const rawData = await providerResponse.json();
+        if (!providerResponse.ok) {
+          res.writeHead(providerResponse.status, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(rawData));
+          return;
+        }
+        responseData = convertGeminiResponse(rawData, targetModel);
+        break;
+      }
+      case "xai": {
+        providerResponse = await forwardToXAI(request, targetModel, apiKey);
+        responseData = await providerResponse.json();
+        if (!providerResponse.ok) {
+          res.writeHead(providerResponse.status, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(responseData));
+          return;
+        }
+        break;
+      }
+      case "moonshot": {
+        providerResponse = await forwardToMoonshot(request, targetModel, apiKey);
+        responseData = await providerResponse.json();
+        if (!providerResponse.ok) {
+          res.writeHead(providerResponse.status, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(responseData));
+          return;
+        }
+        break;
+      }
+      default: {
+        providerResponse = await forwardToOpenAI(request, targetModel, apiKey);
+        responseData = await providerResponse.json();
+        if (!providerResponse.ok) {
+          res.writeHead(providerResponse.status, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(responseData));
+          return;
+        }
+      }
+    }
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: `Provider error: ${errorMsg}` }));
+    return;
+  }
+  const durationMs = Date.now() - startTime;
+  try {
+    const runResult = await relay.run({
+      prompt: promptText.slice(0, 500),
+      taskType,
+      model: `${targetProvider}:${targetModel}`
+    });
+    responseData["_relayplane"] = {
+      runId: runResult.runId,
+      routedTo: `${targetProvider}/${targetModel}`,
+      taskType,
+      confidence,
+      durationMs,
+      mode: routingMode
+    };
+    log(`Completed in ${durationMs}ms, runId: ${runResult.runId}`);
+  } catch (err) {
+    log(`Failed to record run: ${err}`);
+  }
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(responseData));
+}
+
+// src/types.ts
+import { z } from "zod";
+var TaskTypes = [
+  "code_generation",
+  "code_review",
+  "summarization",
+  "analysis",
+  "creative_writing",
+  "data_extraction",
+  "translation",
+  "question_answering",
+  "general"
+];
+var TaskTypeSchema = z.enum(TaskTypes);
+var Providers = ["openai", "anthropic", "google", "xai", "moonshot", "local"];
+var ProviderSchema = z.enum(Providers);
+var RelayPlaneConfigSchema = z.object({
+  dbPath: z.string().optional(),
+  providers: z.record(ProviderSchema, z.object({
+    apiKey: z.string().optional(),
+    baseUrl: z.string().optional()
+  })).optional(),
+  defaultProvider: ProviderSchema.optional(),
+  defaultModel: z.string().optional()
+});
+var RunInputSchema = z.object({
+  prompt: z.string().min(1),
+  systemPrompt: z.string().optional(),
+  taskType: TaskTypeSchema.optional(),
+  model: z.string().optional(),
+  metadata: z.record(z.unknown()).optional()
+});
+var RuleSources = ["default", "user", "learned"];
+var RoutingRuleSchema = z.object({
+  id: z.string(),
+  taskType: TaskTypeSchema,
+  preferredModel: z.string(),
+  source: z.enum(RuleSources),
+  confidence: z.number().min(0).max(1).optional(),
+  sampleCount: z.number().int().positive().optional(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var OutcomeQualities = ["excellent", "good", "acceptable", "poor", "failed"];
+var OutcomeInputSchema = z.object({
+  runId: z.string().min(1),
+  success: z.boolean(),
+  quality: z.enum(OutcomeQualities).optional(),
+  latencySatisfactory: z.boolean().optional(),
+  costSatisfactory: z.boolean().optional(),
+  feedback: z.string().optional()
+});
+var SuggestionSchema = z.object({
+  id: z.string(),
+  taskType: TaskTypeSchema,
+  currentModel: z.string(),
+  suggestedModel: z.string(),
+  reason: z.string(),
+  confidence: z.number().min(0).max(1),
+  expectedImprovement: z.object({
+    successRate: z.number().optional(),
+    latency: z.number().optional(),
+    cost: z.number().optional()
+  }),
+  sampleCount: z.number().int().positive(),
+  createdAt: z.string(),
+  accepted: z.boolean().optional(),
+  acceptedAt: z.string().optional()
+});
+export {
+  DEFAULT_ENDPOINTS,
+  MODEL_MAPPING,
+  MODEL_PRICING,
+  OutcomeRecorder,
+  PatternDetector,
+  ProviderSchema,
+  Providers,
+  RelayPlane,
+  RoutingEngine,
+  Store,
+  TaskTypeSchema,
+  TaskTypes,
+  calculateCost,
+  calculateSavings,
+  getInferenceConfidence,
+  getModelPricing,
+  inferTaskType,
+  startProxy
+};
+//# sourceMappingURL=index.mjs.map