@acarmisc/backstage-plugin-litellm-backend 0.6.2 → 0.8.0

package/config.d.ts

@@ -127,6 +127,27 @@ export interface Config {
       group?: string;
     };
 
+    /**
+     * Controls for the "Generate New Key" form in the frontend.
+     */
+    keyGeneration?: {
+      /**
+       * When true, users can tick an "Unlimited budget" checkbox that skips
+       * the max-budget cap entirely. The checkbox is hidden from the form
+       * when this is false, so a budget is always required.
+       * @default false
+       */
+      allowUnlimitedBudget?: boolean;
+
+      /**
+       * When true (the default), a team must be selected before a key can
+       * be generated. Set to false to let users generate personal,
+       * team-less keys.
+       * @default true
+       */
+      teamRequired?: boolean;
+    };
+
     bridge?: {
       /**
        * When true, mount the /bridge/keys, /bridge/keys (POST), /bridge/models

package/dist/client.d.ts

@@ -1,4 +1,16 @@
 import { LiteLLMConfig, UserInfo, VirtualKey, ModelInfo, UsageMetrics, TeamInfo, GenerateKeyRequest, GenerateKeyResponse, UpdateKeyRequest, DeleteKeyRequest, CreateUserRequest, CreateUserResponse, AuditLogsParams, PaginatedAuditLogs } from './types';
+/**
+ * Typed error for failed upstream LiteLLM responses. Preserves the HTTP
+ * status and the structured `param` (e.g. `key_alias`) from the upstream
+ * body so the router can surface a 400 instead of collapsing everything
+ * into a 500. The message is the upstream `error.message` when present,
+ * otherwise the raw body text.
+ */
+export declare class LiteLLMUpstreamError extends Error {
+    status: number;
+    param?: string;
+    constructor(status: number, statusText: string, body: string);
+}
 export declare class LiteLLMClient {
     private baseUrl;
     private masterKey;

package/dist/client.js

@@ -1,7 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LiteLLMClient = void 0;
+exports.LiteLLMClient = exports.LiteLLMUpstreamError = void 0;
 const DEFAULT_TIMEOUT = 30000;
+/**
+ * Typed error for failed upstream LiteLLM responses. Preserves the HTTP
+ * status and the structured `param` (e.g. `key_alias`) from the upstream
+ * body so the router can surface a 400 instead of collapsing everything
+ * into a 500. The message is the upstream `error.message` when present,
+ * otherwise the raw body text.
+ */
+class LiteLLMUpstreamError extends Error {
+    constructor(status, statusText, body) {
+        let message = `LiteLLM API error: ${status} ${statusText} - ${body}`;
+        let param;
+        try {
+            const parsed = JSON.parse(body);
+            const inner = parsed?.error ?? parsed;
+            if (typeof inner?.message === 'string')
+                message = inner.message;
+            if (typeof inner?.param === 'string' && inner.param !== 'None') {
+                param = inner.param;
+            }
+        }
+        catch {
+            // not JSON — keep the raw body in the message
+        }
+        super(message);
+        this.status = status;
+        this.param = param;
+    }
+}
+exports.LiteLLMUpstreamError = LiteLLMUpstreamError;
 class LiteLLMClient {
     constructor(config, timeout = DEFAULT_TIMEOUT) {
         this.baseUrl = config.baseUrl.replace(/\/$/, '');
@@ -28,9 +57,7 @@ class LiteLLMClient {
             });
             if (!response.ok) {
                 const errorBody = await response.text();
-                const err = new Error(`LiteLLM API error: ${response.status} ${response.statusText} - ${errorBody}`);
-                err.status = response.status;
-                throw err;
+                throw new LiteLLMUpstreamError(response.status, response.statusText, errorBody);
             }
             return response.json();
         }

package/dist/index.cjs.js

@@ -63,6 +63,24 @@ var import_catalog_client = require("@backstage/catalog-client");
 
 // src/client.ts
 var DEFAULT_TIMEOUT = 3e4;
+var LiteLLMUpstreamError = class extends Error {
+  constructor(status, statusText, body) {
+    let message2 = `LiteLLM API error: ${status} ${statusText} - ${body}`;
+    let param;
+    try {
+      const parsed = JSON.parse(body);
+      const inner = parsed?.error ?? parsed;
+      if (typeof inner?.message === "string") message2 = inner.message;
+      if (typeof inner?.param === "string" && inner.param !== "None") {
+        param = inner.param;
+      }
+    } catch {
+    }
+    super(message2);
+    this.status = status;
+    this.param = param;
+  }
+};
 var LiteLLMClient = class {
   constructor(config, timeout = DEFAULT_TIMEOUT) {
     this.baseUrl = config.baseUrl.replace(/\/$/, "");
@@ -84,11 +102,11 @@ var LiteLLMClient = class {
       });
       if (!response.ok) {
         const errorBody = await response.text();
-        const err = new Error(
-          `LiteLLM API error: ${response.status} ${response.statusText} - ${errorBody}`
+        throw new LiteLLMUpstreamError(
+          response.status,
+          response.statusText,
+          errorBody
         );
-        err.status = response.status;
-        throw err;
       }
       return response.json();
     } finally {
@@ -511,12 +529,16 @@ var openApiSpec = {
     "/config": {
       get: {
         tags: ["System"],
-        summary: "Public LiteLLM proxy base URL (for snippet generation)",
+        summary: "Public LiteLLM proxy base URL and key-generation form settings",
         responses: {
           "200": {
-            description: "Proxy URL",
+            description: "Frontend config",
             content: { "application/json": { schema: { type: "object", properties: {
-              baseUrl: { type: "string" }
+              baseUrl: { type: "string" },
+              keyGeneration: { type: "object", properties: {
+                allowUnlimitedBudget: { type: "boolean" },
+                teamRequired: { type: "boolean" }
+              } }
             } } } }
           }
         }
@@ -2465,6 +2487,8 @@ async function createRouter(options) {
   const { enabled: provisioningEnabled, defaults: provisioningDefaults } = readProvisioningDefaults(config);
   const roleConfigs = readRoleConfigs(config);
   const auditGroup = config.getOptionalString("litellm.audit.group");
+  const allowUnlimitedBudget = config.getOptionalBoolean("litellm.keyGeneration.allowUnlimitedBudget") ?? false;
+  const teamRequired = config.getOptionalBoolean("litellm.keyGeneration.teamRequired") ?? true;
   const catalogClient = new import_catalog_client.CatalogClient({ discoveryApi: discovery });
   if (provisioningEnabled) {
     logger.info(
@@ -2477,7 +2501,10 @@ async function createRouter(options) {
     res.json({ status: "ok", provisioning: provisioningEnabled });
   });
   router.get("/config", (_req, res) => {
-    res.json({ baseUrl: publicBaseUrl });
+    res.json({
+      baseUrl: publicBaseUrl,
+      keyGeneration: { allowUnlimitedBudget, teamRequired }
+    });
   });
   router.get("/openapi.json", (_req, res) => {
     res.json(openApiSpec);
@@ -2669,6 +2696,13 @@ async function createRouter(options) {
         });
         return;
       }
+      if (error instanceof LiteLLMUpstreamError) {
+        res.status(error.status).json({
+          error: error.message,
+          ...error.param ? { param: error.param } : {}
+        });
+        return;
+      }
       logger.error("Failed to generate key", error);
       res.status(500).json({ error: error.message });
     }