@relayplane/proxy 0.1.7 → 0.1.8

package/dist/index.d.mts

@@ -1020,4 +1020,99 @@ declare class OutcomeRecorder {
     };
 }
 
-export { DEFAULT_ENDPOINTS, MODEL_MAPPING, MODEL_PRICING, type ModelCostBreakdown, type Outcome, type OutcomeQuality, OutcomeRecorder, PatternDetector, type Provider, type ProviderEndpoint, ProviderSchema, Providers, type ProxyConfig, RelayPlane, type RelayPlaneConfig, RoutingEngine, type RoutingRule, type RuleSource, type RunRecord, type SavingsReport, Store, type Suggestion, type TaskType, TaskTypeSchema, TaskTypes, calculateCost, calculateSavings, getInferenceConfidence, getModelPricing, inferTaskType, startProxy };
+/**
+ * Configuration Management
+ *
+ * Handles loading, validation, and hot-reload of the config file.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Strategy configuration for a task type
+ */
+declare const StrategySchema: z.ZodObject<{
+    model: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+    fallback: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    model: string;
+    minConfidence?: number | undefined;
+    fallback?: string | undefined;
+}, {
+    model: string;
+    minConfidence?: number | undefined;
+    fallback?: string | undefined;
+}>;
+/**
+ * Full config schema
+ */
+declare const ConfigSchema: z.ZodObject<{
+    strategies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodString;
+        minConfidence: z.ZodOptional<z.ZodNumber>;
+        fallback: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        model: string;
+        minConfidence?: number | undefined;
+        fallback?: string | undefined;
+    }, {
+        model: string;
+        minConfidence?: number | undefined;
+        fallback?: string | undefined;
+    }>>>;
+    defaults: z.ZodOptional<z.ZodObject<{
+        qualityModel: z.ZodOptional<z.ZodString>;
+        costModel: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        qualityModel?: string | undefined;
+        costModel?: string | undefined;
+    }, {
+        qualityModel?: string | undefined;
+        costModel?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    strategies?: Record<string, {
+        model: string;
+        minConfidence?: number | undefined;
+        fallback?: string | undefined;
+    }> | undefined;
+    defaults?: {
+        qualityModel?: string | undefined;
+        costModel?: string | undefined;
+    } | undefined;
+}, {
+    strategies?: Record<string, {
+        model: string;
+        minConfidence?: number | undefined;
+        fallback?: string | undefined;
+    }> | undefined;
+    defaults?: {
+        qualityModel?: string | undefined;
+        costModel?: string | undefined;
+    } | undefined;
+}>;
+type StrategyConfig = z.infer<typeof StrategySchema>;
+type Config = z.infer<typeof ConfigSchema>;
+/**
+ * Default configuration
+ */
+declare const DEFAULT_CONFIG: Config;
+/**
+ * Get config file path
+ */
+declare function getConfigPath(): string;
+/**
+ * Load and validate config
+ */
+declare function loadConfig(): Config;
+/**
+ * Get strategy for a task type from config
+ */
+declare function getStrategy(config: Config, taskType: TaskType): StrategyConfig | null;
+/**
+ * Watch config file for changes
+ */
+declare function watchConfig(onChange: (config: Config) => void): void;
+
+export { type Config, DEFAULT_CONFIG, DEFAULT_ENDPOINTS, MODEL_MAPPING, MODEL_PRICING, type ModelCostBreakdown, type Outcome, type OutcomeQuality, OutcomeRecorder, PatternDetector, type Provider, type ProviderEndpoint, ProviderSchema, Providers, type ProxyConfig, RelayPlane, type RelayPlaneConfig, RoutingEngine, type RoutingRule, type RuleSource, type RunRecord, type SavingsReport, Store, type StrategyConfig, type Suggestion, type TaskType, TaskTypeSchema, TaskTypes, calculateCost, calculateSavings, getConfigPath, getInferenceConfidence, getModelPricing, getStrategy, inferTaskType, loadConfig, startProxy, watchConfig };

package/dist/index.d.ts

@@ -1020,4 +1020,99 @@ declare class OutcomeRecorder {
     };
 }
 
