@acarmisc/backstage-plugin-litellm-backend 0.1.16 → 0.2.0

package/dist/client.d.ts

@@ -0,0 +1,38 @@
+import { LiteLLMConfig, UserInfo, VirtualKey, ModelInfo, UsageMetrics, TeamInfo, GenerateKeyRequest, GenerateKeyResponse, UpdateKeyRequest, DeleteKeyRequest, CreateUserRequest, CreateUserResponse } from './types';
+export declare class LiteLLMClient {
+    private baseUrl;
+    private masterKey;
+    private timeout;
+    constructor(config: LiteLLMConfig, timeout?: number);
+    private request;
+    /**
+     * Returns null when the user is not found in LiteLLM (404).
+     * Throws on all other errors so callers know something went wrong.
+     */
+    getUserInfo(userId?: string): Promise<UserInfo | null>;
+    createUser(payload: CreateUserRequest): Promise<CreateUserResponse>;
+    listKeys(userId?: string): Promise<VirtualKey[]>;
+    generateKey(request: GenerateKeyRequest): Promise<GenerateKeyResponse>;
+    updateKey(request: UpdateKeyRequest): Promise<VirtualKey>;
+    deleteKeys(request: DeleteKeyRequest): Promise<{
+        success: boolean;
+    }>;
+    listModels(): Promise<ModelInfo[]>;
+    getTeamInfo(teamId: string): Promise<TeamInfo>;
+    private emptyUsage;
+    /**
+     * Transforms LiteLLM's SpendAnalyticsPaginatedResponse into the flatter
+     * UsageMetrics shape consumed by the frontend charts.
+     *
+     * Source shape (per result row):
+     *   { date, metrics, breakdown: { models: { [name]: { metrics, api_key_breakdown: { [keyHash]: { metrics, metadata } } } } } }
+     *
+     * We fan that out into three views the UI consumes:
+     *   - daily_usage     → spend + request trends over time
+     *   - usage_by_model  → which models drove cost / traffic
+     *   - usage_by_key    → which keys drove cost / traffic (with key_alias + team_id from metadata)
+     */
+    private transformDailyActivity;
+    getUsage(startDate: string, endDate: string, userId?: string, _groupBy?: string): Promise<UsageMetrics>;
+    getTeamUsage(teamId: string, startDate: string, endDate: string): Promise<UsageMetrics>;
+}

