@relayplane/proxy 0.1.8 → 0.1.9

package/dist/index.d.mts

@@ -1071,6 +1071,19 @@ declare const ConfigSchema: z.ZodObject<{
         qualityModel?: string | undefined;
         costModel?: string | undefined;
     }>>;
+    auth: z.ZodOptional<z.ZodObject<{
+        anthropicApiKey: z.ZodOptional<z.ZodString>;
+        anthropicMaxToken: z.ZodOptional<z.ZodString>;
+        useMaxForModels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        anthropicApiKey?: string | undefined;
+        anthropicMaxToken?: string | undefined;
+        useMaxForModels?: string[] | undefined;
+    }, {
+        anthropicApiKey?: string | undefined;
+        anthropicMaxToken?: string | undefined;
+        useMaxForModels?: string[] | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     strategies?: Record<string, {
         model: string;
@@ -1081,6 +1094,11 @@ declare const ConfigSchema: z.ZodObject<{
         qualityModel?: string | undefined;
         costModel?: string | undefined;
     } | undefined;
+    auth?: {
+        anthropicApiKey?: string | undefined;
+        anthropicMaxToken?: string | undefined;
+        useMaxForModels?: string[] | undefined;
+    } | undefined;
 }, {
     strategies?: Record<string, {
         model: string;
@@ -1091,6 +1109,11 @@ declare const ConfigSchema: z.ZodObject<{
         qualityModel?: string | undefined;
         costModel?: string | undefined;
     } | undefined;
+    auth?: {
+        anthropicApiKey?: string | undefined;
+        anthropicMaxToken?: string | undefined;
+        useMaxForModels?: string[] | undefined;
+    } | undefined;
 }>;
 type StrategyConfig = z.infer<typeof StrategySchema>;
 type Config = z.infer<typeof ConfigSchema>;

package/dist/index.d.ts

@@ -1071,6 +1071,19 @@ declare const ConfigSchema: z.ZodObject<{
         qualityModel?: string | undefined;
         costModel?: string | undefined;
     }>>;
+    auth: z.ZodOptional<z.ZodObject<{
+        anthropicApiKey: z.ZodOptional<z.ZodString>;
+        anthropicMaxToken: z.ZodOptional<z.ZodString>;
+        useMaxForModels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        anthropicApiKey?: string | undefined;
+        anthropicMaxToken?: string | undefined;
+        useMaxForModels?: string[] | undefined;
+    }, {
+        anthropicApiKey?: string | undefined;
+        anthropicMaxToken?: string | undefined;
+        useMaxForModels?: string[] | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     strategies?: Record<string, {
         model: string;
@@ -1081,6 +1094,11 @@ declare const ConfigSchema: z.ZodObject<{
         qualityModel?: string | undefined;
         costModel?: string | undefined;
     } | undefined;
+    auth?: {
+        anthropicApiKey?: string | undefined;
+        anthropicMaxToken?: string | undefined;
+        useMaxForModels?: string[] | undefined;
+    } | undefined;
 }, {
     strategies?: Record<string, {
         model: string;
@@ -1091,6 +1109,11 @@ declare const ConfigSchema: z.ZodObject<{
         qualityModel?: string | undefined;
         costModel?: string | undefined;
     } | undefined;
+    auth?: {
+        anthropicApiKey?: string | undefined;
+        anthropicMaxToken?: string | undefined;
+        useMaxForModels?: string[] | undefined;
+    } | undefined;
 }>;
 type StrategyConfig = z.infer<typeof StrategySchema>;
 type Config = z.infer<typeof ConfigSchema>;

package/dist/index.js

@@ -1638,12 +1638,19 @@ var StrategySchema = import_zod.z.object({
   minConfidence: import_zod.z.number().min(0).max(1).optional(),
   fallback: import_zod.z.string().optional()
 });
+var AuthSchema = import_zod.z.object({
+  anthropicApiKey: import_zod.z.string().optional(),
+  anthropicMaxToken: import_zod.z.string().optional(),
+  useMaxForModels: import_zod.z.array(import_zod.z.string()).optional()
+  // Default: ['opus']
+}).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()
+  }).optional(),
+  auth: AuthSchema
 });
 var DEFAULT_CONFIG = {
   strategies: {
@@ -1703,6 +1710,19 @@ function loadConfig() {
 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);
@@ -1723,7 +1743,7 @@ function watchConfig(onChange) {
 }
 
 // src/proxy.ts
-var VERSION = "0.1.8";
+var VERSION = "0.1.9";
 var recentRuns = [];
 var MAX_RECENT_RUNS = 100;
 var modelCounts = {};
@@ -1791,13 +1811,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;
   }
@@ -1808,13 +1832,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;
   }
@@ -2620,12 +2648,24 @@ async function startProxy(config = {}) {
       }
     }
     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"];
@@ -2636,6 +2676,7 @@ async function startProxy(config = {}) {
         targetProvider,
         targetModel,
         apiKey,
+        anthropicAuth,
         relay,
         promptText,
         taskType,
@@ -2652,6 +2693,7 @@ async function startProxy(config = {}) {
         targetProvider,
         targetModel,
         apiKey,
+        anthropicAuth,
         relay,
         promptText,
         taskType,
@@ -2681,12 +2723,13 @@ async function startProxy(config = {}) {
     });
   });
 }
-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);
@@ -2764,13 +2807,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" });