@relayplane/proxy 0.1.10 → 0.2.1

package/dist/index.mjs

@@ -1,3039 +0,0 @@
-// src/proxy.ts
-import * as http from "http";
-import * as url from "url";
-
-// 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 = [
-  // Complex tasks → Sonnet (need reasoning & quality)
-  { taskType: "code_generation", preferredModel: "anthropic:claude-sonnet-4-20250514" },
-  { taskType: "code_review", preferredModel: "anthropic:claude-sonnet-4-20250514" },
-  { taskType: "analysis", preferredModel: "anthropic:claude-sonnet-4-20250514" },
-  { taskType: "creative_writing", preferredModel: "anthropic:claude-sonnet-4-20250514" },
-  // Simple tasks → Haiku (cost efficient)
-  { taskType: "summarization", 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/config.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-import * as os2 from "os";
-import { z } from "zod";
-var StrategySchema = z.object({
-  model: z.string(),
-  minConfidence: z.number().min(0).max(1).optional(),
-  fallback: z.string().optional()
-});
-var AuthSchema = z.object({
-  anthropicApiKey: z.string().optional(),
-  anthropicMaxToken: z.string().optional(),
-  useMaxForModels: z.array(z.string()).optional()
-  // Default: ['opus']
-}).optional();
-var ConfigSchema = z.object({
-  strategies: z.record(z.string(), StrategySchema).optional(),
-  defaults: z.object({
-    qualityModel: z.string().optional(),
-    costModel: z.string().optional()
-  }).optional(),
-  auth: AuthSchema
-});
-var DEFAULT_CONFIG = {
-  strategies: {
-    code_review: { model: "anthropic:claude-sonnet-4-20250514" },
-    code_generation: { model: "anthropic:claude-3-5-haiku-latest" },
-    analysis: { model: "anthropic:claude-sonnet-4-20250514" },
-    summarization: { model: "anthropic:claude-3-5-haiku-latest" },
-    creative_writing: { model: "anthropic:claude-sonnet-4-20250514" },
-    data_extraction: { model: "anthropic:claude-3-5-haiku-latest" },
-    translation: { model: "anthropic:claude-3-5-haiku-latest" },
-    question_answering: { model: "anthropic:claude-3-5-haiku-latest" },
-    general: { model: "anthropic:claude-3-5-haiku-latest" }
-  },
-  defaults: {
-    qualityModel: "claude-sonnet-4-20250514",
-    costModel: "claude-3-5-haiku-latest"
-  }
-};
-function getConfigPath() {
-  return path2.join(os2.homedir(), ".relayplane", "config.json");
-}
-function writeDefaultConfig() {
-  const configPath = getConfigPath();
-  const dir = path2.dirname(configPath);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
-  }
-  if (!fs2.existsSync(configPath)) {
-    fs2.writeFileSync(
-      configPath,
-      JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n",
-      "utf-8"
-    );
-    console.log(`[relayplane] Created default config at ${configPath}`);
-  }
-}
-function loadConfig() {
-  const configPath = getConfigPath();
-  writeDefaultConfig();
-  try {
-    const raw = fs2.readFileSync(configPath, "utf-8");
-    const parsed = JSON.parse(raw);
-    const validated = ConfigSchema.parse(parsed);
-    return validated;
-  } catch (err) {
-    if (err instanceof z.ZodError) {
-      console.error(`[relayplane] Invalid config: ${err.message}`);
-    } else if (err instanceof SyntaxError) {
-      console.error(`[relayplane] Config JSON parse error: ${err.message}`);
-    } else {
-      console.error(`[relayplane] Failed to load config: ${err}`);
-    }
-    console.log("[relayplane] Using default config");
-    return DEFAULT_CONFIG;
-  }
-}
-function getStrategy(config, taskType) {
-  return config.strategies?.[taskType] ?? null;
-}
-function getAnthropicAuth(config, model) {
-  const auth = config.auth;
-  const useMaxForModels = auth?.useMaxForModels ?? ["opus"];
-  const shouldUseMax = useMaxForModels.some((m) => model.toLowerCase().includes(m.toLowerCase()));
-  if (shouldUseMax && auth?.anthropicMaxToken) {
-    return { type: "max", value: auth.anthropicMaxToken };
-  }
-  const apiKey = auth?.anthropicApiKey ?? process.env["ANTHROPIC_API_KEY"];
-  if (apiKey) {
-    return { type: "apiKey", value: apiKey };
-  }
-  return null;
-}
-function watchConfig(onChange) {
-  const configPath = getConfigPath();
-  const dir = path2.dirname(configPath);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
-  }
-  let debounceTimer = null;
-  fs2.watch(dir, (eventType, filename) => {
-    if (filename === "config.json") {
-      if (debounceTimer) clearTimeout(debounceTimer);
-      debounceTimer = setTimeout(() => {
-        console.log("[relayplane] Config file changed, reloading...");
-        const newConfig = loadConfig();
-        onChange(newConfig);
-      }, 100);
-    }
-  });
-}
-
-// src/proxy.ts
-var VERSION = "0.1.9";
-var recentRuns = [];
-var MAX_RECENT_RUNS = 100;
-var modelCounts = {};
-var tokenStats = {};
-var MODEL_PRICING2 = {
-  // Anthropic
-  "claude-3-haiku-20240307": { input: 0.25, output: 1.25 },
-  "claude-3-5-haiku-20241022": { input: 1, output: 5 },
-  "claude-3-5-haiku-latest": { input: 1, output: 5 },
-  "claude-3-5-sonnet-20241022": { input: 3, output: 15 },
-  "claude-sonnet-4-20250514": { input: 3, output: 15 },
-  "claude-3-opus-20240229": { input: 15, output: 75 },
-  "claude-opus-4-5-20250514": { input: 15, output: 75 },
-  // OpenAI
-  "gpt-4o": { input: 2.5, output: 10 },
-  "gpt-4o-mini": { input: 0.15, output: 0.6 },
-  "gpt-4-turbo": { input: 10, output: 30 },
-  // Defaults for unknown models
-  "default-cheap": { input: 1, output: 5 },
-  "default-expensive": { input: 15, output: 75 }
-};
-function trackTokens(model, inputTokens, outputTokens) {
-  if (!tokenStats[model]) {
-    tokenStats[model] = { inputTokens: 0, outputTokens: 0, requests: 0 };
-  }
-  tokenStats[model].inputTokens += inputTokens;
-  tokenStats[model].outputTokens += outputTokens;
-  tokenStats[model].requests += 1;
-}
-function calculateCosts() {
-  let totalInputTokens = 0;
-  let totalOutputTokens = 0;
-  let actualCostUsd = 0;
-  const byModel = {};
-  for (const [model, stats] of Object.entries(tokenStats)) {
-    totalInputTokens += stats.inputTokens;
-    totalOutputTokens += stats.outputTokens;
-    const pricing = MODEL_PRICING2[model] || MODEL_PRICING2["default-cheap"];
-    const cost = stats.inputTokens / 1e6 * pricing.input + stats.outputTokens / 1e6 * pricing.output;
-    actualCostUsd += cost;
-    byModel[model] = {
-      inputTokens: stats.inputTokens,
-      outputTokens: stats.outputTokens,
-      costUsd: parseFloat(cost.toFixed(4))
-    };
-  }
-  const opusPricing = MODEL_PRICING2["claude-opus-4-5-20250514"];
-  const opusCostUsd = totalInputTokens / 1e6 * opusPricing.input + totalOutputTokens / 1e6 * opusPricing.output;
-  const savingsUsd = opusCostUsd - actualCostUsd;
-  const savingsPercent = opusCostUsd > 0 ? (savingsUsd / opusCostUsd * 100).toFixed(1) + "%" : "0%";
-  return {
-    totalInputTokens,
-    totalOutputTokens,
-    actualCostUsd: parseFloat(actualCostUsd.toFixed(4)),
-    opusCostUsd: parseFloat(opusCostUsd.toFixed(4)),
-    savingsUsd: parseFloat(savingsUsd.toFixed(4)),
-    savingsPercent,
-    byModel
-  };
-}
-var serverStartTime = 0;
-var currentConfig = loadConfig();
-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 = {
-  // Complex tasks → Sonnet (need reasoning & quality)
-  code_review: { provider: "anthropic", model: "claude-sonnet-4-20250514" },
-  analysis: { provider: "anthropic", model: "claude-sonnet-4-20250514" },
-  creative_writing: { provider: "anthropic", model: "claude-sonnet-4-20250514" },
-  // Medium tasks → Sonnet (benefit from better model)
-  code_generation: { provider: "anthropic", model: "claude-sonnet-4-20250514" },
-  // Simple tasks → Haiku (cost efficient)
-  summarization: { 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, auth, betaHeaders) {
-  const anthropicBody = buildAnthropicBody(request, targetModel, false);
-  const headers = {
-    "Content-Type": "application/json",
-    "anthropic-version": "2023-06-01"
-  };
-  if (auth.type === "max") {
-    headers["Authorization"] = `Bearer ${auth.value}`;
-  } else {
-    headers["x-api-key"] = auth.value;
-  }
-  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, auth, betaHeaders) {
-  const anthropicBody = buildAnthropicBody(request, targetModel, true);
-  const headers = {
-    "Content-Type": "application/json",
-    "anthropic-version": "2023-06-01"
-  };
-  if (auth.type === "max") {
-    headers["Authorization"] = `Bearer ${auth.value}`;
-  } else {
-    headers["x-api-key"] = auth.value;
-  }
-  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 url2 = p.image_url.url;
-          if (url2.startsWith("data:")) {
-            const match = url2.match(/^data:([^;]+);base64,(.+)$/);
-            if (match) {
-              return {
-                inline_data: {
-                  mime_type: match[1],
-                  data: match[2]
-                }
-              };
-            }
-          }
-          return { text: `[Image: ${url2}]` };
-        }
-        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;
-  }
-}
-var lastStreamingUsage = 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()
-  };
-  let streamInputTokens = 0;
-  let streamOutputTokens = 0;
-  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);
-            if (eventType === "message_start") {
-              const msg = parsed["message"];
-              if (msg?.usage?.input_tokens) {
-                streamInputTokens = msg.usage.input_tokens;
-              }
-            } else if (eventType === "message_delta") {
-              const usage = parsed["usage"];
-              if (usage?.output_tokens) {
-                streamOutputTokens = usage.output_tokens;
-              }
-            }
-            const converted = convertAnthropicStreamEvent(eventType, parsed, messageId, model, toolState);
-            if (converted) {
-              yield converted;
-            }
-          } catch {
-          }
-          eventType = "";
-          eventData = "";
-        }
-      }
-    }
-    lastStreamingUsage = { inputTokens: streamInputTokens, outputTokens: streamOutputTokens };
-  } 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", "GET, POST, OPTIONS");
-    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
-    if (req.method === "OPTIONS") {
-      res.writeHead(204);
-      res.end();
-      return;
-    }
-    const parsedUrl = url.parse(req.url || "", true);
-    const pathname = parsedUrl.pathname || "";
-    if (req.method === "GET" && pathname === "/health") {
-      const uptimeMs = Date.now() - serverStartTime;
-      const uptimeSecs = Math.floor(uptimeMs / 1e3);
-      const hours = Math.floor(uptimeSecs / 3600);
-      const mins = Math.floor(uptimeSecs % 3600 / 60);
-      const secs = uptimeSecs % 60;
-      const providers = {};
-      for (const [name, config2] of Object.entries(DEFAULT_ENDPOINTS)) {
-        providers[name] = !!process.env[config2.apiKeyEnv];
-      }
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({
-        status: "ok",
-        version: VERSION,
-        uptime: `${hours}h ${mins}m ${secs}s`,
-        uptimeMs,
-        providers,
-        totalRuns: recentRuns.length > 0 ? Object.values(modelCounts).reduce((a, b) => a + b, 0) : 0
-      }));
-      return;
-    }
-    if (req.method === "GET" && pathname === "/stats") {
-      const stats = relay.stats();
-      const costs = calculateCosts();
-      const totalRuns = Object.values(modelCounts).reduce((a, b) => a + b, 0);
-      const modelDistribution = {};
-      for (const [model, count] of Object.entries(modelCounts)) {
-        const modelName = model.split("/")[1] || model;
-        const tokenData = costs.byModel[modelName];
-        modelDistribution[model] = {
-          count,
-          percentage: totalRuns > 0 ? (count / totalRuns * 100).toFixed(1) + "%" : "0%",
-          tokens: tokenData ? { input: tokenData.inputTokens, output: tokenData.outputTokens } : void 0,
-          costUsd: tokenData?.costUsd
-        };
-      }
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({
-        totalRuns,
-        tokens: {
-          input: costs.totalInputTokens,
-          output: costs.totalOutputTokens,
-          total: costs.totalInputTokens + costs.totalOutputTokens
-        },
-        costs: {
-          actualUsd: costs.actualCostUsd,
-          opusBaselineUsd: costs.opusCostUsd,
-          savingsUsd: costs.savingsUsd,
-          savingsPercent: costs.savingsPercent
-        },
-        modelDistribution,
-        byTaskType: stats.byTaskType,
-        period: stats.period
-      }));
-      return;
-    }
-    if (req.method === "GET" && pathname === "/runs") {
-      const limitParam = parsedUrl.query["limit"];
-      const parsedLimit = limitParam ? parseInt(String(limitParam), 10) : 20;
-      const limit = Math.min(Number.isNaN(parsedLimit) ? 20 : parsedLimit, MAX_RECENT_RUNS);
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({
-        runs: recentRuns.slice(0, limit),
-        total: recentRuns.length
-      }));
-      return;
-    }
-    if (req.method === "GET" && pathname.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;
-    }
-    if (req.method !== "POST" || !pathname.includes("/chat/completions")) {
-      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 configStrategy = getStrategy(currentConfig, taskType);
-      if (configStrategy) {
-        const parsed = parsePreferredModel(configStrategy.model);
-        if (parsed) {
-          targetProvider = parsed.provider;
-          targetModel = parsed.model;
-          log(`Using config strategy: ${configStrategy.model}`);
-        }
-      }
-      if (!configStrategy) {
-        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 costModel = currentConfig.defaults?.costModel || "claude-3-5-haiku-latest";
-        targetModel = costModel;
-        targetProvider = "anthropic";
-        log(`Cost mode: using ${costModel}`);
-      } else if (routingMode === "quality") {
-        const qualityModel = currentConfig.defaults?.qualityModel || process.env["RELAYPLANE_QUALITY_MODEL"] || "claude-sonnet-4-20250514";
-        targetModel = qualityModel;
-        targetProvider = "anthropic";
-        log(`Quality mode: using ${qualityModel}`);
-      }
-    }
-    log(`Routing to: ${targetProvider}/${targetModel}`);
-    let apiKey;
-    let anthropicAuth = null;
-    if (targetProvider === "anthropic") {
-      anthropicAuth = getAnthropicAuth(currentConfig, targetModel);
-      if (!anthropicAuth) {
-        res.writeHead(500, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: "No Anthropic auth configured (set ANTHROPIC_API_KEY or config.auth.anthropicMaxToken)" }));
-        return;
-      }
-      log(`Using ${anthropicAuth.type === "max" ? "MAX token" : "API key"} auth for ${targetModel}`);
-    } else {
-      const apiKeyEnv = DEFAULT_ENDPOINTS[targetProvider]?.apiKeyEnv ?? `${targetProvider.toUpperCase()}_API_KEY`;
-      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,
-        anthropicAuth,
-        relay,
-        promptText,
-        taskType,
-        confidence,
-        routingMode,
-        startTime,
-        log,
-        betaHeaders
-      );
-    } else {
-      await handleNonStreamingRequest(
-        res,
-        request,
-        targetProvider,
-        targetModel,
-        apiKey,
-        anthropicAuth,
-        relay,
-        promptText,
-        taskType,
-        confidence,
-        routingMode,
-        startTime,
-        log,
-        betaHeaders
-      );
-    }
-  });
-  watchConfig((newConfig) => {
-    currentConfig = newConfig;
-    console.log("[relayplane] Config reloaded");
-  });
-  return new Promise((resolve, reject) => {
-    server.on("error", reject);
-    server.listen(port, host, () => {
-      serverStartTime = Date.now();
-      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(`  Stats: GET /stats, /runs, /health`);
-      console.log(`  Config: ~/.relayplane/config.json (hot-reload enabled)`);
-      console.log(`  Streaming: \u2705 Enabled`);
-      resolve(server);
-    });
-  });
-}
-async function handleStreamingRequest(res, request, targetProvider, targetModel, apiKey, anthropicAuth, relay, promptText, taskType, confidence, routingMode, startTime, log, betaHeaders) {
-  let providerResponse;
-  try {
-    switch (targetProvider) {
-      case "anthropic":
-        if (!anthropicAuth) throw new Error("No Anthropic auth");
-        providerResponse = await forwardToAnthropicStream(request, targetModel, anthropicAuth, 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;
-  const modelKey = `${targetProvider}/${targetModel}`;
-  modelCounts[modelKey] = (modelCounts[modelKey] || 0) + 1;
-  if (lastStreamingUsage && (lastStreamingUsage.inputTokens > 0 || lastStreamingUsage.outputTokens > 0)) {
-    trackTokens(targetModel, lastStreamingUsage.inputTokens, lastStreamingUsage.outputTokens);
-    log(`Tokens: ${lastStreamingUsage.inputTokens} in, ${lastStreamingUsage.outputTokens} out`);
-    lastStreamingUsage = null;
-  }
-  relay.run({
-    prompt: promptText.slice(0, 500),
-    taskType,
-    model: `${targetProvider}:${targetModel}`
-  }).then((runResult) => {
-    recentRuns.unshift({
-      runId: runResult.runId,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      model: modelKey,
-      taskType,
-      confidence,
-      mode: routingMode,
-      durationMs,
-      promptPreview: promptText.slice(0, 100) + (promptText.length > 100 ? "..." : "")
-    });
-    if (recentRuns.length > MAX_RECENT_RUNS) {
-      recentRuns.pop();
-    }
-    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, anthropicAuth, relay, promptText, taskType, confidence, routingMode, startTime, log, betaHeaders) {
-  let providerResponse;
-  let responseData;
-  try {
-    switch (targetProvider) {
-      case "anthropic": {
-        if (!anthropicAuth) throw new Error("No Anthropic auth");
-        providerResponse = await forwardToAnthropic(request, targetModel, anthropicAuth, 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;
-  const modelKey = `${targetProvider}/${targetModel}`;
-  modelCounts[modelKey] = (modelCounts[modelKey] || 0) + 1;
-  const usage = responseData["usage"];
-  if (usage?.prompt_tokens || usage?.completion_tokens) {
-    trackTokens(targetModel, usage.prompt_tokens ?? 0, usage.completion_tokens ?? 0);
-    log(`Tokens: ${usage.prompt_tokens ?? 0} in, ${usage.completion_tokens ?? 0} out`);
-  }
-  try {
-    const runResult = await relay.run({
-      prompt: promptText.slice(0, 500),
-      taskType,
-      model: `${targetProvider}:${targetModel}`
-    });
-    recentRuns.unshift({
-      runId: runResult.runId,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      model: modelKey,
-      taskType,
-      confidence,
-      mode: routingMode,
-      durationMs,
-      promptPreview: promptText.slice(0, 100) + (promptText.length > 100 ? "..." : "")
-    });
-    if (recentRuns.length > MAX_RECENT_RUNS) {
-      recentRuns.pop();
-    }
-    responseData["_relayplane"] = {
-      runId: runResult.runId,
-      routedTo: modelKey,
-      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 as z2 } from "zod";
-var TaskTypes = [
-  "code_generation",
-  "code_review",
-  "summarization",
-  "analysis",
-  "creative_writing",
-  "data_extraction",
-  "translation",
-  "question_answering",
-  "general"
-];
-var TaskTypeSchema = z2.enum(TaskTypes);
-var Providers = ["openai", "anthropic", "google", "xai", "moonshot", "local"];
-var ProviderSchema = z2.enum(Providers);
-var RelayPlaneConfigSchema = z2.object({
-  dbPath: z2.string().optional(),
-  providers: z2.record(ProviderSchema, z2.object({
-    apiKey: z2.string().optional(),
-    baseUrl: z2.string().optional()
-  })).optional(),
-  defaultProvider: ProviderSchema.optional(),
-  defaultModel: z2.string().optional()
-});
-var RunInputSchema = z2.object({
-  prompt: z2.string().min(1),
-  systemPrompt: z2.string().optional(),
-  taskType: TaskTypeSchema.optional(),
-  model: z2.string().optional(),
-  metadata: z2.record(z2.unknown()).optional()
-});
-var RuleSources = ["default", "user", "learned"];
-var RoutingRuleSchema = z2.object({
-  id: z2.string(),
-  taskType: TaskTypeSchema,
-  preferredModel: z2.string(),
-  source: z2.enum(RuleSources),
-  confidence: z2.number().min(0).max(1).optional(),
-  sampleCount: z2.number().int().positive().optional(),
-  createdAt: z2.string(),
-  updatedAt: z2.string()
-});
-var OutcomeQualities = ["excellent", "good", "acceptable", "poor", "failed"];
-var OutcomeInputSchema = z2.object({
-  runId: z2.string().min(1),
-  success: z2.boolean(),
-  quality: z2.enum(OutcomeQualities).optional(),
-  latencySatisfactory: z2.boolean().optional(),
-  costSatisfactory: z2.boolean().optional(),
-  feedback: z2.string().optional()
-});
-var SuggestionSchema = z2.object({
-  id: z2.string(),
-  taskType: TaskTypeSchema,
-  currentModel: z2.string(),
-  suggestedModel: z2.string(),
-  reason: z2.string(),
-  confidence: z2.number().min(0).max(1),
-  expectedImprovement: z2.object({
-    successRate: z2.number().optional(),
-    latency: z2.number().optional(),
-    cost: z2.number().optional()
-  }),
-  sampleCount: z2.number().int().positive(),
-  createdAt: z2.string(),
-  accepted: z2.boolean().optional(),
-  acceptedAt: z2.string().optional()
-});
-export {
-  DEFAULT_CONFIG,
-  DEFAULT_ENDPOINTS,
-  MODEL_MAPPING,
-  MODEL_PRICING,
-  OutcomeRecorder,
-  PatternDetector,
-  ProviderSchema,
-  Providers,
-  RelayPlane,
-  RoutingEngine,
-  Store,
-  TaskTypeSchema,
-  TaskTypes,
-  calculateCost,
-  calculateSavings,
-  getConfigPath,
-  getInferenceConfidence,
-  getModelPricing,
-  getStrategy,
-  inferTaskType,
-  loadConfig,
-  startProxy,
-  watchConfig
-};
-//# sourceMappingURL=index.mjs.map