@relayplane/proxy 0.1.7 → 0.1.8

package/README.md

@@ -176,13 +176,85 @@ Options:
   -h, --help         Show help
 ```
 
+## REST API
+
+The proxy exposes endpoints for stats and monitoring:
+
+### `GET /health`
+
+Server health and version info.
+
+```bash
+curl http://localhost:3001/health
+```
+
+```json
+{
+  "status": "ok",
+  "version": "0.1.7",
+  "uptime": "2h 15m 30s",
+  "providers": { "anthropic": true, "openai": true, "google": false },
+  "totalRuns": 142
+}
+```
+
+### `GET /stats`
+
+Aggregated statistics and cost savings.
+
+```bash
+curl http://localhost:3001/stats
+```
+
+```json
+{
+  "totalRuns": 142,
+  "savings": {
+    "estimatedSavingsPercent": "73.2%",
+    "actualCostUsd": "0.0234",
+    "baselineCostUsd": "0.0873",
+    "savedUsd": "0.0639"
+  },
+  "modelDistribution": {
+    "anthropic/claude-3-5-haiku-latest": { "count": 98, "percentage": "69.0%" },
+    "anthropic/claude-sonnet-4-20250514": { "count": 44, "percentage": "31.0%" }
+  }
+}
+```
+
+### `GET /runs`
+
+Recent routing decisions.
+
+```bash
+curl "http://localhost:3001/runs?limit=10"
+```
+
+```json
+{
+  "runs": [
+    {
+      "runId": "abc123",
+      "timestamp": "2026-02-03T13:26:03Z",
+      "model": "anthropic/claude-3-5-haiku-latest",
+      "taskType": "code_generation",
+      "confidence": 0.92,
+      "mode": "auto",
+      "durationMs": 1203,
+      "promptPreview": "Write a function that..."
+    }
+  ],
+  "total": 142
+}
+```
+
 ## Data Storage
 
 All data stored locally at `~/.relayplane/data.db` (SQLite).
 
 ```bash
 # View recent runs
-sqlite3 ~/.relayplane/data.db "SELECT * FROM runs ORDER BY timestamp DESC LIMIT 10"
+sqlite3 ~/.relayplane/data.db "SELECT * FROM runs ORDER BY created_at DESC LIMIT 10"
 
 # Check routing rules
 sqlite3 ~/.relayplane/data.db "SELECT * FROM routing_rules"

package/dist/cli.js

@@ -1591,12 +1591,107 @@ ${input.prompt}` : input.prompt;
   }
 };
 
+// src/config.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var os2 = __toESM(require("os"));
+var import_zod = require("zod");
+var StrategySchema = import_zod.z.object({
+  model: import_zod.z.string(),
+  minConfidence: import_zod.z.number().min(0).max(1).optional(),
+  fallback: import_zod.z.string().optional()
+});
+var ConfigSchema = import_zod.z.object({
+  strategies: import_zod.z.record(import_zod.z.string(), StrategySchema).optional(),
+  defaults: import_zod.z.object({
+    qualityModel: import_zod.z.string().optional(),
+    costModel: import_zod.z.string().optional()
+  }).optional()
+});
+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 import_zod.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 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.7";
+var VERSION = "0.1.8";
 var recentRuns = [];
 var MAX_RECENT_RUNS = 100;
 var modelCounts = {};
 var serverStartTime = 0;
+var currentConfig = loadConfig();
 var DEFAULT_ENDPOINTS = {
   anthropic: {
     baseUrl: "https://api.anthropic.com/v1",
@@ -2447,33 +2542,44 @@ async function startProxy(config = {}) {
     const confidence = getInferenceConfidence(promptText, taskType);
     log(`Inferred task: ${taskType} (confidence: ${confidence.toFixed(2)})`);
     if (routingMode !== "passthrough") {
-      const rule = relay.routing.get(taskType);
-      if (rule && rule.preferredModel) {
-        const parsed = parsePreferredModel(rule.preferredModel);
+      const configStrategy = getStrategy(currentConfig, taskType);
+      if (configStrategy) {
+        const parsed = parsePreferredModel(configStrategy.model);
         if (parsed) {
           targetProvider = parsed.provider;
           targetModel = parsed.model;
-          log(`Using learned rule: ${rule.preferredModel}`);
+          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;
         }
-      } else {
-        const defaultRoute = DEFAULT_ROUTING[taskType];
-        targetProvider = defaultRoute.provider;
-        targetModel = defaultRoute.model;
       }
       if (routingMode === "cost") {
-        const simpleTasks = ["summarization", "data_extraction", "translation", "question_answering"];
-        if (simpleTasks.includes(taskType)) {
-          targetModel = "claude-3-5-haiku-latest";
-          targetProvider = "anthropic";
-        }
+        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 = process.env["RELAYPLANE_QUALITY_MODEL"] || "claude-sonnet-4-20250514";
+        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}`);
@@ -2520,6 +2626,10 @@ async function startProxy(config = {}) {
       );
     }
   });
+  watchConfig((newConfig) => {
+    currentConfig = newConfig;
+    console.log("[relayplane] Config reloaded");
+  });
   return new Promise((resolve, reject) => {
     server.on("error", reject);
     server.listen(port, host, () => {
@@ -2528,6 +2638,7 @@ async function startProxy(config = {}) {
       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);
     });