berget 1.1.0 → 1.2.0

package/src/services/chat-service.ts

@@ -49,21 +49,133 @@ export class ChatService {
    */
   public async createCompletion(options: ChatCompletionOptions): Promise<any> {
     try {
+      console.log(chalk.yellow('DEBUG: Starting createCompletion method'))
+      
+      // Check if options is defined
+      if (!options) {
+        console.log(chalk.red('ERROR: options is undefined'))
+        throw new Error('Chat completion options are undefined')
+      }
+      
+      // Log the raw options object
+      console.log(chalk.yellow('DEBUG: Raw options:'), typeof options, options ? 'defined' : 'undefined')
+      
       const headers: Record<string, string> = {}
       
       // Check if debug is enabled
       const isDebug = process.argv.includes('--debug')
       
+      if (isDebug) {
+        console.log(chalk.yellow('DEBUG: Starting createCompletion with options:'))
+        try {
+          console.log(chalk.yellow(JSON.stringify({
+            ...options,
+            apiKey: options.apiKey ? '***' : undefined,
+            messages: options.messages ? `${options.messages.length} messages` : undefined
+          }, null, 2)))
+        } catch (error) {
+          console.log(chalk.red('ERROR: Failed to stringify options:'), error)
+        }
+      }
+      
+      // Create a copy of options to avoid modifying the original
+      const optionsCopy = { ...options }
+      
+      if (isDebug) {
+        console.log(chalk.yellow('DEBUG: Checking for API key'))
+        console.log(chalk.yellow(`DEBUG: optionsCopy.apiKey exists: ${!!optionsCopy.apiKey}`))
+      }
+      
+      // Check for environment variables first - prioritize this over everything else
+      const envApiKey = process.env.BERGET_API_KEY;
+      if (envApiKey) {
+        if (isDebug) {
+          console.log(chalk.yellow('DEBUG: Using API key from BERGET_API_KEY environment variable'));
+        }
+        optionsCopy.apiKey = envApiKey;
+      } 
+      // Only try to get the default API key if no API key is provided and no env var is set
+      else if (!optionsCopy.apiKey) {
+        if (isDebug) {
+          console.log(chalk.yellow('DEBUG: No API key provided, trying to get default'))
+        }
+        
+        try {
+          // Import the DefaultApiKeyManager directly
+          if (isDebug) {
+            console.log(chalk.yellow('DEBUG: Importing DefaultApiKeyManager'))
+          }
+          
+          const DefaultApiKeyManager = (await import('../utils/default-api-key')).DefaultApiKeyManager;
+          const defaultApiKeyManager = DefaultApiKeyManager.getInstance();
+          
+          if (isDebug) {
+            console.log(chalk.yellow('DEBUG: Got DefaultApiKeyManager instance'))
+          }
+          
+          // Try to get the default API key
+          if (isDebug) {
+            console.log(chalk.yellow('DEBUG: Calling promptForDefaultApiKey'))
+          }
+          
+          const defaultApiKeyData = defaultApiKeyManager.getDefaultApiKeyData();
+          const apiKey = defaultApiKeyData?.key || await defaultApiKeyManager.promptForDefaultApiKey();
+          
+          if (isDebug) {
+            console.log(chalk.yellow(`DEBUG: Default API key data exists: ${!!defaultApiKeyData}`))
+            console.log(chalk.yellow(`DEBUG: promptForDefaultApiKey returned: ${apiKey ? 'a key' : 'null'}`))
+          }
+          
+          if (apiKey) {
+            if (isDebug) {
+              console.log(chalk.yellow('DEBUG: Using API key from default API key manager'));
+            }
+            optionsCopy.apiKey = apiKey;
+          } else {
+            console.log(chalk.yellow('No API key available. You need to either:'));
+            console.log(chalk.yellow('1. Create an API key with: berget api-keys create --name "My Key"'));
+            console.log(chalk.yellow('2. Set a default API key with: berget api-keys set-default <id>'));
+            console.log(chalk.yellow('3. Provide an API key with the --api-key option'));
+            console.log(chalk.yellow('4. Set the BERGET_API_KEY environment variable'));
+            console.log(chalk.yellow('\nExample:'));
+            console.log(chalk.yellow('  export BERGET_API_KEY=your_api_key_here'));
+            console.log(chalk.yellow('  # or for a single command:'));
+            console.log(chalk.yellow('  BERGET_API_KEY=your_api_key_here berget chat run google/gemma-3-27b-it'));
+            throw new Error('No API key provided and no default API key set');
+          }
+          
+          // Set the API key in the options
+          if (isDebug) {
+            console.log(chalk.yellow('DEBUG: Setting API key in options'))
+          }
+          
+          // Only set the API key if it's not null
+          if (apiKey) {
+            optionsCopy.apiKey = apiKey;
+          }
+        } catch (error) {
+          console.log(chalk.red('Error getting API key:'))
+          if (error instanceof Error) {
+            console.log(chalk.red(error.message))
+          }
+          console.log(chalk.yellow('Please create an API key with: berget api-keys create --name "My Key"'))
+          throw new Error('Failed to get API key')
+        }
+      }
+      
       if (isDebug) {
         console.log(chalk.yellow('DEBUG: Chat completion options:'))
-        console.log(chalk.yellow(JSON.stringify(options, null, 2)))
+        console.log(chalk.yellow(JSON.stringify({
+          ...optionsCopy,
+          apiKey: optionsCopy.apiKey ? '***' : undefined // Hide the actual API key in debug output
+        }, null, 2)))
       }
       
       // If an API key is provided, use it for this request
-      if (options.apiKey) {
-        headers['Authorization'] = `Bearer ${options.apiKey}`
+      if (optionsCopy.apiKey) {
+        headers['Authorization'] = `Bearer ${optionsCopy.apiKey}`
         // Remove apiKey from options before sending to API
-        const { apiKey, ...requestOptions } = options
+        const { apiKey, ...requestOptions } = optionsCopy
         
         if (isDebug) {
           console.log(chalk.yellow('DEBUG: Using provided API key'))
@@ -71,43 +183,45 @@ export class ChatService {
           console.log(chalk.yellow(JSON.stringify(requestOptions, null, 2)))
         }
         
-        const { data, error } = await this.client.POST('/v1/chat/completions', {
-          body: requestOptions,
-          headers
-        })
-        
-        if (isDebug) {
-          console.log(chalk.yellow('DEBUG: API response:'))
-          console.log(chalk.yellow(JSON.stringify({ data, error }, null, 2)))
+        try {
+          const response = await this.client.POST('/v1/chat/completions', {
+            body: requestOptions,
+            headers
+          })
           
-          // Output the complete response data for debugging
-          console.log(chalk.yellow('DEBUG: Complete response data:'))
-          console.log(chalk.yellow(JSON.stringify(data, null, 2)))
-        }
-        
-        if (error) throw new Error(JSON.stringify(error))
-        return data
-      } else {
-        // Use the default authenticated client
-        if (isDebug) {
-          console.log(chalk.yellow('DEBUG: Using default authentication'))
-        }
-        
-        const { data, error } = await this.client.POST('/v1/chat/completions', {
-          body: options
-        })
-        
-        if (isDebug) {
-          console.log(chalk.yellow('DEBUG: API response:'))
-          console.log(chalk.yellow(JSON.stringify({ data, error }, null, 2)))
+          // Check if response has an error property
+          const responseAny = response as any;
+          if (responseAny && responseAny.error) 
+            throw new Error(JSON.stringify(responseAny.error))
+          
+          if (isDebug) {
+            console.log(chalk.yellow('DEBUG: API response:'))
+            console.log(chalk.yellow(JSON.stringify(response, null, 2)))
+            
+            // Output the complete response data for debugging
+            console.log(chalk.yellow('DEBUG: Complete response data:'))
+            console.log(chalk.yellow(JSON.stringify(response.data, null, 2)))
+          }
           
-          // Output the complete response data for debugging
-          console.log(chalk.yellow('DEBUG: Complete response data:'))
-          console.log(chalk.yellow(JSON.stringify(data, null, 2)))
+          return response.data
+        } catch (requestError) {
+          if (process.argv.includes('--debug')) {
+            console.log(chalk.red(`DEBUG: Request error: ${requestError instanceof Error ? requestError.message : String(requestError)}`))
+          }
+          throw requestError
         }
-        
-        if (error) throw new Error(JSON.stringify(error))
-        return data
+      } else {
+        // We've exhausted all options for getting an API key
+        console.log(chalk.yellow('No API key available. You need to either:'));
+        console.log(chalk.yellow('1. Create an API key with: berget api-keys create --name "My Key"'));
+        console.log(chalk.yellow('2. Set a default API key with: berget api-keys set-default <id>'));
+        console.log(chalk.yellow('3. Provide an API key with the --api-key option'));
+        console.log(chalk.yellow('4. Set the BERGET_API_KEY environment variable'));
+        console.log(chalk.yellow('\nExample:'));
+        console.log(chalk.yellow('  export BERGET_API_KEY=your_api_key_here'));
+        console.log(chalk.yellow('  # or for a single command:'));
+        console.log(chalk.yellow('  BERGET_API_KEY=your_api_key_here berget chat run google/gemma-3-27b-it'));
+        throw new Error('No API key available. Please provide an API key or set a default API key.');
       }
     } catch (error) {
       // Improved error handling
@@ -137,9 +251,13 @@ export class ChatService {
    */
   public async listModels(apiKey?: string): Promise<any> {
     try {
-      if (apiKey) {
+      // Check for environment variable first, then fallback to provided API key
+      const envApiKey = process.env.BERGET_API_KEY;
+      const effectiveApiKey = envApiKey || apiKey;
+      
+      if (effectiveApiKey) {
         const headers = {
-          'Authorization': `Bearer ${apiKey}`
+          'Authorization': `Bearer ${effectiveApiKey}`
         }
         
         const { data, error } = await this.client.GET('/v1/models', { headers })

package/src/types/api.d.ts

@@ -14,6 +14,20 @@ export interface paths {
     /**
      * List all API keys
      * @description Lists all API keys for the authenticated user's organization.
+     *
+     * ## Using the CLI
+     *
+     * You can also manage API keys using our CLI tool:
+     * ```
+     * # Login first (if you haven't already)
+     * npx berget auth login
+     *
+     * # List all API keys
+     * npx berget api-keys list
+     *
+     * # Create a new API key
+     * npx berget api-keys create --name my-api-key
+     * ```
      */
     get: {
       responses: {
@@ -36,6 +50,17 @@ export interface paths {
     /**
      * Create a new API key
      * @description Creates a new API key for the authenticated user's organization. The full API key is only returned once at creation time.
+     *
+     * ## Using the CLI
+     *
+     * Creating an API key is easier with our CLI tool:
+     * ```
+     * # Login first (if you haven't already)
+     * npx berget auth login
+     *
+     * # Create a new API key
+     * npx berget api-keys create --name my-api-key
+     * ```
      */
     post: {
       requestBody: {
@@ -97,6 +122,21 @@ export interface paths {
     /**
      * Rotate an API key
      * @description Rotates an API key by invalidating the old key and generating a new one. The new key is returned in the response and is only shown once.
+     *
+     * ## Using the CLI
+     *
+     * You can also rotate API keys using our CLI tool:
+     * ```
+     * # Login first (if you haven't already)
+     * npx berget auth login
+     *
+     * # Rotate an API key
+     * npx berget api-keys rotate --id <key-id>
+     * ```
+     *
+     * ## Security Note
+     *
+     * When you rotate an API key, the old key becomes invalid immediately. Make sure to update any applications using the key.
      */
     put: {
       parameters: {
@@ -131,6 +171,20 @@ export interface paths {
     /**
      * Get API key usage statistics
      * @description Returns usage statistics for a specific API key including request count, daily breakdown, model-specific usage, and token consumption.
+     *
+     * ## Using the CLI
+     *
+     * You can also view API key usage using our CLI tool:
+     * ```
+     * # Login first (if you haven't already)
+     * npx berget auth login
+     *
+     * # View usage for a specific API key
+     * npx berget api-keys usage --id <key-id>
+     *
+     * # View usage for all API keys
+     * npx berget usage
+     * ```
      */
     get: {
       parameters: {
@@ -351,13 +405,27 @@ export interface paths {
   "/v1/auth/login": {
     /**
      * OAuth login
-     * @description Initiates OAuth login flow via Keycloak
+     * @description Initiates OAuth login flow via Keycloak.
+     *
+     * ## CLI Authentication
+     *
+     * For a simpler experience, you can use our CLI tool to authenticate:
+     * ```
+     * npx berget auth login
+     * ```
+     *
+     * After logging in, you can create an API key with:
+     * ```
+     * npx berget api-keys create --name my-api-key
+     * ```
      */
     get: {
       parameters: {
         query?: {
           /** @description URL to redirect to after successful login */
           redirect_uri?: string;
+          /** @description How to return the token after successful login (default is redirect) */
+          response_type?: "redirect" | "json";
         };
       };
       responses: {
@@ -389,29 +457,108 @@ export interface paths {
     };
   };
   "/v1/auth/device": {
-    /** Initiate device authorization flow */
+    /**
+     * Initiate device authorization flow
+     * @description Initiates the device authorization flow, returning a device code and user verification URL.
+     *
+     * ## Using the CLI
+     *
+     * The recommended way to authenticate is through our CLI tool:
+     * ```
+     * npx berget auth login
+     * ```
+     *
+     * This handles the device flow automatically and provides a better user experience.
+     */
     post: {
       responses: {
         /** @description Device authorization initiated */
         200: {
-          content: never;
+          content: {
+            "application/json": components["schemas"]["DeviceAuthInitResponse"];
+          };
         };
       };
     };
   };
   "/v1/auth/device/token": {
-    /** Poll for device token */
+    /**
+     * Poll for device token
+     * @description Polls for the status of a device authorization flow. The client should poll this endpoint
+     * until it receives a token or an error.
+     *
+     * ## Using the CLI
+     *
+     * The recommended way to authenticate is through our CLI tool:
+     * ```
+     * npx berget auth login
+     * ```
+     *
+     * This handles the polling automatically and provides a better user experience.
+     *
+     * ## Troubleshooting
+     *
+     * - If you receive a 400 error, the device code may be invalid or expired
+     * - If you receive a 429 error, you're polling too frequently
+     * - If you receive a 500 error, there may be an issue with the authentication service
+     */
     post: {
       requestBody: {
         content: {
-          "application/json": {
-            device_code?: string;
-          };
+          "application/json": components["schemas"]["DeviceAuthRequest"];
         };
       };
       responses: {
         /** @description Token returned or pending status */
         200: {
+          content: {
+            "application/json": components["schemas"]["DeviceAuthPendingResponse"] | components["schemas"]["DeviceAuthTokenResponse"];
+          };
+        };
+        /** @description Invalid device code or expired token */
+        400: {
+          content: never;
+        };
+        /** @description Polling too frequently */
+        429: {
+          content: never;
+        };
+        /** @description Server error during authentication */
+        500: {
+          content: never;
+        };
+      };
+    };
+  };
+  "/v1/auth/refresh": {
+    /**
+     * Refresh access token
+     * @description Refreshes an access token using a refresh token. This endpoint can be used to obtain a new
+     * access token when the current one expires.
+     *
+     * ## Using the CLI
+     *
+     * The CLI tool handles token refresh automatically:
+     * ```
+     * # The CLI will refresh tokens as needed
+     * npx berget api-keys list
+     * ```
+     */
+    post: {
+      requestBody: {
+        content: {
+          "application/json": components["schemas"]["RefreshTokenRequest"];
+        };
+      };
+      responses: {
+        /** @description New access and refresh tokens */
+        200: {
+          content: {
+            "application/json": components["schemas"]["RefreshTokenResponse"];
+          };
+        };
+        /** @description Invalid or expired refresh token */
+        401: {
           content: never;
         };
       };
@@ -1418,8 +1565,6 @@ export interface components {
     };
     AuthToken: {
       accessToken: string;
-      /** @enum {string} */
-      tokenType: "Bearer";
       expiresIn: number;
       user?: {
         id: string;
@@ -1437,6 +1582,55 @@ export interface components {
       /** Format: uri */
       avatarUrl: string;
     };
+    RefreshTokenRequest: {
+      /** @description The refresh token to use */
+      refresh_token: string;
+      /** @description Whether this is a device token */
+      is_device_token?: boolean;
+    };
+    RefreshTokenResponse: {
+      /** @description The new access token */
+      token: string;
+      /** @description The new refresh token */
+      refresh_token: string;
+      /** @description Seconds until the access token expires */
+      expires_in: number;
+      /** @description Seconds until the refresh token expires */
+      refresh_expires_in: number;
+    };
+    DeviceAuthRequest: {
+      /** @description The device code obtained from the device authorization request */
+      device_code: string;
+    };
+    DeviceAuthInitResponse: {
+      /** @description Code used by the device to poll for authentication status */
+      device_code: string;
+      /** @description Code displayed to the user for authentication */
+      user_code: string;
+      /** @description URL where the user should enter the user_code */
+      verification_url: string;
+      /** @description Expiration time in seconds */
+      expires_in: number;
+      /** @description Polling interval in seconds */
+      interval: number;
+    };
+    DeviceAuthPendingResponse: {
+      /**
+       * @description Authentication is still pending
+       * @enum {string}
+       */
+      status: "pending";
+    };
+    DeviceAuthTokenResponse: {
+      /** @description Access token */
+      token: string;
+      /** @description Refresh token */
+      refresh_token: string;
+      /** @description Access token expiration time in seconds */
+      expires_in: number;
+      /** @description Refresh token expiration time in seconds */
+      refresh_expires_in: number;
+    };
     Usage: {
       current_period: {
         /** Format: date-time */

package/src/types/json.d.ts

@@ -0,0 +1,4 @@
+declare module "*.json" {
+  const value: any;
+  export = value;
+}