@relayplane/proxy 0.1.7 → 0.1.9

package/dist/index.mjs

@@ -1570,12 +1570,127 @@ ${input.prompt}` : input.prompt;
   }
 };
 
+// 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.7";
+var VERSION = "0.1.9";
 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",
@@ -1638,13 +1753,17 @@ function extractPromptText(messages) {
     return "";
   }).join("\n");
 }
-async function forwardToAnthropic(request, targetModel, apiKey, betaHeaders) {
+async function forwardToAnthropic(request, targetModel, auth, betaHeaders) {
   const anthropicBody = buildAnthropicBody(request, targetModel, false);
   const headers = {
     "Content-Type": "application/json",
-    "x-api-key": apiKey,
     "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;
   }
@@ -1655,13 +1774,17 @@ async function forwardToAnthropic(request, targetModel, apiKey, betaHeaders) {
   });
   return response;
 }
-async function forwardToAnthropicStream(request, targetModel, apiKey, betaHeaders) {
+async function forwardToAnthropicStream(request, targetModel, auth, betaHeaders) {
   const anthropicBody = buildAnthropicBody(request, targetModel, true);
   const headers = {
     "Content-Type": "application/json",
-    "x-api-key": apiKey,
     "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;
   }
@@ -2426,42 +2549,65 @@ 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}`);
-    const apiKeyEnv = DEFAULT_ENDPOINTS[targetProvider]?.apiKeyEnv ?? `${targetProvider.toUpperCase()}_API_KEY`;
-    const apiKey = process.env[apiKeyEnv];
-    if (!apiKey) {
-      res.writeHead(500, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ error: `Missing ${apiKeyEnv} environment variable` }));
-      return;
+    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"];
@@ -2472,6 +2618,7 @@ async function startProxy(config = {}) {
         targetProvider,
         targetModel,
         apiKey,
+        anthropicAuth,
         relay,
         promptText,
         taskType,
@@ -2488,6 +2635,7 @@ async function startProxy(config = {}) {
         targetProvider,
         targetModel,
         apiKey,
+        anthropicAuth,
         relay,
         promptText,
         taskType,
@@ -2499,6 +2647,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, () => {
@@ -2507,17 +2659,19 @@ 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);
     });
   });
 }
-async function handleStreamingRequest(res, request, targetProvider, targetModel, apiKey, relay, promptText, taskType, confidence, routingMode, startTime, log, betaHeaders) {
+async function handleStreamingRequest(res, request, targetProvider, targetModel, apiKey, anthropicAuth, relay, promptText, taskType, confidence, routingMode, startTime, log, betaHeaders) {
   let providerResponse;
   try {
     switch (targetProvider) {
       case "anthropic":
-        providerResponse = await forwardToAnthropicStream(request, targetModel, apiKey, betaHeaders);
+        if (!anthropicAuth) throw new Error("No Anthropic auth");
+        providerResponse = await forwardToAnthropicStream(request, targetModel, anthropicAuth, betaHeaders);
         break;
       case "google":
         providerResponse = await forwardToGeminiStream(request, targetModel, apiKey);
@@ -2595,13 +2749,14 @@ async function handleStreamingRequest(res, request, targetProvider, targetModel,
   });
   res.end();
 }
-async function handleNonStreamingRequest(res, request, targetProvider, targetModel, apiKey, relay, promptText, taskType, confidence, routingMode, startTime, log, betaHeaders) {
+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": {
-        providerResponse = await forwardToAnthropic(request, targetModel, apiKey, betaHeaders);
+        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" });
@@ -2697,7 +2852,7 @@ async function handleNonStreamingRequest(res, request, targetProvider, targetMod
 }
 
 // src/types.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 var TaskTypes = [
   "code_generation",
   "code_review",
@@ -2709,63 +2864,64 @@ var TaskTypes = [
   "question_answering",
   "general"
 ];
-var TaskTypeSchema = z.enum(TaskTypes);
+var TaskTypeSchema = z2.enum(TaskTypes);
 var Providers = ["openai", "anthropic", "google", "xai", "moonshot", "local"];
-var ProviderSchema = z.enum(Providers);
-var RelayPlaneConfigSchema = z.object({
-  dbPath: z.string().optional(),
-  providers: z.record(ProviderSchema, z.object({
-    apiKey: z.string().optional(),
-    baseUrl: z.string().optional()
+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: z.string().optional()
+  defaultModel: z2.string().optional()
 });
-var RunInputSchema = z.object({
-  prompt: z.string().min(1),
-  systemPrompt: z.string().optional(),
+var RunInputSchema = z2.object({
+  prompt: z2.string().min(1),
+  systemPrompt: z2.string().optional(),
   taskType: TaskTypeSchema.optional(),
-  model: z.string().optional(),
-  metadata: z.record(z.unknown()).optional()
+  model: z2.string().optional(),
+  metadata: z2.record(z2.unknown()).optional()
 });
 var RuleSources = ["default", "user", "learned"];
-var RoutingRuleSchema = z.object({
-  id: z.string(),
+var RoutingRuleSchema = z2.object({
+  id: z2.string(),
   taskType: TaskTypeSchema,
-  preferredModel: z.string(),
-  source: z.enum(RuleSources),
-  confidence: z.number().min(0).max(1).optional(),
-  sampleCount: z.number().int().positive().optional(),
-  createdAt: z.string(),
-  updatedAt: z.string()
+  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 = z.object({
-  runId: z.string().min(1),
-  success: z.boolean(),
-  quality: z.enum(OutcomeQualities).optional(),
-  latencySatisfactory: z.boolean().optional(),
-  costSatisfactory: z.boolean().optional(),
-  feedback: z.string().optional()
+var 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 = z.object({
-  id: z.string(),
+var SuggestionSchema = z2.object({
+  id: z2.string(),
   taskType: TaskTypeSchema,
-  currentModel: z.string(),
-  suggestedModel: z.string(),
-  reason: z.string(),
-  confidence: z.number().min(0).max(1),
-  expectedImprovement: z.object({
-    successRate: z.number().optional(),
-    latency: z.number().optional(),
-    cost: z.number().optional()
+  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: z.number().int().positive(),
-  createdAt: z.string(),
-  accepted: z.boolean().optional(),
-  acceptedAt: z.string().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,
@@ -2780,9 +2936,13 @@ export {
   TaskTypes,
   calculateCost,
   calculateSavings,
+  getConfigPath,
   getInferenceConfidence,
   getModelPricing,
+  getStrategy,
   inferTaskType,
-  startProxy
+  loadConfig,
+  startProxy,
+  watchConfig
 };
 //# sourceMappingURL=index.mjs.map