@relayplane/proxy 0.1.6 → 0.1.8

package/dist/index.js

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  DEFAULT_CONFIG: () => DEFAULT_CONFIG,
   DEFAULT_ENDPOINTS: () => DEFAULT_ENDPOINTS,
   MODEL_MAPPING: () => MODEL_MAPPING,
   MODEL_PRICING: () => MODEL_PRICING,
@@ -44,15 +45,20 @@ __export(index_exports, {
   TaskTypes: () => TaskTypes,
   calculateCost: () => calculateCost,
   calculateSavings: () => calculateSavings,
+  getConfigPath: () => getConfigPath,
   getInferenceConfidence: () => getInferenceConfidence,
   getModelPricing: () => getModelPricing,
+  getStrategy: () => getStrategy,
   inferTaskType: () => inferTaskType,
-  startProxy: () => startProxy
+  loadConfig: () => loadConfig,
+  startProxy: () => startProxy,
+  watchConfig: () => watchConfig
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/proxy.ts
 var http = __toESM(require("http"));
+var url = __toESM(require("url"));
 
 // src/storage/store.ts
 var import_better_sqlite3 = __toESM(require("better-sqlite3"));
@@ -1622,7 +1628,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.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",
@@ -1919,9 +2025,9 @@ function convertMessagesToGemini(messages) {
           return { text: p.text };
         }
         if (p.type === "image_url" && p.image_url?.url) {
-          const url = p.image_url.url;
-          if (url.startsWith("data:")) {
-            const match = url.match(/^data:([^;]+);base64,(.+)$/);
+          const url2 = p.image_url.url;
+          if (url2.startsWith("data:")) {
+            const match = url2.match(/^data:([^;]+);base64,(.+)$/);
             if (match) {
               return {
                 inline_data: {
@@ -1931,7 +2037,7 @@ function convertMessagesToGemini(messages) {
               };
             }
           }
-          return { text: `[Image: ${url}]` };
+          return { text: `[Image: ${url2}]` };
         }
         return { text: "" };
       });
@@ -2345,28 +2451,88 @@ async function startProxy(config = {}) {
   };
   const server = http.createServer(async (req, res) => {
     res.setHeader("Access-Control-Allow-Origin", "*");
-    res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
     res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
     if (req.method === "OPTIONS") {
       res.writeHead(204);
       res.end();
       return;
     }
-    if (req.method !== "POST" || !req.url?.includes("/chat/completions")) {
-      if (req.method === "GET" && req.url?.includes("/models")) {
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(
-          JSON.stringify({
-            object: "list",
-            data: [
-              { id: "relayplane:auto", object: "model", owned_by: "relayplane" },
-              { id: "relayplane:cost", object: "model", owned_by: "relayplane" },
-              { id: "relayplane:quality", object: "model", owned_by: "relayplane" }
-            ]
-          })
-        );
-        return;
+    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 savings = relay.savingsReport(30);
+      const totalRuns = Object.values(modelCounts).reduce((a, b) => a + b, 0);
+      const modelDistribution = {};
+      for (const [model, count] of Object.entries(modelCounts)) {
+        modelDistribution[model] = {
+          count,
+          percentage: totalRuns > 0 ? (count / totalRuns * 100).toFixed(1) + "%" : "0%"
+        };
       }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        totalRuns,
+        savings: {
+          estimatedSavingsPercent: savings.savingsPercent.toFixed(1) + "%",
+          actualCostUsd: savings.actualCost.toFixed(4),
+          baselineCostUsd: savings.baselineCost.toFixed(4),
+          savedUsd: savings.savings.toFixed(4)
+        },
+        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;
@@ -2413,33 +2579,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}`);
@@ -2486,12 +2663,19 @@ 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, () => {
+      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);
     });
@@ -2554,11 +2738,26 @@ async function handleStreamingRequest(res, request, targetProvider, targetModel,
     log(`Streaming error: ${err}`);
   }
   const durationMs = Date.now() - startTime;
+  const modelKey = `${targetProvider}/${targetModel}`;
+  modelCounts[modelKey] = (modelCounts[modelKey] || 0) + 1;
   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}`);
@@ -2629,15 +2828,30 @@ async function handleNonStreamingRequest(res, request, targetProvider, targetMod
     return;
   }
   const durationMs = Date.now() - startTime;
+  const modelKey = `${targetProvider}/${targetModel}`;
+  modelCounts[modelKey] = (modelCounts[modelKey] || 0) + 1;
   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: `${targetProvider}/${targetModel}`,
+      routedTo: modelKey,
       taskType,
       confidence,
       durationMs,
@@ -2652,7 +2866,7 @@ async function handleNonStreamingRequest(res, request, targetProvider, targetMod
 }
 
 // src/types.ts
-var import_zod = require("zod");
+var import_zod2 = require("zod");
 var TaskTypes = [
   "code_generation",
   "code_review",
@@ -2664,64 +2878,65 @@ var TaskTypes = [
   "question_answering",
   "general"
 ];
-var TaskTypeSchema = import_zod.z.enum(TaskTypes);
+var TaskTypeSchema = import_zod2.z.enum(TaskTypes);
 var Providers = ["openai", "anthropic", "google", "xai", "moonshot", "local"];
-var ProviderSchema = import_zod.z.enum(Providers);
-var RelayPlaneConfigSchema = import_zod.z.object({
-  dbPath: import_zod.z.string().optional(),
-  providers: import_zod.z.record(ProviderSchema, import_zod.z.object({
-    apiKey: import_zod.z.string().optional(),
-    baseUrl: import_zod.z.string().optional()
+var ProviderSchema = import_zod2.z.enum(Providers);
+var RelayPlaneConfigSchema = import_zod2.z.object({
+  dbPath: import_zod2.z.string().optional(),
+  providers: import_zod2.z.record(ProviderSchema, import_zod2.z.object({
+    apiKey: import_zod2.z.string().optional(),
+    baseUrl: import_zod2.z.string().optional()
   })).optional(),
   defaultProvider: ProviderSchema.optional(),
-  defaultModel: import_zod.z.string().optional()
+  defaultModel: import_zod2.z.string().optional()
 });
-var RunInputSchema = import_zod.z.object({
-  prompt: import_zod.z.string().min(1),
-  systemPrompt: import_zod.z.string().optional(),
+var RunInputSchema = import_zod2.z.object({
+  prompt: import_zod2.z.string().min(1),
+  systemPrompt: import_zod2.z.string().optional(),
   taskType: TaskTypeSchema.optional(),
-  model: import_zod.z.string().optional(),
-  metadata: import_zod.z.record(import_zod.z.unknown()).optional()
+  model: import_zod2.z.string().optional(),
+  metadata: import_zod2.z.record(import_zod2.z.unknown()).optional()
 });
 var RuleSources = ["default", "user", "learned"];
-var RoutingRuleSchema = import_zod.z.object({
-  id: import_zod.z.string(),
+var RoutingRuleSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
   taskType: TaskTypeSchema,
-  preferredModel: import_zod.z.string(),
-  source: import_zod.z.enum(RuleSources),
-  confidence: import_zod.z.number().min(0).max(1).optional(),
-  sampleCount: import_zod.z.number().int().positive().optional(),
-  createdAt: import_zod.z.string(),
-  updatedAt: import_zod.z.string()
+  preferredModel: import_zod2.z.string(),
+  source: import_zod2.z.enum(RuleSources),
+  confidence: import_zod2.z.number().min(0).max(1).optional(),
+  sampleCount: import_zod2.z.number().int().positive().optional(),
+  createdAt: import_zod2.z.string(),
+  updatedAt: import_zod2.z.string()
 });
 var OutcomeQualities = ["excellent", "good", "acceptable", "poor", "failed"];
-var OutcomeInputSchema = import_zod.z.object({
-  runId: import_zod.z.string().min(1),
-  success: import_zod.z.boolean(),
-  quality: import_zod.z.enum(OutcomeQualities).optional(),
-  latencySatisfactory: import_zod.z.boolean().optional(),
-  costSatisfactory: import_zod.z.boolean().optional(),
-  feedback: import_zod.z.string().optional()
+var OutcomeInputSchema = import_zod2.z.object({
+  runId: import_zod2.z.string().min(1),
+  success: import_zod2.z.boolean(),
+  quality: import_zod2.z.enum(OutcomeQualities).optional(),
+  latencySatisfactory: import_zod2.z.boolean().optional(),
+  costSatisfactory: import_zod2.z.boolean().optional(),
+  feedback: import_zod2.z.string().optional()
 });
-var SuggestionSchema = import_zod.z.object({
-  id: import_zod.z.string(),
+var SuggestionSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
   taskType: TaskTypeSchema,
-  currentModel: import_zod.z.string(),
-  suggestedModel: import_zod.z.string(),
-  reason: import_zod.z.string(),
-  confidence: import_zod.z.number().min(0).max(1),
-  expectedImprovement: import_zod.z.object({
-    successRate: import_zod.z.number().optional(),
-    latency: import_zod.z.number().optional(),
-    cost: import_zod.z.number().optional()
+  currentModel: import_zod2.z.string(),
+  suggestedModel: import_zod2.z.string(),
+  reason: import_zod2.z.string(),
+  confidence: import_zod2.z.number().min(0).max(1),
+  expectedImprovement: import_zod2.z.object({
+    successRate: import_zod2.z.number().optional(),
+    latency: import_zod2.z.number().optional(),
+    cost: import_zod2.z.number().optional()
   }),
-  sampleCount: import_zod.z.number().int().positive(),
-  createdAt: import_zod.z.string(),
-  accepted: import_zod.z.boolean().optional(),
-  acceptedAt: import_zod.z.string().optional()
+  sampleCount: import_zod2.z.number().int().positive(),
+  createdAt: import_zod2.z.string(),
+  accepted: import_zod2.z.boolean().optional(),
+  acceptedAt: import_zod2.z.string().optional()
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DEFAULT_CONFIG,
   DEFAULT_ENDPOINTS,
   MODEL_MAPPING,
   MODEL_PRICING,
@@ -2736,9 +2951,13 @@ var SuggestionSchema = import_zod.z.object({
   TaskTypes,
   calculateCost,
   calculateSavings,
+  getConfigPath,
   getInferenceConfidence,
   getModelPricing,
+  getStrategy,
   inferTaskType,
-  startProxy
+  loadConfig,
+  startProxy,
+  watchConfig
 });
 //# sourceMappingURL=index.js.map