-export { DEFAULT_ENDPOINTS, MODEL_MAPPING, MODEL_PRICING, type ModelCostBreakdown, type Outcome, type OutcomeQuality, OutcomeRecorder, PatternDetector, type Provider, type ProviderEndpoint, ProviderSchema, Providers, type ProxyConfig, RelayPlane, type RelayPlaneConfig, RoutingEngine, type RoutingRule, type RuleSource, type RunRecord, type SavingsReport, Store, type Suggestion, type TaskType, TaskTypeSchema, TaskTypes, calculateCost, calculateSavings, getInferenceConfidence, getModelPricing, inferTaskType, startProxy };
+/**
+ * Configuration Management
+ *
+ * Handles loading, validation, and hot-reload of the config file.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Strategy configuration for a task type
+ */
+declare const StrategySchema: z.ZodObject<{
+    model: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+    fallback: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    model: string;
+    minConfidence?: number | undefined;
+    fallback?: string | undefined;
+}, {
+    model: string;
+    minConfidence?: number | undefined;
+    fallback?: string | undefined;
+}>;
+/**
+ * Full config schema
+ */
+declare const ConfigSchema: z.ZodObject<{
+    strategies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodString;
+        minConfidence: z.ZodOptional<z.ZodNumber>;
+        fallback: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        model: string;
+        minConfidence?: number | undefined;
+        fallback?: string | undefined;
+    }, {
+        model: string;
+        minConfidence?: number | undefined;
+        fallback?: string | undefined;
+    }>>>;
+    defaults: z.ZodOptional<z.ZodObject<{
+        qualityModel: z.ZodOptional<z.ZodString>;
+        costModel: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        qualityModel?: string | undefined;
+        costModel?: string | undefined;
+    }, {
+        qualityModel?: string | undefined;
+        costModel?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    strategies?: Record<string, {
+        model: string;
+        minConfidence?: number | undefined;
+        fallback?: string | undefined;
+    }> | undefined;
+    defaults?: {
+        qualityModel?: string | undefined;
+        costModel?: string | undefined;
+    } | undefined;
+}, {
+    strategies?: Record<string, {
+        model: string;
+        minConfidence?: number | undefined;
+        fallback?: string | undefined;
+    }> | undefined;
+    defaults?: {
+        qualityModel?: string | undefined;
+        costModel?: string | undefined;
+    } | undefined;
+}>;
+type StrategyConfig = z.infer<typeof StrategySchema>;
+type Config = z.infer<typeof ConfigSchema>;
+/**
+ * Default configuration
+ */
+declare const DEFAULT_CONFIG: Config;
+/**
+ * Get config file path
+ */
+declare function getConfigPath(): string;
+/**
+ * Load and validate config
+ */
+declare function loadConfig(): Config;
+/**
+ * Get strategy for a task type from config
+ */
+declare function getStrategy(config: Config, taskType: TaskType): StrategyConfig | null;
+/**
+ * Watch config file for changes
+ */
+declare function watchConfig(onChange: (config: Config) => void): void;
+
+export { type Config, DEFAULT_CONFIG, DEFAULT_ENDPOINTS, MODEL_MAPPING, MODEL_PRICING, type ModelCostBreakdown, type Outcome, type OutcomeQuality, OutcomeRecorder, PatternDetector, type Provider, type ProviderEndpoint, ProviderSchema, Providers, type ProxyConfig, RelayPlane, type RelayPlaneConfig, RoutingEngine, type RoutingRule, type RuleSource, type RunRecord, type SavingsReport, Store, type StrategyConfig, type Suggestion, type TaskType, TaskTypeSchema, TaskTypes, calculateCost, calculateSavings, getConfigPath, getInferenceConfidence, getModelPricing, getStrategy, inferTaskType, loadConfig, startProxy, watchConfig };

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,10 +45,14 @@ __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);
 
@@ -1623,12 +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.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",
@@ -2479,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}`);
@@ -2552,6 +2663,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, () => {
@@ -2560,6 +2675,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);
     });
@@ -2750,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",
@@ -2762,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,
@@ -2834,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