@camunda/ccma-api 0.0.1

package/dist/services/litellm/litellm.service.d.ts

@@ -0,0 +1,290 @@
+import type { RequestBaseParams } from '../../types/general.types.js';
+/**
+ * Request to create a new team in LiteLLM
+ * POST /team/new
+ */
+export interface CreateTeamRequest extends RequestBaseParams {
+    options: {
+        /** Base URL for LiteLLM API */
+        litellmApiBaseUrl: string;
+        /** API token for authentication */
+        apiToken: string;
+        /** Team alias/name */
+        team_alias: string;
+        /** Maximum budget for the team */
+        max_budget?: number;
+        /** Budget duration (e.g., '30d', '1mo') */
+        budget_duration?: string;
+    };
+}
+/**
+ * Response from creating a new team
+ */
+export interface CreateTeamResponse {
+    team_id: string;
+    team_alias: string;
+    max_budget?: number;
+    budget_duration?: string;
+    created_at?: string;
+    [key: string]: any;
+}
+/**
+ * Request to update a team's budget in LiteLLM
+ * POST /team/update
+ */
+export interface UpdateTeamBudgetRequest extends RequestBaseParams {
+    options: {
+        /** Base URL for LiteLLM API */
+        litellmApiBaseUrl: string;
+        /** API token for authentication */
+        apiToken: string;
+        /** Team ID to update */
+        team_id: string;
+        /** New maximum budget for the team */
+        max_budget: number;
+    };
+}
+/**
+ * Response from updating a team's budget
+ */
+export interface UpdateTeamBudgetResponse {
+    team_id: string;
+    team_alias?: string;
+    max_budget: number;
+    budget_duration?: string;
+    [key: string]: any;
+}
+/**
+ * Request to update a key's budget in LiteLLM
+ * POST /key/update
+ */
+export interface UpdateKeyBudgetRequest extends RequestBaseParams {
+    options: {
+        /** Base URL for LiteLLM API */
+        litellmApiBaseUrl: string;
+        /** API token for authentication */
+        apiToken: string;
+        /** Key to update */
+        key: string;
+        /** New maximum budget for the key */
+        max_budget: number;
+    };
+}
+/**
+ * Response from updating a key's budget
+ */
+export interface UpdateKeyBudgetResponse {
+    key: string;
+    max_budget: number;
+    [key: string]: any;
+}
+/**
+ * Request to delete a team
+ * POST /team/delete
+ */
+export interface DeleteTeamRequest extends RequestBaseParams {
+    options: {
+        /** Base URL for LiteLLM API */
+        litellmApiBaseUrl: string;
+        /** API token for authentication */
+        apiToken: string;
+        /** Team ID to delete */
+        team_id: string;
+    };
+}
+/**
+ * Response from deleting a team
+ */
+export interface DeleteTeamResponse {
+    deleted_teams: string[];
+    [key: string]: any;
+}
+/**
+ * Request to generate a key for a team
+ * POST /key/generate
+ */
+export interface GenerateKeyRequest extends RequestBaseParams {
+    options: {
+        /** Base URL for LiteLLM API */
+        litellmApiBaseUrl: string;
+        /** API token for authentication */
+        apiToken: string;
+        /** Team ID to generate key for */
+        team_id: string;
+        /** Models the key can access */
+        models?: string[];
+        /** Optional key alias */
+        key_alias?: string;
+        /** Duration for the key */
+        duration?: string;
+        /** Additional metadata */
+        metadata?: Record<string, any>;
+        /** Maximum budget for this key */
+        max_budget?: number;
+        /** Budget duration */
+        budget_duration?: string;
+    };
+}
+/**
+ * Response from generating a key
+ */
+export interface GenerateKeyResponse {
+    key: string;
+    key_name?: string;
+    expires?: string;
+    team_id: string;
+    metadata?: Record<string, any>;
+    [key: string]: any;
+}
+/**
+ * Request to block a key
+ * POST /key/block
+ */
+export interface BlockKeyRequest extends RequestBaseParams {
+    options: {
+        /** Base URL for LiteLLM API */
+        litellmApiBaseUrl: string;
+        /** API token for authentication */
+        apiToken: string;
+        /** Key to block */
+        key: string;
+    };
+}
+/**
+ * Response from blocking a key
+ */
+export interface BlockKeyResponse {
+    status: string;
+    message?: string;
+    [key: string]: any;
+}
+/**
+ * Request to unblock a key
+ * POST /key/unblock
+ */
+export interface UnblockKeyRequest extends RequestBaseParams {
+    options: {
+        /** Base URL for LiteLLM API */
+        litellmApiBaseUrl: string;
+        /** API token for authentication */
+        apiToken: string;
+        /** Key to unblock */
+        key: string;
+    };
+}
+/**
+ * Response from unblocking a key
+ */
+export interface UnblockKeyResponse {
+    status: string;
+    message?: string;
+    [key: string]: any;
+}
+/**
+ * Request to get key info
+ * GET /key/info
+ */
+export interface GetKeyInfoRequest extends RequestBaseParams {
+    options: {
+        /** Base URL for LiteLLM API */
+        litellmApiBaseUrl: string;
+        /** API token for authentication */
+        apiToken: string;
+        /** Key to get info for */
+        key: string;
+    };
+}
+/**
+ * Request to delete a key
+ * POST /key/delete
+ */
+export interface DeleteKeyRequest extends RequestBaseParams {
+    options: {
+        /** Base URL for LiteLLM API */
+        litellmApiBaseUrl: string;
+        /** API token for authentication */
+        apiToken: string;
+        /** Key to delete */
+        key: string;
+    };
+}
+/**
+ * Response from deleting a key
+ */
+export interface DeleteKeyResponse {
+    deleted_keys: string[];
+    [key: string]: any;
+}
+/**
+ * Response from getting key info including usage and spend
+ */
+export interface GetKeyInfoResponse {
+    info: {
+        key: string;
+        team_id: string;
+        spend?: number;
+        usage?: {
+            total_tokens?: number;
+            prompt_tokens?: number;
+            completion_tokens?: number;
+        };
+        max_budget?: number;
+        budget_duration?: string;
+        blocked?: boolean;
+        created_at?: string;
+        expires_at?: string;
+        metadata?: Record<string, any>;
+        [key: string]: any;
+    };
+}
+/**
+ * Service for interacting with LiteLLM API
+ * API Documentation: https://camunda.litellm-sandbox.ai
+ */
+export declare class LiteLLMService {
+    /**
+     * Create a new team in LiteLLM
+     * POST /team/new
+     */
+    static createTeam(params: CreateTeamRequest): Promise<CreateTeamResponse>;
+    /**
+     * Update a team's budget in LiteLLM
+     * POST /team/update
+     */
+    static updateTeamBudget(params: UpdateTeamBudgetRequest): Promise<UpdateTeamBudgetResponse>;
+    /**
+     * Update a key's budget in LiteLLM
+     * POST /key/update
+     */
+    static updateKeyBudget(params: UpdateKeyBudgetRequest): Promise<UpdateKeyBudgetResponse>;
+    /**
+     * Generate a key for a team
+     * POST /key/generate
+     */
+    static generateKey(params: GenerateKeyRequest): Promise<GenerateKeyResponse>;
+    /**
+     * Block a key to quickly disable it
+     * POST /key/block
+     */
+    static blockKey(params: BlockKeyRequest): Promise<BlockKeyResponse>;
+    /**
+     * Unblock a key to re-enable it
+     * POST /key/unblock
+     */
+    static unblockKey(params: UnblockKeyRequest): Promise<UnblockKeyResponse>;
+    /**
+     * Get information about a key including usage and spend
+     * GET /key/info
+     */
+    static getKeyInfo(params: GetKeyInfoRequest): Promise<GetKeyInfoResponse>;
+    /**
+     * Delete a key
+     * POST /key/delete
+     */
+    static deleteKey(params: DeleteKeyRequest): Promise<DeleteKeyResponse>;
+    /**
+     * Delete a team
+     * POST /team/delete
+     */
+    static deleteTeam(params: DeleteTeamRequest): Promise<DeleteTeamResponse>;
+}