package/dist/client.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiteLLMClient = void 0;
+const DEFAULT_TIMEOUT = 30000;
+class LiteLLMClient {
+    constructor(config, timeout = DEFAULT_TIMEOUT) {
+        this.baseUrl = config.baseUrl.replace(/\/$/, '');
+        this.masterKey = config.masterKey;
+        this.timeout = timeout;
+    }
+    async request(path, options = {}) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(`${this.baseUrl}${path}`, {
+                ...options,
+                signal: controller.signal,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.masterKey}`,
+                    ...options.headers,
+                },
+            });
+            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;
+            }
+            return response.json();
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    /**
+     * Returns null when the user is not found in LiteLLM (404).
+     * Throws on all other errors so callers know something went wrong.
+     */
+    async getUserInfo(userId) {
+        const query = userId ? `?user_id=${encodeURIComponent(userId)}` : '';
+        try {
+            return await this.request(`/user/info${query}`);
+        }
+        catch (err) {
+            if (err.status === 404)
+                return null;
+            throw err;
+        }
+    }
+    async createUser(payload) {
+        return this.request('/user/new', {
+            method: 'POST',
+            body: JSON.stringify(payload),
+        });
+    }
+    async listKeys(userId) {
+        const query = userId ? `?user_id=${encodeURIComponent(userId)}` : '';
+        try {
+            const response = await this.request(`/key/info${query}`);
+            return Array.isArray(response) ? response : (response.info ?? []);
+        }
+        catch (err) {
+            if (err.status === 404 || err.message.includes('not found')) {
+                return [];
+            }
+            throw err;
+        }
+    }
+    async generateKey(request) {
+        return this.request('/key/generate', {
+            method: 'POST',
+            body: JSON.stringify({ json: request }),
+        });
+    }
+    async updateKey(request) {
+        return this.request('/key/update', {
+            method: 'POST',
+            body: JSON.stringify(request),
+        });
+    }
+    async deleteKeys(request) {
+        return this.request('/key/delete', {
+            method: 'POST',
+            body: JSON.stringify(request),
+        });
+    }
+    async listModels() {
+        const response = await this.request('/models');
+        return Array.isArray(response) ? response : (response.data ?? []);
+    }
+    async getTeamInfo(teamId) {
+        return this.request(`/team/info?team_id=${encodeURIComponent(teamId)}`);
+    }
+    emptyUsage() {
+        return {
+            total_spend: 0,
+            total_tokens: 0,
+            prompt_tokens: 0,
+            completion_tokens: 0,
+            api_requests: 0,
+            successful_requests: 0,
+            failed_requests: 0,
+            usage_by_model: {},
+            usage_by_key: {},
+            daily_usage: [],
+            daily_by_model: [],
+        };
+    }
+    /**
+     * Transforms LiteLLM's SpendAnalyticsPaginatedResponse into the flatter
+     * UsageMetrics shape consumed by the frontend charts.
+     *
+     * Source shape (per result row):
+     *   { date, metrics, breakdown: { models: { [name]: { metrics, api_key_breakdown: { [keyHash]: { metrics, metadata } } } } } }
+     *
+     * We fan that out into three views the UI consumes:
+     *   - daily_usage     → spend + request trends over time
+     *   - usage_by_model  → which models drove cost / traffic
+     *   - usage_by_key    → which keys drove cost / traffic (with key_alias + team_id from metadata)
+     */
+    transformDailyActivity(response) {
+        const results = Array.isArray(response?.results) ? response.results : [];
+        const meta = response?.metadata ?? {};
+        const daily_usage = results
+            .map(r => ({
+            date: r.date,
+            spend: r.metrics?.spend ?? 0,
+            total_tokens: r.metrics?.total_tokens ?? 0,
+            prompt_tokens: r.metrics?.prompt_tokens ?? 0,
+            completion_tokens: r.metrics?.completion_tokens ?? 0,
+            api_requests: r.metrics?.api_requests ?? 0,
+            successful_requests: r.metrics?.successful_requests ?? 0,
+            failed_requests: r.metrics?.failed_requests ?? 0,
+        }))
+            .sort((a, b) => a.date.localeCompare(b.date));
+        const usage_by_model = {};
+        const usage_by_key = {};
+        const daily_by_model = [];
+        const emptyModelBucket = () => ({
+            total_spend: 0,
+            total_tokens: 0,
+            prompt_tokens: 0,
+            completion_tokens: 0,
+            api_requests: 0,
+            successful_requests: 0,
+            failed_requests: 0,
+        });
+        for (const r of results) {
+            const models = r.breakdown?.models ?? {};
+            for (const [name, entry] of Object.entries(models)) {
+                const m = entry?.metrics ?? {};
+                const bucket = usage_by_model[name] ?? emptyModelBucket();
+                bucket.total_spend += m.spend ?? 0;
+                bucket.total_tokens += m.total_tokens ?? 0;
+                bucket.prompt_tokens += m.prompt_tokens ?? 0;
+                bucket.completion_tokens += m.completion_tokens ?? 0;
+                bucket.api_requests += m.api_requests ?? 0;
+                bucket.successful_requests += m.successful_requests ?? 0;
+                bucket.failed_requests += m.failed_requests ?? 0;
+                usage_by_model[name] = bucket;
+                daily_by_model.push({
+                    date: r.date,
+                    model: name,
+                    spend: m.spend ?? 0,
+                    prompt_tokens: m.prompt_tokens ?? 0,
+                    completion_tokens: m.completion_tokens ?? 0,
+                    total_tokens: m.total_tokens ?? 0,
+                    api_requests: m.api_requests ?? 0,
+                    successful_requests: m.successful_requests ?? 0,
+                    failed_requests: m.failed_requests ?? 0,
+                });
+                const keyMap = entry?.api_key_breakdown ?? {};
+                for (const [keyHash, keyEntry] of Object.entries(keyMap)) {
+                    const km = keyEntry?.metrics ?? {};
+                    const kmeta = keyEntry?.metadata ?? {};
+                    const kb = usage_by_key[keyHash] ?? {
+                        key_alias: kmeta.key_alias,
+                        team_id: kmeta.team_id ?? null,
+                        models: [],
+                        ...emptyModelBucket(),
+                    };
+                    if (!kb.key_alias && kmeta.key_alias)
+                        kb.key_alias = kmeta.key_alias;
+                    if (kb.team_id == null && kmeta.team_id)
+                        kb.team_id = kmeta.team_id;
+                    if (!kb.models.includes(name))
+                        kb.models.push(name);
+                    kb.total_spend += km.spend ?? 0;
+                    kb.total_tokens += km.total_tokens ?? 0;
+                    kb.prompt_tokens += km.prompt_tokens ?? 0;
+                    kb.completion_tokens += km.completion_tokens ?? 0;
+                    kb.api_requests += km.api_requests ?? 0;
+                    kb.successful_requests += km.successful_requests ?? 0;
+                    kb.failed_requests += km.failed_requests ?? 0;
+                    usage_by_key[keyHash] = kb;
+                }
+            }
+        }
+        return {
+            total_spend: meta.total_spend ?? 0,
+            total_tokens: meta.total_tokens ?? 0,
+            prompt_tokens: meta.total_prompt_tokens ?? 0,
+            completion_tokens: meta.total_completion_tokens ?? 0,
+            api_requests: meta.total_api_requests ?? 0,
+            successful_requests: meta.total_successful_requests ?? 0,
+            failed_requests: meta.total_failed_requests ?? 0,
+            usage_by_model,
+            usage_by_key,
+            daily_usage,
+            daily_by_model,
+        };
+    }
+    async getUsage(startDate, endDate, userId, _groupBy) {
+        const params = new URLSearchParams({
+            start_date: startDate,
+            end_date: endDate,
+            page_size: '100',
+        });
+        if (userId)
+            params.append('user_id', userId);
+        try {
+            const response = await this.request(`/user/daily/activity?${params.toString()}`);
+            return this.transformDailyActivity(response);
+        }
+        catch (err) {
+            if (err.status === 404 || err.message.includes('not found')) {
+                return this.emptyUsage();
+            }
+            throw err;
+        }
+    }
+    async getTeamUsage(teamId, startDate, endDate) {
+        const params = new URLSearchParams({
+            start_date: startDate,
+            end_date: endDate,
+            team_ids: teamId,
+            page_size: '100',
+        });
+        try {
+            const response = await this.request(`/team/daily/activity?${params.toString()}`);
+            return this.transformDailyActivity(response);
+        }
+        catch (err) {
+            if (err.status === 404 || err.message.includes('not found')) {
+                return this.emptyUsage();
+            }
+            throw err;
+        }
+    }
+}
+exports.LiteLLMClient = LiteLLMClient;

package/dist/index.cjs.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -32,7 +22,6 @@ var index_exports = {};
 __export(index_exports, {
   LiteLLMClient: () => LiteLLMClient,
   createRouter: () => createRouter,
-  default: () => litellmPlugin,
   litellmPlugin: () => litellmPlugin
 });
 module.exports = __toCommonJS(index_exports);
@@ -41,7 +30,7 @@ module.exports = __toCommonJS(index_exports);
 var import_backend_plugin_api = require("@backstage/backend-plugin-api");
 
 // src/router.ts
-var import_express = __toESM(require("express"));
+var import_express = require("express");
 var import_catalog_client = require("@backstage/catalog-client");
 
 // src/client.ts
@@ -61,15 +50,13 @@ var LiteLLMClient = class {
         signal: controller.signal,
         headers: {
           "Content-Type": "application/json",
-          Authorization: `Bearer ${this.masterKey}`,
+          "Authorization": `Bearer ${this.masterKey}`,
           ...options.headers
         }
       });
       if (!response.ok) {
         const errorBody = await response.text();
-        const err = new Error(
-          `LiteLLM API error: ${response.status} ${response.statusText} - ${errorBody}`
-        );
+        const err = new Error(`LiteLLM API error: ${response.status} ${response.statusText} - ${errorBody}`);
         err.status = response.status;
         throw err;
       }
@@ -97,36 +84,11 @@ var LiteLLMClient = class {
       body: JSON.stringify(payload)
     });
   }
-  /**
-   * Updates an existing LiteLLM user record. Used as a defensive follow-up
-   * after /user/new because the upsert path of /user/new has been observed
-   * to silently drop fields like user_role under concurrent inserts.
-   */
-  async updateUser(payload) {
-    return this.request("/user/update", {
-      method: "POST",
-      body: JSON.stringify(payload)
-    });
-  }
-  /**
-   * Returns the keys belonging to a user.
-   *
-   * Implementation note: LiteLLM's `/key/info` endpoint requires a `key`
-   * hash and returns 404 when only `user_id` is passed. The correct way
-   * to enumerate a user's keys is `/user/info?user_id=X`, which embeds
-   * a `keys` array with per-key metadata. We unwrap that array and
-   * normalise field names to match the frontend VirtualKey shape
-   * (LiteLLM exposes `key_name` for the masked display value and
-   * `expires` instead of `expires_at`).
-   */
   async listKeys(userId) {
-    if (!userId) return [];
+    const query = userId ? `?user_id=${encodeURIComponent(userId)}` : "";
     try {
-      const response = await this.request(
-        `/user/info?user_id=${encodeURIComponent(userId)}`
-      );
-      const rawKeys = response.keys ?? [];
-      return rawKeys.map(this.toVirtualKey);
+      const response = await this.request(`/key/info${query}`);
+      return Array.isArray(response) ? response : response.info ?? [];
     } catch (err) {
       if (err.status === 404 || err.message.includes("not found")) {
         return [];
@@ -134,44 +96,10 @@ var LiteLLMClient = class {
       throw err;
     }
   }
-  toVirtualKey(k) {
-    return {
-      // The hashed `token` never leaves LiteLLM in a usable form; the
-      // masked `key_name` ("sk-...XXXX") is what the UI displays. Fall
-      // back to `token` only when `key_name` is missing.
-      key: k.key_name ?? k.token,
-      token: k.token,
-      key_alias: k.key_alias ?? void 0,
-      created_at: k.created_at,
-      expires_at: k.expires ?? void 0,
-      spend: k.spend ?? 0,
-      max_budget: k.max_budget ?? void 0,
-      tpm_limit: k.tpm_limit ?? void 0,
-      rpm_limit: k.rpm_limit ?? void 0,
-      models: k.models ?? [],
-      user_id: k.user_id ?? void 0
-    };
-  }
-  /**
-   * Creates a new virtual key on the LiteLLM proxy.
-   *
-   * Implementation notes — both required to avoid silently-empty keys:
-   *   1. The body must be the plain payload. An earlier version wrapped
-   *      it as `{ json: request }`; LiteLLM doesn't unwrap that envelope
-   *      and treats the request as having no fields, returning a key
-   *      with null alias / models / budget / limits.
-   *   2. LiteLLM expects `key_alias`, not `alias`. Without the rename,
-   *      the alias the user typed is dropped on the floor.
-   */
   async generateKey(request) {
-    const { alias, ...rest } = request;
-    const payload = {
-      ...rest,
-      ...alias && { key_alias: alias }
-    };
     return this.request("/key/generate", {
       method: "POST",
-      body: JSON.stringify(payload)
+      body: JSON.stringify({ json: request })
     });
   }
   async updateKey(request) {
@@ -187,15 +115,11 @@ var LiteLLMClient = class {
     });
   }
   async listModels() {
-    const response = await this.request(
-      "/models"
-    );
+    const response = await this.request("/models");
     return Array.isArray(response) ? response : response.data ?? [];
   }
   async getTeamInfo(teamId) {
-    return this.request(
-      `/team/info?team_id=${encodeURIComponent(teamId)}`
-    );
+    return this.request(`/team/info?team_id=${encodeURIComponent(teamId)}`);
   }
   emptyUsage() {
     return {
@@ -319,9 +243,7 @@ var LiteLLMClient = class {
     });
     if (userId) params.append("user_id", userId);
     try {
-      const response = await this.request(
-        `/user/daily/activity?${params.toString()}`
-      );
+      const response = await this.request(`/user/daily/activity?${params.toString()}`);
       return this.transformDailyActivity(response);
     } catch (err) {
       if (err.status === 404 || err.message.includes("not found")) {
@@ -338,9 +260,7 @@ var LiteLLMClient = class {
       page_size: "100"
     });
     try {
-      const response = await this.request(
-        `/team/daily/activity?${params.toString()}`
-      );
+      const response = await this.request(`/team/daily/activity?${params.toString()}`);
       return this.transformDailyActivity(response);
     } catch (err) {
       if (err.status === 404 || err.message.includes("not found")) {
@@ -450,7 +370,6 @@ async function provisionUser(client, userId, defaults, profile, backstageEntity,
     ...defaults.tpmLimit !== void 0 && { tpm_limit: defaults.tpmLimit },
     ...defaults.rpmLimit !== void 0 && { rpm_limit: defaults.rpmLimit },
     ...defaults.userRole && { user_role: defaults.userRole },
-    auto_create_key: false,
     metadata: {
       ...defaults.metadata,
       provisioned_by: "backstage",
@@ -618,7 +537,6 @@ async function createRouter(options) {
     );
   }
   const router = (0, import_express.Router)();
-  router.use(import_express.default.json());
   router.get("/health", (_req, res) => {
     res.json({ status: "ok", provisioning: provisioningEnabled });
   });
@@ -675,19 +593,6 @@ async function createRouter(options) {
   });
   router.post("/keys/generate", async (req, res) => {
     try {
-      const body = req.body ?? {};
-      const missing = [];
-      if (!body.alias?.trim()) missing.push("alias");
-      if (typeof body.max_budget !== "number" || body.max_budget <= 0) {
-        missing.push("max_budget (positive number)");
-      }
-      if (missing.length) {
-        res.status(400).json({
-          error: "Missing required fields",
-          hint: `Required: ${missing.join(", ")}`
-        });
-        return;
-      }
       const tokenEntityRef = await resolveUserId(req, auth);
       const resolvedUserId = tokenEntityRef ? toLiteLLMUserId(tokenEntityRef, userIdDomain) : void 0;
       if (resolvedUserId) {
@@ -703,20 +608,8 @@ async function createRouter(options) {
           logger
         );
       }
-      const profile = tokenEntityRef ? await resolveUserProfile(tokenEntityRef, catalogClient, auth, logger) : {};
-      const enrichedMetadata = {
-        ...body.metadata ?? {},
-        created_by_backstage_user: tokenEntityRef ?? "unknown",
-        ...profile.email && { created_by_email: profile.email },
-        ...profile.displayName && {
-          created_by_display_name: profile.displayName
-        },
-        created_via: "backstage",
-        created_at_iso: (/* @__PURE__ */ new Date()).toISOString()
-      };
       const request = {
-        ...body,
-        metadata: enrichedMetadata,
+        ...req.body,
         ...resolvedUserId && { user_id: resolvedUserId }
       };
       const result = await client.generateKey(request);