package/dist/services/litellm/litellm.service.js

@@ -0,0 +1,392 @@
+import { request } from "../../utils/api.js";
+import { HttpError } from "../../utils/errors.js";
+class LiteLLMService {
+  /**
+   * Create a new team in LiteLLM
+   * POST /team/new
+   */
+  static async createTeam(params) {
+    const serviceContext = {
+      method: {
+        name: "LiteLLMService.createTeam",
+        url: `${params.options.litellmApiBaseUrl}/team/new`,
+        normalizedUrl: "/team/new",
+        type: "post"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "litellm",
+        type: "external"
+      }
+    };
+    const body = {
+      team_alias: params.options.team_alias,
+      ...params.options.max_budget !== void 0 && {
+        max_budget: params.options.max_budget
+      },
+      ...params.options.budget_duration && {
+        budget_duration: params.options.budget_duration
+      }
+    };
+    const response = await request({
+      config: params.config,
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      type: "json",
+      headers: {
+        Authorization: `Bearer ${params.options.apiToken}`
+      },
+      body
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+  /**
+   * Update a team's budget in LiteLLM
+   * POST /team/update
+   */
+  static async updateTeamBudget(params) {
+    const serviceContext = {
+      method: {
+        name: "LiteLLMService.updateTeamBudget",
+        url: `${params.options.litellmApiBaseUrl}/team/update`,
+        normalizedUrl: "/team/update",
+        type: "post"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "litellm",
+        type: "external"
+      }
+    };
+    const body = {
+      team_id: params.options.team_id,
+      max_budget: params.options.max_budget
+    };
+    const response = await request({
+      config: params.config,
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      type: "json",
+      headers: {
+        Authorization: `Bearer ${params.options.apiToken}`
+      },
+      body
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+  /**
+   * Update a key's budget in LiteLLM
+   * POST /key/update
+   */
+  static async updateKeyBudget(params) {
+    const serviceContext = {
+      method: {
+        name: "LiteLLMService.updateKeyBudget",
+        url: `${params.options.litellmApiBaseUrl}/key/update`,
+        normalizedUrl: "/key/update",
+        type: "post"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "litellm",
+        type: "external"
+      }
+    };
+    const body = {
+      key: params.options.key,
+      max_budget: params.options.max_budget
+    };
+    const response = await request({
+      config: params.config,
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      type: "json",
+      headers: {
+        Authorization: `Bearer ${params.options.apiToken}`
+      },
+      body
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+  /**
+   * Generate a key for a team
+   * POST /key/generate
+   */
+  static async generateKey(params) {
+    const serviceContext = {
+      method: {
+        name: "LiteLLMService.generateKey",
+        url: `${params.options.litellmApiBaseUrl}/key/generate`,
+        normalizedUrl: "/key/generate",
+        type: "post"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "litellm",
+        type: "external"
+      }
+    };
+    const body = {
+      team_id: params.options.team_id,
+      key_type: "llm_api",
+      allowed_routes: ["/chat/completions"],
+      ...params.options.models && { models: params.options.models },
+      ...params.options.key_alias && { key_alias: params.options.key_alias },
+      ...params.options.duration && { duration: params.options.duration },
+      ...params.options.metadata && { metadata: params.options.metadata },
+      ...params.options.max_budget !== void 0 && {
+        max_budget: params.options.max_budget
+      },
+      ...params.options.budget_duration && {
+        budget_duration: params.options.budget_duration
+      }
+    };
+    const response = await request({
+      config: params.config,
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      type: "json",
+      headers: {
+        Authorization: `Bearer ${params.options.apiToken}`
+      },
+      body
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+  /**
+   * Block a key to quickly disable it
+   * POST /key/block
+   */
+  static async blockKey(params) {
+    const serviceContext = {
+      method: {
+        name: "LiteLLMService.blockKey",
+        url: `${params.options.litellmApiBaseUrl}/key/block`,
+        normalizedUrl: "/key/block",
+        type: "post"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "litellm",
+        type: "external"
+      }
+    };
+    const body = {
+      key: params.options.key
+    };
+    const response = await request({
+      config: params.config,
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      type: "json",
+      headers: {
+        Authorization: `Bearer ${params.options.apiToken}`
+      },
+      body
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+  /**
+   * Unblock a key to re-enable it
+   * POST /key/unblock
+   */
+  static async unblockKey(params) {
+    const serviceContext = {
+      method: {
+        name: "LiteLLMService.unblockKey",
+        url: `${params.options.litellmApiBaseUrl}/key/unblock`,
+        normalizedUrl: "/key/unblock",
+        type: "post"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "litellm",
+        type: "external"
+      }
+    };
+    const body = {
+      key: params.options.key
+    };
+    const response = await request({
+      config: params.config,
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      type: "json",
+      headers: {
+        Authorization: `Bearer ${params.options.apiToken}`
+      },
+      body
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+  /**
+   * Get information about a key including usage and spend
+   * GET /key/info
+   */
+  static async getKeyInfo(params) {
+    const serviceContext = {
+      method: {
+        name: "LiteLLMService.getKeyInfo",
+        url: `${params.options.litellmApiBaseUrl}/key/info?key=${encodeURIComponent(params.options.key)}`,
+        normalizedUrl: "/key/info",
+        type: "get"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "litellm",
+        type: "external"
+      }
+    };
+    const response = await request({
+      config: params.config,
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      headers: {
+        Authorization: `Bearer ${params.options.apiToken}`
+      }
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+  /**
+   * Delete a key
+   * POST /key/delete
+   */
+  static async deleteKey(params) {
+    const serviceContext = {
+      method: {
+        name: "LiteLLMService.deleteKey",
+        url: `${params.options.litellmApiBaseUrl}/key/delete`,
+        normalizedUrl: "/key/delete",
+        type: "post"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "litellm",
+        type: "external"
+      }
+    };
+    const body = {
+      keys: [params.options.key]
+    };
+    const response = await request({
+      config: params.config,
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      type: "json",
+      headers: {
+        Authorization: `Bearer ${params.options.apiToken}`
+      },
+      body
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+  /**
+   * Delete a team
+   * POST /team/delete
+   */
+  static async deleteTeam(params) {
+    const serviceContext = {
+      method: {
+        name: "LiteLLMService.deleteTeam",
+        url: `${params.options.litellmApiBaseUrl}/team/delete`,
+        normalizedUrl: "/team/delete",
+        type: "post"
+      },
+      source: params.config.metrics?.source || "unset",
+      target: {
+        name: "litellm",
+        type: "external"
+      }
+    };
+    const body = {
+      team_ids: [params.options.team_id]
+    };
+    const response = await request({
+      config: params.config,
+      url: serviceContext.method.url,
+      method: serviceContext.method.type,
+      metricsDetails: serviceContext,
+      type: "json",
+      headers: {
+        Authorization: `Bearer ${params.options.apiToken}`
+      },
+      body
+    });
+    if (!response.ok) {
+      throw new HttpError(
+        `${serviceContext.method.name}: ${response.status} ${response.statusText}`,
+        response.status,
+        response.statusText
+      );
+    }
+    return response.body;
+  }
+}
+export {
+  LiteLLMService
+};
+//# sourceMappingURL=litellm.service.js.map